mirror/aseprite
1
0
Fork 0
mirror of https://github.com/aseprite/aseprite.git synced 2025-04-10 12:44:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removed Context::getFg/BgColor member functions.

Browse Source 
Modified color_get_*() so they do not need "imgtype" parameter.
ColorBar class is public (defined in colbar.h).
Added ColorBar::Fg/BgColorChange signals.
Converted palette editor widget to a C++ class (PalEdit derived from Widget).
Modified the "Palette Editor" (F4 key) to be non-modal (still WIP).
This commit is contained in:
David Capello 2010-04-10 17:01:56 -03:00
parent 37e08c1a4a
commit 10781dcf5f
28 changed files with 943 additions and 837 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
data/gui.xml
View File

@ -67,7 +67,9 @@
<!-- tools --> <!-- tools -->
<key command="configure_tools" shortcut="C" /> <key command="configure_tools" shortcut="C" />
<key command="film_editor" shortcut="Tab" /> <key command="film_editor" shortcut="Tab" />
<key command="palette_editor" shortcut="F4" /> <key command="palette_editor" shortcut="F4">
<param name="switch" value="true" />
</key>
<key command="convolution_matrix" shortcut="F9" /> <key command="convolution_matrix" shortcut="F9" />
<key command="color_curve" shortcut="Ctrl+M" /> <key command="color_curve" shortcut="Ctrl+M" />
<key command="color_curve" shortcut="F10" /> <key command="color_curve" shortcut="F10" />
@ -289,7 +291,9 @@
<item command="configure_tools" text="&amp;Configure" /> <item command="configure_tools" text="&amp;Configure" />
<separator /> <separator />
<item command="film_editor" text="&amp;Animation Editor" /> <item command="film_editor" text="&amp;Animation Editor" />
<item command="palette_editor" text="&amp;Palette Editor" /> <item command="palette_editor" text="&amp;Palette Editor">
<param name="switch" value="true" />
</item>
<separator /> <separator />
<menu text="F&amp;X" id="fx_popup"> <menu text="F&amp;X" id="fx_popup">
<item command="convolution_matrix" text="Convolution &amp;Matrix" /> <item command="convolution_matrix" text="Convolution &amp;Matrix" />

119
data/widgets/palette_editor.xml
View File

@ -5,63 +5,80 @@
<box vertical="true"> <box vertical="true">
<box horizontal="true" expansive="true"> <box horizontal="true" expansive="true">
<box vertical="true"> <box vertical="true">
<view name="palette_editor" expansive="true" /> <!-- custom-widget --> <view name="palette_editor" /> <!-- custom-widget -->
<slider min="1" max="256" name="columns" />
</box> </box>
<box vertical="true" expansive="true"> <box vertical="true" expansive="true">
<box horizontal="true"> <box horizontal="true" childspacing="0" noborders="true">
<box vertical="true" homogeneous="true"> <radio group="1" text="RGB" name="select_rgb" looklike="button" selected="true" />
<label text="R" /> <radio group="1" text="HSV" name="select_hsv" looklike="button" />
<label text="G" /> <box horizontal="true" expansive="true" />
<label text="B" /> <button text="+" name="make_bigger" tooltip="More options" />
</box>
<box vertical="true" homogeneous="true" expansive="true">
<slider min="0" max="255" name="red" />
<slider min="0" max="255" name="green" />
<slider min="0" max="255" name="blue" />
</box>
<box vertical="true" homogeneous="true">
<label text="H" />
<label text="S" />
<label text="V" />
</box>
<box vertical="true" homogeneous="true" expansive="true">
<slider min="0" max="255" name="hue" />
<slider min="0" max="255" name="saturation" />
<slider min="0" max="255" name="value" />
</box>
</box> </box>
<box name="colorviewer" expansive="true" /> <!-- custom-widget -->
<button text="Select &amp;All" name="select_all" />
<box vertical="true">
<box horizontal="true" homogeneous="true">
<button text="&amp;Undo" name="undo" />
<button text="&amp;Redo" name="redo" />
</box>
<box horizontal="true" homogeneous="true">
<button text="&amp;Load" name="load" />
<button text="&amp;Save" name="save" />
</box>
<box horizontal="true" homogeneous="true">
<button text="&amp;Ramp" name="ramp" />
<button text="&amp;Quantize" name="quantize" />
</box>
</box>
</box>
</box>
<box horizontal="true">
<label text="Frame:" />
<slider min="0" max="1" name="frame" expansive="true" />
</box>
<box horizontal="true"> <grid columns="3" childspacing="0">
<check name="all_frames" text="All frames the same palette" />
<box horizontal="true" expansive="true" /> <label name="R_label" text="R" />
<box horizontal="true" homogeneous="true"> <slider name="R_slider" min="0" max="255" cell_align="horizontal" />
<button text="&amp;OK" name="button_ok" magnetic="true" width="60" /> <entry name="R_entry" maxsize="3" />
<button text="&amp;Cancel" />
<label name="G_label" text="G" />
<slider name="G_slider" min="0" max="255" cell_align="horizontal" />
<entry name="G_entry" maxsize="3" />
<label name="B_label" text="B" />
<slider name="B_slider" min="0" max="255" cell_align="horizontal" />
<entry name="B_entry" maxsize="3" />
<label name="H_label" text="H" />
<slider name="H_slider" min="0" max="255" cell_align="horizontal" />
<entry name="H_entry" maxsize="3" />
<label name="S_label" text="S" />
<slider name="S_slider" min="0" max="255" cell_align="horizontal" />
<entry name="S_entry" maxsize="3" />
<label name="V_label" text="V" />
<slider name="V_slider" min="0" max="255" cell_align="horizontal" />
<entry name="V_entry" maxsize="3" />
<label name="hex_label" text="#" />
<box horizontal="true" cell_hspan="2" >
<entry name="hex_entry" maxsize="6" />
</box>
</grid>
<!-- <box name="colorviewer_box" expansive="true" /> <\!-- custom-widget -\-> -->
<!-- <button text="Select &amp;All" name="select_all" /> -->
<!-- <box vertical="true"> -->
<!-- <box horizontal="true" homogeneous="true"> -->
<!-- <button text="&amp;Undo" name="undo" /> -->
<!-- <button text="&amp;Redo" name="redo" /> -->
<!-- </box> -->
<!-- <box horizontal="true" homogeneous="true"> -->
<!-- <button text="&amp;Load" name="load" /> -->
<!-- <button text="&amp;Save" name="save" /> -->
<!-- </box> -->
<!-- <box horizontal="true" homogeneous="true"> -->
<!-- <button text="&amp;Ramp" name="ramp" /> -->
<!-- <button text="&amp;Quantize" name="quantize" /> -->
<!-- </box> -->
<!-- </box> -->
</box> </box>
</box> </box>
<!-- <box horizontal="true"> -->
<!-- <label text="Frame:" /> -->
<!-- <slider min="0" max="1" name="frame" expansive="true" /> -->
<!-- </box> -->
<!-- <box horizontal="true"> -->
<!-- <\!-- <check name="all_frames" text="All frames the same palette" /> -\-> -->
<!-- <box horizontal="true" expansive="true" /> -->
<!-- <box horizontal="true" homogeneous="true"> -->
<!-- <button text="&amp;OK" name="button_ok" magnetic="true" width="60" /> -->
<!-- <button text="&amp;Cancel" /> -->
<!-- </box> -->
<!-- </box> -->
</box> </box>
</window> </window>
</jinete> </jinete>

14
src/app.cpp
View File

@ -100,8 +100,8 @@ static Widget* box_toolbar = NULL; /* box where the tools bar is */
static Widget* box_statusbar = NULL; /* box where the status bar is */ static Widget* box_statusbar = NULL; /* box where the status bar is */
static Widget* box_tabsbar = NULL; /* box where the tabs bar is */ static Widget* box_tabsbar = NULL; /* box where the tabs bar is */
static Widget* menubar = NULL; /* the menu bar widget */ static Widget* menubar = NULL; /* the menu bar widget */
static StatusBar* statusbar = NULL; /* the status bar widget */ static StatusBar* statusbar = NULL; /* the status bar widget */
static Widget* colorbar = NULL; /* the color bar widget */ static ColorBar* colorbar = NULL; /* the color bar widget */
static Widget* toolbar = NULL; /* the tool bar widget */ static Widget* toolbar = NULL; /* the tool bar widget */
static Widget* tabsbar = NULL; /* the tabs bar widget */ static Widget* tabsbar = NULL; /* the tabs bar widget */
@ -168,7 +168,7 @@ int App::run()
menubar = jmenubar_new(); menubar = jmenubar_new();
statusbar = new StatusBar(); statusbar = new StatusBar();
colorbar = colorbar_new(box_colorbar->getAlign()); colorbar = new ColorBar(box_colorbar->getAlign());
toolbar = toolbar_new(); toolbar = toolbar_new();
tabsbar = tabs_new(tabsbar_select_callback); tabsbar = tabs_new(tabsbar_select_callback);
view = editor_view_new(); view = editor_view_new();
@ -430,7 +430,7 @@ int app_get_current_image_type()
Frame* app_get_top_window() { return top_window; } Frame* app_get_top_window() { return top_window; }
Widget* app_get_menubar() { return menubar; } Widget* app_get_menubar() { return menubar; }
StatusBar* app_get_statusbar() { return statusbar; } StatusBar* app_get_statusbar() { return statusbar; }
Widget* app_get_colorbar() { return colorbar; } ColorBar* app_get_colorbar() { return colorbar; }
Widget* app_get_toolbar() { return toolbar; } Widget* app_get_toolbar() { return toolbar; }
Widget* app_get_tabsbar() { return tabsbar; } Widget* app_get_tabsbar() { return tabsbar; }
@ -442,7 +442,7 @@ void app_default_statusbar_message()
int app_get_fg_color(Sprite *sprite) int app_get_fg_color(Sprite *sprite)
{ {
color_t c = colorbar_get_fg_color(colorbar); color_t c = colorbar->getFgColor();
assert(sprite != NULL); assert(sprite != NULL);
if (sprite->getCurrentLayer() != NULL) if (sprite->getCurrentLayer() != NULL)
@ -453,7 +453,7 @@ int app_get_fg_color(Sprite *sprite)
int app_get_bg_color(Sprite *sprite) int app_get_bg_color(Sprite *sprite)
{ {
color_t c = colorbar_get_bg_color(colorbar); color_t c = colorbar->getBgColor();
assert(sprite != NULL); assert(sprite != NULL);
if (sprite->getCurrentLayer() != NULL) if (sprite->getCurrentLayer() != NULL)
@ -469,7 +469,7 @@ int app_get_color_to_clear_layer(Layer *layer)
/* the `Background' is erased with the `Background Color' */ /* the `Background' is erased with the `Background Color' */
if (layer != NULL && layer->is_background()) if (layer != NULL && layer->is_background())
color = colorbar_get_bg_color(colorbar); color = colorbar->getBgColor();
return get_color_for_layer(layer, color); return get_color_for_layer(layer, color);
} }

3
src/app.h
View File

@ -30,6 +30,7 @@ class LegacyModules;
class Params; class Params;
class Sprite; class Sprite;
class ToolBox; class ToolBox;
class ColorBar;
class StatusBar; class StatusBar;
class App class App
@ -70,7 +71,7 @@ int app_get_current_image_type();
Frame* app_get_top_window(); Frame* app_get_top_window();
Widget* app_get_menubar(); Widget* app_get_menubar();
StatusBar* app_get_statusbar(); StatusBar* app_get_statusbar();
Widget* app_get_colorbar(); ColorBar* app_get_colorbar();
Widget* app_get_toolbar(); Widget* app_get_toolbar();
Widget* app_get_tabsbar(); Widget* app_get_tabsbar();

1
src/commands/cmd_advanced_mode.cpp
View File

@ -24,6 +24,7 @@
#include "app.h" #include "app.h"
#include "core/cfg.h" #include "core/cfg.h"
#include "modules/gui.h" #include "modules/gui.h"
#include "widgets/colbar.h"
#include "widgets/statebar.h" #include "widgets/statebar.h"
class AdvancedModeCommand : public Command class AdvancedModeCommand : public Command

3
src/commands/cmd_background_from_layer.cpp
View File

@ -62,7 +62,8 @@ void BackgroundFromLayerCommand::execute(Context* context)
// each frame of the layer to be converted as `Background' must be // each frame of the layer to be converted as `Background' must be
// cleared using the selected background color in the color-bar // cleared using the selected background color in the color-bar
int bgcolor = context->getBgColor(); int bgcolor = get_color_for_image(sprite->getImgType(),
context->getSettings()->getBgColor());
bgcolor = fixup_color_for_background(sprite->getImgType(), bgcolor); bgcolor = fixup_color_for_background(sprite->getImgType(), bgcolor);
{ {

5
src/commands/cmd_canvas_size.cpp
View File

@ -108,7 +108,10 @@ void CanvasSizeCommand::execute(Context* context)
{ {
Undoable undoable(sprite, "Canvas Size"); Undoable undoable(sprite, "Canvas Size");
int bgcolor = context->getBgColor(); int bgcolor = get_color_for_image(sprite->getImgType(),
context->getSettings()->getBgColor());
bgcolor = fixup_color_for_background(sprite->getImgType(), bgcolor);
undoable.crop_sprite(x1, y1, x2-x1, y2-y1, bgcolor); undoable.crop_sprite(x1, y1, x2-x1, y2-y1, bgcolor);
undoable.commit(); undoable.commit();
} }

15
src/commands/cmd_change_color.cpp
View File

@ -70,10 +70,9 @@ void ChangeColorCommand::load_params(Params* params)
void ChangeColorCommand::execute(Context* context) void ChangeColorCommand::execute(Context* context)
{ {
JWidget colorbar = app_get_colorbar(); ColorBar* colorbar = app_get_colorbar();
color_t color = m_background ? colorbar_get_bg_color(colorbar): color_t color = m_background ? colorbar->getBgColor():
colorbar_get_fg_color(colorbar); colorbar->getFgColor();
int imgtype = app_get_current_image_type();
switch (m_change) { switch (m_change) {
case None: case None:
@ -81,7 +80,7 @@ void ChangeColorCommand::execute(Context* context)
break; break;
case IncrementIndex: case IncrementIndex:
if (color_type(color) == COLOR_TYPE_INDEX) { if (color_type(color) == COLOR_TYPE_INDEX) {
int index = color_get_index(imgtype, color); int index = color_get_index(color);
if (index < 255) // TODO use sprite palette limit if (index < 255) // TODO use sprite palette limit
color = color_index(index+1); color = color_index(index+1);
} }
@ -90,7 +89,7 @@ void ChangeColorCommand::execute(Context* context)
break; break;
case DecrementIndex: case DecrementIndex:
if (color_type(color) == COLOR_TYPE_INDEX) { if (color_type(color) == COLOR_TYPE_INDEX) {
int index = color_get_index(imgtype, color); int index = color_get_index(color);
if (index > 0) if (index > 0)
color = color_index(index-1); color = color_index(index-1);
} }
@ -100,9 +99,9 @@ void ChangeColorCommand::execute(Context* context)
} }
if (m_background) if (m_background)
colorbar_set_bg_color(colorbar, color); colorbar->setBgColor(color);
else else
colorbar_set_fg_color(colorbar, color); colorbar->setFgColor(color);
} }
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////

4
src/commands/cmd_crop.cpp
View File

@ -67,7 +67,7 @@ void CropSpriteCommand::execute(Context* context)
{ {
Undoable undoable(sprite, "Sprite Crop"); Undoable undoable(sprite, "Sprite Crop");
int bgcolor = get_color_for_image(sprite->getImgType(), int bgcolor = get_color_for_image(sprite->getImgType(),
colorbar_get_bg_color(app_get_colorbar())); app_get_colorbar()->getBgColor());
undoable.crop_sprite(sprite->getMask()->x, undoable.crop_sprite(sprite->getMask()->x,
sprite->getMask()->y, sprite->getMask()->y,
sprite->getMask()->w, sprite->getMask()->w,
@ -111,7 +111,7 @@ void AutocropSpriteCommand::execute(Context* context)
CurrentSpriteWriter sprite(context); CurrentSpriteWriter sprite(context);
{ {
Undoable undoable(sprite, "Sprite Autocrop"); Undoable undoable(sprite, "Sprite Autocrop");
undoable.autocrop_sprite(colorbar_get_bg_color(app_get_colorbar())); undoable.autocrop_sprite(app_get_colorbar()->getBgColor());
undoable.commit(); undoable.commit();
} }
sprite->generateMaskBoundaries(); sprite->generateMaskBoundaries();

4
src/commands/cmd_eyedropper.cpp
View File

@ -89,9 +89,9 @@ void EyedropperCommand::execute(Context* context)
// set the color of the color-bar // set the color of the color-bar
if (m_background) if (m_background)
colorbar_set_bg_color(app_get_colorbar(), color); app_get_colorbar()->setBgColor(color);
else else
colorbar_set_fg_color(app_get_colorbar(), color); app_get_colorbar()->setFgColor(color);
} }
} }

2
src/commands/cmd_flatten_layers.cpp
View File

@ -57,7 +57,7 @@ void FlattenLayersCommand::execute(Context* context)
{ {
CurrentSpriteWriter sprite(context); CurrentSpriteWriter sprite(context);
int bgcolor = get_color_for_image(sprite->getImgType(), int bgcolor = get_color_for_image(sprite->getImgType(),
colorbar_get_bg_color(app_get_colorbar())); app_get_colorbar()->getBgColor());
{ {
Undoable undoable(sprite, "Flatten Layers"); Undoable undoable(sprite, "Flatten Layers");
undoable.flatten_layers(bgcolor); undoable.flatten_layers(bgcolor);

2
src/commands/cmd_new_file.cpp
View File

@ -78,7 +78,7 @@ void NewFileCommand::execute(Context* context)
color_rgb(0, 0, 0), color_rgb(0, 0, 0),
color_rgb(255, 255, 255), color_rgb(255, 255, 255),
color_rgb(255, 0, 255), color_rgb(255, 0, 255),
colorbar_get_bg_color(app_get_colorbar()) app_get_colorbar()->getBgColor()
}; };
int ncolors = 256; int ncolors = 256;

845
src/commands/cmd_palette_editor.cpp
View File

@ -24,22 +24,44 @@
#include <assert.h> #include <assert.h>
#include <vector> #include <vector>
#include "Vaca/Bind.h"
#include "jinete/jinete.h" #include "jinete/jinete.h"
#include "app.h"
#include "commands/command.h" #include "commands/command.h"
#include "commands/params.h"
#include "core/cfg.h" #include "core/cfg.h"
#include "core/color.h" #include "core/color.h"
#include "dialogs/filesel.h" #include "dialogs/filesel.h"
#include "modules/gui.h" #include "modules/gui.h"
#include "modules/editors.h"
#include "modules/palettes.h" #include "modules/palettes.h"
#include "raster/image.h" #include "raster/image.h"
#include "raster/palette.h" #include "raster/palette.h"
#include "raster/sprite.h" #include "raster/sprite.h"
#include "raster/stock.h" #include "raster/stock.h"
#include "util/quantize.h" #include "util/quantize.h"
#include "widgets/colbar.h"
#include "widgets/colview.h" #include "widgets/colview.h"
#include "widgets/editor.h"
#include "widgets/paledit.h" #include "widgets/paledit.h"
#include "sprite_wrappers.h" #include "sprite_wrappers.h"
#include "ui_context.h"
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()
{
assert(window != NULL);
jmanager_remove_timer(redraw_timer_id);
redraw_timer_id = -1;
jwidget_free(window);
}
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// palette_editor // palette_editor
@ -51,21 +73,30 @@ public:
Command* clone() { return new PaletteEditorCommand(*this); } Command* clone() { return new PaletteEditorCommand(*this); }
protected: protected:
void load_params(Params* params);
void execute(Context* context); void execute(Context* context);
private:
bool m_open;
bool m_close;
bool m_switch;
bool m_background;
}; };
#define get_sprite(wgt) (*(const SpriteReader*)(wgt->getRoot())->user_data[0]) // #define get_sprite(wgt) (*(const SpriteReader*)(wgt->getRoot())->user_data[0])
static std::vector<Palette*> palettes; 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;
static bool disable_colorbar_signals = false;
static JWidget slider_R, slider_G, slider_B; static bool window_msg_proc(JWidget widget, JMessage msg);
static JWidget slider_H, slider_S, slider_V; static bool window_close_hook(JWidget widget, void *data);
static JWidget colorviewer;
static JWidget palette_editor;
static JWidget slider_frame;
static JWidget check_all_frames;
static void select_all_command(JWidget widget);
static void load_command(JWidget widget); static void load_command(JWidget widget);
static void save_command(JWidget widget); static void save_command(JWidget widget);
static void ramp_command(JWidget widget); static void ramp_command(JWidget widget);
@ -73,10 +104,19 @@ static void quantize_command(JWidget widget);
static bool sliderRGB_change_hook(JWidget widget, void *data); static bool sliderRGB_change_hook(JWidget widget, void *data);
static bool sliderHSV_change_hook(JWidget widget, void *data); static bool sliderHSV_change_hook(JWidget widget, void *data);
static bool slider_columns_change_hook(JWidget widget, void *data); static bool entryRGB_change_hook(JWidget widget, void *data);
static bool slider_frame_change_hook(JWidget widget, void *data); static bool entryHSV_change_hook(JWidget widget, void *data);
static bool check_all_frames_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();
static void update_current_sprite_palette();
static void update_colorbar();
static bool palette_editor_change_hook(JWidget widget, void *data); static bool palette_editor_change_hook(JWidget widget, void *data);
static bool select_rgb_hook(JWidget widget, void *data);
static bool select_hsv_hook(JWidget widget, void *data);
static void modify_all_selected_entries_in_palette(int r, int g, int b);
static void on_color_changed(color_t color);
static void set_new_palette(Palette *palette); static void set_new_palette(Palette *palette);
@ -85,217 +125,201 @@ PaletteEditorCommand::PaletteEditorCommand()
"PaletteEditor", "PaletteEditor",
CmdRecordableFlag) CmdRecordableFlag)
{ {
m_open = true;
m_close = false;
m_switch = false;
m_background = false;
}
void PaletteEditorCommand::load_params(Params* params)
{
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;
} }
void PaletteEditorCommand::execute(Context* context) void PaletteEditorCommand::execute(Context* context)
{ {
JWidget colorviewer_box, palette_editor_view; Widget* palette_editor_view;
JWidget slider_columns, button_ok; Widget* select_rgb;
JWidget button_select_all; Widget* select_hsv;
JWidget button_undo, button_redo; bool first_time = false;
JWidget button_load, button_save;
JWidget button_ramp, button_quantize;
int frame, columns;
Palette *palette = NULL;
const CurrentSpriteReader sprite(context);
int imgtype = sprite ? sprite->getImgType(): IMAGE_INDEXED;
int frame_bak = sprite ? sprite->getCurrentFrame() : 0;
bool all_frames_same_palette = true;
if (imgtype == IMAGE_GRAYSCALE) { // If the window was never loaded yet, load it
jalert(_("Error<<You can't edit grayscale palette||&OK")); 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
window->Close.connect(Vaca::Bind<bool>(&window_close_hook, (JWidget)window, (void*)0));
// 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)
else if (jwidget_is_visible(window) && (m_switch || m_close)) {
window->closeWindow(NULL);
return; return;
} }
/* load widgets */
FramePtr window(load_widget("palette_editor.xml", "palette_editor"));
get_widgets(window, get_widgets(window,
"red", &slider_R, "R_label", &R_label,
"green", &slider_G, "R_slider", &R_slider,
"blue", &slider_B, "R_entry", &R_entry,
"hue", &slider_H, "G_label", &G_label,
"saturation", &slider_S, "G_slider", &G_slider,
"value", &slider_V, "G_entry", &G_entry,
"columns", &slider_columns, "B_label", &B_label,
"frame", &slider_frame, "B_slider", &B_slider,
"select_all", &button_select_all, "B_entry", &B_entry,
"undo", &button_undo, "H_label", &H_label,
"redo", &button_redo, "H_slider", &H_slider,
"load", &button_load, "H_entry", &H_entry,
"save", &button_save, "S_label", &S_label,
"ramp", &button_ramp, "S_slider", &S_slider,
"quantize", &button_quantize, "S_entry", &S_entry,
"button_ok", &button_ok, "V_label", &V_label,
"colorviewer", &colorviewer_box, "V_slider", &V_slider,
"palette_editor", &palette_editor_view, "V_entry", &V_entry,
"all_frames", &check_all_frames, NULL); "hex_entry", &hex_entry,
"select_rgb", &select_rgb,
"select_hsv", &select_hsv,
// "load", &button_load,
// "save", &button_save,
// "ramp", &button_ramp,
// "quantize", &button_quantize,
// "button_ok", &button_ok,
// "colorviewer_box", &colorviewer_box,
"palette_editor", &palette_editor_view, NULL);
window->user_data[0] = (void*)&sprite; // window->user_data[0] = (void*)&sprite;
/* create current_sprite->frames palettes */
if (sprite) {
palettes.resize(sprite->getTotalFrames());
for (frame=0; frame<sprite->getTotalFrames(); ++frame) {
const Palette* orig = sprite->getPalette(frame);
palettes[frame] = new Palette(frame, orig->size());
orig->copyColorsTo(palettes[frame]);
if (frame > 0 && // Custom widgets
palettes[frame-1]->countDiff(palettes[frame], NULL, NULL) > 0) { if (first_time) {
all_frames_same_palette = false; // colorviewer = colorviewer_new(color_index(0), IMAGE_INDEXED);
} palette_editor = new PalEdit(true);
} palette_editor->setBoxSize(4);
}
else {
palettes.clear();
jwidget_disable(check_all_frames);
}
/* get current palette */ // jwidget_expansive(colorviewer, true);
palette = new Palette(*get_current_palette()); // jwidget_add_child(colorviewer_box, colorviewer);
/* get configuration */ // jwidget_disable(button_undo);
columns = get_config_int("PaletteEditor", "Columns", 16); // jwidget_disable(button_redo);
columns = MID(1, columns, 256);
/* custom widgets */ jview_attach(palette_editor_view, palette_editor);
colorviewer = colorviewer_new(color_index(0), IMAGE_INDEXED); jview_maxsize(palette_editor_view);
palette_editor = paledit_new(palette, true, 6);
jwidget_expansive(colorviewer, true); // Set palette editor columns
jwidget_add_child(colorviewer_box, colorviewer); palette_editor->setColumns(16);
jwidget_disable(button_undo);
jwidget_disable(button_redo);
jview_attach(palette_editor_view, palette_editor);
jview_maxsize(palette_editor_view);
/* set columns */
jslider_set_value(slider_columns, columns);
paledit_set_columns(palette_editor, columns);
/* all frames */
if (all_frames_same_palette)
jwidget_select(check_all_frames);
else
jwidget_deselect(check_all_frames);
/* frame */ // Hook signals
if (sprite) { jwidget_add_hook(window, -1, window_msg_proc, NULL);
jslider_set_range(slider_frame, 0, sprite->getTotalFrames()-1); HOOK(R_slider, JI_SIGNAL_SLIDER_CHANGE, sliderRGB_change_hook, 0);
jslider_set_value(slider_frame, sprite->getCurrentFrame()); HOOK(G_slider, JI_SIGNAL_SLIDER_CHANGE, sliderRGB_change_hook, 0);
HOOK(B_slider, JI_SIGNAL_SLIDER_CHANGE, sliderRGB_change_hook, 0);
if (jwidget_is_selected(check_all_frames)) HOOK(H_slider, JI_SIGNAL_SLIDER_CHANGE, sliderHSV_change_hook, 0);
jwidget_disable(slider_frame); HOOK(S_slider, JI_SIGNAL_SLIDER_CHANGE, sliderHSV_change_hook, 0);
} HOOK(V_slider, JI_SIGNAL_SLIDER_CHANGE, sliderHSV_change_hook, 0);
else { HOOK(R_entry, JI_SIGNAL_ENTRY_CHANGE, entryRGB_change_hook, 0);
jwidget_disable(slider_frame); HOOK(G_entry, JI_SIGNAL_ENTRY_CHANGE, entryRGB_change_hook, 0);
jwidget_disable(button_quantize); 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);
setup_mini_look(select_rgb);
setup_mini_look(select_hsv);
// jbutton_add_command(button_load, load_command);
// jbutton_add_command(button_save, save_command);
// jbutton_add_command(button_ramp, ramp_command);
// jbutton_add_command(button_quantize, quantize_command);
select_rgb_hook(NULL, NULL);
} }
/* hook signals */ // Show the specified target color
HOOK(slider_R, JI_SIGNAL_SLIDER_CHANGE, sliderRGB_change_hook, 0); {
HOOK(slider_G, JI_SIGNAL_SLIDER_CHANGE, sliderRGB_change_hook, 0); int imgtype = app_get_current_image_type();
HOOK(slider_B, JI_SIGNAL_SLIDER_CHANGE, sliderRGB_change_hook, 0); color_t color =
HOOK(slider_H, JI_SIGNAL_SLIDER_CHANGE, sliderHSV_change_hook, 0); (m_background ? context->getSettings()->getBgColor():
HOOK(slider_S, JI_SIGNAL_SLIDER_CHANGE, sliderHSV_change_hook, 0); context->getSettings()->getFgColor());
HOOK(slider_V, JI_SIGNAL_SLIDER_CHANGE, sliderHSV_change_hook, 0);
HOOK(slider_columns, JI_SIGNAL_SLIDER_CHANGE, slider_columns_change_hook, 0);
HOOK(slider_frame, JI_SIGNAL_SLIDER_CHANGE, slider_frame_change_hook, 0);
HOOK(check_all_frames, JI_SIGNAL_CHECK_CHANGE, check_all_frames_change_hook, 0);
HOOK(palette_editor, SIGNAL_PALETTE_EDITOR_CHANGE, palette_editor_change_hook, 0);
jbutton_add_command(button_select_all, select_all_command); on_color_changed(color);
jbutton_add_command(button_load, load_command); }
jbutton_add_command(button_save, save_command);
jbutton_add_command(button_ramp, ramp_command);
jbutton_add_command(button_quantize, quantize_command);
/* default position */ if (m_switch || m_open) {
window->remap_window(); if (!jwidget_is_visible(window)) {
window->center_window(); // Default position
window->remap_window();
window->center_window();
/* load window configuration */ // Load window configuration
load_window_pos(window, "PaletteEditor"); load_window_pos(window, "PaletteEditor");
/* open and run the window */
window->open_window_fg();
/* check the killer widget */
if (window->get_killer() == button_ok) {
if (sprite) {
SpriteWriter sprite_writer(sprite);
sprite_writer->resetPalettes();
/* one palette */
if (jwidget_is_selected(check_all_frames)) {
// Copy the current palette in the first frame
get_current_palette()->copyColorsTo(palettes[0]);
sprite_writer->setPalette(palettes[0], true);
}
/* various palettes */
else {
frame = jslider_get_value(slider_frame);
get_current_palette()->copyColorsTo(palettes[frame]);
for (frame=0; frame<sprite_writer->getTotalFrames(); ++frame) {
if (frame == 0 ||
palettes[frame]->countDiff(palettes[frame-1], NULL, NULL) > 0) {
sprite_writer->setPalette(palettes[frame], true);
}
}
}
} }
/* change the system palette */
else
set_default_palette(palette);
set_current_palette(palette, true); // Run the window in background
window->open_window_bg();
} }
/* cancel or ESC */
else {
/* restore the system palette */
if (sprite) {
SpriteWriter sprite_writer(sprite);
sprite_writer->setCurrentFrame(frame_bak);
set_current_palette(sprite->getPalette(frame_bak), true);
}
else {
set_current_palette(NULL, true);
}
}
/* redraw the entire screen */
jmanager_refresh_screen();
/* save columns configuration */
columns = jslider_get_value(slider_columns);
set_config_int("PaletteEditors", "Columns", MID(1, columns, 256));
/* save window configuration */
save_window_pos(window, "PaletteEditor");
if (!palettes.empty()) {
assert(sprite);
for (frame=0; frame<sprite->getTotalFrames(); ++frame)
delete palettes[frame];
palettes.clear();
}
delete palette;
} }
static void select_all_command(JWidget widget) static bool window_msg_proc(JWidget widget, JMessage msg)
{ {
paledit_select_range(palette_editor, 0, 255, if (msg->type == JM_TIMER &&
PALETTE_EDITOR_RANGE_LINEAL); 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);
}
catch (...) {
// Do nothing
}
}
// Redraw just the current editor
else {
redraw_all = true;
current_editor->editor_update();
}
}
return false;
}
static bool window_close_hook(JWidget widget, void *data)
{
// Save window configuration
save_window_pos(window, "PaletteEditor");
return false;
} }
static void load_command(JWidget widget) static void load_command(JWidget widget)
@ -335,22 +359,24 @@ static void save_command(JWidget widget)
return; return;
} }
if (!paledit_get_palette(palette_editor)->save(filename.c_str())) { // TODO
jalert(_("Error<<Saving palette file||&Close")); // if (!palette_editor->getPalette()->save(filename.c_str())) {
} // jalert(_("Error<<Saving palette file||&Close"));
// }
} }
} }
static void ramp_command(JWidget widget) static void ramp_command(JWidget widget)
{ {
int range_type = paledit_get_range_type(palette_editor); #if 0
int i1 = paledit_get_1st_color(palette_editor); int range_type = palette_editor->getRangeType();
int i2 = paledit_get_2nd_color(palette_editor); int i1 = palette_editor->get1stColor();
int i2 = palette_editor->get2ndColor();
Palette* palette = new Palette(0, 256); Palette* palette = new Palette(0, 256);
bool array[256]; bool array[256];
paledit_get_selected_entries(palette_editor, array); palette_editor->getSelectedEntries(array);
paledit_get_palette(palette_editor)->copyColorsTo(palette); palette_editor->getPalette()->copyColorsTo(palette);
if ((i1 >= 0) && (i2 >= 0)) { if ((i1 >= 0) && (i2 >= 0)) {
/* make the ramp */ /* make the ramp */
@ -366,181 +392,348 @@ static void ramp_command(JWidget widget)
set_new_palette(palette); set_new_palette(palette);
delete palette; delete palette;
#endif
} }
static void quantize_command(JWidget widget) static void quantize_command(JWidget widget)
{ {
const SpriteReader& sprite = get_sprite(widget); // const SpriteReader& sprite = get_sprite(widget);
assert(sprite != NULL); // assert(sprite != NULL);
Palette* palette = new Palette(0, 256); // Palette* palette = new Palette(0, 256);
bool array[256]; // bool array[256];
paledit_get_selected_entries(palette_editor, array); // paledit_get_selected_entries(palette_editor, array);
paledit_get_palette(palette_editor)->copyColorsTo(palette); // paledit_get_palette(palette_editor)->copyColorsTo(palette);
if (sprite->getImgType() == IMAGE_RGB) { // if (sprite->getImgType() == IMAGE_RGB) {
SpriteWriter sprite_writer(sprite); // SpriteWriter sprite_writer(sprite);
sprite_quantize_ex(sprite_writer, palette); // sprite_quantize_ex(sprite_writer, palette);
} // }
else { // else {
jalert(_("Error<<You can use this command only for RGB sprites||&OK")); // jalert(_("Error<<You can use this command only for RGB sprites||&OK"));
} // }
set_new_palette(palette); // set_new_palette(palette);
delete palette; // delete palette;
} }
static bool sliderRGB_change_hook(JWidget widget, void *data) static bool sliderRGB_change_hook(JWidget widget, void *data)
{ {
Palette *palette = paledit_get_palette(palette_editor); Palette* palette = get_current_palette();
int r = jslider_get_value(slider_R); int r = jslider_get_value(R_slider);
int g = jslider_get_value(slider_G); int g = jslider_get_value(G_slider);
int b = jslider_get_value(slider_B); int b = jslider_get_value(B_slider);
float h, s, v; color_t color = color_rgb(r, g, b);
bool array[256];
int c;
rgb_to_hsv(r, g, b, &h, &s, &v); jslider_set_value(H_slider, color_get_hue(color));
jslider_set_value(V_slider, color_get_value(color));
jslider_set_value(S_slider, color_get_saturation(color));
paledit_get_selected_entries(palette_editor, array); modify_all_selected_entries_in_palette(r, g, b);
for (c=0; c<256; c++) {
if (array[c]) {
palette->setEntry(c, _rgba(r, g, b, 255));
set_current_color(c, r, g, b);
}
}
jslider_set_value(slider_H, 255.0 * h / 360.0); update_entries_from_sliders();
jslider_set_value(slider_V, 255.0 * v); update_hex_entry();
jslider_set_value(slider_S, 255.0 * s); update_current_sprite_palette();
update_colorbar();
jwidget_dirty(palette_editor);
return false; return false;
} }
static bool sliderHSV_change_hook(JWidget widget, void *data) static bool sliderHSV_change_hook(JWidget widget, void *data)
{ {
Palette *palette = paledit_get_palette(palette_editor); Palette* palette = get_current_palette();
int h = jslider_get_value(slider_H); int h = jslider_get_value(H_slider);
int s = jslider_get_value(slider_S); int s = jslider_get_value(S_slider);
int v = jslider_get_value(slider_V); int v = jslider_get_value(V_slider);
color_t color = color_hsv(h, s, v);
int r, g, b;
jslider_set_value(R_slider, r = color_get_red(color));
jslider_set_value(G_slider, g = color_get_green(color));
jslider_set_value(B_slider, b = color_get_blue(color));
modify_all_selected_entries_in_palette(r, g, b);
update_entries_from_sliders();
update_hex_entry();
update_current_sprite_palette();
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);
color_t color = color_rgb(r, g, b);
H_entry->setTextf("%d", color_get_hue(color));
V_entry->setTextf("%d", color_get_value(color));
S_entry->setTextf("%d", color_get_saturation(color));
modify_all_selected_entries_in_palette(r, g, b);
update_sliders_from_entries();
update_hex_entry();
update_current_sprite_palette();
update_colorbar();
return false;
}
static bool entryHSV_change_hook(JWidget widget, void *data)
{
Palette* palette = get_current_palette();
int h = H_entry->getTextInt();
int s = S_entry->getTextInt();
int v = V_entry->getTextInt();
color_t color = color_hsv(h, s, v);
int r, g, b;
R_entry->setTextf("%d", r = color_get_red(color));
G_entry->setTextf("%d", g = color_get_green(color));
B_entry->setTextf("%d", b = color_get_blue(color));
modify_all_selected_entries_in_palette(r, g, b);
update_sliders_from_entries();
update_hex_entry();
update_current_sprite_palette();
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;
float h, s, v;
bool array[256]; bool array[256];
int c, r, g, b; int c;
hsv_to_rgb(360.0 * h / 255.0, s / 255.0, v / 255.0, &r, &g, &b); // Fill with zeros at the end of the text
while (text.size() < 6)
text.push_back('0');
paledit_get_selected_entries(palette_editor, array); // 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)));
rgb_to_hsv(r, g, b, &h, &s, &v);
palette_editor->getSelectedEntries(array);
for (c=0; c<256; c++) { for (c=0; c<256; c++) {
if (array[c]) { if (array[c]) {
palette->setEntry(c, _rgba(r, g, b, 255)); palette->setEntry(c, _rgba(r, g, b, 255));
set_current_color(c, r, g, b);
} }
} }
jslider_set_value(slider_R, r); jslider_set_value(H_slider, 255.0 * h / 360.0);
jslider_set_value(slider_G, g); jslider_set_value(V_slider, 255.0 * v);
jslider_set_value(slider_B, b); jslider_set_value(S_slider, 255.0 * s);
update_entries_from_sliders();
update_current_sprite_palette();
update_colorbar();
return false;
}
static void update_entries_from_sliders()
{
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));
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));
}
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());
jslider_set_value(H_slider, H_entry->getTextInt());
jslider_set_value(S_slider, S_entry->getTextInt());
jslider_set_value(V_slider, V_entry->getTextInt());
}
static void update_hex_entry()
{
hex_entry->setTextf("%02x%02x%02x",
jslider_get_value(R_slider),
jslider_get_value(G_slider),
jslider_get_value(B_slider));
}
static void update_current_sprite_palette()
{
if (UIContext::instance()->get_current_sprite()) {
try {
CurrentSpriteWriter sprite(UIContext::instance());
sprite->setPalette(get_current_palette(), false);
}
catch (...) {
// Ignore
}
}
jwidget_dirty(palette_editor); jwidget_dirty(palette_editor);
return false;
if (!jmanager_timer_is_running(redraw_timer_id))
jmanager_start_timer(redraw_timer_id);
redraw_all = false;
} }
static bool slider_columns_change_hook(JWidget widget, void *data) static void update_colorbar()
{ {
paledit_set_columns(palette_editor, app_get_colorbar()->dirty();
(int)jslider_get_value(widget));
return false;
} }
static bool slider_frame_change_hook(JWidget widget, void *data) static void update_sliders_from_color(color_t color)
{ {
const SpriteReader& sprite = get_sprite(widget); jslider_set_value(R_slider, color_get_red(color));
assert(sprite != NULL); jslider_set_value(G_slider, color_get_green(color));
jslider_set_value(B_slider, color_get_blue(color));
int old_frame = sprite->getCurrentFrame(); jslider_set_value(H_slider, color_get_hue(color));
int new_frame = jslider_get_value(slider_frame); jslider_set_value(S_slider, color_get_saturation(color));
jslider_set_value(V_slider, color_get_hue(color));
get_current_palette()->copyColorsTo(palettes[old_frame]);
{
SpriteWriter sprite_writer(sprite);
sprite_writer->setCurrentFrame(new_frame);
}
set_new_palette(palettes[new_frame]);
return false;
}
static bool check_all_frames_change_hook(JWidget widget, void *data)
{
const SpriteReader& sprite = get_sprite(widget);
assert(sprite != NULL);
int frame = jslider_get_value(slider_frame);
get_current_palette()->copyColorsTo(palettes[frame]);
if (jwidget_is_selected(check_all_frames)) {
bool has_two_or_more_palettes = false;
int c;
for (c=1; c<sprite->getTotalFrames(); c++) {
if (palettes[c-1]->countDiff(palettes[c], NULL, NULL) > 0) {
has_two_or_more_palettes = true;
break;
}
}
if (has_two_or_more_palettes) {
if (jalert(PACKAGE
"<<There are more than one palette. Only the"
"<<current palette will be kept (for all frames)."
"<<Do you want to continue?"
"||&Yes||&No") != 1) {
jwidget_deselect(check_all_frames);
return false;
}
}
jwidget_disable(slider_frame);
}
else
jwidget_enable(slider_frame);
return false;
} }
static bool palette_editor_change_hook(JWidget widget, void *data) static bool palette_editor_change_hook(JWidget widget, void *data)
{ {
int imgtype = colorviewer_get_imgtype(colorviewer); int imgtype = app_get_current_image_type();
color_t color = color_index(paledit_get_2nd_color(palette_editor)); color_t color = color_index(palette_editor->get2ndColor());
int r = color_get_red(imgtype, color); int r = color_get_red(color);
int g = color_get_green(imgtype, color); int g = color_get_green(color);
int b = color_get_blue(imgtype, color); int b = color_get_blue(color);
float h, s, v; float h, s, v;
rgb_to_hsv(r, g, b, &h, &s, &v); rgb_to_hsv(r, g, b, &h, &s, &v);
colorviewer_set_color(colorviewer, color); // colorviewer_set_color(colorviewer, color);
jslider_set_value(slider_R, r); {
jslider_set_value(slider_G, g); disable_colorbar_signals = true;
jslider_set_value(slider_B, b);
jslider_set_value(slider_H, 255.0 * h / 360.0); if (jmouse_b(0) & 2)
jslider_set_value(slider_V, 255.0 * v); app_get_colorbar()->setBgColor(color);
jslider_set_value(slider_S, 255.0 * s); else
app_get_colorbar()->setFgColor(color);
disable_colorbar_signals = false;
}
jslider_set_value(R_slider, r);
jslider_set_value(G_slider, g);
jslider_set_value(B_slider, b);
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);
return false; return false;
} }
static bool select_rgb_hook(JWidget widget, void *data)
{
jwidget_show(R_label);
jwidget_show(R_slider);
jwidget_show(R_entry);
jwidget_show(G_label);
jwidget_show(G_slider);
jwidget_show(G_entry);
jwidget_show(B_label);
jwidget_show(B_slider);
jwidget_show(B_entry);
jwidget_hide(H_label);
jwidget_hide(H_slider);
jwidget_hide(H_entry);
jwidget_hide(S_label);
jwidget_hide(S_slider);
jwidget_hide(S_entry);
jwidget_hide(V_label);
jwidget_hide(V_slider);
jwidget_hide(V_entry);
window->setBounds(window->getBounds());
window->dirty();
return true;
}
static bool select_hsv_hook(JWidget widget, void *data)
{
jwidget_hide(R_label);
jwidget_hide(R_slider);
jwidget_hide(R_entry);
jwidget_hide(G_label);
jwidget_hide(G_slider);
jwidget_hide(G_entry);
jwidget_hide(B_label);
jwidget_hide(B_slider);
jwidget_hide(B_entry);
jwidget_show(H_label);
jwidget_show(H_slider);
jwidget_show(H_entry);
jwidget_show(S_label);
jwidget_show(S_slider);
jwidget_show(S_entry);
jwidget_show(V_label);
jwidget_show(V_slider);
jwidget_show(V_entry);
window->setBounds(window->getBounds());
window->dirty();
return true;
}
static void modify_all_selected_entries_in_palette(int r, int g, int b)
{
bool array[256];
palette_editor->getSelectedEntries(array);
Palette* palette = get_current_palette();
for (int c=0; c<256; c++)
if (array[c])
palette->setEntry(c, _rgba(r, g, b, 255));
}
static void on_color_changed(color_t color)
{
if (disable_colorbar_signals)
return;
int imgtype = app_get_current_image_type();
int index = color_get_index(color);
palette_editor->selectColor(index);
update_sliders_from_color(color); // Update sliders
update_entries_from_sliders(); // Update entries
update_hex_entry(); // Update hex field
jwidget_flush_redraw(window);
}
static void set_new_palette(Palette* palette) static void set_new_palette(Palette* palette)
{ {
/* copy the palette */ // Copy the palette
palette->copyColorsTo(paledit_get_palette(palette_editor)); palette->copyColorsTo(get_current_palette());
/* set the palette calling the hooks */ // Set the palette calling the hooks
set_current_palette(palette, false); set_current_palette(palette, false);
/* redraw the entire screen */ // Redraw the entire screen
jmanager_refresh_screen(); jmanager_refresh_screen();
} }

10
src/commands/cmd_switch_colors.cpp
View File

@ -44,12 +44,12 @@ SwitchColorsCommand::SwitchColorsCommand()
void SwitchColorsCommand::execute(Context* context) void SwitchColorsCommand::execute(Context* context)
{ {
JWidget colorbar = app_get_colorbar(); ColorBar* colorbar = app_get_colorbar();
color_t fg = colorbar_get_fg_color(colorbar); color_t fg = colorbar->getFgColor();
color_t bg = colorbar_get_bg_color(colorbar); color_t bg = colorbar->getBgColor();
colorbar_set_fg_color(colorbar, bg); colorbar->setFgColor(bg);
colorbar_set_bg_color(colorbar, fg); colorbar->setBgColor(fg);
} }
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////

4
src/commands/fx/cmd_replace_color.cpp
View File

@ -103,12 +103,12 @@ void ReplaceColorCommand::execute(Context* context)
button_color1 = colorbutton_new button_color1 = colorbutton_new
(get_config_color("ReplaceColor", "Color1", (get_config_color("ReplaceColor", "Color1",
colorbar_get_fg_color(app_get_colorbar())), app_get_colorbar()->getFgColor()),
sprite->getImgType()); sprite->getImgType());
button_color2 = colorbutton_new button_color2 = colorbutton_new
(get_config_color("ReplaceColor", "Color2", (get_config_color("ReplaceColor", "Color2",
colorbar_get_bg_color(app_get_colorbar())), app_get_colorbar()->getBgColor()),
sprite->getImgType()); sprite->getImgType());
target_button = target_button_new(sprite->getImgType(), false); target_button = target_button_new(sprite->getImgType(), false);

2
src/context.h
View File

@ -49,8 +49,6 @@ public:
virtual bool is_executing_script() const { return false; } virtual bool is_executing_script() const { return false; }
ISettings* getSettings() { return m_settings; } ISettings* getSettings() { return m_settings; }
int getFgColor() { return m_settings->getFgColor(); }
int getBgColor() { return m_settings->getBgColor(); }
const SpriteList& get_sprite_list() const; const SpriteList& get_sprite_list() const;
Sprite* get_first_sprite() const; Sprite* get_first_sprite() const;

29
src/core/color.cpp
View File

@ -177,15 +177,12 @@ color_t color_index(int index)
return MAKE_COLOR(COLOR_TYPE_INDEX, index & 0xff); return MAKE_COLOR(COLOR_TYPE_INDEX, index & 0xff);
} }
int color_get_red(int imgtype, color_t color) int color_get_red(color_t color)
{ {
switch (GET_COLOR_TYPE(color)) { switch (GET_COLOR_TYPE(color)) {
case COLOR_TYPE_MASK: case COLOR_TYPE_MASK:
if (imgtype == IMAGE_INDEXED) return 0;
return _rgba_getr(get_current_palette()->getEntry(0));
else
return 0;
case COLOR_TYPE_RGB: case COLOR_TYPE_RGB:
return GET_DATA_C1(GET_COLOR_DATA_RGB(color)); return GET_DATA_C1(GET_COLOR_DATA_RGB(color));
@ -211,15 +208,12 @@ int color_get_red(int imgtype, color_t color)
return -1; return -1;
} }
int color_get_green(int imgtype, color_t color) int color_get_green(color_t color)
{ {
switch (GET_COLOR_TYPE(color)) { switch (GET_COLOR_TYPE(color)) {
case COLOR_TYPE_MASK: case COLOR_TYPE_MASK:
if (imgtype == IMAGE_INDEXED) return 0;
return _rgba_getg(get_current_palette()->getEntry(0));
else
return 0;
case COLOR_TYPE_RGB: case COLOR_TYPE_RGB:
return GET_DATA_C2(GET_COLOR_DATA_RGB(color)); return GET_DATA_C2(GET_COLOR_DATA_RGB(color));
@ -245,15 +239,12 @@ int color_get_green(int imgtype, color_t color)
return -1; return -1;
} }
int color_get_blue(int imgtype, color_t color) int color_get_blue(color_t color)
{ {
switch (GET_COLOR_TYPE(color)) { switch (GET_COLOR_TYPE(color)) {
case COLOR_TYPE_MASK: case COLOR_TYPE_MASK:
if (imgtype == IMAGE_INDEXED) return 0;
return _rgba_getb(get_current_palette()->getEntry(0));
else
return 0;
case COLOR_TYPE_RGB: case COLOR_TYPE_RGB:
return GET_DATA_C3(GET_COLOR_DATA_RGB(color)); return GET_DATA_C3(GET_COLOR_DATA_RGB(color));
@ -279,7 +270,7 @@ int color_get_blue(int imgtype, color_t color)
return -1; return -1;
} }
int color_get_hue(int imgtype, color_t color) int color_get_hue(color_t color)
{ {
switch (GET_COLOR_TYPE(color)) { switch (GET_COLOR_TYPE(color)) {
@ -316,7 +307,7 @@ int color_get_hue(int imgtype, color_t color)
return -1; return -1;
} }
int color_get_saturation(int imgtype, color_t color) int color_get_saturation(color_t color)
{ {
switch (GET_COLOR_TYPE(color)) { switch (GET_COLOR_TYPE(color)) {
@ -353,7 +344,7 @@ int color_get_saturation(int imgtype, color_t color)
return -1; return -1;
} }
int color_get_value(int imgtype, color_t color) int color_get_value(color_t color)
{ {
switch (GET_COLOR_TYPE(color)) { switch (GET_COLOR_TYPE(color)) {
@ -390,7 +381,7 @@ int color_get_value(int imgtype, color_t color)
return -1; return -1;
} }
int color_get_index(int imgtype, color_t color) int color_get_index(color_t color)
{ {
switch (GET_COLOR_TYPE(color)) { switch (GET_COLOR_TYPE(color)) {

15
src/core/color.h
View File

@ -46,13 +46,14 @@ color_t color_rgb(int r, int g, int b);
color_t color_hsv(int h, int s, int v); color_t color_hsv(int h, int s, int v);
color_t color_gray(int g); color_t color_gray(int g);
color_t color_index(int index); color_t color_index(int index);
int color_get_red(int imgtype, color_t color); int color_get_red(color_t color);
int color_get_green(int imgtype, color_t color); int color_get_green(color_t color);
int color_get_blue(int imgtype, color_t color); int color_get_blue(color_t color);
int color_get_hue(int imgtype, color_t color); int color_get_hue(color_t color);
int color_get_saturation(int imgtype, color_t color); int color_get_saturation(color_t color);
int color_get_value(int imgtype, color_t color); int color_get_value(color_t color);
int color_get_index(int imgtype, color_t color); int color_get_index(color_t color);
color_t color_from_image(int imgtype, int c); color_t color_from_image(int imgtype, int c);
int blackandwhite(int r, int g, int b); int blackandwhite(int r, int g, int b);

8
src/dialogs/maskcol.cpp
View File

@ -74,7 +74,7 @@ void dialogs_mask_color(Sprite* sprite)
label_color = jlabel_new(_("Color:")); label_color = jlabel_new(_("Color:"));
button_color = colorbutton_new button_color = colorbutton_new
(get_config_color("MaskColor", "Color", (get_config_color("MaskColor", "Color",
colorbar_get_fg_color(app_get_colorbar())), app_get_colorbar()->getFgColor()),
sprite->getImgType()); sprite->getImgType());
button_1 = jbutton_new("1"); button_1 = jbutton_new("1");
button_2 = jbutton_new("2"); button_2 = jbutton_new("2");
@ -156,15 +156,13 @@ void dialogs_mask_color(Sprite* sprite)
static void button_1_command(JWidget widget) static void button_1_command(JWidget widget)
{ {
colorbutton_set_color(button_color, colorbutton_set_color(button_color, app_get_colorbar()->getFgColor());
colorbar_get_fg_color(app_get_colorbar()));
mask_preview((Sprite*)widget->user_data[1]); mask_preview((Sprite*)widget->user_data[1]);
} }
static void button_2_command(JWidget widget) static void button_2_command(JWidget widget)
{ {
colorbutton_set_color(button_color, colorbutton_set_color(button_color, app_get_colorbar()->getBgColor());
colorbar_get_bg_color(app_get_colorbar()));
mask_preview((Sprite*)widget->user_data[1]); mask_preview((Sprite*)widget->user_data[1]);
} }

10
src/modules/gfx.cpp
View File

@ -430,10 +430,10 @@ void draw_color(BITMAP* bmp, const Rect& rc, int imgtype, color_t color)
BITMAP* graph; BITMAP* graph;
if (type == COLOR_TYPE_INDEX) { if (type == COLOR_TYPE_INDEX) {
data = color_get_index(imgtype, color); data = color_get_index(color);
rectfill(bmp, rc.x, rc.y, rc.x+rc.w-1, rc.y+rc.h-1, rectfill(bmp, rc.x, rc.y, rc.x+rc.w-1, rc.y+rc.h-1,
/* get_color_for_allegro(bitmap_color_depth(bmp), color)); */ get_color_for_allegro(bitmap_color_depth(bmp), color));
palette_color[data]); // palette_color[data]);
return; return;
} }
@ -441,7 +441,9 @@ void draw_color(BITMAP* bmp, const Rect& rc, int imgtype, color_t color)
case IMAGE_INDEXED: case IMAGE_INDEXED:
rectfill(bmp, rc.x, rc.y, rc.x+rc.w-1, rc.y+rc.h-1, rectfill(bmp, rc.x, rc.y, rc.x+rc.w-1, rc.y+rc.h-1,
palette_color[get_color_for_image(imgtype, color)]); get_color_for_allegro(imgtype, color_index(get_color_for_image(imgtype, color))));
// get_color_for_allegro(bitmap_color_depth(bmp), color));
// palette_color[get_color_for_image(imgtype, color)]);
break; break;
case IMAGE_RGB: case IMAGE_RGB:

8
src/settings/ui_settings_impl.cpp
View File

@ -65,12 +65,12 @@ UISettingsImpl::~UISettingsImpl()
color_t UISettingsImpl::getFgColor() color_t UISettingsImpl::getFgColor()
{ {
return colorbar_get_fg_color(app_get_colorbar()); return app_get_colorbar()->getFgColor();
} }
color_t UISettingsImpl::getBgColor() color_t UISettingsImpl::getBgColor()
{ {
return colorbar_get_bg_color(app_get_colorbar()); return app_get_colorbar()->getBgColor();
} }
Tool* UISettingsImpl::getCurrentTool() Tool* UISettingsImpl::getCurrentTool()
@ -88,12 +88,12 @@ TiledMode UISettingsImpl::getTiledMode()
void UISettingsImpl::setFgColor(color_t color) void UISettingsImpl::setFgColor(color_t color)
{ {
colorbar_set_fg_color(app_get_colorbar(), color); app_get_colorbar()->setFgColor(color);
} }
void UISettingsImpl::setBgColor(color_t color) void UISettingsImpl::setBgColor(color_t color)
{ {
colorbar_set_fg_color(app_get_colorbar(), color); app_get_colorbar()->setFgColor(color);
} }
void UISettingsImpl::setCurrentTool(Tool* tool) void UISettingsImpl::setCurrentTool(Tool* tool)

110
src/widgets/colbar.cpp
View File

@ -57,54 +57,6 @@ using Vaca::Rect;
#define FGBUTTON_SIZE (16*jguiscale()) #define FGBUTTON_SIZE (16*jguiscale())
#define BGBUTTON_SIZE (18*jguiscale()) #define BGBUTTON_SIZE (18*jguiscale())
typedef enum {
HOTCOLOR_NONE = -3,
HOTCOLOR_FGCOLOR = -2,
HOTCOLOR_BGCOLOR = -1,
} hotcolor_t;
class ColorBar : public Widget
{
size_t m_firstIndex;
size_t m_columns;
size_t m_colorsPerColum;
int m_entrySize;
color_t m_fgcolor;
color_t m_bgcolor;
hotcolor_t m_hot;
hotcolor_t m_hot_editing;
// Drag & drop colors
hotcolor_t m_hot_drag;
hotcolor_t m_hot_drop;
public:
ColorBar(int align);
~ColorBar();
color_t getFgColor() const { return m_fgcolor; }
color_t getBgColor() const { return m_bgcolor; }
void setFgColor(color_t color);
void setBgColor(color_t color);
void setColor(int index, color_t color);
color_t getColorByPosition(int x, int y);
protected:
virtual bool msg_proc(JMessage msg);
private:
int getEntriesCount() const { return m_columns*m_colorsPerColum; }
color_t getEntryColor(size_t i) const { return color_index(i+m_firstIndex); }
color_t getHotColor(hotcolor_t hot);
void setHotColor(hotcolor_t hot, color_t color);
Rect getColumnBounds(size_t column) const;
Rect getEntryBounds(size_t index) const;
Rect getFgBounds() const;
Rect getBgBounds() const;
void updateStatusBar(color_t color, int msecs);
};
int colorbar_type() int colorbar_type()
{ {
static int type = 0; static int type = 0;
@ -113,46 +65,6 @@ int colorbar_type()
return type; return type;
} }
Widget* colorbar_new(int align)
{
return new ColorBar(align);
}
void colorbar_set_size(JWidget widget, int size)
{
// TODO remove this
}
color_t colorbar_get_fg_color(JWidget widget)
{
return ((ColorBar*)widget)->getFgColor();
}
color_t colorbar_get_bg_color(JWidget widget)
{
return ((ColorBar*)widget)->getBgColor();
}
void colorbar_set_fg_color(JWidget widget, color_t color)
{
((ColorBar*)widget)->setFgColor(color);
}
void colorbar_set_bg_color(JWidget widget, color_t color)
{
((ColorBar*)widget)->setBgColor(color);
}
void colorbar_set_color(JWidget widget, int index, color_t color)
{
((ColorBar*)widget)->setColor(index, color);
}
color_t colorbar_get_color_by_position(JWidget widget, int x, int y)
{
return ((ColorBar*)widget)->getColorByPosition(x, y);
}
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// ColorBar class // ColorBar class
@ -204,6 +116,7 @@ void ColorBar::setFgColor(color_t color)
dirty(); dirty();
updateStatusBar(m_fgcolor, 100); updateStatusBar(m_fgcolor, 100);
FgColorChange(m_fgcolor);
} }
void ColorBar::setBgColor(color_t color) void ColorBar::setBgColor(color_t color)
@ -212,11 +125,7 @@ void ColorBar::setBgColor(color_t color)
dirty(); dirty();
updateStatusBar(m_bgcolor, 100); updateStatusBar(m_bgcolor, 100);
} BgColorChange(m_bgcolor);
void ColorBar::setColor(int index, color_t color)
{
// TODO remove me
} }
color_t ColorBar::getColorByPosition(int x, int y) color_t ColorBar::getColorByPosition(int x, int y)
@ -500,22 +409,25 @@ bool ColorBar::msg_proc(JMessage msg)
/* pick the color */ /* pick the color */
else if (m_hot != HOTCOLOR_NONE) { else if (m_hot != HOTCOLOR_NONE) {
switch (m_hot) { switch (m_hot) {
case HOTCOLOR_FGCOLOR: case HOTCOLOR_FGCOLOR:
case HOTCOLOR_BGCOLOR: { case HOTCOLOR_BGCOLOR: {
Command* paledit_cmd = Command* paledit_cmd = CommandsModule::instance()->get_command_by_name(CommandId::palette_editor);
CommandsModule::instance()->get_command_by_name(CommandId::palette_editor);
Params params; Params params;
params.set("target", (m_hot == HOTCOLOR_FGCOLOR ? "foreground": "background"));
params.set("open", "true");
UIContext::instance()->execute_command(paledit_cmd, &params); UIContext::instance()->execute_command(paledit_cmd, &params);
break; break;
} }
default: default:
color_t color = getHotColor(m_hot); color_t color = getHotColor(m_hot);
if (msg->mouse.left) { if (msg->mouse.left) {
colorbar_set_fg_color(this, color); this->setFgColor(color);
} }
if (msg->mouse.right) { if (msg->mouse.right) {
colorbar_set_bg_color(this, color); this->setBgColor(color);
} }
break; break;
} }
@ -564,10 +476,10 @@ void ColorBar::setHotColor(hotcolor_t hot, color_t color)
assert(false); assert(false);
break; break;
case HOTCOLOR_FGCOLOR: case HOTCOLOR_FGCOLOR:
m_fgcolor = color; setFgColor(color);
break; break;
case HOTCOLOR_BGCOLOR: case HOTCOLOR_BGCOLOR:
m_bgcolor = color; setBgColor(color);
break; break;
default: default:
assert(hot >= 0 && hot < getEntriesCount()); assert(hot >= 0 && hot < getEntriesCount());

69
src/widgets/colbar.h
View File

@ -19,23 +19,64 @@
#ifndef WIDGETS_COLBAR_H_INCLUDED #ifndef WIDGETS_COLBAR_H_INCLUDED
#define WIDGETS_COLBAR_H_INCLUDED #define WIDGETS_COLBAR_H_INCLUDED
#include "jinete/jbase.h" #include "Vaca/Signal.h"
#include "jinete/jwidget.h"
#include "core/color.h" #include "core/color.h"
JWidget colorbar_new(int align); class ColorBar : public Widget
{
typedef enum {
HOTCOLOR_NONE = -3,
HOTCOLOR_FGCOLOR = -2,
HOTCOLOR_BGCOLOR = -1,
} hotcolor_t;
public:
ColorBar(int align);
~ColorBar();
color_t getFgColor() const { return m_fgcolor; }
color_t getBgColor() const { return m_bgcolor; }
void setFgColor(color_t color);
void setBgColor(color_t color);
color_t getColorByPosition(int x, int y);
// Signals
Vaca::Signal1<void, color_t> FgColorChange;
Vaca::Signal1<void, color_t> BgColorChange;
protected:
virtual bool msg_proc(JMessage msg);
private:
int getEntriesCount() const { return m_columns*m_colorsPerColum; }
color_t getEntryColor(size_t i) const { return color_index(i+m_firstIndex); }
color_t getHotColor(hotcolor_t hot);
void setHotColor(hotcolor_t hot, color_t color);
Rect getColumnBounds(size_t column) const;
Rect getEntryBounds(size_t index) const;
Rect getFgBounds() const;
Rect getBgBounds() const;
void updateStatusBar(color_t color, int msecs);
size_t m_firstIndex;
size_t m_columns;
size_t m_colorsPerColum;
int m_entrySize;
color_t m_fgcolor;
color_t m_bgcolor;
hotcolor_t m_hot;
hotcolor_t m_hot_editing;
// Drag & drop colors
hotcolor_t m_hot_drag;
hotcolor_t m_hot_drop;
};
int colorbar_type(); int colorbar_type();
void colorbar_set_size(JWidget widget, int size);
color_t colorbar_get_fg_color(JWidget widget);
color_t colorbar_get_bg_color(JWidget widget);
void colorbar_set_fg_color(JWidget widget, color_t color);
void colorbar_set_bg_color(JWidget widget, color_t color);
void colorbar_set_color(JWidget widget, int index, color_t color);
color_t colorbar_get_color_by_position(JWidget widget, int x, int y);
#endif #endif

4
src/widgets/colbut.cpp
View File

@ -161,9 +161,7 @@ static bool colorbutton_msg_proc(JWidget widget, JMessage msg)
} }
/* pick a color from the color-bar */ /* pick a color from the color-bar */
else if (picked->type == colorbar_type()) { else if (picked->type == colorbar_type()) {
color = colorbar_get_color_by_position(picked, color = ((ColorBar*)picked)->getColorByPosition(msg->mouse.x, msg->mouse.y);
msg->mouse.x,
msg->mouse.y);
} }
/* pick a color from a editor */ /* pick a color from a editor */
else if (picked->type == editor_type()) { else if (picked->type == editor_type()) {

60
src/widgets/colsel.cpp
View File

@ -92,7 +92,7 @@ Frame* colorselector_new(bool editable_palette)
JWidget grid1 = jgrid_new(3, false); JWidget grid1 = jgrid_new(3, false);
JWidget grid2 = jgrid_new(5, false); JWidget grid2 = jgrid_new(5, false);
JWidget tabs = tabs_new(select_tab_callback); JWidget tabs = tabs_new(select_tab_callback);
JWidget pal = paledit_new(get_current_palette(), false, 1); PalEdit* pal = new PalEdit(false);
JWidget idx = jlabel_new("None"); JWidget idx = jlabel_new("None");
JWidget lock = jbutton_new(""); JWidget lock = jbutton_new("");
JWidget child; JWidget child;
@ -275,13 +275,13 @@ static bool colorselector_msg_proc(JWidget widget, JMessage msg)
case JM_SIGNAL: case JM_SIGNAL:
if (msg->signal.num == JI_SIGNAL_INIT_THEME) { if (msg->signal.num == JI_SIGNAL_INIT_THEME) {
JWidget idx = jwidget_find_name(widget, "idx"); Widget* idx = widget->findChild("idx");
JWidget pal = jwidget_find_name(widget, "pal"); PalEdit* pal = static_cast<PalEdit*>(widget->findChild("pal"));
JWidget grid2 = jwidget_find_name(widget, "grid2"); Widget* grid2 = widget->findChild("grid2");
int idxlen = ji_font_text_len(idx->getFont(), "Index=888"); int idxlen = ji_font_text_len(idx->getFont(), "Index=888");
jwidget_set_min_size(idx, idxlen, 0); jwidget_set_min_size(idx, idxlen, 0);
paledit_set_boxsize(pal, 4*jguiscale()); pal->setBoxSize(4*jguiscale());
jwidget_set_min_size(grid2, 200*jguiscale(), 0); jwidget_set_min_size(grid2, 200*jguiscale(), 0);
} }
break; break;
@ -326,17 +326,17 @@ static void colorselector_set_color2(JWidget widget, color_t color,
colorselector->color = color; colorselector->color = color;
if (exclude_this_model != models+MODEL_RGB) { if (exclude_this_model != models+MODEL_RGB) {
jslider_set_value(rgb_rslider, color_get_red(imgtype, color)); jslider_set_value(rgb_rslider, color_get_red(color));
jslider_set_value(rgb_gslider, color_get_green(imgtype, color)); jslider_set_value(rgb_gslider, color_get_green(color));
jslider_set_value(rgb_bslider, color_get_blue(imgtype, color)); jslider_set_value(rgb_bslider, color_get_blue(color));
} }
if (exclude_this_model != models+MODEL_HSV) { if (exclude_this_model != models+MODEL_HSV) {
jslider_set_value(hsv_hslider, color_get_hue(imgtype, color)); jslider_set_value(hsv_hslider, color_get_hue(color));
jslider_set_value(hsv_sslider, color_get_saturation(imgtype, color)); jslider_set_value(hsv_sslider, color_get_saturation(color));
jslider_set_value(hsv_vslider, color_get_value(imgtype, color)); jslider_set_value(hsv_vslider, color_get_value(color));
} }
if (exclude_this_model != models+MODEL_GRAY) { if (exclude_this_model != models+MODEL_GRAY) {
jslider_set_value(gray_vslider, color_get_value(imgtype, color)); jslider_set_value(gray_vslider, color_get_value(color));
} }
switch (color_type(color)) { switch (color_type(color)) {
@ -368,16 +368,15 @@ static void colorselector_set_color2(JWidget widget, color_t color,
if (update_index_entry) { if (update_index_entry) {
switch (color_type(color)) { switch (color_type(color)) {
case COLOR_TYPE_INDEX: case COLOR_TYPE_INDEX:
colorselector_set_paledit_index(widget, color_get_index(IMAGE_INDEXED, color), colorselector_set_paledit_index(widget, color_get_index(color), select_index_entry);
select_index_entry);
break; break;
case COLOR_TYPE_MASK: case COLOR_TYPE_MASK:
colorselector_set_paledit_index(widget, 0, true); colorselector_set_paledit_index(widget, 0, true);
break; break;
default: { default: {
int r = color_get_red (IMAGE_RGB, color); int r = color_get_red (color);
int g = color_get_green(IMAGE_RGB, color); int g = color_get_green(color);
int b = color_get_blue (IMAGE_RGB, color); int b = color_get_blue (color);
int i = get_current_palette()->findBestfit(r, g, b); int i = get_current_palette()->findBestfit(r, g, b);
if (i >= 0 && i < 256) if (i >= 0 && i < 256)
colorselector_set_paledit_index(widget, i, true); colorselector_set_paledit_index(widget, i, true);
@ -392,14 +391,14 @@ static void colorselector_set_color2(JWidget widget, color_t color,
static void colorselector_set_paledit_index(JWidget widget, int index, bool select_index_entry) static void colorselector_set_paledit_index(JWidget widget, int index, bool select_index_entry)
{ {
ColorSelector* colorselector = colorselector_data(widget); ColorSelector* colorselector = colorselector_data(widget);
JWidget pal = jwidget_find_name(widget, "pal"); PalEdit* pal = static_cast<PalEdit*>(widget->findChild("pal"));
JWidget idx = jwidget_find_name(widget, "idx"); Widget* idx = widget->findChild("idx");
JWidget lock = jwidget_find_name(widget, "lock"); Widget* lock = widget->findChild("lock");
char buf[256]; char buf[256];
if (index >= 0) { if (index >= 0) {
if (select_index_entry) if (select_index_entry)
paledit_select_color(pal, index); pal->selectColor(index);
sprintf(buf, "Index=%d", index); sprintf(buf, "Index=%d", index);
@ -410,7 +409,7 @@ static void colorselector_set_paledit_index(JWidget widget, int index, bool sele
} }
else { else {
if (select_index_entry) if (select_index_entry)
paledit_select_range(pal, -1, -1, PALETTE_EDITOR_RANGE_NONE); pal->selectRange(-1, -1, PALETTE_EDITOR_RANGE_NONE);
sprintf(buf, "None"); sprintf(buf, "None");
@ -454,7 +453,7 @@ static bool slider_change_hook(JWidget widget, void* data)
Frame* window = static_cast<Frame*>(widget->getRoot()); Frame* window = static_cast<Frame*>(widget->getRoot());
ColorSelector* colorselector = colorselector_data(window); ColorSelector* colorselector = colorselector_data(window);
JWidget tabs = jwidget_find_name(window, "tabs"); JWidget tabs = jwidget_find_name(window, "tabs");
JWidget pal = jwidget_find_name(window, "pal"); PalEdit* pal = static_cast<PalEdit*>(window->findChild("pal"));
Model* m = reinterpret_cast<Model*>(tabs_get_selected_tab(tabs)); Model* m = reinterpret_cast<Model*>(tabs_get_selected_tab(tabs));
color_t color = colorselector->color; color_t color = colorselector->color;
int i, r, g, b; int i, r, g, b;
@ -488,9 +487,9 @@ static bool slider_change_hook(JWidget widget, void* data)
} }
} }
r = color_get_red (IMAGE_RGB, color); r = color_get_red (color);
g = color_get_green(IMAGE_RGB, color); g = color_get_green(color);
b = color_get_blue (IMAGE_RGB, color); b = color_get_blue (color);
/* if the palette is locked then we have to search for the closest /* if the palette is locked then we have to search for the closest
color to the RGB values */ color to the RGB values */
@ -503,14 +502,14 @@ static bool slider_change_hook(JWidget widget, void* data)
else { else {
bool array[256]; bool array[256];
paledit_get_selected_entries(pal, array); pal->getSelectedEntries(array);
for (i=0; i<256; ++i) for (i=0; i<256; ++i)
if (array[i]) if (array[i])
set_current_color(i, r, g, b); set_current_color(i, r, g, b);
jwidget_dirty(pal); jwidget_dirty(pal);
i = paledit_get_2nd_color(pal); i = pal->get2ndColor();
if (i >= 0) if (i >= 0)
color = color_index(i); color = color_index(i);
} }
@ -528,14 +527,15 @@ static bool button_mask_select_hook(JWidget widget, void* data)
return true; return true;
} }
static bool paledit_change_hook(JWidget widget, void* data) static bool paledit_change_hook(Widget* widget, void* data)
{ {
Frame* window = static_cast<Frame*>(widget->getRoot()); Frame* window = static_cast<Frame*>(widget->getRoot());
PalEdit* paledit = static_cast<PalEdit*>(widget);
bool array[256]; bool array[256];
color_t color = colorselector_get_color(window); color_t color = colorselector_get_color(window);
int i; int i;
paledit_get_selected_entries(widget, array); paledit->getSelectedEntries(array);
for (i=0; i<256; ++i) for (i=0; i<256; ++i)
if (array[i]) { if (array[i]) {
color = color_index(i); color = color_index(i);

6
src/widgets/editor/editor.cpp
View File

@ -1799,9 +1799,9 @@ IToolLoop* Editor::createToolLoopImpl(Context* context, JMessage msg)
} }
// Get fg/bg colors // Get fg/bg colors
JWidget colorbar = app_get_colorbar(); ColorBar* colorbar = app_get_colorbar();
color_t fg = colorbar_get_fg_color(colorbar); color_t fg = colorbar->getFgColor();
color_t bg = colorbar_get_bg_color(colorbar); color_t bg = colorbar->getBgColor();
// Create the new tool loop // Create the new tool loop
ToolLoopImpl* tool_loop = new ToolLoopImpl(this, ToolLoopImpl* tool_loop = new ToolLoopImpl(this,

373
src/widgets/paledit.cpp
View File

@ -40,49 +40,9 @@
#include "widgets/paledit.h" #include "widgets/paledit.h"
/* #define COLOR_SIZE 6 */ /* #define COLOR_SIZE 6 */
#define COLOR_SIZE (paledit->boxsize) #define COLOR_SIZE (m_boxsize)
typedef struct PalEdit static int paledit_type()
{
JWidget widget;
Palette *palette;
bool editable;
unsigned range_type;
unsigned columns;
int boxsize;
int color[2];
} PalEdit;
static PalEdit *paledit_data(JWidget widget);
static bool paledit_msg_proc(JWidget widget, JMessage msg);
static void paledit_request_size(JWidget widget, int *w, int *h);
static void paledit_update_scroll(JWidget widget, int color);
JWidget paledit_new(Palette *palette, bool editable, int boxsize)
{
Widget* widget = new Widget(paledit_type());
PalEdit *paledit = jnew(PalEdit, 1);
paledit->widget = widget;
paledit->palette = palette;
paledit->editable = editable;
paledit->range_type = PALETTE_EDITOR_RANGE_NONE;
paledit->columns = 16;
paledit->boxsize = boxsize;
paledit->color[0] = -1;
paledit->color[1] = -1;
jwidget_add_hook(widget, paledit_type(), paledit_msg_proc, paledit);
jwidget_focusrest(widget, true);
widget->border_width.l = widget->border_width.r = 1 * jguiscale();
widget->border_width.t = widget->border_width.b = 1 * jguiscale();
widget->child_spacing = 1 * jguiscale();
return widget;
}
int paledit_type()
{ {
static int type = 0; static int type = 0;
if (!type) if (!type)
@ -90,87 +50,86 @@ int paledit_type()
return type; return type;
} }
Palette *paledit_get_palette(JWidget widget) PalEdit::PalEdit(bool editable)
: Widget(paledit_type())
{ {
PalEdit *paledit = paledit_data(widget); m_editable = editable;
m_range_type = PALETTE_EDITOR_RANGE_NONE;
m_columns = 16;
m_boxsize = 6;
m_color[0] = -1;
m_color[1] = -1;
return paledit->palette; jwidget_focusrest(this, true);
this->border_width.l = this->border_width.r = 1 * jguiscale();
this->border_width.t = this->border_width.b = 1 * jguiscale();
this->child_spacing = 1 * jguiscale();
} }
int paledit_get_range_type(JWidget widget) int PalEdit::getRangeType()
{ {
PalEdit *paledit = paledit_data(widget); return m_range_type;
return paledit->range_type;
} }
int paledit_get_columns(JWidget widget) int PalEdit::getColumns()
{ {
PalEdit *paledit = paledit_data(widget); return m_columns;
return paledit->columns;
} }
void paledit_set_columns(JWidget widget, int columns) void PalEdit::setColumns(int columns)
{ {
PalEdit *paledit = paledit_data(widget); int old_columns = m_columns;
int old_columns = paledit->columns;
assert(columns >= 1 && columns <= 256); assert(columns >= 1 && columns <= 256);
paledit->columns = columns; m_columns = columns;
if (paledit->columns != old_columns) { if (m_columns != old_columns) {
JWidget view = jwidget_get_view(widget); Widget* view = jwidget_get_view(this);
if (view) if (view)
jview_update(view); jview_update(view);
jwidget_dirty(widget); jwidget_dirty(this);
} }
} }
void paledit_set_boxsize(JWidget widget, int boxsize) void PalEdit::setBoxSize(int boxsize)
{ {
PalEdit *paledit = paledit_data(widget); m_boxsize = boxsize;
paledit->boxsize = boxsize;
} }
void paledit_select_color(JWidget widget, int index) void PalEdit::selectColor(int index)
{ {
PalEdit *paledit = paledit_data(widget);
assert(index >= 0 && index <= 255); assert(index >= 0 && index <= 255);
if ((paledit->color[0] != index) || if ((m_color[0] != index) ||
(paledit->color[1] != index) || (m_color[1] != index) ||
(paledit->range_type != PALETTE_EDITOR_RANGE_NONE)) { (m_range_type != PALETTE_EDITOR_RANGE_NONE)) {
paledit->color[0] = index; m_color[0] = index;
paledit->color[1] = index; m_color[1] = index;
paledit->range_type = PALETTE_EDITOR_RANGE_NONE; m_range_type = PALETTE_EDITOR_RANGE_NONE;
if ((index >= 0) && (index <= 255)) if ((index >= 0) && (index <= 255))
paledit_update_scroll(widget, index); update_scroll(index);
jwidget_dirty(widget); jwidget_dirty(this);
} }
} }
void paledit_select_range(JWidget widget, int begin, int end, int range_type) void PalEdit::selectRange(int begin, int end, int range_type)
{ {
PalEdit *paledit = paledit_data(widget);
/* assert(begin >= 0 && begin <= 255); */ /* assert(begin >= 0 && begin <= 255); */
/* assert(end >= 0 && end <= 255); */ /* assert(end >= 0 && end <= 255); */
paledit->color[0] = begin; m_color[0] = begin;
paledit->color[1] = end; m_color[1] = end;
paledit->range_type = range_type; m_range_type = range_type;
paledit_update_scroll(widget, end); update_scroll(end);
jwidget_dirty(widget); jwidget_dirty(this);
} }
static void swap_color(Palette *palette, int i1, int i2) static void swap_color(Palette* palette, int i1, int i2)
{ {
ase_uint32 c1 = palette->getEntry(i1); ase_uint32 c1 = palette->getEntry(i1);
ase_uint32 c2 = palette->getEntry(i2); ase_uint32 c2 = palette->getEntry(i2);
@ -179,38 +138,36 @@ static void swap_color(Palette *palette, int i1, int i2)
palette->setEntry(i1, c2); palette->setEntry(i1, c2);
} }
void paledit_move_selection(JWidget widget, int x, int y) void PalEdit::moveSelection(int x, int y)
{ {
PalEdit *paledit = paledit_data(widget); if (!m_editable)
if (!paledit->editable)
return; return;
switch (paledit->range_type) { switch (m_range_type) {
case PALETTE_EDITOR_RANGE_LINEAL: { case PALETTE_EDITOR_RANGE_LINEAL: {
int c1 = MIN(paledit->color[0], paledit->color[1]); int c1 = MIN(m_color[0], m_color[1]);
int c2 = MAX(paledit->color[0], paledit->color[1]); int c2 = MAX(m_color[0], m_color[1]);
int c; int c;
/* left */ /* left */
if (x < 0) { if (x < 0) {
if (c1 > 0) { if (c1 > 0) {
for (c=c1; c<=c2; c++) for (c=c1; c<=c2; c++)
swap_color(paledit->palette, c, c-1); swap_color(get_current_palette(), c, c-1);
paledit->color[0]--; m_color[0]--;
paledit->color[1]--; m_color[1]--;
} }
} }
/* right */ /* right */
else if (x > 0) { else if (x > 0) {
if (c2 < 255) { if (c2 < 255) {
for (c=c2; c>=c1; c--) for (c=c2; c>=c1; c--)
swap_color(paledit->palette, c, c+1); swap_color(get_current_palette(), c, c+1);
paledit->color[0]++; m_color[0]++;
paledit->color[1]++; m_color[1]++;
} }
} }
/* up */ /* up */
@ -226,9 +183,9 @@ void paledit_move_selection(JWidget widget, int x, int y)
case PALETTE_EDITOR_RANGE_NONE: case PALETTE_EDITOR_RANGE_NONE:
case PALETTE_EDITOR_RANGE_RECTANGULAR: { case PALETTE_EDITOR_RANGE_RECTANGULAR: {
int cols = paledit->columns; int cols = m_columns;
int index1 = paledit->color[0]; int index1 = m_color[0];
int index2 = paledit->color[1]; int index2 = m_color[1];
int c, u, v, x1, y1, x2, y2; int c, u, v, x1, y1, x2, y2;
/* swap */ /* swap */
@ -251,12 +208,12 @@ void paledit_move_selection(JWidget widget, int x, int y)
if ((x1 > 0) && ((y1*cols+x1-1) >= 0)) { if ((x1 > 0) && ((y1*cols+x1-1) >= 0)) {
for (v=y1; v<=y2; v++) for (v=y1; v<=y2; v++)
for (u=x1; u<=x2; u++) for (u=x1; u<=x2; u++)
swap_color(paledit->palette, swap_color(get_current_palette(),
(v*cols + u), (v*cols + u),
(v*cols + (u-1))); (v*cols + (u-1)));
paledit->color[0]--; m_color[0]--;
paledit->color[1]--; m_color[1]--;
} }
} }
/* right */ /* right */
@ -264,12 +221,12 @@ void paledit_move_selection(JWidget widget, int x, int y)
if ((x2 < cols-1) && ((y2*cols+x2+1) <= 255)) { if ((x2 < cols-1) && ((y2*cols+x2+1) <= 255)) {
for (v=y1; v<=y2; v++) for (v=y1; v<=y2; v++)
for (u=x2; u>=x1; u--) for (u=x2; u>=x1; u--)
swap_color(paledit->palette, swap_color(get_current_palette(),
(v*cols + u), (v*cols + u),
(v*cols + (u+1))); (v*cols + (u+1)));
paledit->color[0]++; m_color[0]++;
paledit->color[1]++; m_color[1]++;
} }
} }
/* up */ /* up */
@ -277,12 +234,12 @@ void paledit_move_selection(JWidget widget, int x, int y)
if (((y1-1)*cols+x1) >= 0) { if (((y1-1)*cols+x1) >= 0) {
for (v=y1; v<=y2; v++) for (v=y1; v<=y2; v++)
for (u=x1; u<=x2; u++) for (u=x1; u<=x2; u++)
swap_color(paledit->palette, swap_color(get_current_palette(),
(v*cols + u), (v*cols + u),
((v-1)*cols + u)); ((v-1)*cols + u));
paledit->color[0] -= cols; m_color[0] -= cols;
paledit->color[1] -= cols; m_color[1] -= cols;
} }
} }
/* down */ /* down */
@ -290,12 +247,12 @@ void paledit_move_selection(JWidget widget, int x, int y)
if (((y2+1)*cols+x2) <= 255) { if (((y2+1)*cols+x2) <= 255) {
for (v=y2; v>=y1; v--) for (v=y2; v>=y1; v--)
for (u=x1; u<=x2; u++) for (u=x1; u<=x2; u++)
swap_color(paledit->palette, swap_color(get_current_palette(),
(v*cols + u), (v*cols + u),
((v+1)*cols + u)); ((v+1)*cols + u));
paledit->color[0] += cols; m_color[0] += cols;
paledit->color[1] += cols; m_color[1] += cols;
} }
} }
break; break;
@ -303,43 +260,39 @@ void paledit_move_selection(JWidget widget, int x, int y)
} }
/* fixup the scroll */ /* fixup the scroll */
paledit_update_scroll(widget, paledit->color[1]); update_scroll(m_color[1]);
/* set the palette */ /* set the palette */
set_current_palette(paledit->palette, false); //set_current_palette(m_palette, false);
/* refresh the screen */ /* refresh the screen */
jmanager_refresh_screen(); jmanager_refresh_screen();
} }
int paledit_get_1st_color(JWidget widget) int PalEdit::get1stColor()
{ {
PalEdit *paledit = paledit_data(widget); return m_color[0];
return paledit->color[0];
} }
int paledit_get_2nd_color(JWidget widget) int PalEdit::get2ndColor()
{ {
PalEdit *paledit = paledit_data(widget); return m_color[1];
return paledit->color[1];
} }
void paledit_get_selected_entries(JWidget widget, bool array[256]) void PalEdit::getSelectedEntries(bool array[256])
{ {
PalEdit *paledit = paledit_data(widget);
memset(array, false, sizeof(bool)*256); memset(array, false, sizeof(bool)*256);
switch (paledit->range_type) { switch (m_range_type) {
case PALETTE_EDITOR_RANGE_NONE: case PALETTE_EDITOR_RANGE_NONE:
if (paledit->color[1] >= 0) if (m_color[1] >= 0)
array[paledit->color[1]] = true; array[m_color[1]] = true;
break; break;
case PALETTE_EDITOR_RANGE_LINEAL: { case PALETTE_EDITOR_RANGE_LINEAL: {
int c1 = MIN(paledit->color[0], paledit->color[1]); int c1 = MIN(m_color[0], m_color[1]);
int c2 = MAX(paledit->color[0], paledit->color[1]); int c2 = MAX(m_color[0], m_color[1]);
int c; int c;
for (c=c1; c<=c2; c++) for (c=c1; c<=c2; c++)
@ -348,9 +301,9 @@ void paledit_get_selected_entries(JWidget widget, bool array[256])
} }
case PALETTE_EDITOR_RANGE_RECTANGULAR: { case PALETTE_EDITOR_RANGE_RECTANGULAR: {
int cols = paledit->columns; int cols = m_columns;
int index1 = paledit->color[0]; int index1 = m_color[0];
int index2 = paledit->color[1]; int index2 = m_color[1];
int c, x, y, x1, y1, x2, y2; int c, x, y, x1, y1, x2, y2;
/* swap */ /* swap */
@ -376,64 +329,49 @@ void paledit_get_selected_entries(JWidget widget, bool array[256])
} }
} }
static PalEdit *paledit_data(JWidget widget) bool PalEdit::msg_proc(JMessage msg)
{ {
return reinterpret_cast<PalEdit*>(jwidget_get_data(widget, paledit_type()));
}
static bool paledit_msg_proc(JWidget widget, JMessage msg)
{
PalEdit *paledit = paledit_data(widget);
switch (msg->type) { switch (msg->type) {
case JM_DESTROY:
jfree (paledit);
break;
case JM_REQSIZE: case JM_REQSIZE:
paledit_request_size(widget, &msg->reqsize.w, &msg->reqsize.h); request_size(&msg->reqsize.w, &msg->reqsize.h);
return true; return true;
case JM_KEYPRESSED: // case JM_KEYPRESSED:
if (jwidget_has_focus(widget)) { // if (jwidget_has_focus(this)) {
/* other keys */ // /* other keys */
if ((paledit->color[1] >= 0) && // if ((m_color[1] >= 0) && (m_color[1] <= 255)) {
(paledit->color[1] <= 255)) { // switch (msg->key.scancode) {
switch (msg->key.scancode) { // case KEY_LEFT: moveSelection(-1, 0); return true;
case KEY_LEFT: paledit_move_selection(widget, -1, 0); break; // case KEY_RIGHT: moveSelection(+1, 0); return true;
case KEY_RIGHT: paledit_move_selection(widget, +1, 0); break; // case KEY_UP: moveSelection(0, -1); return true;
case KEY_UP: paledit_move_selection(widget, 0, -1); break; // case KEY_DOWN: moveSelection(0, +1); return true;
case KEY_DOWN: paledit_move_selection(widget, 0, +1); break; // }
// }
default: // }
return false; // break;
}
return true;
}
}
break;
case JM_DRAW: { case JM_DRAW: {
div_t d = div(256, paledit->columns); div_t d = div(256, m_columns);
int cols = paledit->columns; int cols = m_columns;
int rows = d.quot + ((d.rem)? 1: 0); int rows = d.quot + ((d.rem)? 1: 0);
int x1, y1, x2, y2; int x1, y1, x2, y2;
int x, y, u, v; int x, y, u, v;
int c, color; int c, color;
BITMAP *bmp; BITMAP *bmp;
Palette* palette = get_current_palette();
bmp = create_bitmap (jrect_w(widget->rc), jrect_h(widget->rc)); bmp = create_bitmap(jrect_w(this->rc), jrect_h(this->rc));
clear_to_color (bmp, makecol(0 , 0, 0)); clear_to_color(bmp, makecol(0 , 0, 0));
y = widget->border_width.t; y = this->border_width.t;
c = 0; c = 0;
for (v=0; v<rows; v++) { for (v=0; v<rows; v++) {
x = widget->border_width.l; x = this->border_width.l;
for (u=0; u<cols; u++) { for (u=0; u<cols; u++) {
if (c >= 256) if (c >= palette->size())
break; break;
if (bitmap_color_depth(ji_screen) == 8) if (bitmap_color_depth(ji_screen) == 8)
@ -441,26 +379,26 @@ static bool paledit_msg_proc(JWidget widget, JMessage msg)
else else
color = makecol_depth color = makecol_depth
(bitmap_color_depth(ji_screen), (bitmap_color_depth(ji_screen),
_rgba_getr(paledit->palette->getEntry(c)), _rgba_getr(palette->getEntry(c)),
_rgba_getg(paledit->palette->getEntry(c)), _rgba_getg(palette->getEntry(c)),
_rgba_getb(paledit->palette->getEntry(c))); _rgba_getb(palette->getEntry(c)));
rectfill(bmp, x, y, x+COLOR_SIZE-1, y+COLOR_SIZE-1, color); rectfill(bmp, x, y, x+COLOR_SIZE-1, y+COLOR_SIZE-1, color);
x += COLOR_SIZE+widget->child_spacing; x += COLOR_SIZE+this->child_spacing;
c++; c++;
} }
y += COLOR_SIZE+widget->child_spacing; y += COLOR_SIZE+this->child_spacing;
} }
/* draw the edges in the selected color */ /* draw the edges in the selected color */
if (paledit->color[0] >= 0) { if (m_color[0] >= 0) {
int index1 = paledit->color[0]; int index1 = m_color[0];
int index2 = paledit->color[1]; int index2 = m_color[1];
int bl = widget->border_width.l; int bl = this->border_width.l;
int bt = widget->border_width.t; int bt = this->border_width.t;
int cs = widget->child_spacing; int cs = this->child_spacing;
int color = makecol (255, 255, 255); int color = makecol (255, 255, 255);
/* swap */ /* swap */
@ -479,7 +417,7 @@ static bool paledit_msg_proc(JWidget widget, JMessage msg)
if (y2 < y1) { c = y2; y2 = y1; y1 = c; } if (y2 < y1) { c = y2; y2 = y1; y1 = c; }
/* draw the rectangular gamma or just the cursor */ /* draw the rectangular gamma or just the cursor */
if (paledit->range_type != PALETTE_EDITOR_RANGE_LINEAL) { if (m_range_type != PALETTE_EDITOR_RANGE_LINEAL) {
if (x2 < x1) { c = x2; x2 = x1; x1 = c; } if (x2 < x1) { c = x2; x2 = x1; x1 = c; }
rect(bmp, rect(bmp,
@ -548,32 +486,33 @@ static bool paledit_msg_proc(JWidget widget, JMessage msg)
} }
blit(bmp, ji_screen, blit(bmp, ji_screen,
0, 0, widget->rc->x1, widget->rc->y1, bmp->w, bmp->h); 0, 0, this->rc->x1, this->rc->y1, bmp->w, bmp->h);
destroy_bitmap(bmp); destroy_bitmap(bmp);
break; break;
} }
case JM_BUTTONPRESSED: case JM_BUTTONPRESSED:
jwidget_hard_capture_mouse(widget); jwidget_hard_capture_mouse(this);
/* continue... */ /* continue... */
case JM_MOTION: case JM_MOTION:
if (jwidget_has_capture(widget)) { if (jwidget_has_capture(this)) {
JRect cpos = jwidget_get_child_rect(widget); JRect cpos = jwidget_get_child_rect(this);
div_t d = div (256, paledit->columns); div_t d = div(256, m_columns);
int cols = paledit->columns; int cols = m_columns;
int rows = d.quot + ((d.rem)? 1: 0); int rows = d.quot + ((d.rem)? 1: 0);
int mouse_x, mouse_y; int mouse_x, mouse_y;
int req_w, req_h; int req_w, req_h;
int x, y, u, v; int x, y, u, v;
int c; int c;
Palette* palette = get_current_palette();
paledit_request_size(widget, &req_w, &req_h); request_size(&req_w, &req_h);
mouse_x = MID(cpos->x1, msg->mouse.x, mouse_x = MID(cpos->x1, msg->mouse.x,
cpos->x1+req_w-widget->border_width.r-1); cpos->x1+req_w-this->border_width.r-1);
mouse_y = MID(cpos->y1, msg->mouse.y, mouse_y = MID(cpos->y1, msg->mouse.y,
cpos->y1+req_h-widget->border_width.b-1); cpos->y1+req_h-this->border_width.b-1);
y = cpos->y1; y = cpos->y1;
c = 0; c = 0;
@ -582,35 +521,31 @@ static bool paledit_msg_proc(JWidget widget, JMessage msg)
x = cpos->x1; x = cpos->x1;
for (u=0; u<cols; u++) { for (u=0; u<cols; u++) {
if (c >= 256) if (c >= palette->size())
break; break;
if ((mouse_x >= x) && (mouse_x <= x+COLOR_SIZE) && if ((mouse_x >= x) && (mouse_x <= x+COLOR_SIZE) &&
(mouse_y >= y) && (mouse_y <= y+COLOR_SIZE) && (mouse_y >= y) && (mouse_y <= y+COLOR_SIZE) &&
(c != paledit->color[1])) { (c != m_color[1])) {
if (msg->any.shifts & KB_SHIFT_FLAG) if (msg->any.shifts & KB_SHIFT_FLAG)
paledit_select_range(widget, selectRange(m_color[0], c, PALETTE_EDITOR_RANGE_LINEAL);
paledit->color[0], c,
PALETTE_EDITOR_RANGE_LINEAL);
else if (msg->any.shifts & KB_CTRL_FLAG) else if (msg->any.shifts & KB_CTRL_FLAG)
paledit_select_range(widget, selectRange(m_color[0], c, PALETTE_EDITOR_RANGE_RECTANGULAR);
paledit->color[0], c,
PALETTE_EDITOR_RANGE_RECTANGULAR);
else else
paledit_select_color(widget, c); selectColor(c);
paledit_update_scroll(widget, c); update_scroll(c);
jwidget_emit_signal(widget, SIGNAL_PALETTE_EDITOR_CHANGE); jwidget_emit_signal(this, SIGNAL_PALETTE_EDITOR_CHANGE);
c = 256; c = 256;
break; break;
} }
x += COLOR_SIZE+widget->child_spacing; x += COLOR_SIZE+this->child_spacing;
c++; c++;
} }
y += COLOR_SIZE+widget->child_spacing; y += COLOR_SIZE+this->child_spacing;
} }
jrect_free(cpos); jrect_free(cpos);
@ -619,32 +554,30 @@ static bool paledit_msg_proc(JWidget widget, JMessage msg)
break; break;
case JM_BUTTONRELEASED: case JM_BUTTONRELEASED:
jwidget_release_mouse(widget); jwidget_release_mouse(this);
return true; return true;
} }
return false; return Widget::msg_proc(msg);
} }
static void paledit_request_size(JWidget widget, int *w, int *h) void PalEdit::request_size(int* w, int* h)
{ {
PalEdit *paledit = paledit_data(widget); div_t d = div(256, m_columns);
div_t d = div(256, paledit->columns); int cols = m_columns;
int cols = paledit->columns;
int rows = d.quot + ((d.rem)? 1: 0); int rows = d.quot + ((d.rem)? 1: 0);
*w = widget->border_width.l + widget->border_width.r + *w = this->border_width.l + this->border_width.r +
+ cols*COLOR_SIZE + (cols-1)*widget->child_spacing; + cols*COLOR_SIZE + (cols-1)*this->child_spacing;
*h = widget->border_width.t + widget->border_width.b + *h = this->border_width.t + this->border_width.b +
+ rows*COLOR_SIZE + (rows-1)*widget->child_spacing; + rows*COLOR_SIZE + (rows-1)*this->child_spacing;
} }
static void paledit_update_scroll(JWidget widget, int color) void PalEdit::update_scroll(int color)
{ {
JWidget view = jwidget_get_view(widget); Widget* view = jwidget_get_view(this);
if (view != NULL) { if (view != NULL) {
PalEdit *paledit = paledit_data(widget);
JRect vp = jview_get_viewport_position(view); JRect vp = jview_get_viewport_position(view);
int scroll_x, scroll_y; int scroll_x, scroll_y;
int x, y, cols; int x, y, cols;
@ -652,11 +585,11 @@ static void paledit_update_scroll(JWidget widget, int color)
jview_get_scroll(view, &scroll_x, &scroll_y); jview_get_scroll(view, &scroll_x, &scroll_y);
d = div(256, paledit->columns); d = div(256, m_columns);
cols = paledit->columns; cols = m_columns;
y = (COLOR_SIZE+widget->child_spacing) * (color / cols); y = (COLOR_SIZE+this->child_spacing) * (color / cols);
x = (COLOR_SIZE+widget->child_spacing) * (color % cols); x = (COLOR_SIZE+this->child_spacing) * (color % cols);
if (scroll_x > x) if (scroll_x > x)
scroll_x = x; scroll_x = x;

47
src/widgets/paledit.h
View File

@ -21,11 +21,9 @@
#include <allegro/color.h> #include <allegro/color.h>
#include "jinete/jbase.h" #include "jinete/jwidget.h"
class Palette; // TODO use some JI_SIGNAL_USER
/* TODO use some JI_SIGNAL_USER */
#define SIGNAL_PALETTE_EDITOR_CHANGE 0x10005 #define SIGNAL_PALETTE_EDITOR_CHANGE 0x10005
enum { enum {
@ -34,23 +32,38 @@ enum {
PALETTE_EDITOR_RANGE_RECTANGULAR, PALETTE_EDITOR_RANGE_RECTANGULAR,
}; };
JWidget paledit_new(Palette* palette, bool editable, int boxsize); class PalEdit : public Widget
int paledit_type(); {
public:
PalEdit(bool editable);
Palette* paledit_get_palette(JWidget widget); int getRangeType();
int paledit_get_range_type(JWidget widget);
int paledit_get_columns(JWidget widget); int getColumns();
void paledit_set_columns(JWidget widget, int columns); void setColumns(int columns);
void paledit_set_boxsize(JWidget widget, int boxsize); void setBoxSize(int boxsize);
void paledit_select_color(JWidget widget, int index); void selectColor(int index);
void paledit_select_range(JWidget widget, int begin, int end, int range_type); void selectRange(int begin, int end, int range_type);
void paledit_move_selection(JWidget widget, int x, int y); void moveSelection(int x, int y);
int paledit_get_1st_color(JWidget widget); int get1stColor();
int paledit_get_2nd_color(JWidget widget); int get2ndColor();
void paledit_get_selected_entries(JWidget widget, bool array[256]); void getSelectedEntries(bool array[256]);
protected:
virtual bool msg_proc(JMessage msg);
private:
void request_size(int* w, int* h);
void update_scroll(int color);
bool m_editable;
unsigned m_range_type;
unsigned m_columns;
int m_boxsize;
int m_color[2];
};
#endif #endif