예제 #1
0
파일: main.cpp 프로젝트: mmanley/Antares
	virtual void Draw(BRect updateRect)
	{
		BRegion region;
		region.Include(BRect(20, 20, 40, 40));
		region.Include(BRect(30, 30, 80, 80));
		ConstrainClippingRegion(&region);

		SetHighColor(55, 255, 128, 255);
		FillRect(BRect(0, 0, 100, 100));

		PushState();
			SetOrigin(15, 15);
	
			ConstrainClippingRegion(&region);
	
			SetHighColor(155, 255, 128, 255);
			FillRect(BRect(0, 0, 100, 100));
	
//			ConstrainClippingRegion(NULL);
	
			SetHighColor(0, 0, 0, 255);
			StrokeLine(BPoint(2, 2), BPoint(80, 80));
			SetHighColor(255, 0, 0, 255);
			StrokeLine(BPoint(2, 2), BPoint(4, 2));
		PopState();

		SetHighColor(0, 0, 0, 255);
		StrokeLine(BPoint(4, 2), BPoint(82, 80));
	}
예제 #2
0
// Draw
void
IconValueView::Draw(BRect updateRect)
{
	BRect r;
	BRegion originalClippingRegion;
	GetClippingRegion(&originalClippingRegion);
	if (fIcon) {
		BRect b(Bounds());
		// layout icon in the center
		r = fIcon->Bounds();
		r.OffsetTo(floorf(b.left + b.Width() / 2.0 - r.Width() / 2.0),
				   floorf(b.top + b.Height() / 2.0 - r.Height() / 2.0));
		if (fIcon->ColorSpace() == B_RGBA32 || fIcon->ColorSpace() == B_RGBA32_BIG) {
			// set up transparent drawing and let
			// the base class draw the entire background
			SetHighColor(255, 255, 255, 255);
			SetDrawingMode(B_OP_ALPHA);
			SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);
		} else {
			// constrain clipping region to exclude bitmap
			BRegion region = originalClippingRegion;
			region.Exclude(r);
			ConstrainClippingRegion(&region);
		}
	}
	// draw surrouing area (and possibly background for bitmap)
	PropertyEditorView::Draw(updateRect);

	ConstrainClippingRegion(&originalClippingRegion);
	if (fIcon) {
		DrawBitmap(fIcon, r.LeftTop());
	}
}
void
LanguageListView::Draw(BRect updateRect)
{
	BOutlineListView::Draw(updateRect);

	if (fDropIndex >= 0 && fDropTargetHighlightFrame.IsValid()) {
		// TODO: decide if drawing of a drop target indicator should be moved
		//       into ControlLook
		BGradientLinear gradient;
		int step = fGlobalDropTargetIndicator ? 64 : 128;
		for (int i = 0; i < 256; i += step)
			gradient.AddColor(i % (step * 2) == 0
				? ViewColor() : ui_color(B_CONTROL_HIGHLIGHT_COLOR), i);
		gradient.AddColor(ViewColor(), 255);
		gradient.SetStart(fDropTargetHighlightFrame.LeftTop());
		gradient.SetEnd(fDropTargetHighlightFrame.RightBottom());
		if (fGlobalDropTargetIndicator) {
			BRegion region(fDropTargetHighlightFrame);
			region.Exclude(fDropTargetHighlightFrame.InsetByCopy(2.0, 2.0));
			ConstrainClippingRegion(&region);
			FillRect(fDropTargetHighlightFrame, gradient);
			ConstrainClippingRegion(NULL);
		} else
			FillRect(fDropTargetHighlightFrame, gradient);
	}
}
예제 #4
0
void TPanelWindowView::Draw( BRect updateRect )
{
	BRegion Region;
	Region.Include(updateRect);
	ConstrainClippingRegion(&Region);

	float w, h;

	w = Bounds().Width();
	h = Bounds().Height();

	SetHighColor( fColor2 );
	FillRect( BRect( 0, 0, h, h ) );
	FillRect( BRect( w-h, 0, w, h ) );

	FillRect( BRect( h/2, 0, w-(h/2), h/2) );
	FillRect( BRect( 0, h/2, w, h ) );

	SetHighColor( 196, 196, 176 );
	FillRect( BRect( 0, h - 2, w, h ) );

	fPanels.Lock();
	for ( int i=0; i<fPanels.CountItems(); i++ )
	{
		TInnerPanel *panel = fPanels.ItemAt(i);
		if ( panel->Frame().Intersects( updateRect ) )
		{
			BRect rect( panel->Frame() );
			if ( rect.left < updateRect.left )
				rect.left = updateRect.left;
			if ( rect.right > updateRect.right )
				rect.right = updateRect.right;
			if ( rect.top < updateRect.top )
				rect.top = updateRect.top;
			if ( rect.bottom > updateRect.bottom )
				rect.bottom = updateRect.bottom;
			panel->Draw(rect);
		}
	}
	fPanels.Unlock();

	if ( fDrawOuterFrame )
	{
		SetDrawingMode( B_OP_COPY );
		SetHighColor( fOuterFrameColor );

		BRect bounds = Bounds();
		StrokeLine( bounds.LeftTop(), bounds.RightTop() );
		StrokeLine( bounds.LeftTop(), bounds.LeftBottom() );
		StrokeLine( bounds.RightTop(), bounds.RightBottom() );
	}

	ConstrainClippingRegion(NULL);
}
예제 #5
0
void MyView::RequestRedraw()
{
	wind->Lock();

	ConstrainClippingRegion(&fRedrawReg);
	PushState();
	DrawSubTree(topLayer);
	PopState();
	ConstrainClippingRegion(NULL);

	fRedrawReg.MakeEmpty();

	wind->Unlock();
}
예제 #6
0
파일: main.cpp 프로젝트: mmanley/Antares
	virtual void Draw(BRect updateRect)
	{
		BRegion region;
		region.Include(BRect(20, 20, 40, 40));
		region.Include(BRect(30, 30, 80, 80));
		ConstrainClippingRegion(&region);

		SetHighColor(255, 0, 0, 255);
		FillRect(BRect(0, 0, 100, 100));

		ConstrainClippingRegion(NULL);

		SetHighColor(0, 0, 0, 255);
		StrokeLine(BPoint(2, 2), BPoint(80, 80));
	}
예제 #7
0
void MyView::DrawSubTree(Layer* lay)
{
//printf("======== %s =======\n", lay->Name());
//	lay->Visible()->PrintToStream();
//	lay->FullVisible()->PrintToStream();
	for (Layer *child = lay->BottomChild(); child; child = lay->UpperSibling())
		DrawSubTree(child);

	ConstrainClippingRegion(lay->Visible());
	SetHighColor(lay->HighColor());
	BRegion	reg;
	lay->GetWantedRegion(reg);
	FillRect(reg.Frame());
	Flush();
	ConstrainClippingRegion(NULL);
}
예제 #8
0
파일: ObjectView.cpp 프로젝트: dakyri/qua
void ObjectView::Draw(BRect region)
{
	BRect	bnd = Bounds();
	BRegion	regi; regi.Include(region);
	ConstrainClippingRegion(&regi);

	if (isSelected) {
		SetDrawingMode(B_OP_OVER);
		SetHighColor(black);
		FillRect(bnd, B_SOLID_HIGH);
		SetViewColor(black);
		SetHighColor(color);
	} else {
		SetDrawingMode(B_OP_OVER);
		SetHighColor(color);
		FillRect(bnd, B_SOLID_HIGH);
		SetViewColor(color);
		SetHighColor(black);
	}
	StrokeRect(bnd, B_SOLID_HIGH);
	if (label) {
		DrawString(label, labelPoint);
		if (container) {
			BRect	cb = container->Bounds();
			int	d = (cb.right-cb.left-30);
			int		llbl;
			for (	llbl = labelPoint.x + (1+(((int32)region.left) / d)) * d;
					llbl < region.right;
					llbl += d) {
				DrawString(label, BPoint(llbl,labelPoint.y));
			}
		}
	}
}
예제 #9
0
// Draw
void
ColorField::Draw(BRect updateRect)
{
	if (fBitmapDirty && fBitmap != NULL) {
		_FillBitmap(fBitmap, fMode, fFixedValue, fOrientation);
		fBitmapDirty = false;
	}

	BRect bounds = Bounds();

	// Frame
	if (fBorderStyle == B_FANCY_BORDER) {
		rgb_color color = LowColor();
		be_control_look->DrawTextControlBorder(this, bounds, updateRect,
			color);
		BRegion region(bounds);
		ConstrainClippingRegion(&region);
	}

	// Color field fill
	if (fBitmap != NULL)
		DrawBitmap(fBitmap, bounds.LeftTop());
	else {
		SetHighColor(255, 0, 0);
		FillRect(bounds);
	}

	// Marker
	SetHighColor(0, 0, 0);
	StrokeEllipse(fMarkerPosition + bounds.LeftTop(), 5.0, 5.0);
	SetHighColor(255.0, 255.0, 255.0);
	StrokeEllipse(fMarkerPosition + bounds.LeftTop(), 4.0, 4.0);
}
예제 #10
0
void NetListView::FrameResized(float width, float height)
{
	BListView::FrameResized(width, height);
	//Ensure the bevel on the right is drawn properly
	if(width < oldWidth)
		oldWidth = width;
	PushState();
	BRect invalRect(oldWidth, 0, oldWidth, height);
	ConvertFromParent(&invalRect);
	BRegion lineRegion(invalRect);
	ConstrainClippingRegion(&lineRegion);
	Draw(invalRect);
	oldWidth = width;
	PopState();
	
	//Do word wrapping
	BFont curFont;
	GetFont(&curFont);
	float itemWidth = Bounds().Width();
	float wrapWidth = (itemWidth - 6)/curFont.Size();
	for(int itemNum = 0; itemNum < CountItems(); itemNum++)
	{
		NetListItem* item = (NetListItem*)(Items()[itemNum]);
		item->SetWidth(itemWidth);
		item->CalcWordWrap(wrapWidth);
	}
	//DoForEach(UpdateItem, (void*)this);
	Invalidate();
	
	BListView::FrameResized(width, height);
}
예제 #11
0
파일: Box.cpp 프로젝트: D-os/BeFree
void
BBox::Draw(BRect updateRect)
{
	if (!IsVisible() || fBorder == B_NO_BORDER) return;

	e_theme_engine *theme = get_current_theme_engine();
	if (theme == NULL || theme->get_border_margins == NULL || theme->draw_border == NULL) return;

	float l = 0, t = 0, r = 0, b = 0;
	theme->get_border_margins(theme, this, &l, &t, &r, &b, fBorder, PenSize());

	BRect rect = Frame().OffsetToSelf(B_ORIGIN);
	if (!(fLabelView == NULL || fLabelView->Frame().Width() <= 0 || fLabelView->Frame().Height() < t))
		rect.top += (fLabelView->Frame().Height() - t) / 2.f;

	PushState();

	BRegion clipping(updateRect);
	if (!(fLabelView == NULL || fLabelView->Frame().IsValid() == false)) clipping.Exclude(fLabelView->Frame());
	ConstrainClippingRegion(&clipping);

	if (clipping.CountRects() > 0) theme->draw_border(theme, this, rect, fBorder, PenSize());

	PopState();
}
예제 #12
0
	void AsyncRedraw(BRegion& region)
	{
		if (!LockLooper())
			return;

#if 0
		ConstrainClippingRegion(&region);
		FillRect(Bounds());
		ConstrainClippingRegion(NULL);
#else
		PushState();
		ConstrainClippingRegion(&region);
		FillRect(Bounds());
		PopState();
#endif

		UnlockLooper();
	}
예제 #13
0
void
BBox::Draw(BRect updateRect)
{
	_ValidateLayoutData();

	PushState();

	BRect labelBox = BRect(0, 0, 0, 0);
	if (fLabel != NULL) {
		labelBox = fLayoutData->label_box;
		BRegion update(updateRect);
		update.Exclude(labelBox);

		ConstrainClippingRegion(&update);
	} else if (fLabelView != NULL)
		labelBox = fLabelView->Bounds();

	switch (fStyle) {
		case B_FANCY_BORDER:
			_DrawFancy(labelBox);
			break;

		case B_PLAIN_BORDER:
			_DrawPlain(labelBox);
			break;

		default:
			break;
	}

	if (fLabel) {
		ConstrainClippingRegion(NULL);

		font_height fontHeight;
		GetFontHeight(&fontHeight);

		SetHighColor(0, 0, 0);
		DrawString(fLabel, BPoint(10.0f, ceilf(fontHeight.ascent)));
	}

	PopState();
}
예제 #14
0
파일: main.cpp 프로젝트: mmanley/Antares
	virtual void Draw(BRect updateRect)
	{
		BRegion region;
		region.Include(BRect(0, 0, 40, 40));
		region.Include(BRect(30, 30, 140, 140));
		ConstrainClippingRegion(&region);

		SetHighColor(55, 255, 128, 255);
		FillRect(BRect(0, 0, 200, 200));

		PushState();
			SetOrigin(50, 10);
			ConstrainClippingRegion(&region);

			SetHighColor(155, 55, 128, 255);
			FillRect(BRect(0, 0, 200, 200));
		PopState();

		SetHighColor(255, 0, 0);
		StrokeLine(Bounds().LeftTop(), Bounds().RightBottom());
	}
예제 #15
0
void
ClippingView::KeyDown(const char *bytes, int32 numBytes)
{
	SetHighColor(0, 0, 255);
	FillRect(Bounds(), B_SOLID_HIGH);

	BRegion region(BRect(200, 100, 250, 150));
	ConstrainClippingRegion(&region);

	SetHighColor(255, 0, 0);
	FillRect(Bounds(), B_SOLID_HIGH);
}
예제 #16
0
파일: main.cpp 프로젝트: mmanley/Antares
	virtual void Draw(BRect updateRect)
	{
		BRegion region;
		region.Include(BRect(20, 20, 40, 40));
		region.Include(BRect(30, 30, 140, 140));
		ConstrainClippingRegion(&region);

		SetHighColor(55, 255, 128, 255);
		FillRect(BRect(0, 0, 200, 200));

		// NOTE: This exposes broken behavior of the ZETA
		// (probably R5 too) app_server. The new origin
		// is not taken into account
		PushState();

		ConstrainClippingRegion(&region);
		SetOrigin(15, 15);
		SetScale(1.5);

		SetHighColor(155, 255, 128, 255);
		FillRect(BRect(0, 0, 200, 200));

		ConstrainClippingRegion(NULL);

		SetHighColor(0, 0, 0, 255);
		SetDrawingMode(B_OP_OVER);
		DrawString("Text is scaled.", BPoint(20, 30));

		SetScale(1.2);
		DrawString("Text is scaled.", BPoint(20, 30));

		StrokeLine(BPoint(2, 2), BPoint(80, 80));

		PopState();

		SetHighColor(0, 0, 0, 255);
		StrokeLine(BPoint(4, 2), BPoint(82, 80));
	}
예제 #17
0
// Draw
void
FontValueView::Draw(BRect updateRect)
{
	BRect b(Bounds());
	// focus indication
	if (IsFocus()) {
		SetHighColor(ui_color(B_KEYBOARD_NAVIGATION_COLOR));
		StrokeRect(b);
		b.InsetBy(1.0, 1.0);
		BRegion clipping;
		clipping.Include(b);
		ConstrainClippingRegion(&clipping);
		b.left --;
	}
	// background
	FillRect(b, B_SOLID_LOW);

	rgb_color labelColor = LowColor();
	if (fEnabled)
		labelColor = tint_color(labelColor, B_DARKEN_MAX_TINT);
	else
		labelColor = tint_color(labelColor, B_DISABLED_LABEL_TINT);

	SetHighColor(labelColor);

	b.InsetBy(2.0, 1.0);

	float center = floorf(b.top + b.Height() / 2.0);

	BPoint arrow[3];
	arrow[0] = BPoint(b.left, center - 3.0);
	arrow[1] = BPoint(b.left, center + 3.0);
	arrow[2] = BPoint(b.left + 3.0, center);

	FillPolygon(arrow, 3);

	b.left += 6.0;

	BFont font;
	GetFont(&font);

	font_height fh;
	font.GetHeight(&fh);

	BString truncated(fCurrentFont);
	font.TruncateString(&truncated, B_TRUNCATE_END, b.Width());

	DrawString(truncated.String(),
			   BPoint(b.left, floorf(center + fh.ascent / 2.0)));
}
예제 #18
0
파일: ScrollBar.cpp 프로젝트: D-os/BeFree
void
BScrollBar::Draw(BRect updateRect)
{
	if (!IsVisible()) return;

	e_theme_engine *theme = get_current_theme_engine();
	if (theme == NULL || theme->draw_scrollbar == NULL) return;

	PushState();
	ConstrainClippingRegion(updateRect);
	theme->draw_scrollbar(theme, this, Frame().OffsetToSelf(B_ORIGIN),
	                      fOrientation, fRangeMin, fRangeMax, fValue,
	                      (fTracking && fTrackingState > 0) ? fTrackingRegion.Contains(fMousePosition) : false,
	                      fMousePosition);
	PopState();
}
예제 #19
0
status_t
BitmapDrawingEngine::SetSize(int32 newWidth, int32 newHeight)
{
	if (fBitmap != NULL && newWidth > 0 && newHeight > 0
		&& fBitmap->Bounds().IntegerWidth() >= newWidth
		&& fBitmap->Bounds().IntegerHeight() >= newHeight) {
		return B_OK;
	}

	SetHWInterface(NULL);
	if (fHWInterface) {
		fHWInterface->LockExclusiveAccess();
		fHWInterface->Shutdown();
		fHWInterface->UnlockExclusiveAccess();
		delete fHWInterface;
		fHWInterface = NULL;
	}

	delete fBitmap;
	fBitmap = NULL;

	if (newWidth <= 0 || newHeight <= 0)
		return B_OK;

	fBitmap = new(std::nothrow) UtilityBitmap(BRect(0, 0, newWidth - 1,
		newHeight - 1), B_RGB32, 0);
	if (fBitmap == NULL)
		return B_NO_MEMORY;

	fHWInterface = new(std::nothrow) BitmapHWInterface(fBitmap);
	if (fHWInterface == NULL)
		return B_NO_MEMORY;

	status_t result = fHWInterface->Initialize();
	if (result != B_OK)
		return result;

	// we have to set a valid clipping first
	fClipping.Set(fBitmap->Bounds());
	ConstrainClippingRegion(&fClipping);
	SetHWInterface(fHWInterface);
	return B_OK;
}
예제 #20
0
void
BarberPole::Draw(BRect r)
{
	if (fStyle == BARBERPOLE_FANCY) {	
		BRect b(Bounds());
		BRect b1;
		for (int i = 0; i < 4; i ++) {
			BRegion r(b);
			if (i != (4-1)) {
				b1 = b.InsetByCopy(1, 1);
				r.Exclude(b1);
			}
			ConstrainClippingRegion(&r);
			BView::SetHighColor(fHighColors[i]); BView::SetLowColor(fLowColors[i]);
			FillRect(b, fStripes);
			b.InsetBy(1, 1);
		}
	} else {
		BView::SetHighColor(fHighColors[4 - 1]);
		BView::SetLowColor(fLowColors[4 - 1]);
		FillRect(r, fStripes);
	}
}
예제 #21
0
파일: TrackMenu.cpp 프로젝트: DonCN/haiku
void
TrackMenu::Draw(BRect update)
{
	rgb_color dark = {20, 20, 20, 255};
	rgb_color light = {200, 200, 200, 255};
	BPoint pt1, pt2;

	// Draw the frame
	SetHighColor(dark);
	pt1.Set(0, 0);
	pt2 = Bounds().RightTop();
	StrokeLine(pt1, pt2);

	pt2.Set(0, Bounds().bottom);
	StrokeLine(pt1, pt2);

	SetHighColor(255,255,255);
	pt1 = Bounds().RightBottom();
	pt2.Set(Bounds().right, 1);
	StrokeLine(pt1, pt2);

	pt2.Set(1,Bounds().bottom);
	StrokeLine(pt1, pt2);

	// Draw the items
	BRect r(fItemRect);

	for (int32 i = 0; i < fCount; i++) {
		// Draw the item's frame
		if (i == fCurrentItem)
			SetHighColor(dark);
		else
			SetHighColor(light);

		pt1.Set(r.left, r.top);
		pt2.Set(r.right, r.top);
		StrokeLine(pt1, pt2);

		pt2.Set(r.left, r.bottom);
		StrokeLine(pt1, pt2);

		if (i == fCurrentItem) {
			SetHighColor(light);
			pt1.Set(r.right, r.bottom);
			pt2.Set(r.right, r.top + 1);
			StrokeLine(pt1, pt2);

			pt2.Set(r.left + 1, r.bottom);
			StrokeLine(pt1, pt2);

			SetHighColor(light);
			FillRect(r.InsetByCopy(1, 1));
			SetHighColor(dark);
		}
		else if (i == fCount - 1) {
			SetHighColor(light);
			pt1.Set(r.right, r.bottom);
			pt2.Set(r.right, r.top + 1);
			StrokeLine(pt1, pt2);
		}

		// Draw the label, center justified

		BString label;
		label << (i + 1);

		BPoint labelpt;
		labelpt.x = r.left + (r.Width() - StringWidth(label.String())) / 2 + 2;
		labelpt.y = r.bottom - (r.Height() - fFontHeight + 4) / 2;

		if (i == fCurrentItem) {
			SetHighColor(dark);
			SetLowColor(light);
		} else {
			SetHighColor(light);
			SetLowColor(dark);
		}
		DrawString(label.String(), labelpt);

		// Setup for next iteration
		r.OffsetBy(r.Width() + 1, 0);

		if (r.left > Bounds().right - 2) {
			ConstrainClippingRegion(NULL);
			break;
		}

		if (r.right > Bounds().right - 2) {
			r.right = Bounds().right - 2;
			BRegion reg(r);
			ConstrainClippingRegion(&reg);
		}
	}
}
예제 #22
0
void
ETextEditable::Draw(ERect updateRect)
{
	if(!IsVisible()) return;

	ERect rect = Frame().OffsetToSelf(E_ORIGIN);
	rect.left += fMargins.left;
	rect.top += fMargins.top;
	rect.right -= fMargins.right;
	rect.bottom -= fMargins.bottom;

	if(!rect.IsValid()) return;

	ERegion clipping;
	GetClippingRegion(&clipping);
	if(clipping.CountRects() > 0) clipping &= (rect & updateRect);
	else clipping = (rect & updateRect);
	if(clipping.CountRects() <= 0) return;

	e_rgb_color bkColor = e_ui_color(E_DOCUMENT_BACKGROUND_COLOR);
	e_rgb_color fgColor = e_ui_color(E_DOCUMENT_TEXT_COLOR);

	if(!IsEnabled())
	{
		bkColor.disable(ViewColor());
		fgColor.disable(ViewColor());
	}

	if(!IsFocusChanging())
	{
		PushState();
		ConstrainClippingRegion(&clipping);
		SetDrawingMode(E_OP_COPY);
		SetPenSize(0);
		SetHighColor(bkColor);
		FillRect(rect & updateRect, E_SOLID_HIGH);
		PopState();
	}

	EFont font;
	e_font_height fontHeight;
	GetFont(&font);
	font.GetHeight(&fontHeight);

	if(fCount > 0 && !IsFocusChanging())
	{
		PushState();

		ConstrainClippingRegion(&clipping);

		float x = 0, y = 0;
		if(GetCharLocation(0, &x, &y, &font))
		{
			SetDrawingMode(E_OP_COPY);
			SetPenSize(0);
			SetHighColor(fgColor);
			SetLowColor(bkColor);
			_DrawString(fText, EPoint(x, y));

			if(IsEnabled() && IsSelected())
			{
				char *selectedText = DuplicateText(fSelectStart, fSelectEnd);
				if(selectedText != NULL)
				{
					x = 0; y = 0;
					if(GetCharLocation(fSelectStart, &x, &y, &font))
					{
						DrawSelectedBackground(updateRect);
						SetLowColor(e_ui_color(E_DOCUMENT_HIGHLIGHT_COLOR));
						_DrawString(selectedText, EPoint(x, y));
					}
					free(selectedText);
				}
			}
		}

		PopState();
	}

	if(IsEnabled() && IsEditable() && (IsFocus() || IsFocusChanging()))
	{
		PushState();
		ConstrainClippingRegion(&clipping);
		DrawCursor();
		PopState();
	}

	if((IsFocus() || IsFocusChanging()) && Window()->IsActivate() && IsEnabled() && (Flags() & E_NAVIGABLE))
	{
		e_rgb_color color = e_ui_color(E_NAVIGATION_BASE_COLOR);
		if(IsFocusChanging() && !IsFocus()) color = e_ui_color(E_DOCUMENT_BACKGROUND_COLOR);

		PushState();
		ConstrainClippingRegion(&clipping);
		SetDrawingMode(E_OP_COPY);
		SetPenSize(0);
		SetHighColor(color);
		StrokeRect(rect, E_SOLID_HIGH);
		PopState();
	}
}
예제 #23
0
void CLVColumnLabelView::Draw(BRect update_rect)
{
	BRect ViewBounds = Bounds();

	//Draw each column label in turn
	float ColumnBegin = 0.0;
	float ColumnEnd = -1.0;
	bool MergeWithLeft = false;
	int32 NumberOfColumns = fDisplayList->CountItems();
	BPoint Start,Stop;
	for(int32 ColumnDraw = 0; ColumnDraw < NumberOfColumns; ColumnDraw++)
	{
		CLVColumn* ThisColumn = (CLVColumn*)fDisplayList->ItemAt(ColumnDraw);
		if(ThisColumn->IsShown())
		{
			//Figure out where this column is
			ColumnBegin = ThisColumn->fColumnBegin;
			ColumnEnd = ThisColumn->fColumnEnd;
			//Start by figuring out if this column will merge with a shown column to the right
			bool MergeWithRight = false;
			if(ThisColumn->fFlags & CLV_MERGE_WITH_RIGHT)
			{
				for(int32 ColumnCounter = ColumnDraw+1; ColumnCounter < NumberOfColumns;
					ColumnCounter++)
				{
					CLVColumn* NextColumn = (CLVColumn*)fDisplayList->ItemAt(ColumnCounter);
					if(NextColumn->IsShown())
					{
						//The next column is shown
						MergeWithRight = true;
						break;
					}
					else if(!(NextColumn->fFlags & CLV_MERGE_WITH_RIGHT))
						//The next column is not shown and doesn't pass on the merge
						break;
				}
			}
			if(update_rect.Intersects(BRect(ColumnBegin,ViewBounds.top,ColumnEnd,
				ViewBounds.bottom)))
			{
				//Need to draw this column
				BeginLineArray(4);
				//Top line
				Start.Set(ColumnBegin,ViewBounds.top);
				Stop.Set(ColumnEnd-1.0,ViewBounds.top);
				if(MergeWithRight && !(ThisColumn == fColumnClicked && fColumnResizing))
					Stop.x = ColumnEnd;
				AddLine(Start,Stop,BeHighlight);
				//Left line
				if(!MergeWithLeft)
					AddLine(BPoint(ColumnBegin,ViewBounds.top+1.0),
						BPoint(ColumnBegin,ViewBounds.bottom),BeHighlight);
				//Bottom line
				Start.Set(ColumnBegin+1.0,ViewBounds.bottom);
				if(MergeWithLeft)
					Start.x = ColumnBegin;
				Stop.Set(ColumnEnd-1.0,ViewBounds.bottom);
				if(MergeWithRight && !(ThisColumn == fColumnClicked && fColumnResizing))
					Stop.x = ColumnEnd;
				AddLine(Start,Stop,BeShadow);
				//Right line
				if(ThisColumn == fColumnClicked && fColumnResizing)
					AddLine(BPoint(ColumnEnd,ViewBounds.top),BPoint(ColumnEnd,ViewBounds.bottom),
						BeFocusBlue);
				else if(!MergeWithRight)
					AddLine(BPoint(ColumnEnd,ViewBounds.top),BPoint(ColumnEnd,ViewBounds.bottom),
						BeShadow);
				EndLineArray();

				//Add the label
				//Limit the clipping region to the interior of the box
				BRect TextRect(ColumnBegin+1.0,ViewBounds.top+1.0,ColumnEnd-1.0,
					ViewBounds.bottom-1.0);
				BRegion TextRegion;
				TextRegion.Include(TextRect);
				ConstrainClippingRegion(&TextRegion);

				bool focus;
				bool sort_key;
				if(ThisColumn == fColumnClicked && !fColumnResizing)
					focus = true;
				else
					focus = false;
				if(fParent->fSortKeyList.HasItem(ThisColumn) && ThisColumn->fSortMode != NoSort)
					sort_key = true;
				else
					sort_key = false;

				ThisColumn->DrawColumnHeader(this,TextRect,sort_key,focus,fFontAscent);

				//Restore the clipping region
				ConstrainClippingRegion(NULL);
			}
			//Set MergeWithLeft flag for the next column to the appropriate state
			MergeWithLeft = MergeWithRight;
		}
	}

	//Add highlight and shadow to the region after the columns if necessary
	if(ColumnEnd < ViewBounds.right)
	{
		ColumnBegin = ColumnEnd+1.0;
		if(update_rect.Intersects(BRect(ColumnEnd+1.0,ViewBounds.top,ViewBounds.right,
			ViewBounds.bottom)))
		{
			BeginLineArray(3);
			//Top line
			AddLine(BPoint(ColumnBegin,ViewBounds.top),BPoint(ViewBounds.right,ViewBounds.top),
				BeHighlight);
			//Left line
			AddLine(BPoint(ColumnBegin,ViewBounds.top+1.0),BPoint(ColumnBegin,ViewBounds.bottom),
				BeHighlight);
			//Bottom line
			Start.Set(ColumnBegin+1.0,ViewBounds.bottom);
			if(MergeWithLeft)
				Start.x = ColumnBegin;
			Stop.Set(ViewBounds.right,ViewBounds.bottom);
			AddLine(Start,Stop,BeShadow);
			EndLineArray();
		}
	}

	//Draw the dragging box if necessary
	if(fColumnClicked && fColumnDragging)
	{
		float DragOutlineLeft = fPreviousMousePos.x-fDragBoxMouseHoldOffset;
		float GroupBegin = ((CLVDragGroup*)fDragGroups.ItemAt(fDragGroup))->GroupBegin;
		if(DragOutlineLeft < GroupBegin && fSnapGroupBefore == -1)
			DragOutlineLeft = GroupBegin;
		if(DragOutlineLeft > GroupBegin && fSnapGroupAfter == -1)
			DragOutlineLeft = GroupBegin;
		float DragOutlineRight = DragOutlineLeft + fDragBoxWidth;
		BeginLineArray(4);
		AddLine(BPoint(DragOutlineLeft,ViewBounds.top),BPoint(DragOutlineRight,
			ViewBounds.top),BeFocusBlue);
		AddLine(BPoint(DragOutlineLeft,ViewBounds.bottom),BPoint(DragOutlineRight,
			ViewBounds.bottom),BeFocusBlue);
		AddLine(BPoint(DragOutlineLeft,ViewBounds.top+1.0),BPoint(DragOutlineLeft,
			ViewBounds.bottom-1.0),BeFocusBlue);
		AddLine(BPoint(DragOutlineRight,ViewBounds.top+1.0),BPoint(DragOutlineRight,
			ViewBounds.bottom-1.0),BeFocusBlue);
		EndLineArray();
		fPrevDragOutlineLeft = DragOutlineLeft;
		fPrevDragOutlineRight = DragOutlineRight;
	}
}
예제 #24
0
void TLevelsSlider::Draw(BRect updateRect)
{
	PushState();
	
	// Set up clipping
	BRegion clipRegion, saveRegion;
	GetClippingRegion(&saveRegion);
	clipRegion.Set(updateRect);
	ConstrainClippingRegion( &clipRegion );
	
	BPoint startPt, endPt;
	
	const BRect bounds = Bounds();
	
	// Fill with background
	SetHighColor(kPaleGrey);
	FillRect(updateRect);
	
	// Create left frame
	SetHighColor(kDarkGrey);
	startPt.Set(bounds.left, bounds.bottom);
	endPt.Set(bounds.left, bounds.top);
	StrokeLine(startPt, endPt);
	endPt.Set(bounds.right-2, bounds.top);
	StrokeLine(endPt);

	// Create left shadow
	SetHighColor(kBeShadow);
	BRect shadowOutline = bounds;
	shadowOutline.InsetBy(1,1);
	StrokeRect(shadowOutline);
	
	startPt.Set(shadowOutline.left+1, shadowOutline.bottom);
	endPt.Set(shadowOutline.left+1, shadowOutline.top+1);
	StrokeLine(startPt, endPt);
	endPt.Set(shadowOutline.right, shadowOutline.top+1);
	StrokeLine(endPt);
	startPt.Set(shadowOutline.right-1, shadowOutline.top+1);
	endPt.Set(shadowOutline.right-1, shadowOutline.bottom-1);
	StrokeLine(startPt, endPt);
	endPt.Set(shadowOutline.left-2, shadowOutline.bottom-1);
	StrokeLine(endPt);
	
	// Create right hilite
	SetHighColor(kPaleGrey);
	startPt.Set(bounds.right, bounds.top);
	endPt.Set(bounds.right, bounds.bottom);
	StrokeLine(startPt, endPt);
	endPt.Set(bounds.left, bounds.bottom);
	StrokeLine(endPt);
	
	startPt.Set(bounds.right-1, bounds.top+1);
	endPt.Set(bounds.right-1, bounds.bottom-1);
	StrokeLine(startPt, endPt);
	endPt.Set(bounds.left, bounds.bottom-1);
	StrokeLine(endPt);
	
	// Create channel slot
	BRect slot 	= bounds;
	slot.left 	= (bounds.Width()/2) - 3;
	slot.right 	= (bounds.Width()/2) + 2;
	slot.top 	+= 1;
	slot.bottom -= 3;
	SetHighColor(kBlack);
	FillRect(slot);
	
	// Draw slot hilites
	startPt.Set(slot.left, slot.top);
	endPt.Set(slot.left, slot.bottom);
	SetHighColor(kDarkGrey);
	StrokeLine(startPt, endPt);
	slot.top 	+=1;
	slot.left 	= slot.right-2;
	rgb_color dkGrey = {35,35,35,255};
	SetHighColor(dkGrey);
	FillRect(slot);
	
	// Draw ticks
	DrawSliderTicks();
	
	// Draw Sliders
	DrawSliders();
	
	ConstrainClippingRegion( &saveRegion );	
	PopState();
}
예제 #25
0
void
BTextControl::Draw(BRect updateRect)
{
	bool enabled = IsEnabled();
	bool active = fText->IsFocus() && Window()->IsActive();

	BRect rect = fText->Frame();
	rect.InsetBy(-2, -2);

	if (be_control_look != NULL) {
		rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
		uint32 flags = 0;
		if (!enabled)
			flags |= BControlLook::B_DISABLED;
		if (active)
			flags |= BControlLook::B_FOCUSED;
		be_control_look->DrawTextControlBorder(this, rect, updateRect, base,
			flags);

		rect = Bounds();
		rect.right = fDivider - kLabelInputSpacing;
//		rect.right = fText->Frame().left - 2;
//		rect.right -= 3;//be_control_look->DefaultLabelSpacing();
		be_control_look->DrawLabel(this, Label(), rect, updateRect,
			base, flags, BAlignment(fLabelAlign, B_ALIGN_MIDDLE));

		return;
	}

	// outer bevel

	rgb_color noTint = ui_color(B_PANEL_BACKGROUND_COLOR);
	rgb_color lighten1 = tint_color(noTint, B_LIGHTEN_1_TINT);
	rgb_color lighten2 = tint_color(noTint, B_LIGHTEN_2_TINT);
	rgb_color lightenMax = tint_color(noTint, B_LIGHTEN_MAX_TINT);
	rgb_color darken1 = tint_color(noTint, B_DARKEN_1_TINT);
	rgb_color darken2 = tint_color(noTint, B_DARKEN_2_TINT);
	rgb_color darken4 = tint_color(noTint, B_DARKEN_4_TINT);
	rgb_color navigationColor = ui_color(B_KEYBOARD_NAVIGATION_COLOR);

	if (enabled)
		SetHighColor(darken1);
	else
		SetHighColor(noTint);

	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());

	// inner bevel

	rect.InsetBy(1.0f, 1.0f);

	if (active) {
		SetHighColor(navigationColor);
		StrokeRect(rect);
	} else {
		if (enabled)
			SetHighColor(darken4);
		else
			SetHighColor(darken2);

		StrokeLine(rect.LeftTop(), rect.LeftBottom());
		StrokeLine(rect.LeftTop(), rect.RightTop());

		SetHighColor(noTint);
		StrokeLine(BPoint(rect.left + 1.0f, rect.bottom), rect.RightBottom());
		StrokeLine(BPoint(rect.right, rect.top + 1.0f));
	}

	// label

	if (Label()) {
		_ValidateLayoutData();
		font_height& fontHeight = fLayoutData->font_info;

		float y = Bounds().top + (Bounds().Height() + 1 - fontHeight.ascent
			- fontHeight.descent) / 2 + fontHeight.ascent;
		float x;

		float labelWidth = StringWidth(Label());
		switch (fLabelAlign) {
			case B_ALIGN_RIGHT:
				x = fDivider - labelWidth - kLabelInputSpacing;
				break;

			case B_ALIGN_CENTER:
				x = fDivider - labelWidth / 2.0;
				break;

			default:
				x = 0.0;
				break;
		}

		BRect labelArea(x, Bounds().top, x + labelWidth, Bounds().bottom);
		if (x < fDivider && updateRect.Intersects(labelArea)) {
			labelArea.right = fText->Frame().left - kLabelInputSpacing;

			BRegion clipRegion(labelArea);
			ConstrainClippingRegion(&clipRegion);
			SetHighColor(IsEnabled() ? ui_color(B_CONTROL_TEXT_COLOR)
				: tint_color(noTint, B_DISABLED_LABEL_TINT));
			DrawString(Label(), BPoint(x, y));
		}
	}
}
예제 #26
0
void
BSlider::DrawBar()
{
	BRect frame = BarFrame();
	BView *view = OffscreenView();

	if (be_control_look != NULL) {
		uint32 flags = be_control_look->Flags(this);
		rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
		rgb_color rightFillColor = fBarColor;
		rgb_color leftFillColor = fUseFillColor ? fFillColor : fBarColor;
		be_control_look->DrawSliderBar(view, frame, frame, base, leftFillColor,
			rightFillColor, Position(), flags, fOrientation);
		return;
	}

	rgb_color no_tint = ui_color(B_PANEL_BACKGROUND_COLOR);
	rgb_color lightenmax;
	rgb_color darken1;
	rgb_color darken2;
	rgb_color darkenmax;

	rgb_color barColor;
	rgb_color fillColor;

	if (IsEnabled()) {
		lightenmax	= tint_color(no_tint, B_LIGHTEN_MAX_TINT);
		darken1		= tint_color(no_tint, B_DARKEN_1_TINT);
		darken2		= tint_color(no_tint, B_DARKEN_2_TINT);
		darkenmax	= tint_color(no_tint, B_DARKEN_MAX_TINT);
		barColor	= fBarColor;
		fillColor	= fFillColor;
	} else {
		lightenmax	= tint_color(no_tint, B_LIGHTEN_MAX_TINT);
		darken1		= no_tint;
		darken2		= tint_color(no_tint, B_DARKEN_1_TINT);
		darkenmax	= tint_color(no_tint, B_DARKEN_3_TINT);

		barColor.red	= (fBarColor.red + no_tint.red) / 2;
		barColor.green	= (fBarColor.green + no_tint.green) / 2;
		barColor.blue	= (fBarColor.blue + no_tint.blue) / 2;
		barColor.alpha	= 255;

		fillColor.red	= (fFillColor.red + no_tint.red) / 2;
		fillColor.green	= (fFillColor.green + no_tint.green) / 2;
		fillColor.blue	= (fFillColor.blue + no_tint.blue) / 2;
		fillColor.alpha	= 255;
	}

	// exclude the block thumb from the bar filling

	BRect lowerFrame = frame.InsetByCopy(1, 1);
	lowerFrame.top++;
	lowerFrame.left++;
	BRect upperFrame = lowerFrame;
	BRect thumbFrame;

	if (Style() == B_BLOCK_THUMB) {
		thumbFrame = ThumbFrame();

		if (fOrientation == B_HORIZONTAL) {
			lowerFrame.right = thumbFrame.left;
			upperFrame.left = thumbFrame.right;
		} else {
			lowerFrame.top = thumbFrame.bottom;
			upperFrame.bottom = thumbFrame.top;
		}
	} else if (fUseFillColor) {
		if (fOrientation == B_HORIZONTAL) {
			lowerFrame.right = floor(lowerFrame.left - 1 + Position()
				* (lowerFrame.Width() + 1));
			upperFrame.left = lowerFrame.right;
		} else {
			lowerFrame.top = floor(lowerFrame.bottom + 1 - Position()
				* (lowerFrame.Height() + 1));
			upperFrame.bottom = lowerFrame.top;
		}
	}

	view->SetHighColor(barColor);
	view->FillRect(upperFrame);

	if (Style() == B_BLOCK_THUMB || fUseFillColor) {
		if (fUseFillColor)
			view->SetHighColor(fillColor);
		view->FillRect(lowerFrame);
	}

	if (Style() == B_BLOCK_THUMB) {
		// We don't want to stroke the lines over the thumb

		PushState();

		BRegion region;
		GetClippingRegion(&region);
		region.Exclude(thumbFrame);
		ConstrainClippingRegion(&region);
	}

	view->SetHighColor(darken1);
	view->StrokeLine(BPoint(frame.left, frame.top),
					 BPoint(frame.left + 1.0f, frame.top));
	view->StrokeLine(BPoint(frame.left, frame.bottom),
					 BPoint(frame.left + 1.0f, frame.bottom));
	view->StrokeLine(BPoint(frame.right - 1.0f, frame.top),
					 BPoint(frame.right, frame.top));

	view->SetHighColor(darken2);
	view->StrokeLine(BPoint(frame.left + 1.0f, frame.top),
					 BPoint(frame.right - 1.0f, frame.top));
	view->StrokeLine(BPoint(frame.left, frame.bottom - 1.0f),
					 BPoint(frame.left, frame.top + 1.0f));

	view->SetHighColor(lightenmax);
	view->StrokeLine(BPoint(frame.left + 1.0f, frame.bottom),
					 BPoint(frame.right, frame.bottom));
	view->StrokeLine(BPoint(frame.right, frame.bottom - 1.0f),
					 BPoint(frame.right, frame.top + 1.0f));

	frame.InsetBy(1.0f, 1.0f);

	view->SetHighColor(darkenmax);
	view->StrokeLine(BPoint(frame.left, frame.bottom),
					 BPoint(frame.left, frame.top));
	view->StrokeLine(BPoint(frame.left + 1.0f, frame.top),
					 BPoint(frame.right, frame.top));

	if (Style() == B_BLOCK_THUMB)
		PopState();
}