haiku.git

/*
 * Copyright 2015-2016, Rene Gollent, rene@gollent.com.
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "IntegerValueHandler.h"

#include <new>

#include <AutoDeleter.h>

#include "IntegerValue.h"
#include "Setting.h"
#include "Settings.h"
#include "SettingsDescription.h"
#include "SettingsMenu.h"
#include "TableCellFormattedValueRenderer.h"
#include "TableCellIntegerEditor.h"


static const char* const kFormatSettingID = "format";


// #pragma mark - FormatOption


class IntegerValueHandler::FormatOption : public SettingsOption {
public:
	FormatOption(const char* id, const char* name, integer_format format)
		:
		fID(id),
		fName(name),
		fFormat(format)
	{
	}

	virtual const char* ID() const
	{
		return fID;
	}

	virtual const char* Name() const
	{
		return fName;
	}

	integer_format Format() const
	{
		return fFormat;
	}

private:
	const char*		fID;
	const char*		fName;
	integer_format	fFormat;
};


// #pragma mark - IntegerFormatterConfig


class IntegerValueHandler::IntegerFormatterConfig
	: public IntegerValueFormatter::Config {
public:
	IntegerFormatterConfig()
		:
		fSettings(NULL),
		fFormatSetting(NULL)
	{
	}

	~IntegerFormatterConfig()
	{
		if (fSettings != NULL)
			fSettings->ReleaseReference();
	}

	status_t Init(SettingsDescription* settingsDescription)
	{
		fSettings = new(std::nothrow) Settings(settingsDescription);
		if (fSettings == NULL)
			return B_NO_MEMORY;

		status_t error = fSettings->Init();
		if (error != B_OK)
			return error;

		fFormatSetting = dynamic_cast<OptionsSetting*>(
			settingsDescription->SettingByID(kFormatSettingID));
		if (fFormatSetting == NULL)
			return B_BAD_VALUE;

		return B_OK;
	}

	virtual Settings* GetSettings() const
	{
		return fSettings;
	}

	virtual integer_format IntegerFormat() const
	{
		FormatOption* option = dynamic_cast<FormatOption*>(
			fSettings->OptionValue(fFormatSetting));
		return option != NULL ? option->Format() : INTEGER_FORMAT_DEFAULT;
	}

private:
	Settings*		fSettings;
	OptionsSetting*	fFormatSetting;
};


// #pragma mark - IntegerValueHandler


IntegerValueHandler::IntegerValueHandler()
{
}


IntegerValueHandler::~IntegerValueHandler()
{
}


status_t
IntegerValueHandler::Init()
{
	return B_OK;
}


float
IntegerValueHandler::SupportsValue(Value* value)
{
	return dynamic_cast<IntegerValue*>(value) != NULL ? 0.5f : 0;
}


status_t
IntegerValueHandler::GetValueFormatter(Value* _value,
	ValueFormatter*& _formatter)
{
	IntegerValue* value = dynamic_cast<IntegerValue*>(_value);
	if (value == NULL)
		return B_BAD_VALUE;

	IntegerValueFormatter::Config* config = NULL;
	status_t error = CreateIntegerFormatterConfig(value, config);
	if (error != B_OK)
		return error;

	BReference<IntegerValueFormatter::Config> configReference(config, true);
	ValueFormatter* formatter = new(std::nothrow) IntegerValueFormatter(config);
	if (formatter == NULL)
		return B_NO_MEMORY;

	_formatter = formatter;
	return B_OK;
}


status_t
IntegerValueHandler::GetTableCellValueRenderer(Value* _value,
	TableCellValueRenderer*& _renderer)
{
	IntegerValue* value = dynamic_cast<IntegerValue*>(_value);
	if (value == NULL)
		return B_BAD_VALUE;

	IntegerValueFormatter::Config* config = NULL;
	status_t error = CreateIntegerFormatterConfig(value, config);
	if (error != B_OK)
		return error;
	BReference<IntegerValueFormatter::Config> configReference(config, true);

	// create the renderer
	return CreateTableCellValueRenderer(value, config, _renderer);
}


status_t
IntegerValueHandler::GetTableCellValueEditor(Value* _value,
	Settings* settings, TableCellValueEditor*& _editor)
{
	IntegerValue* value = dynamic_cast<IntegerValue*>(_value);
	if (value == NULL)
		return B_BAD_VALUE;

	IntegerValueFormatter::Config* config = NULL;
	status_t error = CreateIntegerFormatterConfig(value, config);
	if (error != B_OK)
		return error;
	BReference<IntegerValueFormatter::Config> configReference(config, true);

	ValueFormatter* formatter;
	error = CreateValueFormatter(config, formatter);
	if (error != B_OK)
		return error;
	BReference<ValueFormatter> formatterReference(formatter, true);

	TableCellIntegerEditor* editor = new(std::nothrow) TableCellIntegerEditor(
		value, formatter);
	if (editor == NULL)
		return B_NO_MEMORY;

	BReference<TableCellIntegerEditor> editorReference(editor, true);
	error = editor->Init();
	if (error != B_OK)
		return error;

	editorReference.Detach();
	_editor = editor;
	return B_OK;
}


status_t
IntegerValueHandler::CreateTableCellValueSettingsMenu(Value* value,
	Settings* settings, SettingsMenu*& _menu)
{
	// get the format option
	OptionsSetting* formatSetting = dynamic_cast<OptionsSetting*>(
		settings->Description()->SettingByID(kFormatSettingID));
	if (formatSetting == NULL)
		return B_BAD_VALUE;

	// create the settings menu
	SettingsMenuImpl* menu = new(std::nothrow) SettingsMenuImpl(settings);
	if (menu == NULL)
		return B_NO_MEMORY;
	ObjectDeleter<SettingsMenu> menuDeleter(menu);

	// add the format option menu item
	if (!menu->AddOptionsItem(formatSetting))
		return B_NO_MEMORY;

	_menu = menuDeleter.Detach();
	return B_OK;
}


integer_format
IntegerValueHandler::DefaultIntegerFormat(IntegerValue* value)
{
	return value->IsSigned() ? INTEGER_FORMAT_SIGNED : INTEGER_FORMAT_UNSIGNED;
}


status_t
IntegerValueHandler::AddIntegerFormatSettingOptions(IntegerValue* value,
	OptionsSettingImpl* setting)
{
	status_t error = AddIntegerFormatOption(setting, "signed", "Signed",
		INTEGER_FORMAT_SIGNED);
	if (error != B_OK)
		return error;

	error = AddIntegerFormatOption(setting, "unsigned", "Unsigned",
		INTEGER_FORMAT_UNSIGNED);
	if (error != B_OK)
		return error;

	error = AddIntegerFormatOption(setting, "hex", "Hexadecimal",
		INTEGER_FORMAT_HEX_DEFAULT);
	if (error != B_OK)
		return error;

	return B_OK;
}


status_t
IntegerValueHandler::CreateValueFormatter(
	IntegerValueFormatter::Config* config,
	ValueFormatter*& _formatter)
{
	ValueFormatter* formatter = new(std::nothrow) IntegerValueFormatter(
		config);
	if (formatter == NULL)
		return B_NO_MEMORY;

	_formatter = formatter;
	return B_OK;
}


status_t
IntegerValueHandler::CreateTableCellValueRenderer(IntegerValue* value,
	IntegerValueFormatter::Config* config,
	TableCellValueRenderer*& _renderer)
{
	ValueFormatter* formatter;
	status_t error = CreateValueFormatter(config, formatter);
	if (error != B_OK)
		return error;
	BReference<ValueFormatter> formatterReference(formatter, true);

	TableCellValueRenderer* renderer
		= new(std::nothrow) TableCellFormattedValueRenderer(formatter);
	if (renderer == NULL)
		return B_NO_MEMORY;

	_renderer = renderer;
	return B_OK;
}


status_t
IntegerValueHandler::CreateIntegerFormatterConfig(IntegerValue* value,
	IntegerValueFormatter::Config*& _config)
{
	// create a settings description
	SettingsDescription* settingsDescription
		= _CreateTableCellSettingsDescription(value);
	if (settingsDescription == NULL)
		return B_NO_MEMORY;
	BReference<SettingsDescription> settingsDescriptionReference(
		settingsDescription, true);

	// create config
	IntegerFormatterConfig* config = new(std::nothrow) IntegerFormatterConfig;
	if (config == NULL)
		return B_NO_MEMORY;
	BReference<IntegerFormatterConfig> configReference(config, true);

	status_t error = config->Init(settingsDescription);
	if (error != B_OK)
		return error;

	_config = config;
	configReference.Detach();

	return B_OK;
}


status_t
IntegerValueHandler::AddIntegerFormatOption(OptionsSettingImpl* setting,
	const char* id, const char* name, integer_format format)
{
	FormatOption* option = new(std::nothrow) FormatOption(id, name, format);
	BReference<FormatOption> optionReference(option, true);
	if (option == NULL || !setting->AddOption(option))
		return B_NO_MEMORY;

	return B_OK;
}


SettingsDescription*
IntegerValueHandler::_CreateTableCellSettingsDescription(
	IntegerValue* value)
{
	// create description object
	SettingsDescription* description = new(std::nothrow) SettingsDescription;
	if (description == NULL)
		return NULL;
	BReference<SettingsDescription> descriptionReference(description, true);

	// integer format setting
	OptionsSettingImpl* setting = new(std::nothrow) OptionsSettingImpl(
		kFormatSettingID, "Format");
	if (setting == NULL)
		return NULL;
	BReference<OptionsSettingImpl> settingReference(setting, true);

	// add options
	if (AddIntegerFormatSettingOptions(value, setting) != B_OK)
		return NULL;

	// set default
	integer_format defaultFormat = DefaultIntegerFormat(value);
	SettingsOption* defaultOption = setting->OptionAt(0);
	for (int32 i = 0;
		FormatOption* option
			= dynamic_cast<FormatOption*>(setting->OptionAt(i));
		i++) {
		if (option->Format() == defaultFormat) {
			defaultOption = option;
			break;
		}
	}

	setting->SetDefaultOption(defaultOption);

	// add setting
	if (!description->AddSetting(setting))
		return NULL;

	return descriptionReference.Detach();
}