nephele/haiku
nephele
/
haiku
0
0
Fork 0
Code Issues Releases Activity
haiku/src/apps/resedit/BitmapView.cpp

687 lines
14 KiB
C++
Raw Permalink Blame History

#include "BitmapView.h"
#include <Alert.h>
#include <BitmapStream.h>
#include <Clipboard.h>
#include <Font.h>
#include <MenuItem.h>
#include <Entry.h>
#include <TranslationUtils.h>
#include <TranslatorRoster.h>
#include <TranslatorFormats.h>
// TODO: Add support for labels
#define M_REMOVE_IMAGE 'mrmi'
#define M_PASTE_IMAGE 'mpsi'
enum
{
CLIP_NONE = 0,
CLIP_BEOS = 1,
CLIP_SHOWIMAGE = 2,
CLIP_PRODUCTIVE = 3
};
inline void SetRGBColor(rgb_color *col, uint8 r, uint8 g, uint8 b, uint8 a = 255);
void
SetRGBColor(rgb_color *col, uint8 r, uint8 g, uint8 b, uint8 a)
{
if (col) {
col->red = r;
col->green = g;
col->blue = b;
col->alpha = a;
}
}
BitmapView::BitmapView(BRect frame, const char *name, BMessage *mod, BBitmap *bitmap,
const char *label, border_style borderstyle, int32 resize, int32 flags)
: BView(frame, name, resize, flags)
{
SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
if (bitmap && bitmap->IsValid())
fBitmap = bitmap;
else
fBitmap = NULL;
if (mod)
SetMessage(mod);
fLabel = label;
fBorderStyle = borderstyle;
fFixedSize = false;
fEnabled = true;
fRemovableBitmap = false;
fAcceptDrops = true;
fAcceptPaste = true;
fConstrainDrops = true;
fMaxWidth = 100;
fMaxHeight = 100;
fPopUpMenu = new BPopUpMenu("deletepopup", false, false);
fPopUpMenu->AddItem(new BMenuItem("Close This Menu", new BMessage(B_CANCEL)));
fPopUpMenu->AddSeparatorItem();
fPasteItem = new BMenuItem("Paste Photo from Clipboard", new BMessage(M_PASTE_IMAGE));
fPopUpMenu->AddItem(fPasteItem);
fPopUpMenu->AddSeparatorItem();
fRemoveItem = new BMenuItem("Remove Photo", new BMessage(M_REMOVE_IMAGE));
fPopUpMenu->AddItem(fRemoveItem);
CalculateBitmapRect();
// Calculate the offsets for each of the words -- the phrase will be center justified
fNoPhotoWidths[0] = StringWidth("Drop");
fNoPhotoWidths[1] = StringWidth("a");
fNoPhotoWidths[2] = StringWidth("Photo");
fNoPhotoWidths[3] = StringWidth("Here");
font_height fh;
GetFontHeight(&fh);
float totalheight = fh.ascent + fh.descent + fh.leading;
float yoffset = (Bounds().Height() - 10 - (totalheight * 4)) / 2;
fNoPhotoOffsets[0].Set((Bounds().Width() - fNoPhotoWidths[0]) / 2, totalheight + yoffset);
fNoPhotoOffsets[1].Set((Bounds().Width() - fNoPhotoWidths[1]) / 2,
fNoPhotoOffsets[0].y + totalheight);
fNoPhotoOffsets[2].Set((Bounds().Width() - fNoPhotoWidths[2]) / 2,
fNoPhotoOffsets[1].y + totalheight);
fNoPhotoOffsets[3].Set((Bounds().Width() - fNoPhotoWidths[3]) / 2,
fNoPhotoOffsets[2].y + totalheight);
}
BitmapView::~BitmapView(void)
{
delete fPopUpMenu;
}
void
BitmapView::AttachedToWindow(void)
{
SetTarget((BHandler*)Window());
fPopUpMenu->SetTargetForItems(this);
}
void
BitmapView::SetBitmap(BBitmap *bitmap)
{
if (bitmap && bitmap->IsValid()) {
if (fBitmap == bitmap)
return;
fBitmap = bitmap;
} else {
if (!fBitmap)
return;
fBitmap = NULL;
}
CalculateBitmapRect();
if (!IsHidden())
Invalidate();
}
void
BitmapView::SetEnabled(bool value)
{
if (fEnabled != value) {
fEnabled = value;
Invalidate();
}
}
/*
void
BitmapView::SetLabel(const char *label)
{
if (fLabel.Compare(label) != 0) {
fLabel = label;
CalculateBitmapRect();
if (!IsHidden())
Invalidate();
}
}
*/
void
BitmapView::SetStyle(border_style style)
{
if (fBorderStyle != style) {
fBorderStyle = style;
CalculateBitmapRect();
if (!IsHidden())
Invalidate();
}
}
void
BitmapView::SetFixedSize(bool isfixed)
{
if (fFixedSize != isfixed) {
fFixedSize = isfixed;
CalculateBitmapRect();
if (!IsHidden())
Invalidate();
}
}
void
BitmapView::MessageReceived(BMessage *msg)
{
if (msg->WasDropped() && AcceptsDrops()) {
// We'll handle two types of drops: those from Tracker and those from ShowImage
if (msg->what == B_SIMPLE_DATA) {
int32 actions;
if (msg->FindInt32("be:actions", &actions) == B_OK) {
// ShowImage drop. This is a negotiated drag&drop, so send a reply
BMessage reply(B_COPY_TARGET), response;
reply.AddString("be:types", "image/jpeg");
reply.AddString("be:types", "image/png");
msg->SendReply(&reply, &response);
// now, we've gotten the response
if (response.what == B_MIME_DATA) {
// Obtain and translate the received data
uint8 *imagedata;
ssize_t datasize;
// Try JPEG first
if (response.FindData("image/jpeg", B_MIME_DATA,
(const void **)&imagedata, &datasize) != B_OK) {
// Try PNG next and piddle out if unsuccessful
if (response.FindData("image/png", B_PNG_FORMAT,
(const void **)&imagedata, &datasize) != B_OK)
return;
}
// Set up to decode into memory
BMemoryIO memio(imagedata, datasize);
BTranslatorRoster *roster = BTranslatorRoster::Default();
BBitmapStream bstream;
if (roster->Translate(&memio, NULL, NULL, &bstream, B_TRANSLATOR_BITMAP) == B_OK)
{
BBitmap *bmp;
if (bstream.DetachBitmap(&bmp) != B_OK)
return;
SetBitmap(bmp);
if (fConstrainDrops)
ConstrainBitmap();
Invoke();
}
}
return;
}
entry_ref ref;
if (msg->FindRef("refs", &ref) == B_OK) {
// Tracker drop
BBitmap *bmp = BTranslationUtils::GetBitmap(&ref);
if (bmp) {
SetBitmap(bmp);
if (fConstrainDrops)
ConstrainBitmap();
Invoke();
}
}
}
return;
}
switch (msg->what)
{
case M_REMOVE_IMAGE: {
BAlert *alert = new BAlert("ResEdit", "This cannot be undone. "
"Remove the image?", "Remove", "Cancel");
alert->SetShortcut(1, B_ESCAPE);
int32 value = alert->Go();
if (value == 0) {
SetBitmap(NULL);
if (Target()) {
BMessenger msgr(Target());
msgr.SendMessage(new BMessage(M_BITMAP_REMOVED));
return;
}
}
}
case M_PASTE_IMAGE:
{
PasteBitmap();
Invoke();
}
}
BView::MessageReceived(msg);
}
void
BitmapView::Draw(BRect rect)
{
if (fBitmap)
DrawBitmap(fBitmap, fBitmap->Bounds(), fBitmapRect);
else {
SetHighColor(0, 0, 0, 80);
SetDrawingMode(B_OP_ALPHA);
DrawString("Drop", fNoPhotoOffsets[0]);
DrawString("a", fNoPhotoOffsets[1]);
DrawString("Photo", fNoPhotoOffsets[2]);
DrawString("Here", fNoPhotoOffsets[3]);
SetDrawingMode(B_OP_COPY);
}
if (fBorderStyle == B_FANCY_BORDER) {
rgb_color base= { 216, 216, 216, 255 };
rgb_color work;
SetHighColor(base);
StrokeRect(Bounds().InsetByCopy(2, 2));
BeginLineArray(12);
BRect r(Bounds());
work = tint_color(base, B_DARKEN_2_TINT);
AddLine(r.LeftTop(), r.RightTop(), work);
AddLine(r.LeftTop(), r.LeftBottom(), work);
r.left++;
work = tint_color(base, B_DARKEN_4_TINT);
AddLine(r.RightTop(), r.RightBottom(), work);
AddLine(r.LeftBottom(), r.RightBottom(), work);
r.right--;
r.top++;
r.bottom--;
work = tint_color(base, B_LIGHTEN_MAX_TINT);
AddLine(r.LeftTop(), r.RightTop(), work);
AddLine(r.LeftTop(), r.LeftBottom(), work);
r.left++;
work = tint_color(base, B_DARKEN_3_TINT);
AddLine(r.RightTop(), r.RightBottom(), work);
AddLine(r.LeftBottom(), r.RightBottom(), work);
// this rect handled by the above StrokeRect, so inset a total of 2 pixels
r.left++;
r.right -= 2;
r.top += 2;
r.bottom -= 2;
work = tint_color(base, B_DARKEN_3_TINT);
AddLine(r.LeftTop(), r.RightTop(), work);
AddLine(r.LeftTop(), r.LeftBottom(), work);
r.left++;
work = tint_color(base, B_LIGHTEN_MAX_TINT);
AddLine(r.RightTop(), r.RightBottom(), work);
AddLine(r.LeftBottom(), r.RightBottom(), work);
r.right--;
r.top++;
r.bottom--;
EndLineArray();
SetHighColor(tint_color(base, B_DARKEN_2_TINT));
StrokeRect(r);
} else {
// Plain border
SetHighColor(0, 0, 0);
StrokeRect(fBitmapRect);
}
}
void
BitmapView::MouseDown(BPoint pt)
{
BPoint mousept;
uint32 buttons;
GetMouse(&mousept, &buttons);
if (buttons & B_SECONDARY_MOUSE_BUTTON) {
ConvertToScreen(&mousept);
mousept.x= (mousept.x>5) ? mousept.x-5 : 0;
mousept.y= (mousept.y>5) ? mousept.y-5 : 0;
if (AcceptsPaste() && ClipboardHasBitmap())
fPasteItem->SetEnabled(true);
else
fPasteItem->SetEnabled(false);
if (fRemovableBitmap && fBitmap)
fRemoveItem->SetEnabled(true);
else
fRemoveItem->SetEnabled(false);
fPopUpMenu->Go(mousept, true, true, true);
}
}
void
BitmapView::FrameResized(float w, float h)
{
CalculateBitmapRect();
}
void
BitmapView::CalculateBitmapRect(void)
{
if (!fBitmap || fFixedSize) {
fBitmapRect = Bounds().InsetByCopy(1, 1);
return;
}
uint8 borderwidth = (fBorderStyle == B_FANCY_BORDER) ? 5 : 1;
BRect r(Bounds());
fBitmapRect= ScaleRectToFit(fBitmap->Bounds(), r.InsetByCopy(borderwidth, borderwidth));
}
void
BitmapView::SetAcceptDrops(bool accept)
{
fAcceptDrops = accept;
}
void
BitmapView::SetAcceptPaste(bool accept)
{
fAcceptPaste = accept;
}
void
BitmapView::SetConstrainDrops(bool value)
{
fConstrainDrops = value;
}
void
BitmapView::MaxBitmapSize(float *width, float *height) const
{
*width = fMaxWidth;
*height = fMaxHeight;
}
void
BitmapView::SetMaxBitmapSize(const float &width, const float &height)
{
fMaxWidth = width;
fMaxHeight = height;
ConstrainBitmap();
}
void
BitmapView::SetBitmapRemovable(bool isremovable)
{
fRemovableBitmap = isremovable;
}
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);
}
bool
BitmapView::ClipboardHasBitmap(void)
{
BMessage *clip = NULL, flattened;
uint8 clipval = CLIP_NONE;
bool returnval;
if (be_clipboard->Lock()) {
clip = be_clipboard->Data();
if (!clip->IsEmpty()) {
returnval = (clip->FindMessage("image/bitmap", &flattened) == B_OK);
if (returnval)
clipval = CLIP_BEOS;
else {
BString string;
returnval = (clip->FindString("class", &string) == B_OK && string == "BBitmap");
// Try method Gobe Productive uses if that, too, didn't work
if (returnval)
clipval = CLIP_SHOWIMAGE;
else {
returnval = (clip->FindMessage("image/x-vnd.Be-bitmap", &flattened) == B_OK);
if (returnval)
clipval = CLIP_SHOWIMAGE;
else
clipval = CLIP_NONE;
}
}
}
be_clipboard->Unlock();
}
return (clipval != CLIP_NONE)?true:false;
}
BBitmap *
BitmapView::BitmapFromClipboard(void)
{
BMessage *clip = NULL, flattened;
BBitmap *bitmap;
if (!be_clipboard->Lock())
return NULL;
clip = be_clipboard->Data();
if (!clip)
return NULL;
uint8 clipval = CLIP_NONE;
// Try ArtPaint-style storage
status_t status = clip->FindMessage("image/bitmap", &flattened);
// If that didn't work, try ShowImage-style
if (status != B_OK) {
BString string;
status = clip->FindString("class", &string);
// Try method Gobe Productive uses if that, too, didn't work
if (status == B_OK && string == "BBitmap")
clipval = CLIP_SHOWIMAGE;
else {
status = clip->FindMessage("image/x-vnd.Be-bitmap", &flattened);
if (status == B_OK)
clipval = CLIP_PRODUCTIVE;
else
clipval = CLIP_NONE;
}
}
else
clipval = CLIP_BEOS;
be_clipboard->Unlock();
switch (clipval) {
case CLIP_SHOWIMAGE: {
// Showimage does it a slightly different way -- it dumps the BBitmap
// data directly to the clipboard message instead of packaging it in
// a bitmap like everyone else.
if (!be_clipboard->Lock())
return NULL;
BMessage datamsg(*be_clipboard->Data());
be_clipboard->Unlock();
const void *buffer;
ssize_t bufferLength;
BRect frame;
color_space cspace = B_NO_COLOR_SPACE;
status = datamsg.FindRect("_frame", &frame);
if (status != B_OK)
return NULL;
status = datamsg.FindInt32("_cspace", (int32)cspace);
if (status != B_OK)
return NULL;
cspace = B_RGBA32;
bitmap = new BBitmap(frame, cspace, true);
status = datamsg.FindData("_data", B_RAW_TYPE, (const void **)&buffer, &bufferLength);
if (status != B_OK) {
delete bitmap;
return NULL;
}
memcpy(bitmap->Bits(), buffer, bufferLength);
return bitmap;
}
case CLIP_PRODUCTIVE:
// Productive doesn't name the packaged BBitmap data message the same, but
// uses exactly the same data format.
case CLIP_BEOS: {
const void *buffer;
ssize_t bufferLength;
BRect frame;
color_space cspace = B_NO_COLOR_SPACE;
status = flattened.FindRect("_frame", &frame);
if (status != B_OK)
return NULL;
status = flattened.FindInt32("_cspace", (int32)cspace);
if (status != B_OK)
return NULL;
cspace = B_RGBA32;
bitmap = new BBitmap(frame, cspace, true);
status = flattened.FindData("_data", B_RAW_TYPE, (const void **)&buffer, &bufferLength);
if (status != B_OK) {
delete bitmap;
return NULL;
}
memcpy(bitmap->Bits(), buffer, bufferLength);
return bitmap;
}
default:
return NULL;
}
// shut the compiler up
return NULL;
}
BRect
ScaleRectToFit(const BRect &from, const BRect &to)
{
// Dynamic sizing algorithm
// 1) Check to see if either dimension is bigger than the view's display area
// 2) If smaller along both axes, make bitmap rect centered and return
// 3) Check to see if scaling is to be horizontal or vertical on basis of longer axis
// 4) Calculate scaling factor
// 5) Scale both axes down by scaling factor, accounting for border width
// 6) Center the rectangle in the direction of the smaller axis
if (!to.IsValid())
return from;
if (!from.IsValid())
return to;
BRect r(to);
if ((from.Width() <= r.Width()) && (from.Height() <= r.Height())) {
// Smaller than view, so just center and return
r = from;
r.OffsetBy((to.Width() - r.Width()) / 2, (to.Height() - r.Height()) / 2);
return r;
}
float multiplier = from.Width()/from.Height();
if (multiplier > 1) {
// Landscape orientation
// Scale rectangle to bounds width and center height
r.bottom = r.top + (r.Width() / multiplier);
r.OffsetBy(0, (to.Height() - r.Height()) / 2);
} else {
// Portrait orientation
// Scale rectangle to bounds height and center width
r.right = r.left + (r.Height() * multiplier);
r.OffsetBy((to.Width() - r.Width()) / 2, 0);
}
return r;
}
void
BitmapView::RemoveBitmap(void)
{
SetBitmap(NULL);
}
void
BitmapView::PasteBitmap(void)
{
BBitmap *bmp = BitmapFromClipboard();
if (bmp)
SetBitmap(bmp);
if (fConstrainDrops)
ConstrainBitmap();
}
View Git Blame Copy Permalink