haiku.git

/*
 * Copyright 2009 Vincent Duvert, vincent.duvert@free.fr
 * Copyright 2014 Haiku, Inc. All rights reserved.
 *
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Vincent Duvert, vincent.duvert@free.fr
 *		John Scipione, jscipione@gmail.com
 */


#include "IconsSaver.h"

#include <stdlib.h>

#include <Bitmap.h>
#include <Catalog.h>
#include <DefaultSettingsView.h>
#include <MimeType.h>

#include "IconDisplay.h"
#include "VectorIcon.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Screensaver Icons"


#define RAND_BETWEEN(a, b) ((rand() % ((b) - (a) + 1) + (a)))


static const int32 kMaxConcurrentIcons = 15;
static const int32 kMinIconWidthPercentage = 5;
	// percentage of the screen width
static const int32 kMaxIconWidthPercentage = 20;
	// same here
static const int32 kMinIconCount = 20;
static const int32 kMaxIconCount = 384;


const rgb_color kBackgroundColor = ui_color(B_DESKTOP_COLOR);


BScreenSaver* instantiate_screen_saver(BMessage* msg, image_id image)
{
	return new IconsSaver(msg, image);
}


//	#pragma mark - IconsSaver


IconsSaver::IconsSaver(BMessage* archive, image_id image)
	:
	BScreenSaver(archive, image),
	fIcons(NULL),
	fBackBitmap(NULL),
	fBackView(NULL),
	fMinSize(0),
	fMaxSize(0)
{
}


IconsSaver::~IconsSaver()
{
	vector_icon* icon;
	while ((icon = fVectorIcons.RemoveItemAt((int32)0)) != NULL) {
		delete[] icon->data;
		free(icon);
	}
}


status_t
IconsSaver::StartSaver(BView* view, bool /*preview*/)
{
	if (fVectorIcons.CountItems() < kMinIconCount)
		_GetVectorIcons();

	srand(system_time() % INT_MAX);

	BRect screenRect(0, 0, view->Frame().Width(), view->Frame().Height());
	fBackBitmap = new BBitmap(screenRect, B_RGBA32, true);
	if (!fBackBitmap->IsValid())
		return B_NO_MEMORY;

	fBackView = new BView(screenRect, "back view", 0, 0);
	if (fBackView == NULL)
		return B_NO_MEMORY;

	fBackView->SetViewColor(kBackgroundColor);
	fBackView->SetHighColor(kBackgroundColor);

	fBackBitmap->AddChild(fBackView);
	if (fBackBitmap->Lock()) {
		fBackView->FillRect(fBackView->Frame());
		fBackView->SetDrawingMode(B_OP_ALPHA);
		fBackView->SetBlendingMode(B_CONSTANT_ALPHA, B_ALPHA_OVERLAY);
		fBackView->Sync();
		fBackBitmap->Unlock();
	}

	fIcons = new IconDisplay[kMaxConcurrentIcons];

	fMaxSize = (screenRect.IntegerWidth() * kMaxIconWidthPercentage) / 100;
	fMinSize = (screenRect.IntegerWidth() * kMinIconWidthPercentage) / 100;
	if (fMaxSize > 255)
		fMaxSize = 255;

	if (fMaxSize > screenRect.IntegerHeight())
		fMaxSize = screenRect.IntegerHeight();

	if (fMinSize > fMaxSize)
		fMinSize = fMaxSize;

	return B_OK;
}


void
IconsSaver::StopSaver()
{
	delete[] fIcons;
	fIcons = NULL;
	delete fBackBitmap;
	fBackBitmap = NULL;
}


void
IconsSaver::Draw(BView* view, int32 frame)
{
	static int32 previousFrame = 0;

	// update drawing
	if (fBackBitmap->Lock()) {
		for (uint8 i = 0 ; i < kMaxConcurrentIcons ; i++)
			fIcons[i].ClearOn(fBackView);

		int32 delta = frame - previousFrame;
		for (uint8 i = 0 ; i < kMaxConcurrentIcons ; i++)
			fIcons[i].DrawOn(fBackView, delta);

		fBackView->Sync();
		fBackBitmap->Unlock();
	}

	// sync the view with the back buffer
	view->DrawBitmap(fBackBitmap);
	previousFrame = frame;

	if (fVectorIcons.CountItems() < kMinIconCount)
		return;

	// restart one icon
	for (uint8 i = 0 ; i < kMaxConcurrentIcons ; i++) {
		if (!fIcons[i].IsRunning()) {
			uint16 size = RAND_BETWEEN(fMinSize, fMaxSize);
			uint16 maxX = view->Frame().IntegerWidth() - size;
			uint16 maxY = view->Frame().IntegerHeight() - size;

			BRect iconFrame(0, 0, size, size);
			iconFrame.OffsetTo(RAND_BETWEEN(0, maxX), RAND_BETWEEN(0, maxY));

			// Check that the icon doesn't overlap with others
			for (uint8 j = 0 ; j < kMaxConcurrentIcons ; j++) {
				if (fIcons[j].IsRunning() &&
					iconFrame.Intersects(fIcons[j].GetFrame()))
					return;
			}

			int32 index = RAND_BETWEEN(0, fVectorIcons.CountItems() - 1);
			fIcons[i].Run(fVectorIcons.ItemAt(index), iconFrame);
			return;
		}
	}
}


void
IconsSaver::StartConfig(BView* view)
{
	BPrivate::BuildDefaultSettingsView(view, "Icons",
		B_TRANSLATE("by Vincent Duvert"));
}


//	#pragma mark - IconsSaver private methods


void
IconsSaver::_GetVectorIcons()
{
	// Load vector icons from the MIME type database
	BMessage types;
	if (BMimeType::GetInstalledTypes(&types) != B_OK)
		return;

	const char* type;
	for (int32 i = 0; types.FindString("types", i, &type) == B_OK; i++) {
		BMimeType mimeType(type);
		if (mimeType.InitCheck() != B_OK)
			continue;

		uint8* data;
		size_t size;

		if (mimeType.GetIcon(&data, &size) != B_OK) {
			// didn't find an icon
			continue;
		}

		vector_icon* icon = (vector_icon*)malloc(sizeof(vector_icon));
		if (icon == NULL) {
			// ran out of memory, delete the icon data
			delete[] data;
			continue;
		}

		icon->data = data;
		icon->size = size;

		// found a vector icon, add it to the list
		fVectorIcons.AddItem(icon);
		if (fVectorIcons.CountItems() >= kMaxIconCount) {
			// this is enough to choose from, stop eating memory...
			return;
		}
	}
}