haiku.git

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

#include "SavePanel.h"

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

#include <Alert.h>
#include <Button.h>
#include <Catalog.h>
#include <Locale.h>
#include <MenuBar.h>
#include <MenuField.h>
#include <PopUpMenu.h>
#include <ScrollBar.h>
#include <TextControl.h>
#include <TranslationKit.h>
#include <View.h>
#include <Window.h>

#include "Exporter.h"
#include "IconEditorApp.h"
#include "Panel.h"


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


enum {
	MSG_FORMAT		= 'sfpf',
	MSG_SETTINGS	= 'sfps',
};

// SaveItem class
SaveItem::SaveItem(const char* name,
				   BMessage* message,
				   uint32 exportMode)
	: BMenuItem(name, message),
	  fExportMode(exportMode)
{
}

// #pragma mark -

// SavePanel class
SavePanel::SavePanel(const char* name,
					 BMessenger* target,
					 entry_ref* startDirectory,
					 uint32 nodeFlavors,
					 bool allowMultipleSelection,
					 BMessage* message,
					 BRefFilter* filter,
					 bool modal,
					 bool hideWhenDone)
	: BFilePanel(B_SAVE_PANEL, target, startDirectory,
				 nodeFlavors, allowMultipleSelection,
				 message, filter, modal, hideWhenDone),
	  BHandler(name),
	  fConfigWindow(NULL),
	  fFormatM(NULL),
	  fExportMode(EXPORT_MODE_ICON_RDEF)
{
	BWindow* window = Window();
	if (!window || !window->Lock())
		return;

	// add this instance as BHandler to the window's looper
	window->AddHandler(this);

	// find a couple of important views and mess with their layout
	BView* background = Window()->ChildAt(0);
	if (background == NULL) {
		printf("SavePanel::SavePanel() - couldn't find necessary controls.\n");
		return;
	}
	BButton* cancel = dynamic_cast<BButton*>(
		background->FindView("cancel button"));
	BView* textview = background->FindView("text view");

	if (!cancel || !textview) {
		printf("SavePanel::SavePanel() - couldn't find necessary controls.\n");
		return;
	}

	_BuildMenu();

	BRect rect = textview->Frame();
	rect.top = cancel->Frame().top;
	font_height fh;
	be_plain_font->GetHeight(&fh);
	rect.bottom = rect.top + fh.ascent + fh.descent + 5.0;

	fFormatMF = new BMenuField(rect, "format popup", B_TRANSLATE("Format"),
								fFormatM, true,
								B_FOLLOW_LEFT | B_FOLLOW_BOTTOM,
								B_WILL_DRAW | B_NAVIGABLE);
	fFormatMF->SetDivider(be_plain_font->StringWidth(
		B_TRANSLATE("Format")) + 7);
	fFormatMF->MenuBar()->ResizeToPreferred();
	fFormatMF->ResizeToPreferred();

	float height = fFormatMF->Bounds().Height() + 8.0;

	// find all the views that are in the way and
	// move up them up the height of the menu field
	BView *poseview = background->FindView("PoseView");
	if (poseview) poseview->ResizeBy(0, -height);
	BView *countvw = (BView *)background->FindView("CountVw");
	if (countvw) countvw->MoveBy(0, -height);
	textview->MoveBy(0, -height);

#if HAIKU_TARGET_PLATFORM_DANO
	fFormatMF->MoveTo(textview->Frame().left, fFormatMF->Frame().top + 2);
#else
	fFormatMF->MoveTo(textview->Frame().left, fFormatMF->Frame().top);
#endif

	background->AddChild(fFormatMF);

	// Build the "Settings" button relative to the format menu
	rect = cancel->Frame();
	rect.OffsetTo(fFormatMF->Frame().right + 5.0, rect.top);
	fSettingsB = new BButton(rect, "settings",
							 B_TRANSLATE("Settings" B_UTF8_ELLIPSIS),
							 new BMessage(MSG_SETTINGS),
							 B_FOLLOW_LEFT | B_FOLLOW_BOTTOM,
							 B_WILL_DRAW | B_NAVIGABLE);
	fSettingsB->ResizeToPreferred();
	background->AddChild(fSettingsB);
	fSettingsB->SetTarget(this);

	textview->ResizeTo(fSettingsB->Frame().right - fFormatMF->Frame().left,
					   textview->Frame().Height());

	BButton *insert = (BButton *)background->FindView("default button");

	// Make sure the smallest window won't draw the "Settings" button over
	// anything else
	float minWindowWidth = textview->Bounds().Width()
							+ cancel->Bounds().Width()
							+ (insert ? insert->Bounds().Width() : 0.0)
							+ 90;
	Window()->SetSizeLimits(minWindowWidth, 10000, 250, 10000);
	if (Window()->Bounds().IntegerWidth() + 1 < minWindowWidth)
		Window()->ResizeTo(minWindowWidth, Window()->Bounds().Height());


	// Init window title
	SetExportMode(true);

	window->Unlock();
}

// destructor
SavePanel::~SavePanel()
{
}

// SendMessage
void
SavePanel::SendMessage(const BMessenger* messenger, BMessage* message)
{
	// add the current format information to the message,
	// bot only if we are indeed in export mode
	if (message && fFormatM->IsEnabled())
		message->AddInt32("export mode", ExportMode());
	// let the original file panel code handle the rest
	BFilePanel::SendMessage(messenger, message);
}

// MessageReceived
void
SavePanel::MessageReceived(BMessage* message)
{
	// Handle messages from controls we've added
	switch (message->what) {
		case MSG_FORMAT:
			fExportMode = ExportMode();
			AdjustExtension();
				// TODO: make this behaviour a setting
			_EnableSettings();
			break;
		case MSG_SETTINGS:
			_ExportSettings();
			break;
		default:
			BHandler::MessageReceived(message);
			break;
	}
}

// SetExportMode
void
SavePanel::SetExportMode(bool exportMode)
{
	BWindow* window = Window();
	if (!window || !window->Lock())
		return;

	// adjust window title and enable format menu
	BString title(B_TRANSLATE_SYSTEM_NAME("Icon-O-Matic"));
	title  << ": ";
	if (exportMode) {
		fFormatMF->SetEnabled(true);
		SetExportMode(fExportMode);
		_EnableSettings();
		title << B_TRANSLATE_COMMENT("Export icon", "Dialog title");
	} else {
		fExportMode = ExportMode();
			// does not overwrite fExportMode in case we already were
			// in native save mode
		fNativeMI->SetMarked(true);

		fFormatMF->SetEnabled(false);
		fSettingsB->SetEnabled(false);
		title << B_TRANSLATE_COMMENT("Save icon", "Dialog title");
	}

	window->SetTitle(title);
	window->Unlock();
}

// SetExportMode
void
SavePanel::SetExportMode(int32 mode)
{
	BWindow* window = Window();
	if (!window || !window->Lock())
		return;

	switch (mode) {
		case EXPORT_MODE_MESSAGE:
			fNativeMI->SetMarked(true);
			break;
		case EXPORT_MODE_FLAT_ICON:
			fHVIFMI->SetMarked(true);
			break;
		case EXPORT_MODE_SVG:
			fSVGMI->SetMarked(true);
			break;
		case EXPORT_MODE_BITMAP_16:
			fBitmap16MI->SetMarked(true);
			break;
		case EXPORT_MODE_BITMAP_32:
			fBitmap32MI->SetMarked(true);
			break;
		case EXPORT_MODE_BITMAP_64:
			fBitmap64MI->SetMarked(true);
			break;
		case EXPORT_MODE_BITMAP_SET:
			fBitmapSetMI->SetMarked(true);
			break;
		case EXPORT_MODE_ICON_ATTR:
			fIconAttrMI->SetMarked(true);
			break;
		case EXPORT_MODE_ICON_MIME_ATTR:
			fIconMimeAttrMI->SetMarked(true);
			break;
		case EXPORT_MODE_ICON_RDEF:
			fRDefMI->SetMarked(true);
			break;
		case EXPORT_MODE_ICON_SOURCE:
			fSourceMI->SetMarked(true);
			break;
	}

	if (mode != EXPORT_MODE_MESSAGE)
		fExportMode = mode;

	fFormatMF->SetEnabled(mode != EXPORT_MODE_MESSAGE);
	_EnableSettings();

	window->Unlock();
}

// ExportMode
int32
SavePanel::ExportMode() const
{
	int32 mode = fExportMode;
	BWindow* window = Window();
	if (!window || !window->Lock())
		return mode;

	if (fFormatMF->IsEnabled()) {
		// means we are actually in export mode
		SaveItem* item = _GetCurrentMenuItem();
		mode = item->ExportMode();
	}
	window->Unlock();

	return mode;
}

// AdjustExtension
void
SavePanel::AdjustExtension()
{
//	if (!Window()->Lock())
//		return;
//
//	BView* background = Window()->ChildAt(0);
//	BTextControl* textview = dynamic_cast<BTextControl*>(
//		background->FindView("text view"));
//
//	if (textview) {
//
//		translator_id id = 0;
//		uint32 format = 0;
//		int32 mode = ExportMode();
//		SaveItem* exportItem = dynamic_cast<SaveItem*>(_GetCurrentMenuItem());
//		if (mode == EXPORT_TRANSLATOR && exportItem) {
//			id = exportItem->id;
//			format = exportItem->format;
//		}
//
//		Exporter* exporter = Exporter::ExporterFor(mode, id, format);
//
//		if (exporter) {
//			BString name(textview->Text());
//
//			// adjust the name extension
//			const char* extension = exporter->Extension();
//			if (strlen(extension) > 0) {
//				int32 cutPos = name.FindLast('.');
//				int32 cutCount = name.Length() - cutPos;
//				if (cutCount > 0 && cutCount <= 4) {
//					name.Remove(cutPos, cutCount);
//				}
//				name << "." << extension;
//			}
//
//			SetSaveText(name.String());
//		}
//
//		delete exporter;
//	}
//	Window()->Unlock();
}

// _GetCurrentMenuItem
SaveItem*
SavePanel::_GetCurrentMenuItem() const
{
	SaveItem* item = dynamic_cast<SaveItem*>(fFormatM->FindMarked());
	if (!item)
		return fNativeMI;
	return item;
}

// _ExportSettings
void
SavePanel::_ExportSettings()
{
//	SaveItem *item = dynamic_cast<SaveItem*>(_GetCurrentMenuItem());
//	if (item == NULL)
//		return;
//
//	BTranslatorRoster *roster = BTranslatorRoster::Default();
//	BView *view;
//	BRect rect(0, 0, 239, 239);
//
//	// Build a window around this translator's configuration view
//	status_t err = roster->MakeConfigurationView(item->id, NULL, &view, &rect);
//	if (err < B_OK || view == NULL) {
//		BAlert *alert = new BAlert(NULL, strerror(err), B_TRANSLATE("OK"));
//		alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
//		alert->Go();
//	} else {
//		if (fConfigWindow != NULL) {
//			if (fConfigWindow->Lock())
//				fConfigWindow->Quit();
//		}
//		fConfigWindow = new Panel(rect, "Translator Settings",
//								  B_TITLED_WINDOW_LOOK,
//								  B_NORMAL_WINDOW_FEEL,
//								  B_NOT_ZOOMABLE | B_NOT_RESIZABLE);
//		fConfigWindow->AddChild(view);
//		// Just to make sure
//		view->MoveTo(0, 0);
//		view->ResizeTo(rect.Width(), rect.Height());
//		view->ResizeToPreferred();
//		fConfigWindow->MoveTo(100, 100);
//		fConfigWindow->Show();
//	}
}

// _BuildMenu
void
SavePanel::_BuildMenu()
{
	fFormatM = new BPopUpMenu(B_TRANSLATE("Format"));

	fNativeMI = new SaveItem("Icon-O-Matic",
		new BMessage(MSG_FORMAT), EXPORT_MODE_MESSAGE);
	fFormatM->AddItem(fNativeMI);
	fNativeMI->SetEnabled(false);

	fFormatM->AddSeparatorItem();

	fHVIFMI = new SaveItem("HVIF",
		new BMessage(MSG_FORMAT), EXPORT_MODE_FLAT_ICON);
	fFormatM->AddItem(fHVIFMI);

	fRDefMI = new SaveItem("HVIF RDef",
		new BMessage(MSG_FORMAT), EXPORT_MODE_ICON_RDEF);
	fFormatM->AddItem(fRDefMI);

	fSourceMI = new SaveItem(B_TRANSLATE("HVIF source code"),
		new BMessage(MSG_FORMAT), EXPORT_MODE_ICON_SOURCE);
	fFormatM->AddItem(fSourceMI);

	fFormatM->AddSeparatorItem();

	fSVGMI = new SaveItem("SVG",
		new BMessage(MSG_FORMAT), EXPORT_MODE_SVG);

	fFormatM->AddItem(fSVGMI);

	fFormatM->AddSeparatorItem();

	fBitmap16MI = new SaveItem("PNG 16x16",
		new BMessage(MSG_FORMAT), EXPORT_MODE_BITMAP_16);
	fFormatM->AddItem(fBitmap16MI);

	fBitmap32MI = new SaveItem("PNG 32x32",
		new BMessage(MSG_FORMAT), EXPORT_MODE_BITMAP_32);
	fFormatM->AddItem(fBitmap32MI);

	fBitmap64MI = new SaveItem("PNG 64x64",
		new BMessage(MSG_FORMAT), EXPORT_MODE_BITMAP_64);
	fFormatM->AddItem(fBitmap64MI);

	fBitmapSetMI = new SaveItem(B_TRANSLATE("PNG set"),
		new BMessage(MSG_FORMAT), EXPORT_MODE_BITMAP_SET);
	fFormatM->AddItem(fBitmapSetMI);

	fFormatM->AddSeparatorItem();

	fIconAttrMI = new SaveItem(B_TRANSLATE("BEOS:ICON attribute"),
		new BMessage(MSG_FORMAT), EXPORT_MODE_ICON_ATTR);
	fFormatM->AddItem(fIconAttrMI);

	fIconMimeAttrMI = new SaveItem(B_TRANSLATE("META:ICON attribute"),
		new BMessage(MSG_FORMAT), EXPORT_MODE_ICON_MIME_ATTR);

	fFormatM->AddItem(fIconMimeAttrMI);


	fFormatM->SetTargetForItems(this);

	// pick the RDef item in the list
	fRDefMI->SetMarked(true);
}

// _EnableSettings
void
SavePanel::_EnableSettings() const
{
	// no settings currently necessary
	fSettingsB->SetEnabled(false);
}