#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include "ui/widget/spinbutton.h"

#include "toolbox.h"

#include "rect-toolbar.h"

#include "../desktop.h"

#include "../desktop-handles.h"

#include "document-undo.h"

#include "../verbs.h"

#include "../inkscape.h"

#include "../selection-chemistry.h"

#include "../selection.h"

#include "../ege-adjustment-action.h"

#include "../ege-output-action.h"

#include "../ege-select-one-action.h"

#include "../ink-action.h"

#include "../ink-comboboxentry-action.h"

#include "../widgets/button.h"

#include "../widgets/spinbutton-events.h"

#include "../widgets/spw-utilities.h"

#include "../widgets/widget-sizes.h"

#include "../xml/node-event-vector.h"

#include "../xml/repr.h"

#include "ui/uxmanager.h"

#include "../ui/icon-names.h"

#include "../helper/unit-menu.h"

#include "../helper/units.h"

#include "../helper/unit-tracker.h"

#include "../pen-context.h"

#include "../sp-namedview.h"

#include "../sp-rect.h"

using Inkscape::UnitTracker;

using Inkscape::UI::UXManager;

using Inkscape::DocumentUndo;

using Inkscape::UI::ToolboxFactory;

using Inkscape::UI::PrefPusher;

static void sp_rtb_sensitivize( GObject *tbl )

{

GtkAdjustment *adj1 = GTK_ADJUSTMENT( g_object_get_data(tbl, "rx") );

GtkAdjustment *adj2 = GTK_ADJUSTMENT( g_object_get_data(tbl, "ry") );

GtkAction* not_rounded = GTK_ACTION( g_object_get_data(tbl, "not_rounded") );

if (gtk_adjustment_get_value(adj1) == 0 && gtk_adjustment_get_value(adj2) == 0 && g_object_get_data(tbl, "single")) { // only for a single selected rect (for now)

gtk_action_set_sensitive( not_rounded, FALSE );

} else {

gtk_action_set_sensitive( not_rounded, TRUE );

}

}

static void sp_rtb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name,

void (*setter)(SPRect *, gdouble))

{

SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );

UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));

SPUnit const *unit = tracker->getActiveUnit();

if (DocumentUndo::getUndoSensitive(sp_desktop_document(desktop))) {

Inkscape::Preferences *prefs = Inkscape::Preferences::get();

prefs->setDouble(Glib::ustring("/tools/shapes/rect/") + value_name,

sp_units_get_pixels(gtk_adjustment_get_value(adj), *unit));

}

// quit if run by the attr_changed listener

if (g_object_get_data( tbl, "freeze" )) {

return;

}

// in turn, prevent listener from responding

g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));

bool modmade = false;

Inkscape::Selection *selection = sp_desktop_selection(desktop);

for (GSList const *items = selection->itemList(); items != NULL; items = items->next) {

if (SP_IS_RECT(items->data)) {

if (gtk_adjustment_get_value(adj) != 0) {

setter(SP_RECT(items->data),

sp_units_get_pixels(gtk_adjustment_get_value(adj), *unit));

} else {

SP_OBJECT(items->data)->getRepr()->setAttribute(value_name, NULL);

}

modmade = true;

}

}

sp_rtb_sensitivize( tbl );

if (modmade) {

DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_CONTEXT_RECT,

_("Change rectangle"));

}

g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );

}

static void sp_rtb_rx_value_changed(GtkAdjustment *adj, GObject *tbl)

{

sp_rtb_value_changed(adj, tbl, "rx", sp_rect_set_visible_rx);

}

static void sp_rtb_ry_value_changed(GtkAdjustment *adj, GObject *tbl)

{

sp_rtb_value_changed(adj, tbl, "ry", sp_rect_set_visible_ry);

}

static void sp_rtb_width_value_changed(GtkAdjustment *adj, GObject *tbl)

{

sp_rtb_value_changed(adj, tbl, "width", sp_rect_set_visible_width);

}

static void sp_rtb_height_value_changed(GtkAdjustment *adj, GObject *tbl)

{

sp_rtb_value_changed(adj, tbl, "height", sp_rect_set_visible_height);

}

static void sp_rtb_defaults( GtkWidget * /*widget*/, GObject *obj)

{

GtkAdjustment *adj = 0;

adj = GTK_ADJUSTMENT( g_object_get_data(obj, "rx") );

gtk_adjustment_set_value(adj, 0.0);

// this is necessary if the previous value was 0, but we still need to run the callback to change all selected objects

gtk_adjustment_value_changed(adj);

adj = GTK_ADJUSTMENT( g_object_get_data(obj, "ry") );

gtk_adjustment_set_value(adj, 0.0);

gtk_adjustment_value_changed(adj);

sp_rtb_sensitivize( obj );

}

static void rect_tb_event_attr_changed(Inkscape::XML::Node * /*repr*/, gchar const * /*name*/,

gchar const * /*old_value*/, gchar const * /*new_value*/,

bool /*is_interactive*/, gpointer data)

{

GObject *tbl = G_OBJECT(data);

// quit if run by the _changed callbacks

if (g_object_get_data( tbl, "freeze" )) {

return;

}

// in turn, prevent callbacks from responding

g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );

UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );

SPUnit const *unit = tracker->getActiveUnit();

gpointer item = g_object_get_data( tbl, "item" );

if (item && SP_IS_RECT(item)) {

{

GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "rx" ) );

gdouble rx = sp_rect_get_visible_rx(SP_RECT(item));

gtk_adjustment_set_value(adj, sp_pixels_get_units(rx, *unit));

}

{

GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "ry" ) );

gdouble ry = sp_rect_get_visible_ry(SP_RECT(item));

gtk_adjustment_set_value(adj, sp_pixels_get_units(ry, *unit));

}

{

GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "width" ) );

gdouble width = sp_rect_get_visible_width (SP_RECT(item));

gtk_adjustment_set_value(adj, sp_pixels_get_units(width, *unit));

}

{

GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "height" ) );

gdouble height = sp_rect_get_visible_height (SP_RECT(item));

gtk_adjustment_set_value(adj, sp_pixels_get_units(height, *unit));

}

}

sp_rtb_sensitivize( tbl );

g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );

}

static Inkscape::XML::NodeEventVector rect_tb_repr_events = {

NULL, /* child_added */

NULL, /* child_removed */

rect_tb_event_attr_changed,

NULL, /* content_changed */

NULL /* order_changed */

};

static void sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)

{

int n_selected = 0;

Inkscape::XML::Node *repr = NULL;

SPItem *item = NULL;

if ( g_object_get_data( tbl, "repr" ) ) {

g_object_set_data( tbl, "item", NULL );

}

purge_repr_listener( tbl, tbl );

for (GSList const *items = selection->itemList();

items != NULL;

items = items->next) {

if (SP_IS_RECT(reinterpret_cast<SPItem *>(items->data))) {

n_selected++;

item = reinterpret_cast<SPItem *>(items->data);

repr = item->getRepr();

}

}

EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );

g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) );

if (n_selected == 0) {

g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );

GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) );

gtk_action_set_sensitive(w, FALSE);

GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) );

gtk_action_set_sensitive(h, FALSE);

} else if (n_selected == 1) {

g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );

g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) );

GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) );

gtk_action_set_sensitive(w, TRUE);

GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) );

gtk_action_set_sensitive(h, TRUE);

if (repr) {

g_object_set_data( tbl, "repr", repr );

g_object_set_data( tbl, "item", item );

Inkscape::GC::anchor(repr);

sp_repr_add_listener(repr, &rect_tb_repr_events, tbl);

sp_repr_synthesize_events(repr, &rect_tb_repr_events, tbl);

}

} else {

// FIXME: implement averaging of all parameters for multiple selected

//gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));

g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );

sp_rtb_sensitivize( tbl );

}

}

void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)

{

EgeAdjustmentAction* eact = 0;

Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);

{

EgeOutputAction* act = ege_output_action_new( "RectStateAction", _("<b>New:</b>"), "", 0 );

ege_output_action_set_use_markup( act, TRUE );

gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );

g_object_set_data( holder, "mode_action", act );

}

// rx/ry units menu: create

UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE );

//tracker->addUnit( SP_UNIT_PERCENT, 0 );

// fixme: add % meaning per cent of the width/height

tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units );

g_object_set_data( holder, "tracker", tracker );

/* W */

{

gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};

eact = create_adjustment_action( "RectWidthAction",

_("Width"), _("W:"), _("Width of rectangle"),

"/tools/shapes/rect/width", 0,

GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-rect",

0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,

labels, values, G_N_ELEMENTS(labels),

sp_rtb_width_value_changed );

tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );

g_object_set_data( holder, "width_action", eact );

gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );

gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );

}

/* H */

{

gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};

eact = create_adjustment_action( "RectHeightAction",

_("Height"), _("H:"), _("Height of rectangle"),

"/tools/shapes/rect/height", 0,

GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,

0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,

labels, values, G_N_ELEMENTS(labels),

sp_rtb_height_value_changed );

tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );

g_object_set_data( holder, "height_action", eact );

gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );

gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );

}

/* rx */

{

gchar const* labels[] = {_("not rounded"), 0, 0, 0, 0, 0, 0, 0, 0};

gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};

eact = create_adjustment_action( "RadiusXAction",

_("Horizontal radius"), _("Rx:"), _("Horizontal radius of rounded corners"),

"/tools/shapes/rect/rx", 0,

GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,

0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,

labels, values, G_N_ELEMENTS(labels),

sp_rtb_rx_value_changed);

tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );

gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );

}

/* ry */

{

gchar const* labels[] = {_("not rounded"), 0, 0, 0, 0, 0, 0, 0, 0};

gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};

eact = create_adjustment_action( "RadiusYAction",

_("Vertical radius"), _("Ry:"), _("Vertical radius of rounded corners"),

"/tools/shapes/rect/ry", 0,

GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,

0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,

labels, values, G_N_ELEMENTS(labels),

sp_rtb_ry_value_changed);

tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );

gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );

}

// add the units menu

{

GtkAction* act = tracker->createAction( "RectUnitsAction", _("Units"), ("") );

gtk_action_group_add_action( mainActions, act );

}

/* Reset */

{

InkAction* inky = ink_action_new( "RectResetAction",

_("Not rounded"),

_("Make corners sharp"),

INKSCAPE_ICON("rectangle-make-corners-sharp"),

secondarySize );

g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_rtb_defaults), holder );

gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );

gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );

g_object_set_data( holder, "not_rounded", inky );

}

g_object_set_data( holder, "single", GINT_TO_POINTER(TRUE) );

sp_rtb_sensitivize( holder );

sigc::connection *connection = new sigc::connection(

sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_rect_toolbox_selection_changed), (GObject *)holder))

);

g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection );

g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );

}