haiku.git

/*
 * Copyright 2006, 2011, Stephan Aßmus <superstippi@gmx.de>.
 * Copyright 2023 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Zardshard
 */


#include "IconEditorApp.h"

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

#include <Alert.h>
#include <Catalog.h>
#include <FilePanel.h>
#include <FindDirectory.h>
#include <IconEditorProtocol.h>
#include <Locale.h>
#include <Message.h>
#include <Mime.h>
#include <Path.h>

#include "support_settings.h"

#include "AutoLocker.h"
#include "Defines.h"
#include "MainWindow.h"
#include "SavePanel.h"
#include "ShapeListView.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Icon-O-Matic-Main"


using std::nothrow;

static const char* kAppSig = "application/x-vnd.haiku-icon_o_matic";

static const float kWindowOffset = 20;


IconEditorApp::IconEditorApp()
	:
	BApplication(kAppSig),
	fWindowCount(0),
	fLastWindowFrame(50, 50, 900, 750),

	fOpenPanel(NULL),
	fSavePanel(NULL),

	fLastOpenPath(""),
	fLastSavePath(""),
	fLastExportPath("")
{
	// create file panels
	BMessenger messenger(this, this);
	BMessage message(B_REFS_RECEIVED);
	fOpenPanel = new BFilePanel(B_OPEN_PANEL, &messenger, NULL, B_FILE_NODE,
		true, &message);

	message.what = MSG_SAVE_AS;
	fSavePanel = new SavePanel("save panel", &messenger, NULL, B_FILE_NODE
		| B_DIRECTORY_NODE | B_SYMLINK_NODE, false, &message);

	_RestoreSettings();
}


IconEditorApp::~IconEditorApp()
{
	delete fOpenPanel;
	delete fSavePanel;
}


// #pragma mark -


bool
IconEditorApp::QuitRequested()
{
	// Run the QuitRequested() hook in each window's own thread. Otherwise
	// the BAlert which a window shows when an icon is not saved will not
	// repaint the window. (BAlerts check which thread is running Go() and
	// will repaint windows when it's a BWindow.)
	bool quit = true;
	for (int32 i = 0; BWindow* window = WindowAt(i); i++) {
		if (!window->Lock())
			continue;
		// Try to cast the window while the pointer must be valid.
		MainWindow* mainWindow = dynamic_cast<MainWindow*>(window);
		window->Unlock();
		if (mainWindow == NULL)
			continue;
		BMessenger messenger(window, window);
		BMessage reply;
		if (messenger.SendMessage(B_QUIT_REQUESTED, &reply) != B_OK)
			continue;
		bool result;
		if (reply.FindBool("result", &result) == B_OK && !result)
			quit = false;
	}

	if (!quit)
		return false;

	_StoreSettings();

	return true;
}


void
IconEditorApp::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case MSG_NEW:
			_NewWindow()->Show();
			break;
		case MSG_OPEN:
		{
			BMessage openMessage(B_REFS_RECEIVED);
			MainWindow* window;
			if (message->FindPointer("window", (void**)&window) == B_OK)
				openMessage.AddPointer("window", window);
			bool referenceImage;
			if (message->FindBool("reference image", &referenceImage) == B_OK)
				openMessage.AddBool("reference image", referenceImage);
			fOpenPanel->SetMessage(&openMessage);
			fOpenPanel->Show();
			break;
		}
		case MSG_APPEND:
		{
			MainWindow* window;
			if (message->FindPointer("window", (void**)&window) != B_OK)
				break;
			BMessage openMessage(B_REFS_RECEIVED);
			openMessage.AddBool("append", true);
			openMessage.AddPointer("window", window);
			fOpenPanel->SetMessage(&openMessage);
			fOpenPanel->Show();
			break;
		}
		case B_EDIT_ICON_DATA:
		{
			BMessenger messenger;
			if (message->FindMessenger("reply to", &messenger) < B_OK) {
				// required
				break;
			}
			const uint8* data;
			ssize_t size;
			if (message->FindData("icon data", B_VECTOR_ICON_TYPE,
				(const void**)&data, &size) < B_OK) {
				// optional (new icon will be created)
				data = NULL;
				size = 0;
			}
			MainWindow* window = _NewWindow();
			window->Open(messenger, data, size);
			window->Show();
			break;
		}
		case MSG_SAVE_AS:
		case MSG_EXPORT_AS:
		{
			BMessenger messenger;
			if (message->FindMessenger("target", &messenger) != B_OK)
				break;

			fSavePanel->SetExportMode(message->what == MSG_EXPORT_AS);
//			fSavePanel->Refresh();
			const char* saveText;
			if (message->FindString("save text", &saveText) == B_OK)
				fSavePanel->SetSaveText(saveText);
			entry_ref saveDirectory;
			if (message->FindRef("save directory", &saveDirectory) == B_OK)
				fSavePanel->SetPanelDirectory(&saveDirectory);
			fSavePanel->SetTarget(messenger);
			fSavePanel->Show();
			break;
		}

		case MSG_WINDOW_CLOSED:
		{
			fWindowCount--;
			if (fWindowCount == 0)
				PostMessage(B_QUIT_REQUESTED);
			BMessage settings;
			if (message->FindMessage("settings", &settings) == B_OK)
				fLastWindowSettings = settings;
			BRect frame;
			if (message->FindRect("window frame", &frame) == B_OK) {
				fLastWindowFrame = frame;
				fLastWindowFrame.OffsetBy(-kWindowOffset, -kWindowOffset);
			}
			break;
		}

		default:
			BApplication::MessageReceived(message);
			break;
	}
}


void
IconEditorApp::ReadyToRun()
{
	// create main window
	if (fWindowCount == 0)
		_NewWindow()->Show();

	_InstallDocumentMimeType();
}


void
IconEditorApp::RefsReceived(BMessage* message)
{
	bool append;
	if (message->FindBool("append", &append) != B_OK)
		append = false;
	bool referenceImage;
	if (message->FindBool("reference image", &referenceImage) != B_OK)
		referenceImage = false;
	MainWindow* window;
	if (message->FindPointer("window", (void**)&window) != B_OK)
		window = NULL;
	// When appending, we need to know a window.
	if (append && window == NULL)
		return;
	entry_ref ref;
	if (append || referenceImage) {
		if (!window->Lock())
			return;
		for (int32 i = 0; message->FindRef("refs", i, &ref) == B_OK; i++) {
			if (append)
				window->Open(ref, true);
			if (referenceImage)
				window->AddReferenceImage(ref);
		}
		window->Unlock();
	} else {
		for (int32 i = 0; message->FindRef("refs", i, &ref) == B_OK; i++) {
			if (window != NULL && i == 0) {
				window->Lock();
				window->Open(ref, false);
				window->Unlock();
			} else {
				window = _NewWindow();
				window->Open(ref, false);
				window->Show();
			}
		}
	}

	if (fOpenPanel != NULL && fSavePanel != NULL)
		_SyncPanels(fOpenPanel, fSavePanel);
}


void
IconEditorApp::ArgvReceived(int32 argc, char** argv)
{
	if (argc < 2)
		return;

	entry_ref ref;

	for (int32 i = 1; i < argc; i++) {
		if (get_ref_for_path(argv[i], &ref) == B_OK) {
		 	MainWindow* window = _NewWindow();
			window->Open(ref);
			window->Show();
		}
	}
}


// #pragma mark -


MainWindow*
IconEditorApp::_NewWindow()
{
	fLastWindowFrame.OffsetBy(kWindowOffset, kWindowOffset);
	MainWindow* window = new MainWindow(fLastWindowFrame, this,
		&fLastWindowSettings);
	fWindowCount++;

	window->MoveOnScreen(B_MOVE_IF_PARTIALLY_OFFSCREEN);

	return window;
}


void
IconEditorApp::_SyncPanels(BFilePanel* from, BFilePanel* to)
{
	if (from->Window()->Lock()) {
		// location
		if (to->Window()->Lock()) {
			BRect frame = from->Window()->Frame();
			to->Window()->MoveTo(frame.left, frame.top);
			to->Window()->ResizeTo(frame.Width(), frame.Height());
			to->Window()->Unlock();
		}
		// current folder
		entry_ref panelDir;
		from->GetPanelDirectory(&panelDir);
		to->SetPanelDirectory(&panelDir);
		from->Window()->Unlock();
	}
}


const char*
IconEditorApp::_LastFilePath(path_kind which)
{
	const char* path = NULL;

	switch (which) {
		case LAST_PATH_OPEN:
			if (fLastOpenPath.Length() > 0)
				path = fLastOpenPath.String();
			else if (fLastSavePath.Length() > 0)
				path = fLastSavePath.String();
			else if (fLastExportPath.Length() > 0)
				path = fLastExportPath.String();
			break;
		case LAST_PATH_SAVE:
			if (fLastSavePath.Length() > 0)
				path = fLastSavePath.String();
			else if (fLastExportPath.Length() > 0)
				path = fLastExportPath.String();
			else if (fLastOpenPath.Length() > 0)
				path = fLastOpenPath.String();
			break;
		case LAST_PATH_EXPORT:
			if (fLastExportPath.Length() > 0)
				path = fLastExportPath.String();
			else if (fLastSavePath.Length() > 0)
				path = fLastSavePath.String();
			else if (fLastOpenPath.Length() > 0)
				path = fLastOpenPath.String();
			break;
	}
	if (path == NULL) {

		BPath homePath;
		if (find_directory(B_USER_DIRECTORY, &homePath) == B_OK)
			path = homePath.Path();
		else 
			path = "/boot/home";
	}

	return path;
}


// #pragma mark -


void
IconEditorApp::_StoreSettings()
{
	BMessage settings('stns');

	settings.AddRect("window frame", fLastWindowFrame);
	settings.AddMessage("window settings", &fLastWindowSettings);
	settings.AddInt32("export mode", fSavePanel->ExportMode());

	save_settings(&settings, "Icon-O-Matic");
}


void
IconEditorApp::_RestoreSettings()
{
	BMessage settings('stns');
	load_settings(&settings, "Icon-O-Matic");

	BRect frame;
	if (settings.FindRect("window frame", &frame) == B_OK) {
		fLastWindowFrame = frame;
		// Compensate offset for next window...
		fLastWindowFrame.OffsetBy(-kWindowOffset, -kWindowOffset);
	}
	BMessage lastSettings;
	if (settings.FindMessage("window settings", &lastSettings)
		== B_OK) {
		fLastWindowSettings = lastSettings;
	}

	int32 mode;
	if (settings.FindInt32("export mode", &mode) >= B_OK)
		fSavePanel->SetExportMode(mode);
}


void
IconEditorApp::_InstallDocumentMimeType()
{
	// install mime type of documents
	BMimeType mime(kNativeIconMimeType);
	status_t ret = mime.InitCheck();
	if (ret < B_OK) {
		fprintf(stderr, "Could not init native document mime type (%s): %s.\n",
			kNativeIconMimeType, strerror(ret));
		return;
	}

	if (mime.IsInstalled() && !(modifiers() & B_SHIFT_KEY)) {
		// mime is already installed, and the user is not
		// pressing the shift key to force a re-install
		return;
	}

	ret = mime.Install();
	if (ret < B_OK) {
		fprintf(stderr, "Could not install native document mime type (%s): "
			"%s.\n", kNativeIconMimeType, strerror(ret));
		return;
	}
	// set preferred app
	ret = mime.SetPreferredApp(kAppSig);
	if (ret < B_OK)
		fprintf(stderr, "Could not set native document preferred app: %s\n",
			strerror(ret));

	// set descriptions
	ret = mime.SetShortDescription("Haiku Icon");
	if (ret < B_OK)
		fprintf(stderr, "Could not set short description of mime type: %s\n",
			strerror(ret));
	ret = mime.SetLongDescription("Native Haiku vector icon");
	if (ret < B_OK)
		fprintf(stderr, "Could not set long description of mime type: %s\n",
			strerror(ret));

	// set extensions
	BMessage message('extn');
	message.AddString("extensions", "icon");
	ret = mime.SetFileExtensions(&message);
	if (ret < B_OK)
		fprintf(stderr, "Could not set extensions of mime type: %s\n",
			strerror(ret));

	// set sniffer rule
	const char* snifferRule = "0.9 ('IMSG')";
	ret = mime.SetSnifferRule(snifferRule);
	if (ret < B_OK) {
		BString parseError;
		BMimeType::CheckSnifferRule(snifferRule, &parseError);
		fprintf(stderr, "Could not set sniffer rule of mime type: %s\n",
			parseError.String());
	}
}