mirror/aseprite
1
0
Fork 0
mirror of https://github.com/aseprite/aseprite.git synced 2025-03-29 19:20:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Convert jslider to Slider class.

Browse Source 
+ Changed JI_SIGNAL_SLIDER_CHANGE to Slider::Change signal.
This commit is contained in:
David Capello 2010-12-04 16:13:21 -03:00
parent 5605ae81e0
commit 551efd4313
17 changed files with 353 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/commands/cmd_cel_properties.cpp
View File

@ -64,7 +64,8 @@ bool CelPropertiesCommand::onEnabled(Context* context)
void CelPropertiesCommand::onExecute(Context* context)
{
JWidget label_frame, label_pos, label_size;
JWidget slider_opacity, button_ok;
Widget* button_ok;
Slider* slider_opacity;
char buf[1024];
int memsize;
@ -113,7 +114,7 @@ void CelPropertiesCommand::onExecute(Context* context)
label_size->setText(buf);
/* opacity */
jslider_set_value(slider_opacity, cel->opacity);
slider_opacity->setValue(cel->opacity);
if (layer->is_background()) {
slider_opacity->setEnabled(false);
jwidget_add_tooltip_text(slider_opacity, "The `Background' layer is opaque,\n"
@ -123,7 +124,7 @@ void CelPropertiesCommand::onExecute(Context* context)
else {
label_pos->setText("None");
label_size->setText("Empty (0 bytes)");
jslider_set_value(slider_opacity, 0);
slider_opacity->setValue(0);
slider_opacity->setEnabled(false);
}
@ -134,7 +135,7 @@ void CelPropertiesCommand::onExecute(Context* context)
Layer* layer_writer = sprite_writer->getCurrentLayer();
Cel* cel_writer = static_cast<LayerImage*>(layer_writer)->getCel(sprite->getCurrentFrame());
int new_opacity = jslider_get_value(slider_opacity);
int new_opacity = slider_opacity->getValue();
/* the opacity was changed? */
if (cel_writer != NULL &&

170
src/commands/cmd_configure_tools.cpp
View File

@ -51,13 +51,7 @@ static Frame* window = NULL;
static bool brush_preview_msg_proc(JWidget widget, JMessage msg);
static bool window_close_hook(JWidget widget, void *data);
static bool brush_size_slider_change_hook(JWidget widget, void *data);
static bool brush_angle_slider_change_hook(JWidget widget, void *data);
static bool brush_type_change_hook(JWidget widget, void *data);
static bool opacity_slider_change_hook(JWidget widget, void *data);
static bool tolerance_slider_change_hook(JWidget widget, void *data);
static bool spray_width_slider_change_hook(JWidget widget, void *data);
static bool air_speed_slider_change_hook(JWidget widget, void *data);
// Slot for App::Exit signal
static void on_exit_delete_this_widget()
@ -68,9 +62,11 @@ static void on_exit_delete_this_widget()
static void on_pen_size_after_change()
{
Widget* brush_size = window->findChild("brush_size");
Slider* brush_size = window->findChildT<Slider>("brush_size");
Widget* brush_preview = window->findChild("brush_preview");
ASSERT(brush_size != NULL);
Tool* current_tool = UIContext::instance()
->getSettings()
->getCurrentTool();
@ -79,7 +75,7 @@ static void on_pen_size_after_change()
->getSettings()
->getToolSettings(current_tool);
jslider_set_value(brush_size, tool_settings->getPen()->getSize());
brush_size->setValue(tool_settings->getPen()->getSize());
// Regenerate the preview
brush_preview->dirty();
@ -87,17 +83,17 @@ static void on_pen_size_after_change()
static void on_current_tool_change()
{
Widget* brush_size = window->findChild("brush_size");
Widget* brush_angle = window->findChild("brush_angle");
Slider* brush_size = window->findChildT<Slider>("brush_size");
Slider* brush_angle = window->findChildT<Slider>("brush_angle");
Widget* brush_type = window->findChild("brush_type");
Widget* brush_preview = window->findChild("brush_preview");
Widget* opacity_label = window->findChild("opacity_label");
Widget* opacity = window->findChild("opacity");
Slider* opacity = window->findChildT<Slider>("opacity");
Widget* tolerance_label = window->findChild("tolerance_label");
Widget* tolerance = window->findChild("tolerance");
Slider* tolerance = window->findChildT<Slider>("tolerance");
Widget* spray_box = window->findChild("spray_box");
Widget* spray_width = window->findChild("spray_width");
Widget* air_speed = window->findChild("air_speed");
Slider* spray_width = window->findChildT<Slider>("spray_width");
Slider* air_speed = window->findChildT<Slider>("air_speed");
Tool* current_tool = UIContext::instance()
->getSettings()
@ -107,12 +103,12 @@ static void on_current_tool_change()
->getSettings()
->getToolSettings(current_tool);
jslider_set_value(opacity, tool_settings->getOpacity());
jslider_set_value(tolerance, tool_settings->getTolerance());
jslider_set_value(brush_size, tool_settings->getPen()->getSize());
jslider_set_value(brush_angle, tool_settings->getPen()->getAngle());
jslider_set_value(spray_width, tool_settings->getSprayWidth());
jslider_set_value(air_speed, tool_settings->getSpraySpeed());
opacity->setValue(tool_settings->getOpacity());
tolerance->setValue(tool_settings->getTolerance());
brush_size->setValue(tool_settings->getPen()->getSize());
brush_angle->setValue(tool_settings->getPen()->getAngle());
spray_width->setValue(tool_settings->getSprayWidth());
air_speed->setValue(tool_settings->getSpraySpeed());
// Select the brush type
group_button_select(brush_type, tool_settings->getPen()->getType());
@ -183,6 +179,12 @@ private:
CheckBox* m_snapToGrid;
CheckBox* m_onionSkin;
CheckBox* m_viewGrid;
Slider* m_brushSize;
Slider* m_brushAngle;
Slider* m_opacity;
Slider* m_tolerance;
Slider* m_sprayWidth;
Slider* m_airSpeed;
void onTiledClick();
void onTiledXYClick(int tiled_axis, CheckBox* checkbox);
@ -191,6 +193,13 @@ private:
void onSetGridClick();
void onSnapToGridClick();
void onOnionSkinClick();
void onBrushSizeSliderChange(Widget* brush_preview);
void onBrushAngleSliderChange(Widget* brush_preview);
void onOpacitySliderChange();
void onToleranceSliderChange();
void onSprayWidthSliderChange();
void onAirSpeedSliderChange();
};
ConfigureTools::ConfigureTools()
@ -203,8 +212,6 @@ ConfigureTools::ConfigureTools()
void ConfigureTools::onExecute(Context* context)
{
Button* set_grid;
JWidget brush_size, brush_angle, opacity, tolerance;
JWidget spray_width, air_speed;
JWidget brush_preview_box;
JWidget brush_type_box, brush_type;
JWidget brush_preview;
@ -229,12 +236,12 @@ void ConfigureTools::onExecute(Context* context)
"view_grid", &m_viewGrid,
"pixel_grid", &m_pixelGrid,
"set_grid", &set_grid,
"brush_size", &brush_size,
"brush_angle", &brush_angle,
"opacity", &opacity,
"tolerance", &tolerance,
"spray_width", &spray_width,
"air_speed", &air_speed,
"brush_size", &m_brushSize,
"brush_angle", &m_brushAngle,
"opacity", &m_opacity,
"tolerance", &m_tolerance,
"spray_width", &m_sprayWidth,
"air_speed", &m_airSpeed,
"brush_preview_box", &brush_preview_box,
"brush_type_box", &brush_type_box,
"onionskin", &m_onionSkin, NULL);
@ -311,13 +318,14 @@ void ConfigureTools::onExecute(Context* context)
App::instance()->CurrentToolChange.connect(&on_current_tool_change);
// Append hooks
HOOK(brush_size, JI_SIGNAL_SLIDER_CHANGE, brush_size_slider_change_hook, brush_preview);
HOOK(brush_angle, JI_SIGNAL_SLIDER_CHANGE, brush_angle_slider_change_hook, brush_preview);
m_brushSize->Change.connect(Bind<void>(&ConfigureTools::onBrushSizeSliderChange, this, brush_preview));
m_brushAngle->Change.connect(Bind<void>(&ConfigureTools::onBrushAngleSliderChange, this, brush_preview));
m_opacity->Change.connect(&ConfigureTools::onOpacitySliderChange, this);
m_tolerance->Change.connect(&ConfigureTools::onToleranceSliderChange, this);
m_airSpeed->Change.connect(&ConfigureTools::onAirSpeedSliderChange, this);
m_sprayWidth->Change.connect(&ConfigureTools::onSprayWidthSliderChange, this);
HOOK(brush_type, SIGNAL_GROUP_BUTTON_CHANGE, brush_type_change_hook, brush_preview);
HOOK(opacity, JI_SIGNAL_SLIDER_CHANGE, opacity_slider_change_hook, 0);
HOOK(tolerance, JI_SIGNAL_SLIDER_CHANGE, tolerance_slider_change_hook, 0);
HOOK(air_speed, JI_SIGNAL_SLIDER_CHANGE, air_speed_slider_change_hook, 0);
HOOK(spray_width, JI_SIGNAL_SLIDER_CHANGE, spray_width_slider_change_hook, 0);
}
// Update current pen properties
@ -383,38 +391,6 @@ static bool window_close_hook(JWidget widget, void *data)
return false;
}
static bool brush_size_slider_change_hook(JWidget widget, void *data)
{
Tool* current_tool = UIContext::instance()
->getSettings()
->getCurrentTool();
UIContext::instance()
->getSettings()
->getToolSettings(current_tool)
->getPen()
->setSize(jslider_get_value(widget));
jwidget_dirty((JWidget)data);
return false;
}
static bool brush_angle_slider_change_hook(JWidget widget, void *data)
{
Tool* current_tool = UIContext::instance()
->getSettings()
->getCurrentTool();
UIContext::instance()
->getSettings()
->getToolSettings(current_tool)
->getPen()
->setAngle(jslider_get_value(widget));
jwidget_dirty((JWidget)data);
return false;
}
static bool brush_type_change_hook(JWidget widget, void *data)
{
PenType type = (PenType)group_button_get_selected(widget);
@ -441,36 +417,66 @@ static bool brush_type_change_hook(JWidget widget, void *data)
return true;
}
static bool opacity_slider_change_hook(JWidget widget, void *data)
void ConfigureTools::onBrushSizeSliderChange(Widget* brush_preview)
{
ISettings* settings = UIContext::instance()->getSettings();
Tool* current_tool = settings->getCurrentTool();
settings->getToolSettings(current_tool)->setOpacity(jslider_get_value(widget));
return false;
Tool* current_tool = UIContext::instance()
->getSettings()
->getCurrentTool();
UIContext::instance()
->getSettings()
->getToolSettings(current_tool)
->getPen()
->setSize(m_brushSize->getValue());
brush_preview->dirty();
}
static bool tolerance_slider_change_hook(JWidget widget, void *data)
void ConfigureTools::onBrushAngleSliderChange(Widget* brush_preview)
{
ISettings* settings = UIContext::instance()->getSettings();
Tool* current_tool = settings->getCurrentTool();
settings->getToolSettings(current_tool)->setTolerance(jslider_get_value(widget));
return false;
Tool* current_tool = UIContext::instance()
->getSettings()
->getCurrentTool();
UIContext::instance()
->getSettings()
->getToolSettings(current_tool)
->getPen()
->setAngle(m_brushAngle->getValue());
brush_preview->dirty();
}
static bool spray_width_slider_change_hook(JWidget widget, void *data)
void ConfigureTools::onOpacitySliderChange()
{
ISettings* settings = UIContext::instance()->getSettings();
Tool* current_tool = settings->getCurrentTool();
settings->getToolSettings(current_tool)->setSprayWidth(jslider_get_value(widget));
return false;
settings->getToolSettings(current_tool)->setOpacity(m_opacity->getValue());
}
static bool air_speed_slider_change_hook(JWidget widget, void *data)
void ConfigureTools::onToleranceSliderChange()
{
ISettings* settings = UIContext::instance()->getSettings();
Tool* current_tool = settings->getCurrentTool();
settings->getToolSettings(current_tool)->setSpraySpeed(jslider_get_value(widget));
return false;
settings->getToolSettings(current_tool)->setTolerance(m_tolerance->getValue());
}
void ConfigureTools::onSprayWidthSliderChange()
{
ISettings* settings = UIContext::instance()->getSettings();
Tool* current_tool = settings->getCurrentTool();
settings->getToolSettings(current_tool)->setSprayWidth(m_sprayWidth->getValue());
}
void ConfigureTools::onAirSpeedSliderChange()
{
ISettings* settings = UIContext::instance()->getSettings();
Tool* current_tool = settings->getCurrentTool();
settings->getToolSettings(current_tool)->setSpraySpeed(m_airSpeed->getValue());
}
void ConfigureTools::onTiledClick()

104
src/commands/cmd_palette_editor.cpp
View File

@ -91,8 +91,8 @@ private:
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 Slider *R_slider, *G_slider, *B_slider;
static Slider *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;
@ -108,8 +108,8 @@ static void ramp_command(JWidget widget);
static void sort_command(JWidget widget);
static void quantize_command(JWidget widget);
static bool sliderRGB_change_hook(JWidget widget, void *data);
static bool sliderHSV_change_hook(JWidget widget, void *data);
static void sliderRGB_change_hook(Slider* widget);
static void sliderHSV_change_hook(Slider* widget);
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);
@ -242,12 +242,12 @@ void PaletteEditorCommand::onExecute(Context* context)
// 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);
R_slider->Change.connect(Bind<void>(&sliderRGB_change_hook, R_slider));
G_slider->Change.connect(Bind<void>(&sliderRGB_change_hook, G_slider));
B_slider->Change.connect(Bind<void>(&sliderRGB_change_hook, B_slider));
H_slider->Change.connect(Bind<void>(&sliderHSV_change_hook, H_slider));
S_slider->Change.connect(Bind<void>(&sliderHSV_change_hook, S_slider));
V_slider->Change.connect(Bind<void>(&sliderHSV_change_hook, V_slider));
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);
@ -725,16 +725,16 @@ static void quantize_command(JWidget widget)
delete palette;
}
static bool sliderRGB_change_hook(JWidget widget, void *data)
static void sliderRGB_change_hook(Slider* widget)
{
int r = jslider_get_value(R_slider);
int g = jslider_get_value(G_slider);
int b = jslider_get_value(B_slider);
int r = R_slider->getValue();
int g = G_slider->getValue();
int b = B_slider->getValue();
Color color = Color::fromRgb(r, g, b);
jslider_set_value(H_slider, color.getHue());
jslider_set_value(V_slider, color.getValue());
jslider_set_value(S_slider, color.getSaturation());
H_slider->setValue(color.getHue());
V_slider->setValue(color.getValue());
S_slider->setValue(color.getSaturation());
modify_rgb_of_selected_entries(r, g, b,
widget == R_slider,
@ -745,20 +745,19 @@ static bool sliderRGB_change_hook(JWidget widget, void *data)
update_hex_entry();
update_current_sprite_palette("Color Change");
update_colorbar();
return false;
}
static bool sliderHSV_change_hook(JWidget widget, void *data)
static void sliderHSV_change_hook(Slider* widget)
{
int h = jslider_get_value(H_slider);
int s = jslider_get_value(S_slider);
int v = jslider_get_value(V_slider);
int h = H_slider->getValue();
int s = S_slider->getValue();
int v = V_slider->getValue();
Color color = Color::fromHsv(h, s, v);
int r, g, b;
jslider_set_value(R_slider, r = color.getRed());
jslider_set_value(G_slider, g = color.getGreen());
jslider_set_value(B_slider, b = color.getBlue());
R_slider->setValue(r = color.getRed());
G_slider->setValue(g = color.getGreen());
B_slider->setValue(b = color.getBlue());
modify_hsv_of_selected_entries(h, s, v,
widget == H_slider,
@ -769,7 +768,6 @@ static bool sliderHSV_change_hook(JWidget widget, void *data)
update_hex_entry();
update_current_sprite_palette("Color Change");
update_colorbar();
return false;
}
static bool entryRGB_change_hook(JWidget widget, void *data)
@ -838,9 +836,9 @@ static bool hex_entry_change_hook(JWidget widget, void *data)
// 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)));
R_slider->setValue(r = ((hex & 0xff0000) >> 16));
G_slider->setValue(g = ((hex & 0xff00) >> 8));
B_slider->setValue(b = ((hex & 0xff)));
rgb_to_hsv(r, g, b, &h, &s, &v);
@ -851,9 +849,9 @@ static bool hex_entry_change_hook(JWidget widget, void *data)
}
}
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);
H_slider->setValue(255.0 * h / 360.0);
V_slider->setValue(255.0 * v);
S_slider->setValue(255.0 * s);
update_entries_from_sliders();
update_current_sprite_palette("Color Change");
@ -863,32 +861,32 @@ static bool hex_entry_change_hook(JWidget widget, void *data)
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));
R_entry->setTextf("%d", R_slider->getValue());
G_entry->setTextf("%d", G_slider->getValue());
B_entry->setTextf("%d", B_slider->getValue());
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));
H_entry->setTextf("%d", H_slider->getValue());
S_entry->setTextf("%d", S_slider->getValue());
V_entry->setTextf("%d", V_slider->getValue());
}
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());
R_slider->setValue(R_entry->getTextInt());
G_slider->setValue(G_entry->getTextInt());
B_slider->setValue(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());
H_slider->setValue(H_entry->getTextInt());
S_slider->setValue(S_entry->getTextInt());
V_slider->setValue(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));
R_slider->getValue(),
G_slider->getValue(),
B_slider->getValue());
}
static void update_current_sprite_palette(const char* operationName)
@ -934,12 +932,12 @@ static void update_colorbar()
static void update_sliders_from_color(const Color& color)
{
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());
R_slider->setValue(color.getRed());
G_slider->setValue(color.getGreen());
B_slider->setValue(color.getBlue());
H_slider->setValue(color.getHue());
S_slider->setValue(color.getSaturation());
V_slider->setValue(color.getValue());
}
static bool palette_editor_change_hook(JWidget widget, void *data)

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

@ -44,13 +44,13 @@
static ColorButton* button_color1;
static ColorButton* button_color2;
static JWidget slider_tolerance;
static Slider* slider_tolerance;
static JWidget preview;
static CheckBox* check_preview;
static bool color_change_hook(JWidget widget, void *data);
static bool target_change_hook(JWidget widget, void *data);
static bool slider_change_hook(JWidget widget, void *data);
static void slider_change_hook(Slider* tolerance_slider);
static void preview_change_hook(Widget* widget);
static void make_preview();
@ -117,8 +117,7 @@ void ReplaceColorCommand::onExecute(Context* context)
target_button = target_button_new(sprite->getImgType(), false);
target_button_set_target(target_button, effect.target);
jslider_set_value(slider_tolerance,
get_config_int("ReplaceColor", "Tolerance", 0));
slider_tolerance->setValue(get_config_int("ReplaceColor", "Tolerance", 0));
if (get_config_bool("ReplaceColor", "Preview", true))
check_preview->setSelected(true);
@ -130,7 +129,7 @@ void ReplaceColorCommand::onExecute(Context* context)
HOOK(button_color1, SIGNAL_COLORBUTTON_CHANGE, color_change_hook, 1);
HOOK(button_color2, SIGNAL_COLORBUTTON_CHANGE, color_change_hook, 2);
HOOK(target_button, SIGNAL_TARGET_BUTTON_CHANGE, target_change_hook, 0);
HOOK(slider_tolerance, JI_SIGNAL_SLIDER_CHANGE, slider_change_hook, 0);
slider_tolerance->Change.connect(Bind<void>(&slider_change_hook, slider_tolerance));
check_preview->Click.connect(Bind<void>(&preview_change_hook, check_preview));
/* default position */
@ -175,11 +174,10 @@ static bool target_change_hook(JWidget widget, void *data)
return false;
}
static bool slider_change_hook(JWidget widget, void *data)
static void slider_change_hook(Slider* tolerance_slider)
{
set_config_int("ReplaceColor", "Tolerance", jslider_get_value(widget));
set_config_int("ReplaceColor", "Tolerance", tolerance_slider->getValue());
make_preview();
return false;
}
static void preview_change_hook(Widget* widget)

39
src/dialogs/maskcol.cpp
View File

@ -18,19 +18,18 @@
#include "config.h"
#include "app.h"
#include "app/color.h"
#include "app/color_utils.h"
#include "base/bind.h"
#include "gui/jbox.h"
#include "core/cfg.h"
#include "gui/button.h"
#include "gui/frame.h"
#include "gui/jbox.h"
#include "gui/jhook.h"
#include "gui/label.h"
#include "gui/slider.h"
#include "gui/widget.h"
#include "gui/frame.h"
#include "app.h"
#include "app/color.h"
#include "app/color_utils.h"
#include "core/cfg.h"
#include "modules/editors.h"
#include "modules/gui.h"
#include "raster/image.h"
@ -43,13 +42,11 @@
static ColorButton* button_color;
static CheckBox* check_preview;
static Widget* slider_tolerance;
static Slider* slider_tolerance;
static void button_1_command(JWidget widget);
static void button_2_command(JWidget widget);
static bool color_change_hook(JWidget widget, void *data);
static bool slider_change_hook(JWidget widget, void *data);
static void preview_change_hook(Sprite* data);
static Mask *gen_mask(const Sprite* sprite);
static void mask_preview(Sprite* sprite);
@ -85,7 +82,7 @@ void dialogs_mask_color(Sprite* sprite)
button_1 = new Button("1");
button_2 = new Button("2");
label_tolerance = new Label("Tolerance:");
slider_tolerance = jslider_new(0, 255, get_config_int("MaskColor", "Tolerance", 0));
slider_tolerance = new Slider(0, 255, get_config_int("MaskColor", "Tolerance", 0));
check_preview = new CheckBox("&Preview");
button_ok = new Button("&OK");
button_cancel = new Button("&Cancel");
@ -102,8 +99,8 @@ void dialogs_mask_color(Sprite* sprite)
button_cancel->Click.connect(Bind<void>(&Frame::closeWindow, window.get(), button_cancel));
HOOK(button_color, SIGNAL_COLORBUTTON_CHANGE, color_change_hook, sprite);
HOOK(slider_tolerance, JI_SIGNAL_SLIDER_CHANGE, slider_change_hook, sprite);
check_preview->Click.connect(Bind<void>(&preview_change_hook, sprite));
slider_tolerance->Change.connect(Bind<void>(&mask_preview, sprite));
check_preview->Click.connect(Bind<void>(&mask_preview, sprite));
jwidget_magnetic(button_ok, true);
jwidget_expansive(button_color, true);
@ -144,8 +141,7 @@ void dialogs_mask_color(Sprite* sprite)
mask_free(mask);
set_config_color("MaskColor", "Color", button_color->getColor());
set_config_int("MaskColor", "Tolerance",
jslider_get_value(slider_tolerance));
set_config_int("MaskColor", "Tolerance", slider_tolerance->getValue());
set_config_bool("MaskColor", "Preview", check_preview->isSelected());
}
@ -175,17 +171,6 @@ static bool color_change_hook(JWidget widget, void *data)
return false;
}
static bool slider_change_hook(JWidget widget, void *data)
{
mask_preview((Sprite*)data);
return false;
}
static void preview_change_hook(Sprite* sprite)
{
mask_preview(sprite);
}
static Mask *gen_mask(const Sprite* sprite)
{
int xpos, ypos, color, tolerance;
@ -193,7 +178,7 @@ static Mask *gen_mask(const Sprite* sprite)
const Image* image = sprite->getCurrentImage(&xpos, &ypos, NULL);
color = color_utils::color_for_image(button_color->getColor(), sprite->getImgType());
tolerance = jslider_get_value(slider_tolerance);
tolerance = slider_tolerance->getValue();
Mask* mask = mask_new();
mask_by_color(mask, image, color, tolerance);

7
src/file/jpeg_format.cpp
View File

@ -360,17 +360,18 @@ static FormatOptions *get_options_JPEG(FileOp *fop)
/* widgets */
FramePtr window(load_widget("jpeg_options.xml", "jpeg_options"));
JWidget slider_quality, ok;
Slider* slider_quality;
Widget* ok;
get_widgets(window,
"quality", &slider_quality,
"ok", &ok, NULL);
jslider_set_value(slider_quality, jpeg_options->quality * 10.0f);
slider_quality->setValue(jpeg_options->quality * 10.0f);
window->open_window_fg();
if (window->get_killer() == ok) {
jpeg_options->quality = jslider_get_value(slider_quality) / 10.0f;
jpeg_options->quality = slider_quality->getValue() / 10.0f;
set_config_float("JPEG", "Quality", jpeg_options->quality);
}
else {

1
src/gui/jbase.h
View File

@ -183,7 +183,6 @@ enum {
JI_SIGNAL_MANAGER_REMOVE_WINDOW,
JI_SIGNAL_MANAGER_LOSTCHAR,
JI_SIGNAL_MENUITEM_SELECT,
JI_SIGNAL_SLIDER_CHANGE,
JI_SIGNAL_WINDOW_RESIZE,
};

3
src/gui/jtheme.h
View File

@ -12,6 +12,7 @@
struct FONT;
struct BITMAP;
class ButtonBase;
class Slider;
class jtheme
{
@ -56,7 +57,7 @@ public:
virtual void draw_panel(JWidget widget, JRect clip) = 0;
virtual void draw_radio(ButtonBase* widget, JRect clip) = 0;
virtual void draw_separator(JWidget widget, JRect clip) = 0;
virtual void draw_slider(JWidget widget, JRect clip) = 0;
virtual void draw_slider(Slider* widget, JRect clip) = 0;
virtual void draw_combobox_entry(JWidget widget, JRect clip) = 0;
virtual void draw_combobox_button(ButtonBase* widget, JRect clip) = 0;
virtual void draw_textbox(JWidget widget, JRect clip) = 0;

201
src/gui/slider.cpp
View File

@ -14,128 +14,97 @@
#include "gui/jrect.h"
#include "gui/jsystem.h"
#include "gui/jtheme.h"
#include "gui/preferred_size_event.h"
#include "gui/slider.h"
#include "gui/widget.h"
typedef struct Slider
{
int min;
int max;
int value;
} Slider;
static int slider_press_x;
static int slider_press_value;
static int slider_press_left;
static bool slider_msg_proc(JWidget widget, JMessage msg);
static void slider_request_size(JWidget widget, int *w, int *h);
static void slider_setcursor(JWidget widget);
JWidget jslider_new(int min, int max, int value)
Slider::Slider(int min, int max, int value)
: Widget(JI_SLIDER)
{
Widget* widget = new Widget(JI_SLIDER);
Slider* slider = jnew(Slider, 1);
m_min = min;
m_max = max;
m_value = MID(min, value, max);
slider->min = min;
slider->max = max;
slider->value = MID(min, value, max);
jwidget_add_hook(widget, JI_SLIDER, slider_msg_proc, slider);
jwidget_focusrest(widget, true);
jwidget_init_theme(widget);
return widget;
jwidget_focusrest(this, true);
jwidget_init_theme(this);
}
void jslider_set_range(JWidget widget, int min, int max)
void Slider::setRange(int min, int max)
{
Slider* slider = reinterpret_cast<Slider*>(jwidget_get_data(widget, JI_SLIDER));
m_min = min;
m_max = max;
m_value = MID(min, m_value, max);
slider->min = min;
slider->max = max;
slider->value = MID(min, slider->value, max);
jwidget_dirty(widget);
dirty();
}
void jslider_set_value(JWidget widget, int value)
void Slider::setValue(int value)
{
Slider* slider = reinterpret_cast<Slider*>(jwidget_get_data(widget, JI_SLIDER));
int old_value = slider->value;
int old_value = m_value;
slider->value = MID(slider->min, value, slider->max);
m_value = MID(m_min, value, m_max);
if (slider->value != old_value)
jwidget_dirty(widget);
if (m_value != old_value)
dirty();
/* it DOES NOT emit CHANGE signal! to avoid recursive calls */
// It DOES NOT emit CHANGE signal! to avoid recursive calls.
}
int jslider_get_value(JWidget widget)
int Slider::getValue() const
{
Slider* slider = reinterpret_cast<Slider*>(jwidget_get_data(widget, JI_SLIDER));
return slider->value;
return m_value;
}
void jtheme_slider_info(JWidget widget, int *min, int *max, int *value)
void Slider::getSliderThemeInfo(int* min, int* max, int* value)
{
Slider* slider = reinterpret_cast<Slider*>(jwidget_get_data(widget, JI_SLIDER));
if (min) *min = slider->min;
if (max) *max = slider->max;
if (value) *value = slider->value;
if (min) *min = m_min;
if (max) *max = m_max;
if (value) *value = m_value;
}
static bool slider_msg_proc(JWidget widget, JMessage msg)
bool Slider::onProcessMessage(JMessage msg)
{
Slider* slider = reinterpret_cast<Slider*>(jwidget_get_data(widget, JI_SLIDER));
switch (msg->type) {
case JM_DESTROY:
jfree(slider);
break;
case JM_REQSIZE:
slider_request_size(widget, &msg->reqsize.w, &msg->reqsize.h);
return true;
case JM_DRAW:
widget->theme->draw_slider(widget, &msg->draw.rect);
this->theme->draw_slider(this, &msg->draw.rect);
return true;
case JM_FOCUSENTER:
case JM_FOCUSLEAVE:
if (widget->isEnabled())
jwidget_dirty(widget);
if (isEnabled())
dirty();
break;
case JM_BUTTONPRESSED:
if (!widget->isEnabled())
if (!isEnabled())
return true;
widget->setSelected(true);
widget->captureMouse();
setSelected(true);
captureMouse();
slider_press_x = msg->mouse.x;
slider_press_value = slider->value;
slider_press_value = m_value;
slider_press_left = msg->mouse.left;
slider_setcursor(widget);
slider_setcursor();
/* continue to JM_MOTION */
case JM_MOTION:
if (widget->hasCapture()) {
if (hasCapture()) {
int value, accuracy, range;
JRect rc = jwidget_get_child_rect(widget);
JRect rc = jwidget_get_child_rect(this);
range = slider->max - slider->min + 1;
range = m_max - m_min + 1;
/* with left click */
if (slider_press_left) {
value = slider->min + range * (msg->mouse.x - rc->x1) / jrect_w(rc);
value = m_min + range * (msg->mouse.x - rc->x1) / jrect_w(rc);
}
/* with right click */
else {
@ -145,11 +114,11 @@ static bool slider_msg_proc(JWidget widget, JMessage msg)
(msg->mouse.x - slider_press_x) / accuracy;
}
value = MID(slider->min, value, slider->max);
value = MID(m_min, value, m_max);
if (slider->value != value) {
jslider_set_value(widget, value);
jwidget_emit_signal(widget, JI_SIGNAL_SLIDER_CHANGE);
if (m_value != value) {
this->setValue(value);
onChange();
}
/* for left click */
@ -167,7 +136,7 @@ static bool slider_msg_proc(JWidget widget, JMessage msg)
/* for right click */
else if (jmouse_control_infinite_scroll(rc)) {
slider_press_x = jmouse_x(0);
slider_press_value = slider->value;
slider_press_value = m_value;
}
jrect_free(rc);
@ -176,10 +145,10 @@ static bool slider_msg_proc(JWidget widget, JMessage msg)
break;
case JM_BUTTONRELEASED:
if (widget->hasCapture()) {
widget->setSelected(false);
widget->releaseMouse();
slider_setcursor(widget);
if (hasCapture()) {
setSelected(false);
releaseMouse();
slider_setcursor();
}
break;
@ -197,15 +166,15 @@ static bool slider_msg_proc(JWidget widget, JMessage msg)
/* } */
/* TODO theme stuff */
if (widget->isEnabled())
jwidget_dirty(widget);
if (isEnabled())
dirty();
break;
case JM_KEYPRESSED:
if (widget->hasFocus()) {
int min = slider->min;
int max = slider->max;
int value = slider->value;
if (hasFocus()) {
int min = m_min;
int max = m_max;
int value = m_value;
switch (msg->key.scancode) {
case KEY_LEFT: value = MAX(value-1, min); break;
@ -215,12 +184,12 @@ static bool slider_msg_proc(JWidget widget, JMessage msg)
case KEY_HOME: value = min; break;
case KEY_END: value = max; break;
default:
return false;
goto not_used;
}
if (slider->value != value) {
jslider_set_value(widget, value);
jwidget_emit_signal(widget, JI_SIGNAL_SLIDER_CHANGE);
if (m_value != value) {
this->setValue(value);
onChange();
}
return true;
@ -228,49 +197,61 @@ static bool slider_msg_proc(JWidget widget, JMessage msg)
break;
case JM_WHEEL:
if (widget->isEnabled()) {
int value = slider->value + jmouse_z(0) - jmouse_z(1);
if (isEnabled()) {
int value = m_value + jmouse_z(0) - jmouse_z(1);
value = MID(slider->min, value, slider->max);
value = MID(m_min, value, m_max);
if (slider->value != value) {
jslider_set_value(widget, value);
jwidget_emit_signal(widget, JI_SIGNAL_SLIDER_CHANGE);
if (m_value != value) {
this->setValue(value);
onChange();
}
return true;
}
break;
case JM_SETCURSOR:
slider_setcursor(widget);
slider_setcursor();
return true;
}
return false;
not_used:;
return Widget::onProcessMessage(msg);
}
static void slider_request_size(JWidget widget, int *w, int *h)
void Slider::onPreferredSize(PreferredSizeEvent& ev)
{
Slider* slider = reinterpret_cast<Slider*>(jwidget_get_data(widget, JI_SLIDER));
int min_w, max_w;
int w, h, min_w, max_w;
char buf[256];
usprintf(buf, "%d", slider->min);
min_w = ji_font_text_len(widget->getFont(), buf);
usprintf(buf, "%d", m_min);
min_w = ji_font_text_len(this->getFont(), buf);
usprintf(buf, "%d", slider->max);
max_w = ji_font_text_len(widget->getFont(), buf);
usprintf(buf, "%d", m_max);
max_w = ji_font_text_len(this->getFont(), buf);
*w = MAX(min_w, max_w);
*h = text_height(widget->getFont());
w = MAX(min_w, max_w);
h = text_height(this->getFont());
*w += widget->border_width.l + widget->border_width.r;
*h += widget->border_width.t + widget->border_width.b;
w += this->border_width.l + this->border_width.r;
h += this->border_width.t + this->border_width.b;
ev.setPreferredSize(w, h);
}
static void slider_setcursor(JWidget widget)
void Slider::onChange()
{
if (widget->hasCapture()) {
Change(); // Emit Change signal
}
void Slider::onButtonReleased()
{
ButtonReleased();
}
void Slider::slider_setcursor()
{
if (hasCapture()) {
if (slider_press_left)
jmouse_set_cursor(JI_CURSOR_NORMAL);
else

38
src/gui/slider.h
View File

@ -7,16 +7,40 @@
#ifndef GUI_SLIDER_H_INCLUDED
#define GUI_SLIDER_H_INCLUDED
#include "gui/jbase.h"
#include "base/signal.h"
#include "gui/widget.h"
JWidget jslider_new(int min, int max, int value);
class Slider : public Widget
{
public:
Slider(int min, int max, int value);
void jslider_set_range(JWidget slider, int min, int max);
void setRange(int min, int max);
void jslider_set_value(JWidget slider, int value);
int jslider_get_value(JWidget slider);
void setValue(int value);
int getValue() const;
/* for themes */
void jtheme_slider_info(JWidget slider, int *min, int *max, int *value);
void getSliderThemeInfo(int* min, int* max, int* value);
// Signals
Signal0<void> Change;
Signal0<void> ButtonReleased;
protected:
// Events
bool onProcessMessage(JMessage msg);
void onPreferredSize(PreferredSizeEvent& ev);
// New events
virtual void onChange();
virtual void onButtonReleased();
private:
void slider_setcursor();
int m_min;
int m_max;
int m_value;
};
#endif

6
src/gui/themes/jstandard_theme.cpp
View File

@ -100,7 +100,7 @@ public:
void draw_panel(JWidget widget, JRect clip);
void draw_radio(ButtonBase* widget, JRect clip);
void draw_separator(JWidget widget, JRect clip);
void draw_slider(JWidget widget, JRect clip);
void draw_slider(Slider* widget, JRect clip);
void draw_combobox_entry(JWidget widget, JRect clip);
void draw_combobox_button(ButtonBase* widget, JRect clip);
void draw_textbox(JWidget widget, JRect clip);
@ -1015,13 +1015,13 @@ static bool my_add_clip_rect(BITMAP *bitmap, int x1, int y1, int x2, int y2)
return true;
}
void jstandard_theme::draw_slider(JWidget widget, JRect clip)
void jstandard_theme::draw_slider(Slider* widget, JRect clip)
{
int x, x1, y1, x2, y2, bg, c1, c2;
int min, max, value;
char buf[256];
jtheme_slider_info(widget, &min, &max, &value);
widget->getSliderThemeInfo(&min, &max, &value);
/* main pos */
x1 = widget->rc->x1;

4
src/modules/skinneable_theme.cpp
View File

@ -1107,13 +1107,13 @@ static bool my_add_clip_rect(BITMAP *bitmap, int x1, int y1, int x2, int y2)
return true;
}
void SkinneableTheme::draw_slider(JWidget widget, JRect clip)
void SkinneableTheme::draw_slider(Slider* widget, JRect clip)
{
int x, x1, y1, x2, y2;
int min, max, value;
char buf[256];
jtheme_slider_info(widget, &min, &max, &value);
widget->getSliderThemeInfo(&min, &max, &value);
// Tool buttons are smaller
bool isMiniLook = false;

2
src/modules/skinneable_theme.h
View File

@ -461,7 +461,7 @@ public:
void draw_panel(JWidget widget, JRect clip);
void draw_radio(ButtonBase* widget, JRect clip);
void draw_separator(JWidget widget, JRect clip);
void draw_slider(JWidget widget, JRect clip);
void draw_slider(Slider* widget, JRect clip);
void draw_combobox_entry(JWidget widget, JRect clip);
void draw_combobox_button(ButtonBase* widget, JRect clip);
void draw_textbox(JWidget widget, JRect clip);

89
src/widgets/color_selector.cpp
View File

@ -70,7 +70,7 @@ static void colorselector_set_paledit_index(JWidget widget, int index,
bool select_index_entry);
static bool select_model_hook(Frame* frame, Model* selected_model);
static bool slider_change_hook(JWidget widget, void* data);
static void slider_change_hook(Slider* widget);
static bool paledit_change_hook(JWidget widget, void* data);
static Model models[] = {
@ -167,9 +167,9 @@ static Widget* create_rgb_container()
Label* rlabel = new Label("R");
Label* glabel = new Label("G");
Label* blabel = new Label("B");
Widget* rslider = jslider_new(0, 255, 0);
Widget* gslider = jslider_new(0, 255, 0);
Widget* bslider = jslider_new(0, 255, 0);
Slider* rslider = new Slider(0, 255, 0);
Slider* gslider = new Slider(0, 255, 0);
Slider* bslider = new Slider(0, 255, 0);
jgrid_add_child(grid, rlabel, 1, 1, JI_RIGHT);
jgrid_add_child(grid, rslider, 1, 1, JI_HORIZONTAL);
jgrid_add_child(grid, glabel, 1, 1, JI_RIGHT);
@ -181,9 +181,9 @@ static Widget* create_rgb_container()
gslider->setName("rgb_g");
bslider->setName("rgb_b");
HOOK(rslider, JI_SIGNAL_SLIDER_CHANGE, slider_change_hook, 0);
HOOK(gslider, JI_SIGNAL_SLIDER_CHANGE, slider_change_hook, 0);
HOOK(bslider, JI_SIGNAL_SLIDER_CHANGE, slider_change_hook, 0);
rslider->Change.connect(Bind<void>(&slider_change_hook, rslider));
gslider->Change.connect(Bind<void>(&slider_change_hook, gslider));
bslider->Change.connect(Bind<void>(&slider_change_hook, bslider));
return grid;
}
@ -194,9 +194,9 @@ static Widget* create_hsv_container()
Label* hlabel = new Label("H");
Label* slabel = new Label("S");
Label* vlabel = new Label("V");
Widget* hslider = jslider_new(0, 255, 0);
Widget* sslider = jslider_new(0, 255, 0);
Widget* vslider = jslider_new(0, 255, 0);
Slider* hslider = new Slider(0, 255, 0);
Slider* sslider = new Slider(0, 255, 0);
Slider* vslider = new Slider(0, 255, 0);
jgrid_add_child(grid, hlabel, 1, 1, JI_RIGHT);
jgrid_add_child(grid, hslider, 1, 1, JI_HORIZONTAL);
jgrid_add_child(grid, slabel, 1, 1, JI_RIGHT);
@ -208,9 +208,9 @@ static Widget* create_hsv_container()
sslider->setName("hsv_s");
vslider->setName("hsv_v");
HOOK(hslider, JI_SIGNAL_SLIDER_CHANGE, slider_change_hook, 0);
HOOK(sslider, JI_SIGNAL_SLIDER_CHANGE, slider_change_hook, 0);
HOOK(vslider, JI_SIGNAL_SLIDER_CHANGE, slider_change_hook, 0);
hslider->Change.connect(Bind<void>(&slider_change_hook, hslider));
sslider->Change.connect(Bind<void>(&slider_change_hook, sslider));
vslider->Change.connect(Bind<void>(&slider_change_hook, vslider));
return grid;
}
@ -219,13 +219,13 @@ static Widget* create_gray_container()
{
Widget* grid = jgrid_new(2, false);
Label* klabel = new Label("V");
Widget* vslider = jslider_new(0, 255, 0);
Slider* vslider = new Slider(0, 255, 0);
jgrid_add_child(grid, klabel, 1, 1, JI_RIGHT);
jgrid_add_child(grid, vslider, 1, 1, JI_HORIZONTAL);
vslider->setName("gray_v");
HOOK(vslider, JI_SIGNAL_SLIDER_CHANGE, slider_change_hook, 0);
vslider->Change.connect(Bind<void>(&slider_change_hook, vslider));
return grid;
}
@ -284,28 +284,28 @@ static void colorselector_set_color2(JWidget widget, const Color& color,
{
ColorSelector* colorselector = colorselector_data(widget);
Model* m = colorselector->selected_model;
JWidget rgb_rslider = jwidget_find_name(widget, "rgb_r");
JWidget rgb_gslider = jwidget_find_name(widget, "rgb_g");
JWidget rgb_bslider = jwidget_find_name(widget, "rgb_b");
JWidget hsv_hslider = jwidget_find_name(widget, "hsv_h");
JWidget hsv_sslider = jwidget_find_name(widget, "hsv_s");
JWidget hsv_vslider = jwidget_find_name(widget, "hsv_v");
JWidget gray_vslider = jwidget_find_name(widget, "gray_v");
Slider* rgb_rslider = widget->findChildT<Slider>("rgb_r");
Slider* rgb_gslider = widget->findChildT<Slider>("rgb_g");
Slider* rgb_bslider = widget->findChildT<Slider>("rgb_b");
Slider* hsv_hslider = widget->findChildT<Slider>("hsv_h");
Slider* hsv_sslider = widget->findChildT<Slider>("hsv_s");
Slider* hsv_vslider = widget->findChildT<Slider>("hsv_v");
Slider* gray_vslider = widget->findChildT<Slider>("gray_v");
colorselector->color = color;
if (exclude_this_model != models+MODEL_RGB) {
jslider_set_value(rgb_rslider, color.getRed());
jslider_set_value(rgb_gslider, color.getGreen());
jslider_set_value(rgb_bslider, color.getBlue());
rgb_rslider->setValue(color.getRed());
rgb_gslider->setValue(color.getGreen());
rgb_bslider->setValue(color.getBlue());
}
if (exclude_this_model != models+MODEL_HSV) {
jslider_set_value(hsv_hslider, color.getHue());
jslider_set_value(hsv_sslider, color.getSaturation());
jslider_set_value(hsv_vslider, color.getValue());
hsv_hslider->setValue(color.getHue());
hsv_sslider->setValue(color.getSaturation());
hsv_vslider->setValue(color.getValue());
}
if (exclude_this_model != models+MODEL_GRAY) {
jslider_set_value(gray_vslider, color.getValue());
gray_vslider->setValue(color.getValue());
}
switch (color.getType()) {
@ -424,7 +424,7 @@ static bool select_model_hook(Frame* frame, Model* selected_model)
return true;
}
static bool slider_change_hook(JWidget widget, void* data)
static void slider_change_hook(Slider* widget)
{
Frame* window = static_cast<Frame*>(widget->getRoot());
ColorSelector* colorselector = colorselector_data(window);
@ -434,28 +434,28 @@ static bool slider_change_hook(JWidget widget, void* data)
switch (m->model) {
case MODEL_RGB: {
JWidget rslider = jwidget_find_name(window, "rgb_r");
JWidget gslider = jwidget_find_name(window, "rgb_g");
JWidget bslider = jwidget_find_name(window, "rgb_b");
int r = jslider_get_value(rslider);
int g = jslider_get_value(gslider);
int b = jslider_get_value(bslider);
Slider* rslider = window->findChildT<Slider>("rgb_r");
Slider* gslider = window->findChildT<Slider>("rgb_g");
Slider* bslider = window->findChildT<Slider>("rgb_b");
int r = rslider->getValue();
int g = gslider->getValue();
int b = bslider->getValue();
color = Color::fromRgb(r, g, b);
break;
}
case MODEL_HSV: {
JWidget hslider = jwidget_find_name(window, "hsv_h");
JWidget sslider = jwidget_find_name(window, "hsv_s");
JWidget vslider = jwidget_find_name(window, "hsv_v");
int h = jslider_get_value(hslider);
int s = jslider_get_value(sslider);
int v = jslider_get_value(vslider);
Slider* hslider = window->findChildT<Slider>("hsv_h");
Slider* sslider = window->findChildT<Slider>("hsv_s");
Slider* vslider = window->findChildT<Slider>("hsv_v");
int h = hslider->getValue();
int s = sslider->getValue();
int v = vslider->getValue();
color = Color::fromHsv(h, s, v);
break;
}
case MODEL_GRAY: {
JWidget vslider = jwidget_find_name(window, "gray_v");
int v = jslider_get_value(vslider);
Slider* vslider = window->findChildT<Slider>("gray_v");
int v = vslider->getValue();
color = Color::fromGray(v);
break;
}
@ -472,7 +472,6 @@ static bool slider_change_hook(JWidget widget, void* data)
colorselector_set_color2(window, color, false, false, m);
jwidget_emit_signal(window, SIGNAL_COLORSELECTOR_COLOR_CHANGED);
return 0;
}
static bool paledit_change_hook(Widget* widget, void* data)

15
src/widgets/statebar.cpp
View File

@ -60,7 +60,7 @@ enum AniAction {
static bool tipwindow_msg_proc(JWidget widget, JMessage msg);
static bool transparent_color_change_hook(JWidget widget, void *data);
static bool slider_change_hook(JWidget widget, void *data);
static void slider_change_hook(Slider* slider);
static void ani_button_command(Button* widget, AniAction action);
static int statusbar_type()
@ -107,7 +107,7 @@ StatusBar::StatusBar()
Widget* box1 = jbox_new(JI_HORIZONTAL);
Widget* box2 = jbox_new(JI_HORIZONTAL | JI_HOMOGENEOUS);
Widget* box3 = jbox_new(JI_HORIZONTAL);
m_slider = jslider_new(0, 255, 255);
m_slider = new Slider(0, 255, 255);
setup_mini_look(m_slider);
@ -117,7 +117,7 @@ StatusBar::StatusBar()
ICON_NEW(m_b_next, GFX_ANI_NEXT, ACTION_NEXT);
ICON_NEW(m_b_last, GFX_ANI_LAST, ACTION_LAST);
HOOK(m_slider, JI_SIGNAL_SLIDER_CHANGE, slider_change_hook, 0);
m_slider->Change.connect(Bind<void>(&slider_change_hook, m_slider));
jwidget_set_min_size(m_slider, JI_SCREEN_W/5, 0);
jwidget_set_border(box1, 2*jguiscale(), 1*jguiscale(), 2*jguiscale(), 2*jguiscale());
@ -742,7 +742,7 @@ static bool transparent_color_change_hook(JWidget widget, void *data)
return true;
}
static bool slider_change_hook(JWidget widget, void *data)
static void slider_change_hook(Slider* slider)
{
try {
CurrentSpriteWriter sprite(UIContext::instance());
@ -752,7 +752,7 @@ static bool slider_change_hook(JWidget widget, void *data)
Cel* cel = ((LayerImage*)sprite->getCurrentLayer())->getCel(sprite->getCurrentFrame());
if (cel) {
// Update the opacity
cel->opacity = jslider_get_value(widget);
cel->opacity = slider->getValue();
// Update the editors
update_screen_for_sprite(sprite);
@ -763,7 +763,6 @@ static bool slider_change_hook(JWidget widget, void *data)
catch (LockedSpriteException&) {
// do nothing
}
return false;
}
static void ani_button_command(Button* widget, AniAction action)
@ -795,11 +794,11 @@ void StatusBar::updateFromLayer()
sprite->getCurrentLayer()->is_image() &&
!sprite->getCurrentLayer()->is_background() &&
(cel = ((LayerImage*)sprite->getCurrentLayer())->getCel(sprite->getCurrentFrame()))) {
jslider_set_value(m_slider, MID(0, cel->opacity, 255));
m_slider->setValue(MID(0, cel->opacity, 255));
m_slider->setEnabled(true);
}
else {
jslider_set_value(m_slider, 255);
m_slider->setValue(255);
m_slider->setEnabled(false);
}
}

9
src/widgets/statebar.h
View File

@ -23,11 +23,12 @@
#include "gui/jbase.h"
#include "gui/widget.h"
class Frame;
class StatusBar;
class Tool;
class Button;
class ColorButton;
class Frame;
class Slider;
class StatusBar;
class Tool;
class Progress
{
@ -91,7 +92,7 @@ private:
// Box of main commands
Widget* m_commandsBox;
Widget* m_slider; // Opacity slider
Slider* m_slider; // Opacity slider
Button* m_b_first; // Go to first frame
Button* m_b_prev; // Go to previous frame
Button* m_b_play; // Play animation

2
src/xml_widgets.cpp
View File

@ -282,7 +282,7 @@ static Widget* convert_xmlelement_to_widget(TiXmlElement* elem, Widget* root)
int min_value = min != NULL ? ustrtol(min, NULL, 10): 0;
int max_value = max != NULL ? ustrtol(max, NULL, 10): 0;
widget = jslider_new(min_value, max_value, min_value);
widget = new Slider(min_value, max_value, min_value);
}
/* textbox */
else if (ustrcmp(elem_name, "textbox") == 0) {