haiku.git

/*
 * Copyright 2006, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 */

#include "support_ui.h"

#include <stdio.h>
#include <string.h>

#include <Bitmap.h>
#include <DataIO.h>
#include <Directory.h>
#include <File.h>
#include <FindDirectory.h>
#include <Screen.h>
#include <String.h>
#include <Path.h>
#include <View.h>

// stroke_frame
void
stroke_frame(BView* v, BRect r, rgb_color left, rgb_color top,
			 rgb_color right, rgb_color bottom)
{
	if (v && r.IsValid()) {
		v->BeginLineArray(4);
			v->AddLine(BPoint(r.left, r.bottom),
					   BPoint(r.left, r.top), left);
			v->AddLine(BPoint(r.left + 1.0, r.top),
					   BPoint(r.right, r.top), top);
			v->AddLine(BPoint(r.right, r.top + 1.0),
					   BPoint(r.right, r.bottom), right);
			v->AddLine(BPoint(r.right - 1.0, r.bottom),
					   BPoint(r.left + 1.0, r.bottom), bottom);
		v->EndLineArray();
	}
}

// store_color_in_message
status_t
store_color_in_message(BMessage* message, rgb_color color)
{
	status_t ret = B_BAD_VALUE;
	if (message) {
		ret = message->AddData("RGBColor", B_RGB_COLOR_TYPE,
							   (void*)&color, sizeof(rgb_color));
	}
	return ret;
}

// restore_color_from_message
status_t
restore_color_from_message(const BMessage* message, rgb_color& color, int32 index)
{
	status_t ret = B_BAD_VALUE;
	if (message) {
			const void* colorPointer;
			ssize_t size = sizeof(rgb_color);
			ret = message->FindData("RGBColor", B_RGB_COLOR_TYPE, index,
									&colorPointer, &size);
			if (ret >= B_OK)
				color = *(const rgb_color*)colorPointer;
	}
	return ret;
}

// make_color_drop_message
BMessage
make_color_drop_message(rgb_color color, BBitmap* bitmap)
{
	// prepare message
	BMessage message(B_PASTE);
	char hexString[8];
	snprintf(hexString, sizeof(hexString), "#%.2X%.2X%.2X",
		color.red, color.green, color.blue);
	message.AddData("text/plain", B_MIME_TYPE, &hexString, sizeof(hexString));
	message.AddData("RGBColor", B_RGB_COLOR_TYPE, &color, sizeof(color));
	// prepare bitmap
	if (bitmap && bitmap->IsValid()
		&& (bitmap->ColorSpace() == B_RGB32
			|| bitmap->ColorSpace() == B_RGBA32)) {
		uint8* bits = (uint8*)bitmap->Bits();
		uint32 bpr = bitmap->BytesPerRow();
		uint32 width = bitmap->Bounds().IntegerWidth() + 1;
		uint32 height = bitmap->Bounds().IntegerHeight() + 1;
		for (uint32 y = 0; y < height; y++) {
			uint8* bitsHandle = bits;
			for (uint32 x = 0; x < width; x++) {
				if (x == 0 || y == 0 ) {
					// top or left border
					bitsHandle[0] = (uint8)min_c(255, color.blue * 1.2 + 40);
					bitsHandle[1] = (uint8)min_c(255, color.green * 1.2 + 40);
					bitsHandle[2] = (uint8)min_c(255, color.red * 1.2 + 40);
					bitsHandle[3] = 180;
				} else if ((x == width - 2 || y == height - 2)
						   && !(x == width - 1 || y == height - 1)) {
					// bottom or right border
					bitsHandle[0] = (uint8)(color.blue * 0.8);
					bitsHandle[1] = (uint8)(color.green * 0.8);
					bitsHandle[2] = (uint8)(color.red * 0.8);
					bitsHandle[3] = 180;
				} else if (x == width - 1 || y == height - 1) {
					// shadow
					bitsHandle[0] = 0;
					bitsHandle[1] = 0;
					bitsHandle[2] = 0;
					bitsHandle[3] = 100;
				} else {
					// color
					bitsHandle[0] = color.blue;
					bitsHandle[1] = color.green;
					bitsHandle[2] = color.red;
					bitsHandle[3] = 180;
				}
				if ((x == 0 && y == height - 1) || (y == 0 && x == width - 1)) {
					// spare pixels of shadow
					bitsHandle[0] = 0;
					bitsHandle[1] = 0;
					bitsHandle[2] = 0;
					bitsHandle[3] = 50;
				}
				bitsHandle += 4;
			}
			bits += bpr;
		}
	}
	return message;
}

// make_sure_frame_is_on_screen
void
make_sure_frame_is_on_screen(BRect& frame, BWindow* window)
{
	if (!frame.IsValid())
		return;

	BRect screenFrame;
	if (window) {
		BScreen screen(window);
		if (!screen.IsValid())
			return;
		screenFrame = screen.Frame();
	} else {
		BScreen screen(B_MAIN_SCREEN_ID);
		if (!screen.IsValid())
			return;
		screenFrame = screen.Frame();
	}
	if (!screenFrame.Contains(frame)) {
		// make sure frame fits in the screen
		if (frame.Width() > screenFrame.Width())
			frame.right -= frame.Width() - screenFrame.Width() + 10.0;
		if (frame.Height() > screenFrame.Height())
			frame.bottom -= frame.Height() - screenFrame.Height() + 30.0;
		// frame is now at the most the size of the screen
		if (frame.right > screenFrame.right)
			frame.OffsetBy(-(frame.right - screenFrame.right), 0.0);
		if (frame.bottom > screenFrame.bottom)
			frame.OffsetBy(0.0, -(frame.bottom - screenFrame.bottom));
		if (frame.left < screenFrame.left)
			frame.OffsetBy((screenFrame.left - frame.left), 0.0);
		if (frame.top < screenFrame.top)
			frame.OffsetBy(0.0, (screenFrame.top - frame.top));
	}
}

// print_modifiers
void
print_modifiers()
{
	uint32 mods = modifiers();
	if (mods & B_SHIFT_KEY)
		printf("B_SHIFT_KEY\n");
	if (mods & B_COMMAND_KEY)
		printf("B_COMMAND_KEY\n");
	if (mods & B_CONTROL_KEY)
		printf("B_CONTROL_KEY\n");
	if (mods & B_CAPS_LOCK)
		printf("B_CAPS_LOCK\n");
	if (mods & B_SCROLL_LOCK)
		printf("B_SCROLL_LOCK\n");
	if (mods & B_NUM_LOCK)
		printf("B_NUM_LOCK\n");
	if (mods & B_OPTION_KEY)
		printf("B_OPTION_KEY\n");
	if (mods & B_MENU_KEY)
		printf("B_MENU_KEY\n");
	if (mods & B_LEFT_SHIFT_KEY)
		printf("B_LEFT_SHIFT_KEY\n");
	if (mods & B_RIGHT_SHIFT_KEY)
		printf("B_RIGHT_SHIFT_KEY\n");
	if (mods & B_LEFT_COMMAND_KEY)
		printf("B_LEFT_COMMAND_KEY\n");
	if (mods & B_RIGHT_COMMAND_KEY)
		printf("B_RIGHT_COMMAND_KEY\n");
	if (mods & B_LEFT_CONTROL_KEY)
		printf("B_LEFT_CONTROL_KEY\n");
	if (mods & B_RIGHT_CONTROL_KEY)
		printf("B_RIGHT_CONTROL_KEY\n");
	if (mods & B_LEFT_OPTION_KEY)
		printf("B_LEFT_OPTION_KEY\n");
	if (mods & B_RIGHT_OPTION_KEY)
		printf("B_RIGHT_OPTION_KEY\n");
}

/*
// convert_cap_mode
agg::line_cap_e
convert_cap_mode(uint32 mode)
{
	agg::line_cap_e aggMode = agg::butt_cap;
	switch (mode) {
		case CAP_MODE_BUTT:
			aggMode = agg::butt_cap;
			break;
		case CAP_MODE_SQUARE:
			aggMode = agg::square_cap;
			break;
		case CAP_MODE_ROUND:
			aggMode = agg::round_cap;
			break;
	}
	return aggMode;
}

// convert_cap_mode
agg::line_join_e
convert_join_mode(uint32 mode)
{
	agg::line_join_e aggMode = agg::miter_join;
	switch (mode) {
		case JOIN_MODE_MITER:
			aggMode = agg::miter_join;
			break;
		case JOIN_MODE_ROUND:
			aggMode = agg::round_join;
			break;
		case JOIN_MODE_BEVEL:
			aggMode = agg::bevel_join;
			break;
	}
	return aggMode;
}
*/

// string_for_color_space
const char*
string_for_color_space(color_space format)
{
	const char* name = "<unkown format>";
	switch (format) {
		case B_RGB32:
			name = "B_RGB32";
			break;
		case B_RGBA32:
			name = "B_RGBA32";
			break;
		case B_RGB32_BIG:
			name = "B_RGB32_BIG";
			break;
		case B_RGBA32_BIG:
			name = "B_RGBA32_BIG";
			break;
		case B_RGB24:
			name = "B_RGB24";
			break;
		case B_RGB24_BIG:
			name = "B_RGB24_BIG";
			break;
		case B_CMAP8:
			name = "B_CMAP8";
			break;
		case B_GRAY8:
			name = "B_GRAY8";
			break;
		case B_GRAY1:
			name = "B_GRAY1";
			break;

		// YCbCr
		case B_YCbCr422:
			name = "B_YCbCr422";
			break;
		case B_YCbCr411:
			name = "B_YCbCr411";
			break;
		case B_YCbCr444:
			name = "B_YCbCr444";
			break;
		case B_YCbCr420:
			name = "B_YCbCr420";
			break;

		// YUV
		case B_YUV422:
			name = "B_YUV422";
			break;
		case B_YUV411:
			name = "B_YUV411";
			break;
		case B_YUV444:
			name = "B_YUV444";
			break;
		case B_YUV420:
			name = "B_YUV420";
			break;

		case B_YUV9:
			name = "B_YUV9";
			break;
		case B_YUV12:
			name = "B_YUV12";
			break;

		default:
			break;
	}
	return name;
}

// print_color_space
void
print_color_space(color_space format)
{
	printf("%s\n", string_for_color_space(format));
}