static int set_enter(void)
{
int w = config_get_d(CONFIG_WIDTH);
int h = config_get_d(CONFIG_HEIGHT);
int id, jd, kd;
int i;
if (do_init)
{
total = set_init();
first = MIN(first, (total - 1) - ((total - 1) % SET_STEP));
audio_music_fade_to(0.5f, "bgm/inter.ogg");
audio_play(AUD_START, 1.f);
}
else do_init = 1;
if ((id = gui_vstack(0)))
{
if ((jd = gui_hstack(id)))
{
gui_label(jd, _("Level Set"), GUI_SML, GUI_ALL, gui_yel, gui_red);
gui_filler(jd);
gui_navig(jd, first > 0, first + SET_STEP < total);
}
gui_space(id);
if ((jd = gui_harray(id)))
{
shot_id = gui_image(jd, set_shot(first), 7 * w / 16, 7 * h / 16);
if ((kd = gui_varray(jd)))
{
for (i = first; i < first + SET_STEP; i++)
gui_set(kd, i);
}
}
gui_space(id);
desc_id = gui_multi(id, " \\ \\ \\ \\ \\", GUI_SML, GUI_ALL,
gui_yel, gui_wht);
gui_layout(id, 0, 0);
}
return id;
}
static int demo_compat_gui(void)
{
int id;
if ((id = gui_vstack(0)))
{
gui_label(id, _("Warning!"), GUI_MED, 0, 0);
gui_space(id);
gui_multi(id, _("The current replay was recorded with a\\"
"different (or unknown) version of this level.\\"
"Be prepared to encounter visual errors.\\"),
GUI_SML, gui_wht, gui_wht);
gui_layout(id, 0, 0);
}
return id;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
/* Plug-in variables */
gboolean single_image;
gboolean defaults_proc;
/* Plug-In variables */
cairo_surface_t *pdf_file;
cairo_t *cr;
GimpExportCapabilities capabilities;
guint32 i = 0;
gint32 j = 0;
gdouble x_res, y_res;
gdouble x_scale, y_scale;
gint32 image_id;
gboolean exported;
GimpImageBaseType type;
gint32 temp;
gint *layers;
gint32 num_of_layers;
GimpDrawable *layer;
cairo_surface_t *layer_image;
gdouble opacity;
gint x, y;
GimpRGB layer_color;
gboolean single_color;
gint32 mask_id = -1;
GimpDrawable *mask = NULL;
cairo_surface_t *mask_image = NULL;
FILE *fp;
INIT_I18N ();
/* Setting mandatory output values */
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Initializing all the settings */
multi_page.image_count = 0;
if (! init_vals (name, nparams, param, &single_image,
&defaults_proc, &run_mode))
{
values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
return;
}
/* Starting the executions */
if (run_mode == GIMP_RUN_INTERACTIVE)
{
if (single_image)
{
if (! gui_single ())
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
}
else if (! gui_multi ())
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
if (file_name == NULL)
{
values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
gimp_message (_("You must select a file to save!"));
return;
}
}
fp = g_fopen (file_name, "wb");
pdf_file = cairo_pdf_surface_create_for_stream (write_func, fp, 1, 1);
if (cairo_surface_status (pdf_file) != CAIRO_STATUS_SUCCESS)
{
char *str = g_strdup_printf
(_("An error occured while creating the PDF file:\n"
"%s\n"
"Make sure you entered a valid filename and that the selected location isn't read only!"),
cairo_status_to_string (cairo_surface_status (pdf_file)));
gimp_message (str);
g_free (str);
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
return;
}
cr = cairo_create (pdf_file);
capabilities = GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_ALPHA |
GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_LAYERS |
GIMP_EXPORT_CAN_HANDLE_INDEXED;
if (optimize.apply_masks)
capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS;
for (i = 0; i < multi_page.image_count; i++)
{
/* Save the state of the surface before any changes, so that settings
* from one page won't affect all the others */
cairo_save (cr);
image_id = multi_page.images[i];
/* We need the active layer in order to use gimp_image_export */
temp = gimp_image_get_active_drawable (image_id);
if (temp == -1)
exported = gimp_export_image (&image_id, &temp, NULL, capabilities) == GIMP_EXPORT_EXPORT;
else
exported = FALSE;
type = gimp_image_base_type (image_id);
gimp_image_get_resolution (image_id, &x_res, &y_res);
x_scale = 72.0 / x_res;
y_scale = 72.0 / y_res;
cairo_pdf_surface_set_size (pdf_file,
gimp_image_width (image_id) * x_scale,
gimp_image_height (image_id) * y_scale);
/* This way we set how many pixels are there in every inch.
* It's very important for PangoCairo */
cairo_surface_set_fallback_resolution (pdf_file, x_res, y_res);
/* PDF is usually 72 points per inch. If we have a different resolution,
* we will need this to fit our drawings */
cairo_scale (cr, x_scale, y_scale);
/* Now, we should loop over the layers of each image */
layers = gimp_image_get_layers (image_id, &num_of_layers);
for (j = 0; j < num_of_layers; j++)
{
layer = gimp_drawable_get (layers [num_of_layers-j-1]);
opacity = gimp_layer_get_opacity (layer->drawable_id)/100.0;
/* Gimp doesn't display indexed layers with opacity below 50%
* And if it's above 50%, it will be rounded to 100% */
if (type == GIMP_INDEXED)
{
if (opacity <= 0.5)
opacity = 0.0;
else
opacity = 1.0;
}
if (gimp_item_get_visible (layer->drawable_id)
&& (! optimize.ignore_hidden || (optimize.ignore_hidden && opacity > 0.0)))
{
mask_id = gimp_layer_get_mask (layer->drawable_id);
if (mask_id != -1)
{
mask = gimp_drawable_get (mask_id);
mask_image = get_drawable_image (mask);
}
gimp_drawable_offsets (layer->drawable_id, &x, &y);
/* For raster layers */
if (!gimp_item_is_text_layer (layer->drawable_id))
{
layer_color = get_layer_color (layer, &single_color);
cairo_rectangle (cr, x, y, layer->width, layer->height);
if (optimize.vectorize && single_color)
{
cairo_set_source_rgba (cr, layer_color.r, layer_color.g, layer_color.b, layer_color.a * opacity);
if (mask_id != -1)
cairo_mask_surface (cr, mask_image, x, y);
else
cairo_fill (cr);
}
else
{
cairo_clip (cr);
layer_image = get_drawable_image (layer);
cairo_set_source_surface (cr, layer_image, x, y);
cairo_push_group (cr);
cairo_paint_with_alpha (cr, opacity);
cairo_pop_group_to_source (cr);
if (mask_id != -1)
cairo_mask_surface (cr, mask_image, x, y);
else
cairo_paint (cr);
cairo_reset_clip (cr);
cairo_surface_destroy (layer_image);
}
}
/* For text layers */
else
{
drawText (layer, opacity, cr, x_res, y_res);
}
}
/* We are done with the layer - time to free some resources */
gimp_drawable_detach (layer);
if (mask_id != -1)
{
gimp_drawable_detach (mask);
cairo_surface_destroy (mask_image);
}
}
/* We are done with this image - Show it! */
cairo_show_page (cr);
cairo_restore (cr);
if (exported)
gimp_image_delete (image_id);
}
/* We are done with all the images - time to free the resources */
cairo_surface_destroy (pdf_file);
cairo_destroy (cr);
fclose (fp);
/* Finally done, let's save the parameters */
gimp_set_data (DATA_OPTIMIZE, &optimize, sizeof (optimize));
if (!single_image)
{
g_strlcpy (multi_page.file_name, file_name, MAX_FILE_NAME_LENGTH);
gimp_set_data (DATA_IMAGE_LIST, &multi_page, sizeof (multi_page));
}
}
static int course_enter(void)
{
int w = config_get_d(CONFIG_WIDTH);
int h = config_get_d(CONFIG_HEIGHT);
int id, jd, kd, ld, md, i = 0, j, n = course_count();
int m = (int)(sqrt(n/2.0)*2);
if ((id = gui_vstack(0)))
{
gui_label(id, _("Select Course"), GUI_MED, GUI_ALL, 0, 0);
gui_space(id);
if ((jd = gui_hstack(id)))
{
shot_id = gui_image(jd, course_shot(0), w / 3, h / 3);
gui_filler(jd);
if ((kd = gui_varray(jd)))
{
for(i = 0; i < n; i += m)
{
if ((ld = gui_harray(kd)))
{
for (j = (m - 1); j >= 0; j--)
{
if (i + j < n)
{
md = gui_image(ld, course_shot(i + j),
w / 3 / m, h / 3 / m);
gui_active(md, i + j, 0);
if (i + j == 0)
gui_focus(md);
}
else
gui_space(ld);
}
}
}
}
}
gui_space(id);
desc_id = gui_multi(id, _(course_desc(0)), GUI_SML, GUI_ALL, gui_yel, gui_wht);
gui_space(id);
if ((jd = gui_hstack(id)))
{
gui_filler(jd);
gui_state(jd, _("Back"), GUI_SML, COURSE_BACK, 0);
}
gui_layout(id, 0, 0);
}
audio_music_fade_to(0.5f, "bgm/inter.ogg");
return id;
}
static int course_enter(struct state *st, struct state *prev)
{
int w = config_get_d(CONFIG_WIDTH);
int h = config_get_d(CONFIG_HEIGHT);
int id, jd, kd, ld, md;
int i, j, r, c, n;
n = course_count();
r = comp_rows(n);
c = comp_cols(n);
if ((id = gui_vstack(0)))
{
gui_label(id, _("Select Course"), GUI_MED, 0, 0);
gui_space(id);
if ((jd = gui_hstack(id)))
{
shot_id = gui_image(jd, course_shot(0), w / 3, h / 3);
gui_filler(jd);
if ((kd = gui_varray(jd)))
{
for(i = 0; i < r; i++)
{
if ((ld = gui_harray(kd)))
{
for (j = c - 1; j >= 0; j--)
{
int k = i * c + j;
if (k < n)
{
md = gui_image(ld, course_shot(k),
w / 3 / c, h / 3 / r);
gui_set_state(md, k, 0);
if (k == 0)
gui_focus(md);
}
else
gui_space(ld);
}
}
}
}
}
gui_space(id);
desc_id = gui_multi(id, _(course_desc(0)), GUI_SML, gui_yel, gui_wht);
gui_space(id);
if ((jd = gui_hstack(id)))
{
gui_filler(jd);
gui_state(jd, _("Back"), GUI_SML, COURSE_BACK, 0);
}
gui_layout(id, 0, 0);
}
audio_music_fade_to(0.5f, "bgm/inter.ogg");
return id;
}
static int help_enter(void)
{
const char *s0 =
"Move the mouse or joystick to tilt the floor\\"
"causing the ball to roll. Roll over coins to\\"
"collect them. Collect coins to unlock the goal\\"
"and finish the level. Earn an extra ball for\\"
"each 100 coins collected.\\";
const char *s4 = "Left and right mouse buttons rotate the view.";
const char *s5 = "Hold Shift for faster view rotation.";
const char *s6 = "Pause / Release Pointer";
const char *s7 = "Exit / Cancel Menu";
const char *s8 = "Chase View";
const char *s9 = "Lazy View";
const char *sA = "Manual View";
const char *sB = "Comments? Problems? [email protected]";
const char *k0 = "Spacebar";
const char *k1 = "Escape";
const char *k2 = SDL_GetKeyName((SDLKey)config_get_d(CONFIG_KEY_CAMERA_1));
const char *k3 = SDL_GetKeyName((SDLKey)config_get_d(CONFIG_KEY_CAMERA_2));
const char *k4 = SDL_GetKeyName((SDLKey)config_get_d(CONFIG_KEY_CAMERA_3));
int id, jd;
if ((id = gui_vstack(0)))
{
gui_multi(id, s0, GUI_SML, GUI_ALL, gui_wht, gui_wht);
gui_space(id);
if ((jd = gui_harray(id)))
{
gui_label(jd, s6, GUI_SML, GUI_NE, gui_wht, gui_wht);
gui_label(jd, k0, GUI_SML, GUI_NW, gui_yel, gui_yel);
}
if ((jd = gui_harray(id)))
{
gui_label(jd, s7, GUI_SML, 0, gui_wht, gui_wht);
gui_label(jd, k1, GUI_SML, 0, gui_yel, gui_yel);
}
if ((jd = gui_harray(id)))
{
gui_label(jd, s8, GUI_SML, 0, gui_wht, gui_wht);
gui_label(jd, k2, GUI_SML, 0, gui_yel, gui_yel);
}
if ((jd = gui_harray(id)))
{
gui_label(jd, s9, GUI_SML, 0, gui_wht, gui_wht);
gui_label(jd, k3, GUI_SML, 0, gui_yel, gui_yel);
}
if ((jd = gui_harray(id)))
{
gui_label(jd, sA, GUI_SML, GUI_SE, gui_wht, gui_wht);
gui_label(jd, k4, GUI_SML, GUI_SW, gui_yel, gui_yel);
}
gui_space(id);
gui_label(id, s4, GUI_SML, GUI_TOP, gui_wht, gui_wht);
gui_label(id, s5, GUI_SML, GUI_BOT, gui_wht, gui_wht);
gui_space(id);
gui_label(id, sB, GUI_SML, GUI_ALL, gui_wht, gui_wht);
gui_layout(id, 0, 0);
}
return id;
}
