AlderconeStudio/PIKApp
AlderconeStudio
/
PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity
PIKApp/plug-ins/common/tile-small.c

1199 lines
34 KiB
C
Raw Normal View History

Initial checkin of Pika from heckimp
2023-09-26 00:35:21 +02:00
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for PIKA.
*
* Tileit - This plugin take an image and makes repeated copies of it.
*
* Copyright (C) 1997 Andy Thomas alt@picnic.demon.co.uk
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* A fair proportion of this code was taken from the Whirl plug-in
* which was copyrighted by Federico Mena Quintero (as below).
*
* Whirl plug-in --- distort an image into a whirlpool
* Copyright (C) 1997 Federico Mena Quintero
*
*/
/* Change log:-
* 0.2 Added new functions to allow "editing" of the tile pattern.
*
* 0.1 First version released.
*/
#include "config.h"
#include <string.h>
#include <libpika/pika.h>
#include <libpika/pikaui.h>
#include "libpika/stdplugins-intl.h"
#define PLUG_IN_PROC "plug-in-small-tiles"
#define PLUG_IN_BINARY "tile-small"
#define PLUG_IN_ROLE "pika-tile-small"
/***** Magic numbers *****/
#define PREVIEW_SIZE 128
#define MAX_SEGS 6
#define PREVIEW_MASK GDK_EXPOSURE_MASK | \
GDK_BUTTON_PRESS_MASK | \
GDK_BUTTON_MOTION_MASK
/* Variables set in dialog box */
typedef struct data
{
gint numtiles;
} TileItVals;
typedef struct
{
GtkWidget *preview;
guchar preview_row[PREVIEW_SIZE * 4];
gint img_bpp;
guchar *pv_cache;
} TileItInterface;
static TileItInterface tint =
{
NULL, /* Preview */
{
'4',
'u'
}, /* Preview_row */
4, /* bpp of drawable */
NULL
};
typedef struct _Tile Tile;
typedef struct _TileClass TileClass;
struct _Tile
{
PikaPlugIn parent_instance;
};
struct _TileClass
{
PikaPlugInClass parent_class;
};
#define TILE_TYPE (tile_get_type ())
#define TILE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TILE_TYPE, Tile))
GType tile_get_type (void) G_GNUC_CONST;
static GList * tile_query_procedures (PikaPlugIn *plug_in);
static PikaProcedure * tile_create_procedure (PikaPlugIn *plug_in,
const gchar *name);
static PikaValueArray * tile_run (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
gpointer run_data);
static gboolean tileit_dialog (PikaDrawable *drawable);
static void tileit_scale_update (PikaLabelSpin *entry,
gint *value);
static void tileit_exp_update (GtkWidget *widget,
gpointer value);
static void tileit_exp_update_f (GtkWidget *widget,
gpointer value);
static void tileit_reset (GtkWidget *widget,
gpointer value);
static void tileit_radio_update (GtkWidget *widget,
gpointer data);
static void tileit_hvtoggle_update (GtkWidget *widget,
gpointer data);
static void do_tiles (PikaDrawable *drawable);
static gint tiles_xy (gint width,
gint height,
gint x,
gint y,
gint *nx,
gint *ny);
static void all_update (void);
static void alt_update (void);
static void explicit_update (gboolean);
static void dialog_update_preview (void);
static void cache_preview (PikaDrawable *drawable);
static gboolean tileit_preview_draw (GtkWidget *widget,
cairo_t *cr);
static gboolean tileit_preview_events (GtkWidget *widget,
GdkEvent *event);
G_DEFINE_TYPE (Tile, tile, PIKA_TYPE_PLUG_IN)
PIKA_MAIN (TILE_TYPE)
DEFINE_STD_SET_I18N
/* Values when first invoked */
static TileItVals itvals =
{
2
};
/* Structures for call backs... */
/* The "explicit tile" & family */
typedef enum
{
ALL,
ALT,
EXPLICIT
} AppliedTo;
typedef struct
{
AppliedTo type;
gint x; /* X - pos of tile */
gint y; /* Y - pos of tile */
GtkAdjustment *r_adj; /* row adjustment */
GtkAdjustment *c_adj; /* column adjustment */
GtkWidget *applybut; /* The apply button */
} Exp_Call;
static Exp_Call exp_call =
{
ALL,
-1,
-1,
NULL,
NULL,
NULL,
};
/* The reset button needs to know some toggle widgets.. */
typedef struct
{
GtkWidget *htoggle;
GtkWidget *vtoggle;
} Reset_Call;
static Reset_Call res_call =
{
NULL,
NULL,
};
/* 2D - Array that holds the actions for each tile */
/* Action type on cell */
#define HORIZONTAL 0x1
#define VERTICAL 0x2
static gint tileactions[MAX_SEGS][MAX_SEGS];
/* What actions buttons toggled */
static gint do_horz = FALSE;
static gint do_vert = FALSE;
static gint opacity = 100;
/* Stuff for the preview bit */
static gint sel_x1, sel_y1, sel_x2, sel_y2;
static gint sel_width, sel_height;
static gint preview_width, preview_height;
static gboolean has_alpha;
static void
tile_class_init (TileClass *klass)
{
PikaPlugInClass *plug_in_class = PIKA_PLUG_IN_CLASS (klass);
plug_in_class->query_procedures = tile_query_procedures;
plug_in_class->create_procedure = tile_create_procedure;
plug_in_class->set_i18n = STD_SET_I18N;
}
static void
tile_init (Tile *tile)
{
}
static GList *
tile_query_procedures (PikaPlugIn *plug_in)
{
return g_list_append (NULL, g_strdup (PLUG_IN_PROC));
}
static PikaProcedure *
tile_create_procedure (PikaPlugIn *plug_in,
const gchar *name)
{
PikaProcedure *procedure = NULL;
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = pika_image_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
tile_run, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB*, GRAY*");
pika_procedure_set_sensitivity_mask (procedure,
PIKA_PROCEDURE_SENSITIVE_DRAWABLE);
pika_procedure_set_menu_label (procedure, _("_Small Tiles..."));
pika_procedure_add_menu_path (procedure, "<Image>/Filters/Map");
pika_procedure_set_documentation (procedure,
_("Tile image into smaller "
"versions of the original"),
"More here later",
name);
pika_procedure_set_attribution (procedure,
"Andy Thomas",
"Andy Thomas",
"1997");
PIKA_PROC_ARG_INT (procedure, "num-tiles",
"Num tiles",
"Number of tiles to make",
2, MAX_SEGS, 2,
G_PARAM_READWRITE);
}
return procedure;
}
static PikaValueArray *
tile_run (PikaProcedure *procedure,
PikaRunMode run_mode,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
gpointer run_data)
{
PikaDrawable *drawable;
gint pwidth;
gint pheight;
gegl_init (NULL, NULL);
if (n_drawables != 1)
{
GError *error = NULL;
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
_("Procedure '%s' only works with one drawable."),
PLUG_IN_PROC);
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CALLING_ERROR,
error);
}
else
{
drawable = drawables[0];
}
has_alpha = pika_drawable_has_alpha (drawable);
if (! pika_drawable_mask_intersect (drawable,
&sel_x1, &sel_y1,
&sel_width, &sel_height))
{
g_message (_("Region selected for filter is empty."));
return pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
}
sel_x2 = sel_x1 + sel_width;
sel_y2 = sel_y1 + sel_height;
/* Calculate preview size */
if (sel_width > sel_height)
{
pwidth = MIN (sel_width, PREVIEW_SIZE);
pheight = sel_height * pwidth / sel_width;
}
else
{
pheight = MIN (sel_height, PREVIEW_SIZE);
pwidth = sel_width * pheight / sel_height;
}
preview_width = MAX (pwidth, 2); /* Min size is 2 */
preview_height = MAX (pheight, 2);
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
pika_get_data (PLUG_IN_PROC, &itvals);
if (! tileit_dialog (drawable))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
break;
case PIKA_RUN_NONINTERACTIVE:
itvals.numtiles = PIKA_VALUES_GET_INT (args, 0);
break;
case PIKA_RUN_WITH_LAST_VALS:
pika_get_data (PLUG_IN_PROC, &itvals);
break;
}
if (pika_drawable_is_rgb (drawable) ||
pika_drawable_is_gray (drawable))
{
pika_progress_init (_("Tiling"));
do_tiles (drawable);
if (run_mode != PIKA_RUN_NONINTERACTIVE)
pika_displays_flush ();
if (run_mode == PIKA_RUN_INTERACTIVE)
pika_set_data (PLUG_IN_PROC, &itvals, sizeof (TileItVals));
}
else
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_EXECUTION_ERROR,
NULL);
}
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
}
static GtkWidget *
spin_button_new (GtkAdjustment **adjustment, /* return value */
gdouble value,
gdouble lower,
gdouble upper,
gdouble step_increment,
gdouble page_increment,
gdouble page_size,
gdouble climb_rate,
guint digits)
{
GtkWidget *spinbutton;
*adjustment = gtk_adjustment_new (value, lower, upper,
step_increment, page_increment, 0);
spinbutton = pika_spin_button_new (*adjustment, climb_rate, digits);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
return spinbutton;
}
static gboolean
tileit_dialog (PikaDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *grid;
GtkWidget *button;
GtkWidget *label;
GtkWidget *spinbutton;
GtkAdjustment *adj;
GtkWidget *scale;
GtkWidget *toggle;
GSList *orientation_group = NULL;
gboolean run;
pika_ui_init (PLUG_IN_BINARY);
cache_preview (drawable); /* Get the preview image */
dlg = pika_dialog_new (_("Small Tiles"), PLUG_IN_ROLE,
NULL, 0,
pika_standard_help_func, PLUG_IN_PROC,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
pika_dialog_set_alternative_button_order (GTK_DIALOG (dlg),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
pika_window_set_transient (GTK_WINDOW (dlg));
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
tint.preview = pika_preview_area_new ();
g_object_set (tint.preview,
"check-size", pika_check_size (),
"check-type", pika_check_type (),
"check-custom-color1", pika_check_custom_color1 (),
"check-custom-color2", pika_check_custom_color2 (),
NULL);
gtk_widget_set_size_request (tint.preview, preview_width, preview_height);
gtk_widget_set_events (GTK_WIDGET (tint.preview), PREVIEW_MASK);
gtk_container_add (GTK_CONTAINER (frame), tint.preview);
gtk_widget_show (tint.preview);
g_signal_connect_after (tint.preview, "draw",
G_CALLBACK (tileit_preview_draw),
NULL);
g_signal_connect (tint.preview, "event",
G_CALLBACK (tileit_preview_events),
NULL);
/* Area for buttons etc */
frame = pika_frame_new (_("Flip"));
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
toggle = gtk_check_button_new_with_mnemonic (_("_Horizontal"));
gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (tileit_hvtoggle_update),
&do_horz);
res_call.htoggle = toggle;
toggle = gtk_check_button_new_with_mnemonic (_("_Vertical"));
gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (tileit_hvtoggle_update),
&do_vert);
res_call.vtoggle = toggle;
button = gtk_button_new_with_mnemonic (_("_Reset"));
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (tileit_reset),
&res_call);
/* Grid for the inner widgets..*/
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 0);
gtk_widget_show (grid);
toggle = gtk_radio_button_new_with_mnemonic (orientation_group,
_("A_ll tiles"));
orientation_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
gtk_grid_attach (GTK_GRID (grid), toggle, 0, 0, 4, 1);
gtk_widget_show (toggle);
g_object_set_data (G_OBJECT (toggle), "pika-item-data",
GINT_TO_POINTER (ALL));
g_signal_connect (toggle, "toggled",
G_CALLBACK (tileit_radio_update),
&exp_call.type);
toggle = gtk_radio_button_new_with_mnemonic (orientation_group,
_("Al_ternate tiles"));
orientation_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
gtk_grid_attach (GTK_GRID (grid), toggle, 0, 1, 4, 1);
gtk_widget_show (toggle);
g_object_set_data (G_OBJECT (toggle), "pika-item-data",
GINT_TO_POINTER (ALT));
g_signal_connect (toggle, "toggled",
G_CALLBACK (tileit_radio_update),
&exp_call.type);
toggle = gtk_radio_button_new_with_mnemonic (orientation_group,
_("_Explicit tile"));
orientation_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
gtk_grid_attach (GTK_GRID (grid), toggle, 0, 2, 1, 2);
gtk_widget_show (toggle);
label = gtk_label_new_with_mnemonic (_("Ro_w:"));
gtk_label_set_xalign (GTK_LABEL (label), 1.0);
gtk_grid_attach (GTK_GRID (grid), label, 1, 2, 1, 1);
gtk_widget_show (label);
g_object_bind_property (toggle, "active",
label, "sensitive",
G_BINDING_SYNC_CREATE);
spinbutton = spin_button_new (&adj, 2, 1, 6, 1, 1, 0, 1, 0);
gtk_widget_set_hexpand (spinbutton, TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_grid_attach (GTK_GRID (grid), spinbutton, 2, 2, 1, 1);
gtk_widget_show (spinbutton);
g_signal_connect (adj, "value-changed",
G_CALLBACK (tileit_exp_update_f),
&exp_call);
exp_call.r_adj = adj;
g_object_bind_property (toggle, "active",
spinbutton, "sensitive",
G_BINDING_SYNC_CREATE);
label = gtk_label_new_with_mnemonic (_("Col_umn:"));
gtk_label_set_xalign (GTK_LABEL (label), 1.0);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), label, 1, 3, 1, 1);
g_object_bind_property (toggle, "active",
label, "sensitive",
G_BINDING_SYNC_CREATE);
spinbutton = spin_button_new (&adj, 2, 1, 6, 1, 1, 0, 1, 0);
gtk_widget_set_hexpand (spinbutton, TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_grid_attach (GTK_GRID (grid), spinbutton, 2, 3, 1, 1);
gtk_widget_show (spinbutton);
g_signal_connect (adj, "value-changed",
G_CALLBACK (tileit_exp_update_f),
&exp_call);
exp_call.c_adj = adj;
g_object_bind_property (toggle, "active",
spinbutton, "sensitive",
G_BINDING_SYNC_CREATE);
g_object_set_data (G_OBJECT (toggle), "pika-item-data",
GINT_TO_POINTER (EXPLICIT));
g_signal_connect (toggle, "toggled",
G_CALLBACK (tileit_radio_update),
&exp_call.type);
button = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_grid_attach (GTK_GRID (grid), button, 3, 2, 1, 2);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (tileit_exp_update),
&exp_call);
exp_call.applybut = button;
g_object_bind_property (toggle, "active",
spinbutton, "sensitive",
G_BINDING_SYNC_CREATE);
/* Widget for selecting the Opacity */
scale = pika_scale_entry_new (_("O_pacity:"), opacity, 0, 100, 0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (tileit_scale_update),
&opacity);
gtk_widget_show (scale);
gtk_widget_set_sensitive (scale, pika_drawable_has_alpha (drawable));
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 6);
/* Lower frame saying how many segments */
frame = pika_frame_new (_("Number of Segments"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
scale = pika_scale_entry_new ("_n²", itvals.numtiles, 2, MAX_SEGS, 0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (tileit_scale_update),
&itvals.numtiles);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_widget_show (scale);
gtk_widget_show (dlg);
dialog_update_preview ();
run = (pika_dialog_run (PIKA_DIALOG (dlg)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dlg);
return run;
}
static void
tileit_hvtoggle_update (GtkWidget *widget,
gpointer data)
{
pika_toggle_button_update (widget, data);
switch (exp_call.type)
{
case ALL:
/* Clear current settings */
memset (tileactions, 0, sizeof (tileactions));
all_update ();
break;
case ALT:
/* Clear current settings */
memset (tileactions, 0, sizeof (tileactions));
alt_update ();
break;
case EXPLICIT:
break;
}
dialog_update_preview ();
}
static gboolean
tileit_preview_draw (GtkWidget *widget,
cairo_t *cr)
{
if (exp_call.type == EXPLICIT)
{
gdouble width = (gdouble) preview_width / (gdouble) itvals.numtiles;
gdouble height = (gdouble) preview_height / (gdouble) itvals.numtiles;
gdouble x , y;
x = width * (exp_call.x - 1);
y = height * (exp_call.y - 1);
cairo_rectangle (cr, x + 1.5, y + 1.5, width - 2, height - 2);
cairo_set_line_width (cr, 3.0);
cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.6);
cairo_stroke_preserve (cr);
cairo_set_line_width (cr, 1.0);
cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.8);
cairo_stroke_preserve (cr);
}
return FALSE;
}
static void
exp_need_update (gint nx,
gint ny)
{
if (nx <= 0 || nx > itvals.numtiles || ny <= 0 || ny > itvals.numtiles)
return;
if (nx != exp_call.x || ny != exp_call.y)
{
exp_call.x = nx;
exp_call.y = ny;
gtk_widget_queue_draw (tint.preview);
g_signal_handlers_block_by_func (exp_call.c_adj,
tileit_exp_update_f,
&exp_call);
g_signal_handlers_block_by_func (exp_call.r_adj,
tileit_exp_update_f,
&exp_call);
gtk_adjustment_set_value (exp_call.c_adj, nx);
gtk_adjustment_set_value (exp_call.r_adj, ny);
g_signal_handlers_unblock_by_func (exp_call.c_adj,
tileit_exp_update_f,
&exp_call);
g_signal_handlers_unblock_by_func (exp_call.r_adj,
tileit_exp_update_f,
&exp_call);
}
}
static gboolean
tileit_preview_events (GtkWidget *widget,
GdkEvent *event)
{
GdkEventButton *bevent;
GdkEventMotion *mevent;
gint nx, ny;
gint twidth = preview_width / itvals.numtiles;
gint theight = preview_height / itvals.numtiles;
switch (event->type)
{
case GDK_EXPOSE:
break;
case GDK_BUTTON_PRESS:
bevent = (GdkEventButton *) event;
nx = bevent->x/twidth + 1;
ny = bevent->y/theight + 1;
exp_need_update (nx, ny);
break;
case GDK_MOTION_NOTIFY:
mevent = (GdkEventMotion *) event;
if ( !mevent->state )
break;
if (mevent->x < 0 || mevent->y < 0)
break;
nx = mevent->x/twidth + 1;
ny = mevent->y/theight + 1;
exp_need_update (nx, ny);
break;
default:
break;
}
return FALSE;
}
static void
explicit_update (gboolean settile)
{
gint x,y;
/* Make sure bounds are OK */
y = ROUND (gtk_adjustment_get_value (exp_call.r_adj));
if (y > itvals.numtiles || y <= 0)
{
y = itvals.numtiles;
}
x = ROUND (gtk_adjustment_get_value (exp_call.c_adj));
if (x > itvals.numtiles || x <= 0)
{
x = itvals.numtiles;
}
/* Set it */
if (settile)
tileactions[x-1][y-1] = (((do_horz) ? HORIZONTAL : 0) |
((do_vert) ? VERTICAL : 0));
exp_call.x = x;
exp_call.y = y;
}
static void
all_update (void)
{
gint x,y;
for (x = 0 ; x < MAX_SEGS; x++)
for (y = 0 ; y < MAX_SEGS; y++)
tileactions[x][y] |= (((do_horz) ? HORIZONTAL : 0) |
((do_vert) ? VERTICAL : 0));
}
static void
alt_update (void)
{
gint x,y;
for (x = 0 ; x < MAX_SEGS; x++)
for (y = 0 ; y < MAX_SEGS; y++)
if (!((x + y) % 2))
tileactions[x][y] |= (((do_horz) ? HORIZONTAL : 0) |
((do_vert) ? VERTICAL : 0));
}
static void
tileit_radio_update (GtkWidget *widget,
gpointer data)
{
pika_radio_button_update (widget, data);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
{
switch (exp_call.type)
{
case ALL:
/* Clear current settings */
memset (tileactions, 0, sizeof (tileactions));
all_update ();
break;
case ALT:
/* Clear current settings */
memset (tileactions, 0, sizeof (tileactions));
alt_update ();
break;
case EXPLICIT:
explicit_update (FALSE);
break;
}
dialog_update_preview ();
}
}
static void
tileit_scale_update (PikaLabelSpin *scale,
gint *value)
{
*value = RINT (pika_label_spin_get_value (scale));
dialog_update_preview ();
}
static void
tileit_reset (GtkWidget *widget,
gpointer data)
{
Reset_Call *r = (Reset_Call *) data;
memset (tileactions, 0, sizeof (tileactions));
g_signal_handlers_block_by_func (r->htoggle,
tileit_hvtoggle_update,
&do_horz);
g_signal_handlers_block_by_func (r->vtoggle,
tileit_hvtoggle_update,
&do_vert);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (r->htoggle), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (r->vtoggle), FALSE);
g_signal_handlers_unblock_by_func (r->htoggle,
tileit_hvtoggle_update,
&do_horz);
g_signal_handlers_unblock_by_func (r->vtoggle,
tileit_hvtoggle_update,
&do_vert);
do_horz = do_vert = FALSE;
dialog_update_preview ();
}
/* Could avoid almost dup. functions by using a field in the data
* passed. Must still pass the data since used in sig blocking func.
*/
static void
tileit_exp_update (GtkWidget *widget,
gpointer applied)
{
explicit_update (TRUE);
dialog_update_preview ();
}
static void
tileit_exp_update_f (GtkWidget *widget,
gpointer applied)
{
explicit_update (FALSE);
dialog_update_preview ();
}
/* Cache the preview image - updates are a lot faster. */
/* The preview_cache will contain the small image */
static void
cache_preview (PikaDrawable *drawable)
{
GeglBuffer *buffer = pika_drawable_get_buffer (drawable);
const Babl *format;
gdouble scale;
if (pika_drawable_has_alpha (drawable))
format = babl_format ("R'G'B'A u8");
else
format = babl_format ("R'G'B' u8");
tint.img_bpp = babl_format_get_bytes_per_pixel (format);
tint.pv_cache = g_new (guchar, preview_width * preview_height * 4);
scale = MIN ((gdouble) preview_width / (gdouble) sel_width,
(gdouble) preview_height / (gdouble) sel_height);
gegl_buffer_get (buffer,
GEGL_RECTANGLE (scale * sel_x1, scale * sel_y1,
preview_width, preview_height),
scale,
format, tint.pv_cache,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
g_object_unref (buffer);
}
static void
do_tiles (PikaDrawable *drawable)
{
GeglBuffer *src_buffer;
GeglBuffer *dest_buffer;
GeglBufferIterator *iter;
const Babl *format;
gboolean has_alpha;
gint progress, max_progress;
gint bpp;
guchar pixel[4];
gint nc, nr;
gint i;
src_buffer = pika_drawable_get_buffer (drawable);
dest_buffer = pika_drawable_get_shadow_buffer (drawable);
has_alpha = pika_drawable_has_alpha (drawable);
if (has_alpha)
format = babl_format ("R'G'B'A u8");
else
format = babl_format ("R'G'B' u8");
bpp = babl_format_get_bytes_per_pixel (format);
progress = 0;
max_progress = sel_width * sel_height;
iter = gegl_buffer_iterator_new (dest_buffer,
GEGL_RECTANGLE (sel_x1, sel_y1,
sel_width, sel_height), 0,
format,
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1);
while (gegl_buffer_iterator_next (iter))
{
GeglRectangle dest_roi = iter->items[0].roi;
guchar *dest_row = iter->items[0].data;
gint row;
for (row = dest_roi.y; row < (dest_roi.y + dest_roi.height); row++)
{
guchar *dest = dest_row;
gint col;
for (col = dest_roi.x; col < (dest_roi.x + dest_roi.width); col++)
{
tiles_xy (sel_width,
sel_height,
col - sel_x1,
row - sel_y1,
&nc, &nr);
gegl_buffer_sample (src_buffer, nc + sel_x1, nr + sel_y1, NULL,
pixel, format,
GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
for (i = 0; i < bpp; i++)
dest[i] = pixel[i];
if (has_alpha)
dest[bpp - 1] = (pixel[bpp - 1] * opacity) / 100;
dest += bpp;
}
dest_row += dest_roi.width * bpp;
}
progress += dest_roi.width * dest_roi.height;
pika_progress_update ((double) progress / max_progress);
}
pika_progress_update (1.0);
g_object_unref (src_buffer);
g_object_unref (dest_buffer);
pika_drawable_merge_shadow (drawable, TRUE);
pika_drawable_update (drawable,
sel_x1, sel_y1, sel_width, sel_height);
}
/* Get the xy pos and any action */
static gint
tiles_xy (gint width,
gint height,
gint x,
gint y,
gint *nx,
gint *ny)
{
gint px,py;
gint rnum,cnum;
gint actiontype;
gdouble rnd = 1 - (1.0 / (gdouble) itvals.numtiles) + 0.01;
rnum = y * itvals.numtiles / height;
py = (y * itvals.numtiles) % height;
px = (x * itvals.numtiles) % width;
cnum = x * itvals.numtiles / width;
if ((actiontype = tileactions[cnum][rnum]))
{
if (actiontype & VERTICAL)
{
gdouble pyr;
pyr = height - y - 1 + rnd;
py = ((gint) (pyr * (gdouble) itvals.numtiles)) % height;
}
if (actiontype & HORIZONTAL)
{
gdouble pxr;
pxr = width - x - 1 + rnd;
px = ((gint) (pxr * (gdouble) itvals.numtiles)) % width;
}
}
*nx = px;
*ny = py;
return(actiontype);
}
/* Given a row then shrink it down a bit */
static void
do_tiles_preview (guchar *dest_row,
guchar *src_rows,
gint width,
gint dh,
gint height,
gint bpp)
{
gint x;
gint i;
gint px, py;
gint rnum,cnum;
gint actiontype;
gdouble rnd = 1 - (1.0 / (gdouble) itvals.numtiles) + 0.01;
rnum = dh * itvals.numtiles / height;
for (x = 0; x < width; x ++)
{
py = (dh*itvals.numtiles)%height;
px = (x*itvals.numtiles)%width;
cnum = x*itvals.numtiles/width;
if ((actiontype = tileactions[cnum][rnum]))
{
if (actiontype & VERTICAL)
{
gdouble pyr;
pyr = height - dh - 1 + rnd;
py = ((int)(pyr*(gdouble)itvals.numtiles))%height;
}
if (actiontype & HORIZONTAL)
{
gdouble pxr;
pxr = width - x - 1 + rnd;
px = ((int)(pxr*(gdouble)itvals.numtiles))%width;
}
}
for (i = 0 ; i < bpp; i++ )
dest_row[x*tint.img_bpp+i] =
src_rows[(px + (py*width))*bpp+i];
if (has_alpha)
dest_row[x*tint.img_bpp + (bpp - 1)] =
(dest_row[x*tint.img_bpp + (bpp - 1)]*opacity)/100;
}
}
static void
dialog_update_preview (void)
{
gint y;
guchar *buffer;
buffer = g_new (guchar, preview_width * preview_height * tint.img_bpp);
for (y = 0; y < preview_height; y++)
{
do_tiles_preview (tint.preview_row,
tint.pv_cache,
preview_width,
y,
preview_height,
tint.img_bpp);
memcpy (buffer + y* (preview_width * tint.img_bpp),
tint.preview_row,
preview_width * tint.img_bpp);
}
pika_preview_area_draw (PIKA_PREVIEW_AREA (tint.preview),
0, 0, preview_width, preview_height,
(tint.img_bpp>3)?PIKA_RGBA_IMAGE:PIKA_RGB_IMAGE,
buffer,
preview_width * tint.img_bpp);
g_free (buffer);
gtk_widget_queue_draw (tint.preview);
}