2007-11-16 18:25:45 +00:00
|
|
|
/* ASE - Allegro Sprite Editor
|
2010-02-01 21:25:40 +00:00
|
|
|
* Copyright (C) 2001-2010 David Capello
|
2007-09-23 20:13:58 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
2008-03-22 18:43:56 +00:00
|
|
|
#include <allegro.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2010-03-28 15:15:32 +00:00
|
|
|
#include <vector>
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-09-25 20:20:59 +00:00
|
|
|
#include "base/bind.h"
|
2010-09-26 18:59:32 +00:00
|
|
|
#include "gui/jinete.h"
|
2007-09-23 20:13:58 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
#include "app.h"
|
2010-09-25 19:22:32 +00:00
|
|
|
#include "app/color.h"
|
2009-10-09 01:34:06 +00:00
|
|
|
#include "commands/command.h"
|
2010-04-10 20:01:56 +00:00
|
|
|
#include "commands/params.h"
|
2008-03-22 18:43:56 +00:00
|
|
|
#include "core/cfg.h"
|
|
|
|
#include "dialogs/filesel.h"
|
2010-09-25 19:22:32 +00:00
|
|
|
#include "gfx/size.h"
|
2010-04-10 20:01:56 +00:00
|
|
|
#include "modules/editors.h"
|
2010-09-25 19:22:32 +00:00
|
|
|
#include "modules/gui.h"
|
2008-03-22 18:43:56 +00:00
|
|
|
#include "modules/palettes.h"
|
|
|
|
#include "raster/image.h"
|
|
|
|
#include "raster/palette.h"
|
|
|
|
#include "raster/sprite.h"
|
|
|
|
#include "raster/stock.h"
|
2010-06-17 05:17:42 +00:00
|
|
|
#include "raster/undo.h"
|
2010-09-25 19:22:32 +00:00
|
|
|
#include "sprite_wrappers.h"
|
|
|
|
#include "ui_context.h"
|
2008-03-22 18:43:56 +00:00
|
|
|
#include "util/quantize.h"
|
2010-08-23 21:11:47 +00:00
|
|
|
#include "widgets/color_bar.h"
|
2008-03-22 18:43:56 +00:00
|
|
|
#include "widgets/colview.h"
|
2010-04-10 20:01:56 +00:00
|
|
|
#include "widgets/editor.h"
|
2008-03-22 18:43:56 +00:00
|
|
|
#include "widgets/paledit.h"
|
2010-04-25 17:40:40 +00:00
|
|
|
#include "widgets/statebar.h"
|
2010-04-10 20:01:56 +00:00
|
|
|
|
2010-09-25 19:22:32 +00:00
|
|
|
using namespace gfx;
|
2010-08-03 01:57:41 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static Frame* window = NULL;
|
|
|
|
static int redraw_timer_id = -1;
|
|
|
|
static bool redraw_all = false;
|
|
|
|
|
|
|
|
// Slot for App::Exit signal
|
|
|
|
static void on_exit_delete_this_widget()
|
|
|
|
{
|
2010-08-04 02:33:44 +00:00
|
|
|
ASSERT(window != NULL);
|
2010-04-10 20:01:56 +00:00
|
|
|
|
|
|
|
jmanager_remove_timer(redraw_timer_id);
|
|
|
|
redraw_timer_id = -1;
|
|
|
|
|
|
|
|
jwidget_free(window);
|
|
|
|
}
|
2009-10-09 01:34:06 +00:00
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// palette_editor
|
|
|
|
|
|
|
|
class PaletteEditorCommand : public Command
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
PaletteEditorCommand();
|
|
|
|
Command* clone() { return new PaletteEditorCommand(*this); }
|
|
|
|
|
|
|
|
protected:
|
2010-07-31 15:23:45 +00:00
|
|
|
void onLoadParams(Params* params);
|
|
|
|
void onExecute(Context* context);
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
private:
|
|
|
|
bool m_open;
|
|
|
|
bool m_close;
|
|
|
|
bool m_switch;
|
|
|
|
bool m_background;
|
|
|
|
};
|
2009-06-11 15:11:11 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
// #define get_sprite(wgt) (*(const SpriteReader*)(wgt->getRoot())->user_data[0])
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static Widget *R_label, *G_label, *B_label;
|
|
|
|
static Widget *H_label, *S_label, *V_label;
|
|
|
|
static Widget *R_slider, *G_slider, *B_slider;
|
|
|
|
static Widget *H_slider, *S_slider, *V_slider;
|
|
|
|
static Widget *R_entry, *G_entry, *B_entry;
|
|
|
|
static Widget *H_entry, *S_entry, *V_entry;
|
|
|
|
static Widget *hex_entry;
|
|
|
|
static PalEdit* palette_editor;
|
2010-06-13 22:35:40 +00:00
|
|
|
static Widget* more_options = NULL;
|
2010-04-10 20:01:56 +00:00
|
|
|
static bool disable_colorbar_signals = false;
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static bool window_msg_proc(JWidget widget, JMessage msg);
|
|
|
|
static bool window_close_hook(JWidget widget, void *data);
|
2008-03-22 18:43:56 +00:00
|
|
|
static void load_command(JWidget widget);
|
|
|
|
static void save_command(JWidget widget);
|
|
|
|
static void ramp_command(JWidget widget);
|
2010-06-13 23:04:38 +00:00
|
|
|
static void sort_command(JWidget widget);
|
2008-03-22 18:43:56 +00:00
|
|
|
static void quantize_command(JWidget widget);
|
|
|
|
|
|
|
|
static bool sliderRGB_change_hook(JWidget widget, void *data);
|
|
|
|
static bool sliderHSV_change_hook(JWidget widget, void *data);
|
2010-04-10 20:01:56 +00:00
|
|
|
static bool entryRGB_change_hook(JWidget widget, void *data);
|
|
|
|
static bool entryHSV_change_hook(JWidget widget, void *data);
|
|
|
|
static bool hex_entry_change_hook(JWidget widget, void *data);
|
|
|
|
static void update_entries_from_sliders();
|
|
|
|
static void update_sliders_from_entries();
|
|
|
|
static void update_hex_entry();
|
2010-12-02 02:41:20 +00:00
|
|
|
static void update_current_sprite_palette(const char* operationName);
|
2010-04-10 20:01:56 +00:00
|
|
|
static void update_colorbar();
|
2008-03-22 18:43:56 +00:00
|
|
|
static bool palette_editor_change_hook(JWidget widget, void *data);
|
2010-04-10 20:01:56 +00:00
|
|
|
static bool select_rgb_hook(JWidget widget, void *data);
|
|
|
|
static bool select_hsv_hook(JWidget widget, void *data);
|
2010-06-13 22:35:40 +00:00
|
|
|
static bool expand_button_select_hook(JWidget widget, void *data);
|
2010-04-10 20:01:56 +00:00
|
|
|
static void modify_all_selected_entries_in_palette(int r, int g, int b);
|
2010-08-25 03:26:37 +00:00
|
|
|
static void on_color_changed(const Color& color);
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-12-02 02:41:20 +00:00
|
|
|
static void set_new_palette(Palette *palette, const char* operationName);
|
2007-09-23 20:13:58 +00:00
|
|
|
|
2009-10-09 01:34:06 +00:00
|
|
|
PaletteEditorCommand::PaletteEditorCommand()
|
|
|
|
: Command("palette_editor",
|
|
|
|
"PaletteEditor",
|
|
|
|
CmdRecordableFlag)
|
|
|
|
{
|
2010-04-10 20:01:56 +00:00
|
|
|
m_open = true;
|
|
|
|
m_close = false;
|
|
|
|
m_switch = false;
|
|
|
|
m_background = false;
|
|
|
|
}
|
|
|
|
|
2010-07-31 15:23:45 +00:00
|
|
|
void PaletteEditorCommand::onLoadParams(Params* params)
|
2010-04-10 20:01:56 +00:00
|
|
|
{
|
|
|
|
std::string target = params->get("target");
|
|
|
|
if (target == "foreground") m_background = false;
|
|
|
|
else if (target == "background") m_background = true;
|
|
|
|
|
|
|
|
std::string open_str = params->get("open");
|
|
|
|
if (open_str == "true") m_open = true;
|
|
|
|
else m_open = false;
|
|
|
|
|
|
|
|
std::string close_str = params->get("close");
|
|
|
|
if (close_str == "true") m_close = true;
|
|
|
|
else m_close = false;
|
|
|
|
|
|
|
|
std::string switch_str = params->get("switch");
|
|
|
|
if (switch_str == "true") m_switch = true;
|
|
|
|
else m_switch = false;
|
2009-10-09 01:34:06 +00:00
|
|
|
}
|
|
|
|
|
2010-07-31 15:23:45 +00:00
|
|
|
void PaletteEditorCommand::onExecute(Context* context)
|
2007-12-05 01:30:50 +00:00
|
|
|
{
|
2010-04-10 20:01:56 +00:00
|
|
|
Widget* palette_editor_view;
|
|
|
|
Widget* select_rgb;
|
|
|
|
Widget* select_hsv;
|
2010-08-23 20:41:19 +00:00
|
|
|
Button* expand_button;
|
|
|
|
Button* button_load;
|
|
|
|
Button* button_save;
|
|
|
|
Button* button_ramp;
|
|
|
|
Button* button_sort;
|
|
|
|
Button* button_quantize;
|
2010-04-10 20:01:56 +00:00
|
|
|
bool first_time = false;
|
|
|
|
|
|
|
|
// If the window was never loaded yet, load it
|
|
|
|
if (!window) {
|
|
|
|
if (m_close)
|
|
|
|
return; // Do nothing (the user want to close and inexistent window)
|
|
|
|
|
|
|
|
// Load the palette editor window
|
|
|
|
window = static_cast<Frame*>(load_widget("palette_editor.xml", "palette_editor"));
|
|
|
|
redraw_timer_id = jmanager_add_timer(window, 250);
|
|
|
|
|
|
|
|
first_time = true;
|
|
|
|
|
|
|
|
// Append hooks
|
2010-09-25 20:20:59 +00:00
|
|
|
window->Close.connect(Bind<bool>(&window_close_hook, (JWidget)window, (void*)0));
|
2010-04-10 20:01:56 +00:00
|
|
|
|
|
|
|
// Hook fg/bg color changes (by eyedropper mainly)
|
|
|
|
app_get_colorbar()->FgColorChange.connect(&on_color_changed);
|
|
|
|
app_get_colorbar()->BgColorChange.connect(&on_color_changed);
|
|
|
|
|
|
|
|
// Hook App::Exit signal
|
|
|
|
App::instance()->Exit.connect(&on_exit_delete_this_widget);
|
|
|
|
}
|
|
|
|
// If the window is opened, close it (only in "switch" mode)
|
2010-07-04 15:03:14 +00:00
|
|
|
else if (window->isVisible() && (m_switch || m_close)) {
|
2010-04-10 20:01:56 +00:00
|
|
|
window->closeWindow(NULL);
|
2008-03-22 18:43:56 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-06-11 15:11:11 +00:00
|
|
|
get_widgets(window,
|
2010-04-10 20:01:56 +00:00
|
|
|
"R_label", &R_label,
|
|
|
|
"R_slider", &R_slider,
|
|
|
|
"R_entry", &R_entry,
|
|
|
|
"G_label", &G_label,
|
|
|
|
"G_slider", &G_slider,
|
|
|
|
"G_entry", &G_entry,
|
|
|
|
"B_label", &B_label,
|
|
|
|
"B_slider", &B_slider,
|
|
|
|
"B_entry", &B_entry,
|
|
|
|
"H_label", &H_label,
|
|
|
|
"H_slider", &H_slider,
|
|
|
|
"H_entry", &H_entry,
|
|
|
|
"S_label", &S_label,
|
|
|
|
"S_slider", &S_slider,
|
|
|
|
"S_entry", &S_entry,
|
|
|
|
"V_label", &V_label,
|
|
|
|
"V_slider", &V_slider,
|
|
|
|
"V_entry", &V_entry,
|
|
|
|
"hex_entry", &hex_entry,
|
|
|
|
"select_rgb", &select_rgb,
|
|
|
|
"select_hsv", &select_hsv,
|
2010-06-13 22:35:40 +00:00
|
|
|
"expand", &expand_button,
|
|
|
|
"more_options", &more_options,
|
2010-06-13 23:04:38 +00:00
|
|
|
"load", &button_load,
|
|
|
|
"save", &button_save,
|
|
|
|
"ramp", &button_ramp,
|
|
|
|
"sort", &button_sort,
|
|
|
|
"quantize", &button_quantize,
|
2010-04-10 20:01:56 +00:00
|
|
|
"palette_editor", &palette_editor_view, NULL);
|
2010-03-28 15:15:32 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
// Custom widgets
|
|
|
|
if (first_time) {
|
|
|
|
palette_editor = new PalEdit(true);
|
2010-06-13 21:06:11 +00:00
|
|
|
palette_editor->setBoxSize(4*jguiscale());
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
jview_attach(palette_editor_view, palette_editor);
|
|
|
|
jview_maxsize(palette_editor_view);
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
// Set palette editor columns
|
|
|
|
palette_editor->setColumns(16);
|
|
|
|
|
|
|
|
// Hook signals
|
|
|
|
jwidget_add_hook(window, -1, window_msg_proc, NULL);
|
|
|
|
HOOK(R_slider, JI_SIGNAL_SLIDER_CHANGE, sliderRGB_change_hook, 0);
|
|
|
|
HOOK(G_slider, JI_SIGNAL_SLIDER_CHANGE, sliderRGB_change_hook, 0);
|
|
|
|
HOOK(B_slider, JI_SIGNAL_SLIDER_CHANGE, sliderRGB_change_hook, 0);
|
|
|
|
HOOK(H_slider, JI_SIGNAL_SLIDER_CHANGE, sliderHSV_change_hook, 0);
|
|
|
|
HOOK(S_slider, JI_SIGNAL_SLIDER_CHANGE, sliderHSV_change_hook, 0);
|
|
|
|
HOOK(V_slider, JI_SIGNAL_SLIDER_CHANGE, sliderHSV_change_hook, 0);
|
|
|
|
HOOK(R_entry, JI_SIGNAL_ENTRY_CHANGE, entryRGB_change_hook, 0);
|
|
|
|
HOOK(G_entry, JI_SIGNAL_ENTRY_CHANGE, entryRGB_change_hook, 0);
|
|
|
|
HOOK(B_entry, JI_SIGNAL_ENTRY_CHANGE, entryRGB_change_hook, 0);
|
|
|
|
HOOK(H_entry, JI_SIGNAL_ENTRY_CHANGE, entryHSV_change_hook, 0);
|
|
|
|
HOOK(S_entry, JI_SIGNAL_ENTRY_CHANGE, entryHSV_change_hook, 0);
|
|
|
|
HOOK(V_entry, JI_SIGNAL_ENTRY_CHANGE, entryHSV_change_hook, 0);
|
|
|
|
HOOK(hex_entry, JI_SIGNAL_ENTRY_CHANGE, hex_entry_change_hook, 0);
|
|
|
|
HOOK(palette_editor, SIGNAL_PALETTE_EDITOR_CHANGE, palette_editor_change_hook, 0);
|
|
|
|
HOOK(select_rgb, JI_SIGNAL_RADIO_CHANGE, select_rgb_hook, 0);
|
|
|
|
HOOK(select_hsv, JI_SIGNAL_RADIO_CHANGE, select_hsv_hook, 0);
|
2010-06-13 22:35:40 +00:00
|
|
|
HOOK(expand_button, JI_SIGNAL_BUTTON_SELECT, expand_button_select_hook, 0);
|
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
setup_mini_look(select_rgb);
|
|
|
|
setup_mini_look(select_hsv);
|
|
|
|
|
2010-06-15 22:46:39 +00:00
|
|
|
// Hide (or show) the "More Options" depending the saved value in .cfg file
|
2010-07-04 15:03:14 +00:00
|
|
|
more_options->setVisible(get_config_bool("PaletteEditor", "ShowMoreOptions", false));
|
2010-06-13 22:35:40 +00:00
|
|
|
|
2010-09-25 20:20:59 +00:00
|
|
|
button_load->Click.connect(Bind<void>(&load_command, button_load));
|
|
|
|
button_save->Click.connect(Bind<void>(&save_command, button_save));
|
|
|
|
button_ramp->Click.connect(Bind<void>(&ramp_command, button_ramp));
|
|
|
|
button_sort->Click.connect(Bind<void>(&sort_command, button_sort));
|
|
|
|
button_quantize->Click.connect(Bind<void>(&quantize_command, button_quantize));
|
2010-04-10 20:01:56 +00:00
|
|
|
|
|
|
|
select_rgb_hook(NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Show the specified target color
|
|
|
|
{
|
2010-08-25 03:26:37 +00:00
|
|
|
Color color =
|
2010-04-10 20:01:56 +00:00
|
|
|
(m_background ? context->getSettings()->getBgColor():
|
|
|
|
context->getSettings()->getFgColor());
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
on_color_changed(color);
|
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
if (m_switch || m_open) {
|
2010-07-04 15:03:14 +00:00
|
|
|
if (!window->isVisible()) {
|
2010-04-25 17:40:40 +00:00
|
|
|
// Default bounds
|
2010-04-10 20:01:56 +00:00
|
|
|
window->remap_window();
|
2010-04-25 17:40:40 +00:00
|
|
|
|
|
|
|
int width = MAX(jrect_w(window->rc), JI_SCREEN_W/2);
|
|
|
|
window->setBounds(Rect(JI_SCREEN_W - width - jrect_w(app_get_toolbar()->rc),
|
|
|
|
JI_SCREEN_H - jrect_h(window->rc) - jrect_h(app_get_statusbar()->rc),
|
|
|
|
width, jrect_h(window->rc)));
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
// Load window configuration
|
|
|
|
load_window_pos(window, "PaletteEditor");
|
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
// Run the window in background
|
|
|
|
window->open_window_bg();
|
2009-06-11 15:11:11 +00:00
|
|
|
}
|
2010-04-10 20:01:56 +00:00
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static bool window_msg_proc(JWidget widget, JMessage msg)
|
|
|
|
{
|
|
|
|
if (msg->type == JM_TIMER &&
|
|
|
|
msg->timer.timer_id == redraw_timer_id) {
|
|
|
|
// Redraw all editors
|
|
|
|
if (redraw_all) {
|
|
|
|
redraw_all = false;
|
|
|
|
jmanager_stop_timer(redraw_timer_id);
|
|
|
|
|
|
|
|
try {
|
|
|
|
const CurrentSpriteReader sprite(UIContext::instance());
|
|
|
|
update_editors_with_sprite(sprite);
|
2008-05-06 15:22:57 +00:00
|
|
|
}
|
2010-04-10 20:01:56 +00:00
|
|
|
catch (...) {
|
|
|
|
// Do nothing
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
}
|
2010-04-10 20:01:56 +00:00
|
|
|
// Redraw just the current editor
|
2008-03-22 18:43:56 +00:00
|
|
|
else {
|
2010-04-10 20:01:56 +00:00
|
|
|
redraw_all = true;
|
|
|
|
current_editor->editor_update();
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
}
|
2010-04-10 20:01:56 +00:00
|
|
|
return false;
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static bool window_close_hook(JWidget widget, void *data)
|
2008-03-22 18:43:56 +00:00
|
|
|
{
|
2010-04-10 20:01:56 +00:00
|
|
|
// Save window configuration
|
|
|
|
save_window_pos(window, "PaletteEditor");
|
|
|
|
return false;
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void load_command(JWidget widget)
|
|
|
|
{
|
|
|
|
Palette *palette;
|
2010-09-30 18:34:12 +00:00
|
|
|
base::string filename = ase_file_selector("Load Palette", "", "png,pcx,bmp,tga,lbm,col");
|
2008-10-11 20:41:27 +00:00
|
|
|
if (!filename.empty()) {
|
2010-03-28 15:15:32 +00:00
|
|
|
palette = Palette::load(filename.c_str());
|
2008-03-22 18:43:56 +00:00
|
|
|
if (!palette) {
|
2010-09-19 02:54:56 +00:00
|
|
|
jalert("Error<<Loading palette file||&Close");
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
else {
|
2010-12-02 02:41:20 +00:00
|
|
|
set_new_palette(palette, "Load Palette");
|
2010-03-28 15:15:32 +00:00
|
|
|
delete palette;
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void save_command(JWidget widget)
|
|
|
|
{
|
2010-09-30 18:34:12 +00:00
|
|
|
base::string filename;
|
2008-03-22 18:43:56 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
again:
|
2010-09-19 02:54:56 +00:00
|
|
|
filename = ase_file_selector("Save Palette", "", "png,pcx,bmp,tga,col");
|
2008-10-11 20:41:27 +00:00
|
|
|
if (!filename.empty()) {
|
|
|
|
if (exists(filename.c_str())) {
|
2010-09-19 02:54:56 +00:00
|
|
|
ret = jalert("Warning<<File exists, overwrite it?<<%s||&Yes||&No||&Cancel",
|
|
|
|
get_filename(filename.c_str()));
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2008-10-11 20:41:27 +00:00
|
|
|
if (ret == 2)
|
2008-03-22 18:43:56 +00:00
|
|
|
goto again;
|
2008-10-11 20:41:27 +00:00
|
|
|
else if (ret != 1)
|
2008-03-22 18:43:56 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-06-13 23:04:38 +00:00
|
|
|
Palette* palette = get_current_palette();
|
|
|
|
if (!palette->save(filename.c_str())) {
|
2010-09-19 02:54:56 +00:00
|
|
|
jalert("Error<<Saving palette file||&Close");
|
2010-06-13 23:04:38 +00:00
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ramp_command(JWidget widget)
|
|
|
|
{
|
2010-04-10 20:01:56 +00:00
|
|
|
int range_type = palette_editor->getRangeType();
|
|
|
|
int i1 = palette_editor->get1stColor();
|
|
|
|
int i2 = palette_editor->get2ndColor();
|
2010-06-13 23:04:38 +00:00
|
|
|
Palette* src_palette = get_current_palette();
|
|
|
|
Palette* dst_palette = new Palette(0, 256);
|
2008-03-22 18:43:56 +00:00
|
|
|
bool array[256];
|
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
palette_editor->getSelectedEntries(array);
|
2010-06-13 23:04:38 +00:00
|
|
|
src_palette->copyColorsTo(dst_palette);
|
2008-03-22 18:43:56 +00:00
|
|
|
|
|
|
|
if ((i1 >= 0) && (i2 >= 0)) {
|
2010-06-13 23:04:38 +00:00
|
|
|
// Make the ramp
|
2008-03-22 18:43:56 +00:00
|
|
|
if (range_type == PALETTE_EDITOR_RANGE_LINEAL) {
|
2010-06-13 23:04:38 +00:00
|
|
|
// Lineal ramp
|
|
|
|
dst_palette->makeHorzRamp(i1, i2);
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
else if (range_type == PALETTE_EDITOR_RANGE_RECTANGULAR) {
|
2010-06-13 23:04:38 +00:00
|
|
|
// Rectangular ramp
|
|
|
|
dst_palette->makeRectRamp(i1, i2, palette_editor->getColumns());
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-02 02:41:20 +00:00
|
|
|
set_new_palette(dst_palette, "Color Ramp");
|
2010-06-13 23:04:38 +00:00
|
|
|
delete dst_palette;
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
|
2010-06-15 01:53:30 +00:00
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// Sort Options Begin
|
|
|
|
|
|
|
|
struct SortDlgData
|
|
|
|
{
|
|
|
|
Widget* available_criteria;
|
|
|
|
Widget* selected_criteria;
|
|
|
|
Widget* insert_criteria;
|
|
|
|
Widget* remove_criteria;
|
|
|
|
Widget* asc;
|
|
|
|
Widget* des;
|
2010-06-17 03:34:39 +00:00
|
|
|
Widget* first;
|
|
|
|
Widget* last;
|
2010-06-15 01:53:30 +00:00
|
|
|
Widget* ok_button;
|
|
|
|
};
|
|
|
|
|
|
|
|
static bool insert_criteria_hook(Widget* widget, void* data);
|
|
|
|
static bool remove_criteria_hook(Widget* widget, void* data);
|
2010-06-17 05:16:43 +00:00
|
|
|
static bool sort_by_criteria(Palette* palette, int from, int to, JList selected_listitems, std::vector<int>& mapping);
|
2010-06-15 01:53:30 +00:00
|
|
|
|
2010-06-13 23:04:38 +00:00
|
|
|
static void sort_command(JWidget widget)
|
2008-03-22 18:43:56 +00:00
|
|
|
{
|
2010-06-17 05:28:37 +00:00
|
|
|
if (jalert("ASE Beta<<Sort command is not available in this beta version.||&OK")) // TODO remove this
|
|
|
|
return;
|
|
|
|
|
2010-06-15 01:53:30 +00:00
|
|
|
SortDlgData data;
|
|
|
|
|
|
|
|
try {
|
|
|
|
// Load the sort criteria window
|
|
|
|
FramePtr dlg(load_widget("palette_editor.xml", "sort_criteria"));
|
|
|
|
|
|
|
|
get_widgets(dlg,
|
|
|
|
"available_criteria", &data.available_criteria,
|
|
|
|
"selected_criteria", &data.selected_criteria,
|
|
|
|
"insert_criteria", &data.insert_criteria,
|
|
|
|
"remove_criteria", &data.remove_criteria,
|
|
|
|
"asc", &data.asc,
|
|
|
|
"des", &data.des,
|
2010-06-17 03:34:39 +00:00
|
|
|
"first", &data.first,
|
|
|
|
"last", &data.last,
|
2010-06-15 01:53:30 +00:00
|
|
|
"ok_button", &data.ok_button, NULL);
|
|
|
|
|
|
|
|
// Selected Ascending by default
|
|
|
|
data.asc->setSelected(true);
|
|
|
|
|
2010-06-17 03:34:39 +00:00
|
|
|
// Range to sort
|
|
|
|
int i1 = palette_editor->get1stColor();
|
|
|
|
int i2 = palette_editor->get2ndColor();
|
|
|
|
if (i1 == i2) { // Sort all palette entries
|
|
|
|
i1 = 0;
|
|
|
|
i2 = get_current_palette()->size()-1;
|
|
|
|
}
|
|
|
|
else if (i1 > i2) {
|
|
|
|
std::swap(i1, i2);
|
|
|
|
}
|
|
|
|
data.first->setTextf("%d", i1);
|
|
|
|
data.last->setTextf("%d", i2);
|
|
|
|
|
2010-06-15 01:53:30 +00:00
|
|
|
HOOK(data.insert_criteria, JI_SIGNAL_BUTTON_SELECT, insert_criteria_hook, &data);
|
|
|
|
HOOK(data.remove_criteria, JI_SIGNAL_BUTTON_SELECT, remove_criteria_hook, &data);
|
|
|
|
|
2010-06-15 22:45:57 +00:00
|
|
|
// If there is a selected <listitem> in available criteria
|
|
|
|
// <listbox>, insert it as default criteria to sort colors
|
|
|
|
if (jlistbox_get_selected_child(data.available_criteria))
|
|
|
|
insert_criteria_hook(data.insert_criteria, (void*)&data);
|
2010-06-15 01:53:30 +00:00
|
|
|
|
|
|
|
// Open the window
|
|
|
|
dlg->open_window_fg();
|
|
|
|
|
|
|
|
if (dlg->get_killer() == data.ok_button) {
|
|
|
|
Palette* palette = new Palette(*get_current_palette());
|
2010-06-17 03:34:39 +00:00
|
|
|
int from = data.first->getTextInt();
|
|
|
|
int to = data.last->getTextInt();
|
|
|
|
|
|
|
|
from = MID(0, from, palette->size()-1);
|
|
|
|
to = MID(from, to, palette->size()-1);
|
2010-06-15 01:53:30 +00:00
|
|
|
|
2010-06-17 05:16:43 +00:00
|
|
|
std::vector<int> mapping;
|
|
|
|
sort_by_criteria(palette, from, to, data.selected_criteria->children, mapping);
|
2010-06-17 05:17:42 +00:00
|
|
|
|
|
|
|
if (UIContext::instance()->get_current_sprite()) {
|
|
|
|
// Remap all colors
|
|
|
|
if (mapping.size() > 0) {
|
|
|
|
CurrentSpriteWriter sprite(UIContext::instance());
|
|
|
|
Palette* frame_palette = sprite->getCurrentPalette();
|
|
|
|
int frame_begin = 0;
|
|
|
|
int frame_end = 0;
|
|
|
|
int frame = 0;
|
|
|
|
while (frame < sprite->getTotalFrames()) {
|
|
|
|
if (sprite->getPalette(frame) == frame_palette) {
|
|
|
|
frame_begin = frame;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++frame;
|
|
|
|
}
|
|
|
|
while (frame < sprite->getTotalFrames()) {
|
|
|
|
if (sprite->getPalette(frame) != frame_palette)
|
|
|
|
break;
|
|
|
|
++frame;
|
|
|
|
}
|
|
|
|
frame_end = frame;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// TODO The following code is unreadable, move this to Undoable class
|
|
|
|
|
2010-09-19 18:23:15 +00:00
|
|
|
if (sprite->getUndo()->isEnabled()) {
|
2010-09-19 20:44:06 +00:00
|
|
|
sprite->getUndo()->setLabel("Sort Palette");
|
2010-10-01 02:55:35 +00:00
|
|
|
sprite->getUndo()->undo_open();
|
2010-06-17 05:17:42 +00:00
|
|
|
|
|
|
|
// Remove the current palette in the current frame
|
2010-10-01 02:55:35 +00:00
|
|
|
sprite->getUndo()->undo_remove_palette(sprite, frame_palette);
|
2010-06-17 05:17:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Delete the current palette
|
|
|
|
sprite->deletePalette(frame_palette);
|
|
|
|
|
|
|
|
// Setup the new palette in the sprite
|
|
|
|
palette->setFrame(frame_begin);
|
|
|
|
sprite->setPalette(palette, true);
|
|
|
|
|
2010-09-19 18:23:15 +00:00
|
|
|
if (sprite->getUndo()->isEnabled()) {
|
2010-06-17 05:17:42 +00:00
|
|
|
// Add undo information about the new added palette
|
2010-10-01 02:55:35 +00:00
|
|
|
sprite->getUndo()->undo_add_palette(sprite, sprite->getPalette(frame_begin));
|
2010-06-17 05:17:42 +00:00
|
|
|
|
|
|
|
// Add undo information about image remapping
|
2010-10-01 02:55:35 +00:00
|
|
|
sprite->getUndo()->undo_remap_palette(sprite, frame_begin, frame_end-1, mapping);
|
|
|
|
sprite->getUndo()->undo_close();
|
2010-06-17 05:17:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Remap images (to the new palette indexes)
|
|
|
|
sprite->remapImages(frame_begin, frame_end-1, mapping);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the new palette in the sprite
|
2010-12-02 02:41:20 +00:00
|
|
|
set_new_palette(palette, "Sort Palette");
|
2010-06-15 01:53:30 +00:00
|
|
|
|
|
|
|
delete palette;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (ase_exception& e) {
|
|
|
|
e.show();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool insert_criteria_hook(Widget* widget, void* _data)
|
|
|
|
{
|
|
|
|
SortDlgData* data = (SortDlgData*)_data;
|
|
|
|
|
|
|
|
// Move the selected item to the
|
|
|
|
Widget* item = jlistbox_get_selected_child(data->available_criteria);
|
|
|
|
if (item) {
|
|
|
|
std::string new_criteria(item->getText());
|
|
|
|
new_criteria += " - ";
|
|
|
|
new_criteria += (data->asc->isSelected() ? data->asc->getText():
|
|
|
|
data->des->getText());
|
|
|
|
|
|
|
|
// Remove the criteria
|
|
|
|
int removed_index = jlistbox_get_selected_index(data->available_criteria);
|
|
|
|
jwidget_remove_child(data->available_criteria, item);
|
|
|
|
|
|
|
|
int count = jlistbox_get_items_count(data->available_criteria);
|
|
|
|
if (count > 0) {
|
|
|
|
jlistbox_select_index(data->available_criteria,
|
|
|
|
removed_index < count ? removed_index: count-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add to the selected criteria
|
|
|
|
item->setText(new_criteria.c_str());
|
|
|
|
jwidget_add_child(data->selected_criteria, item);
|
|
|
|
jlistbox_select_child(data->selected_criteria, item);
|
|
|
|
|
|
|
|
// Relayout
|
|
|
|
data->available_criteria->setBounds(data->available_criteria->getBounds()); // TODO layout()
|
|
|
|
data->selected_criteria->setBounds(data->selected_criteria->getBounds()); // TODO layout()
|
|
|
|
data->available_criteria->dirty();
|
|
|
|
data->selected_criteria->dirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool remove_criteria_hook(Widget* widget, void* _data)
|
|
|
|
{
|
|
|
|
SortDlgData* data = (SortDlgData*)_data;
|
|
|
|
|
|
|
|
// Move the selected item to the
|
|
|
|
Widget* item = jlistbox_get_selected_child(data->selected_criteria);
|
|
|
|
if (item) {
|
|
|
|
std::string criteria_text(item->getText());
|
|
|
|
int index = criteria_text.find('-');
|
|
|
|
criteria_text = criteria_text.substr(0, index-1);
|
|
|
|
|
|
|
|
// Remove from the selected criteria
|
|
|
|
int removed_index = jlistbox_get_selected_index(data->selected_criteria);
|
|
|
|
jwidget_remove_child(data->selected_criteria, item);
|
|
|
|
|
|
|
|
int count = jlistbox_get_items_count(data->selected_criteria);
|
|
|
|
if (count > 0) {
|
|
|
|
jlistbox_select_index(data->selected_criteria,
|
|
|
|
removed_index < count ? removed_index: count-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add to the available criteria
|
|
|
|
item->setText(criteria_text.c_str());
|
|
|
|
jwidget_add_child(data->available_criteria, item);
|
|
|
|
jlistbox_select_child(data->available_criteria, item);
|
|
|
|
|
|
|
|
// Relayout
|
|
|
|
data->available_criteria->setBounds(data->available_criteria->getBounds()); // TODO layout()
|
|
|
|
data->selected_criteria->setBounds(data->selected_criteria->getBounds()); // TODO layout()
|
|
|
|
data->available_criteria->dirty();
|
|
|
|
data->selected_criteria->dirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-06-17 05:16:43 +00:00
|
|
|
static bool sort_by_criteria(Palette* palette, int from, int to, JList selected_listitems, std::vector<int>& mapping)
|
2010-06-15 01:53:30 +00:00
|
|
|
{
|
|
|
|
SortPalette* sort_palette = NULL;
|
|
|
|
JLink link;
|
|
|
|
|
|
|
|
JI_LIST_FOR_EACH(selected_listitems, link) {
|
|
|
|
Widget* item = (Widget*)link->data;
|
|
|
|
std::string item_text = item->getText();
|
2010-06-17 03:21:57 +00:00
|
|
|
SortPalette::Channel channel = SortPalette::YUV_Luma;
|
2010-06-15 01:53:30 +00:00
|
|
|
bool ascending = false;
|
|
|
|
|
|
|
|
if (item_text.find("RGB") != std::string::npos) {
|
|
|
|
if (item_text.find("Red") != std::string::npos) {
|
|
|
|
channel = SortPalette::RGB_Red;
|
|
|
|
}
|
|
|
|
else if (item_text.find("Green") != std::string::npos) {
|
|
|
|
channel = SortPalette::RGB_Green;
|
|
|
|
}
|
|
|
|
else if (item_text.find("Blue") != std::string::npos) {
|
|
|
|
channel = SortPalette::RGB_Blue;
|
|
|
|
}
|
2010-06-17 03:21:57 +00:00
|
|
|
else
|
2010-08-04 02:33:44 +00:00
|
|
|
ASSERT(false);
|
2010-06-15 01:53:30 +00:00
|
|
|
}
|
|
|
|
else if (item_text.find("HSV") != std::string::npos) {
|
|
|
|
if (item_text.find("Hue") != std::string::npos) {
|
|
|
|
channel = SortPalette::HSV_Hue;
|
|
|
|
}
|
|
|
|
else if (item_text.find("Saturation") != std::string::npos) {
|
|
|
|
channel = SortPalette::HSV_Saturation;
|
|
|
|
}
|
|
|
|
else if (item_text.find("Value") != std::string::npos) {
|
|
|
|
channel = SortPalette::HSV_Value;
|
|
|
|
}
|
2010-06-17 03:21:57 +00:00
|
|
|
else
|
2010-08-04 02:33:44 +00:00
|
|
|
ASSERT(false);
|
2010-06-15 01:53:30 +00:00
|
|
|
}
|
2010-06-17 03:21:57 +00:00
|
|
|
else if (item_text.find("HSL") != std::string::npos) {
|
|
|
|
if (item_text.find("Lightness") != std::string::npos) {
|
|
|
|
channel = SortPalette::HSL_Lightness;
|
|
|
|
}
|
|
|
|
else
|
2010-08-04 02:33:44 +00:00
|
|
|
ASSERT(false);
|
2010-06-17 03:21:57 +00:00
|
|
|
}
|
|
|
|
else if (item_text.find("YUV") != std::string::npos) {
|
|
|
|
if (item_text.find("Luma") != std::string::npos) {
|
|
|
|
channel = SortPalette::YUV_Luma;
|
|
|
|
}
|
|
|
|
else
|
2010-08-04 02:33:44 +00:00
|
|
|
ASSERT(false);
|
2010-06-17 03:21:57 +00:00
|
|
|
}
|
|
|
|
else
|
2010-08-04 02:33:44 +00:00
|
|
|
ASSERT(false);
|
2010-06-15 01:53:30 +00:00
|
|
|
|
|
|
|
if (item_text.find("Ascending") != std::string::npos)
|
|
|
|
ascending = true;
|
2010-06-17 03:21:57 +00:00
|
|
|
else if (item_text.find("Descending") != std::string::npos)
|
2010-06-15 01:53:30 +00:00
|
|
|
ascending = false;
|
2010-06-17 03:21:57 +00:00
|
|
|
else
|
2010-08-04 02:33:44 +00:00
|
|
|
ASSERT(false);
|
2010-06-15 01:53:30 +00:00
|
|
|
|
|
|
|
SortPalette* chain = new SortPalette(channel, ascending);
|
|
|
|
if (sort_palette)
|
|
|
|
sort_palette->addChain(chain);
|
|
|
|
else
|
|
|
|
sort_palette = chain;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sort_palette) {
|
2010-06-17 05:16:43 +00:00
|
|
|
palette->sort(from, to, sort_palette, mapping);
|
2010-06-15 01:53:30 +00:00
|
|
|
delete sort_palette;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
2010-06-13 23:04:38 +00:00
|
|
|
}
|
2009-06-11 15:11:11 +00:00
|
|
|
|
2010-06-15 01:53:30 +00:00
|
|
|
// Sort Options End
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
2010-06-13 23:04:38 +00:00
|
|
|
static void quantize_command(JWidget widget)
|
|
|
|
{
|
|
|
|
const CurrentSpriteReader& sprite(UIContext::instance());
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-06-13 23:04:38 +00:00
|
|
|
if (sprite == NULL) {
|
2010-09-19 02:54:56 +00:00
|
|
|
jalert("Error<<There is no sprite selected to quantize.||&OK");
|
2010-06-13 23:04:38 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-06-13 23:04:38 +00:00
|
|
|
if (sprite->getImgType() != IMAGE_RGB) {
|
2010-09-19 02:54:56 +00:00
|
|
|
jalert("Error<<You can use this command only for RGB sprites||&OK");
|
2010-06-13 23:04:38 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-06-13 23:04:38 +00:00
|
|
|
Palette* palette = new Palette(0, 256);
|
|
|
|
{
|
|
|
|
SpriteWriter sprite_writer(sprite);
|
|
|
|
sprite_quantize_ex(sprite_writer, palette);
|
2010-12-02 02:41:20 +00:00
|
|
|
set_new_palette(palette, "Quantize Palette");
|
2010-06-13 23:04:38 +00:00
|
|
|
}
|
|
|
|
delete palette;
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool sliderRGB_change_hook(JWidget widget, void *data)
|
|
|
|
{
|
2010-04-10 20:01:56 +00:00
|
|
|
int r = jslider_get_value(R_slider);
|
|
|
|
int g = jslider_get_value(G_slider);
|
|
|
|
int b = jslider_get_value(B_slider);
|
2010-08-25 03:26:37 +00:00
|
|
|
Color color = Color::fromRgb(r, g, b);
|
2010-04-10 20:01:56 +00:00
|
|
|
|
2010-08-25 03:26:37 +00:00
|
|
|
jslider_set_value(H_slider, color.getHue());
|
|
|
|
jslider_set_value(V_slider, color.getValue());
|
|
|
|
jslider_set_value(S_slider, color.getSaturation());
|
2010-04-10 20:01:56 +00:00
|
|
|
|
|
|
|
modify_all_selected_entries_in_palette(r, g, b);
|
|
|
|
|
|
|
|
update_entries_from_sliders();
|
|
|
|
update_hex_entry();
|
2010-12-02 02:41:20 +00:00
|
|
|
update_current_sprite_palette("Color Change");
|
2010-04-10 20:01:56 +00:00
|
|
|
update_colorbar();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool sliderHSV_change_hook(JWidget widget, void *data)
|
|
|
|
{
|
|
|
|
int h = jslider_get_value(H_slider);
|
|
|
|
int s = jslider_get_value(S_slider);
|
|
|
|
int v = jslider_get_value(V_slider);
|
2010-08-25 03:26:37 +00:00
|
|
|
Color color = Color::fromHsv(h, s, v);
|
2010-04-10 20:01:56 +00:00
|
|
|
int r, g, b;
|
|
|
|
|
2010-08-25 03:26:37 +00:00
|
|
|
jslider_set_value(R_slider, r = color.getRed());
|
|
|
|
jslider_set_value(G_slider, g = color.getGreen());
|
|
|
|
jslider_set_value(B_slider, b = color.getBlue());
|
2010-04-10 20:01:56 +00:00
|
|
|
|
|
|
|
modify_all_selected_entries_in_palette(r, g, b);
|
|
|
|
|
|
|
|
update_entries_from_sliders();
|
|
|
|
update_hex_entry();
|
2010-12-02 02:41:20 +00:00
|
|
|
update_current_sprite_palette("Color Change");
|
2010-04-10 20:01:56 +00:00
|
|
|
update_colorbar();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool entryRGB_change_hook(JWidget widget, void *data)
|
|
|
|
{
|
|
|
|
int r = R_entry->getTextInt();
|
|
|
|
int g = G_entry->getTextInt();
|
|
|
|
int b = B_entry->getTextInt();
|
|
|
|
r = MID(0, r, 255);
|
|
|
|
g = MID(0, g, 255);
|
|
|
|
b = MID(0, b, 255);
|
2010-08-25 03:26:37 +00:00
|
|
|
Color color = Color::fromRgb(r, g, b);
|
2010-04-10 20:01:56 +00:00
|
|
|
|
2010-08-25 03:26:37 +00:00
|
|
|
H_entry->setTextf("%d", color.getHue());
|
|
|
|
V_entry->setTextf("%d", color.getValue());
|
|
|
|
S_entry->setTextf("%d", color.getSaturation());
|
2010-04-10 20:01:56 +00:00
|
|
|
|
|
|
|
modify_all_selected_entries_in_palette(r, g, b);
|
|
|
|
|
|
|
|
update_sliders_from_entries();
|
|
|
|
update_hex_entry();
|
2010-12-02 02:41:20 +00:00
|
|
|
update_current_sprite_palette("Color Change");
|
2010-04-10 20:01:56 +00:00
|
|
|
update_colorbar();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool entryHSV_change_hook(JWidget widget, void *data)
|
|
|
|
{
|
|
|
|
int h = H_entry->getTextInt();
|
|
|
|
int s = S_entry->getTextInt();
|
|
|
|
int v = V_entry->getTextInt();
|
2010-08-25 03:26:37 +00:00
|
|
|
Color color = Color::fromHsv(h, s, v);
|
2010-04-10 20:01:56 +00:00
|
|
|
int r, g, b;
|
|
|
|
|
2010-08-25 03:26:37 +00:00
|
|
|
R_entry->setTextf("%d", r = color.getRed());
|
|
|
|
G_entry->setTextf("%d", g = color.getGreen());
|
|
|
|
B_entry->setTextf("%d", b = color.getBlue());
|
2010-04-10 20:01:56 +00:00
|
|
|
|
|
|
|
modify_all_selected_entries_in_palette(r, g, b);
|
|
|
|
|
|
|
|
update_sliders_from_entries();
|
|
|
|
update_hex_entry();
|
2010-12-02 02:41:20 +00:00
|
|
|
update_current_sprite_palette("Color Change");
|
2010-04-10 20:01:56 +00:00
|
|
|
update_colorbar();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool hex_entry_change_hook(JWidget widget, void *data)
|
|
|
|
{
|
|
|
|
Palette* palette = get_current_palette();
|
|
|
|
std::string text = hex_entry->getText();
|
|
|
|
int r, g, b;
|
2008-03-22 18:43:56 +00:00
|
|
|
float h, s, v;
|
|
|
|
bool array[256];
|
|
|
|
int c;
|
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
// Fill with zeros at the end of the text
|
|
|
|
while (text.size() < 6)
|
|
|
|
text.push_back('0');
|
|
|
|
|
|
|
|
// Convert text (Base 16) to integer
|
|
|
|
int hex = strtol(text.c_str(), NULL, 16);
|
|
|
|
|
|
|
|
jslider_set_value(R_slider, r = ((hex & 0xff0000) >> 16));
|
|
|
|
jslider_set_value(G_slider, g = ((hex & 0xff00) >> 8));
|
|
|
|
jslider_set_value(B_slider, b = ((hex & 0xff)));
|
|
|
|
|
2008-03-22 18:43:56 +00:00
|
|
|
rgb_to_hsv(r, g, b, &h, &s, &v);
|
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
palette_editor->getSelectedEntries(array);
|
2008-03-22 18:43:56 +00:00
|
|
|
for (c=0; c<256; c++) {
|
|
|
|
if (array[c]) {
|
2010-03-28 15:15:32 +00:00
|
|
|
palette->setEntry(c, _rgba(r, g, b, 255));
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
jslider_set_value(H_slider, 255.0 * h / 360.0);
|
|
|
|
jslider_set_value(V_slider, 255.0 * v);
|
|
|
|
jslider_set_value(S_slider, 255.0 * s);
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
update_entries_from_sliders();
|
2010-12-02 02:41:20 +00:00
|
|
|
update_current_sprite_palette("Color Change");
|
2010-04-10 20:01:56 +00:00
|
|
|
update_colorbar();
|
2010-01-30 16:43:13 +00:00
|
|
|
return false;
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static void update_entries_from_sliders()
|
2008-03-22 18:43:56 +00:00
|
|
|
{
|
2010-04-10 20:01:56 +00:00
|
|
|
R_entry->setTextf("%d", jslider_get_value(R_slider));
|
|
|
|
G_entry->setTextf("%d", jslider_get_value(G_slider));
|
|
|
|
B_entry->setTextf("%d", jslider_get_value(B_slider));
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
H_entry->setTextf("%d", jslider_get_value(H_slider));
|
|
|
|
S_entry->setTextf("%d", jslider_get_value(S_slider));
|
|
|
|
V_entry->setTextf("%d", jslider_get_value(V_slider));
|
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static void update_sliders_from_entries()
|
|
|
|
{
|
|
|
|
jslider_set_value(R_slider, R_entry->getTextInt());
|
|
|
|
jslider_set_value(G_slider, G_entry->getTextInt());
|
|
|
|
jslider_set_value(B_slider, B_entry->getTextInt());
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
jslider_set_value(H_slider, H_entry->getTextInt());
|
|
|
|
jslider_set_value(S_slider, S_entry->getTextInt());
|
|
|
|
jslider_set_value(V_slider, V_entry->getTextInt());
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static void update_hex_entry()
|
2008-03-22 18:43:56 +00:00
|
|
|
{
|
2010-04-10 20:01:56 +00:00
|
|
|
hex_entry->setTextf("%02x%02x%02x",
|
|
|
|
jslider_get_value(R_slider),
|
|
|
|
jslider_get_value(G_slider),
|
|
|
|
jslider_get_value(B_slider));
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
|
2010-12-02 02:41:20 +00:00
|
|
|
static void update_current_sprite_palette(const char* operationName)
|
2008-03-22 18:43:56 +00:00
|
|
|
{
|
2010-04-10 20:01:56 +00:00
|
|
|
if (UIContext::instance()->get_current_sprite()) {
|
|
|
|
try {
|
|
|
|
CurrentSpriteWriter sprite(UIContext::instance());
|
2010-12-02 02:41:20 +00:00
|
|
|
Palette* newPalette = get_current_palette(); // System current pal
|
|
|
|
Palette* currentSpritePalette = sprite->getPalette(sprite->getCurrentFrame()); // Sprite current pal
|
|
|
|
int from, to;
|
|
|
|
|
|
|
|
// Check differences between current sprite palette and current system palette
|
|
|
|
from = to = -1;
|
|
|
|
currentSpritePalette->countDiff(newPalette, &from, &to);
|
|
|
|
|
|
|
|
if (from >= 0 && to >= from) {
|
|
|
|
// Add undo information to save the range of pal entries that will be modified.
|
|
|
|
if (sprite->getUndo()->isEnabled()) {
|
|
|
|
sprite->getUndo()->setLabel(operationName);
|
|
|
|
sprite->getUndo()->undo_set_palette_colors(sprite, currentSpritePalette, from, to);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Change the sprite palette
|
|
|
|
sprite->setPalette(newPalette, false);
|
|
|
|
}
|
2010-04-10 20:01:56 +00:00
|
|
|
}
|
|
|
|
catch (...) {
|
|
|
|
// Ignore
|
|
|
|
}
|
|
|
|
}
|
2009-06-11 15:11:11 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
jwidget_dirty(palette_editor);
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
if (!jmanager_timer_is_running(redraw_timer_id))
|
|
|
|
jmanager_start_timer(redraw_timer_id);
|
|
|
|
redraw_all = false;
|
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static void update_colorbar()
|
|
|
|
{
|
|
|
|
app_get_colorbar()->dirty();
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
|
2010-08-25 03:26:37 +00:00
|
|
|
static void update_sliders_from_color(const Color& color)
|
2008-05-06 15:22:57 +00:00
|
|
|
{
|
2010-08-25 03:26:37 +00:00
|
|
|
jslider_set_value(R_slider, color.getRed());
|
|
|
|
jslider_set_value(G_slider, color.getGreen());
|
|
|
|
jslider_set_value(B_slider, color.getBlue());
|
|
|
|
jslider_set_value(H_slider, color.getHue());
|
|
|
|
jslider_set_value(S_slider, color.getSaturation());
|
|
|
|
jslider_set_value(V_slider, color.getValue());
|
2010-04-10 20:01:56 +00:00
|
|
|
}
|
2009-06-11 15:11:11 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static bool palette_editor_change_hook(JWidget widget, void *data)
|
|
|
|
{
|
2010-08-25 03:26:37 +00:00
|
|
|
Color color = Color::fromIndex(palette_editor->get2ndColor());
|
2008-05-06 15:22:57 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
// colorviewer_set_color(colorviewer, color);
|
2008-05-06 15:22:57 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
{
|
|
|
|
disable_colorbar_signals = true;
|
2008-05-06 15:22:57 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
if (jmouse_b(0) & 2)
|
|
|
|
app_get_colorbar()->setBgColor(color);
|
|
|
|
else
|
|
|
|
app_get_colorbar()->setFgColor(color);
|
2008-05-06 15:22:57 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
disable_colorbar_signals = false;
|
2008-05-06 15:22:57 +00:00
|
|
|
}
|
|
|
|
|
2010-04-11 20:42:01 +00:00
|
|
|
update_sliders_from_color(color); // Update sliders
|
|
|
|
update_entries_from_sliders(); // Update entries
|
|
|
|
update_hex_entry(); // Update hex field
|
2010-01-30 16:43:13 +00:00
|
|
|
return false;
|
2008-05-06 15:22:57 +00:00
|
|
|
}
|
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static bool select_rgb_hook(JWidget widget, void *data)
|
2008-03-22 18:43:56 +00:00
|
|
|
{
|
2010-07-04 15:03:14 +00:00
|
|
|
R_label->setVisible(true);
|
|
|
|
R_slider->setVisible(true);
|
|
|
|
R_entry->setVisible(true);
|
|
|
|
G_label->setVisible(true);
|
|
|
|
G_slider->setVisible(true);
|
|
|
|
G_entry->setVisible(true);
|
|
|
|
B_label->setVisible(true);
|
|
|
|
B_slider->setVisible(true);
|
|
|
|
B_entry->setVisible(true);
|
|
|
|
|
|
|
|
H_label->setVisible(false);
|
|
|
|
H_slider->setVisible(false);
|
|
|
|
H_entry->setVisible(false);
|
|
|
|
S_label->setVisible(false);
|
|
|
|
S_slider->setVisible(false);
|
|
|
|
S_entry->setVisible(false);
|
|
|
|
V_label->setVisible(false);
|
|
|
|
V_slider->setVisible(false);
|
|
|
|
V_entry->setVisible(false);
|
2010-04-10 20:01:56 +00:00
|
|
|
|
|
|
|
window->setBounds(window->getBounds());
|
|
|
|
window->dirty();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static bool select_hsv_hook(JWidget widget, void *data)
|
|
|
|
{
|
2010-07-04 15:03:14 +00:00
|
|
|
R_label->setVisible(false);
|
|
|
|
R_slider->setVisible(false);
|
|
|
|
R_entry->setVisible(false);
|
|
|
|
G_label->setVisible(false);
|
|
|
|
G_slider->setVisible(false);
|
|
|
|
G_entry->setVisible(false);
|
|
|
|
B_label->setVisible(false);
|
|
|
|
B_slider->setVisible(false);
|
|
|
|
B_entry->setVisible(false);
|
|
|
|
|
|
|
|
H_label->setVisible(true);
|
|
|
|
H_slider->setVisible(true);
|
|
|
|
H_entry->setVisible(true);
|
|
|
|
S_label->setVisible(true);
|
|
|
|
S_slider->setVisible(true);
|
|
|
|
S_entry->setVisible(true);
|
|
|
|
V_label->setVisible(true);
|
|
|
|
V_slider->setVisible(true);
|
|
|
|
V_entry->setVisible(true);
|
2010-04-10 20:01:56 +00:00
|
|
|
|
|
|
|
window->setBounds(window->getBounds());
|
|
|
|
window->dirty();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-06-13 22:35:40 +00:00
|
|
|
static bool expand_button_select_hook(JWidget widget, void *data)
|
|
|
|
{
|
2010-08-03 01:57:41 +00:00
|
|
|
Size reqSize;
|
2010-06-13 22:35:40 +00:00
|
|
|
|
2010-07-04 15:03:14 +00:00
|
|
|
if (more_options->isVisible()) {
|
2010-06-15 22:46:39 +00:00
|
|
|
set_config_bool("PaletteEditor", "ShowMoreOptions", false);
|
2010-07-04 15:03:14 +00:00
|
|
|
more_options->setVisible(false);
|
2010-06-13 22:35:40 +00:00
|
|
|
|
|
|
|
// Get the required size of the "More options" panel
|
2010-08-03 01:57:41 +00:00
|
|
|
reqSize = more_options->getPreferredSize();
|
|
|
|
reqSize.h += 4;
|
2010-06-13 22:35:40 +00:00
|
|
|
|
|
|
|
// Remove the space occupied by the "More options" panel
|
|
|
|
{
|
|
|
|
JRect rect = jrect_new(window->rc->x1, window->rc->y1,
|
2010-08-03 01:57:41 +00:00
|
|
|
window->rc->x2, window->rc->y2 - reqSize.h);
|
2010-06-13 22:35:40 +00:00
|
|
|
window->move_window(rect);
|
|
|
|
jrect_free(rect);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2010-06-15 22:46:39 +00:00
|
|
|
set_config_bool("PaletteEditor", "ShowMoreOptions", true);
|
2010-07-04 15:03:14 +00:00
|
|
|
more_options->setVisible(true);
|
2010-06-13 22:35:40 +00:00
|
|
|
|
|
|
|
// Get the required size of the whole window
|
2010-08-03 01:57:41 +00:00
|
|
|
reqSize = window->getPreferredSize();
|
2010-06-13 22:35:40 +00:00
|
|
|
|
|
|
|
// Add space for the "more_options" panel
|
2010-08-03 01:57:41 +00:00
|
|
|
if (jrect_h(window->rc) < reqSize.h) {
|
2010-06-13 22:35:40 +00:00
|
|
|
JRect rect = jrect_new(window->rc->x1, window->rc->y1,
|
2010-08-03 01:57:41 +00:00
|
|
|
window->rc->x2, window->rc->y1 + reqSize.h);
|
2010-06-13 22:35:40 +00:00
|
|
|
|
|
|
|
// Show the expanded area inside the screen
|
|
|
|
if (rect->y2 > JI_SCREEN_H)
|
|
|
|
jrect_displace(rect, 0, JI_SCREEN_H - rect->y2);
|
|
|
|
|
|
|
|
window->move_window(rect);
|
|
|
|
jrect_free(rect);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
window->setBounds(window->getBounds()); // TODO layout() method is missing
|
|
|
|
}
|
|
|
|
|
|
|
|
// Redraw the window
|
|
|
|
window->dirty();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
static void modify_all_selected_entries_in_palette(int r, int g, int b)
|
|
|
|
{
|
|
|
|
bool array[256];
|
|
|
|
palette_editor->getSelectedEntries(array);
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
Palette* palette = get_current_palette();
|
|
|
|
for (int c=0; c<256; c++)
|
|
|
|
if (array[c])
|
|
|
|
palette->setEntry(c, _rgba(r, g, b, 255));
|
|
|
|
}
|
|
|
|
|
2010-08-25 03:26:37 +00:00
|
|
|
static void on_color_changed(const Color& color)
|
2010-04-10 20:01:56 +00:00
|
|
|
{
|
|
|
|
if (disable_colorbar_signals)
|
|
|
|
return;
|
|
|
|
|
2010-08-25 03:26:37 +00:00
|
|
|
if (color.isValid() && color.getType() == Color::IndexType) {
|
|
|
|
int index = color.getIndex();
|
2010-04-23 22:13:55 +00:00
|
|
|
palette_editor->selectColor(index);
|
2010-04-10 20:01:56 +00:00
|
|
|
|
2010-04-23 22:13:55 +00:00
|
|
|
update_sliders_from_color(color); // Update sliders
|
|
|
|
update_entries_from_sliders(); // Update entries
|
|
|
|
update_hex_entry(); // Update hex field
|
2010-04-10 20:01:56 +00:00
|
|
|
|
2010-04-23 22:13:55 +00:00
|
|
|
jwidget_flush_redraw(window);
|
|
|
|
}
|
2008-03-22 18:43:56 +00:00
|
|
|
}
|
|
|
|
|
2010-12-02 02:41:20 +00:00
|
|
|
static void set_new_palette(Palette* palette, const char* operationName)
|
2008-03-22 18:43:56 +00:00
|
|
|
{
|
2010-04-10 20:01:56 +00:00
|
|
|
// Copy the palette
|
|
|
|
palette->copyColorsTo(get_current_palette());
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
// Set the palette calling the hooks
|
2010-01-30 16:43:13 +00:00
|
|
|
set_current_palette(palette, false);
|
2008-03-22 18:43:56 +00:00
|
|
|
|
2010-06-13 23:04:38 +00:00
|
|
|
// Update the sprite palette
|
2010-12-02 02:41:20 +00:00
|
|
|
update_current_sprite_palette(operationName);
|
2010-06-13 23:04:38 +00:00
|
|
|
|
2010-04-10 20:01:56 +00:00
|
|
|
// Redraw the entire screen
|
2008-03-22 18:43:56 +00:00
|
|
|
jmanager_refresh_screen();
|
2007-12-05 01:30:50 +00:00
|
|
|
}
|
|
|
|
|
2009-10-09 01:34:06 +00:00
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// CommandFactory
|
|
|
|
|
|
|
|
Command* CommandFactory::create_palette_editor_command()
|
|
|
|
{
|
|
|
|
return new PaletteEditorCommand;
|
|
|
|
}
|