/*
* texture.c: Texture widgets, color widgets
*
* Written by: Ullrich Hafner
*
* Copyright (C) 1998 Ullrich Hafner <hafner@bigfoot.de>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
*/
/*
* $Date: 2002/01/07 19:14:44 $
* $Author: ulli $
* $Revision: 1.75 $
* $State: Exp $
*/
#include "config.h"
#include <gtk/gtk.h>
#include "proplist_t.h"
#include <ctype.h>
#if HAVE_STRING_H
# include <string.h>
#else /* not HAVE_STRING_H */
# include <strings.h>
#endif /* not HAVE_STRING_H */
#include "misc.h"
#include "load.h"
#include "icons.h"
#include "window.h"
#include "dialog.h"
#include "previews.h"
#include "texture.h"
#include "menu.h"
#include "rimage.h"
#include "error.h"
/*******************************************************************************
global variables (imported from window.c)
*******************************************************************************/
extern proplist_t windowmaker;
extern proplist_t wmconfig;
extern bool_t changed;
extern GtkTooltips *tooltips;
/*******************************************************************************
local variables
*******************************************************************************/
static const char **workspace_names = NULL;
static const char **ttype_strings = NULL;
static const char **ptype_strings = NULL;
static const char **gtype_strings = NULL;
static const char **option_t_normal = NULL;
static const char **option_t_wspace = NULL;
static const char **option_t_wspecific = NULL;
static const char **option_p_normal = NULL;
static const char **option_p_wspace = NULL;
static const char **option_g = NULL;
static int wsnumber = 0;
#define KEY_OF_TEXTURE (array == WMGetFromPLDictionary (windowmaker, wtexture->key) ? wtexture->key: wtexture->wssback)
/*****************************************************************************
prototypes
*****************************************************************************/
static void
color_right_button (GtkWidget *dummy, gpointer ptr);
static void
update_gradient_preview (wtexture_t *wtexture);
static void
init_types (void);
static gint
list_button_press (GtkWidget *list, GdkEventButton *event, gpointer ptr);
static void
list_change (GtkWidget *widget, GtkWidget *list);
static void
list_remove (GtkWidget *widget, GtkWidget *list);
static void
list_append (GtkWidget *widget, GtkWidget *list);
static void
list_insert (GtkWidget *widget, GtkWidget *list);
static GtkWidget *
new_list_item (wtexture_t *wtexture, proplist_t color);
static void
set_pixmap (GtkWidget *widget, gpointer filesel);
static void
set_pixmap_name (GtkWidget *widget, gpointer ptr);
static void
change_path (GtkWidget *widget, gpointer filesel);
static void
file_selection (GtkWidget *widget, wtexture_t *wtexture);
static void
update_pixmap (GtkWidget *widget, GtkFileSelection *fs);
#ifdef HAVE_LIBWMFUN
static void
update_wmfun_preview (wtexture_t *wtexture, GtkWidget **preview);
static GtkWidget *
generate_bilinear_dialog (wtexture_t *wtexture);
static GtkWidget *
generate_fade_dialog (wtexture_t *wtexture);
static GtkWidget *
generate_waves_dialog (wtexture_t *wtexture);
static void
set_layers (GtkWidget *widget, gpointer ptr);
static void
set_frequency (GtkWidget *widget, gpointer ptr);
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
static GtkWidget *
generate_interwoven_dialog (wtexture_t *wtexture);
static void
set_thickness_1 (GtkWidget *widget, gpointer ptr);
static void
set_thickness_2 (GtkWidget *widget, gpointer ptr);
static void
update_interwoven_preview (wtexture_t *wtexture, GtkWidget **preview);
#endif /* HAVE_INTERWOVEN_GRADIENT */
static GtkWidget *
generate_pixmap_dialog (wtexture_t *wtexture);
static GtkWidget *
generate_simple_gradient (wtexture_t *wtexture);
static GtkWidget *
generate_gradient_dialog (wtexture_t *wtexture);
static GtkWidget *
generate_default_color (wtexture_t *wtexture);
static void
show_texture_dialog (wtexture_t *wtexture);
static void
gradient_type_toggle (GtkWidget *widget, gpointer ptr);
static void
pixmap_type_toggle (GtkWidget *widget, gpointer ptr);
static void
texture_type_toggle (GtkWidget *widget, gpointer ptr);
static void
color_selection_dialog (GtkWidget *widget, proplist_t key);
static void
color_selection_ok (GtkWidget *w, GtkColorSelection *colorsel);
static void
color_selection_cancel (GtkWidget *w, GtkColorSelection *colorsel);
static void
set_opacity (GtkWidget *widget, gpointer ptr);
static char **
get_workspace_names (void);
static void
workspace_toggle (GtkWidget *widget, gpointer ptr);
static proplist_t
get_texture_array (wtexture_t *wtexture);
static void
update_texture (proplist_t key, gpointer ptr, proplist_t value,
const char *path);
static void
combine_path_and_filename (proplist_t array, wtexture_t *wtexture);
/*******************************************************************************
public code
*******************************************************************************/
GtkWidget *
texture_dialog (GtkWidget *box, GtkWidget *omenu_box, proplist_t key)
/*
* Generate a new texture dialog widget and pack widget into given 'box'.
*
* No return value.
*/
{
wtexture_t *wtexture;
GtkWidget *dialog;
GtkWidget *table;
GtkWidget *vbox1, *vbox2;
if (!ttype_strings || !ptype_strings || !gtype_strings)
init_types ();
wtexture = Calloc (1, sizeof (wtexture_t));
wtexture->wpixmap = Calloc (PIXMAP_LAST, sizeof (GtkWidget *));
wtexture->wgradient = Calloc (GRADIENT_LAST, sizeof (GtkWidget *));
wtexture->wsgradient = Calloc (SGRADIENT_LAST, sizeof (GtkWidget *));
#ifdef HAVE_LIBWMFUN
wtexture->wbilinear = Calloc (BILINEAR_LAST, sizeof (GtkWidget *));
wtexture->wfade = Calloc (FADE_LAST, sizeof (GtkWidget *));
wtexture->wwaves = Calloc (WAVES_LAST, sizeof (GtkWidget *));
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
wtexture->winterwoven = Calloc (INTERWOVEN_LAST, sizeof (GtkWidget *));
#endif /* INTERWOVEN_FRAME */
wtexture->key = key;
wtexture->wssback = WMCreatePLString ("WorkspaceSpecificBack");
wtexture->wsnumber = 0;
wtexture->path = NULL;
{
GtkWidget *vbox = gtk_vbox_new (FALSE, 5);
GtkWidget *hbox = gtk_hbox_new (FALSE, 0);
table = gtk_table_new (1, 2, TRUE);
gtk_table_set_row_spacings (GTK_TABLE (table), 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), vbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
dialog = vbox;
}
vbox1 = gtk_vbox_new (FALSE, 5);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (table), vbox1, 0, 1, 0, 1,
GTK_SHRINK | GTK_EXPAND | GTK_FILL,
GTK_SHRINK | GTK_EXPAND | GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), vbox2, 1, 2, 0, 1,
GTK_SHRINK | GTK_EXPAND | GTK_FILL,
GTK_SHRINK | GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show_all (dialog);
/*
* Texture type
*/
if (omenu_box && strcaseeq ("workspaceback", WMGetFromPLString (wtexture->key)))
{
GtkWidget *frame = gtk_frame_new (_("Workspace"));
GtkWidget *vbox = gtk_vbox_new (FALSE, 5);
workspace_names = (const char **) get_workspace_names ();
gtk_box_pack_start (GTK_BOX (vbox),
generate_option_menu (NULL, tooltips,
_("For each workspace a different"
" texture can be specified. "
"The texture of the default "
"workspace is used if the "
"texture type is set"
" to 'default' for a specific "
"workspace."), workspace_names,
"Default", NULL,
workspace_toggle, wtexture),
FALSE, FALSE, 0);
gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show_all (frame);
gtk_box_pack_start (GTK_BOX (omenu_box), frame, FALSE, TRUE, 5);
}
{
GtkWidget *vbox = gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
if (strcaseeq ("workspaceback", WMGetFromPLString (wtexture->key)))
wtexture->wttype
= generate_option_menu (NULL, tooltips,
_("A solid color, a pixmap, or a gradient. "
"If 'None' is selected, then the root "
"background is not changed by Window "
"Maker. If 'Default' is selected, then "
"the texture of the default workspace "
"is used"),
option_t_wspecific, option_t_wspecific [0],
NULL, texture_type_toggle, wtexture);
else
wtexture->wttype
= generate_option_menu (NULL, tooltips,
_("A solid color, a pixmap, or a gradient."),
option_t_normal, option_t_normal [0], NULL,
texture_type_toggle, wtexture);
gtk_box_pack_start (GTK_BOX (vbox), wtexture->wttype, FALSE, FALSE, 0);
if (strcaseeq ("workspaceback", WMGetFromPLString (wtexture->key)))
{
wtexture->wwttype
= generate_option_menu (NULL, tooltips,
_("A solid color, a pixmap, or a gradient. "
"If 'None' is selected, then the root "
"background is not changed by Window "
"Maker."),
option_t_wspace, option_t_wspace [0], NULL,
texture_type_toggle, wtexture);
gtk_box_pack_start (GTK_BOX (vbox), wtexture->wwttype, FALSE, FALSE, 0);
}
{
GtkWidget *frame = gtk_frame_new (_("Type"));
gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_box_pack_start (GTK_BOX (vbox1), frame, FALSE, TRUE, 0);
gtk_widget_show_all (frame);
}
}
gtk_box_pack_start (GTK_BOX (vbox1), generate_default_color (wtexture),
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox1), generate_simple_gradient (wtexture),
TRUE, TRUE, 0);
#ifdef HAVE_LIBWMFUN
gtk_box_pack_start (GTK_BOX (vbox1), generate_bilinear_dialog (wtexture),
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox1), generate_fade_dialog (wtexture),
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox1), generate_waves_dialog (wtexture),
TRUE, TRUE, 0);
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
gtk_box_pack_start (GTK_BOX (vbox1), generate_interwoven_dialog (wtexture),
TRUE, TRUE, 0);
#endif /* HAVE_INTERWOVEN_GRADIENT */
gtk_box_pack_start (GTK_BOX (vbox2),
generate_pixmap_dialog (wtexture), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox2),
generate_gradient_dialog (wtexture), TRUE, TRUE, 0);
show_texture_dialog (wtexture);
connect_update_function (key, wtexture, update_texture);
return dialog;
}
GtkWidget *
color_button (wtexture_t *wtexture, proplist_t key, proplist_t color,
GtkTooltips *tooltips, const char *info)
/*
* Generate color button.
* The color value (in proplist format) is assigned to preview.
*/
{
GtkWidget *frame = gtk_frame_new (NULL);
GtkWidget *preview = gtk_preview_new (GTK_PREVIEW_COLOR);
GtkWidget *button = gtk_button_new ();
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 3);
gtk_preview_size (GTK_PREVIEW (preview), 30, 15);
gtk_container_add (GTK_CONTAINER (frame), preview);
gtk_object_set_user_data (GTK_OBJECT (preview), (gpointer) color);
gtk_object_set_data (GTK_OBJECT (preview), "wtexture", wtexture);
fill_preview (GTK_PREVIEW (preview), color ? WMGetFromPLString (color) : "tan");
if (info)
gtk_tooltips_set_tip (tooltips, button, info, NULL);
gtk_container_add (GTK_CONTAINER (button), frame);
gtk_object_set_user_data (GTK_OBJECT (button), preview);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (color_selection_dialog),
(gpointer) key);
gtk_widget_show_all (button);
gtk_object_set_user_data (GTK_OBJECT (button), preview);
return button;
}
void
fill_preview (GtkPreview *preview, const char *col_spec)
/*
* Fill a 'preview' with color 'col_spec'.
*
* No return value.
*/
{
unsigned y;
GdkColor color;
unsigned width = GTK_WIDGET (preview)->requisition.width;
unsigned height = GTK_WIDGET (preview)->requisition.height;
unsigned char *buffer = Calloc (width * 3, sizeof (unsigned char));
if (!make_color (col_spec, &color))
color.red = color.green = color.blue = 65535;
for (y = 0; y < height; y++)
{
unsigned i;
unsigned char *ptr = buffer;
for (i = 0; i < width; i++)
{
*ptr++ = color.red / 256;
*ptr++ = color.green / 256;
*ptr++ = color.blue / 256;
}
gtk_preview_draw_row (preview, buffer, 0, y, width);
}
Free (buffer);
gtk_widget_draw (GTK_WIDGET (preview), NULL);
}
GtkWidget *
show_pixmap (proplist_t key, const char *name, GtkWidget *pixmap)
{
const char *keyname = WMGetFromPLString (key);
proplist_t array = WMGetFromPLDictionary (windowmaker, key);
/* If we are modifying the WorkspaceSpecificBack array, ensure that
* there are sufficient array elements to hold all the workspace textures,
* then pass the appropriate sub-array as argument.
* This is an ugly hack -- really the workspace-specific code should all
* be rewritten. */
if (strcaseeq (keyname, "workspacespecificback") && WMIsPLArray (array)) {
assert (wsnumber > 0);
if (wsnumber > WMGetPropListItemCount (array)) {
int i = WMGetPropListItemCount (array);
for ( ; i < wsnumber; i++)
WMAddToPLArray (array, WMCreatePLArray (NULL));
}
if (WMIsPLArray (WMGetFromPLArray (array, wsnumber - 1)))
array = WMGetFromPLArray (array, wsnumber - 1);
}
if (!WMIsPLArray (array) || WMGetPropListItemCount (array) != 5
#if !defined(PREVIEWS) || defined(CONVERT)
|| WMGetPropListItemCount (array) != 3
#endif /* !defined(PREVIEWS) || defined(CONVERT) */
)
{
if (strcaseeq (keyname, "workspaceback") ||
strcaseeq (keyname, "workspacespecificback"))
return make_pixmap (name, 180, 180 * 3 / 4, pixmap);
else if (strcaseeq (keyname + 1, "titleback")
|| strcaseeq (keyname, "menutitleback")
|| strcaseeq (keyname, "menutextback"))
return make_pixmap (name, 180, 22, pixmap);
else
return make_pixmap (name, 64, 64, pixmap);
}
#if defined(PREVIEWS) && !defined(CONVERT)
else /* textured gradient: colored gradient over pixmap */
{
gtype_e gtype;
char *type = WMGetFromPLString (WMGetFromPLArray (array, 0));
if (*(type + 1) == 'h')
gtype = HGRADIENT;
else if (*(type + 1) == 'v')
gtype = VGRADIENT;
else
gtype = DGRADIENT;
if (strcaseeq (keyname, "workspaceback") ||
strcaseeq (keyname, "workspacespecificback"))
return make_textured_gradient (get_pixmap_path (name), array,
180, 180 * 3 / 4, gtype, pixmap);
else if (strcaseeq (keyname + 1, "titleback")
|| strcaseeq (keyname, "menutitleback")
|| strcaseeq (keyname, "menutextback"))
return make_textured_gradient (get_pixmap_path (name), array,
180, 22, gtype, pixmap);
else
return make_textured_gradient (get_pixmap_path (name), array,
64, 64, gtype, pixmap);
}
#endif /* defined(PREVIEWS) && !defined(CONVERT) */
return pixmap;
}
void
verify_pixmap_name (GtkWidget *widget, wtexture_t *wtexture)
/*
* Verify if typed pixmap name is valid.
*
* No return value.
*
* Side effects:
* pixmap is changed
*/
{
const char *filename = gtk_entry_get_text (GTK_ENTRY (widget));
proplist_t array = get_texture_array (wtexture);
show_pixmap (KEY_OF_TEXTURE, filename, wtexture->wpixmap [PIXMAP_PIXMAP]);
}
void
cleanup_textures (void)
{
Free (workspace_names);
Free (ttype_strings);
Free (ptype_strings);
Free (gtype_strings);
Free (option_t_normal);
Free (option_t_wspace);
Free (option_t_wspecific);
Free (option_p_normal);
Free (option_p_wspace);
Free (option_g);
}
/*******************************************************************************
private code
*******************************************************************************/
static GtkWidget *
generate_pixmap_dialog (wtexture_t *wtexture)
/*
* Generate all widgets for the pixmap dialog.
*
* Return value:
* Container widget of pixmap dialog.
*/
{
GtkWidget *frame;
const char *name = WMGetFromPLString (wtexture->key);
wtexture->wpixmap [PIXMAP_FRAME] = frame = gtk_frame_new (_("Pixmap"));
gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
if (strcaseeq ("workspaceback", WMGetFromPLString (wtexture->key)))
wtexture->wpixmap [PIXMAP_TYPE]
= generate_option_menu (NULL,
tooltips,
_("Centered: "
"The pixmap will be shown centered.\n"
"Tiled: The pixmap will be tiled in the "
"destination.\n"
"Scaled: The pixmap will be scaled to "
"adapt to the destination's size.\n"
"Scaled (x:y): The pixmap will be scaled to "
"adapt to the destination's size but"
" will maintain aspect ratio."),
option_p_wspace, option_p_wspace [0], NULL,
pixmap_type_toggle, wtexture);
else
wtexture->wpixmap [PIXMAP_TYPE]
= generate_option_menu (NULL, tooltips,
_("Centered: "
"The pixmap will be shown centered.\n"
"Tiled: The pixmap will be tiled in the "
"destination.\n"
"Scaled: The pixmap will be scaled to "
"adapt to the destination's size."),
option_p_normal, option_p_normal [0], NULL,
pixmap_type_toggle, wtexture);
if (!strcaseeq (name, "iconback"))
{
GtkWidget *table = gtk_table_new (5, 1, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 0);
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_table_attach (GTK_TABLE (table), wtexture->wpixmap [PIXMAP_TYPE],
0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
/*
* Frame for pixmap
*/
wtexture->wpixmap [PIXMAP_PIXMAP]
= show_pixmap (wtexture->key, PKGDATADIR "/black.xpm", NULL);
if (strcaseeq (name, "workspaceback") ||
strcaseeq (name, "workspacespecificback"))
{
GtkWidget *frame = gtk_frame_new (NULL);
GtkWidget *hbox = gtk_hbox_new (TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame),
wtexture->wpixmap [PIXMAP_PIXMAP]);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 1, 2,
GTK_SHRINK, GTK_SHRINK, 0, 0);
}
else
gtk_table_attach (GTK_TABLE (table), wtexture->wpixmap [PIXMAP_PIXMAP],
0, 1, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
/*
* Filename entry
*/
{
GtkWidget *entry;
GtkWidget *hbox = gtk_hbox_new (TRUE, 0);
guint entry_sig_handler;
wtexture->wpixmap [PIXMAP_NAME] = entry = gtk_entry_new ();
entry_sig_handler = gtk_signal_connect
(GTK_OBJECT (entry), "changed",
GTK_SIGNAL_FUNC (set_pixmap_name), wtexture);
gtk_object_set_user_data (GTK_OBJECT (entry),
GINT_TO_POINTER (entry_sig_handler));
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (verify_pixmap_name), wtexture);
gtk_tooltips_set_tip (tooltips, entry,
_("Filename of the pixmap. <RETURN> checks if "
"the pixmap filename is valid."), NULL);
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 2, 3,
GTK_SHRINK | GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
}
/*
* Buttons
*/
{
GtkWidget *hbox, *button;
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox),
GTK_BUTTONBOX_SPREAD);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 3, 4,
GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 5);
button = gtk_button_new_with_label (_("Browse..."));
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (file_selection), wtexture);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, button,
_("Use file browser to select pixmap."), NULL);
#ifdef PREVIEWS
button = gtk_button_new_with_label (_("Previews..."));
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (preview_browser), wtexture);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, button,
_("Use preview browser to select pixmap."),
NULL);
#endif /* PREVIEWS */
}
}
else
{
GtkWidget *table = gtk_table_new (3, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_table_attach (GTK_TABLE (table), wtexture->wpixmap [PIXMAP_TYPE],
0, 2, 0, 1,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
{
GtkWidget *frame = gtk_frame_new (NULL);
GtkWidget *vbox = gtk_vbox_new (TRUE, 0);
GtkWidget *hbox = gtk_hbox_new (TRUE, 0);
wtexture->wpixmap [PIXMAP_PIXMAP]
= show_pixmap (wtexture->key, PKGDATADIR "/black.xpm", NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame),
wtexture->wpixmap [PIXMAP_PIXMAP]);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, TRUE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 1, 2,
GTK_SHRINK, GTK_SHRINK, 0, 0);
}
/*
* Filename entry
*/
{
GtkWidget *entry;
guint entry_sig_handler;
wtexture->wpixmap [PIXMAP_NAME] = entry = gtk_entry_new ();
entry_sig_handler = gtk_signal_connect
(GTK_OBJECT (entry), "changed",
GTK_SIGNAL_FUNC (set_pixmap_name), wtexture);
gtk_object_set_user_data (GTK_OBJECT (entry),
GINT_TO_POINTER (entry_sig_handler));
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (verify_pixmap_name), wtexture);
gtk_table_attach (GTK_TABLE (table), entry, 0, 2, 2, 3,
GTK_FILL | GTK_SHRINK | GTK_EXPAND,
GTK_FILL | GTK_SHRINK, 0, 0);
gtk_tooltips_set_tip (tooltips, entry,
_("Filename of the pixmap. <RETURN> checks if "
"the pixmap filename is valid."), NULL);
}
/*
* Browse button
*/
{
GtkWidget *vbox, *button;
vbox = gtk_vbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbox),
GTK_BUTTONBOX_SPREAD);
gtk_table_attach (GTK_TABLE (table), vbox, 1, 2, 1, 2,
GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
button = gtk_button_new_with_label (_("Browse..."));
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (file_selection), wtexture);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, button,
_("Use file browser to select pixmap."), NULL);
#ifdef PREVIEWS
button = gtk_button_new_with_label (_("Previews..."));
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (preview_browser), wtexture);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, button,
_("Use preview browser to select pixmap."),
NULL);
#endif /* PREVIEWS */
}
}
gtk_widget_show_all (frame);
return frame;
}
static GtkWidget *
generate_simple_gradient (wtexture_t *wtexture)
/*
* Generate all widgets for the simple gradient dialog.
*
* Return value:
* Container widget of simple gradient dialog.
*/
{
GtkWidget *frame = gtk_frame_new (_("Gradient"));
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
GtkWidget *hbox;
wtexture->wsgradient [SGRADIENT_FRAME] = frame;
gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
wtexture->wsgradient [SGRADIENT_TYPE]
= generate_option_menu (NULL, tooltips,
_("Horizontal: A gradient going from left to "
"right.\n"
"Vertical: A gradient going from top to "
"bottom.\n"
"Diagonal: A gradient going from the top-left"
" corner to the bottom-right corner.\n"
"Always from color 1 to color 2"),
option_g, option_g [0], NULL,
gradient_type_toggle, wtexture);
gtk_box_pack_start (GTK_BOX (vbox), wtexture->wsgradient [SGRADIENT_TYPE],
FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (hbox), gtk_label_new (_("Color 1: ")),
FALSE, TRUE, 0);
wtexture->wsgradient [SGRADIENT_COLOR1]
= color_button (wtexture, wtexture->key, NULL, NULL, NULL);
gtk_box_pack_start (GTK_BOX (hbox), wtexture->wsgradient [SGRADIENT_COLOR1],
FALSE, TRUE, 0);
wtexture->wsgradient [SGRADIENT_COLOR2]
= color_button (wtexture, wtexture->key, NULL, NULL, NULL);
gtk_box_pack_end (GTK_BOX (hbox), wtexture->wsgradient [SGRADIENT_COLOR2],
FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (hbox), gtk_label_new (_("Color 2: ")),
FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (hbox), gtk_label_new (_("Opacity:")),
FALSE, TRUE, 0);
{
GtkObject *adj = gtk_adjustment_new (0, 0, 255, 1.0, 10.0, 0.0);
GtkWidget *spinner;
spinner = wtexture->wsgradient [SGRADIENT_SPINNER]
= gtk_spin_button_new (GTK_ADJUSTMENT (adj), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_widget_show_all (spinner);
gtk_object_set_user_data (GTK_OBJECT (adj), (gpointer) spinner);
gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, spinner,
_("Opacity of the pixmap. If set to zero, only the"
" pixmap is visible (and vice versa)."), NULL);
gtk_signal_connect (GTK_OBJECT (>K_SPIN_BUTTON (spinner)->entry),
"changed", GTK_SIGNAL_FUNC (set_opacity), wtexture);
gtk_widget_set_usize (spinner, 100, -1);
}
gtk_widget_show_all (frame);
return frame;
}
static GtkWidget *
generate_default_color (wtexture_t *wtexture)
/*
* Generate default color dialog.
*
* Return value:
* Container widget of default color dialog.
*/
{
GtkWidget *frame = gtk_frame_new (_("Default color"));
GtkWidget *box = gtk_hbox_new (TRUE, 0);
GtkWidget *box1 = gtk_vbox_new (FALSE, 0);
wtexture->wcolorbox = frame;
gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
gtk_container_set_border_width (GTK_CONTAINER (box), 5);
wtexture->wcolor = color_button (wtexture, wtexture->key, NULL,
tooltips,
_("This color is used as solid color,"
" if a gradient can't be drawn, or during "
"the pixmap scaling/tiling process."));
gtk_box_pack_start (GTK_BOX (box1), wtexture->wcolor, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), box1, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), box);
gtk_widget_show_all (frame);
return frame;
}
#ifdef HAVE_LIBWMFUN
static GtkWidget *
generate_bilinear_dialog (wtexture_t *wtexture)
/*
* Generate bilinear gradient dialog.
*
* Return value:
* Container widget of bilinear gradient dialog.
*/
{
GtkWidget *frame = gtk_frame_new (_("Bilinear gradient"));
GtkWidget *table = gtk_table_new (3, 2, FALSE);
GtkWidget *hbox = gtk_hbox_new (TRUE, 0);
GtkWidget *vbox = gtk_hbox_new (FALSE, 0);
wtexture->wbilinear [BILINEAR_FRAME] = frame;
gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
wtexture->wbilinear [BILINEAR_NW]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("Color of the upper left corner."));
wtexture->wbilinear [BILINEAR_NE]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("Color of the upper right corner."));
wtexture->wbilinear [BILINEAR_SW]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("Color of the lower left corner."));
wtexture->wbilinear [BILINEAR_SE]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("Color of the lower right corner."));
wtexture->wbilinear [BILINEAR_PREVIEW] = NULL;
update_wmfun_preview (wtexture, &wtexture->wbilinear [BILINEAR_PREVIEW]);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), wtexture->wbilinear [BILINEAR_NW],
FALSE, FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 0, 1,
GTK_FILL | GTK_SHRINK | GTK_EXPAND,
GTK_FILL | GTK_SHRINK, 0, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX (hbox), wtexture->wbilinear [BILINEAR_NE],
FALSE, FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1,
GTK_FILL | GTK_SHRINK | GTK_EXPAND,
GTK_FILL | GTK_SHRINK, 0, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), wtexture->wbilinear [BILINEAR_SW],
FALSE, FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 2, 3,
GTK_FILL | GTK_SHRINK | GTK_EXPAND,
GTK_FILL | GTK_SHRINK, 0, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX (hbox), wtexture->wbilinear [BILINEAR_SE],
FALSE, FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 3,
GTK_FILL | GTK_SHRINK | GTK_EXPAND,
GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table), wtexture->wbilinear [BILINEAR_PREVIEW],
0, 2, 1, 2,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_widget_show_all (frame);
return frame;
}
static GtkWidget *
generate_fade_dialog (wtexture_t *wtexture)
/*
* Generate fading gradient dialog.
*
* Return value:
* Container widget of fading gradient dialog.
*/
{
GtkWidget *frame = gtk_frame_new (_("Fading vertical gradient"));
GtkWidget *table = gtk_table_new (3, 1, FALSE);
GtkWidget *hbox = gtk_hbox_new (TRUE, 0);
GtkWidget *vbox = gtk_hbox_new (FALSE, 0);
wtexture->wfade [FADE_FRAME] = frame;
gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
wtexture->wfade [FADE_FROM]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("First color of gradient."));
wtexture->wfade [FADE_TO]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("Last color of gradient."));
wtexture->wfade [FADE_PREVIEW] = NULL;
update_wmfun_preview (wtexture, &wtexture->wfade [FADE_PREVIEW]);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), wtexture->wfade [FADE_FROM],
FALSE, FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 0, 1,
GTK_FILL | GTK_SHRINK | GTK_EXPAND,
GTK_FILL | GTK_SHRINK, 0, 0);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), wtexture->wfade [FADE_TO],
FALSE, FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 2, 3,
GTK_FILL | GTK_SHRINK | GTK_EXPAND,
GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table), wtexture->wfade [FADE_PREVIEW],
0, 1, 1, 2,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_widget_show_all (frame);
return frame;
}
static GtkWidget *
generate_waves_dialog (wtexture_t *wtexture)
/*
* Generate waves gradient dialog.
*
* Return value:
* Container widget of waves gradient dialog.
*/
{
GtkWidget *frame = gtk_frame_new (_("Waves gradient"));
GtkWidget *table = gtk_table_new (2, 4, FALSE);
GtkWidget *hbox = gtk_hbox_new (TRUE, 0);
GtkWidget *vbox = gtk_hbox_new (FALSE, 0);
wtexture->wwaves [WAVES_FRAME] = frame;
gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
wtexture->wwaves [WAVES_FROM]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("First color of gradient."));
wtexture->wwaves [WAVES_TO]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("Last color of gradient."));
wtexture->wwaves [WAVES_PREVIEW] = NULL;
{
GtkObject *adj = gtk_adjustment_new (0, 0, 255, 1.0, 10.0, 0.0);
GtkWidget *spinner;
spinner = wtexture->wwaves [WAVES_LAYERS]
= gtk_spin_button_new (GTK_ADJUSTMENT (adj), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_widget_show_all (spinner);
gtk_object_set_user_data (GTK_OBJECT (adj), (gpointer) spinner);
gtk_tooltips_set_tip (tooltips, spinner,
_("Number of sine layers."), NULL);
gtk_signal_connect (GTK_OBJECT (>K_SPIN_BUTTON (spinner)->entry),
"changed", GTK_SIGNAL_FUNC (set_layers), wtexture);
}
{
GtkObject *adj = gtk_adjustment_new (0, 0, 255, 1.0, 10.0, 0.0);
GtkWidget *spinner;
spinner = wtexture->wwaves [WAVES_FREQUENCY]
= gtk_spin_button_new (GTK_ADJUSTMENT (adj), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_widget_show_all (spinner);
gtk_object_set_user_data (GTK_OBJECT (adj), (gpointer) spinner);
gtk_tooltips_set_tip (tooltips, spinner,
_("Frequency range of sine layers."), NULL);
gtk_signal_connect (GTK_OBJECT (>K_SPIN_BUTTON (spinner)->entry),
"changed", GTK_SIGNAL_FUNC (set_frequency),
wtexture);
}
update_wmfun_preview (wtexture, &wtexture->wwaves [WAVES_PREVIEW]);
gtk_table_attach (GTK_TABLE (table), wtexture->wwaves [WAVES_FROM],
0, 1, 0, 1,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table), wtexture->wwaves [WAVES_TO],
1, 2, 0, 1,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table), wtexture->wwaves [WAVES_LAYERS],
2, 3, 0, 1,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table), wtexture->wwaves [WAVES_FREQUENCY],
3, 4, 0, 1,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table), wtexture->wwaves [WAVES_PREVIEW],
0, 4, 1, 2,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_widget_show_all (frame);
return frame;
}
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
static GtkWidget *
generate_interwoven_dialog (wtexture_t *wtexture)
/*
* Generate interwoven gradient dialog.
*
* Return value:
* Container widget of interwoven gradient dialog.
*/
{
GtkWidget *frame = gtk_frame_new (_("Interwoven gradient"));
GtkWidget *table = gtk_table_new (3, 3, FALSE);
GtkWidget *hbox = gtk_hbox_new (TRUE, 0);
GtkWidget *vbox = gtk_hbox_new (FALSE, 0);
wtexture->winterwoven [INTERWOVEN_FRAME] = frame;
gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
wtexture->winterwoven [INTERWOVEN_FROM_1]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("First color of gradient 1."));
wtexture->winterwoven [INTERWOVEN_TO_1]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("Last color of gradient 1."));
wtexture->winterwoven [INTERWOVEN_FROM_2]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("First color of gradient 2."));
wtexture->winterwoven [INTERWOVEN_TO_2]
= color_button (wtexture, wtexture->key, NULL,
tooltips, _("Last color of gradient 2."));
wtexture->winterwoven [INTERWOVEN_PREVIEW] = NULL;
{
GtkObject *adj = gtk_adjustment_new (0, 0, 255, 1.0, 10.0, 0.0);
GtkWidget *spinner;
spinner = wtexture->winterwoven [INTERWOVEN_THICKNESS_1]
= gtk_spin_button_new (GTK_ADJUSTMENT (adj), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_widget_show_all (spinner);
gtk_object_set_user_data (GTK_OBJECT (adj), (gpointer) spinner);
gtk_tooltips_set_tip (tooltips, spinner,
_("Thickness gradient 1."), NULL);
gtk_signal_connect (GTK_OBJECT (>K_SPIN_BUTTON (spinner)->entry),
"changed", GTK_SIGNAL_FUNC (set_thickness_1),
wtexture);
}
{
GtkObject *adj = gtk_adjustment_new (0, 0, 255, 1.0, 10.0, 0.0);
GtkWidget *spinner;
spinner = wtexture->winterwoven [INTERWOVEN_THICKNESS_2]
= gtk_spin_button_new (GTK_ADJUSTMENT (adj), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_widget_show_all (spinner);
gtk_object_set_user_data (GTK_OBJECT (adj), (gpointer) spinner);
gtk_tooltips_set_tip (tooltips, spinner,
_("Thickness gradient 2."), NULL);
gtk_signal_connect (GTK_OBJECT (>K_SPIN_BUTTON (spinner)->entry),
"changed", GTK_SIGNAL_FUNC (set_thickness_2),
wtexture);
}
wtexture->winterwoven [INTERWOVEN_PREVIEW] = NULL;
update_interwoven_preview (wtexture,
&wtexture->winterwoven [INTERWOVEN_PREVIEW]);
gtk_table_attach (GTK_TABLE (table),
wtexture->winterwoven [INTERWOVEN_FROM_1], 0, 1, 0, 1,
GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table),
wtexture->winterwoven [INTERWOVEN_TO_1], 1, 2, 0, 1,
GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table),
wtexture->winterwoven [INTERWOVEN_THICKNESS_1],
2, 3, 0, 1,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table),
wtexture->winterwoven [INTERWOVEN_PREVIEW], 0, 3, 1, 2,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table),
wtexture->winterwoven [INTERWOVEN_FROM_2], 0, 1, 2, 3,
GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table),
wtexture->winterwoven [INTERWOVEN_TO_2], 1, 2, 2, 3,
GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_table_attach (GTK_TABLE (table),
wtexture->winterwoven [INTERWOVEN_THICKNESS_2],
2, 3, 2, 3,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_widget_show_all (frame);
return frame;
}
#endif /* HAVE_INTERWOVEN_GRADIENT */
static GtkWidget *
generate_gradient_dialog (wtexture_t *wtexture)
/*
* Generate all widgets for the gradient dialog.
*
* Return value:
* Container widget of gradient dialog.
*/
{
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *scrolled;
GtkWidget *table;
GtkWidget *list;
frame = wtexture->wgradient [GRADIENT_FRAME]
= gtk_frame_new (_("Gradient"));
gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);
wtexture->wgradient [GRADIENT_TYPE]
= generate_option_menu (NULL, tooltips,
_("Horizontal: A gradient going from left to "
"right.\n"
"Vertical: A gradient going from top to "
"bottom.\n"
"Diagonal: A gradient going from the top-left"
" corner to the bottom-right corner.\n"
"Always from the first to the last color."),
option_g, option_g [0], NULL,
gradient_type_toggle, wtexture);
table = gtk_table_new (2, 1, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_table_attach (GTK_TABLE (table), wtexture->wgradient [GRADIENT_TYPE],
0, 2, 0, 1,
GTK_FILL | GTK_SHRINK | GTK_EXPAND,
GTK_FILL | GTK_SHRINK, 0, 0);
hbox = gtk_hbox_new (FALSE, 5);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 1, 2,
GTK_FILL | GTK_SHRINK | GTK_EXPAND,
GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0);
/*
* Scrolled window for list
*/
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (hbox), scrolled, TRUE, TRUE, 0);
gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolled),
GTK_CORNER_TOP_LEFT);
/*
* Color list
*/
wtexture->wgradient [GRADIENT_LIST] = list = gtk_list_new ();
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled), list);
gtk_object_set_user_data (GTK_OBJECT (list), wtexture);
gtk_signal_connect (GTK_OBJECT (list), "button_press_event",
GTK_SIGNAL_FUNC (list_button_press), wtexture);
/*
* List manipulating buttons
*/
{
GtkWidget *bbox;
const char *text [] = {N_("Remove"),
N_("Insert"),
N_("Append")};
const char *info [] = {N_("Remove selected color from "
"gradient color list."),
N_("Insert a new color before current color."),
N_("Append a new color after the last color.")};
void (*fct []) (GtkWidget *, GtkWidget *list) = {list_remove, list_insert,
list_append};
unsigned i;
bbox = gtk_vbutton_box_new ();
{
proplist_t array = get_texture_array (wtexture);
if (!strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "workspaceback") &&
!strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "workspacespecificback") &&
!strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "iconback"))
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox),
GTK_BUTTONBOX_SPREAD);
}
gtk_box_pack_start (GTK_BOX (hbox), bbox, FALSE, FALSE, 0);
for (i = 0; i < 3; i++)
{
GtkWidget *button = gtk_button_new_with_label (_(text [i]));
if (i == 0)
wtexture->wgradient [GRADIENT_REMOVE] = button;
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (fct [i]), list);
gtk_tooltips_set_tip (tooltips, button, _(info [i]), NULL);
}
}
#if defined(PREVIEWS) && !defined(CONVERT)
wtexture->wgradient [GRADIENT_PREVIEW] = NULL;
update_gradient_preview (wtexture);
if (strcaseeq (WMGetFromPLString (wtexture->key), "workspaceback") ||
strcaseeq (WMGetFromPLString (wtexture->key), "workspacespecificback"))
{
GtkWidget *frame = gtk_frame_new (NULL);
GtkWidget *vbox = gtk_vbox_new (TRUE, 0);
GtkWidget *hbox = gtk_hbox_new (TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame),
wtexture->wgradient [GRADIENT_PREVIEW]);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
gtk_table_attach (GTK_TABLE (table), hbox,
0, 1, 2, 3, GTK_SHRINK, GTK_SHRINK, 5, 5);
}
else
gtk_table_attach (GTK_TABLE (table), wtexture->wgradient [GRADIENT_PREVIEW],
0, 1, 2, 3, GTK_SHRINK, GTK_SHRINK, 5, 5);
#endif /* defined(PREVIEWS) && !defined(CONVERT) */
gtk_widget_show_all (frame);
return frame;
}
static void
show_texture_dialog (wtexture_t *wtexture)
/*
* Generate set of visible/hidden widgets for the current texture attribute
*/
{
unsigned n;
char *type = NULL;
texture_e texture = TEXTURE_LAST;
proplist_t array = get_texture_array (wtexture);
if (!WMIsPLArray (array)) /* uups */
{
if (strcaseeq ("workspaceback", WMGetFromPLString (wtexture->key))
&& wtexture->wsnumber > 0)
WMPutInPLDictionary (windowmaker, wtexture->wssback,
array = WMCreatePLArray (NULL));
else
WMPutInPLDictionary (windowmaker, wtexture->key,
array = WMCreatePLArray (NULL));
}
/*
* Check which type of texture is used
*/
if ((n = WMGetPropListItemCount (array)) != 0)
{
type = WMGetFromPLString (WMGetFromPLArray (array, 0));
if (strcaseeq (type + 1, "gradient")
#ifdef HAVE_INTERWOVEN_GRADIENT
&& *type != 'i'
#endif /* HAVE_INTERWOVEN_GRADIENT */
) /* convert to m[hvd]gradient */
{
if (n == 3)
{
GdkColor color1, color2;
char *c1name = WMGetFromPLString (WMGetFromPLArray (array, 1));
char *c2name = WMGetFromPLString (WMGetFromPLArray (array, 2));
/*
* Compute default color = (color1 + color2) / 2
*/
if (!make_color (c1name, &color1))
color1.red = color1.green = color1.blue = 65535; /* white */
if (!make_color (c2name, &color2))
color2.red = color2.green = color2.blue = 65535; /* white */
color1.red = (color1.red + color2.red) >> 1;
color1.green = (color1.green + color2.green) >> 1;
color1.blue = (color1.blue + color2.blue) >> 1;
{
char colstr [MAXSTRLEN];
sprintf (colstr, "#%02x%02x%02x", /* new color */
(unsigned) (color1.red / 256 + 0.5),
(unsigned) (color1.green / 256 + 0.5),
(unsigned) (color1.blue / 256 + 0.5));
WMInsertInPLArray (array, 1, WMCreatePLString (colstr));
}
/*
* Replace gradient by mgradient
*/
{
char *tmp = g_strconcat ("m", type, NULL);
WMDeleteFromPLArray (array, 0);
WMInsertInPLArray (array, 0, WMCreatePLString (tmp));
Free (tmp);
type = WMGetFromPLString (WMGetFromPLArray (array, 0));
}
n++;
}
}
if (strcaseeq (type, "solid"))
texture = n == 2 ? TEXTURE_SOLID : TEXTURE_LAST;
else if (strcaseeq (type, "none"))
texture = TEXTURE_NONE;
#ifdef HAVE_INTERWOVEN_GRADIENT
else if (strcaseeq (type, "igradient"))
texture = n == 7 ? TEXTURE_INTERWOVEN : TEXTURE_LAST;
#endif
else if (strcaseeq (type + 2, "gradient"))
{
if (*type != 'm' && *type != 't')
texture = TEXTURE_LAST;
else
{
if (*type == 't')
texture = n == 5 ? TEXTURE_TGRADIENT : TEXTURE_LAST;
else
texture = n > 3 ? TEXTURE_GRADIENT : TEXTURE_LAST;
if (*(type + 1) != 'v' && *(type + 1) != 'h' && *(type + 1) != 'd')
texture = TEXTURE_LAST;
}
}
else if (strcaseeq (type + 1, "pixmap"))
{
if ((*type != 's' && *type != 't' && *type != 'c' && *type != 'm')
|| (*type == 'm'
&& !strcaseeq ("workspaceback", WMGetFromPLString (wtexture->key))))
texture = TEXTURE_LAST;
else
texture = n == 3 ? TEXTURE_PIXMAP : TEXTURE_LAST;
}
#ifdef HAVE_LIBWMFUN
else if (strcaseeq (type, "function"))
{
texture = TEXTURE_LAST;
if (n >= 3)
{
char *library = WMGetFromPLString (WMGetFromPLArray (array, 1));
char *function = WMGetFromPLString (WMGetFromPLArray (array, 2));
if (strncaseeq (library, "libwmfun", strlen ("libwmfun")))
{
if (strcaseeq (function, "bilinear") && n == 7)
texture = TEXTURE_BILINEAR;
else if (strcaseeq (function, "fade"))
texture = TEXTURE_FADE;
else if (strcaseeq (function, "waves") && n >= 5)
texture = TEXTURE_WAVES;
}
}
}
#endif
}
else if (strcaseeq ("workspaceback", WMGetFromPLString (wtexture->key))) {
if (wtexture->wsnumber)
texture = TEXTURE_DEFAULT;
else /* we're inspecting default texture */
texture = TEXTURE_NONE;
}
/*
* Convert unknown texture types to (solid, black)
*/
if (texture == TEXTURE_LAST)
{
unsigned i;
warning (_("Texture `%s' not yet supported or wrong number "
"of arguments.\nConverting to (solid, black) ..."),
type ? type : "()");
for (i = n; i; i--)
WMDeleteFromPLArray (array, 0);
WMInsertInPLArray (array, 0, WMCreatePLString ("solid"));
WMInsertInPLArray (array, 1, WMCreatePLString ("black"));
texture = TEXTURE_SOLID;
}
/*
* Set texture type option menu to given value
*/
if (strcaseeq ("workspaceback", WMGetFromPLString (wtexture->key)))
{
if (wtexture->wsnumber == 0)
{
gtk_widget_show (wtexture->wwttype);
gtk_widget_hide (wtexture->wttype);
set_option_menu_default (GTK_OPTION_MENU (wtexture->wwttype),
option_t_wspace, ttype_strings [texture]);
}
else
{
gtk_widget_show (wtexture->wttype);
gtk_widget_hide (wtexture->wwttype);
set_option_menu_default (GTK_OPTION_MENU (wtexture->wttype),
option_t_wspecific, ttype_strings [texture]);
}
}
else
{
gtk_widget_show (wtexture->wttype);
set_option_menu_default (GTK_OPTION_MENU (wtexture->wttype),
option_t_normal, ttype_strings [texture]);
}
if (texture == TEXTURE_SOLID)
{
gtk_widget_hide (wtexture->wpixmap [PIXMAP_FRAME]);
gtk_widget_hide (wtexture->wgradient [GRADIENT_FRAME]);
gtk_widget_hide (wtexture->wsgradient [SGRADIENT_FRAME]);
#ifdef HAVE_LIBWMFUN
gtk_widget_hide (wtexture->wbilinear [BILINEAR_FRAME]);
gtk_widget_hide (wtexture->wfade [FADE_FRAME]);
gtk_widget_hide (wtexture->wwaves [WAVES_FRAME]);
#endif
#ifdef HAVE_INTERWOVEN_GRADIENT
gtk_widget_hide (wtexture->winterwoven [INTERWOVEN_FRAME]);
#endif /* HAVE_INTERWOVEN_GRADIENT */
gtk_widget_show (wtexture->wcolorbox);
/*
* Set default color
*/
{
GtkWidget *preview;
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wcolor));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 1)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 1));
}
}
#ifdef HAVE_LIBWMFUN
else if (texture == TEXTURE_BILINEAR)
{
gtk_widget_hide (wtexture->wpixmap [PIXMAP_FRAME]);
gtk_widget_hide (wtexture->wgradient [GRADIENT_FRAME]);
gtk_widget_hide (wtexture->wsgradient [SGRADIENT_FRAME]);
gtk_widget_hide (wtexture->wcolorbox);
gtk_widget_hide (wtexture->wfade [FADE_FRAME]);
gtk_widget_hide (wtexture->wwaves [WAVES_FRAME]);
#ifdef HAVE_INTERWOVEN_GRADIENT
gtk_widget_hide (wtexture->winterwoven [INTERWOVEN_FRAME]);
#endif /* HAVE_INTERWOVEN_GRADIENT */
gtk_widget_show (wtexture->wbilinear [BILINEAR_FRAME]);
/*
* Set colors of bilinear gradient
*/
{
GtkWidget *preview;
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wbilinear [BILINEAR_NW]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 3)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 3));
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wbilinear [BILINEAR_NE]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 4)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 4));
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wbilinear [BILINEAR_SW]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 5)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 5));
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wbilinear [BILINEAR_SE]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 6)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 6));
}
update_wmfun_preview (wtexture, &wtexture->wbilinear [BILINEAR_PREVIEW]);
}
else if (texture == TEXTURE_FADE)
{
gtk_widget_hide (wtexture->wpixmap [PIXMAP_FRAME]);
gtk_widget_hide (wtexture->wgradient [GRADIENT_FRAME]);
gtk_widget_hide (wtexture->wsgradient [SGRADIENT_FRAME]);
gtk_widget_hide (wtexture->wcolorbox);
gtk_widget_hide (wtexture->wwaves [WAVES_FRAME]);
gtk_widget_hide (wtexture->wbilinear [BILINEAR_FRAME]);
#ifdef HAVE_INTERWOVEN_GRADIENT
gtk_widget_hide (wtexture->winterwoven [INTERWOVEN_FRAME]);
#endif /* HAVE_INTERWOVEN_GRADIENT */
gtk_widget_show (wtexture->wfade [FADE_FRAME]);
{
/*
* Let's normalize the parameters to --from value --to value
*/
char *from = g_strdup ("black");
char *to = g_strdup ("white");
unsigned i = 3;
while (i <= n - 2)
{
char *name = WMGetFromPLString (WMGetFromPLArray (array, i++));
char *color = WMGetFromPLString (WMGetFromPLArray (array, i++));
if (streq (name, "--from"))
from = g_strdup (color);
else if (streq (name, "--to"))
to = g_strdup (color);
}
while (WMGetPropListItemCount (array) > 3)
WMDeleteFromPLArray (array, 3);
WMInsertInPLArray (array, 3, WMCreatePLString ("--from"));
WMInsertInPLArray (array, 4, WMCreatePLString (from));
WMInsertInPLArray (array, 5, WMCreatePLString ("--to"));
WMInsertInPLArray (array, 6, WMCreatePLString (to));
g_free (from);
g_free (to);
}
/*
* Set colors of fading gradient
*/
{
GtkWidget *preview;
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wfade [FADE_FROM]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 4)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 4));
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wfade [FADE_TO]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 6)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 6));
}
update_wmfun_preview (wtexture, &wtexture->wfade [FADE_PREVIEW]);
}
else if (texture == TEXTURE_WAVES)
{
gtk_widget_hide (wtexture->wpixmap [PIXMAP_FRAME]);
gtk_widget_hide (wtexture->wgradient [GRADIENT_FRAME]);
gtk_widget_hide (wtexture->wsgradient [SGRADIENT_FRAME]);
gtk_widget_hide (wtexture->wcolorbox);
gtk_widget_hide (wtexture->wfade [FADE_FRAME]);
gtk_widget_hide (wtexture->wbilinear [BILINEAR_FRAME]);
#ifdef HAVE_INTERWOVEN_GRADIENT
gtk_widget_hide (wtexture->winterwoven [INTERWOVEN_FRAME]);
#endif /* HAVE_INTERWOVEN_GRADIENT */
gtk_widget_show (wtexture->wwaves [WAVES_FRAME]);
{
/*
* Let's normalize the parameters to --from value --to value
*/
char *from = g_strdup ("black");
char *to = g_strdup ("white");
unsigned i = 3;
while (i <= n - 4)
{
char *name = WMGetFromPLString (WMGetFromPLArray (array, i++));
char *color = WMGetFromPLString (WMGetFromPLArray (array, i++));
if (streq (name, "--from"))
from = g_strdup (color);
else if (streq (name, "--to"))
to = g_strdup (color);
}
while (WMGetPropListItemCount (array) > 5)
WMDeleteFromPLArray (array, 3);
WMInsertInPLArray (array, 3, WMCreatePLString ("--from"));
WMInsertInPLArray (array, 4, WMCreatePLString (from));
WMInsertInPLArray (array, 5, WMCreatePLString ("--to"));
WMInsertInPLArray (array, 6, WMCreatePLString (to));
g_free (from);
g_free (to);
}
/*
* Set colors of waves gradient
*/
{
GtkWidget *preview;
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wwaves [WAVES_FROM]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 4)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 4));
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wwaves [WAVES_TO]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 6)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 6));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (wtexture->wwaves [WAVES_LAYERS]), strtod (WMGetFromPLString (WMGetFromPLArray (array, 7)), NULL));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (wtexture->wwaves [WAVES_FREQUENCY]), strtod (WMGetFromPLString (WMGetFromPLArray (array, 8)), NULL));
}
update_wmfun_preview (wtexture, &wtexture->wwaves [WAVES_PREVIEW]);
}
#endif
#ifdef HAVE_INTERWOVEN_GRADIENT
else if (texture == TEXTURE_INTERWOVEN)
{
gtk_widget_hide (wtexture->wpixmap [PIXMAP_FRAME]);
gtk_widget_hide (wtexture->wgradient [GRADIENT_FRAME]);
gtk_widget_hide (wtexture->wsgradient [SGRADIENT_FRAME]);
gtk_widget_hide (wtexture->wcolorbox);
#ifdef HAVE_LIBWMFUN
gtk_widget_hide (wtexture->wfade [FADE_FRAME]);
gtk_widget_hide (wtexture->wbilinear [BILINEAR_FRAME]);
gtk_widget_hide (wtexture->wwaves [WAVES_FRAME]);
#endif /* HAVE_LIBWMFUN */
gtk_widget_show (wtexture->winterwoven [INTERWOVEN_FRAME]);
/*
* Set colors of interwoven gradient
*/
{
GtkWidget *preview;
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->winterwoven [INTERWOVEN_FROM_1]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 1)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 1));
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->winterwoven [INTERWOVEN_TO_1]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 2)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 2));
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->winterwoven [INTERWOVEN_FROM_2]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 4)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 4));
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->winterwoven [INTERWOVEN_TO_2]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 5)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 5));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (wtexture->winterwoven [INTERWOVEN_THICKNESS_1]), strtod (WMGetFromPLString (WMGetFromPLArray (array, 3)), NULL));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (wtexture->winterwoven [INTERWOVEN_THICKNESS_2]), strtod (WMGetFromPLString (WMGetFromPLArray (array, 6)), NULL));
}
update_interwoven_preview (wtexture,
&wtexture->winterwoven [INTERWOVEN_PREVIEW]);
}
#endif /* HAVE_INTERWOVEN_GRADIENT */
else if (texture == TEXTURE_NONE || texture == TEXTURE_DEFAULT)
{
#ifdef HAVE_LIBWMFUN
gtk_widget_hide (wtexture->wbilinear [BILINEAR_FRAME]);
gtk_widget_hide (wtexture->wfade [FADE_FRAME]);
gtk_widget_hide (wtexture->wwaves [WAVES_FRAME]);
#endif
#ifdef HAVE_INTERWOVEN_GRADIENT
gtk_widget_hide (wtexture->winterwoven [INTERWOVEN_FRAME]);
#endif /* HAVE_INTERWOVEN_GRADIENT */
gtk_widget_hide (wtexture->wpixmap [PIXMAP_FRAME]);
gtk_widget_hide (wtexture->wgradient [GRADIENT_FRAME]);
gtk_widget_hide (wtexture->wsgradient [SGRADIENT_FRAME]);
gtk_widget_hide (wtexture->wcolorbox);
}
else if (texture == TEXTURE_PIXMAP)
{
#ifdef HAVE_LIBWMFUN
gtk_widget_hide (wtexture->wbilinear [BILINEAR_FRAME]);
gtk_widget_hide (wtexture->wfade [FADE_FRAME]);
gtk_widget_hide (wtexture->wwaves [WAVES_FRAME]);
#endif
#ifdef HAVE_INTERWOVEN_GRADIENT
gtk_widget_hide (wtexture->winterwoven [INTERWOVEN_FRAME]);
#endif /* HAVE_INTERWOVEN_GRADIENT */
gtk_widget_show (wtexture->wpixmap [PIXMAP_FRAME]);
gtk_widget_show (wtexture->wpixmap [PIXMAP_TYPE]);
gtk_widget_hide (wtexture->wgradient [GRADIENT_FRAME]);
gtk_widget_hide (wtexture->wsgradient [SGRADIENT_FRAME]);
gtk_widget_show (wtexture->wcolorbox);
/*
* Set default color
*/
{
GtkWidget *preview;
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wcolor));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 2)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 2));
}
combine_path_and_filename (array, wtexture);
g_signal_handler_block (wtexture->wpixmap [PIXMAP_NAME],
GPOINTER_TO_INT (gtk_object_get_user_data
GTK_OBJECT (wtexture->wpixmap [PIXMAP_NAME])));
gtk_entry_set_text (GTK_ENTRY (wtexture->wpixmap [PIXMAP_NAME]),
WMGetFromPLString (WMGetFromPLArray (array, 1)));
g_signal_handler_unblock (wtexture->wpixmap [PIXMAP_NAME],
GPOINTER_TO_INT (gtk_object_get_user_data
GTK_OBJECT (wtexture->wpixmap [PIXMAP_NAME])));
show_pixmap (KEY_OF_TEXTURE, WMGetFromPLString (WMGetFromPLArray (array, 1)),
wtexture->wpixmap [PIXMAP_PIXMAP]);
/*
* scaled, tiled, centered, maxaspect pixmap
*/
if (strcaseeq ("workspaceback", WMGetFromPLString (wtexture->key)))
{
GtkOptionMenu *opt = GTK_OPTION_MENU (wtexture->wpixmap [PIXMAP_TYPE]);
if (*type == 't')
set_option_menu_default (opt, option_p_wspace,
ptype_strings [PIXMAP_TILED]);
else if (*type == 's')
set_option_menu_default (opt, option_p_wspace,
ptype_strings [PIXMAP_SCALED]);
else
set_option_menu_default (opt, option_p_wspace,
ptype_strings [PIXMAP_CENTERED]);
}
else
{
GtkOptionMenu *opt = GTK_OPTION_MENU (wtexture->wpixmap [PIXMAP_TYPE]);
if (*type == 't')
set_option_menu_default (opt, option_p_normal,
ptype_strings [PIXMAP_TILED]);
else if (*type == 's')
set_option_menu_default (opt, option_p_normal,
ptype_strings [PIXMAP_SCALED]);
else if (*type == 'm')
set_option_menu_default (opt, option_p_normal,
ptype_strings [PIXMAP_MAXASPECT]);
else
set_option_menu_default (opt, option_p_normal,
ptype_strings [PIXMAP_CENTERED]);
}
}
else if (texture == TEXTURE_GRADIENT)
{
#ifdef HAVE_LIBWMFUN
gtk_widget_hide (wtexture->wbilinear [BILINEAR_FRAME]);
gtk_widget_hide (wtexture->wfade [FADE_FRAME]);
gtk_widget_hide (wtexture->wwaves [WAVES_FRAME]);
#endif
#ifdef HAVE_INTERWOVEN_GRADIENT
gtk_widget_hide (wtexture->winterwoven [INTERWOVEN_FRAME]);
#endif /* HAVE_INTERWOVEN_GRADIENT */
gtk_widget_hide (wtexture->wpixmap [PIXMAP_FRAME]);
gtk_widget_show (wtexture->wgradient [GRADIENT_FRAME]);
gtk_widget_hide (wtexture->wsgradient [SGRADIENT_FRAME]);
gtk_widget_show (wtexture->wcolorbox);
/*
* Set default color
*/
{
GtkWidget *preview;
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wcolor));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 1)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 1));
}
/*
* horizontal, vertical, or diagonal gradient
*/
{
GtkOptionMenu *opt;
opt = GTK_OPTION_MENU (wtexture->wgradient [GRADIENT_TYPE]);
if (*(type + 1) == 'h')
set_option_menu_default (opt, option_g,
gtype_strings [GRADIENT_HOR]);
else if (*(type + 1) == 'v')
set_option_menu_default (opt, option_g,
gtype_strings [GRADIENT_VER]);
else
set_option_menu_default (opt, option_g,
gtype_strings [GRADIENT_DIAG]);
}
/*
* gradient colors
*/
{
unsigned i;
GtkWidget *list = wtexture->wgradient [GRADIENT_LIST];
while (g_list_length (GTK_LIST (list)->children))
gtk_list_clear_items (GTK_LIST (list), 0, -1);
for (i = 2; i < n; i++)
gtk_container_add (GTK_CONTAINER (list),
new_list_item (wtexture,
WMGetFromPLArray (array, i)));
gtk_widget_set_sensitive (wtexture->wgradient [GRADIENT_REMOVE], n > 4);
gtk_list_select_item (GTK_LIST (list), 0);
}
update_gradient_preview (wtexture);
}
else if (texture == TEXTURE_TGRADIENT)
{
#ifdef HAVE_LIBWMFUN
gtk_widget_hide (wtexture->wbilinear [BILINEAR_FRAME]);
gtk_widget_hide (wtexture->wfade [FADE_FRAME]);
gtk_widget_hide (wtexture->wwaves [WAVES_FRAME]);
#endif
#ifdef HAVE_INTERWOVEN_GRADIENT
gtk_widget_hide (wtexture->winterwoven [INTERWOVEN_FRAME]);
#endif /* HAVE_INTERWOVEN_GRADIENT */
gtk_widget_show (wtexture->wpixmap [PIXMAP_FRAME]);
gtk_widget_hide (wtexture->wgradient [GRADIENT_FRAME]);
gtk_widget_show (wtexture->wsgradient [SGRADIENT_FRAME]);
gtk_widget_hide (wtexture->wcolorbox);
gtk_widget_hide (wtexture->wpixmap [PIXMAP_TYPE]);
/*
* horizontal, vertical, or diagonal gradient
*/
{
GtkOptionMenu *opt;
opt = GTK_OPTION_MENU (wtexture->wsgradient [SGRADIENT_TYPE]);
if (*(type + 1) == 'h')
set_option_menu_default (opt, option_g,
gtype_strings [GRADIENT_HOR]);
else if (*(type + 1) == 'v')
set_option_menu_default (opt, option_g,
gtype_strings [GRADIENT_VER]);
else
set_option_menu_default (opt, option_g,
gtype_strings [GRADIENT_DIAG]);
}
combine_path_and_filename (array, wtexture);
g_signal_handler_block (wtexture->wpixmap [PIXMAP_NAME],
GPOINTER_TO_INT (gtk_object_get_user_data
GTK_OBJECT (wtexture->wpixmap [PIXMAP_NAME])));
gtk_entry_set_text (GTK_ENTRY (wtexture->wpixmap [PIXMAP_NAME]),
WMGetFromPLString (WMGetFromPLArray (array, 1)));
g_signal_handler_unblock (wtexture->wpixmap [PIXMAP_NAME],
GPOINTER_TO_INT (gtk_object_get_user_data
GTK_OBJECT (wtexture->wpixmap [PIXMAP_NAME])));
show_pixmap (KEY_OF_TEXTURE, WMGetFromPLString (WMGetFromPLArray (array, 1)),
wtexture->wpixmap [PIXMAP_PIXMAP]);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (wtexture->wsgradient [SGRADIENT_SPINNER]), strtod (WMGetFromPLString (WMGetFromPLArray (array, 2)), NULL));
{
GtkWidget *preview;
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wsgradient [SGRADIENT_COLOR1]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 3)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 3));
preview = gtk_object_get_user_data (GTK_OBJECT (wtexture->wsgradient [SGRADIENT_COLOR2]));
fill_preview (GTK_PREVIEW (preview),
WMGetFromPLString (WMGetFromPLArray (array, 4)));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, 4));
}
}
}
static void
update_gradient_preview (wtexture_t *wtexture)
{
proplist_t array = get_texture_array (wtexture);
proplist_t ttype = WMGetFromPLArray (array, 0);
char *type;
if (ttype)
type = WMGetFromPLString (ttype);
#if defined(PREVIEWS) && !defined(CONVERT)
{
gtype_e gtype;
unsigned width, height;
if (!ttype || *(type + 1) == 'h')
gtype = HGRADIENT;
else if (*(type + 1) == 'v')
gtype = VGRADIENT;
else
gtype = DGRADIENT;
if (strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "iconback"))
width = height = 64;
else if (strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "workspaceback") ||
strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "workspacespecificback"))
{
width = 160;
height = 160 * 3 / 4;
}
else
{
width = 180;
height = 22;
}
wtexture->wgradient [GRADIENT_PREVIEW]
= make_gradient (array, width, height, gtype,
wtexture->wgradient [GRADIENT_PREVIEW]);
}
#endif /* defined(PREVIEWS) && !defined(CONVERT) */
}
#ifdef HAVE_LIBWMFUN
static void
update_wmfun_preview (wtexture_t *wtexture, GtkWidget **preview)
{
proplist_t array = get_texture_array (wtexture);
#if defined(PREVIEWS) && !defined(CONVERT)
{
unsigned width, height;
if (strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "iconback"))
width = height = 64;
else if (strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "workspaceback") ||
strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "workspacespecificback"))
{
width = 180;
height = 180 * 3 / 4;
}
else
{
width = 180;
height = 22;
}
*preview = make_wmfun (array, width, height, *preview);
}
#endif /* defined(PREVIEWS) && !defined(CONVERT) */
}
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
static void
update_interwoven_preview (wtexture_t *wtexture, GtkWidget **preview)
{
proplist_t array = get_texture_array (wtexture);
#if defined(PREVIEWS) && !defined(CONVERT)
{
unsigned width, height;
if (strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "iconback"))
width = height = 64;
else if (strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "workspaceback") ||
strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "workspacespecificback"))
{
width = 180;
height = 180 * 3 / 4;
}
else
{
width = 180;
height = 22;
}
*preview = make_igradient (array, width, height, *preview);
}
#endif /* defined(PREVIEWS) && !defined(CONVERT) */
}
#endif /* HAVE_INTERWOVEN_GRADIENT */
static void
combine_path_and_filename (proplist_t array, wtexture_t *wtexture)
/*
* Set pixmap and filename
*/
{
if (wtexture->path)
{
char *tmp = g_strconcat (wtexture->path, "/",
WMGetFromPLString (WMGetFromPLArray (array, 1)), NULL);
char *test = get_pixmap_path (tmp);
if (test)
{
WMDeleteFromPLArray (array, 1);
WMInsertInPLArray (array, 1, WMCreatePLString (tmp));
Free (test);
}
Free (tmp);
wtexture->path = NULL;
}
}
static void
color_selection_dialog (GtkWidget *widget, proplist_t key)
/*
* Generate a color selection popup window.
* associated user data of 'widget' must be a pointer to corresponding preview.
* 'key' is the associated wmaker attribute name
*
* No return value.
*/
{
GdkColor color;
GtkWidget *preview = gtk_object_get_user_data (GTK_OBJECT (widget));
proplist_t value = gtk_object_get_user_data (GTK_OBJECT (preview));
GtkColorSelection *cs;
GtkColorSelectionDialog *dialog;
gdouble *rgb = Calloc (4, sizeof (gdouble));
GtkWidget *window = NULL;
gtk_preview_set_install_cmap (TRUE);
gtk_widget_push_visual (gtk_preview_get_visual ());
gtk_widget_push_colormap (gtk_preview_get_cmap ());
window = gtk_color_selection_dialog_new (_("Color selection"));
dialog = GTK_COLOR_SELECTION_DIALOG (window);
cs = GTK_COLOR_SELECTION (dialog->colorsel);
gtk_widget_hide (dialog->help_button);
gtk_object_set_data (GTK_OBJECT (cs), "key", key);
gtk_object_set_data (GTK_OBJECT (cs), "old-color", rgb);
gtk_object_set_user_data (GTK_OBJECT (cs), preview);
if (!make_color (WMGetFromPLString (value), &color))
color.red = color.green = color.blue = 65530;
rgb [0] = color.red / 65535.0;
rgb [1] = color.green / 65535.0;
rgb [2] = color.blue / 65535.0;
gtk_color_selection_set_color (cs, rgb);
gtk_color_selection_get_color (cs, rgb);
gtk_color_selection_set_color (cs, rgb);
gtk_color_selection_set_has_opacity_control (cs, FALSE);
gtk_color_selection_set_update_policy (cs, GTK_UPDATE_CONTINUOUS);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
gtk_signal_connect_object (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
gtk_signal_connect (GTK_OBJECT (cs), "color_changed",
GTK_SIGNAL_FUNC (color_selection_ok), cs);
gtk_signal_connect_object (GTK_OBJECT (dialog->ok_button),
"clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
gtk_signal_connect (GTK_OBJECT (dialog->cancel_button),
"clicked", GTK_SIGNAL_FUNC (color_selection_cancel), cs);
gtk_signal_connect_object_after (GTK_OBJECT (dialog->cancel_button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
gtk_widget_pop_colormap ();
gtk_widget_pop_visual ();
gtk_widget_show (window);
}
static void
color_selection_cancel (GtkWidget *w, GtkColorSelection *colorsel)
/*
* Restore old color
*/
{
gdouble *color = gtk_object_get_data (GTK_OBJECT (colorsel), "old-color");
gtk_signal_disconnect_by_func (GTK_OBJECT (colorsel),
GTK_SIGNAL_FUNC (color_selection_ok),
colorsel);
gtk_color_selection_set_color (colorsel, color);
color_selection_ok (w, colorsel);
}
static void
color_selection_ok (GtkWidget *w, GtkColorSelection *colorsel)
/*
* Replace old color with new one.
*
* No return value.
*
* Side effects:
* value of wmaker attribute w->key is modified.
* corresponding preview color update
*/
{
gdouble color [4];
proplist_t key = gtk_object_get_data (GTK_OBJECT (colorsel), "key");
GtkPreview *preview = gtk_object_get_user_data (GTK_OBJECT (colorsel));
proplist_t value = gtk_object_get_user_data (GTK_OBJECT (preview));
gtk_color_selection_get_color (colorsel, color);
{
char tmp [MAXSTRLEN];
sprintf (tmp, "#%02x%02x%02x", /* new color */
(unsigned) (color [0] * 255 + 0.5),
(unsigned) (color [1] * 255 + 0.5),
(unsigned) (color [2] * 255 + 0.5));
{
wtexture_t *wtexture = gtk_object_get_data (GTK_OBJECT (preview),
"wtexture");
if (wtexture) /* texture */
{
unsigned i;
proplist_t array = get_texture_array (wtexture);
char *type = WMGetFromPLString (WMGetFromPLArray (array, 0));
for (i = 1; i < WMGetPropListItemCount (array); i++)
if (WMGetFromPLArray (array, i) == value)
{
WMDeleteFromPLArray (array, i);
WMInsertInPLArray (array, i, WMCreatePLString (tmp));
gtk_object_set_user_data (GTK_OBJECT (preview),
WMGetFromPLArray (array, i));
fill_preview (preview, tmp);
toggle_save (changed = YES, KEY_OF_TEXTURE);
break;
}
if (tolower (*type) == 't')
show_pixmap (KEY_OF_TEXTURE,
WMGetFromPLString (WMGetFromPLArray (array, 1)),
wtexture->wpixmap [PIXMAP_PIXMAP]);
#ifdef HAVE_LIBWMFUN
else if (strcaseeq (type, "function"))
{
char *function = WMGetFromPLString (WMGetFromPLArray (array, 2));
if (function && strcaseeq (function, "bilinear"))
update_wmfun_preview (wtexture,
&wtexture->wbilinear [BILINEAR_PREVIEW]);
else if (function && strcaseeq (function, "fade"))
update_wmfun_preview (wtexture,
&wtexture->wfade [FADE_PREVIEW]);
else if (function && strcaseeq (function, "waves"))
update_wmfun_preview (wtexture,
&wtexture->wwaves [WAVES_PREVIEW]);
}
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
else if (strcaseeq (type, "igradient"))
update_interwoven_preview (wtexture, &wtexture->winterwoven [INTERWOVEN_PREVIEW]);
#endif /* HAVE_INTERWOVEN_GRADIENT */
else
update_gradient_preview (wtexture);
}
else /* color attribute */
{
proplist_t array = WMGetFromPLDictionary (windowmaker, key);
proplist_t plval = WMCreatePLString (tmp);
gtk_object_set_user_data (GTK_OBJECT (preview), plval);
fill_preview (preview, tmp);
toggle_save (changed = YES, key);
if (WMIsPLString (array))
WMPutInPLDictionary (windowmaker, key, plval);
else
{
unsigned i;
for (i = 0; i < WMGetPropListItemCount (array); i++)
if (WMGetFromPLArray (array, i) == value)
{
WMDeleteFromPLArray (array, i);
WMInsertInPLArray (array, i, plval);
break;
}
}
}
}
}
}
static proplist_t
get_texture_array (wtexture_t *wtexture)
{
proplist_t array;
if (strcaseeq ("workspaceback", WMGetFromPLString (wtexture->key))
&& wtexture->wsnumber > 0)
{
proplist_t subarray;
array = WMGetFromPLDictionary (windowmaker, wtexture->wssback);
if (!array || !WMIsPLArray (array))
{
if (array)
WMReleasePropList (array);
array = WMCreatePLArray (NULL);
WMPutInPLDictionary (windowmaker, wtexture->wssback, array);
}
while (WMGetPropListItemCount (array) < wtexture->wsnumber)
{
WMAddToPLArray (array, WMCreatePLArray (NULL));
toggle_save (changed = YES, wtexture->wssback);
}
subarray = WMGetFromPLArray (array, wtexture->wsnumber - 1);
if (!subarray || !WMIsPLArray (subarray))
{
if (subarray)
WMReleasePropList (subarray);
subarray = WMCreatePLArray (NULL);
WMInsertInPLArray (array, wtexture->wsnumber - 1, subarray);
}
array = subarray;
}
else
{
array = WMGetFromPLDictionary (windowmaker, wtexture->key);
if (!array || !WMIsPLArray (array))
{
if (array)
WMReleasePropList (array);
array = WMCreatePLArray (WMCreatePLString ("solid"),
WMCreatePLString ("black"),
NULL);
WMPutInPLDictionary (windowmaker, wtexture->key, array);
}
}
return array;
}
static void
gradient_type_toggle (GtkWidget *widget, gpointer ptr)
/*
* Toggle gradient type (horizontal, vertical, diagonal).
*
* Side effects:
* Window Maker attribute is updated
*/
{
const char *text = gtk_object_get_user_data (GTK_OBJECT (widget));
wtexture_t *wtexture = (wtexture_t *) ptr;
proplist_t array = get_texture_array (wtexture);
const char *type = WMGetFromPLString (WMGetFromPLArray (array, 0));
if (strcaseeq (type + 2, "gradient")
&&
((tolower (*(type + 1)) == 'h'
&& !streq (text, gtype_strings [GRADIENT_HOR]))
|| (tolower (*(type + 1)) == 'v'
&& !streq (text, gtype_strings [GRADIENT_VER]))
|| (tolower (*(type + 1)) == 'd'
&& !streq (text, gtype_strings [GRADIENT_DIAG]))))
{
char *tmp = g_strdup (type);
if (streq (text, gtype_strings [GRADIENT_HOR]))
*(tmp + 1) = 'h';
else if (streq (text, gtype_strings [GRADIENT_VER]))
*(tmp + 1) = 'v';
else
*(tmp + 1) = 'd';
WMDeleteFromPLArray (array, 0);
WMInsertInPLArray (array, 0, WMCreatePLString (tmp));
Free (tmp);
toggle_save (changed = YES, KEY_OF_TEXTURE);
if (tolower (*type) == 't')
show_pixmap (KEY_OF_TEXTURE, WMGetFromPLString (WMGetFromPLArray (array, 1)),
wtexture->wpixmap [PIXMAP_PIXMAP]);
else
update_gradient_preview (wtexture);
}
}
static void
pixmap_type_toggle (GtkWidget *widget, gpointer ptr)
/*
* Toggle pixmap type (scaled, tiled, centered, maxaspect).
*
* Side effects:
* Window Maker attribute is updated
*/
{
const char *text = gtk_object_get_user_data (GTK_OBJECT (widget));
wtexture_t *wtexture = (wtexture_t *) ptr;
proplist_t array = get_texture_array (wtexture);
const char *type = WMGetFromPLString (WMGetFromPLArray (array, 0));
if (strcaseeq (type + 1, "pixmap")
&&
((tolower (*type) == 's'
&& !streq (text, ptype_strings [PIXMAP_SCALED]))
|| (tolower (*type) == 't'
&& !streq (text, ptype_strings [PIXMAP_TILED]))
|| (tolower (*type) == 'm'
&& !streq (text, ptype_strings [PIXMAP_MAXASPECT]))
|| (tolower (*type) == 'c'
&& !streq (text, ptype_strings [PIXMAP_CENTERED]))))
{
char *tmp = g_strdup (type);
if (streq (text, ptype_strings [PIXMAP_SCALED]))
*tmp = 's';
else if (streq (text, ptype_strings [PIXMAP_TILED]))
*tmp = 't';
else if (streq (text, ptype_strings [PIXMAP_MAXASPECT]))
*tmp = 'm';
else
*tmp = 'c';
WMDeleteFromPLArray (array, 0);
WMInsertInPLArray (array, 0, WMCreatePLString (tmp));
Free (tmp);
toggle_save (changed = YES, KEY_OF_TEXTURE);
}
}
static void
texture_type_toggle (GtkWidget *widget, gpointer ptr)
/*
* Toggle texture type (solid, pixmap, gradient, textured gradient).
*
* Side effects:
* Window Maker attribute is updated
*/
{
const char *text = gtk_object_get_user_data (GTK_OBJECT (widget));
wtexture_t *wtexture = (wtexture_t *) ptr;
proplist_t array = get_texture_array (wtexture);
unsigned n = WMGetPropListItemCount (array) > 0;
const char *type = n
? WMGetFromPLString (WMGetFromPLArray (array, 0)) : NULL;
#ifdef HAVE_LIBWMFUN
const char *library = n > 2
? WMGetFromPLString (WMGetFromPLArray (array, 1)) : NULL;
const char *function = n > 2
? WMGetFromPLString (WMGetFromPLArray (array, 2)) : NULL;
#endif
if ((type == NULL && !streq (text, ttype_strings [TEXTURE_DEFAULT]))
|| (type
&& (!((strcaseeq (type + 1, "pixmap")
&& streq (text, ttype_strings [TEXTURE_PIXMAP]))
|| (strcaseeq (type, "solid")
&& streq (text, ttype_strings [TEXTURE_SOLID]))
#ifdef HAVE_LIBWMFUN
|| (library && function && strcaseeq (type, "function") &&
strncaseeq (library, "libwmfun", strlen ("libwmfun")) &&
((strcaseeq (function, "bilinear")
&& streq (text, ttype_strings [TEXTURE_BILINEAR])) ||
(strcaseeq (function, "fade")
&& streq (text, ttype_strings [TEXTURE_FADE])) ||
(strcaseeq (function, "waves")
&& streq (text, ttype_strings [TEXTURE_WAVES]))))
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
|| (strcaseeq (type, "igradient")
&& streq (text, ttype_strings [TEXTURE_INTERWOVEN]))
#endif /* HAVE_INTERWOVEN_GRADIENT */
|| (strcaseeq (type + 2, "gradient") && tolower (*type) == 'm'
&& streq (text, ttype_strings [TEXTURE_GRADIENT]))
|| (strcaseeq (type + 2, "gradient") && tolower (*type) == 't'
&& streq (text, ttype_strings [TEXTURE_TGRADIENT]))
|| (strcaseeq (type, "none")
&& streq (text, ttype_strings [TEXTURE_NONE]))))))
{
unsigned n;
for (n = WMGetPropListItemCount (array); n; n--)
WMDeleteFromPLArray (array, 0); /* clear array */
if (streq (text, ttype_strings [TEXTURE_SOLID]))
{
WMInsertInPLArray (array, 0, WMCreatePLString ("solid"));
WMInsertInPLArray (array, 1, WMCreatePLString ("white"));
}
else if (streq (text, ttype_strings [TEXTURE_NONE]))
{
WMInsertInPLArray (array, 0, WMCreatePLString ("none"));
}
else if (streq (text, ttype_strings [TEXTURE_PIXMAP]))
{
WMInsertInPLArray (array, 0, WMCreatePLString ("spixmap"));
WMInsertInPLArray (array, 1,
WMCreatePLString (PKGDATADIR "/black.xpm"));
WMInsertInPLArray (array, 2, WMCreatePLString ("white"));
}
else if (streq (text, ttype_strings [TEXTURE_GRADIENT]))
{
WMInsertInPLArray (array, 0, WMCreatePLString ("mhgradient"));
WMInsertInPLArray (array, 1, WMCreatePLString ("blue"));
WMInsertInPLArray (array, 2, WMCreatePLString ("yellow"));
WMInsertInPLArray (array, 3, WMCreatePLString ("blue"));
}
#ifdef HAVE_LIBWMFUN
else if (streq (text, ttype_strings [TEXTURE_BILINEAR]))
{
WMInsertInPLArray (array, 0, WMCreatePLString ("function"));
WMInsertInPLArray (array, 1, WMCreatePLString ("libwmfun.so"));
WMInsertInPLArray (array, 2, WMCreatePLString ("bilinear"));
WMInsertInPLArray (array, 3, WMCreatePLString ("black"));
WMInsertInPLArray (array, 4, WMCreatePLString ("yellow"));
WMInsertInPLArray (array, 5, WMCreatePLString ("white"));
WMInsertInPLArray (array, 6, WMCreatePLString ("red"));
}
else if (streq (text, ttype_strings [TEXTURE_FADE]))
{
WMInsertInPLArray (array, 0, WMCreatePLString ("function"));
WMInsertInPLArray (array, 1, WMCreatePLString ("libwmfun.so"));
WMInsertInPLArray (array, 2, WMCreatePLString ("fade"));
WMInsertInPLArray (array, 3, WMCreatePLString ("--from"));
WMInsertInPLArray (array, 4, WMCreatePLString ("black"));
WMInsertInPLArray (array, 5, WMCreatePLString ("--to"));
WMInsertInPLArray (array, 6, WMCreatePLString ("white"));
}
else if (streq (text, ttype_strings [TEXTURE_WAVES]))
{
WMInsertInPLArray (array, 0, WMCreatePLString ("function"));
WMInsertInPLArray (array, 1, WMCreatePLString ("libwmfun.so"));
WMInsertInPLArray (array, 2, WMCreatePLString ("waves"));
WMInsertInPLArray (array, 3, WMCreatePLString ("--from"));
WMInsertInPLArray (array, 4, WMCreatePLString ("black"));
WMInsertInPLArray (array, 5, WMCreatePLString ("--to"));
WMInsertInPLArray (array, 6, WMCreatePLString ("white"));
WMInsertInPLArray (array, 7, WMCreatePLString ("5"));
WMInsertInPLArray (array, 8, WMCreatePLString ("7"));
}
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
else if (streq (text, ttype_strings [TEXTURE_INTERWOVEN]))
{
WMInsertInPLArray (array, 0, WMCreatePLString ("igradient"));
WMInsertInPLArray (array, 1, WMCreatePLString ("black"));
WMInsertInPLArray (array, 2, WMCreatePLString ("yellow"));
WMInsertInPLArray (array, 3, WMCreatePLString ("1"));
WMInsertInPLArray (array, 4, WMCreatePLString ("white"));
WMInsertInPLArray (array, 5, WMCreatePLString ("red"));
WMInsertInPLArray (array, 6, WMCreatePLString ("1"));
}
#endif /* HAVE_INTERWOVEN_GRADIENT */
else if (streq (text, ttype_strings [TEXTURE_TGRADIENT]))
{
WMInsertInPLArray (array, 0, WMCreatePLString ("thgradient"));
WMInsertInPLArray (array, 1,
WMCreatePLString (PKGDATADIR "/black.xpm"));
WMInsertInPLArray (array, 2, WMCreatePLString ("128"));
WMInsertInPLArray (array, 3, WMCreatePLString ("yellow"));
WMInsertInPLArray (array, 4, WMCreatePLString ("blue"));
} /* nothing to do for () */
show_texture_dialog (wtexture);
toggle_save (changed = YES, KEY_OF_TEXTURE);
}
}
static void
workspace_toggle (GtkWidget *widget, gpointer ptr)
/*
* Toggle workspace name.
*/
{
wtexture_t *wtexture = (wtexture_t *) ptr;
char *text = gtk_object_get_user_data (GTK_OBJECT (widget));
for (wtexture->wsnumber = 0;
workspace_names [wtexture->wsnumber];
wtexture->wsnumber++)
if (streq (workspace_names [wtexture->wsnumber], text))
break;
wsnumber = wtexture->wsnumber;
show_texture_dialog (wtexture);
}
static void
set_opacity (GtkWidget *widget, gpointer ptr)
/*
* Set opacity.
*
* Side effects:
* Window Maker attribute is updated
*/
{
char *value;
wtexture_t *wtexture = (wtexture_t *) ptr;
proplist_t array = get_texture_array (wtexture);
value = g_strdup (gtk_entry_get_text (GTK_ENTRY (widget)));
WMDeleteFromPLArray (array, 2);
WMInsertInPLArray (array, 2, WMCreatePLString (value));
toggle_save (changed = YES, KEY_OF_TEXTURE);
show_pixmap (KEY_OF_TEXTURE,
WMGetFromPLString (WMGetFromPLArray (array, 1)),
wtexture->wpixmap [PIXMAP_PIXMAP]);
}
static void
file_selection (GtkWidget *widget, wtexture_t *wtexture)
/*
* Show pixmap file selection popup window.
*
* No return value.
*/
{
static GtkWidget *filesel = NULL;
if (!filesel)
{
GtkFileSelection *fs;
/*
* Fileselection dialog window
*/
filesel = gtk_file_selection_new (_("Pixmap file browser"));
fs = GTK_FILE_SELECTION (filesel);
gtk_file_selection_hide_fileop_buttons (fs);
gtk_window_set_position (GTK_WINDOW (filesel), GTK_WIN_POS_MOUSE);
gtk_object_set_user_data (GTK_OBJECT (fs), wtexture);
gtk_signal_connect (GTK_OBJECT (filesel), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&filesel);
gtk_signal_connect (GTK_OBJECT (fs->ok_button), "clicked",
GTK_SIGNAL_FUNC (set_pixmap),
(gpointer) filesel);
gtk_signal_connect_object (GTK_OBJECT (fs->cancel_button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (filesel));
gtk_signal_connect_object (GTK_OBJECT (fs->ok_button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (filesel));
/*
* Initial filename and pixmap display window
*/
{
proplist_t array = get_texture_array (wtexture);
char *filename;
filename = get_pixmap_path (WMGetFromPLString (WMGetFromPLArray (array, 1)));
if (filename)
gtk_file_selection_set_filename (fs, filename);
/*
* Display of pixmap
*/
{
GtkWidget *vbox = gtk_vbox_new (TRUE, 0);
GtkWidget *hbox = gtk_hbox_new (TRUE, 0);
GtkWidget *pixmap = show_pixmap (KEY_OF_TEXTURE,
filename
? filename
: PKGDATADIR "/black.xpm", NULL);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
if (strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "iconback")
|| strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "workspaceback")
|| strcaseeq (WMGetFromPLString (KEY_OF_TEXTURE), "workspacespecificback"))
{
GtkWidget *frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame), pixmap);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
}
else
{
gtk_box_pack_start (GTK_BOX (vbox), pixmap, FALSE, FALSE, 0);
}
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
{
GtkWidget *parent = fs->dir_list;
while (parent && !GTK_IS_BOX (parent))
parent = parent->parent;
gtk_box_pack_start (GTK_BOX (parent ? parent : fs->main_vbox),
hbox, FALSE, FALSE, 10);
}
gtk_signal_connect (GTK_OBJECT (fs->selection_entry), "changed",
GTK_SIGNAL_FUNC (update_pixmap), fs);
gtk_object_set_data (GTK_OBJECT (fs), "preview", pixmap);
gtk_widget_show_all (hbox);
}
if (filename)
Free (filename);
}
/*
* Optionmenu pixmap path
*/
{
const char **pathlist;
unsigned n;
GtkWidget *box;
GtkWidget **wpixmap;
proplist_t plpath = WMCreatePLString ("PixmapPath");
proplist_t pixmap_path = WMGetFromPLDictionary (windowmaker, plpath);
proplist_t pltitle = WMCreatePLString ("Title");
proplist_t plinfo = WMCreatePLString ("Info");
proplist_t keydef = WMGetFromPLDictionary (wmconfig, plpath);
proplist_t title_text = WMGetFromPLDictionary (keydef, pltitle);
proplist_t info_text = WMGetFromPLDictionary (keydef, plinfo);
WMReleasePropList (plpath);
WMReleasePropList (plinfo);
WMReleasePropList (pltitle);
wpixmap = gtk_object_get_user_data (GTK_OBJECT (widget));
pathlist = Calloc (WMGetPropListItemCount (pixmap_path) + 1,
sizeof (char *));
for (n = 0; n < WMGetPropListItemCount (pixmap_path); n++)
pathlist [n] = WMGetFromPLString (WMGetFromPLArray (pixmap_path, n));
pathlist [n] = NULL;
box = generate_option_menu (D_(WMGetFromPLString (title_text)), tooltips,
D_(WMGetFromPLString (info_text)),
pathlist, pathlist [0], NULL,
change_path, filesel);
gtk_box_pack_start (GTK_BOX (fs->main_vbox), box, FALSE, TRUE, 5);
Free (pathlist);
}
}
if (!GTK_WIDGET_VISIBLE (filesel))
gtk_widget_show (filesel);
else
gtk_widget_destroy (filesel);
}
static void
update_pixmap (GtkWidget *widget, GtkFileSelection *fs)
{
const char *path = gtk_file_selection_get_filename (fs);
wtexture_t *wtexture = gtk_object_get_user_data (GTK_OBJECT (fs));
GtkWidget *pixmap = gtk_object_get_data (GTK_OBJECT (fs), "preview");
char *filename;
if (!strlen (path) || (strlen (path) && path [strlen (path) - 1] == '/'))
return;
filename = get_pixmap_path (path);
if (filename)
{
proplist_t array = get_texture_array (wtexture);
show_pixmap (KEY_OF_TEXTURE, filename, pixmap);
Free (filename);
}
}
static void
change_path (GtkWidget *widget, gpointer filesel)
/*
* Change current path of fileselection dialog 'filesel'.
* 'path' is given by user data of the option menu 'widget'.
*
* No return value.
*/
{
const char *path = gtk_object_get_user_data (GTK_OBJECT (widget));
if (strlen (path) && path [strlen (path) - 1] != '/') /* append a slash */
{
char *tmp = g_strconcat (path, "/", NULL);
gtk_file_selection_set_filename (GTK_FILE_SELECTION (filesel), tmp);
Free (tmp);
}
else
gtk_file_selection_set_filename (GTK_FILE_SELECTION (filesel), path);
}
static void
set_pixmap (GtkWidget *widget, gpointer filesel)
/*
* Set pixmap name of texture.
*
* No return value.
*
* Side effects:
* value of wmaker array element 1 of attribute wtexture->key is modified.
* update of filename entry and pixmap
*
*/
{
const char *filename;
GtkFileSelection *fs = GTK_FILE_SELECTION (filesel);
wtexture_t *wtexture = gtk_object_get_user_data (GTK_OBJECT (fs));
const char *path = gtk_file_selection_get_filename (fs);
if ((filename = strrchr (path, '/'))) /* remove path components */
filename++;
else
filename = path;
/*
* Check if pixmap is in PixmapPath
*/
{
char *tmp = get_pixmap_path (filename);
if (!tmp) /* pixmap not found in PixmapPath */
filename = path;
else
Free (tmp);
}
{
proplist_t array = get_texture_array (wtexture);
WMDeleteFromPLArray (array, 1);
WMInsertInPLArray (array, 1, WMCreatePLString ((char *) filename));
show_pixmap (KEY_OF_TEXTURE, filename, wtexture->wpixmap [PIXMAP_PIXMAP]);
g_signal_handler_block (wtexture->wpixmap [PIXMAP_NAME],
GPOINTER_TO_INT (gtk_object_get_user_data
GTK_OBJECT (wtexture->wpixmap [PIXMAP_NAME])));
gtk_entry_set_text (GTK_ENTRY (wtexture->wpixmap [PIXMAP_NAME]),filename);
g_signal_handler_unblock (wtexture->wpixmap [PIXMAP_NAME],
GPOINTER_TO_INT (gtk_object_get_user_data
GTK_OBJECT (wtexture->wpixmap [PIXMAP_NAME])));
toggle_save (changed = YES, KEY_OF_TEXTURE);
}
}
static GtkWidget *
new_list_item (wtexture_t *wtexture, proplist_t color)
/*
* Allocate new color cell in color list.
*
* Return value:
* list item
*/
{
GtkWidget *list_item;
GtkWidget *preview;
GtkWidget *lhbox;
list_item = gtk_list_item_new ();
gtk_widget_show (list_item);
gtk_container_set_border_width (GTK_CONTAINER (list_item), 2);
lhbox = gtk_hbox_new (TRUE, 0);
gtk_widget_show (lhbox);
gtk_container_add (GTK_CONTAINER (list_item), lhbox);
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_object_set_data (GTK_OBJECT (preview), "wtexture", wtexture);
gtk_preview_size (GTK_PREVIEW (preview), 30, 15);
gtk_box_pack_start (GTK_BOX (lhbox), preview, FALSE, TRUE, 5);
gtk_widget_show (preview);
fill_preview (GTK_PREVIEW (preview), WMGetFromPLString (color));
gtk_object_set_user_data (GTK_OBJECT (list_item), preview);
gtk_object_set_user_data (GTK_OBJECT (preview), color);
return list_item;
}
static char *last_color = NULL; /* save last color name */
static void
color_right_button (GtkWidget *dummy, gpointer ptr)
{
color_selection_dialog ((GTK_LIST (ptr)->selection)->data,
gtk_object_get_user_data (GTK_OBJECT (ptr)));
}
static gint
list_button_press (GtkWidget *widget, GdkEventButton *event, gpointer ptr)
{
if (event->type == GDK_2BUTTON_PRESS)
color_selection_dialog ((GTK_LIST (widget)->selection)->data,
gtk_object_get_user_data (GTK_OBJECT (widget)));
else if (event->button == 3)
{
static GtkWidget *menu = NULL;
GtkWidget *menu_item;
static GtkWidget *remove_item = NULL;
if (!menu)
{
menu = gtk_menu_new ();
menu_item = gtk_menu_item_new_with_label (_("Change"));
gtk_menu_append (GTK_MENU (menu), menu_item);
gtk_widget_show (menu_item);
gtk_signal_connect (GTK_OBJECT(menu_item), "activate",
GTK_SIGNAL_FUNC (color_right_button), widget);
remove_item = menu_item = gtk_menu_item_new_with_label (_("Remove"));
gtk_menu_append (GTK_MENU (menu), menu_item);
gtk_widget_show (menu_item);
gtk_signal_connect (GTK_OBJECT(menu_item), "activate",
GTK_SIGNAL_FUNC (list_remove), widget);
menu_item = gtk_menu_item_new_with_label (_("Insert"));
gtk_menu_append (GTK_MENU (menu), menu_item);
gtk_widget_show (menu_item);
gtk_signal_connect (GTK_OBJECT(menu_item), "activate",
GTK_SIGNAL_FUNC (list_insert), widget);
menu_item = gtk_menu_item_new_with_label (_("Append"));
gtk_menu_append (GTK_MENU (menu), menu_item);
gtk_widget_show (menu_item);
gtk_signal_connect (GTK_OBJECT(menu_item), "activate",
GTK_SIGNAL_FUNC (list_append), widget);
}
gtk_widget_set_sensitive (remove_item,
g_list_length (GTK_LIST (widget)->children) > 2);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 3, event->time);
}
return TRUE;
}
static void
list_insert (GtkWidget *widget, GtkWidget *list)
/*
* Insert new color cell before current position.
*
* No return value.
*
* Side effects:
* new element is inserted in wmaker array attribute wtexture->key
*/
{
GtkWidget *list_item;
int position;
wtexture_t *wtexture = gtk_object_get_user_data (GTK_OBJECT (list));
proplist_t array = get_texture_array (wtexture);
proplist_t element = WMCreatePLString (last_color?last_color:g_strdup ("black"));
position = gtk_list_child_position (GTK_LIST (list),
(GTK_LIST (list)->selection)->data);
WMInsertInPLArray (array, position + 2, element);
list_item = new_list_item (wtexture, element);
/*
* Insert list item at selection
*/
{
GList *gl = Calloc (1, sizeof (GList));
gl->next = gl->prev = NULL;
gl->data = list_item;
gtk_list_insert_items (GTK_LIST (list), gl, position);
}
if (g_list_length (GTK_LIST (list)->children) > 2)
gtk_widget_set_sensitive (wtexture->wgradient [GRADIENT_REMOVE], TRUE);
else
gtk_widget_set_sensitive (wtexture->wgradient [GRADIENT_REMOVE], FALSE);
gtk_list_select_item (GTK_LIST (list), position);
list_change (widget, list);
toggle_save (changed = YES, KEY_OF_TEXTURE);
update_gradient_preview (wtexture);
}
static void
list_append (GtkWidget *widget, GtkWidget *list)
/*
* Append new color cell after last position.
*
* No return value.
*
* Side effects:
* new element is inserted in wmaker array attribute wtexture->key
*/
{
wtexture_t *wtexture = gtk_object_get_user_data (GTK_OBJECT (list));
proplist_t array = get_texture_array (wtexture);
proplist_t element = WMCreatePLString (last_color?last_color:g_strdup("black"));
WMAddToPLArray (array, element);
gtk_container_add (GTK_CONTAINER (list), new_list_item (wtexture, element));
if (g_list_length (GTK_LIST (list)->children) > 2)
gtk_widget_set_sensitive (wtexture->wgradient [GRADIENT_REMOVE], TRUE);
else
gtk_widget_set_sensitive (wtexture->wgradient [GRADIENT_REMOVE], FALSE);
gtk_list_select_item (GTK_LIST (list),
g_list_length (GTK_LIST (list)->children) - 1);
list_change (widget, list);
toggle_save (changed = YES, KEY_OF_TEXTURE);
update_gradient_preview (wtexture);
}
static void
list_remove (GtkWidget *widget, GtkWidget *list)
/*
* Remove color cell at current position.
*
* No return value.
*
* Side effects:
* one element of wmaker array attribute wtexture->key is removed.
*/
{
GList *tmp_list;
GList *clear_list;
unsigned i;
wtexture_t *wtexture = gtk_object_get_user_data (GTK_OBJECT (list));
proplist_t array = get_texture_array (wtexture);
unsigned position;
position = gtk_list_child_position (GTK_LIST (list),
(GTK_LIST (list)->selection)->data);
tmp_list = GTK_LIST (list)->selection;
clear_list = NULL;
/*
* Remove color from proplist array
*/
for (i = 2; i < WMGetPropListItemCount (array); i++)
{
GtkPreview *p = gtk_object_get_user_data (GTK_OBJECT (tmp_list->data));
if (WMGetFromPLArray (array, i)
== gtk_object_get_user_data (GTK_OBJECT (p)))
{
if (last_color)
Free (last_color);
last_color = g_strdup (WMGetFromPLString (WMGetFromPLArray (array, i)));
WMDeleteFromPLArray (array, i);
break;
}
}
/*
* Remove list item
*/
while (tmp_list)
{
clear_list = g_list_prepend (clear_list, tmp_list->data);
tmp_list = tmp_list->next;
}
clear_list = g_list_reverse (clear_list);
gtk_list_remove_items (GTK_LIST (list), clear_list);
g_list_free (clear_list);
if (g_list_length (GTK_LIST (list)->children))
{
if (position < g_list_length (GTK_LIST (list)->children))
gtk_list_select_item (GTK_LIST (list), position);
else
gtk_list_select_item (GTK_LIST (list), position - 1);
}
if (g_list_length (GTK_LIST (list)->children) > 2)
gtk_widget_set_sensitive (wtexture->wgradient [GRADIENT_REMOVE], TRUE);
else
gtk_widget_set_sensitive (wtexture->wgradient [GRADIENT_REMOVE], FALSE);
toggle_save (changed = YES, KEY_OF_TEXTURE);
update_gradient_preview (wtexture);
}
static void
list_change (GtkWidget *widget, GtkWidget *list)
/*
* Popup a colorselection dialog to change select color cell.
*
* No return value.
*
* Side effects:
* value of wmaker array attribute wtexture->key is modified.
*/
{
wtexture_t *wtexture;
wtexture = (wtexture_t *) gtk_object_get_user_data (GTK_OBJECT (list));
color_selection_dialog ((GTK_LIST (list)->selection)->data, wtexture->key);
}
static void
set_pixmap_name (GtkWidget *widget, gpointer ptr)
/*
* Update pixmap string value.
*
* No return value.
*/
{
wtexture_t *wtexture = (wtexture_t *) ptr;
proplist_t element;
proplist_t array = get_texture_array (wtexture);
element = WMCreatePLString ((char *) gtk_entry_get_text (GTK_ENTRY (widget)));
WMDeleteFromPLArray (array, 1); /* filename */
WMInsertInPLArray (array, 1, element);
toggle_save (changed = YES, KEY_OF_TEXTURE);
}
static char **
get_workspace_names (void)
{
char *filename = get_gnustep_path ("Defaults/WMState");
proplist_t state = read_proplist (filename);
proplist_t ws = WMCreatePLString ("Workspaces");
proplist_t name = WMCreatePLString ("Name");
char **array = NULL;
unsigned pos = 0;
if (state)
{
proplist_t workspaces = WMGetFromPLDictionary (state, ws);
unsigned i, n;
if (workspaces && (n = WMGetPropListItemCount (workspaces)) > 0)
{
array = Calloc (n + 2, sizeof (char *));
array [pos++] = g_strdup ("Default");
for (i = 0; i < n; i++)
{
proplist_t wspace = WMGetFromPLArray (workspaces, i);
if (wspace)
{
proplist_t wname = WMGetFromPLDictionary (wspace, name);
array [pos++] = wname ? WMGetFromPLString (wname) : NULL;
}
else
array [pos++] = NULL;
}
}
}
if (!array)
{
array = Calloc (2, sizeof (char *));
array [pos++] = g_strdup ("Default");
array [pos++] = NULL;
}
else
array [pos++] = NULL;
Free (filename);
WMReleasePropList (ws);
WMReleasePropList (name);
return array;
}
static void
init_types (void)
/*
* Initialize local string variables and option menus ...
*/
{
unsigned i;
ttype_strings = Calloc (TEXTURE_LAST, sizeof (char *));
ptype_strings = Calloc (PIXMAP_LAST, sizeof (char *));
gtype_strings = Calloc (GRADIENT_LAST, sizeof (char *));
ttype_strings [TEXTURE_SOLID] = _("Solid color");
ttype_strings [TEXTURE_GRADIENT] = _("Gradient");
ttype_strings [TEXTURE_PIXMAP] = _("Pixmap");
ttype_strings [TEXTURE_TGRADIENT] = _("Textured gradient");
ttype_strings [TEXTURE_NONE] = _("None");
ttype_strings [TEXTURE_DEFAULT] = _("Default");
#ifdef HAVE_LIBWMFUN
ttype_strings [TEXTURE_BILINEAR] = _("Bilinear gradient");
ttype_strings [TEXTURE_FADE] = _("Fading gradient");
ttype_strings [TEXTURE_WAVES] = _("Waves gradient");
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
ttype_strings [TEXTURE_INTERWOVEN] = _("Interwoven gradient");
#endif /* HAVE_INTERWOVEN_GRADIENT */
ptype_strings [PIXMAP_SCALED] = _("Scaled");
ptype_strings [PIXMAP_TILED] = _("Tiled");
ptype_strings [PIXMAP_CENTERED] = _("Centered");
ptype_strings [PIXMAP_MAXASPECT] = _("Scaled (x:y)");
gtype_strings [GRADIENT_HOR] = _("Horizontal");
gtype_strings [GRADIENT_VER] = _("Vertical");
gtype_strings [GRADIENT_DIAG] = _("Diagonal");
i = 0;
option_t_normal = Calloc (TEXTURE_LAST + 1, sizeof (char *));
option_t_normal [i++] = ttype_strings [TEXTURE_SOLID];
option_t_normal [i++] = ttype_strings [TEXTURE_PIXMAP];
option_t_normal [i++] = ttype_strings [TEXTURE_GRADIENT];
option_t_normal [i++] = ttype_strings [TEXTURE_TGRADIENT];
#ifdef HAVE_LIBWMFUN
option_t_normal [i++] = ttype_strings [TEXTURE_BILINEAR];
option_t_normal [i++] = ttype_strings [TEXTURE_FADE];
option_t_normal [i++] = ttype_strings [TEXTURE_WAVES];
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
option_t_normal [i++] = ttype_strings [TEXTURE_INTERWOVEN];
#endif /* HAVE_INTERWOVEN_GRADIENT */
option_t_normal [i++] = NULL;
i = 0;
option_t_wspace = Calloc (TEXTURE_LAST + 1, sizeof (char *));
option_t_wspace [i++] = ttype_strings [TEXTURE_SOLID];
option_t_wspace [i++] = ttype_strings [TEXTURE_PIXMAP];
option_t_wspace [i++] = ttype_strings [TEXTURE_GRADIENT];
option_t_wspace [i++] = ttype_strings [TEXTURE_TGRADIENT];
#ifdef HAVE_LIBWMFUN
option_t_wspace [i++] = ttype_strings [TEXTURE_BILINEAR];
option_t_wspace [i++] = ttype_strings [TEXTURE_FADE];
option_t_wspace [i++] = ttype_strings [TEXTURE_WAVES];
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
option_t_wspace [i++] = ttype_strings [TEXTURE_INTERWOVEN];
#endif /* HAVE_INTERWOVEN_GRADIENT */
option_t_wspace [i++] = ttype_strings [TEXTURE_NONE];
option_t_wspace [i++] = NULL;
i = 0;
option_t_wspecific = Calloc (TEXTURE_LAST + 1, sizeof (char *));
option_t_wspecific [i++] = ttype_strings [TEXTURE_SOLID];
option_t_wspecific [i++] = ttype_strings [TEXTURE_PIXMAP];
option_t_wspecific [i++] = ttype_strings [TEXTURE_GRADIENT];
option_t_wspecific [i++] = ttype_strings [TEXTURE_TGRADIENT];
#ifdef HAVE_LIBWMFUN
option_t_wspecific [i++] = ttype_strings [TEXTURE_BILINEAR];
option_t_wspecific [i++] = ttype_strings [TEXTURE_FADE];
option_t_wspecific [i++] = ttype_strings [TEXTURE_WAVES];
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
option_t_wspecific [i++] = ttype_strings [TEXTURE_INTERWOVEN];
#endif /* HAVE_INTERWOVEN_GRADIENT */
option_t_wspecific [i++] = ttype_strings [TEXTURE_NONE];
option_t_wspecific [i++] = ttype_strings [TEXTURE_DEFAULT];
option_t_wspecific [i++] = NULL;
option_p_normal = Calloc (4, sizeof (char *));
option_p_normal [0] = ptype_strings [PIXMAP_CENTERED];
option_p_normal [1] = ptype_strings [PIXMAP_TILED];
option_p_normal [2] = ptype_strings [PIXMAP_SCALED];
option_p_normal [3] = NULL;
option_p_wspace = Calloc (5, sizeof (char *));
option_p_wspace [0] = ptype_strings [PIXMAP_CENTERED];
option_p_wspace [1] = ptype_strings [PIXMAP_TILED];
option_p_wspace [2] = ptype_strings [PIXMAP_SCALED];
option_p_wspace [3] = ptype_strings [PIXMAP_MAXASPECT];
option_p_wspace [4] = NULL;
option_g = Calloc (4, sizeof (char *));
option_g [0] = gtype_strings [GRADIENT_HOR];
option_g [1] = gtype_strings [GRADIENT_VER];
option_g [2] = gtype_strings [GRADIENT_DIAG];
option_g [3] = NULL;
}
static void
update_texture (proplist_t key, gpointer ptr, proplist_t value,
const char *path)
{
if (WMIsPLArray (value))
{
wtexture_t *wtexture = (wtexture_t *) ptr;
wtexture->path = path;
WMPutInPLDictionary (windowmaker, key, value);
toggle_save (changed = YES, key);
show_texture_dialog (wtexture);
}
}
#ifdef HAVE_LIBWMFUN
static void
set_layers (GtkWidget *widget, gpointer ptr)
/*
* Set number of layers for waves gradient.
*
* Side effects:
* Window Maker attribute is updated
*/
{
char *value;
wtexture_t *wtexture = (wtexture_t *) ptr;
proplist_t array = get_texture_array (wtexture);
unsigned n = WMGetPropListItemCount (array);
value = gtk_entry_get_text (GTK_ENTRY (widget));
WMDeleteFromPLArray (array, n - 2);
WMInsertInPLArray (array, n - 2, WMCreatePLString (value));
toggle_save (changed = YES, KEY_OF_TEXTURE);
update_wmfun_preview (wtexture, &wtexture->wwaves [WAVES_PREVIEW]);
}
static void
set_frequency (GtkWidget *widget, gpointer ptr)
/*
* Set number of layers for waves gradient.
*
* Side effects:
* Window Maker attribute is updated
*/
{
char *value;
wtexture_t *wtexture = (wtexture_t *) ptr;
proplist_t array = get_texture_array (wtexture);
unsigned n = WMGetPropListItemCount (array);
value = gtk_entry_get_text (GTK_ENTRY (widget));
WMDeleteFromPLArray (array, n - 1);
WMInsertInPLArray (array, n - 1, WMCreatePLString (value));
toggle_save (changed = YES, KEY_OF_TEXTURE);
update_wmfun_preview (wtexture, &wtexture->wwaves [WAVES_PREVIEW]);
}
#endif /* HAVE_LIBWMFUN */
#ifdef HAVE_INTERWOVEN_GRADIENT
static void
set_thickness_1 (GtkWidget *widget, gpointer ptr)
/*
* Set thickness 1 of interwoven gradient.
*
* Side effects:
* Window Maker attribute is updated
*/
{
char *value;
wtexture_t *wtexture = (wtexture_t *) ptr;
proplist_t array = get_texture_array (wtexture);
//unsigned n = WMGetPropListItemCount (array);
value = g_strdup (gtk_entry_get_text (GTK_ENTRY (widget)));
WMDeleteFromPLArray (array, 3);
WMInsertInPLArray (array, 3, WMCreatePLString (value));
toggle_save (changed = YES, KEY_OF_TEXTURE);
update_interwoven_preview (wtexture,
&wtexture->winterwoven [INTERWOVEN_PREVIEW]);
}
static void
set_thickness_2 (GtkWidget *widget, gpointer ptr)
/*
* Set thickness 2 of interwoven gradient.
*
* Side effects:
* Window Maker attribute is updated
*/
{
char *value;
wtexture_t *wtexture = (wtexture_t *) ptr;
proplist_t array = get_texture_array (wtexture);
//unsigned n = WMGetPropListItemCount (array);
value = g_strdup (gtk_entry_get_text (GTK_ENTRY (widget)));
WMDeleteFromPLArray (array, 6);
WMInsertInPLArray (array, 6, WMCreatePLString (value));
toggle_save (changed = YES, KEY_OF_TEXTURE);
update_interwoven_preview (wtexture,
&wtexture->winterwoven [INTERWOVEN_PREVIEW]);
}
#endif /* HAVE_INTERWOVEN_GRADIENT */
syntax highlighted by Code2HTML, v. 0.9.1