static BBitmap*
MakeActuatorBitmap(bool lit)
{
BBitmap* map = new BBitmap(ICON_BITMAP_RECT, ICON_BITMAP_SPACE, true);
const rgb_color yellow = {255, 255, 0};
const rgb_color red = {200, 200, 200};
const rgb_color black = {0, 0, 0};
const BPoint points[10] = {
BPoint(8, 0), BPoint(9.8, 5.8), BPoint(16, 5.8),
BPoint(11, 9.0), BPoint(13, 16), BPoint(8, 11),
BPoint(3, 16), BPoint(5, 9.0), BPoint(0, 5.8),
BPoint(6.2, 5.8) };
BView* view = new BView(BRect(0, 0, 16, 16), NULL, B_FOLLOW_ALL_SIDES, 0L);
map->AddChild(view);
map->Lock();
view->SetHighColor(B_TRANSPARENT_32_BIT);
view->FillRect(ICON_BITMAP_RECT);
view->SetHighColor(lit ? yellow : red);
view->FillPolygon(points, 10);
view->SetHighColor(black);
view->StrokePolygon(points, 10);
map->Unlock();
map->RemoveChild(view);
delete view;
return map;
}
void APPosSlider::DrawThumb(void)
{
BRect rect;
BView *view;
// Get the frame rectangle of the thumb
// and the offscreen view
rect = ThumbFrame();
view = OffscreenView();
// Draw the black shadow
view->SetDrawingMode(B_OP_ALPHA);
rgb_color c = BeDarkShadow;
c.alpha = 128;
view->SetHighColor(c);
rect.top++;
rect.left++;
view->FillEllipse(rect);
// Fill the inside of the thumb
view->SetDrawingMode(B_OP_COPY);
view->SetHighColor(BeButtonGrey);
rect.OffsetBy(-1, -1);
view->FillEllipse(rect);
// Draw the dark grey edge
view->SetHighColor(86, 86, 86, 255); // TODO : use an Haiku define to get that ?
view->SetPenSize(1.2);
view->StrokeEllipse(rect);
}
BBitmap* SwatchView::make_bitmap(void)
{
BRect rect(0.0, 0.0, 12.0, 12.0);
BBitmap *bitmap = new BBitmap(rect, B_RGB32, true);
BView *view = new BView(rect, "", B_FOLLOW_NONE, B_WILL_DRAW);
bitmap->Lock();
bitmap->AddChild(view);
view->SetDrawingMode(B_OP_ALPHA);
view->SetHighColor(m_color);
view->FillRect(rect);
view->SetDrawingMode(B_OP_COPY);
view->SetHighColor(0, 0, 0, 255);
view->StrokeRect(rect);
view->Sync();
bitmap->RemoveChild(view);
delete view;
bitmap->Unlock();
return bitmap;
}
/***********************************************************
* Make down state picture.
***********************************************************/
BPicture*
HToolbarButton::MakeDownPicture(BBitmap *in)
{
HToolbar *toolbar = cast_as(Parent(),HToolbar);
BRect buttonRect = toolbar->ButtonRect();
BView *view = new BView(BRect(0,0,buttonRect.Width(),buttonRect.Height())
,"offview",0,0);
BBitmap *bitmap = new BBitmap(view->Bounds(), in->ColorSpace(), true);
BPicture *pict;
bitmap->AddChild(view);
bitmap->Lock();
view->SetHighColor(BeLightShadow);
view->FillRect(view->Bounds());
view->BeginPicture(new BPicture);
DrawString(view,fName.String(),true);
view->SetDrawingMode(B_OP_MIN);
DrawBitmap(view,in,true);
const float height = view->Bounds().Height();
view->SetDrawingMode(B_OP_OVER);
view->SetHighColor(BeShadow);
view->FillRect(BRect(0,0,0,height));
view->FillRect(BRect(0,0,height,0));
view->SetHighColor(White);
view->FillRect(BRect(height-1,0,height-1,height-1));
view->FillRect(BRect(0,height-1,height-1,height-1));
pict = view->EndPicture();
bitmap->Unlock();
delete bitmap;
return pict;
}
BBitmap* MainView::CreateIcon(const rgb_color colorIn)
{
BRect rect(0, 0, 15, 15);
BBitmap* toReturn = new BBitmap(rect, B_CMAP8, true);
BView* drawing = new BView(rect,
"drawer",
B_FOLLOW_LEFT | B_FOLLOW_TOP,
B_WILL_DRAW);
if (!drawing || !toReturn) { return NULL; }
toReturn->AddChild(drawing);
if (toReturn->Lock()) {
drawing->SetHighColor(kWhite);
drawing->FillRect(rect);
drawing->SetHighColor(kBlack);
drawing->SetPenSize(1);
drawing->StrokeRect(rect);
drawing->SetHighColor(colorIn);
drawing->FillRect(rect.InsetBySelf(1, 1));
drawing->Sync();
toReturn->Unlock();
}
toReturn->RemoveChild(drawing);
delete drawing;
return toReturn;
}
void CounterView::Draw (BRect updateRect)
{
BRect MovingRect (
m_MovingDotPoint.x,
m_MovingDotPoint.y,
m_MovingDotPoint.x + m_MovingDotSize,
m_MovingDotPoint.y + m_MovingDotSize);
char TempString [40];
if (m_BackingBitmap != NULL)
{
m_BackingBitmap->Lock ();
m_BackingView.SetHighColor (60, 60, 255, 8);
m_BackingView.FillRect (m_BndRect);
m_BackingView.SetHighColor (255, 255, 0, 255);
m_BackingView.MovePenTo (m_TextStartPoint);
sprintf (TempString, "%d", m_CurrentCount);
m_BackingView.DrawString (TempString);
m_BackingView.FillRect (MovingRect);
m_BackingView.Sync ();
m_BackingBitmap->Unlock ();
MovePenTo (0, 0);
DrawBitmap (m_BackingBitmap);
}
}
/*!
* \brief Create the square icon filled with submitted color.
* \param[in] color The color of the requested icon.
* \param[in] toChange If there is an allocated item, it may be changed.
* If the submitted pointer is not NULL (which is default),
* this BBitmap is tested for dimensions match, and if dimensions
* allow, its contents are replaced with new icon. Else, old icon
* is deleted, and a new is created. In this case, both the
* "toChange" pointer and returned pointer point to the same
* BBitmap.
*/
BBitmap* CategoryMenuItem::CreateIcon(const rgb_color colorIn, BBitmap* toChange )
{
font_height fh;
BFont plainFont( be_plain_font );
plainFont.GetHeight( &fh );
int squareSize = ceilf( fh.ascent + fh.descent + fh.leading - 2 ); //!< Side of the square.
BRect rect(0, 0, squareSize, squareSize );
BBitmap* toReturn = NULL;
if ( !toChange ) // Checking availability of the input
{
toReturn = new BBitmap(rect, B_RGB32, true);
} else {
// It would be a good idea to check also the color space,
// but it may be changed by the BBitmap itself, so...
if ( ceilf ( ( toChange->Bounds() ).Width() ) != squareSize )
{
delete toChange;
toChange = new BBitmap(rect, B_RGB32, true);
if ( !toChange )
{
/* Panic! */
exit(1);
}
}
toReturn = toChange;
}
BView* drawing = new BView( rect,
"Drawer",
B_FOLLOW_LEFT | B_FOLLOW_TOP,
B_WILL_DRAW);
if (!drawing || !toReturn) { return NULL; }
toReturn->AddChild(drawing);
if (toReturn->Lock()) {
// Clean the area
drawing->SetHighColor( ui_color( B_DOCUMENT_BACKGROUND_COLOR ) );
drawing->FillRect(rect);
// Draw the black square
drawing->SetHighColor( ui_color( B_DOCUMENT_TEXT_COLOR ) );
drawing->SetPenSize(1);
drawing->StrokeRect(rect);
// Fill the inside of the square
drawing->SetHighColor( colorIn );
drawing->FillRect(rect.InsetBySelf(1, 1));
// Flush the actions to BBitmap
drawing->Sync();
toReturn->Unlock();
}
toReturn->RemoveChild(drawing); // Cleanup
delete drawing;
return toReturn;
} // <-- end of function CategoryMenuItem::CreateIcon
void
IconView::MouseMoved(BPoint where, uint32 transit, const BMessage* dragMessage)
{
if (fTracking && !fDragging && fIcon != NULL
&& (abs((int32)(where.x - fDragPoint.x)) > 3
|| abs((int32)(where.y - fDragPoint.y)) > 3)) {
// Start drag
BMessage message(B_SIMPLE_DATA);
::Icon* icon = fIconData;
if (fHasRef || fHasType) {
icon = new ::Icon;
if (fHasRef)
icon->SetTo(fRef, fType.Type());
else if (fHasType)
icon->SetTo(fType);
}
icon->CopyTo(message);
if (icon != fIconData)
delete icon;
BBitmap *dragBitmap = new BBitmap(fIcon->Bounds(), B_RGBA32, true);
dragBitmap->Lock();
BView *view
= new BView(dragBitmap->Bounds(), B_EMPTY_STRING, B_FOLLOW_NONE, 0);
dragBitmap->AddChild(view);
view->SetHighColor(B_TRANSPARENT_COLOR);
view->FillRect(dragBitmap->Bounds());
view->SetBlendingMode(B_CONSTANT_ALPHA, B_ALPHA_COMPOSITE);
view->SetDrawingMode(B_OP_ALPHA);
view->SetHighColor(0, 0, 0, 160);
view->DrawBitmap(fIcon);
view->Sync();
dragBitmap->Unlock();
DragMessage(&message, dragBitmap, B_OP_ALPHA,
fDragPoint - BitmapRect().LeftTop(), this);
fDragging = true;
SetMouseEventMask(B_POINTER_EVENTS, B_NO_POINTER_HISTORY);
}
if (dragMessage != NULL && !fDragging && AcceptsDrag(dragMessage)) {
bool dropTarget = transit == B_ENTERED_VIEW || transit == B_INSIDE_VIEW;
if (dropTarget != fDropTarget) {
fDropTarget = dropTarget;
Invalidate();
}
} else if (fDropTarget) {
fDropTarget = false;
Invalidate();
}
}
void
IconSpewer::DrawSomeOld()
{
#if 0
if (!oldIconCacheInited)
BIconCache::InitIconCaches();
target->Lock();
target->SetTitle("old cache");
BView* view = target->FindView("iconView");
ASSERT(view);
BRect bounds(target->Bounds());
view->SetHighColor(Color(255, 255, 255));
view->FillRect(bounds);
view->SetHighColor(Color(0, 0, 0));
char buffer[256];
if (cycleTime) {
sprintf(buffer, "last cycle time %Ld ms", cycleTime/1000);
view->DrawString(buffer, BPoint(20, bounds.bottom - 20));
}
if (numDrawn) {
sprintf(buffer, "average draw time %Ld us per icon",
watch.ElapsedTime() / numDrawn);
view->DrawString(buffer, BPoint(20, bounds.bottom - 30));
}
sprintf(buffer, "directory: %s", currentPath.Path());
view->DrawString(buffer, BPoint(20, bounds.bottom - 40));
target->Unlock();
for (int32 row = 0; row < kRowCount; row++) {
for (int32 column = 0; column < kColumnCount; column++) {
BEntry entry(NextRef());
BModel model(&entry, true);
if (!target->Lock())
return;
if (model.IsDirectory())
entry.GetPath(¤tPath);
BIconCache::LockIconCache();
BIconCache* iconCache
= BIconCache::GetIconCache(&model, kIconSize);
iconCache->Draw(view, BPoint(column * (kIconSize + 2),
row * (kIconSize + 2)), B_NORMAL_ICON, kIconSize, true);
BIconCache::UnlockIconCache();
target->Unlock();
numDrawn++;
}
}
#endif
}
BBitmap *DragonView::_MakeDragBitmap( void )
{
// If the currently displayed bitmap is too large to drag around,
// we'll just drag around a rectangle.
BRect drag_rect = _bits->Bounds();
if( drag_rect.Width() > _drag_max_size.x ||
drag_rect.Height() > _drag_max_size.y ) return NULL;
// If we've got a PNG image, we'll assume that it's got
// "interesting" alpha information. The ones that are built
// into DragonDrop's resources all have "interesting" alpha
// channels.
if( _image_is_png ) {
BBitmap *drag_me = new BBitmap( _bits );
memcpy( drag_me->Bits(), _bits->Bits(), _bits->BitsLength() );
return drag_me;
}
// If you've made it here, we'll need to build a semi-transparent image
// to drag around. This magic is from Pavel Cisler, and it ensures that
// you've got a drag bitmap that's translucent.
BRect rect( _bits->Bounds() );
BBitmap *bitmap = new BBitmap( rect, B_RGBA32, true );
BView *view = new BView( rect, "drag view", B_FOLLOW_NONE, 0 );
bitmap->Lock();
bitmap->AddChild( view );
BRegion new_clip;
new_clip.Set( rect );
view->ConstrainClippingRegion( &new_clip );
view->SetHighColor( 0, 0, 0, 0 );
view->FillRect( rect );
view->SetDrawingMode( B_OP_ALPHA );
view->SetHighColor( 0, 0, 0, 128 );
view->SetBlendingMode( B_CONSTANT_ALPHA, B_ALPHA_COMPOSITE );
view->DrawBitmap( _bits );
view->Sync();
bitmap->Unlock();
return bitmap;
}
void
IconSpewer::DrawSomeNew()
{
target->Lock();
BView* view = target->FindView("iconView");
ASSERT(view);
BRect bounds(target->Bounds());
view->SetHighColor(Color(255, 255, 255));
view->FillRect(bounds);
view->SetHighColor(Color(0, 0, 0));
char buffer[256];
if (cycleTime) {
sprintf(buffer, "last cycle time %" B_PRId64 " ms", cycleTime/1000);
view->DrawString(buffer, BPoint(20, bounds.bottom - 20));
}
if (numDrawn) {
sprintf(buffer, "average draw time %" B_PRId64 " us per icon",
watch.ElapsedTime() / numDrawn);
view->DrawString(buffer, BPoint(20, bounds.bottom - 30));
}
sprintf(buffer, "directory: %s", currentPath.Path());
view->DrawString(buffer, BPoint(20, bounds.bottom - 40));
target->Unlock();
for (int32 row = 0; row < kRowCount; row++) {
for (int32 column = 0; column < kColumnCount; column++) {
BEntry entry(NextRef());
Model model(&entry, true);
if (!target->Lock())
return;
if (model.IsDirectory())
entry.GetPath(¤tPath);
IconCache::sIconCache->Draw(&model, view,
BPoint(column * (kIconSize + 2), row * (kIconSize + 2)),
kNormalIcon, kIconSize, true);
target->Unlock();
numDrawn++;
}
}
}
/***********************************************************
* Make disable state picture.
***********************************************************/
BPicture*
HToolbarButton::MakeDisablePicture(BBitmap *in)
{
HToolbar *toolbar = cast_as(Parent(),HToolbar);
BRect buttonRect = toolbar->ButtonRect();
BView *view = new BView(BRect(0,0,buttonRect.Width(),buttonRect.Height())
,"offview",0,0);
BBitmap *bitmap = new BBitmap(view->Bounds(), in->ColorSpace(), true);
BPicture *pict;
bitmap->AddChild(view);
bitmap->Lock();
view->BeginPicture(new BPicture);
view->SetHighColor(bgcolor);
view->FillRect(view->Bounds());
DrawString(view,fName.String(),false,false);
view->SetDrawingMode(B_OP_BLEND);
DrawBitmap(view,in);
pict = view->EndPicture();
bitmap->Unlock();
delete bitmap;
return pict;
}
HSPictureButton::HSPictureButton(BRect frame, BBitmap* off, BBitmap* on,
BMessage* message, const char* helpMessage, const char* longHelpMessage,
uint32 behavior, uint32 mode, uint32 flags)
: BPictureButton(frame, "?", NULL, NULL, message, behavior, mode, flags)
, fLongHelpMessage(longHelpMessage)
{
if (helpMessage)
SetToolTip(helpMessage);
BRect rect(0, 0, 0, 0);
BBitmap* offScreen = new BBitmap(rect, B_RGB_32_BIT, true);
BView* offView = new BView(rect, "", B_FOLLOW_ALL, 0);
offScreen->AddChild(offView);
offScreen->Lock();
offView->SetHighColor(255, 0, 0);
offView->SetLowColor(0, 0, 120);
offView->SetDrawingMode(B_OP_COPY);
offView->BeginPicture(new BPicture());
offView->DrawBitmap(on, BPoint(0, 0));
SetEnabledOn(offView->EndPicture());
offView->BeginPicture(new BPicture());
offView->DrawBitmap(off, BPoint(0, 0));
SetEnabledOff(offView->EndPicture());
offScreen->Unlock();
delete offScreen;
}
TestWindow::TestWindow(BApplication* myApp)
: BWindow(BRect(20,20,100,100),
"Code Profile", B_TITLED_WINDOW, 0)
{
BRect frm = Bounds();
BView* myview = new BView(BRect(),"testView",0,0);
BOutlineListView* olist =
new BOutlineListView(BRect(),"MyList",
B_SINGLE_SELECTION_LIST,B_FOLLOW_NONE);
if( myview && olist ) {
myview->AddChild(olist);
BView* vw = olist;
vw->SetViewColor(0xc0,0xc0,0xc0);
vw->Invalidate();
vw->SetLowColor(0xc0,0xc0,0xc0);
vw->Invalidate();
vw->SetHighColor(0x00,0x00,0x00);
vw->Invalidate();
vw->SetFont(be_bold_font);
this->AddChild(myview);
BRect frm = vw->Frame();
vw->ResizeTo(1,1);
vw->Draw(vw->Bounds());
vw->ResizeToPreferred();
float w=0,h=0;
vw->GetPreferredSize(&w,&h);
printf("Preferred size = %f x %f\n",w,h);
}
string = new BStringView(BRect(0,0,100,20),"String",
"Ready to profile...");
if( string ) {
string->SetViewColor(0xc0,0xc0,0xc0);
this->AddChild(string);
float w=0, h=0;
string->GetPreferredSize(&w,&h);
MoveTo(30,30);
ResizeTo(w,h);
}
BMenuBar* menu = new BMenuBar(BRect(),"MainMenu",B_FOLLOW_NONE);
if( menu ) {
this->AddChild(menu);
float w=0, h=0;
menu->GetPreferredSize(&w,&h);
printf("Preferred Size = (%f,%f)\n",w,h);
menu->SetFont(be_plain_font);
menu->GetPreferredSize(&w,&h);
printf("Preferred Size = (%f,%f)\n",w,h);
menu->SetFont(be_bold_font);
menu->GetPreferredSize(&w,&h);
printf("Preferred Size = (%f,%f)\n",w,h);
menu->SetFont(be_fixed_font);
menu->GetPreferredSize(&w,&h);
printf("Preferred Size = (%f,%f)\n",w,h);
}
}
// SetIcon
status_t
IconButton::SetIcon(const unsigned char* bitsFromQuickRes,
uint32 width, uint32 height, color_space format, bool convertToBW)
{
status_t status = B_BAD_VALUE;
if (bitsFromQuickRes && width > 0 && height > 0) {
BBitmap* quickResBitmap = new(nothrow) BBitmap(BRect(0.0, 0.0, width - 1.0, height - 1.0), format);
status = quickResBitmap ? quickResBitmap->InitCheck() : B_ERROR;
if (status >= B_OK) {
// It doesn't look right to copy BitsLength() bytes, but bitmaps
// exported from QuickRes still contain their padding, so it is alright.
memcpy(quickResBitmap->Bits(), bitsFromQuickRes, quickResBitmap->BitsLength());
if (format != B_RGB32 && format != B_RGBA32 && format != B_RGB32_BIG && format != B_RGBA32_BIG) {
// colorspace needs conversion
BBitmap* bitmap = new(nothrow) BBitmap(quickResBitmap->Bounds(), B_RGB32, true);
if (bitmap && bitmap->IsValid()) {
BView* helper = new BView(bitmap->Bounds(), "helper",
B_FOLLOW_NONE, B_WILL_DRAW);
if (bitmap->Lock()) {
bitmap->AddChild(helper);
helper->SetHighColor(ui_color(B_PANEL_BACKGROUND_COLOR));
helper->FillRect(helper->Bounds());
helper->SetDrawingMode(B_OP_OVER);
helper->DrawBitmap(quickResBitmap, BPoint(0.0, 0.0));
helper->Sync();
bitmap->Unlock();
}
status = _MakeBitmaps(bitmap);
} else
printf("IconButton::SetIcon() - B_RGB32 bitmap is not valid\n");
delete bitmap;
} else {
// native colorspace (32 bits)
if (convertToBW) {
// convert to gray scale icon
uint8* bits = (uint8*)quickResBitmap->Bits();
uint32 bpr = quickResBitmap->BytesPerRow();
for (uint32 y = 0; y < height; y++) {
uint8* handle = bits;
uint8 gray;
for (uint32 x = 0; x < width; x++) {
gray = uint8((116 * handle[0] + 600 * handle[1] + 308 * handle[2]) / 1024);
handle[0] = gray;
handle[1] = gray;
handle[2] = gray;
handle += 4;
}
bits += bpr;
}
}
status = _MakeBitmaps(quickResBitmap);
}
} else
printf("IconButton::SetIcon() - error allocating bitmap: %s\n", strerror(status));
delete quickResBitmap;
}
return status;
}
BView *ViewFactory::Create<BView>(BRect rect, const char *name, uint32 resize, uint32 flags) {
BView *view = NULL;
#ifdef __HAIKU__
view = new BView(name, flags & B_SUPPORTS_LAYOUT);
#else
view = new BView(rect, name, resize, flags);
#endif
#if B_BEOS_VERSION > B_BEOS_VERSION_5
view->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
view->SetLowColor(ui_color(B_PANEL_BACKGROUND_COLOR));
view->SetHighColor(ui_color(B_PANEL_TEXT_COLOR));
#else
view->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
view->SetLowColor(ui_color(B_PANEL_BACKGROUND_COLOR));
view->SetHighColor(0, 0, 0, 0);
#endif
return view;
};
void wxStatusBarBeOS::DrawStatusBar()
{
int i=0;
int leftPos=0;
wxArrayInt widthsAbs;
wxString text;
m_view->Clear();
BRect bounds(m_view->bounds());
BView * drawview = m_view->GetBack();
if(drawview->LockLooper())
{
rgb_color clr;
drawview->PushState();
clr = drawview->ViewColor();
clr.red-=50; clr.green-=50; clr.blue-=50;
drawview->SetHighColor(clr);
drawview->StrokeLine(BPoint(bounds.left, bounds.top), BPoint(bounds.right, bounds.top));
clr.red+=100; clr.green+=100; clr.blue+=100;
drawview->SetHighColor(clr);
drawview->StrokeLine(BPoint(bounds.left, bounds.top+1), BPoint(bounds.right, bounds.top+1));
drawview->PopState();
if(m_nFields>0)
widthsAbs = CalculateAbsWidths(bounds.IntegerWidth() - 2*(m_nFields - 1));
drawview->SetDrawingMode(B_OP_OVER);
for(i=0;i<m_nFields;i++)
{
text = GetStatusBufferText(i);
drawview->DrawString(text, BPoint(leftPos, bounds.bottom-2));
leftPos+=widthsAbs[i]+2;
}
drawview->UnlockLooper();
}
m_view->flush();
}
/*
* Make inside state picture.
*/
BPicture*
HToolbarButton::MakeInsidePicture(BBitmap *in)
{
HToolbar *toolbar = cast_as(Parent(),HToolbar);
BRect buttonRect = toolbar->ButtonRect();
BView *view = new BView(BRect(0,0,buttonRect.Width(),buttonRect.Height())
,"offview",0,0);
BBitmap *bitmap = new BBitmap(view->Bounds(), in->ColorSpace(), true);
BPicture *pict;
bitmap->AddChild(view);
bitmap->Lock();
view->SetDrawingMode(B_OP_ALPHA);
view->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);
view->BeginPicture(new BPicture);
DrawBitmap(view,in);
DrawString(view,fName.String());
//view->SetHighColor(White);
//view->FillRect(BRect(0,0,0,22));
//view->FillRect(BRect(0,0,22,0));
//view->SetHighColor(BeShadow);
//view->FillRect(BRect(21,0,21,21));
//view->FillRect(BRect(0,21,21,21));
BRect rect(Bounds());
view->SetDrawingMode(B_OP_OVER);
rect.InsetBy(1,1);
view->BeginLineArray(5);
view->AddLine(rect.LeftTop(), rect.LeftBottom(),
tint_color(ui_color(B_PANEL_BACKGROUND_COLOR), B_LIGHTEN_MAX_TINT));
view->AddLine(rect.LeftTop(), rect.RightTop(),
tint_color(ui_color(B_PANEL_BACKGROUND_COLOR), B_LIGHTEN_MAX_TINT));
view->AddLine(rect.LeftBottom(), rect.RightBottom(),
tint_color(ui_color(B_PANEL_BACKGROUND_COLOR), B_DARKEN_3_TINT));
rect.bottom--;
view->AddLine(rect.LeftBottom(), rect.RightBottom(),
tint_color(ui_color(B_PANEL_BACKGROUND_COLOR), B_DARKEN_1_TINT));
view->AddLine(rect.RightTop(), rect.RightBottom(),
tint_color(ui_color(B_PANEL_BACKGROUND_COLOR), B_DARKEN_3_TINT));
view->EndLineArray();
view->SetHighColor(tint_color(ui_color(B_PANEL_BACKGROUND_COLOR), B_DARKEN_3_TINT));
view->StrokeRect(Bounds());
pict = view->EndPicture();
bitmap->Unlock();
delete bitmap;
return pict;
}
BBitmap *bitmap (char *title)
{
strcpy (title, "Grabbed");
BBitmap *b = new BBitmap (BRect (0, 0, 127, 127), B_RGB_32_BIT, true);
BView *v = new BView (BRect (0, 0, 127, 127), "bg", 0, 0);
b->Lock();
b->AddChild (v);
rgb_color fg, bg;
fg.red = 255; fg.green = 255; fg.blue = 255; fg.alpha = 255;
bg.red = 0; bg.green = 0; bg.blue = 0; bg.alpha = 127;
v->SetHighColor (fg);
v->SetLowColor (bg);
v->FillRect (BRect (0, 0, 127, 127), B_MIXED_COLORS);
v->Sync();
b->RemoveChild (v);
b->Unlock();
delete v;
return (b);
}
void ArpTextControl::copy_colors(BView* v)
{
// Make no assumptions about the structure of the children.
if( !v ) return;
int32 num = v->CountChildren();
for( int32 i=0; i<num; i++ ) {
BView* child = v->ChildAt(i);
if( child ) {
copy_colors(child);
BTextView* text = dynamic_cast<BTextView*>(child);
if( text ) {
text->SetFontAndColor(NULL, B_FONT_ALL, &PV_FillForeColor);
}
child->SetViewColor(PV_FillBackColor);
child->SetLowColor(PV_FillBackColor);
child->SetHighColor(PV_FillForeColor);
child->Invalidate();
}
}
}
void APPosSlider::DrawFocusMark(void)
{
BRect rect;
BView *view;
rgb_color color;
if (IsFocus())
{
// Get the frame rectangle of the thumb
// and the offscreen view
rect = ThumbFrame();
view = OffscreenView();
// Get the color to use
color = keyboard_navigation_color();
view->SetHighColor(color);
// Draw a circle inside the thumb
rect.InsetBy(2.0f, 2.0f);
view->StrokeEllipse(rect);
}
}
BBitmap *DragonView::_MakeNoneImage( void )
{
// Draw an "empty" bitmap to represent "no image"; we'll use one
// that tells the user what to do.
BBitmap *bitmap = new BBitmap( BRect( 0, 0, 319, 199 ),
BScreen().ColorSpace(),
true );
BView *view = new BView( bitmap->Bounds(),
"not a bitmap",
B_FOLLOW_ALL_SIDES, 0 );
bitmap->AddChild( view );
DragonApp *app = dynamic_cast<DragonApp *>( be_app );
rgb_color White = { 255, 255, 255, 0 };
rgb_color Black = { 0, 0, 0, 0 };
bitmap->Lock();
view->SetLowColor( White );
view->SetViewColor( White );
view->SetHighColor( Black );
view->SetDrawingMode( B_OP_OVER );
view->FillRect( view->Bounds(), B_SOLID_LOW );
// Excercise for the reader here: Read the old newsletter articles
// about how to use the font metrics to find out how large a font is,
// then center to font in the window dynamically no matter what font
// settings the user has.
view->SetFont( be_plain_font );
view->MovePenTo( 5, 100 );
view->DrawString( app->rsrc_strings->FindString( RSRC_Drop_an_image ) );
view->Sync();
bitmap->Unlock();
return bitmap;
}
bool
ClipView::InitiateDrag(BPoint point, int32 index, bool wasSelected)
{
ClipItem* sItem = dynamic_cast<ClipItem *> (ItemAt(index));
if (sItem == NULL)
return false;
BString string(sItem->GetClip());
BMessage message(FAV_ADD);
message.AddData("text/plain", B_MIME_TYPE, string, string.Length());
message.AddPointer("clip", sItem);
BRect dragRect(0.0f, 0.0f, Bounds().Width(), sItem->Height());
BBitmap* dragBitmap = new BBitmap(dragRect, B_RGB32, true);
if (dragBitmap->IsValid()) {
BView* view = new BView(dragBitmap->Bounds(), "helper", B_FOLLOW_NONE,
B_WILL_DRAW);
dragBitmap->AddChild(view);
dragBitmap->Lock();
sItem->DrawItem(view, dragRect);
view->SetHighColor(0, 0, 0, 255);
view->StrokeRect(view->Bounds());
view->Sync();
dragBitmap->Unlock();
} else {
delete dragBitmap;
dragBitmap = NULL;
}
if (dragBitmap != NULL)
DragMessage(&message, dragBitmap, B_OP_ALPHA, BPoint(0.0, 0.0));
else
DragMessage(&message, dragRect.OffsetToCopy(point), this);
return true;
}
status_t
CanvasMessage::ReadViewState(BView& view, ::pattern& pattern)
{
bool subPixelPrecise;
float penSize, miterLimit;
drawing_mode drawingMode;
source_alpha sourceAlpha;
alpha_function alphaFunction;
cap_mode capMode;
join_mode joinMode;
rgb_color highColor, lowColor;
Read(penSize);
Read(subPixelPrecise);
Read(drawingMode);
Read(sourceAlpha);
Read(alphaFunction);
Read(pattern);
Read(capMode);
Read(joinMode);
Read(miterLimit);
Read(highColor);
status_t result = Read(lowColor);
if (result != B_OK)
return result;
uint32 flags = view.Flags() & ~B_SUBPIXEL_PRECISE;
view.SetFlags(flags | (subPixelPrecise ? B_SUBPIXEL_PRECISE : 0));
view.SetPenSize(penSize);
view.SetDrawingMode(drawingMode);
view.SetBlendingMode(sourceAlpha, alphaFunction);
view.SetLineMode(capMode, joinMode, miterLimit);
view.SetHighColor(highColor);
view.SetLowColor(lowColor);
return B_OK;
}
void BochsView::SetHighColor(uchar r, uchar g, uchar b, uchar a)
{
backing_store->Lock();
backing_view->SetHighColor(r,g,b,a);
backing_store->Unlock();
}
void
BTitleView::Draw(BRect /*updateRect*/, bool useOffscreen, bool updateOnly,
const BColumnTitle *pressedColumn,
void (*trackRectBlitter)(BView *, BRect), BRect passThru)
{
BRect bounds(Bounds());
BView *view;
if (useOffscreen) {
ASSERT(sOffscreen);
BRect frame(bounds);
frame.right += frame.left;
// this is kind of messy way of avoiding being clipped by the ammount the
// title is scrolled to the left
// ToDo: fix this
view = sOffscreen->BeginUsing(frame);
view->SetOrigin(-bounds.left, 0);
view->SetLowColor(LowColor());
view->SetHighColor(HighColor());
BFont font(be_plain_font);
font.SetSize(9);
view->SetFont(&font);
} else
view = this;
if (be_control_look != NULL) {
rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
view->SetHighColor(tint_color(base, B_DARKEN_2_TINT));
view->StrokeLine(bounds.LeftBottom(), bounds.RightBottom());
bounds.bottom--;
be_control_look->DrawButtonBackground(view, bounds, bounds, base, 0,
BControlLook::B_TOP_BORDER | BControlLook::B_BOTTOM_BORDER);
} else {
// fill background with light gray background
if (!updateOnly)
view->FillRect(bounds, B_SOLID_LOW);
view->BeginLineArray(4);
view->AddLine(bounds.LeftTop(), bounds.RightTop(), sShadowColor);
view->AddLine(bounds.LeftBottom(), bounds.RightBottom(), sShadowColor);
// draw lighter gray and white inset lines
bounds.InsetBy(0, 1);
view->AddLine(bounds.LeftBottom(), bounds.RightBottom(), sLightShadowColor);
view->AddLine(bounds.LeftTop(), bounds.RightTop(), sShineColor);
view->EndLineArray();
}
int32 count = fTitleList.CountItems();
float minx = bounds.right;
float maxx = bounds.left;
for (int32 index = 0; index < count; index++) {
BColumnTitle *title = fTitleList.ItemAt(index);
title->Draw(view, title == pressedColumn);
BRect titleBounds(title->Bounds());
if (titleBounds.left < minx)
minx = titleBounds.left;
if (titleBounds.right > maxx)
maxx = titleBounds.right;
}
if (be_control_look != NULL) {
bounds = Bounds();
minx--;
view->SetHighColor(sLightShadowColor);
view->StrokeLine(BPoint(minx, bounds.top), BPoint(minx, bounds.bottom - 1));
} else {
// first and last shades before and after first column
maxx++;
minx--;
view->BeginLineArray(2);
view->AddLine(BPoint(minx, bounds.top),
BPoint(minx, bounds.bottom), sShadowColor);
view->AddLine(BPoint(maxx, bounds.top),
BPoint(maxx, bounds.bottom), sShineColor);
view->EndLineArray();
}
#if !(APP_SERVER_CLEARS_BACKGROUND)
FillRect(BRect(bounds.left, bounds.top + 1, minx - 1, bounds.bottom - 1), B_SOLID_LOW);
FillRect(BRect(maxx + 1, bounds.top + 1, bounds.right, bounds.bottom - 1), B_SOLID_LOW);
#endif
if (useOffscreen) {
if (trackRectBlitter)
(trackRectBlitter)(view, passThru);
view->Sync();
DrawBitmap(sOffscreen->Bitmap());
sOffscreen->DoneUsing();
} else if (trackRectBlitter)
(trackRectBlitter)(view, passThru);
}
/*! \function CategoryMenuItem::CreateIcon
* \brief Create the square icon filled with submitted color.
* \param[in] color The color of the requested icon.
* \param[in] toChange If there is an allocated item, it may be changed.
* If the submitted pointer is not NULL (which is default),
* this BBitmap is tested for dimensions match, and if dimensions
* allow, its contents are replaced with new icon. Else, old icon
* is deleted, and a new is created. In this case, both the
* "toChange" pointer and returned pointer point to the same
* BBitmap.
*/
BBitmap* CategoryMenuItem::CreateIcon( const rgb_color color,
BBitmap* toChange )
{
BBitmap* toReturn = NULL; //!< This is the value to be returned.
BRect tempRect;
float width, height, squareSide;
// Get size of the square
this->GetContentSize( &width, &height );
squareSide = ceilf( height ) - 2;
// Compare submitted bitmap to calculated size
if ( toChange )
{
tempRect = toChange->Bounds();
if ( ( tempRect.Width() != squareSide ) ||
( tempRect.Height() != squareSide ) )
{
// Dimensions don't match - need to delete the bitmap and reallocate it
delete toChange;
tempRect.Set( 0, 0, squareSide, squareSide );
toChange = new BBitmap( tempRect, B_RGB32, true );
if ( !toChange )
{
/* Panic! */
exit(1);
}
toReturn = toChange;
}
else
{
/*! \note Note about color spaces
* Actually, even if the dimensions are correct, the existing
* BBitmap may be not suitable due to incorrect color space.
* However, BBitmap may change the color space on its own, (and
* probably will, since there's no much sense in having 32 bits
* per pixel for bitmap with only 2 colors - black for the frame
* and Category's color for the inside). Therefore, color space is
* not checked. It's assumed that existing color space is good enough.
*/
// Dimensions match, color space is not checked - continuing
toReturn = toChange;
}
}
else // No bitmap is submitted
{
toReturn = new BBitmap( tempRect, B_RGB32, true );
if ( !toReturn )
{
/* Panic! */
exit(1);
}
}
/* Here toReturn is already set. */
// Add the drawing view to the bitmap
tempRect.Set( 0, 0, squareSide, squareSide );
BView* drawing = new BView (tempRect,
"Drawer",
B_FOLLOW_LEFT | B_FOLLOW_TOP,
B_WILL_DRAW);
if (!drawing || !toReturn) {
/* Panic! */
return NULL;
}
toReturn->AddChild(drawing);
if (toReturn->Lock()) {
// Clean the area
drawing->SetHighColor( ui_color( B_MENU_BACKGROUND_COLOR ) );
drawing->FillRect( tempRect );
// Draw the black square
drawing->SetHighColor( ui_color( B_MENU_ITEM_TEXT_COLOR ) );
drawing->SetPenSize( 1 );
drawing->StrokeRect( tempRect );
// Fill the inside of the square
drawing->SetHighColor( color );
drawing->FillRect( tempRect.InsetBySelf( 1, 1 ) );
// Flush the actions to BBitmap
drawing->Sync();
toReturn->Unlock();
}
toReturn->RemoveChild( drawing );
delete drawing;
return toReturn;
} // <-- end of function "CategoryMenuItem::CreateIcon"
/*! \function ColorUpdateWindow::MessageReceived
* \brief Main function
*/
void ColorUpdateWindow::MessageReceived( BMessage* in )
{
BAlert* al = NULL;
DebuggerPrintout* deb = NULL;
BTextView* textView = NULL;
BView* background = NULL;
BMessenger* mesg = NULL;
status_t errorCode = B_OK;
BString currentString( this->originalString );
rgb_color previousHighColor;
BRect tempRect;
switch ( in->what )
{
case kColorSelected:
/* The user had make his choise. */
/* Checking if the color has changed... */
if ( colorControl )
{
currentColor = colorControl->ValueAsColor();
if ( currentColor != originalColor )
{
this->dirty = true;
}
}
/* Checking if the string has changed... */
if ( enableEditingLabel )
{
if ( labelView )
{
// textView = ( BTextView* )labelView; // For matter of simplicity only
currentString.SetTo( ( ( BTextControl* )labelView )->Text() );
if ( currentString != originalString ) // If there were changes
{
if ( ! utl_CheckStringValidity( currentString ) )
{
// User has changed the string to an invalid one -
// he must correct it before proceeding
al = new BAlert("Error detected!",
"The string you've entered is invalid. Please correct.",
"Ok",
NULL,
NULL,
B_WIDTH_AS_USUAL,
B_STOP_ALERT );
if ( al ) {
al->Go();
break; // Returning to main window
} else {
/* Panic! */
exit(1);
}
} // <-- end of "if (string is not valid) "
else
{
// String is valid - verify it's different
if ( currentString != originalString )
{
this->dirty = true;
}
}
} // <-- end of "if (user changed the string)
} // <-- end of "if ( BTextView exists )"
} // <-- end of "if (user has possibility to change the string)"
// If anything has changed, send the update message. Else, send revert message.
if ( ! messageToSend )
{
if ( this->dirty )
{
this->messageToSend = new BMessage( kColorSelected );
} else {
this->messageToSend = new BMessage( kColorReverted );
}
if ( ! this->messageToSend ) {
/* Panic! */
exit(1);
}
}
// Stuff the message with needed data
messageToSend->AddBool( "Dirty", this->dirty );
messageToSend->AddString ( "Original string", this->originalString );
if ( this->dirty ) {
messageToSend->AddString("New string", currentString );
}
messageToSend->AddInt32( "Original color", RepresentColorAsUint32( this->originalColor ) );
messageToSend->AddInt32( "New color", RepresentColorAsUint32( this->currentColor ) );
// Send the message and close current window
// mesg = new BMessenger( (BHandler* )target, NULL, &errorCode );
mesg = new BMessenger( "application/x-vnd.Hitech.Skeleton", -1, &errorCode );
if ( errorCode == B_OK ) {
mesg->SendMessage( messageToSend, ( BHandler* )NULL );
deb = new DebuggerPrintout( "Message was sent" );
} else {
deb = new DebuggerPrintout( "Message wasn't sent" );
}
this->Quit();
break;
case kColorReverted:
/* Returning to original settings */
if ( colorControl )
{
colorControl->SetValue( originalColor );
colorControl->Invoke();
}
if ( enableEditingLabel && this->labelView )
{
( (BTextControl*)this->labelView )->SetText( this->originalString.String() );
( (BTextControl*)this->labelView )->MakeFocus( false ); // Prevent accidental change of text
}
break;
case kColorChanged:
// We need to reflect the change in color.
// We'll do it using the current view's high color. For this, we need to
// back up current high color in order to restore it later.
background = this->FindView( "Background" );
if ( ! background )
{
deb = new DebuggerPrintout( "Didn't find background!" );
return;
}
previousHighColor = background->HighColor();
background->SetHighColor( 0, 0, 1 ); // almost black
tempRect = BRect( ( revertButton->Frame() ).right + 10,
( revertButton->Frame() ).top,
( okButton->Frame() ).left - 10,
( revertButton->Frame() ).bottom );
// Actual drawing
if ( this->Lock() ) {
background->SetPenSize( 1 );
// Create border
background->StrokeRoundRect( tempRect.InsetBySelf( 1, 1 ), 4, 4 );
// Fill the rectangle
background->SetHighColor( colorControl->ValueAsColor() );
background->FillRoundRect( tempRect.InsetBySelf( 1, 1 ), 4, 4 );
background->Flush();
this->Flush();
this->Unlock();
}
background->SetHighColor( previousHighColor );
break;
default:
BWindow::MessageReceived( in );
};
} // <-- end of function "ColorUpdateWindow::MessageReceived"
void
ActivityView::_DrawHistory(bool drawBackground)
{
_UpdateOffscreenBitmap();
BView* view = this;
if (fOffscreen != NULL) {
fOffscreen->Lock();
view = _OffscreenView();
}
BRect frame = _HistoryFrame();
BRect outerFrame = frame.InsetByCopy(-2, -2);
// draw the outer frame
uint32 flags = 0;
if (!drawBackground)
flags |= BControlLook::B_BLEND_FRAME;
be_control_look->DrawTextControlBorder(this, outerFrame,
outerFrame, fLegendBackgroundColor, flags);
// convert to offscreen view if necessary
if (view != this)
frame.OffsetTo(B_ORIGIN);
view->SetLowColor(fHistoryBackgroundColor);
view->FillRect(frame, B_SOLID_LOW);
uint32 step = 2;
uint32 resolution = fDrawResolution;
if (fDrawResolution > 1) {
step = 1;
resolution--;
}
// We would get a negative number of steps which isn't a good idea.
if (frame.IntegerWidth() <= 10)
return;
uint32 width = frame.IntegerWidth() - 10;
uint32 steps = width / step;
bigtime_t timeStep = RefreshInterval() * resolution;
bigtime_t now = system_time();
// Draw scale
// TODO: add second markers?
view->SetPenSize(1);
rgb_color scaleColor = view->LowColor();
uint32 average = (scaleColor.red + scaleColor.green + scaleColor.blue) / 3;
if (average < 96)
scaleColor = tint_color(scaleColor, B_LIGHTEN_2_TINT);
else
scaleColor = tint_color(scaleColor, B_DARKEN_2_TINT);
view->SetHighColor(scaleColor);
view->StrokeLine(BPoint(frame.left, frame.top + frame.Height() / 2),
BPoint(frame.right, frame.top + frame.Height() / 2));
// Draw values
view->SetPenSize(1.5);
BAutolock _(fSourcesLock);
for (uint32 i = fSources.CountItems(); i-- > 0;) {
ViewHistory* viewValues = fViewValues.ItemAt(i);
DataSource* source = fSources.ItemAt(i);
DataHistory* values = fValues.ItemAt(i);
viewValues->Update(values, steps, fDrawResolution, now, timeStep,
RefreshInterval());
if (viewValues->Start() >= (int32)steps - 1)
continue;
uint32 x = viewValues->Start() * step;
bool first = true;
view->SetHighColor(source->Color());
view->SetLineMode(B_BUTT_CAP, B_ROUND_JOIN);
view->MovePenTo(B_ORIGIN);
try {
view->BeginLineArray(steps - viewValues->Start() - 1);
BPoint prev;
for (uint32 j = viewValues->Start(); j < steps; x += step, j++) {
float y = _PositionForValue(source, values,
viewValues->ValueAt(j));
if (first) {
first = false;
} else
view->AddLine(prev, BPoint(x, y), source->Color());
prev.Set(x, y);
}
} catch (std::bad_alloc) {
// Not enough memory to allocate the line array.
// TODO we could try to draw using the slower but less memory
// consuming solution using StrokeLine.
}
view->EndLineArray();
}
// TODO: add marks when an app started or quit
view->Sync();
if (fOffscreen != NULL) {
fOffscreen->Unlock();
DrawBitmap(fOffscreen, outerFrame.LeftTop());
}
}
AttribPolygon::AttribPolygon ()
: AttribView (BRect (0, 0, 148, 90), lstring (30, "Polygons"))
{
SetViewColor (LightGrey);
lSlid = new Slider (BRect (8, 8, 140, 26), 60, lstring (310, "Pen Size"), 1, 50, 1, new BMessage ('ALpc'));
AddChild (lSlid);
fPenSize = 1;
fType = POLYGON_OUTFILL;
BBox *type = new BBox (BRect (18, 32, 130, 82), "type");
type->SetLabel (lstring (311, "Type"));
AddChild (type);
BPoint pointArray[] = {
BPoint ( 2, 8),
BPoint ( 9, 2),
BPoint (27, 12),
BPoint (19, 28),
BPoint (14, 20),
BPoint ( 9, 26)
};
BPolygon *poly = new BPolygon();
poly->AddPoints(pointArray, 6);
BWindow *picWindow = new BWindow (BRect (0, 0, 100, 100), "Temp Pic Window", B_BORDERED_WINDOW, uint32 (NULL), uint32 (NULL));
BView *bg = new BView (BRect (0, 0, 100, 100), "Temp Pic View", uint32 (NULL), uint32 (NULL));
picWindow->AddChild (bg);
BPicture *p10;
bg->BeginPicture (new BPicture);
bg->SetLowColor (LightGrey);
bg->FillRect (BRect (0, 0, 32, 32), B_SOLID_LOW);
bg->SetLowColor (White);
bg->FillPolygon (poly, B_SOLID_LOW);
bg->StrokePolygon (poly);
p10 = bg->EndPicture();
BPicture *p20;
bg->BeginPicture (new BPicture);
bg->SetLowColor (LightGrey);
bg->FillRect (BRect (0, 0, 32, 32), B_SOLID_LOW);
bg->SetHighColor (Black);
bg->SetLowColor (White);
bg->FillPolygon (poly, B_SOLID_LOW);
p20 = bg->EndPicture();
BPicture *p30;
bg->BeginPicture (new BPicture);
bg->SetLowColor (LightGrey);
bg->FillRect (BRect (0, 0, 32, 32), B_SOLID_LOW);
bg->SetHighColor (Black);
bg->SetLowColor (White);
bg->StrokePolygon (poly);
p30 = bg->EndPicture();
BPicture *p11;
bg->BeginPicture (new BPicture);
bg->SetLowColor (DarkGrey);
bg->FillRect (BRect (0, 0, 32, 32), B_SOLID_LOW);
bg->SetHighColor (Black);
bg->SetLowColor (White);
bg->FillPolygon (poly, B_SOLID_LOW);
bg->StrokePolygon (poly);
p11 = bg->EndPicture();
BPicture *p21;
bg->BeginPicture (new BPicture);
bg->SetLowColor (DarkGrey);
bg->FillRect (BRect (0, 0, 32, 32), B_SOLID_LOW);
bg->SetHighColor (Black);
bg->SetLowColor (White);
bg->FillPolygon (poly, B_SOLID_LOW);
p21 = bg->EndPicture();
BPicture *p31;
bg->BeginPicture (new BPicture);
bg->SetLowColor (DarkGrey);
bg->FillRect (BRect (0, 0, 32, 32), B_SOLID_LOW);
bg->SetHighColor (Black);
bg->SetLowColor (White);
bg->StrokePolygon (poly);
p31 = bg->EndPicture();
delete poly;
delete picWindow;
SetViewColor (LightGrey);
pT1 = new BPictureButton (BRect (4, 15, 34, 45), "APVt1", p10, p11, new BMessage ('pvT1'), B_TWO_STATE_BUTTON);
pT2 = new BPictureButton (BRect (40, 15, 70, 45), "APVt2", p20, p21, new BMessage ('pvT2'), B_TWO_STATE_BUTTON);
pT3 = new BPictureButton (BRect (76, 15, 106, 45), "APVt3", p30, p31, new BMessage ('pvT3'), B_TWO_STATE_BUTTON);
type->AddChild (pT1);
type->AddChild (pT2);
type->AddChild (pT3);
pT1->SetValue (B_CONTROL_ON);
fCurrentProperty = 0;
}
