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* 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;
}
/*!
* \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
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;
}
/*! \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());
}
}
void
RemoteView::_DrawThread()
{
RemoteMessage reply(NULL, fSendBuffer);
RemoteMessage message(fReceiveBuffer, NULL);
// cursor
BPoint cursorHotSpot(0, 0);
while (!fStopThread) {
uint16 code;
status_t status = message.NextMessage(code);
if (status != B_OK) {
TRACE_ERROR("failed to read message from receiver\n");
break;
}
TRACE("code %u with %ld bytes data\n", code, message.DataLeft());
BAutolock locker(this->Looper());
if (!locker.IsLocked())
break;
// handle stuff that doesn't go to a specicifc engine
switch (code) {
case RP_INIT_CONNECTION:
{
uint16 port;
status_t result = message.Read(port);
if (result != B_OK) {
TRACE_ERROR("failed to read remote port\n");
continue;
}
BNetEndpoint *endpoint = fReceiver->Endpoint();
if (endpoint == NULL) {
TRACE_ERROR("receiver not connected anymore\n");
continue;
}
in_addr remoteHost;
char hostName[MAXHOSTNAMELEN + 1];
BNetAddress address(endpoint->RemoteAddr());
address.GetAddr(remoteHost);
address.GetAddr(hostName, NULL);
address.SetTo(remoteHost, port);
TRACE("connecting to host \"%s\" port %u\n", hostName, port);
result = fSendEndpoint->Connect(address);
if (result != B_OK) {
TRACE_ERROR("failed to connect to host \"%s\" port %u\n",
hostName, port);
continue;
}
BRect bounds = fOffscreenBitmap->Bounds();
reply.Start(RP_UPDATE_DISPLAY_MODE);
reply.Add(bounds.IntegerWidth() + 1);
reply.Add(bounds.IntegerHeight() + 1);
if (reply.Flush() == B_OK)
fIsConnected = true;
continue;
}
case RP_CLOSE_CONNECTION:
{
be_app->PostMessage(B_QUIT_REQUESTED);
continue;
}
case RP_CREATE_STATE:
case RP_DELETE_STATE:
{
uint32 token;
message.Read(token);
if (code == RP_CREATE_STATE)
_CreateState(token);
else
_DeleteState(token);
continue;
}
case RP_SET_CURSOR:
{
BBitmap *bitmap;
BPoint oldHotSpot = cursorHotSpot;
message.Read(cursorHotSpot);
if (message.ReadBitmap(&bitmap) != B_OK)
continue;
delete fCursorBitmap;
fCursorBitmap = bitmap;
Invalidate(fCursorFrame);
BRect bounds = fCursorBitmap->Bounds();
fCursorFrame.right = fCursorFrame.left
+ bounds.IntegerWidth() + 1;
fCursorFrame.bottom = fCursorFrame.bottom
+ bounds.IntegerHeight() + 1;
fCursorFrame.OffsetBy(oldHotSpot - cursorHotSpot);
Invalidate(fCursorFrame);
continue;
}
case RP_SET_CURSOR_VISIBLE:
{
bool wasVisible = fCursorVisible;
message.Read(fCursorVisible);
if (wasVisible != fCursorVisible)
Invalidate(fCursorFrame);
continue;
}
case RP_MOVE_CURSOR_TO:
{
BPoint position;
message.Read(position);
if (fCursorVisible)
Invalidate(fCursorFrame);
fCursorFrame.OffsetTo(position - cursorHotSpot);
Invalidate(fCursorFrame);
continue;
}
case RP_INVALIDATE_RECT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
Invalidate(rect);
continue;
}
case RP_INVALIDATE_REGION:
{
BRegion region;
if (message.ReadRegion(region) != B_OK)
continue;
Invalidate(®ion);
continue;
}
case RP_FILL_REGION_COLOR_NO_CLIPPING:
{
BRegion region;
rgb_color color;
message.ReadRegion(region);
if (message.Read(color) != B_OK)
continue;
fOffscreen->LockLooper();
fOffscreen->SetHighColor(color);
fOffscreen->FillRegion(®ion);
fOffscreen->UnlockLooper();
Invalidate(®ion);
continue;
}
case RP_COPY_RECT_NO_CLIPPING:
{
int32 xOffset, yOffset;
BRect rect;
message.Read(xOffset);
message.Read(yOffset);
if (message.Read(rect) != B_OK)
continue;
BRect dest = rect.OffsetByCopy(xOffset, yOffset);
fOffscreen->LockLooper();
fOffscreen->CopyBits(rect, dest);
fOffscreen->UnlockLooper();
continue;
}
}
uint32 token;
message.Read(token);
engine_state *state = _FindState(token);
if (state == NULL) {
TRACE_ERROR("didn't find state for token %lu\n", token);
continue;
}
BView *offscreen = state->view;
::pattern &pattern = state->pattern;
BRegion &clippingRegion = state->clipping_region;
float &penSize = state->pen_size;
bool &syncDrawing = state->sync_drawing;
BRegion invalidRegion;
BAutolock offscreenLocker(offscreen->Looper());
if (!offscreenLocker.IsLocked())
break;
switch (code) {
case RP_ENABLE_SYNC_DRAWING:
syncDrawing = true;
continue;
case RP_DISABLE_SYNC_DRAWING:
syncDrawing = false;
continue;
case RP_SET_OFFSETS:
{
int32 xOffset, yOffset;
message.Read(xOffset);
if (message.Read(yOffset) != B_OK)
continue;
offscreen->MovePenTo(xOffset, yOffset);
break;
}
case RP_SET_HIGH_COLOR:
case RP_SET_LOW_COLOR:
{
rgb_color color;
if (message.Read(color) != B_OK)
continue;
if (code == RP_SET_HIGH_COLOR)
offscreen->SetHighColor(color);
else
offscreen->SetLowColor(color);
break;
}
case RP_SET_PEN_SIZE:
{
float newPenSize;
if (message.Read(newPenSize) != B_OK)
continue;
offscreen->SetPenSize(newPenSize);
penSize = newPenSize / 2;
break;
}
case RP_SET_STROKE_MODE:
{
cap_mode capMode;
join_mode joinMode;
float miterLimit;
message.Read(capMode);
message.Read(joinMode);
if (message.Read(miterLimit) != B_OK)
continue;
offscreen->SetLineMode(capMode, joinMode, miterLimit);
break;
}
case RP_SET_BLENDING_MODE:
{
source_alpha sourceAlpha;
alpha_function alphaFunction;
message.Read(sourceAlpha);
if (message.Read(alphaFunction) != B_OK)
continue;
offscreen->SetBlendingMode(sourceAlpha, alphaFunction);
break;
}
case RP_SET_PATTERN:
{
if (message.Read(pattern) != B_OK)
continue;
break;
}
case RP_SET_DRAWING_MODE:
{
drawing_mode drawingMode;
if (message.Read(drawingMode) != B_OK)
continue;
offscreen->SetDrawingMode(drawingMode);
break;
}
case RP_SET_FONT:
{
BFont font;
if (message.ReadFontState(font) != B_OK)
continue;
offscreen->SetFont(&font);
break;
}
case RP_CONSTRAIN_CLIPPING_REGION:
{
if (message.ReadRegion(clippingRegion) != B_OK)
continue;
offscreen->ConstrainClippingRegion(&clippingRegion);
break;
}
case RP_INVERT_RECT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
offscreen->InvertRect(rect);
invalidRegion.Include(rect);
break;
}
case RP_DRAW_BITMAP:
{
BBitmap *bitmap;
BRect bitmapRect, viewRect;
uint32 options;
message.Read(bitmapRect);
message.Read(viewRect);
message.Read(options);
if (message.ReadBitmap(&bitmap) != B_OK || bitmap == NULL)
continue;
offscreen->DrawBitmap(bitmap, bitmapRect, viewRect, options);
invalidRegion.Include(viewRect);
delete bitmap;
break;
}
case RP_DRAW_BITMAP_RECTS:
{
color_space colorSpace;
int32 rectCount;
uint32 flags, options;
message.Read(options);
message.Read(colorSpace);
message.Read(flags);
message.Read(rectCount);
for (int32 i = 0; i < rectCount; i++) {
BBitmap *bitmap;
BRect viewRect;
message.Read(viewRect);
if (message.ReadBitmap(&bitmap, true, colorSpace,
flags) != B_OK || bitmap == NULL) {
continue;
}
offscreen->DrawBitmap(bitmap, bitmap->Bounds(), viewRect,
options);
invalidRegion.Include(viewRect);
delete bitmap;
}
break;
}
case RP_STROKE_ARC:
case RP_FILL_ARC:
case RP_FILL_ARC_GRADIENT:
{
BRect rect;
float angle, span;
message.Read(rect);
message.Read(angle);
if (message.Read(span) != B_OK)
continue;
if (code == RP_STROKE_ARC) {
offscreen->StrokeArc(rect, angle, span, pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_ARC)
offscreen->FillArc(rect, angle, span, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillArc(rect, angle, span, *gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_BEZIER:
case RP_FILL_BEZIER:
case RP_FILL_BEZIER_GRADIENT:
{
BPoint points[4];
if (message.ReadList(points, 4) != B_OK)
continue;
BRect bounds = _BuildInvalidateRect(points, 4);
if (code == RP_STROKE_BEZIER) {
offscreen->StrokeBezier(points, pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_BEZIER)
offscreen->FillBezier(points, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillBezier(points, *gradient);
delete gradient;
}
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_ELLIPSE:
case RP_FILL_ELLIPSE:
case RP_FILL_ELLIPSE_GRADIENT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
if (code == RP_STROKE_ELLIPSE) {
offscreen->StrokeEllipse(rect, pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_ELLIPSE)
offscreen->FillEllipse(rect, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillEllipse(rect, *gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_POLYGON:
case RP_FILL_POLYGON:
case RP_FILL_POLYGON_GRADIENT:
{
BRect bounds;
bool closed;
int32 numPoints;
message.Read(bounds);
message.Read(closed);
if (message.Read(numPoints) != B_OK)
continue;
BPoint points[numPoints];
for (int32 i = 0; i < numPoints; i++)
message.Read(points[i]);
if (code == RP_STROKE_POLYGON) {
offscreen->StrokePolygon(points, numPoints, bounds, closed,
pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_POLYGON)
offscreen->FillPolygon(points, numPoints, bounds, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillPolygon(points, numPoints, bounds,
*gradient);
delete gradient;
}
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_RECT:
case RP_FILL_RECT:
case RP_FILL_RECT_GRADIENT:
{
BRect rect;
if (message.Read(rect) != B_OK)
continue;
if (code == RP_STROKE_RECT) {
offscreen->StrokeRect(rect, pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_RECT)
offscreen->FillRect(rect, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillRect(rect, *gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_ROUND_RECT:
case RP_FILL_ROUND_RECT:
case RP_FILL_ROUND_RECT_GRADIENT:
{
BRect rect;
float xRadius, yRadius;
message.Read(rect);
message.Read(xRadius);
if (message.Read(yRadius) != B_OK)
continue;
if (code == RP_STROKE_ROUND_RECT) {
offscreen->StrokeRoundRect(rect, xRadius, yRadius,
pattern);
rect.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_ROUND_RECT)
offscreen->FillRoundRect(rect, xRadius, yRadius, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillRoundRect(rect, xRadius, yRadius,
*gradient);
delete gradient;
}
invalidRegion.Include(rect);
break;
}
case RP_STROKE_SHAPE:
case RP_FILL_SHAPE:
case RP_FILL_SHAPE_GRADIENT:
{
BRect bounds;
int32 opCount, pointCount;
message.Read(bounds);
if (message.Read(opCount) != B_OK)
continue;
BMessage archive;
for (int32 i = 0; i < opCount; i++) {
int32 op;
message.Read(op);
archive.AddInt32("ops", op);
}
if (message.Read(pointCount) != B_OK)
continue;
for (int32 i = 0; i < pointCount; i++) {
BPoint point;
message.Read(point);
archive.AddPoint("pts", point);
}
BPoint offset;
message.Read(offset);
float scale;
if (message.Read(scale) != B_OK)
continue;
offscreen->PushState();
offscreen->MovePenTo(offset);
offscreen->SetScale(scale);
BShape shape(&archive);
if (code == RP_STROKE_SHAPE) {
offscreen->StrokeShape(&shape, pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_SHAPE)
offscreen->FillShape(&shape, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK) {
offscreen->PopState();
continue;
}
offscreen->FillShape(&shape, *gradient);
delete gradient;
}
offscreen->PopState();
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_TRIANGLE:
case RP_FILL_TRIANGLE:
case RP_FILL_TRIANGLE_GRADIENT:
{
BRect bounds;
BPoint points[3];
message.ReadList(points, 3);
if (message.Read(bounds) != B_OK)
continue;
if (code == RP_STROKE_TRIANGLE) {
offscreen->StrokeTriangle(points[0], points[1], points[2],
bounds, pattern);
bounds.InsetBy(-penSize, -penSize);
} else if (code == RP_FILL_TRIANGLE) {
offscreen->FillTriangle(points[0], points[1], points[2],
bounds, pattern);
} else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillTriangle(points[0], points[1], points[2],
bounds, *gradient);
delete gradient;
}
invalidRegion.Include(bounds);
break;
}
case RP_STROKE_LINE:
{
BPoint points[2];
if (message.ReadList(points, 2) != B_OK)
continue;
offscreen->StrokeLine(points[0], points[1], pattern);
BRect bounds = _BuildInvalidateRect(points, 2);
invalidRegion.Include(bounds.InsetBySelf(-penSize, -penSize));
break;
}
case RP_STROKE_LINE_ARRAY:
{
int32 numLines;
if (message.Read(numLines) != B_OK)
continue;
BRect bounds;
offscreen->BeginLineArray(numLines);
for (int32 i = 0; i < numLines; i++) {
rgb_color color;
BPoint start, end;
message.ReadArrayLine(start, end, color);
offscreen->AddLine(start, end, color);
bounds.left = min_c(bounds.left, min_c(start.x, end.x));
bounds.top = min_c(bounds.top, min_c(start.y, end.y));
bounds.right = max_c(bounds.right, max_c(start.x, end.x));
bounds.bottom = max_c(bounds.bottom, max_c(start.y, end.y));
}
offscreen->EndLineArray();
invalidRegion.Include(bounds);
break;
}
case RP_FILL_REGION:
case RP_FILL_REGION_GRADIENT:
{
BRegion region;
if (message.ReadRegion(region) != B_OK)
continue;
if (code == RP_FILL_REGION)
offscreen->FillRegion(®ion, pattern);
else {
BGradient *gradient;
if (message.ReadGradient(&gradient) != B_OK)
continue;
offscreen->FillRegion(®ion, *gradient);
delete gradient;
}
invalidRegion.Include(®ion);
break;
}
case RP_STROKE_POINT_COLOR:
{
BPoint point;
rgb_color color;
message.Read(point);
if (message.Read(color) != B_OK)
continue;
rgb_color oldColor = offscreen->HighColor();
offscreen->SetHighColor(color);
offscreen->StrokeLine(point, point);
offscreen->SetHighColor(oldColor);
invalidRegion.Include(
BRect(point, point).InsetBySelf(-penSize, -penSize));
break;
}
case RP_STROKE_LINE_1PX_COLOR:
{
BPoint points[2];
rgb_color color;
message.ReadList(points, 2);
if (message.Read(color) != B_OK)
continue;
float oldSize = offscreen->PenSize();
rgb_color oldColor = offscreen->HighColor();
drawing_mode oldMode = offscreen->DrawingMode();
offscreen->SetPenSize(1);
offscreen->SetHighColor(color);
offscreen->SetDrawingMode(B_OP_OVER);
offscreen->StrokeLine(points[0], points[1]);
offscreen->SetDrawingMode(oldMode);
offscreen->SetHighColor(oldColor);
offscreen->SetPenSize(oldSize);
invalidRegion.Include(_BuildInvalidateRect(points, 2));
break;
}
case RP_STROKE_RECT_1PX_COLOR:
case RP_FILL_RECT_COLOR:
{
BRect rect;
rgb_color color;
message.Read(rect);
if (message.Read(color) != B_OK)
continue;
rgb_color oldColor = offscreen->HighColor();
offscreen->SetHighColor(color);
if (code == RP_STROKE_RECT_1PX_COLOR) {
float oldSize = PenSize();
offscreen->SetPenSize(1);
offscreen->StrokeRect(rect);
offscreen->SetPenSize(oldSize);
} else
offscreen->FillRect(rect);
offscreen->SetHighColor(oldColor);
invalidRegion.Include(rect);
break;
}
case RP_DRAW_STRING:
{
BPoint point;
size_t length;
char *string;
bool hasDelta;
message.Read(point);
message.ReadString(&string, length);
if (message.Read(hasDelta) != B_OK) {
free(string);
continue;
}
if (hasDelta) {
escapement_delta delta[length];
message.ReadList(delta, length);
offscreen->DrawString(string, point, delta);
} else
offscreen->DrawString(string, point);
free(string);
reply.Start(RP_DRAW_STRING_RESULT);
reply.Add(token);
reply.Add(offscreen->PenLocation());
reply.Flush();
font_height height;
offscreen->GetFontHeight(&height);
BRect bounds(point, offscreen->PenLocation());
bounds.top -= height.ascent;
bounds.bottom += height.descent;
invalidRegion.Include(bounds);
break;
}
case RP_DRAW_STRING_WITH_OFFSETS:
{
size_t length;
char *string;
message.ReadString(&string, length);
int32 count = UTF8CountChars(string, length);
BPoint offsets[count];
if (message.ReadList(offsets, count) != B_OK) {
free(string);
continue;
}
offscreen->DrawString(string, offsets, count);
free(string);
reply.Start(RP_DRAW_STRING_RESULT);
reply.Add(token);
reply.Add(offscreen->PenLocation());
reply.Flush();
BFont font;
offscreen->GetFont(&font);
BRect boxes[count];
font.GetBoundingBoxesAsGlyphs(string, count, B_SCREEN_METRIC,
boxes);
font_height height;
offscreen->GetFontHeight(&height);
for (int32 i = 0; i < count; i++) {
// TODO: validate
boxes[i].OffsetBy(offsets[i] + BPoint(0, -height.ascent));
invalidRegion.Include(boxes[i]);
}
break;
}
case RP_READ_BITMAP:
{
BRect bounds;
bool drawCursor;
message.Read(bounds);
if (message.Read(drawCursor) != B_OK)
continue;
// TODO: support the drawCursor flag
BBitmap bitmap(bounds, B_BITMAP_NO_SERVER_LINK, B_RGB32);
bitmap.ImportBits(fOffscreenBitmap, bounds.LeftTop(),
BPoint(0, 0), bounds.IntegerWidth() + 1,
bounds.IntegerHeight() + 1);
reply.Start(RP_READ_BITMAP_RESULT);
reply.Add(token);
reply.AddBitmap(&bitmap);
reply.Flush();
break;
}
default:
TRACE_ERROR("unknown protocol code: %u\n", code);
break;
}
if (syncDrawing) {
offscreen->Sync();
Invalidate(&invalidRegion);
}
}
}
void
TouchpadView::DrawSliders()
{
BView* view;
if (fOffScreenView != NULL)
view = fOffScreenView;
else
view = this;
if (!LockLooper())
return;
if (fOffScreenBitmap->Lock()) {
view->SetHighColor(ui_color(B_PANEL_BACKGROUND_COLOR));
view->FillRect(Bounds());
view->SetHighColor(100, 100, 100);
view->FillRoundRect(fPadRect, 4, 4);
int32 dragSize = 3; // half drag size
// scroll areas
view->SetHighColor(145, 100, 100);
BRect rightRect(fPadRect.left + fXScrollRange, fPadRect.top,
fPadRect.right, fPadRect.bottom);
view->FillRoundRect(rightRect, 4, 4);
BRect bottomRect(fPadRect.left, fPadRect.top + fYScrollRange,
fPadRect.right, fPadRect.bottom);
view->FillRoundRect(bottomRect, 4, 4);
// Stroke Rect
view->SetHighColor(100, 100, 100);
view->SetPenSize(2);
view->StrokeRoundRect(fPadRect, 4, 4);
// x scroll range line
view->SetHighColor(200, 0, 0);
view->StrokeLine(BPoint(fPadRect.left + fXScrollRange, fPadRect.top),
BPoint(fPadRect.left + fXScrollRange, fPadRect.bottom));
fXScrollDragZone = BRect(fPadRect.left + fXScrollRange - dragSize,
fPadRect.top - dragSize, fPadRect.left + fXScrollRange + dragSize,
fPadRect.bottom + dragSize);
fXScrollDragZone1 = BRect(fPadRect.left + fXScrollRange - dragSize,
fPadRect.top - dragSize, fPadRect.left + fXScrollRange + dragSize,
fPadRect.top + dragSize);
view->FillRect(fXScrollDragZone1);
fXScrollDragZone2 = BRect(fPadRect.left + fXScrollRange - dragSize,
fPadRect.bottom - dragSize,
fPadRect.left + fXScrollRange + dragSize,
fPadRect.bottom + dragSize);
view->FillRect(fXScrollDragZone2);
// y scroll range line
view->StrokeLine(BPoint(fPadRect.left, fPadRect.top + fYScrollRange),
BPoint(fPadRect.right, fPadRect.top + fYScrollRange));
fYScrollDragZone = BRect(fPadRect.left - dragSize,
fPadRect.top + fYScrollRange - dragSize,
fPadRect.right + dragSize,
fPadRect.top + fYScrollRange + dragSize);
fYScrollDragZone1 = BRect(fPadRect.left - dragSize,
fPadRect.top + fYScrollRange - dragSize, fPadRect.left + dragSize,
fPadRect.top + fYScrollRange + dragSize);
view->FillRect(fYScrollDragZone1);
fYScrollDragZone2 = BRect(fPadRect.right - dragSize,
fPadRect.top + fYScrollRange - dragSize, fPadRect.right + dragSize,
fPadRect.top + fYScrollRange + dragSize);
view->FillRect(fYScrollDragZone2);
fOffScreenView->Sync();
fOffScreenBitmap->Unlock();
DrawBitmap(fOffScreenBitmap, B_ORIGIN);
}
UnlockLooper();
}
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--;
}
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());
uint32 x = viewValues->Start() * step;
BShape shape;
bool first = true;
for (uint32 i = viewValues->Start(); i < steps; x += step, i++) {
float y = _PositionForValue(source, values,
viewValues->ValueAt(i));
if (first) {
shape.MoveTo(BPoint(x, y));
first = false;
} else
shape.LineTo(BPoint(x, y));
}
view->SetHighColor(source->Color());
view->SetLineMode(B_BUTT_CAP, B_ROUND_JOIN);
view->MovePenTo(B_ORIGIN);
view->StrokeShape(&shape);
}
// TODO: add marks when an app started or quit
view->Sync();
if (fOffscreen != NULL) {
fOffscreen->Unlock();
DrawBitmap(fOffscreen, outerFrame.LeftTop());
}
}
//Build up GUI eg MenuBar
void ImmersiveVideoWindow::_InitWindow(void) {
BRect r;
BMenu *menu;
BMenuItem *item;
//++++MenuBar++++
r = Bounds();
menubar = new BMenuBar(r, "menu_bar");
// Add File menu to menu bar
menu = new BMenu("File");
// menu->AddItem(new BMenuItem("New", new BMessage(MENU_FILE_NEW), 'N'));
menu->AddItem(item=new BMenuItem("Open" B_UTF8_ELLIPSIS,new BMessage(MENU_FILE_OPEN), 'O'));
item->SetTarget(be_app);
menu->AddItem(item=new BMenuItem("Close", new BMessage(MENU_FILE_CLOSE), 'W'));
item->SetTarget(be_app);
menu->AddSeparatorItem();
menu->AddItem(saveitem=new BMenuItem("Save", new BMessage(MENU_FILE_SAVE), 'S'));
// saveitem->SetEnabled(false);
//saveitem->SetTarget(be_app);
//menu->AddItem(item=new BMenuItem("Save as" B_UTF8_ELLIPSIS,new BMessage(MENU_FILE_SAVEAS)));
//item->SetTarget(be_app);
menu->AddSeparatorItem();
menu->AddItem(item=new BMenuItem("Export" B_UTF8_ELLIPSIS,new BMessage(MENU_FILE_EXPORT)));
item->SetTarget(be_app);
menu->AddSeparatorItem();
menu->AddItem(item=new BMenuItem("Page Setup" B_UTF8_ELLIPSIS,new BMessage(MENU_FILE_PAGESETUP)));
item->SetEnabled(false);
item->SetTarget(be_app);
menu->AddItem(item=new BMenuItem("Print" B_UTF8_ELLIPSIS,new BMessage(MENU_FILE_PRINT), 'P'));
item->SetTarget(be_app);
item->SetEnabled(false);
menu->AddSeparatorItem();
menu->AddItem(item=new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED), 'Q'));
item->SetTarget(be_app);
menubar->AddItem(menu);
// Add the Edit menu to the menu bar
edit = new BMenu("Edit");
edit->AddItem(item=new BMenuItem("Undo", new BMessage(B_UNDO), 'Z'));
// edit->AddItem(item=new BMenuItem("Redo", new BMessage(B_REDO), 'Z'));
edit->AddSeparatorItem();
edit->AddItem(item=new BMenuItem("Cut", new BMessage(B_CUT), 'X'));
edit->AddItem(item=new BMenuItem("Copy", new BMessage(B_COPY), 'C'));
edit->AddItem(item=new BMenuItem("Paste", new BMessage(B_PASTE), 'V'));
edit->AddSeparatorItem();
edit->AddItem(item=new BMenuItem("Preferences", new BMessage(MENU_EDIT_PREFERENCES), 'A'));
menubar->AddItem(edit);
// Attach the menu bar to he window
AddChild(menubar);
//----MenuBar----
//++++GUI++++
//+++BackView+++
BRect background= Bounds();
background.top = menubar->Bounds().bottom + 1.0;
BView *backView=new BView(background,"hintergrund",B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_PULSE_NEEDED);
AddChild(backView);
backView->SetViewColor(216,216,216);
//---BackView---
//+++PluginListe+++
BRect pluginListFrame = background;
pluginListFrame.right -= B_V_SCROLL_BAR_WIDTH;
pluginListFrame.bottom -= 180;
//**nur notwendig wenn wir unten ein Scrollbar einführen wollen
// pluginListFrame.bottom -= B_V_SCROLL_BAR_WIDTH;
pluginListFrame.InsetBy(2,2);
listView = new BListView(pluginListFrame, "plugin_view", B_SINGLE_SELECTION_LIST,
B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_PULSE_NEEDED);
scrollView = new BScrollView("scroll_view", listView, B_FOLLOW_ALL_SIDES, B_SUBPIXEL_PRECISE, false, true);
backView->AddChild(scrollView);
listView->MakeFocus(true);
listView->SetSelectionMessage(new BMessage(PLUGINLIST_SELECTION_CHANGED));
//---PluginListe---
//+++Originalgrößen View+++
BRect pictureSize = background;
pictureSize.top=(pluginListFrame.bottom+5);
pictureSize.bottom -=115;
BBox *pictureSizeView=new BBox(pictureSize,"pictureView1",B_FOLLOW_BOTTOM|B_FOLLOW_LEFT_RIGHT);
backView->AddChild(pictureSizeView);
pictureSizeView->SetLabel(new BStringView(BRect(10,0,50,20),"Label","Originalgröße:"));
BStringView *label1=new BStringView(BRect(5,20,45,35),"Label1","Width:", B_FOLLOW_BOTTOM|B_FOLLOW_LEFT , B_WILL_DRAW|B_PULSE_NEEDED);
BStringView *unit1=new BStringView(BRect(pictureSize.Width()-75,20,pictureSize.Width()-60,35),"Unit1","px", B_FOLLOW_BOTTOM|B_FOLLOW_RIGHT , B_WILL_DRAW|B_PULSE_NEEDED);
inputWidth=new BStringView(BRect(65,20,pictureSize.Width()-80,35),"iWidth","",B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_PULSE_NEEDED);
BStringView *label2=new BStringView(BRect(5,40,45,55),"Label2","Height:", B_FOLLOW_BOTTOM|B_FOLLOW_LEFT, B_WILL_DRAW|B_PULSE_NEEDED);
BStringView *unit2=new BStringView(BRect(pictureSize.Width()-75,40,pictureSize.Width()-60,55),"Unit2","px", B_FOLLOW_BOTTOM|B_FOLLOW_RIGHT , B_WILL_DRAW|B_PULSE_NEEDED);
inputHeight=new BStringView(BRect(65,40,pictureSize.Width()-80,55),"iHeight","",B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_PULSE_NEEDED);
pictureSizeView->AddChild(label1);
pictureSizeView->AddChild(inputHeight);
pictureSizeView->AddChild(unit1);
inputHeight->SetViewColor(200,200,200,255);
inputHeight->SetDrawingMode(B_OP_OVER);
// (inputHeight->TextView())->MakeEditable(false);
pictureSizeView->AddChild(label2);
pictureSizeView->AddChild(inputWidth);
pictureSizeView->AddChild(unit2);
inputWidth->SetViewColor(200,200,200,255);
inputWidth->SetDrawingMode(B_OP_OVER);
// (inputWidth->TextView())->MakeEditable(false);
//---Originalgrößen View---
//+++Neue Größe View+++
BRect newPictureSize = background;
newPictureSize.top=(pictureSize.bottom+3);
newPictureSize.bottom -=50;
BBox *newPictureSizeView=new BBox(newPictureSize,"pictureView2",B_FOLLOW_BOTTOM|B_FOLLOW_LEFT_RIGHT);
newPictureSizeView->SetLabel(new BStringView(BRect(10,0,50,20),"Label","Neue Größe:"));
outputWidth=new BTextControl(BRect(5,15,newPictureSize.Width()-80,20),"oWidth","Width:","",new BMessage(OUTPUT_WIDTH_CHANGED),B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_PULSE_NEEDED);
outputHeight=new BTextControl(BRect(5,35,newPictureSize.Width()-80,20),"oHeight","Height:","",new BMessage(OUTPUT_HEIGHT_CHANGED),B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_PULSE_NEEDED);
//Die Maseinheiten auswahl...
BMenu *messureMenu=new BMenu("px",B_ITEMS_IN_COLUMN);
messureMenu->SetRadioMode(true);
messureMenu->SetLabelFromMarked(true);
messureMenu->AddItem(item=new BMenuItem("px",new BMessage(MESSURE_MENU_PIXEL)));
item->SetMarked(true);
messureMenu->AddItem(item=new BMenuItem("%",new BMessage(MESSURE_MENU_PERCENT)));
BMenuField *messureKind=new BMenuField(BRect(newPictureSize.Width()-40,25,newPictureSize.Width()-5,40),"messureKind",NULL,messureMenu,B_FOLLOW_BOTTOM|B_FOLLOW_RIGHT);
BRect rect=BRect(newPictureSize.Width()-75,20,newPictureSize.Width()-45,50);
BView *tmpView = new BView(rect, "temp", B_FOLLOW_NONE, B_WILL_DRAW );
// der Verknüpfungsknop
AddChild(tmpView);
//create on picture
rgb_color back=backView->ViewColor();
//back.alpha=255;
BPicture *on;
tmpView->BeginPicture(new BPicture);
tmpView->SetHighColor(back);
tmpView->FillRect(tmpView->Bounds());
tmpView->BeginLineArray(7);
tmpView->AddLine(BPoint(0,3),BPoint(15,3),black);
tmpView->AddLine(BPoint(0,3),BPoint(5,0),black);
tmpView->AddLine(BPoint(0,3),BPoint(5,6),black);
tmpView->AddLine(BPoint(15,3),BPoint(15,27),black);
tmpView->AddLine(BPoint(0,27),BPoint(15,27),black);
tmpView->AddLine(BPoint(0,27),BPoint(5,24),black);
tmpView->AddLine(BPoint(0,27),BPoint(5,30),black);
tmpView->EndLineArray();
on = tmpView->EndPicture();
//create off picture
BPicture *off;
tmpView->BeginPicture(new BPicture);
tmpView->SetHighColor(back);
tmpView->FillRect(tmpView->Bounds());
tmpView->BeginLineArray(8);
tmpView->AddLine(BPoint(0,3),BPoint(15,3),black);
tmpView->AddLine(BPoint(0,3),BPoint(5,0),black);
tmpView->AddLine(BPoint(0,3),BPoint(5,6),black);
tmpView->AddLine(BPoint(15,3),BPoint(15,10),black);
tmpView->AddLine(BPoint(15,20),BPoint(15,27),black);
tmpView->AddLine(BPoint(0,27),BPoint(15,27),black);
tmpView->AddLine(BPoint(0,27),BPoint(5,24),black);
tmpView->AddLine(BPoint(0,27),BPoint(5,30),black);
tmpView->EndLineArray();
tmpView->SetPenSize(1.5);
tmpView->SetHighColor(red);
tmpView->StrokeArc(BPoint(15,7),4,2,180,180);
tmpView->StrokeArc(BPoint(15,23),4,2,0,180);
off = tmpView->EndPicture();
//get rid of tmpView
RemoveChild(tmpView);
delete tmpView;
depent = new BPictureButton(rect,"concate", on, off, NULL,B_TWO_STATE_BUTTON,B_FOLLOW_BOTTOM|B_FOLLOW_RIGHT);
newPictureSizeView->AddChild(outputHeight);
newPictureSizeView->AddChild(outputWidth);
newPictureSizeView->AddChild(depent);
newPictureSizeView->AddChild(messureKind);
backView->AddChild(newPictureSizeView);
// BButton *testButton=new BButton(BRect(10,Bounds().Height()-45,70,Bounds().Height()-25),"TestButton","Test",new BMessage(TEST_REQUEST),B_FOLLOW_BOTTOM);
BButton *testButton=new BButton(BRect(Bounds().Width()-60,Bounds().Height()-45,Bounds().Width()-7,Bounds().Height()-25),"TestButton","Berechnen",new BMessage(TEST_REQUEST),B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
// BButton *speichernButton=new BButton(BRect(Bounds().Width()-70,Bounds().Height()-45,Bounds().Width()-10,Bounds().Height()-25),"SaveButton","Save",new BMessage(TEST_REQUEST),B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
backView->AddChild(testButton);
// backView->AddChild(speichernButton);
//---Neue Größe View---
pluginWindow=NULL;
LoadPlugins();
}
