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;
}
void KlondikeView::_LoadBitmaps()
{
BString suits[] = {
"spade",
"heart",
"club",
"diamond"
};
// load images
BString filename;
for (short i = 0; i < CARDS_IN_SUIT; i++) {
for (short j = 0; j < 4; j++) {
filename = "";
filename << "Artwork/" << i + 1 << "_" << suits[j] << ".png";
fCards[j * CARDS_IN_SUIT + i]
= BTranslationUtils::GetBitmap('rGFX', filename);
}
}
fBack[0] = BTranslationUtils::GetBitmap('rGFX', "Artwork/back.png");
fEmpty = BTranslationUtils::GetBitmap('rGFX', "Artwork/empty.png");
// load audio
fResources = be_app->AppResources();
fShuffle = _LoadSound("Artwork/shuffle.wav");
fFanfare = _LoadSound("Artwork/fanfare.wav");
// cache multiple backs in a row
for (short i = 1; i < CACHED_BACKS; i++) {
fBack[i] = new BBitmap(BRect(0, 0, CARD_WIDTH - 1,
CARD_HEIGHT + i * 18), fBack[0]->ColorSpace(), true);
BView* fBackView = new BView(fBack[i]->Bounds(), NULL, 0, 0);
BRect destRect = fBack[0]->Bounds();
fBack[i]->AddChild(fBackView);
fBack[i]->Lock();
fBackView->SetDrawingMode(B_OP_COPY);
fBackView->DrawBitmap(fBack[0], destRect);
destRect.top = i * 18;
destRect.bottom = destRect.top + CARD_HEIGHT;
fBackView->DrawBitmap(fBack[0], destRect);
fBackView->SetDrawingMode(B_OP_ALPHA);
for (short j = 0; j < i + 1; j++) {
destRect.top = j * 18;
destRect.bottom = destRect.top + CARD_HEIGHT;
fBackView->DrawBitmap(fBack[0], destRect);
}
fBackView->Sync();
fBack[i]->Unlock();
}
Invalidate();
}
int targatobpic(
const unsigned char* targa, int targasize,
BPicture* picture)
{
BRect frame(0,0,100,100); // arbitraire
BBitmap *bitmap;
BView *view;
BWindow *window;
bitmap=targatobbitmap(targa,targasize);
if(!bitmap) return -1;
window=new BWindow(frame,NULL,B_MODAL_WINDOW,0);
view=new BView(frame,NULL,B_FOLLOW_NONE,0);
window->AddChild(view);
view->BeginPicture(picture);
view->DrawBitmap(bitmap);
view->EndPicture();
delete bitmap;
delete window;
return 0;
}
// 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;
}
void BochsView::DrawBitmap(const BBitmap *aBitmap, BPoint where)
{
backing_store->Lock();
backing_view->DrawBitmap(aBitmap,where);
backing_store->Unlock();
BRect r = aBitmap->Bounds();
r.OffsetBy(where);
Invalidate(r);
}
status_t
MakeScreenshot(BBitmap **here)
{
status_t err;
BScreen bs;
BWindow *win;
BBitmap *shot;
BBitmap *scaledBmp = NULL;
be_app->Lock();
win = be_app->WindowAt(0);
if (win) {
win->Lock();
win->Hide();
win->Unlock();
}
snooze(500000);
err = bs.GetBitmap(&shot);
if (!err) {
BRect scaledBounds(0,0,640-1,480-1);
scaledBmp = new BBitmap(scaledBounds, B_BITMAP_ACCEPTS_VIEWS, B_RGB32/*shot->ColorSpace()*/);
err = scaledBmp->InitCheck();
if (!err) {
err = ENOSYS;
#ifdef B_ZETA_VERSION
err = ScaleBitmap(*shot, *scaledBmp);
#endif
if (err) {
// filtered scaling didn't work, do it manually
BView *v = new BView(scaledBounds, "scaleview", B_FOLLOW_NONE, 0);
scaledBmp->AddChild(v);
v->LockLooper();
v->DrawBitmap(shot);
v->Sync();
v->UnlockLooper();
scaledBmp->RemoveChild(v);
delete v;
err = B_OK;
}
}
delete shot;
}
if (win) {
win->Lock();
win->Show();
win->Unlock();
}
be_app->Unlock();
if (err)
return err;
*here = scaledBmp;
return B_OK;
}
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();
}
}
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;
}
BBitmap *ConvertTo32bit( BBitmap *bitmap )
{
// printf( "CS: %d\n", bitmap->ColorSpace() );
if( (bitmap->ColorSpace()==B_RGB32) || (bitmap->ColorSpace()==B_RGBA32) )
return new BBitmap( bitmap );
BBitmap *bitmap_32bit = new BBitmap( bitmap->Bounds(), B_RGBA32, true );
BView *view = new BView( bitmap->Bounds(), "", 0, 0 );
bitmap_32bit->AddChild( view );
bitmap_32bit->Lock();
view->DrawBitmap( bitmap );
bitmap_32bit->Unlock();
return bitmap_32bit;
}
void
EntryMenuItem::DrawContent()
{
BView* view = Menu();
BPoint pos(view->PenLocation());
if (fSmallIcon == NULL) {
fSmallIcon = LoadIcon(); // load on demand
}
view->MovePenBy(kTextIndent, 0);
BMenuItem::DrawContent();
if (fSmallIcon) {
view->SetDrawingMode(B_OP_OVER);
view->DrawBitmap(fSmallIcon, pos);
}
}
// GetClipping -- this will return NULL if the user hasn't selected any region of
// the screen. If she has, it will return a BBitmap representing that
// selection. You MUST delete it. It's not mine.
// Anything else, it returns NULL.
BBitmap * PictureViewer::GetClipping() {
if (thePic == NULL) return NULL;
if (clipping == false) return NULL;
BBitmap *dragImage = new BBitmap(BRect(0,0,clippingRegion.Width(),clippingRegion.Height()), thePic->ColorSpace(),true,false);
BView *tempView = new BView(dragImage->Bounds(),"yo",0,0);
dragImage->AddChild(tempView);
dragImage->Lock();
tempView->SetViewColor(0,0,0);
float left = -clippingRegion.left;
float top = -clippingRegion.top;
tempView->MovePenTo( left, top);
tempView->DrawBitmap(thePic);
dragImage->Unlock();
dragImage->RemoveChild(tempView);
delete tempView;
return dragImage;
}
void
BitmapView::ConstrainBitmap(void)
{
if (!fBitmap || fMaxWidth < 1 || fMaxHeight < 1)
return;
BRect r = ScaleRectToFit(fBitmap->Bounds(), BRect(0, 0, fMaxWidth - 1, fMaxHeight - 1));
r.OffsetTo(0, 0);
BBitmap *scaled = new BBitmap(r, fBitmap->ColorSpace(), true);
BView *view = new BView(r, "drawview", 0, 0);
scaled->Lock();
scaled->AddChild(view);
view->DrawBitmap(fBitmap, fBitmap->Bounds(), scaled->Bounds());
scaled->Unlock();
delete fBitmap;
fBitmap = new BBitmap(scaled, false);
}
// _ConvertToRGB32
BBitmap*
IconButton::_ConvertToRGB32(const BBitmap* bitmap) const
{
BBitmap* convertedBitmap = new(nothrow) BBitmap(bitmap->Bounds(), B_BITMAP_ACCEPTS_VIEWS, B_RGBA32);
if (convertedBitmap && convertedBitmap->IsValid()) {
memset(convertedBitmap->Bits(), 0, convertedBitmap->BitsLength());
BView* helper = new BView(bitmap->Bounds(), "helper",
B_FOLLOW_NONE, B_WILL_DRAW);
if (convertedBitmap->Lock()) {
convertedBitmap->AddChild(helper);
helper->SetDrawingMode(B_OP_OVER);
helper->DrawBitmap(bitmap, BPoint(0.0, 0.0));
helper->Sync();
convertedBitmap->Unlock();
}
} else {
delete convertedBitmap;
convertedBitmap = NULL;
}
return convertedBitmap;
}
// ToolboxWindow::InitWindow -- Initialization Commands here
void ToolboxWindow::InitWindow(void)
{
BRect r;
r = Bounds();
// Add Controls
// Toolbar
//int ToolbarButtonMargin = 2;
//int ToolbarButtonWidth = 22;
//int ButtonGap = 1;
// StringView Button
BRect BitmapFrame (BRect(0,0,23,23));
BPicture *tmpBPicture;
BPicture *tmpBPicture2;
BView *tmpBPictureView = new BView(BitmapFrame, "tmpBPictureView",B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW | B_NAVIGABLE);
rgb_color toolbar_button_background = { 255, 255, 255, 0 };
AddChild(tmpBPictureView);
BBitmap *stringviewpicture = new BBitmap(BitmapFrame,B_RGB32);
stringviewpicture->SetBits(stringviewicon,1728,0,B_RGB32);
tmpBPictureView->SetLowColor(toolbar_button_background);
tmpBPictureView->BeginPicture(new BPicture);
tmpBPictureView->DrawBitmap(stringviewpicture,BPoint(0,0));
tmpBPicture = tmpBPictureView->EndPicture();
tmpBPictureView->RemoveSelf();
AddChild(tmpBPictureView);
BBitmap *stringviewpicture_state2 = new BBitmap(BitmapFrame,B_RGB32);
stringviewpicture_state2->SetBits(stringviewiconinverse,1728,0,B_RGB32);
tmpBPictureView->SetLowColor(toolbar_button_background);
tmpBPictureView->BeginPicture(new BPicture);
tmpBPictureView->DrawBitmap(stringviewpicture_state2,BPoint(0,0));
tmpBPicture2 = tmpBPictureView->EndPicture();
btnBrieStringViewControl = new BPictureButton(BRect (1,0,24,23),"StringView",tmpBPicture,tmpBPicture2, new BMessage(TOOLBOX_BTN_STRINGVIEWCONTROL),B_ONE_STATE_BUTTON, B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW | B_NAVIGABLE);
tmpBPictureView->RemoveSelf();
AddChild(tmpBPictureView);
//--------------------------------------------------------------------//
// TextView Button
BBitmap *textviewpicture = new BBitmap(BitmapFrame,B_RGB32);
textviewpicture->SetBits(brietextcontrol,1728,0,B_RGB32);
tmpBPictureView->SetLowColor(toolbar_button_background);
tmpBPictureView->BeginPicture(new BPicture);
tmpBPictureView->DrawBitmap(textviewpicture,BPoint(0,0));
tmpBPicture = tmpBPictureView->EndPicture();
tmpBPictureView->RemoveSelf();
AddChild(tmpBPictureView);
BBitmap *textviewpicture_state2 = new BBitmap(BitmapFrame,B_RGB32);
textviewpicture_state2->SetBits(brietextcontrolinverse,1728,0,B_RGB32);
tmpBPictureView->SetLowColor(toolbar_button_background);
tmpBPictureView->BeginPicture(new BPicture);
tmpBPictureView->DrawBitmap(textviewpicture_state2,BPoint(0,0));
tmpBPicture2 = tmpBPictureView->EndPicture();
btnBrieTextControl = new BPictureButton(BRect (26,0,50,23),"TextControl",tmpBPicture,tmpBPicture2, new BMessage(TOOLBOX_BTN_TEXTCONTROL),B_ONE_STATE_BUTTON, B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW | B_NAVIGABLE);
tmpBPictureView->RemoveSelf();
AddChild(tmpBPictureView);
//--------------------------------------------------------------------//
// Button Button
BBitmap *buttonpicture = new BBitmap(BitmapFrame,B_RGB32);
buttonpicture->SetBits(stringviewicon,1728,0,B_RGB32);
tmpBPictureView->SetLowColor(toolbar_button_background);
tmpBPictureView->BeginPicture(new BPicture);
tmpBPictureView->DrawBitmap(buttonpicture,BPoint(0,0));
tmpBPicture = tmpBPictureView->EndPicture();
tmpBPictureView->RemoveSelf();
AddChild(tmpBPictureView);
BBitmap *buttonpicture_state2 = new BBitmap(BitmapFrame,B_RGB32);
buttonpicture_state2->SetBits(stringviewiconinverse,1728,0,B_RGB32);
tmpBPictureView->SetLowColor(toolbar_button_background);
tmpBPictureView->BeginPicture(new BPicture);
tmpBPictureView->DrawBitmap(buttonpicture_state2,BPoint(0,0));
tmpBPicture2 = tmpBPictureView->EndPicture();
btnBrieButtonControl = new BPictureButton(BRect (1,25,24,48),
"Button",tmpBPicture,tmpBPicture2, new BMessage(TOOLBOX_BTN_BUTTONCONTROL),B_ONE_STATE_BUTTON, B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW | B_NAVIGABLE);
tmpBPictureView->RemoveSelf();
AddChild(tmpBPictureView);
//--------------------------------------------------------------------//
// Picture Button
BBitmap *picturepicture = new BBitmap(BitmapFrame,B_RGB32);
picturepicture->SetBits(stringviewicon,1728,0,B_RGB32);
tmpBPictureView->SetLowColor(toolbar_button_background);
tmpBPictureView->BeginPicture(new BPicture);
tmpBPictureView->DrawBitmap(picturepicture,BPoint(0,0));
tmpBPicture = tmpBPictureView->EndPicture();
tmpBPictureView->RemoveSelf();
AddChild(tmpBPictureView);
BBitmap *picturepicture_state2 = new BBitmap(BitmapFrame,B_RGB32);
picturepicture_state2->SetBits(stringviewiconinverse,1728,0,B_RGB32);
tmpBPictureView->SetLowColor(toolbar_button_background);
tmpBPictureView->BeginPicture(new BPicture);
tmpBPictureView->DrawBitmap(picturepicture_state2,BPoint(0,0));
tmpBPicture2 = tmpBPictureView->EndPicture();
btnBriePictureControl = new BPictureButton(BRect (26,25,50,48),
"TextControl",tmpBPicture,tmpBPicture2, new BMessage(TOOLBOX_BTN_PICTURECONTROL),B_ONE_STATE_BUTTON, B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW | B_NAVIGABLE);
tmpBPictureView->RemoveSelf();
AddChild(tmpBPictureView);
//--------------------------------------------------------------------//
AddChild(btnBriePictureControl);
AddChild(btnBrieButtonControl);
AddChild(btnBrieTextControl);
AddChild(btnBrieStringViewControl);
// Add the Drawing View
AddChild(ptrToolboxWindowView = new ToolboxWindowView(r));
}
void KlondikeView::MouseDown(BPoint point)
{
if (fMouseLock)
return;
fMouseLock = true;
uint32 mouse;
GetMouse(&point, &mouse);
if (mouse == B_SECONDARY_MOUSE_BUTTON) {
// stop auto-play if it's started
if (fAutoPlayStarted) {
fAutoPlayStarted = false;
return;
}
if (fQuickAutoPlay) {
while(MoveOneToFoundation());
Invalidate();
CheckBoard();
}
else {
fAutoPlayStarted = true;
}
return;
}
int hSpacing = _CardHSpacing();
short stack = (int)((point.x - hSpacing) / (CARD_WIDTH + hSpacing));
if (point.x > (stack + 1) * (CARD_WIDTH + hSpacing))
return;
// stock
if (point.y < 15 + CARD_HEIGHT && point.y > 15
&& stack == 0 && point.x > hSpacing) {
int revealed = 0;
for (short i = 0; i < 24; i++)
if (fStock[i]->fRevealed)
revealed++;
if (revealed < 24 && ++fWasteCard == 24) {
fWasteCard = -1;
fPoints -= 100;
if (fPoints < 0)
fPoints = 0;
}
Invalidate();
return;
}
// pick up a card from waste
if (stack == 1 && point.y < 15 + CARD_HEIGHT) {
if (fWasteCard == -1)
return;
if (fDoubleClick == -1)
fDoubleClick = 1;
else if (fDoubleClick > -1) {
_MoveWasteToFoundation();
CheckBoard();
Invalidate();
fDoubleClick = -1;
return;
}
card* picked = fStock[fWasteCard];
fPickedCard = picked;
fIsWasteCardPicked = true;
BMessage msg(B_SIMPLE_DATA);
msg.AddPointer("view", this);
BBitmap* img = new BBitmap(
fCards[picked->fColor * CARDS_IN_SUIT + picked->fValue]);
DragMessage(&msg, img, B_OP_BLEND,
BPoint((int)(point.x - hSpacing) % (CARD_WIDTH + hSpacing),
point.y - 15));
Invalidate();
return;
}
// pick up a card from a foundation
if (stack > 2 && stack < 7 && point.y < 15 + CARD_HEIGHT) {
short foundation = stack - 3;
short value = fFoundations[foundation];
short color = fFoundationsColors[foundation];
if (fFoundations[foundation] == -1)
return;
// find picked card
for (short i = 0; i < CARDS_IN_DECK; i++) {
if (fAllCards[i]->fValue == value
&& fAllCards[i]->fColor == color)
fPickedCard = fAllCards[i];
}
BMessage msg(B_SIMPLE_DATA);
msg.AddPointer("view", this);
BBitmap* img = new BBitmap(
fCards[fPickedCard->fColor * CARDS_IN_SUIT + fPickedCard->fValue]);
fIsFoundationCardPicked = true;
fPickedCardBoardPos = foundation;
fFoundations[foundation]--;
DragMessage(&msg, img, B_OP_BLEND,
BPoint((int)(point.x - hSpacing) % (CARD_WIDTH + hSpacing),
point.y - 15));
Invalidate();
return;
}
// pick up a stack
if (stack < 7 && fBoard[stack] != NULL
&& point.x > hSpacing && point.y > 2 * 15 + CARD_HEIGHT) {
// find clicked on card
int cardNumber = 1;
card* picked = fBoard[stack];
while (picked->fNextCard != NULL) {
if (point.y - 18 * cardNumber - CARD_HEIGHT - 15 < 18) {
break;
}
picked = picked->fNextCard;
cardNumber++;
}
if (picked->fNextCard == NULL) {
// on last card, if below than not clicking on card
if (point.y - 18 * cardNumber - CARD_HEIGHT - 15 >= CARD_HEIGHT) {
return;
}
if (fDoubleClick == -1)
fDoubleClick = 1;
else if (fDoubleClick > -1 && fAutoPlayEnabled) {
MoveOneToFoundation(stack, stack);
CheckBoard();
Invalidate();
fDoubleClick = -1;
return;
}
}
if (picked->fRevealed == false)
return;
card* currentCard = picked->fNextCard;
card* lastCard = picked;
short pickedHeight = 1;
for (short i = 1; currentCard != NULL;
i++) {
pickedHeight++;
if (lastCard->fIsColorRed == currentCard->fIsColorRed)
return;
lastCard = currentCard;
currentCard = currentCard->fNextCard;
}
fPickedCardBoardPos = stack;
fPickedCard = picked;
fIsCardPicked = true;
_RemoveCardFromPile(stack, picked);
BMessage msg(B_SIMPLE_DATA);
msg.AddPointer("view", this);
BBitmap* img;
if (pickedHeight == 1)
img = new BBitmap(
fCards[picked->fColor * CARDS_IN_SUIT + picked->fValue]);
else {
img = new BBitmap(BRect(0, 0, CARD_WIDTH - 1,
CARD_HEIGHT + (pickedHeight - 1) * 18),
fBack[0]->ColorSpace(), true);
BView* imgView = new BView(img->Bounds(), NULL, 0, 0);
BRect destRect = fBack[0]->Bounds();
img->AddChild(imgView);
img->Lock();
currentCard = picked;
imgView->SetDrawingMode(B_OP_COPY);
imgView->DrawBitmap(fCards
[currentCard->fColor * CARDS_IN_SUIT + currentCard->fValue],
destRect);
destRect.top = (pickedHeight - 1) * 18;
destRect.bottom = destRect.top + CARD_HEIGHT;
imgView->DrawBitmap(fBack[0], destRect);
// we don't know the top card yet, so we'll overwrite this
imgView->SetDrawingMode(B_OP_ALPHA);
for (short j = 0; j < pickedHeight; j++) {
destRect.top = j * 18;
destRect.bottom = destRect.top + CARD_HEIGHT;
imgView->DrawBitmap(fCards[currentCard->fColor
* CARDS_IN_SUIT + currentCard->fValue], destRect);
currentCard = currentCard->fNextCard;
}
imgView->Sync();
img->Unlock();
img->RemoveChild(imgView);
delete imgView;
}
DragMessage(&msg, img, B_OP_BLEND,
BPoint((int)(point.x - hSpacing) % (CARD_WIDTH + hSpacing),
point.y - cardNumber * 18 - 131));
Invalidate();
}
}
void URLView::DoPersonDrag() {
// Handle all of the bookmark dragging. This includes setting up
// the drag message and drawing the dragged bitmap.
// Set up the drag message to support both BTextView dragging (using
// the e-mail address) and file dropping (to Tracker).
BMessage *dragMessage = new BMessage( B_MIME_DATA );
dragMessage->AddInt32( "be:actions", B_COPY_TARGET );
dragMessage->AddString( "be:types", "application/octet-stream" );
dragMessage->AddString( "be:filetypes", "application/x-person" );
dragMessage->AddString( "be:type_descriptions", "person" );
dragMessage->AddString( "be:clip_name", Text() );
// This allows the user to drag the e-mail address into a
// standard BTextView.
BString email = GetImportantURL();
dragMessage->AddData( "text/plain", B_MIME_DATA, email.String(),
email.Length() + 1 );
// Query for the system's icon for bookmarks.
BBitmap *personIcon = new BBitmap( BRect( 0, 0, iconSize - 1,
iconSize - 1 ), B_CMAP8 );
#ifdef ZETA
BMimeType mime( "application/x-vnd.Be-PEPL" );
#else
BMimeType mime( "application/x-person" );
#endif
if( iconSize == 16 ) mime.GetIcon( personIcon, B_MINI_ICON );
else mime.GetIcon( personIcon, B_LARGE_ICON );
// Find the size of the bitmap to drag. If the text is bigger than the
// icon, use that size. Otherwise, use the icon's. Center the icon
// vertically in the bitmap.
BRect rect = GetTextRect();
rect.right += iconSize + 4;
if( (rect.bottom - rect.top) < iconSize ) {
int adjustment = (int) ((iconSize - (rect.bottom - rect.top)) / 2) + 1;
rect.top -= adjustment;
rect.bottom += adjustment;
}
// Make sure the rectangle starts at 0,0.
rect.bottom += 0 - rect.top;
rect.top = 0;
// Create the bitmap to draw the dragged image in.
BBitmap *dragBitmap = new BBitmap( rect, B_RGBA32, true );
BView *dragView = new BView( rect, "Drag View", 0, 0 );
dragBitmap->Lock();
dragBitmap->AddChild( dragView );
BRect frameRect = dragView->Frame();
// Make the background of the dragged image transparent.
dragView->SetHighColor( B_TRANSPARENT_COLOR );
dragView->FillRect( frameRect );
// We want 'g's, etc. to go below the underline. When the BeOS can
// do underlining of any font, this code can be removed.
font_height height;
GetFontHeight( &height );
float descent = height.descent;
// Find the vertical center of the view so we can vertically
// center everything.
int centerPixel = (int) ((frameRect.bottom - frameRect.top) / 2);
int textCenter = (int) (descent + underlineThickness) + centerPixel;
// We want to draw everything only half opaque.
dragView->SetDrawingMode( B_OP_ALPHA );
dragView->SetHighColor( 0.0, 0.0, 0.0, 128.0 );
dragView->SetBlendingMode( B_CONSTANT_ALPHA, B_ALPHA_COMPOSITE );
// Center the icon in the view.
dragView->MovePenTo( BPoint( frameRect.left,
centerPixel - (iconSize / 2) ) );
dragView->DrawBitmap( personIcon );
// Draw the text in the same font (size, etc.) as the link view.
// Note: DrawString() draws the text at one pixel above the pen's
// current y coordinate.
BFont font;
GetFont( &font );
dragView->SetFont( &font );
dragView->MovePenTo( BPoint( frameRect.left + iconSize + 4, textCenter ) );
dragView->DrawString( Text() );
// Be sure to flush the view buffer so everything is drawn.
dragView->Flush();
dragBitmap->Unlock();
// The Person icon adds some width to the bitmap that we are
// going to draw. So horizontally offset the bitmap proportionally
// to where the user clicked on the link.
float horiz = dragOffset.x / GetTextRect().Width();
dragOffset.x = horiz * frameRect.right;
DragMessage( dragMessage, dragBitmap, B_OP_ALPHA,
BPoint( dragOffset.x,
(rect.Height() + underlineThickness) / 2 + 2), this );
delete dragMessage;
draggedOut = true;
}
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);
}
}
}
/*------------------------------------------------------------------------------*\
( )
-
\*------------------------------------------------------------------------------*/
BPicture* BmToolbarButton::CreatePicture( int32 mode, float width,
float height) {
const char* label = mLabel.String();
BmBitmapHandle* imageHandle
= TheResources->IconByName(BmString("Button_")<<mResourceName);
BBitmap* image = imageHandle ? imageHandle->bitmap : NULL;
// Calc icon/label positions
BFont font( be_plain_font);
bool showIcons = ThePrefs->GetBool( "ShowToolbarIcons", true);
BmString labelMode = ThePrefs->GetString( "ShowToolbarLabel", "Bottom");
float labelWidth
= (label && labelMode != "Hide") ? font.StringWidth( label) : 0;
float labelHeight
= (label && labelMode != "Hide")
? TheResources->FontLineHeight( &font)
: 0;
float iconWidth = (showIcons && image) ? image->Bounds().Width() : 0;
float iconHeight = (showIcons && image) ? image->Bounds().Height() : 0;
BPoint posIcon( 0,0), posLabel( 0,0);
if (showIcons && (labelMode == "Left")) {
// Icon + Label/Left
float d = (width-(mNeedsLatch ? DIVLATCHW : 0)-DIVW-labelWidth-iconWidth)/2;
posLabel = BPoint( d,(height-labelHeight)/2);
posIcon = BPoint( d+DIVW+labelWidth+(mNeedsLatch ? DIVLATCHW : 0),
(height-iconHeight)/2-1);
} else if (showIcons && (labelMode == "Right")) {
// Icon + Label/Right
float d = (width-(mNeedsLatch ? DIVLATCHW : 0)-DIVW-labelWidth-iconWidth)/2;
posLabel = BPoint( d+DIVW+iconWidth,(height-labelHeight)/2);
posIcon = BPoint( d,(height-iconHeight)/2-1);
} else if (showIcons && (labelMode == "Top")) {
// Icon + Label/top
float d = (height-DIVH-labelHeight-iconHeight)/2-2;
posLabel = BPoint( (width-labelWidth-(mNeedsLatch ? DIVLATCHW : 0))/2, d);
posIcon = BPoint( (width-iconWidth)/2-1,d+DIVH+labelHeight);
} else if (showIcons && (labelMode == "Bottom")) {
// Icon + Label/bottom
float d = (height-DIVH-labelHeight-iconHeight)/2;
posLabel = BPoint( (width-labelWidth-(mNeedsLatch ? DIVLATCHW : 0))/2,
d+DIVH+iconHeight);
posIcon = BPoint( (width-iconWidth)/2-1,d);
} else if (!showIcons && labelMode != "Hide") {
// Label only
posLabel = BPoint( (width-labelWidth-(mNeedsLatch ? DIVLATCHW : 0))/2,
(height-labelHeight)/2);
} else if (showIcons && labelMode == "Hide") {
// Icon only
posIcon = BPoint( (width-iconWidth-(mNeedsLatch ? DIVLATCHW : 0))/2,
(height-iconHeight)/2);
}
if (mNeedsLatch) {
if (labelMode == "Hide")
mLatchRect.Set( posIcon.x+iconWidth+2,
posIcon.y+iconHeight/2-LATCHSZ/2,
width, height);
else
mLatchRect.Set( posLabel.x+labelWidth+2,
posLabel.y+labelHeight/2-LATCHSZ/2,
width, height);
} else
mLatchRect.Set( -1, -1, -1, -1);
// Draw
BRect rect(0,0,width-1,height-1);
BView* view = new BView( rect, NULL, B_FOLLOW_NONE, 0);
BBitmap* drawImage = new BBitmap( rect, B_RGBA32, true);
drawImage->AddChild( view);
drawImage->Lock();
BPicture* picture = new BPicture();
view->BeginPicture( picture);
view->SetHighColor( ui_color( B_PANEL_TEXT_COLOR));
view->SetViewColor( B_TRANSPARENT_COLOR);
view->SetLowColor( ui_color( B_PANEL_BACKGROUND_COLOR));
#ifndef __HAIKU__
BmToolbar* toolbar = dynamic_cast<BmToolbar*>(Parent()->Parent());
BBitmap* toolbarBackground = NULL;
if (toolbar) {
toolbarBackground = toolbar->BackgroundBitmap();
if (toolbarBackground)
view->DrawBitmap( toolbarBackground, Frame(), rect);
}
if (mode == STATE_ON) {
rect.InsetBy( 1, 1);
view->BeginLineArray(4);
view->AddLine( rect.LeftBottom(), rect.LeftTop(),
BmWeakenColor(B_SHADOW_COLOR, BeShadowMod));
view->AddLine( rect.LeftTop(), rect.RightTop(),
BmWeakenColor(B_SHADOW_COLOR, BeShadowMod));
view->AddLine( rect.LeftBottom(), rect.RightBottom(),
ui_color( B_SHINE_COLOR));
view->AddLine( rect.RightBottom(), rect.RightTop(),
ui_color( B_SHINE_COLOR));
view->EndLineArray();
}
#endif
// Draw Icon
if (showIcons && image) {
view->SetDrawingMode( B_OP_ALPHA);
view->SetBlendingMode( B_PIXEL_ALPHA, B_ALPHA_OVERLAY);
#ifdef __HAIKU__
BBitmap disabledImage(image);
if (mode == STATE_DISABLED) {
image = &disabledImage;
uint8* bits = (uint8*)image->Bits();
uint32 width = image->Bounds().IntegerWidth() + 1;
uint32 height = image->Bounds().IntegerWidth() + 1;
uint32 bpr = image->BytesPerRow();
for (uint32 y = 0; y < height; y++) {
uint8* b = bits;
for (uint32 x = 0; x < width; x++) {
b[3] = (uint8)(((int)b[3] * 100) >> 8);
b += 4;
}
bits += bpr;
}
}
/*------------------------------------------------------------------------------*\
( )
-
\*------------------------------------------------------------------------------*/
void BmToolbar::UpdateLayout(bool recalcSizes) {
if (LockLooper()) {
// since we want the background tiles for the complete toolbar to appear
// as one piece, we can't simply use the toolbar-background as view-bitmap
// in all toolbar-buttons (horizontal wallpapering wouldn't work).
// So, we render the complete wallpaper into a special bitmap, which is
// then used by each toolbar-button when that creates its pictures.
BRect rect = Bounds();
BmBitmapHandle* toolbarBackground
= TheResources->IconByName("Toolbar_Background");
if (toolbarBackground) {
delete mBackgroundBitmap;
BView* view = new BView( rect, NULL, B_FOLLOW_NONE, 0);
mBackgroundBitmap = new BBitmap( rect, B_RGBA32, true);
mBackgroundBitmap->AddChild( view);
mBackgroundBitmap->Lock();
float y=0.0;
while(y < rect.Height()) {
float x=0.0;
while(x < rect.Width()) {
view->DrawBitmap(toolbarBackground->bitmap, BPoint(x,y));
x += toolbarBackground->bitmap->Bounds().Width();
}
y += toolbarBackground->bitmap->Bounds().Height();
}
view->Sync();
mBackgroundBitmap->Unlock();
mBackgroundBitmap->RemoveChild(view);
delete view;
}
// now step through all toolbar-buttons and let them create
// their pictures:
BView* group = ChildAt(0);
if (group) {
int32 count = group->CountChildren();
// Get maximum button size...
float width=0, height=0;
for( int32 c=0; c<count; ++c) {
BmToolbarButton* tbb
= dynamic_cast<BmToolbarButton*>(group->ChildAt(c));
if (tbb)
BmToolbarButton::CalcMaxSize(
width, height, tbb->Label().String(), tbb->NeedsLatch()
);
}
//...and layout all buttons according to this size:
for( int32 c=0; c<count; ++c) {
BmToolbarButton* tbb
= dynamic_cast<BmToolbarButton*>(group->ChildAt(c));
if (tbb)
tbb->CreateAllPictures(width, height);
}
MWindow* win = dynamic_cast<MWindow*>( Window());
if (win && recalcSizes)
win->RecalcSize();
for( int32 c=0; c<count; ++c)
group->ChildAt(c)->Invalidate();
}
// FIXME: a little hackish, but we need to invalidate the whole window
// anyway, since icons in other views will have changed, too.
// Strangely enough, calling Invalidate() on the topmost child
// doesn't work...
Window()->ChildAt(0)->Hide();
Window()->ChildAt(0)->Show();
UnlockLooper();
}
}
void
EBePrivateWin::DispatchMessage(BMessage *bMsg, BHandler *handler)
{
bool handled = true;
if(bMsg->what == 'etk_')
{
int32 what = 0;
bMsg->FindInt32("etk:what", &what);
switch(what)
{
case ETK_BEOS_QUIT:
doQuit = true;
PostMessage(B_QUIT_REQUESTED);
break;
case ETK_BEOS_CONTACT_TO:
{
fContactor = EMessenger();
const char *buffer = NULL;
ssize_t size = -1;
if(bMsg->FindData("etk:messenger", B_ANY_TYPE, (const void**)&buffer, &size) != B_OK) break;
if(buffer == NULL || size <= 0) break;
fContactor.Unflatten(buffer, (size_t)size);
}
break;
case ETK_BEOS_SET_BACKGROUND:
{
rgb_color bkColor;
if(bMsg->FindInt32("background", (int32*)&bkColor) != B_OK) break;
fTopView->SetViewColor(bkColor);
fTopView->Invalidate();
}
break;
case ETK_BEOS_SET_LOOK:
{
int8 look;
if(bMsg->FindInt8("look", &look) != B_OK) break;
switch((e_window_look)look)
{
case E_BORDERED_WINDOW_LOOK:
SetLook(B_BORDERED_WINDOW_LOOK);
break;
case E_NO_BORDER_WINDOW_LOOK:
SetLook(B_NO_BORDER_WINDOW_LOOK);
break;
case E_TITLED_WINDOW_LOOK:
SetLook(B_TITLED_WINDOW_LOOK);
break;
case E_DOCUMENT_WINDOW_LOOK:
SetLook(B_DOCUMENT_WINDOW_LOOK);
break;
case E_MODAL_WINDOW_LOOK:
SetLook(B_MODAL_WINDOW_LOOK);
break;
case E_FLOATING_WINDOW_LOOK:
SetLook(B_FLOATING_WINDOW_LOOK);
break;
default:
break;
}
}
break;
case ETK_BEOS_SET_TITLE:
{
const char *title = NULL;
if(bMsg->FindString("title", &title) != B_OK) break;
SetTitle(title);
}
break;
case ETK_BEOS_SET_WORKSPACES:
{
uint32 workspaces = 0;
if(bMsg->FindInt32("workspaces", (int32*)&workspaces) != B_OK) break;
if(workspaces == 0) workspaces = current_workspace() + 1;
SetWorkspaces(workspaces);
}
break;
case ETK_BEOS_GET_WORKSPACES:
{
uint32 workspaces = Workspaces();
bMsg->AddInt32("workspaces", *((int32*)&workspaces));
}
break;
case ETK_BEOS_ICONIFY:
if(!IsMinimized()) Minimize(true);
break;
case ETK_BEOS_SHOW:
if(IsHidden())
{
uint32 oldFlags = Flags();
SetFlags(oldFlags | B_AVOID_FOCUS);
Show();
if(Look() != B_NO_BORDER_WINDOW_LOOK) SetFlags(oldFlags);
}
break;
case ETK_BEOS_HIDE:
if(!IsHidden()) Hide();
break;
case ETK_BEOS_RAISE:
if(!IsFront())
{
uint32 oldFlags = Flags();
SetFlags(oldFlags | B_AVOID_FOCUS);
Activate(true);
if(Look() != B_NO_BORDER_WINDOW_LOOK) SetFlags(oldFlags);
}
break;
case ETK_BEOS_LOWER:
{
BHandler *_frontWin = NULL;
if(bMsg->FindPointer("front", (void**)&_frontWin) != B_OK) break;
BWindow *frontWin = e_cast_as(_frontWin, BWindow);
if(frontWin == NULL) break;
SendBehind(frontWin);
bMsg->AddBool("done", true);
}
break;
case ETK_BEOS_ACTIVATE:
{
bool state;
if(bMsg->FindBool("state", &state) != B_OK || state == IsActive()) break;
Activate(state);
}
break;
case ETK_BEOS_GET_ACTIVATED_STATE:
bMsg->AddBool("state", IsActive());
break;
case ETK_BEOS_MOVE_RESIZE:
{
if(bMsg->HasPoint("where"))
{
BPoint pt;
if(bMsg->FindPoint("where", &pt) == B_OK) MoveTo(pt);
}
if(bMsg->HasFloat("width") && bMsg->HasFloat("height"))
{
float w = -1, h = -1;
bMsg->FindFloat("width", &w);
bMsg->FindFloat("height", &h);
if(w < 0 || h < 0) break;
ResizeTo(w, h);
}
}
break;
case ETK_BEOS_DRAW_BITMAP:
{
BBitmap *bitmap = NULL;
BRect srcRect, destRect;
const ERegion *clipping = NULL;
if(bMsg->FindPointer("bitmap", (void**)&bitmap) != B_OK || bitmap == NULL) break;
bMsg->FindRect("src", &srcRect);
bMsg->FindRect("dest", &destRect);
if(srcRect.IsValid() == false || destRect.IsValid() == false) break;
bMsg->FindPointer("clipping", (void**)&clipping);
BRegion beRegion;
__etk_convert_region(clipping, &beRegion, fTopView->Bounds());
fTopView->ConstrainClippingRegion(&beRegion);
fTopView->DrawBitmap(bitmap, srcRect, destRect);
}
break;
case ETK_BEOS_GRAB_MOUSE:
case ETK_BEOS_UNGRAB_MOUSE:
{
uint32 options = (what == ETK_BEOS_GRAB_MOUSE ? B_LOCK_WINDOW_FOCUS : 0);
if(fTopView->SetEventMask(B_POINTER_EVENTS, options) != B_OK) break;
bMsg->AddBool("state", what == ETK_BEOS_GRAB_MOUSE);
}
break;
case ETK_BEOS_GRAB_KEYBOARD:
case ETK_BEOS_UNGRAB_KEYBOARD:
{
uint32 options = (what == ETK_BEOS_GRAB_KEYBOARD ? B_LOCK_WINDOW_FOCUS : 0);
if(fTopView->SetEventMask(B_KEYBOARD_EVENTS, options) != B_OK) break;
bMsg->AddBool("state", what == ETK_BEOS_GRAB_KEYBOARD);
}
break;
case ETK_BEOS_QUERY_MOUSE:
{
BPoint pt;
uint32 btns = 0;
fTopView->GetMouse(&pt, &btns, false);
bMsg->AddInt32("x", (int32)pt.x);
bMsg->AddInt32("y", (int32)pt.y);
bMsg->AddInt32("buttons", (int32)btns);
}
break;
case ETK_BEOS_SET_SIZE_LIMITS:
{
BRect r;
if(bMsg->FindRect("limits", &r) != B_OK) break;
SetSizeLimits(r.left, r.right, r.top, r.bottom);
bMsg->AddBool("done", true);
}
break;
case ETK_BEOS_GET_SIZE_LIMITS:
{
BRect r(-1, -1, -1, -1);
GetSizeLimits(&(r.left), &(r.right), &(r.top), &(r.bottom));
bMsg->AddRect("limits", r);
}
break;
default:
handled = false;
break;
}
if(handled)
{
BMessage aMsg(*bMsg);
bMsg->SendReply(&aMsg);
return;
}
}
switch(bMsg->what)
{
case B_WINDOW_ACTIVATED:
{
handled = false;
if(fContactor.IsValid() == false) break;
EMessage message(E_WINDOW_ACTIVATED);
message.AddBool("etk:msg_from_gui", true);
message.AddInt64("when", e_real_time_clock_usecs());
fContactor.SendMessage(&message);
}
break;
case B_MOUSE_DOWN:
case B_MOUSE_UP:
case B_MOUSE_MOVED:
{
if(fContactor.IsValid() == false) break;
BPoint where;
int32 buttons = 0;
bMsg->FindPoint("where", &where);
if(bMsg->what != B_MOUSE_UP) bMsg->FindInt32("buttons", &buttons);
int32 clicks = 1;
if(bMsg->what == B_MOUSE_DOWN)
{
#if 0
bMsg->FindInt32("clicks", &clicks);
#else
bigtime_t eventTime;
if(bMsg->FindInt64("when", &eventTime) == B_OK)
{
if(eventTime - fPrevMouseDownTime <= CLICK_TIMEOUT)
clicks = (fPrevMouseDownCount += 1);
else
clicks = fPrevMouseDownCount = 1;
fPrevMouseDownTime = eventTime;
}
#endif
}
EMessage message;
if(bMsg->what == B_MOUSE_DOWN) message.what = E_MOUSE_DOWN;
else if(bMsg->what == B_MOUSE_UP) message.what = E_MOUSE_UP;
else message.what = E_MOUSE_MOVED;
message.AddBool("etk:msg_from_gui", true);
message.AddInt64("when", e_real_time_clock_usecs());
if(bMsg->what != B_MOUSE_UP) message.AddInt32("buttons", buttons);
if(bMsg->what == B_MOUSE_DOWN) message.AddInt32("clicks", clicks);
message.AddPoint("where", EPoint(where.x, where.y));
ConvertToScreen(&where);
message.AddPoint("screen_where", EPoint(where.x, where.y));
// TODO: modifiers
message.AddMessenger("etk:msg_for_target", fContactor);
etk_app->PostMessage(&message);
}
break;
case B_KEY_DOWN:
case B_KEY_UP:
case B_UNMAPPED_KEY_DOWN:
case B_UNMAPPED_KEY_UP:
{
if(fContactor.IsValid() == false) break;
int8 byte[4];
const char *bytes = NULL;
int32 numBytes = 0;
int32 key = 0;
int32 key_repeat = 0;
int32 beModifiers = 0;
eint32 modifiers = 0;
bMsg->FindInt32("key", &key);
bMsg->FindInt32("modifiers", &beModifiers);
bzero(byte, sizeof(int8) * 4);
if(bMsg->what == B_KEY_DOWN || bMsg->what == B_KEY_UP)
{
for(int32 i = 0; i < 3; i++) bMsg->FindInt8("byte", i, &byte[i]);
if(bMsg->FindString("bytes", &bytes) == B_OK) numBytes = strlen(bytes);
// if(bMsg->what == B_KEY_DOWN) bMsg->FindInt32("be:key_repeat", &key_repeat);
}
else
{
etk_beos_get_byte(beModifiers, key, (char*)byte);
}
if(beModifiers & B_SHIFT_KEY) modifiers |= E_SHIFT_KEY;
if(beModifiers & B_CONTROL_KEY) modifiers |= E_CONTROL_KEY;
if(beModifiers & B_COMMAND_KEY) modifiers |= E_COMMAND_KEY;
EMessage message;
if(bMsg->what == B_KEY_DOWN) message.what = E_KEY_DOWN;
else if(bMsg->what == B_KEY_UP) message.what = E_KEY_UP;
else if(bMsg->what == B_UNMAPPED_KEY_DOWN) message.what = E_UNMAPPED_KEY_DOWN;
else message.what = E_UNMAPPED_KEY_UP;
message.AddBool("etk:msg_from_gui", true);
message.AddInt64("when", e_real_time_clock_usecs());
message.AddInt32("key", key);
message.AddInt32("modifiers", modifiers);
if(bMsg->what == B_KEY_DOWN || bMsg->what == B_KEY_UP)
{
if(bMsg->what == B_KEY_DOWN) message.AddInt32("etk:key_repeat", key_repeat);
for(int32 i = 0; i < 3; i++) message.AddInt8("byte", byte[i]);
if(!(numBytes != 1 || *bytes != byte[0]))
{
etk_beos_get_byte(beModifiers, key, (char*)byte);
message.AddString("bytes", (char*)byte);
}
else if(numBytes > 0)
{
message.AddString("bytes", bytes);
}
}
else if(byte[0] != 0)
{
message.AddInt8("byte", byte[0]);
message.AddString("bytes", (char*)byte);
}
message.AddMessenger("etk:msg_for_target", fContactor);
etk_app->PostMessage(&message);
}
break;
case B_MODIFIERS_CHANGED:
{
if(fContactor.IsValid() == false) break;
eint32 modifiers = 0;
eint32 old_modifiers = 0;
int32 beModifiers = 0;
int32 old_beModifiers = 0;
bMsg->FindInt32("modifiers", &beModifiers);
bMsg->FindInt32("be:old_modifiers", &old_beModifiers);
if(beModifiers & B_SHIFT_KEY) modifiers |= E_SHIFT_KEY;
if(beModifiers & B_CONTROL_KEY) modifiers |= E_CONTROL_KEY;
if(beModifiers & B_COMMAND_KEY) modifiers |= E_COMMAND_KEY;
if(old_beModifiers & B_SHIFT_KEY) old_modifiers |= E_SHIFT_KEY;
if(old_beModifiers & B_CONTROL_KEY) old_modifiers |= E_CONTROL_KEY;
if(old_beModifiers & B_COMMAND_KEY) old_modifiers |= E_COMMAND_KEY;
EMessage message(E_MODIFIERS_CHANGED);
message.AddBool("etk:msg_from_gui", true);
message.AddInt64("when", e_real_time_clock_usecs());
message.AddInt32("modifiers", modifiers);
message.AddInt32("etk:old_modifiers", old_modifiers);
message.AddMessenger("etk:msg_for_target", fContactor);
etk_app->PostMessage(&message);
}
break;
default:
handled = false;
break;
}
if(!handled) BWindow::DispatchMessage(bMsg, handler);
}
void
RowSummaryView::AllAttached()
{
//Bitmaps used to hold the pictures for the Primay key picture button
BRect rect(0,0,13,11);
PrefilledBitmap firstRowOffBitmap(rect, B_COLOR_8_BIT, FirstRowOffRaw, 1344);
PrefilledBitmap firstRowOnBitmap(rect, B_COLOR_8_BIT, FirstRowOnRaw, 1344);
PrefilledBitmap previousRowOffBitmap(rect, B_COLOR_8_BIT, PreviousRowOffRaw, 1344);
PrefilledBitmap previousRowOnBitmap(rect, B_COLOR_8_BIT, PreviousRowOnRaw, 1344);
PrefilledBitmap nextRowOffBitmap(rect, B_COLOR_8_BIT, NextRowOffRaw, 1344);
PrefilledBitmap nextRowOnBitmap(rect, B_COLOR_8_BIT, NextRowOnRaw, 1344);
PrefilledBitmap lastRowOffBitmap(rect, B_COLOR_8_BIT, LastRowOffRaw, 1344);
PrefilledBitmap lastRowOnBitmap(rect, B_COLOR_8_BIT, LastRowOnRaw, 1344);
PrefilledBitmap newRowOffBitmap(rect, B_COLOR_8_BIT, NewRowOffRaw, 1344);
PrefilledBitmap newRowOnBitmap(rect, B_COLOR_8_BIT, NewRowOnRaw, 1344);
PrefilledBitmap previousRowOffDisabledBitmap(rect, B_COLOR_8_BIT, PreviousRowOffDisabledRaw, 1344);
PrefilledBitmap nextRowOffDisabledBitmap(rect, B_COLOR_8_BIT, NextRowOffDisabledRaw, 1344);
PrefilledBitmap newRowOffDisabledBitmap(rect, B_COLOR_8_BIT, NewRowOffDisabledRaw, 1344);
//TempView used to create BPictures
BView *tempView = new BView(rect, "temp", B_FOLLOW_NONE, B_WILL_DRAW);
AddChild(tempView);
//Record BPictures for Off bitmaps
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&firstRowOnBitmap);
BPicture* firstRowPictureOn = tempView->EndPicture();
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&previousRowOffBitmap);
BPicture* previousRowPictureOff = tempView->EndPicture();
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&nextRowOffBitmap);
BPicture* nextRowPictureOff = tempView->EndPicture();
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&lastRowOffBitmap);
BPicture* lastRowPictureOff = tempView->EndPicture();
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&newRowOffBitmap);
BPicture* newRowPictureOff = tempView->EndPicture();
//Record BPicture for DisabledOff bitmaps
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&previousRowOffDisabledBitmap);
BPicture* previousRowDisabledPictureOff = tempView->EndPicture();
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&nextRowOffDisabledBitmap);
BPicture* nextRowDisabledPictureOff = tempView->EndPicture();
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&newRowOffDisabledBitmap);
BPicture* newRowDisabledPictureOff = tempView->EndPicture();
//Record BPictures for On bitmaps
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&firstRowOffBitmap);
BPicture* firstRowPictureOff = tempView->EndPicture();
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&previousRowOnBitmap);
BPicture* previousRowPictureOn = tempView->EndPicture();
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&nextRowOnBitmap);
BPicture* nextRowPictureOn = tempView->EndPicture();
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&lastRowOnBitmap);
BPicture* lastRowPictureOn = tempView->EndPicture();
tempView->BeginPicture(new BPicture);
tempView->DrawBitmap(&newRowOnBitmap);
BPicture* newRowPictureOn = tempView->EndPicture();
RemoveChild(tempView);
delete tempView;
// First Row Button
BMessage* homeMsg = new BMessage(GRID_GOTO_ROW_MSG);
homeMsg->AddInt32("rowNumber", int32(0));
fFirstRowButton = new BPictureButton(BRect(48,1,61,12), "homeButton", firstRowPictureOff,
firstRowPictureOn, homeMsg);
// Previous Row Button
BMessage* prevMsg = new BMessage(GRID_GOTO_PREV_ROW_MSG);
fPreviousRowButton = new BPictureButton(BRect(63,1,76,12), "previousButton",
previousRowPictureOff, previousRowPictureOn, prevMsg);
fPreviousRowButton->SetDisabledOff(previousRowDisabledPictureOff);
// Row Number Display
BRect frame(80,1,130,12);
BRect textRect(0,0,frame.Width(),frame.Height());
fRowNumberDisplay = new RowNumberDisplay(frame, "rowNumberDisplay", textRect,
B_FOLLOW_BOTTOM, B_WILL_DRAW|B_NAVIGABLE);
BFont font;
font.SetSize(10);
fRowNumberDisplay->SetFontAndColor(&font);
fRowNumberDisplay->SetAlignment(B_ALIGN_RIGHT);
fRowNumberDisplay->SetWordWrap(false);
// Next Row Button
BMessage* nextMsg = new BMessage(GRID_GOTO_NEXT_ROW_MSG);
fNextRowButton = new BPictureButton(BRect(134,1,147,12), "nextButton",
nextRowPictureOff, nextRowPictureOn, nextMsg);
fNextRowButton->SetDisabledOff(nextRowDisabledPictureOff);
// Last Row Button
BMessage* lastMsg = new BMessage(GRID_GOTO_LAST_ROW_MSG);
fLastRowButton = new BPictureButton(BRect(149,1,162,12), "lastButton",
lastRowPictureOff, lastRowPictureOn, lastMsg);
// New Row Button
BMessage* newMsg = new BMessage(GRID_GOTO_NEW_ROW_MSG);
fNewRowButton = new BPictureButton(BRect(164,1,177,12), "newButton",
newRowPictureOff, newRowPictureOn, newMsg);
fNewRowButton->SetDisabledOff(newRowDisabledPictureOff);
fNewRowButton->SetDisabledOn(newRowDisabledPictureOff);
AddChild(fFirstRowButton);
AddChild(fPreviousRowButton);
AddChild(fRowNumberDisplay);
AddChild(fNextRowButton);
AddChild(fLastRowButton);
AddChild(fNewRowButton);
}
status_t
MovieEncoder::Encode()
{
int32 framesLeft = fFileList->CountItems();
int32 framesWritten = 0;
if (framesLeft <= 0) {
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_ERROR);
fMessenger.SendMessage(&message);
return B_ERROR;
}
// Create movie
char movieName[B_FILE_NAME_LENGTH];
MakeUniqueName(fOutputFile.Path(), movieName, B_FILE_NAME_LENGTH);
entry_ref movieRef;
get_ref_for_path(movieName, &movieRef);
media_file_format fileFormat;
if (!GetMediaFileFormat(fFamily, fileFormat)) {
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_ERROR);
fMessenger.SendMessage(&message);
return B_ERROR;
}
BBitmap* bitmap = BTranslationUtils::GetBitmapFile(fFileList->ItemAt(0));
BRect sourceFrame = bitmap->Bounds();
delete bitmap;
if (!fDestFrame.IsValid())
fDestFrame = sourceFrame.OffsetToCopy(B_ORIGIN);
BitmapMovie* movie = new BitmapMovie(fDestFrame.IntegerWidth() + 1,
fDestFrame.IntegerHeight() + 1, fColorSpace);
status_t error = movie->CreateFile(movieRef, fileFormat, fFormat, fCodecInfo);
if (error < B_OK) {
delete movie;
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)error);
fMessenger.SendMessage(&message);
return error;
}
// Bitmap and view used to convert the source bitmap
// to the correct size and depth
BBitmap* destBitmap = new BBitmap(fDestFrame, fColorSpace, true);
BView* destDrawer = new BView(fDestFrame, "drawing view", B_FOLLOW_NONE, 0);
if (destBitmap->Lock()) {
destBitmap->AddChild(destDrawer);
destBitmap->Unlock();
}
const uint32 keyFrameFrequency = 10;
BMessage progressMessage(B_UPDATE_STATUS_BAR);
progressMessage.AddFloat("delta", 1.0);
bool keyFrame = true;
for (int32 i = 0; i < fFileList->CountItems(); i++) {
if (framesWritten % keyFrameFrequency == 0)
keyFrame = true;
const char* fileName = fFileList->ItemAt(i);
BBitmap* frame = BTranslationUtils::GetBitmapFile(fileName);
if (frame == NULL)
continue;
// Draw scaled
if (error == B_OK) {
destBitmap->Lock();
destDrawer->DrawBitmap(frame, frame->Bounds(), destDrawer->Bounds());
destDrawer->Sync();
destBitmap->Unlock();
}
delete frame;
if (error == B_OK)
error = movie->WriteFrame(destBitmap, keyFrame);
if (error == B_OK) {
framesWritten++;
keyFrame = false;
} else {
printf("%s\n", strerror(error));
break;
}
if (fMessenger.IsValid())
fMessenger.SendMessage(new BMessage(progressMessage));
}
//printf("%ld frames written\n", framesWritten);
delete movie;
delete destBitmap;
//delete cursor;
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_OK);
fMessenger.SendMessage(&message);
return B_OK;
}
int
main(int argc, char **argv)
{
BApplication app("application/x-vnd.Antares-RAWTranslator");
#if TEST_MODE
if (argc > 1) {
for (int i = 1; i < argc; i++) {
BFile file;
status_t status = file.SetTo(argv[i], B_READ_ONLY);
if (status != B_OK) {
fprintf(stderr, "Cannot read file %s: %s\n", argv[i],
strerror(status));
continue;
}
DCRaw raw(file);
try {
status = raw.Identify();
} catch (status_t error) {
status = error;
}
if (status < B_OK) {
fprintf(stderr, "Could not identify file %s: %s\n",
argv[i], strerror(status));
continue;
}
image_meta_info meta;
raw.GetMetaInfo(meta);
printf("manufacturer: %s\n", meta.manufacturer);
printf("model: %s\n", meta.model);
printf("software: %s\n", meta.software);
printf("flash used: %g\n", meta.flash_used);
printf("ISO speed: %g\n", meta.iso_speed);
printf("shutter: ");
if (meta.shutter >= 1)
printf("%g sec\n", meta.shutter);
else
printf("1/%g sec\n", 1 / meta.shutter);
printf("aperture: %g\n", meta.aperture);
printf("focal length: %g mm\n", meta.focal_length);
printf("pixel aspect: %g\n", meta.pixel_aspect);
printf("flip: %d\n", meta.flip);
printf("shot order: %ld\n", meta.shot_order);
printf("DNG version: %ld\n", meta.dng_version);
printf("Camera White Balance:");
for (int32 i = 0; i < 4; i++) {
printf(" %g", meta.camera_multipliers[i]);
}
putchar('\n');
for (int32 i = 0; i < (int32)raw.CountImages(); i++) {
image_data_info data;
raw.ImageAt(i, data);
printf(" [%ld] %s %lu x %lu (%ld bits per sample, compression %ld)\n",
i, data.is_raw ? "RAW " : "JPEG",
data.width, data.height, data.bits_per_sample, data.compression);
# if SHOW_MODE
if (!data.is_raw) {
// write data to file
uint8* buffer;
size_t bufferSize;
try {
status = raw.ReadImageAt(i, buffer, bufferSize);
} catch (status_t error) {
status = error;
}
if (status == B_OK) {
BString name = "/tmp/output";
name << i << ".jpg";
BFile output(name.String(),
B_CREATE_FILE | B_ERASE_FILE | B_WRITE_ONLY);
output.Write(buffer, bufferSize);
}
} else {
RAWTranslator translator;
BBitmapStream output;
BBitmap* bitmap;
status_t status = translator.DerivedTranslate(&file, NULL,
NULL, B_TRANSLATOR_BITMAP, &output, 0);
if (status == B_OK)
status = output.DetachBitmap(&bitmap);
if (status == B_OK) {
BWindow* window = new BWindow(BRect(0, 0, 1, 1),
"RAW", B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS
| B_NOT_RESIZABLE | B_AUTO_UPDATE_SIZE_LIMITS);
BView* view = new BView(window->Bounds(), NULL,
B_WILL_DRAW, B_FOLLOW_NONE);
window->AddChild(view);
window->SetLayout(new BGroupLayout(B_HORIZONTAL));
window->Show();
snooze(300000);
window->Lock();
view->DrawBitmap(bitmap, window->Bounds());
view->Sync();
window->Unlock();
delete bitmap;
wait_for_thread(window->Thread(), &status);
}
}
# endif
}
}
return 0;
}
#endif
status_t status = LaunchTranslatorWindow(new RAWTranslator, "RAW Settings");
if (status != B_OK)
return 1;
app.Run();
return 0;
}
PrinterItem::PrinterItem(PrintersWindow* window, const BDirectory& node,
PrinterListLayoutData& layoutData)
: BListItem(0, false),
fFolder(NULL),
fNode(node),
fLayoutData(layoutData)
{
BRect rect(0, 0, B_LARGE_ICON - 1, B_LARGE_ICON - 1);
if (sIcon == NULL) {
#ifdef HAIKU_TARGET_PLATFORM_HAIKU
sIcon = new BBitmap(rect, B_RGBA32);
#else
sIcon = new BBitmap(rect, B_CMAP8);
#endif
BMimeType type(PSRV_PRINTER_FILETYPE);
type.GetIcon(sIcon, B_LARGE_ICON);
}
if (sIcon && sIcon->IsValid() && sSelectedIcon == NULL) {
const float checkMarkIconSize = 20.0;
BBitmap *checkMark = _LoadVectorIcon("check_mark_icon",
checkMarkIconSize);
if (checkMark && checkMark->IsValid()) {
sSelectedIcon = new BBitmap(rect, B_RGBA32, true);
if (sSelectedIcon && sSelectedIcon->IsValid()) {
// draw check mark at bottom left over printer icon
BView *view = new BView(rect, "offscreen", B_FOLLOW_ALL,
B_WILL_DRAW);
float y = rect.Height() - checkMark->Bounds().Height();
sSelectedIcon->Lock();
sSelectedIcon->AddChild(view);
view->DrawBitmap(sIcon);
view->SetDrawingMode(B_OP_ALPHA);
view->DrawBitmap(checkMark, BPoint(0, y));
view->Sync();
view->RemoveSelf();
sSelectedIcon->Unlock();
delete view;
}
}
delete checkMark;
}
// Get Name of printer
_GetStringProperty(PSRV_PRINTER_ATTR_PRT_NAME, fName);
_GetStringProperty(PSRV_PRINTER_ATTR_COMMENTS, fComments);
_GetStringProperty(PSRV_PRINTER_ATTR_TRANSPORT, fTransport);
_GetStringProperty(PSRV_PRINTER_ATTR_TRANSPORT_ADDR, fTransportAddress);
_GetStringProperty(PSRV_PRINTER_ATTR_DRV_NAME, fDriverName);
BPath path;
if (find_directory(B_USER_PRINTERS_DIRECTORY, &path) != B_OK)
return;
// Setup spool folder
path.Append(fName.String());
BDirectory dir(path.Path());
if (dir.InitCheck() == B_OK) {
fFolder = new SpoolFolder(window, this, dir);
UpdatePendingJobs();
}
}
// When this is running, no member variable should be accessed
// from other threads
status_t
MovieEncoder::_EncoderThread()
{
int32 framesLeft = fFileList->CountItems();
int32 framesWritten = 0;
if (framesLeft <= 0) {
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_ERROR);
fMessenger.SendMessage(&message);
return B_ERROR;
}
// Create movie
entry_ref movieRef;
get_ref_for_path(fOutputFile.Path(), &movieRef);
BitmapEntry* entry = fFileList->ItemAt(0);
BBitmap* bitmap = entry->Bitmap();
BRect sourceFrame = bitmap->Bounds();
delete bitmap;
if (!fDestFrame.IsValid())
fDestFrame = sourceFrame.OffsetToCopy(B_ORIGIN);
// Calc the average time difference between the first 100 frames,
// and use it to calculate the framerate.
// TODO: Actually we could just calculate the number of frames and
// the time difference between the first and the last one.
/*int32 maxTimeStampNum = std::min((int32)100, fFileList->CountItems());
bigtime_t previousFrameTime = entry->TimeStamp();
bigtime_t diffSum = 0;
for (int32 i = 0; i < maxTimeStampNum; i++) {
BitmapEntry* entry = fFileList->ItemAt(i);
bigtime_t currentFrameTime = entry->TimeStamp();
diffSum += currentFrameTime - previousFrameTime;
previousFrameTime = currentFrameTime;
}
float medianDiffTime = diffSum / maxTimeStampNum;
*/
int32 numFrames = fFileList->CountItems();
BitmapEntry* firstEntry = fFileList->ItemAt(0);
BitmapEntry* lastEntry = fFileList->ItemAt(numFrames - 1);
int frameSeconds = (1000000 * numFrames) / (lastEntry->TimeStamp() - firstEntry->TimeStamp());
media_format inputFormat = fFormat;
inputFormat.u.raw_video.field_rate = frameSeconds;
status_t status = _CreateFile(movieRef, fFileFormat, inputFormat, fCodecInfo);
if (status < B_OK) {
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)status);
fMessenger.SendMessage(&message);
return status;
}
// Bitmap and view used to convert the source bitmap
// to the correct size and depth
BBitmap* destBitmap = new BBitmap(fDestFrame, fColorSpace, true);
BView* destDrawer = new BView(fDestFrame, "drawing view", B_FOLLOW_NONE, 0);
if (destBitmap->Lock()) {
destBitmap->AddChild(destDrawer);
destBitmap->Unlock();
}
const uint32 keyFrameFrequency = 10;
// TODO: Make this tunable
BMessage progressMessage(B_UPDATE_STATUS_BAR);
progressMessage.AddFloat("delta", 1.0);
destBitmap->Bounds().PrintToStream();
PrintMediaFormat(inputFormat);
status = B_OK;
while (BitmapEntry* entry = const_cast<FileList*>(fFileList)->Pop()) {
if (fKillThread)
break;
bool keyFrame = (framesWritten % keyFrameFrequency == 0);
BBitmap* frame = entry->Bitmap();
if (frame == NULL) {
// TODO: What to do here ? Exit with an error ?
std::cerr << "Error while loading bitmap entry" << std::endl;
delete entry;
continue;
}
// Draw scaled
if (status == B_OK) {
destBitmap->Lock();
destDrawer->DrawBitmap(frame, frame->Bounds(), destDrawer->Bounds());
destDrawer->Sync();
destBitmap->Unlock();
}
delete frame;
delete entry;
if (status == B_OK)
status = _WriteFrame(destBitmap, keyFrame);
if (status != B_OK)
break;
framesWritten++;
if (fMessenger.IsValid())
fMessenger.SendMessage(new BMessage(progressMessage));
else {
// BMessenger is no longer valid. This means that the application
// has been closed or it has crashed.
break;
}
}
delete destBitmap;
DisposeData();
if (fMessenger.IsValid()) {
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)status);
message.AddInt32("frames", (int32)framesWritten);
fMessenger.SendMessage(&message);
}
return status;
}
status_t
MovieEncoder::Encode()
{
int32 framesLeft = fFileList->CountItems();
int32 framesWritten = 0;
if (framesLeft <= 0) {
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_ERROR);
fMessenger.SendMessage(&message);
return B_ERROR;
}
// Create movie
char movieName[B_FILE_NAME_LENGTH];
MakeUniqueName(fOutputFile.Path(), movieName, B_FILE_NAME_LENGTH);
entry_ref movieRef;
get_ref_for_path(movieName, &movieRef);
BBitmap* bitmap = BTranslationUtils::GetBitmapFile(fFileList->ItemAt(0));
BRect sourceFrame = bitmap->Bounds();
delete bitmap;
if (!fDestFrame.IsValid())
fDestFrame = sourceFrame.OffsetToCopy(B_ORIGIN);
BitmapMovie* movie = new BitmapMovie(fDestFrame.IntegerWidth() + 1,
fDestFrame.IntegerHeight() + 1, fColorSpace);
status_t status = movie->CreateFile(movieRef, fFileFormat, fFormat, fCodecInfo);
if (status < B_OK) {
delete movie;
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)status);
fMessenger.SendMessage(&message);
return status;
}
// Bitmap and view used to convert the source bitmap
// to the correct size and depth
BBitmap* destBitmap = new BBitmap(fDestFrame, fColorSpace, true);
BView* destDrawer = new BView(fDestFrame, "drawing view", B_FOLLOW_NONE, 0);
if (destBitmap->Lock()) {
destBitmap->AddChild(destDrawer);
destBitmap->Unlock();
}
const uint32 keyFrameFrequency = 10;
// TODO: Make this tunable
BMessage progressMessage(B_UPDATE_STATUS_BAR);
progressMessage.AddFloat("delta", 1.0);
status = B_OK;
for (int32 i = 0; i < fFileList->CountItems(); i++) {
bool keyFrame = (framesWritten % keyFrameFrequency == 0);
const char* fileName = fFileList->ItemAt(i);
BBitmap* frame = BTranslationUtils::GetBitmapFile(fileName);
if (frame == NULL) {
// TODO: What to do here ? Exit with an error ?
continue;
}
// Draw scaled
if (status == B_OK) {
destBitmap->Lock();
destDrawer->DrawBitmap(frame, frame->Bounds(), destDrawer->Bounds());
destDrawer->Sync();
destBitmap->Unlock();
}
delete frame;
if (status == B_OK)
status = movie->WriteFrame(destBitmap, keyFrame);
if (status != B_OK)
break;
framesWritten++;
if (fMessenger.IsValid())
fMessenger.SendMessage(new BMessage(progressMessage));
}
delete movie;
delete destBitmap;
DisposeData();
if (fMessenger.IsValid()) {
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)status);
message.AddInt32("frames", (int32)framesWritten);
fMessenger.SendMessage(&message);
}
return status;
}
