static HildonAppMenu *
create_menu (GtkWidget *label,
GtkAccelGroup *accel)
{
GtkWidget *button;
HildonSizeType buttonsize = HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH;
HildonAppMenu *menu = HILDON_APP_MENU (hildon_app_menu_new ());
/* Options */
button = hildon_gtk_button_new (buttonsize);
gtk_button_set_label (GTK_BUTTON (button), "Menu command one");
g_signal_connect_after (button, "clicked", G_CALLBACK (menu_button_clicked), label);
hildon_app_menu_append (menu, GTK_BUTTON (button));
gtk_widget_add_accelerator (button, "activate", accel, GDK_r, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
button = hildon_gtk_button_new (buttonsize);
gtk_button_set_label (GTK_BUTTON (button), "Menu command two");
g_signal_connect_after (button, "clicked", G_CALLBACK (menu_button_clicked), label);
hildon_app_menu_append (menu, GTK_BUTTON (button));
button = hildon_gtk_button_new (buttonsize);
gtk_button_set_label (GTK_BUTTON (button), "Menu command three");
g_signal_connect_after (button, "clicked", G_CALLBACK (menu_button_clicked), label);
hildon_app_menu_append (menu, GTK_BUTTON (button));
button = hildon_gtk_button_new (buttonsize);
gtk_button_set_label (GTK_BUTTON (button), "Menu command four");
g_signal_connect_after (button, "clicked", G_CALLBACK (menu_button_clicked), label);
hildon_app_menu_append (menu, GTK_BUTTON (button));
button = hildon_gtk_button_new (buttonsize);
gtk_button_set_label (GTK_BUTTON (button), "Menu command five");
g_signal_connect_after (button, "clicked", G_CALLBACK (menu_button_clicked), label);
hildon_app_menu_append (menu, GTK_BUTTON (button));
/* Filters */
button = hildon_gtk_radio_button_new (buttonsize, NULL);
gtk_button_set_label (GTK_BUTTON (button), "filter one");
g_signal_connect_after (button, "clicked", G_CALLBACK (menu_button_clicked), label);
hildon_app_menu_add_filter (menu, GTK_BUTTON (button));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
button = hildon_gtk_radio_button_new_from_widget (buttonsize, GTK_RADIO_BUTTON (button));
gtk_button_set_label (GTK_BUTTON (button), "filter two");
g_signal_connect_after (button, "clicked", G_CALLBACK (menu_button_clicked), label);
hildon_app_menu_add_filter (menu, GTK_BUTTON (button));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
gtk_widget_show_all (GTK_WIDGET (menu));
return menu;
}
void gcb_play_channel(GtkWidget *w, struct gchan *o)
{
guint res;
GtkTreeSelection *select;
GtkTreeModel *model;
gint index=0;
GList *pathlist=NULL;
if( mixer->chan[o->idx-1]->on) {
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(o->play), FALSE);
return;
}
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(o->tree));
if( !(pathlist = gtk_tree_selection_get_selected_rows(select, &model)) )
return;
index = gtk_tree_path_get_indices((GtkTreePath *)pathlist->data)[0];
func(_("selected index = %d"), index);
gtk_tree_path_free((GtkTreePath *)pathlist->data);
mixer->set_channel(o->idx-1, index+1);
res = mixer->play_channel(o->idx-1);
switch(res) {
case 0:
o->channel=0;
break;
case 1: /* channel is seekable */
gtk_entry_set_text(GTK_ENTRY(o->ptime), "00:00:00");
gtk_adjustment_set_value(GTK_ADJUSTMENT(o->adjprog), 0.0);
o->channel=1;
break;
case 2: /* unseekable */
gtk_entry_set_text(GTK_ENTRY(o->ptime), "-stream-");
gtk_adjustment_set_value(GTK_ADJUSTMENT(o->adjprog), 0.0);
o->channel=2;
break;
}
if(res==0) {
func(_("KO for playing :("));
gtk_toggle_button_set_mode
(GTK_TOGGLE_BUTTON(o->play), FALSE);
} else {
func(_("ok for playing"));
gtk_toggle_button_set_mode
(GTK_TOGGLE_BUTTON(o->play), TRUE);
}
}
static GtkWidget *
checkbutton_new (GladeXML *xml, GladeWidgetInfo *info)
{
GtkWidget *button;
GList *tmp;
char *string = NULL;
gboolean active = FALSE, draw_indicator = TRUE;
for (tmp = info->attributes; tmp; tmp = tmp->next) {
GladeAttribute *attr = tmp->data;
if (!strcmp(attr->name, "label"))
string = attr->value;
else if (!strcmp(attr->name, "active"))
active = attr->value[0] == 'T';
else if (!strcmp(attr->name, "draw_indicator"))
draw_indicator = attr->value[0] == 'T';
}
if (string != NULL) {
guint key;
button = gtk_check_button_new_with_label("");
key = gtk_label_parse_uline(GTK_LABEL(GTK_BIN(button)->child),
string[0] ? _(string) : "");
if (key)
gtk_widget_add_accelerator(button, "clicked",
glade_xml_ensure_accel(xml),
key, GDK_MOD1_MASK, 0);
} else
button = gtk_check_button_new();
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), active);
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button), draw_indicator);
return button;
}
static GSList *
aw_map_view_get_filters (AwTreeView *view)
{
struct {
const char *label;
void (*callback) ();
} filters[] = {
{ _("Distance"), aw_map_view_sort_by_distance_cb },
{ _("Name"), aw_map_view_sort_by_name_cb },
{ _("ID"), aw_map_view_sort_by_id_cb },
{ _("Level"), aw_map_view_sort_by_level_cb },
};
gpointer button = NULL;
int i;
for (i = G_N_ELEMENTS (filters) - 1; i >= 0; --i)
{
button = gtk_radio_button_new_from_widget (button);
gtk_button_set_label (button, filters[i].label);
gtk_toggle_button_set_mode (button, FALSE);
g_signal_connect_swapped (button, "toggled",
filters[i].callback, view);
gtk_widget_show (button);
}
return gtk_radio_button_get_group (button);
}
static void
add_child (GtkStackSwitcher *self,
GtkWidget *widget)
{
GtkWidget *button;
GList *group;
button = gtk_radio_button_new (NULL);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
update_button (self, widget, button);
group = gtk_container_get_children (GTK_CONTAINER (self));
if (group != NULL)
{
gtk_radio_button_join_group (GTK_RADIO_BUTTON (button), GTK_RADIO_BUTTON (group->data));
g_list_free (group);
}
gtk_container_add (GTK_CONTAINER (self), button);
g_object_set_data (G_OBJECT (button), "stack-child", widget);
g_signal_connect (button, "clicked", G_CALLBACK (on_button_clicked), self);
g_signal_connect (widget, "child-notify::title", G_CALLBACK (on_title_icon_updated), self);
g_signal_connect (widget, "child-notify::icon-name", G_CALLBACK (on_title_icon_updated), self);
g_signal_connect (widget, "child-notify::position", G_CALLBACK (on_position_updated), self);
g_hash_table_insert (self->priv->buttons, widget, button);
}
static VALUE
rg_set_mode(VALUE self, VALUE mode)
{
gtk_toggle_button_set_mode(RVAL2GTKTOGGLEBUTTON(self),
RVAL2CBOOL(mode));
return self;
}
static VALUE
tbtn_set_mode(VALUE self, VALUE mode)
{
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(RVAL2GOBJ(self)),
RVAL2CBOOL(mode));
return self;
}
static GtkWidget * create_pixmap_radio_button(bg_nle_timeline_t * w,
const char * filename,
const char * tooltip,
guint * id, GSList ** group)
{
GtkWidget * button;
GtkWidget * image;
char * path;
path = bg_search_file_read("icons", filename);
if(path)
{
image = gtk_image_new_from_file(path);
free(path);
}
else
image = gtk_image_new();
gtk_widget_show(image);
button = gtk_radio_button_new(*group);
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button), FALSE);
if(!(*group))
*group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
gtk_container_add(GTK_CONTAINER(button), image);
*id = g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(button_callback), w);
gtk_widget_show(button);
bg_gtk_tooltips_set_tip(button, tooltip, PACKAGE);
return button;
}
gboolean
mt_ctw_init (MTClosure *mt, gint x, gint y)
{
GtkWidget *ctw, *w;
GError *error = NULL;
const gchar *b[] = { "single", "double", "drag", "right" };
GSList *group;
gpointer data;
gint i;
mt->ui = gtk_builder_new ();
gtk_builder_add_from_file (mt->ui, DATADIR "/mousetweaks.ui", &error);
if (error) {
g_print ("%s\n", error->message);
g_error_free (error);
g_object_unref (mt->ui);
mt->ui = NULL;
return FALSE;
}
ctw = mt_ctw_get_window (mt);
gtk_window_stick (GTK_WINDOW (ctw));
gtk_window_set_keep_above (GTK_WINDOW (ctw), TRUE);
g_signal_connect (ctw, "delete-event", G_CALLBACK (ctw_delete_cb), mt);
for (i = 0; i < N_CLICK_TYPES; i++) {
w = WID (b[i]);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (w), FALSE);
g_signal_connect (w, "toggled", G_CALLBACK (ctw_button_cb), mt);
g_signal_connect (w, "button-press-event",
G_CALLBACK (ctw_context_menu), mt);
}
g_signal_connect (WID ("text"), "toggled",
G_CALLBACK (ctw_menu_toggled), mt);
g_signal_connect (WID ("icon"), "toggled",
G_CALLBACK (ctw_menu_toggled), mt);
w = WID ("both");
g_signal_connect (w, "toggled",
G_CALLBACK (ctw_menu_toggled), mt);
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w));
data = g_slist_nth_data (group, mt->style);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (data), TRUE);
gtk_widget_realize (ctw);
mt_ctw_update_style (mt, mt->style);
mt_ctw_update_sensitivity (mt);
mt_ctw_update_visibility (mt);
if (x != -1 && y != -1)
gtk_window_move (GTK_WINDOW (ctw), x, y);
return TRUE;
}
static GtkWidget *
radiobutton_new(GladeXML *xml, GladeWidgetInfo *info)
{
GtkWidget *button;
GList *tmp;
char *string = NULL;
gboolean active = FALSE, draw_indicator = TRUE;
GSList *group = NULL;
char *group_name = NULL;
for (tmp = info->attributes; tmp; tmp = tmp->next) {
GladeAttribute *attr = tmp->data;
if (!strcmp(attr->name, "label"))
string = attr->value;
else if (!strcmp(attr->name, "active"))
active = attr->value[0] == 'T';
else if (!strcmp(attr->name, "draw_indicator"))
draw_indicator = attr->value[0] == 'T';
else if (!strcmp(attr->name, "group")){
group_name = attr->value;
group = g_hash_table_lookup (xml->priv->radio_groups,
group_name);
if (!group)
group_name = g_strdup(group_name);
}
}
if (string != NULL) {
guint key;
button = gtk_radio_button_new_with_label(group, "");
key = gtk_label_parse_uline(GTK_LABEL(GTK_BIN(button)->child),
string[0] ? _(string) : "");
if (key)
gtk_widget_add_accelerator(button, "clicked",
glade_xml_ensure_accel(xml),
key, GDK_MOD1_MASK, 0);
} else
button = gtk_radio_button_new (group);
if (group_name) {
GtkRadioButton *radio = GTK_RADIO_BUTTON (button);
g_hash_table_insert (xml->priv->radio_groups,
group_name,
gtk_radio_button_group (radio));
}
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), active);
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button), draw_indicator);
return button;
}
gboolean on_mouse_click(GtkWidget *widget,GdkEventButton *event,gpointer data)//GtkEventButton对应鼠标按键事件，结构成员event->button等于1对应按下鼠标左键，等于3对应按下鼠标右键。
{
gint index;
gint row,col;
gchar buf[4];
vbox3 = gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox3),s_image,FALSE,FALSE,0);
if(time_out_tag==0)
{
time_out_tag = g_timeout_add(1000,(GSourceFunc)tick,NULL);
}
if(game_over == TRUE)
return TRUE;
index = (gint)data;
switch(event->button)
{
case 1:
row = index/width;
col = index%width;
open_block(col,row);//鼠标左键按一下，表示打开一个方块，调用open_block()处理。
break;
case 2:
break;
case 3:
if(map[index].opened == TRUE)
break;
if(map[index].marked != TRUE)
{
map[index].marked = TRUE;
gtk_button_set_label(GTK_BUTTON(widget),"@");//按下鼠标右键，表示标记本方块是地雷，直接在方块上画个“@”符号。
marked_count++;
}
else
{
map[index].marked = FALSE;
gtk_button_set_label(GTK_BUTTON(widget),"");
marked_count--;
}
g_snprintf(buf,4,"%d",MAX(0,mines-marked_count));
gtk_label_set_text(GTK_LABEL(mine_label),buf);
}
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(map[index].button),TRUE);
return TRUE;
}
static void
_new_page (OlPlayerChooser *window,
const char *page_name)
{
OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window);
OlPlayerChooserPage *page = g_new (OlPlayerChooserPage, 1);
page->page_button = GTK_TOGGLE_BUTTON (gtk_radio_button_new_with_label (priv->page_button_group,
page_name));
priv->page_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (page->page_button));
gtk_toggle_button_set_mode (page->page_button, FALSE);
gtk_button_set_relief (GTK_BUTTON (page->page_button), GTK_RELIEF_NONE);
page->chooser = OL_APP_CHOOSER_WIDGET (ol_app_chooser_widget_new ());
gtk_widget_show (GTK_WIDGET (page->chooser));
page->panel = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL));
gtk_scrolled_window_add_with_viewport (page->panel, GTK_WIDGET (page->chooser));
GtkViewport *viewport = GTK_VIEWPORT (gtk_bin_get_child (GTK_BIN (page->panel)));
gtk_viewport_set_shadow_type (viewport, GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (page->panel,
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
g_signal_connect (page->page_button,
"toggled",
G_CALLBACK (_page_button_toggled),
page);
g_signal_connect (page->chooser,
"app-activate",
G_CALLBACK (_app_activate_cb),
window);
_page_button_toggled (page->page_button, page);
if (priv->pages->len > 0)
gtk_box_pack_start (priv->page_button_panel,
gtk_vseparator_new (),
FALSE,
FALSE,
5);
gtk_box_pack_start (priv->page_button_panel,
GTK_WIDGET (page->page_button),
FALSE, /* expand */
FALSE, /* fill */
0); /* padding */
gtk_box_pack_start (priv->chooser_panel,
GTK_WIDGET (page->panel),
TRUE, /* expand */
TRUE, /* fill */
0); /* padding */
g_ptr_array_add (priv->pages, page);
}
static GtkWidget *
create_volume_button(gchar* text, GtkTable* table, int column, int row)
{
GtkWidget *btn;
btn = hildon_gtk_toggle_button_new(HILDON_SIZE_THUMB_HEIGHT
| HILDON_SIZE_AUTO_WIDTH);
gtk_button_set_label(GTK_BUTTON(btn), text);
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(btn), FALSE);
gtk_table_attach(GTK_TABLE(table), btn,
column, column + 1,
row, row + 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
return btn;
}
GtkWidget * yui_check_button_new(const gchar * label, GKeyFile * keyfile, const gchar * group, const gchar * key) {
GtkWidget * button;
YuiCheckButton * ycb;
gboolean current;
button = GTK_WIDGET(g_object_new(yui_check_button_get_type(),
"label", label,
"key-file", keyfile, "group", group, "key", key, NULL));
ycb = YUI_CHECK_BUTTON(button);
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(ycb), TRUE);
current = g_key_file_get_boolean(ycb->keyfile, ycb->group, ycb->key, NULL);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(ycb), current);
g_signal_connect(GTK_TOGGLE_BUTTON(ycb), "toggled", G_CALLBACK(yui_check_button_toggled), ycb);
return button;
}
static void
photos_tool_filter_button_constructed (GObject *object)
{
PhotosToolFilterButton *self = PHOTOS_TOOL_FILTER_BUTTON (object);
GApplication *app;
g_autoptr (GdkPixbuf) preview_icon = NULL;
GtkWidget *image;
PhotosWidgetShader *shader;
cairo_surface_t *preview_icon_surface = NULL; /* TODO: use g_autoptr */
gint scale;
G_OBJECT_CLASS (photos_tool_filter_button_parent_class)->constructed (object);
app = g_application_get_default ();
scale = photos_application_get_scale_factor (PHOTOS_APPLICATION (app));
preview_icon = photos_utils_create_placeholder_icon_for_scale ("content-loading-symbolic", 96, scale);
if (preview_icon != NULL)
preview_icon_surface = gdk_cairo_surface_create_from_pixbuf (preview_icon, scale, NULL);
image = gtk_image_new_from_surface (preview_icon_surface);
gtk_container_add (GTK_CONTAINER (self->overlay), image);
shader = photos_widget_shader_new (image);
gtk_widget_show (image);
self->button = gtk_radio_button_new_with_label_from_widget (self->group, self->label);
gtk_button_set_always_show_image (GTK_BUTTON (self->button), TRUE);
gtk_button_set_image (GTK_BUTTON (self->button), self->overlay);
gtk_button_set_image_position (GTK_BUTTON (self->button), GTK_POS_TOP);
gtk_button_set_relief (GTK_BUTTON (self->button), GTK_RELIEF_NONE);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (self->button), FALSE);
gtk_container_add (GTK_CONTAINER (self), self->button);
g_object_bind_property (self->button, "active", shader, "active", G_BINDING_SYNC_CREATE);
g_signal_connect_swapped (self->button, "toggled", G_CALLBACK (photos_tool_filter_button_toggled), self);
photos_tool_filter_button_toggled (self);
g_clear_pointer (&preview_icon_surface, (GDestroyNotify) cairo_surface_destroy);
self->group = NULL; /* We will not need it any more */
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_radio_button_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gboolean state, indicator;
gchar *group_name;
GSList *group = NULL, *current_group;
GbFindGroupData find_group_data;
if (gb_toolbar_is_toolbar_button (widget))
{
gb_toolbar_input_child_label (widget, data, Label);
gb_toolbar_input_child_icon (widget, data, Icon);
}
else
{
gb_widget_input_child_label (widget, data, Label);
}
state = gb_widget_input_bool (data, State);
if (data->apply)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), state);
if (state)
data->widget_data->flags |= GLADE_ACTIVE;
else
data->widget_data->flags &= ~GLADE_ACTIVE;
}
indicator = gb_widget_input_bool (data, Indicator);
if (data->apply)
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (widget), indicator);
/* Find any widgets in given group and set this widgets group.
If group is NULL try to find radiobuttons with same parent and use
their group. If these don't succeed, set group to NULL. */
group_name = gb_widget_input_combo (data, Group);
if (data->apply)
{
if (group_name && group_name[0] == '\0')
group_name = NULL;
current_group = gtk_radio_button_group (GTK_RADIO_BUTTON (widget));
if (group_name == NULL)
gtk_container_foreach (GTK_CONTAINER (widget->parent),
(GtkCallback) find_parents_group, &group);
else
{
find_group_data.group_name = group_name;
find_group_data.group = NULL;
find_group (gtk_widget_get_toplevel (widget), &find_group_data);
group = find_group_data.group;
}
g_free (gtk_object_get_data (GTK_OBJECT (widget), Group));
gtk_object_set_data (GTK_OBJECT (widget), Group, g_strdup (group_name));
/* This crashes if we set the group to NULL, so we have to reset the
group ourself. We only set the group if it has changed. */
if (group)
{
if (group != current_group)
{
if (current_group->data == widget)
current_group = current_group->next;
gtk_radio_button_set_group (GTK_RADIO_BUTTON (widget), group);
gb_radio_button_update_radio_group (current_group);
gb_radio_button_update_radio_group (gtk_radio_button_group (GTK_RADIO_BUTTON (widget)));
}
}
else
{
if (g_slist_length (current_group) != 1)
{
current_group = gb_radio_button_reset_radio_group (widget);
gb_radio_button_update_radio_group (current_group);
gb_radio_button_update_radio_group (gtk_radio_button_group (GTK_RADIO_BUTTON (widget)));
}
}
}
}
static int gtkToggleMapMethod(Ihandle* ih)
{
Ihandle* radio = iupRadioFindToggleParent(ih);
char *value;
int is3state = 0;
if (!ih->parent)
return IUP_ERROR;
if (radio)
ih->data->radio = 1;
value = iupAttribGet(ih, "IMAGE");
if (value)
ih->data->type = IUP_TOGGLE_IMAGE;
else
ih->data->type = IUP_TOGGLE_TEXT;
if (radio)
{
GtkRadioButton* last_tg = (GtkRadioButton*)iupAttribGet(radio, "_IUPGTK_LASTRADIOBUTTON");
if (last_tg)
ih->handle = gtk_radio_button_new_from_widget(last_tg);
else
ih->handle = gtk_radio_button_new(NULL);
iupAttribSetStr(radio, "_IUPGTK_LASTRADIOBUTTON", (char*)ih->handle);
}
else
{
if (ih->data->type == IUP_TOGGLE_TEXT)
{
ih->handle = gtk_check_button_new();
if (iupAttribGetInt(ih, "3STATE"))
is3state = 1;
}
else
ih->handle = gtk_toggle_button_new();
}
if (!ih->handle)
return IUP_ERROR;
if (ih->data->type == IUP_TOGGLE_TEXT)
{
gtk_button_set_image((GtkButton*)ih->handle, gtk_label_new(NULL));
gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, TRUE);
}
else
{
gtk_button_set_image((GtkButton*)ih->handle, gtk_image_new());
gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, FALSE);
}
/* add to the parent, all GTK controls must call this. */
iupgtkBaseAddToParent(ih);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
g_signal_connect(G_OBJECT(ih->handle), "toggled", G_CALLBACK(gtkToggleToggled), ih);
if (ih->data->type == IUP_TOGGLE_IMAGE || is3state)
{
g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(gtkToggleButtonEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(gtkToggleButtonEvent), ih);
}
if (is3state)
{
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkToggleKeyEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-release-event", G_CALLBACK(gtkToggleKeyEvent), ih);
}
gtk_widget_realize(ih->handle);
return IUP_NOERROR;
}
static int gtkToggleMapMethod(Ihandle* ih)
{
Ihandle* radio = iupRadioFindToggleParent(ih);
char *value;
int is3state = 0;
if (!ih->parent)
return IUP_ERROR;
value = iupAttribGet(ih, "IMAGE");
if (value)
ih->data->type = IUP_TOGGLE_IMAGE;
else
ih->data->type = IUP_TOGGLE_TEXT;
if (radio)
{
GtkRadioButton* last_tg = (GtkRadioButton*)iupAttribGet(radio, "_IUPGTK_LASTRADIOBUTTON");
if (last_tg)
ih->handle = gtk_radio_button_new_from_widget(last_tg);
else
ih->handle = gtk_radio_button_new(NULL);
iupAttribSet(radio, "_IUPGTK_LASTRADIOBUTTON", (char*)ih->handle);
/* make sure it has at least one name */
if (!iupAttribGetHandleName(ih))
iupAttribSetHandleName(ih);
ih->data->is_radio = 1;
}
else
{
if (ih->data->type == IUP_TOGGLE_TEXT)
{
ih->handle = gtk_check_button_new();
if (iupAttribGetBoolean(ih, "3STATE"))
is3state = 1;
}
else
ih->handle = gtk_toggle_button_new();
}
if (!ih->handle)
return IUP_ERROR;
if (ih->data->type == IUP_TOGGLE_TEXT)
{
gtk_button_set_image((GtkButton*)ih->handle, gtk_label_new(NULL));
gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, TRUE);
}
else
{
gtk_button_set_image((GtkButton*)ih->handle, gtk_image_new());
gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, FALSE);
}
iupgtkClearSizeStyleCSS(ih->handle);
/* add to the parent, all GTK controls must call this. */
iupgtkAddToParent(ih);
if (!iupAttribGetBoolean(ih, "CANFOCUS"))
iupgtkSetCanFocus(ih->handle, 0);
if (ih->data->type == IUP_TOGGLE_IMAGE && ih->data->flat)
{
gtk_button_set_relief((GtkButton*)ih->handle, GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(gtkToggleEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(gtkToggleEnterLeaveEvent), ih);
}
else
{
g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
}
g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
g_signal_connect(G_OBJECT(ih->handle), "toggled", G_CALLBACK(gtkToggleToggled), ih);
if (ih->data->type == IUP_TOGGLE_IMAGE || is3state)
{
g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(gtkToggleButtonEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(gtkToggleButtonEvent), ih);
}
if (is3state)
{
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkToggleKeyEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-release-event", G_CALLBACK(gtkToggleKeyEvent), ih);
}
gtk_widget_realize(ih->handle);
/* update a mnemonic in a label if necessary */
iupgtkUpdateMnemonic(ih);
return IUP_NOERROR;
}
/** \brief Create and initialise time controller widgets.
* \param module The parent GtkSatModule
*
*/
void tmg_create (GtkSatModule *mod)
{
GtkWidget *vbox, *hbox, *table;
GtkWidget *image;
GtkWidget *label;
gchar *title;
gchar *buff;
/* make sure controller is not already active */
if (mod->tmgActive) {
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: Time Controller for %s is already active"),
__FUNCTION__, mod->name);
/* try to make window visible in case it is covered
by something else */
gtk_window_present (GTK_WINDOW (mod->tmgWin));
return;
}
/* create hbox containing the controls
the controls are implemented as radiobuttons in order
to inherit the mutual exclusion behaviour
*/
hbox = gtk_hbox_new (FALSE, 0);
/* FWD */
mod->tmgFwd = gtk_radio_button_new (NULL);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgFwd), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mod->tmgFwd), TRUE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_FORWARD, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgFwd), image);
gtk_widget_set_tooltip_text (mod->tmgFwd, _("Play forward"));
g_signal_connect (mod->tmgFwd, "toggled", G_CALLBACK (tmg_fwd), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgFwd, FALSE, FALSE, 0);
/* STOP */
mod->tmgStop = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (mod->tmgFwd));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgStop), FALSE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgStop), image);
gtk_widget_set_tooltip_text (mod->tmgStop, _("Stop"));
g_signal_connect (mod->tmgStop, "toggled", G_CALLBACK (tmg_stop), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgStop, FALSE, FALSE, 0);
/* BWD */
mod->tmgBwd = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (mod->tmgFwd));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgBwd), FALSE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_REWIND, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgBwd), image);
gtk_widget_set_tooltip_text (mod->tmgBwd, _("Play backwards"));
g_signal_connect (mod->tmgBwd, "toggled", G_CALLBACK (tmg_bwd), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgBwd, FALSE, FALSE, 0);
/* reset time */
mod->tmgReset = gtk_button_new_with_label (_("Reset"));
gtk_widget_set_tooltip_text (mod->tmgReset, _("Reset to current date and time"));
g_signal_connect (mod->tmgReset, "clicked", G_CALLBACK (tmg_reset), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgReset, FALSE, FALSE, 10);
/* status label */
mod->tmgState = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (mod->tmgState), 0.0, 0.5);
gtk_label_set_markup (GTK_LABEL (mod->tmgState), _("<b>Real-Time</b>"));
gtk_box_pack_start (GTK_BOX (hbox), mod->tmgState, TRUE, TRUE, 10);
/* create table containing the date and time widgets */
table = gtk_table_new (5, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 0);
mod->tmgCal = gtk_calendar_new ();
gtk_calendar_set_display_options (GTK_CALENDAR (mod->tmgCal),
GTK_CALENDAR_SHOW_HEADING |
GTK_CALENDAR_SHOW_DAY_NAMES |
GTK_CALENDAR_WEEK_START_MONDAY);
g_signal_connect (mod->tmgCal, "day-selected",
G_CALLBACK (tmg_time_set), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgCal,
0, 1, 0, 5, GTK_SHRINK, GTK_SHRINK,
0, 0);
/* Time controllers.
Note that the controllers for hours, minutes, and seconds have ranges;
however, they can wrap around their limits in order to ensure a smooth
and continuous control of the time
*/
/* hour */
label = gtk_label_new (_(" Hour:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgHour = gtk_spin_button_new_with_range (0, 23, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgHour), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgHour),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgHour), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgHour), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgHour), 2);
gtk_widget_set_tooltip_text (mod->tmgHour,
_("Use this control to set the hour"));
g_signal_connect (mod->tmgHour, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgHour, "wrapped", G_CALLBACK (tmg_hour_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgHour,
2, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* minutes */
label = gtk_label_new (_(" Min:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgMin = gtk_spin_button_new_with_range (0, 59, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgMin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgMin),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgMin), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgMin), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMin), 2);
gtk_widget_set_tooltip_text (mod->tmgMin,
_("Use this control to set the minutes"));
g_signal_connect (mod->tmgMin, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgMin, "wrapped", G_CALLBACK (tmg_min_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgMin,
2, 3, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* seconds */
label = gtk_label_new (_(" Sec:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgSec = gtk_spin_button_new_with_range (0, 59, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgSec), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgSec),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgSec), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgSec), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgSec), 2);
gtk_widget_set_tooltip_text (mod->tmgSec,
_("Use this control to set the seconds"));
g_signal_connect (mod->tmgSec, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgSec, "wrapped", G_CALLBACK (tmg_sec_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgSec,
2, 3, 2, 3, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* milliseconds */
label = gtk_label_new (_(" Msec:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 3, 4, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgMsec = gtk_spin_button_new_with_range (0, 999, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgMsec), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgMsec),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgMsec), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgMsec), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMsec), 2);
gtk_widget_set_tooltip_text (mod->tmgMsec,
_("Use this control to set the milliseconds"));
g_signal_connect (mod->tmgMsec, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgMsec, "wrapped", G_CALLBACK (tmg_msec_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgMsec,
2, 3, 3, 4, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* time throttle */
label = gtk_label_new (_("Throttle:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 4, 5, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgFactor = gtk_spin_button_new_with_range (1, 100, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgFactor), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgFactor),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgFactor), 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgFactor), 1);
gtk_widget_set_tooltip_text (mod->tmgFactor,
_("Time throttle / compression factor"));
g_signal_connect (mod->tmgFactor, "value-changed",
G_CALLBACK (tmg_throttle), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgFactor,
2, 3, 4, 5, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* add slider */
mod->tmgSlider = gtk_hscale_new_with_range (-0.1, +0.1, 0.0001); // +/- 2.5 hr
/*gtk_widget_set_tooltip_text (mod->tmgSlider,
_("Drag the slider to change the time up to +/- 2.5 hours.\n"\
"Resolution is ~ 8 seconds."));*/
gtk_scale_set_draw_value (GTK_SCALE (mod->tmgSlider), FALSE);
gtk_range_set_value (GTK_RANGE (mod->tmgSlider), 0.0);
g_signal_connect (mod->tmgSlider, "value-changed",
G_CALLBACK (slider_moved), mod);
/* create the vertical box */
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), mod->tmgSlider, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* create main window */
mod->tmgWin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
title = g_strconcat (_("Time Controller"), " / ", mod->name, NULL);
gtk_window_set_title (GTK_WINDOW (mod->tmgWin), title);
g_free (title);
gtk_window_set_transient_for (GTK_WINDOW (mod->tmgWin),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (mod))));
g_signal_connect (G_OBJECT (mod->tmgWin), "delete_event",
G_CALLBACK (tmg_delete), mod);
g_signal_connect (G_OBJECT (mod->tmgWin), "destroy",
G_CALLBACK (tmg_destroy), mod);
/* window icon */
buff = icon_file_name ("gpredict-clock.png");
gtk_window_set_icon_from_file (GTK_WINDOW (mod->tmgWin), buff, NULL);
g_free (buff);
gtk_container_add (GTK_CONTAINER (mod->tmgWin), vbox);
gtk_widget_show_all (mod->tmgWin);
mod->tmgActive = TRUE;
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: Time Controller for %s launched"),
__FUNCTION__, mod->name);
}
GtkWidget *
gnc_item_edit_new (GnucashSheet *sheet)
{
char *hpad_str, *vpad_str, *entry_css;
GtkStyleContext *stylecontext;
GtkCssProvider *provider;
GncItemEdit *item_edit =
g_object_new (GNC_TYPE_ITEM_EDIT,
"sheet", sheet,
"spacing", 0,
"homogeneous", FALSE,
NULL);
gtk_layout_put (GTK_LAYOUT(sheet), GTK_WIDGET(item_edit), 0, 0);
// This sets a style class for when Gtk+ version is less than 3.20
gnc_widget_set_css_name (GTK_WIDGET(item_edit), "cursor");
/* Create the text entry */
item_edit->editor = gtk_entry_new();
sheet->entry = item_edit->editor;
gtk_entry_set_width_chars (GTK_ENTRY(item_edit->editor), 1);
gtk_box_pack_start (GTK_BOX(item_edit), item_edit->editor, TRUE, TRUE, 0);
// Make sure the Entry can not have focus and no frame
gtk_widget_set_can_focus (GTK_WIDGET(item_edit->editor), FALSE);
gtk_entry_set_has_frame (GTK_ENTRY(item_edit->editor), FALSE);
// Connect to the draw signal so we can draw a cursor
g_signal_connect_after (item_edit->editor, "draw",
G_CALLBACK (draw_text_cursor_cb), NULL);
// Fill in the background so the underlying sheet cell can not be seen
g_signal_connect (item_edit, "draw",
G_CALLBACK (draw_background_cb), item_edit);
/* Force padding on the entry to align with the rest of the register this
is done in the gnucash.css file which should be in line with sheet.h */
/* Create the popup button
It will only be displayed when the cell being edited provides
a popup item (like a calendar or account list) */
item_edit->popup_toggle.tbutton = gtk_toggle_button_new();
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (item_edit->popup_toggle.tbutton), FALSE);
/* Force padding on the button to keep it small and display as much as
possible of the arrow which is done in the gnucash.css file */
/* Wrap the popup button in an event box to give it its own gdkwindow.
* Without one the button would disappear behind the grid object. */
item_edit->popup_toggle.ebox = gtk_event_box_new();
g_object_ref(item_edit->popup_toggle.ebox);
gtk_container_add(GTK_CONTAINER(item_edit->popup_toggle.ebox),
item_edit->popup_toggle.tbutton);
gtk_box_pack_start (GTK_BOX(item_edit),
item_edit->popup_toggle.ebox,
FALSE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(item_edit));
return GTK_WIDGET(item_edit);
}
GtkWidget* bimp_watermark_gui_new(watermark_settings settings)
{
GtkWidget *gui, *hbox_text_entry, *hbox_text_font, *hbox_text_color, *hbox_opacity, *frame_position, *table_position;
GtkWidget *align_radio_text, *align_radio_image;
GtkWidget *label_text, *label_font, *label_color, *label_opacity, *label_percent;
gui = gtk_vbox_new(FALSE, 5);
align_radio_text = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_radio_text), 0, 5, 10, 0);
radio_text = gtk_radio_button_new_with_label(NULL, _("Text watermark"));
vbox_text = gtk_vbox_new(FALSE, 5);
hbox_text_entry = gtk_hbox_new(FALSE, 5);
label_text = gtk_label_new(g_strconcat(_("Text"), ":", NULL));
gtk_widget_set_size_request (label_text, LABEL_W, LABEL_H);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_text), settings->mode);
entry_text = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry_text), 50);
gtk_entry_set_text(GTK_ENTRY(entry_text), settings->text);
gtk_widget_set_size_request (entry_text, INPUT_W, INPUT_H);
hbox_text_font = gtk_hbox_new(FALSE, 5);
label_font = gtk_label_new(g_strconcat(_("Font"), ":", NULL));
gtk_widget_set_size_request (label_font, LABEL_W, LABEL_H);
chooser_font = gtk_font_button_new_with_font(pango_font_description_to_string(settings->font));
gtk_widget_set_size_request (chooser_font, INPUT_W, INPUT_H);
hbox_text_color = gtk_hbox_new(FALSE, 5);
label_color = gtk_label_new(g_strconcat(_("Color"), ":", NULL));
gtk_widget_set_size_request (label_color, LABEL_W, LABEL_H);
chooser_color = gtk_color_button_new_with_color(&(settings->color));
gtk_widget_set_size_request (chooser_color, INPUT_W, INPUT_H);
align_radio_image = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_radio_image), 0, 5, 10, 0);
radio_image = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON(radio_text), _("Image watermark"));
vbox_image = gtk_vbox_new(FALSE, 5);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_image), !settings->mode);
chooser_image = gtk_file_chooser_button_new(_("Select image"), GTK_FILE_CHOOSER_ACTION_OPEN);
/* set image chooser's filters */
GtkFileFilter *filter_all, *supported[5];
filter_all = gtk_file_filter_new();
gtk_file_filter_set_name(filter_all, _("All supported types"));
supported[0] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[0], "Bitmap (*.bmp)");
gtk_file_filter_add_pattern (supported[0], "*.bmp");
gtk_file_filter_add_pattern (filter_all, "*.bmp");
supported[1] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[1], "JPEG (*.jpg, *.jpeg, *jpe)");
gtk_file_filter_add_pattern (supported[1], "*.jpg");
gtk_file_filter_add_pattern (supported[1], "*.jpeg");
gtk_file_filter_add_pattern (supported[1], "*.jpe");
gtk_file_filter_add_pattern (filter_all, "*.jpg");
gtk_file_filter_add_pattern (filter_all, "*.jpeg");
gtk_file_filter_add_pattern (filter_all, "*.jpe");
supported[2] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[2], "GIF (*.gif)");
gtk_file_filter_add_pattern (supported[2], "*.gif");
gtk_file_filter_add_pattern (filter_all, "*.gif");
supported[3] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[3], "PNG (*.png)");
gtk_file_filter_add_pattern (supported[3], "*.png");
gtk_file_filter_add_pattern (filter_all, "*.png");
supported[4] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[4], "TIFF (*tif, *.tiff)");
gtk_file_filter_add_pattern (supported[4], "*.tiff");
gtk_file_filter_add_pattern (supported[4], "*.tif");
gtk_file_filter_add_pattern (filter_all, "*.tiff");
gtk_file_filter_add_pattern (filter_all, "*.tif");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser_image), filter_all);
int i;
for(i = 0; i < 5; i++) {
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser_image), supported[i]);
}
if (settings->image_file != NULL) {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(chooser_image), settings->image_file);
}
gtk_widget_set_size_request (chooser_image, INPUT_W, INPUT_H);
hbox_opacity = gtk_hbox_new(FALSE, 5);
label_opacity = gtk_label_new(g_strconcat(_("Opacity"), ":", NULL));
gtk_widget_set_size_request (label_opacity, LABEL_TRANSP_W, LABEL_TRANSP_H);
gtk_misc_set_alignment(GTK_MISC(label_opacity), 0.5, 0.8);
scale_opacity = gtk_hscale_new_with_range(1, 100, 1);
gtk_range_set_value(GTK_RANGE(scale_opacity), settings->opacity);
gtk_widget_set_size_request (scale_opacity, SCALE_TRANSP_W, SCALE_TRANSP_H);
label_percent = gtk_label_new("%");
gtk_widget_set_size_request (label_percent, LABEL_PERCENT_W, LABEL_PERCENT_H);
gtk_misc_set_alignment(GTK_MISC(label_percent), 0.5, 0.8);
frame_position = gtk_frame_new(g_strconcat(_("Position on the image"), ":", NULL));
gtk_widget_set_size_request (frame_position, FRAME_POSITION_W, FRAME_POSITION_H);
table_position = gtk_table_new(3, 3, TRUE);
button_tl = gtk_radio_button_new (NULL);
gtk_button_set_image(GTK_BUTTON(button_tl), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_postl, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_tl, watermark_pos_get_string(WM_POS_TL));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_tl), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_tl), settings->position == WM_POS_TL);
gtk_widget_set_size_request (button_tl, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_tl, 0, 1, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_tc = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_tc), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_postc, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_tc, watermark_pos_get_string(WM_POS_TC));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_tc), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_tc), settings->position == WM_POS_TC);
gtk_widget_set_size_request (button_tc, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_tc, 1, 2, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_tr = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_tr), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_postr, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_tr, watermark_pos_get_string(WM_POS_TR));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_tr), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_tr), settings->position == WM_POS_TR);
gtk_widget_set_size_request (button_tr, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_tr, 2, 3, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_cl = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_cl), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_poscl, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_cl, watermark_pos_get_string(WM_POS_CL));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_cl), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_cl), settings->position == WM_POS_CL);
gtk_widget_set_size_request (button_cl, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_cl, 0, 1, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_cc = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_cc), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_poscc, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_cc, watermark_pos_get_string(WM_POS_CC));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_cc), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_cc), settings->position == WM_POS_CC);
gtk_widget_set_size_request (button_cc, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_cc, 1, 2, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_cr = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_cr), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_poscr, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_cr, watermark_pos_get_string(WM_POS_CR));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_cr), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_cr), settings->position == WM_POS_CR);
gtk_widget_set_size_request (button_cr, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_cr, 2, 3, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_bl = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_bl), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_posbl, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_bl, watermark_pos_get_string(WM_POS_BL));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_bl), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_bl), settings->position == WM_POS_BL);
gtk_widget_set_size_request (button_bl, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_bl, 0, 1, 2, 3, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_bc = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_bc), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_posbc, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_bc, watermark_pos_get_string(WM_POS_BC));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_bc), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_bc), settings->position == WM_POS_BC);
gtk_widget_set_size_request (button_bc, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_bc, 1, 2, 2, 3, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_br = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_br), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_posbr, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_br, watermark_pos_get_string(WM_POS_BR));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_br), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_br), settings->position == WM_POS_BR);
gtk_widget_set_size_request (button_br, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_br, 2, 3, 2, 3, GTK_EXPAND, GTK_EXPAND, 0, 0);
gtk_box_pack_start(GTK_BOX(gui), radio_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_entry), label_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_entry), entry_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_font), label_font, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_font), chooser_font, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_color), label_color, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_color), chooser_color, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_text), hbox_text_entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_text), hbox_text_font, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_text), hbox_text_color, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align_radio_text), vbox_text);
gtk_box_pack_start(GTK_BOX(gui), align_radio_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), radio_image, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_image), chooser_image, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align_radio_image), vbox_image);
gtk_box_pack_start(GTK_BOX(gui), align_radio_image, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_opacity), label_opacity, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_opacity), scale_opacity, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_opacity), label_percent, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), hbox_opacity, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame_position), table_position);
gtk_box_pack_start(GTK_BOX(gui), frame_position, FALSE, FALSE, 0);
toggle_group(NULL, NULL);
g_signal_connect(G_OBJECT(radio_text), "toggled", G_CALLBACK(toggle_group), NULL);
return gui;
}
void
gui_create_about (GtkWidget *vbox_top, GUI *appGUI)
{
GtkWidget *hbox = NULL, *vbox = NULL;
GtkWidget *label;
GtkWidget *hseparator;
GtkWidget *logo_area;
GdkPixbuf *logo, *logo_scaled = NULL;
GtkWidget *viewport;
GtkWidget *hbuttonbox = NULL;
GSList *radiobutton_group = NULL;
char *str;
appGUI->about_counter = 0;
appGUI->about_vbox = GTK_BOX (vbox_top);
logo_area = gtk_image_new ();
logo = gdk_pixbuf_new_from_inline (-1, osmo_logo, FALSE, NULL);
gtk_widget_show (logo_area);
gtk_box_pack_start (GTK_BOX (vbox_top), logo_area, FALSE, TRUE, 0);
if (appGUI->tiny_gui == TRUE) {
logo_scaled = gdk_pixbuf_scale_simple (logo,
gdk_pixbuf_get_width (logo) / 2,
gdk_pixbuf_get_height (logo) / 2,
GDK_INTERP_HYPER);
}
#ifndef REV
str = g_strdup_printf ("%s %s", _("version"), VERSION);
#else
str = g_strdup_printf ("%s %d", _("SVN revision"), REV);
#endif
label = gtk_label_new (str);
g_free (str);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox_top), label, FALSE, TRUE, 4);
if (logo_scaled != NULL) {
gtk_image_set_from_pixbuf (GTK_IMAGE (logo_area), logo_scaled);
g_object_unref (logo_scaled);
} else {
gtk_image_set_from_pixbuf (GTK_IMAGE (logo_area), logo);
g_object_unref (logo);
}
/*--------------------------------------------------------------------------*/
vbox = gtk_vbox_new (FALSE, 4);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (vbox_top), vbox, FALSE, TRUE, 0);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 0);
if (appGUI->tiny_gui == TRUE) {
hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
} else {
hbuttonbox = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox);
gtk_box_pack_start (GTK_BOX (vbox), hbuttonbox, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
}
if (appGUI->tiny_gui == TRUE) {
appGUI->about_radiobutton = utl_gui_stock_label_radio_button (NULL, OSMO_STOCK_ABOUT, GTK_ICON_SIZE_LARGE_TOOLBAR);
} else {
appGUI->about_radiobutton = utl_gui_stock_label_radio_button (_("About"), OSMO_STOCK_ABOUT, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add (GTK_CONTAINER (hbuttonbox), appGUI->about_radiobutton);
}
gtk_widget_show (appGUI->about_radiobutton);
gtk_button_set_relief (GTK_BUTTON (appGUI->about_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS (appGUI->about_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (appGUI->about_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (appGUI->about_radiobutton));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (appGUI->about_radiobutton), TRUE);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (appGUI->about_radiobutton), FALSE);
g_signal_connect (G_OBJECT (appGUI->about_radiobutton), "released",
G_CALLBACK (button_released_cb), appGUI);
if (appGUI->tiny_gui == TRUE) {
appGUI->help_radiobutton = utl_gui_stock_label_radio_button (NULL, OSMO_STOCK_HELP, GTK_ICON_SIZE_LARGE_TOOLBAR);
} else {
appGUI->help_radiobutton = utl_gui_stock_label_radio_button (_("Key shortcuts"), OSMO_STOCK_HELP, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add (GTK_CONTAINER (hbuttonbox), appGUI->help_radiobutton);
}
gtk_widget_show (appGUI->help_radiobutton);
gtk_button_set_relief (GTK_BUTTON (appGUI->help_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS (appGUI->help_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (appGUI->help_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (appGUI->help_radiobutton));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (appGUI->help_radiobutton), FALSE);
g_signal_connect (G_OBJECT (appGUI->help_radiobutton), "released",
G_CALLBACK (button_released_cb), appGUI);
if (appGUI->tiny_gui == TRUE) {
appGUI->license_radiobutton = utl_gui_stock_label_radio_button (NULL, OSMO_STOCK_LICENSE, GTK_ICON_SIZE_LARGE_TOOLBAR);
} else {
appGUI->license_radiobutton = utl_gui_stock_label_radio_button (_("License"), OSMO_STOCK_LICENSE, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add (GTK_CONTAINER (hbuttonbox), appGUI->license_radiobutton);
}
gtk_widget_show (appGUI->license_radiobutton);
gtk_button_set_relief (GTK_BUTTON (appGUI->license_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS (appGUI->license_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (appGUI->license_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (appGUI->license_radiobutton));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (appGUI->license_radiobutton), FALSE);
g_signal_connect (G_OBJECT (appGUI->license_radiobutton), "released",
G_CALLBACK (button_released_cb), appGUI);
if (appGUI->tiny_gui == TRUE) {
gtk_box_pack_end (GTK_BOX (hbox), appGUI->license_radiobutton, FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (hbox), appGUI->help_radiobutton, FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (hbox), appGUI->about_radiobutton, FALSE, TRUE, 0);
}
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 0);
/*--------------------------------------------------------------------------*/
appGUI->scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox_top), appGUI->scrolled_window, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (appGUI->scrolled_window);
viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport);
gtk_container_set_border_width (GTK_CONTAINER (viewport), 0);
gtk_container_add (GTK_CONTAINER (appGUI->scrolled_window), viewport);
appGUI->about_entry_buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_get_iter_at_offset (appGUI->about_entry_buffer, &appGUI->about_entry_iter, 0);
gtk_text_buffer_create_tag (appGUI->about_entry_buffer, "fixed", "family", "monospace", NULL);
gtk_text_buffer_create_tag (appGUI->about_entry_buffer, "bold", "weight", PANGO_WEIGHT_ULTRABOLD, NULL);
gtk_text_buffer_create_tag (appGUI->about_entry_buffer, "big", "size", 16 * PANGO_SCALE, NULL);
gtk_text_buffer_create_tag (appGUI->about_entry_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL);
gtk_text_buffer_create_tag (appGUI->about_entry_buffer, "center", "justification", GTK_JUSTIFY_CENTER, NULL);
gtk_text_buffer_get_iter_at_offset (appGUI->about_entry_buffer, &appGUI->about_entry_iter, 0);
appGUI->about_textview = gtk_text_view_new_with_buffer (appGUI->about_entry_buffer);
gtk_container_set_border_width (GTK_CONTAINER (appGUI->about_textview), 1);
gtk_text_view_set_editable (GTK_TEXT_VIEW (appGUI->about_textview), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (appGUI->about_textview), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->about_textview), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (appGUI->about_textview), 2);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (appGUI->about_textview), 6);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (appGUI->about_textview), 6);
gtk_widget_show (appGUI->about_textview);
gtk_container_add (GTK_CONTAINER (viewport), appGUI->about_textview);
utl_gui_url_setup (&appGUI->about_links_list, &appGUI->about_link_index, appGUI->about_textview, appGUI);
display_about (appGUI);
}
static GtkWidget *
gradient_box_new (GimpContainer *container,
GimpContext *context,
const gchar *label,
gint spacing,
GimpViewType view_type,
GimpViewSize view_size,
const gchar *reverse_prop,
const gchar *editor_id,
const gchar *editor_tooltip)
{
GtkWidget *hbox;
GtkWidget *button;
GList *children;
if (! container)
container = gimp_data_factory_get_container (context->gimp->gradient_factory);
hbox = gimp_viewable_box_new (container, context, label, spacing,
view_type, GIMP_VIEW_SIZE_SMALL, view_size,
"gimp-gradient-list|gimp-gradient-grid",
GIMP_STOCK_GRADIENT,
_("Open the gradient selection dialog"),
editor_id, editor_tooltip);
children = gtk_container_get_children (GTK_CONTAINER (hbox));
button = children->data;
g_list_free (children);
GIMP_VIEWABLE_BUTTON (button)->button_view_size = GIMP_VIEW_SIZE_SMALL;
if (reverse_prop)
{
GtkWidget *toggle;
GtkWidget *view;
GtkWidget *image;
gchar *signal_name;
toggle = gimp_prop_check_button_new (G_OBJECT (context), reverse_prop,
NULL);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (hbox), toggle, 1);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle, _("Reverse"), NULL);
image = gtk_image_new_from_icon_name (GIMP_STOCK_FLIP_HORIZONTAL,
GTK_ICON_SIZE_MENU);
/* gimp_prop_check_button_new() adds the property nick as label of
* the button by default. */
gtk_container_remove (GTK_CONTAINER (toggle),
gtk_bin_get_child (GTK_BIN (toggle)));
gtk_container_add (GTK_CONTAINER (toggle), image);
gtk_widget_show (image);
view = gtk_bin_get_child (GTK_BIN (button));
signal_name = g_strconcat ("notify::", reverse_prop, NULL);
g_signal_connect_object (context, signal_name,
G_CALLBACK (gimp_gradient_box_reverse_notify),
G_OBJECT (view), 0);
g_free (signal_name);
gimp_gradient_box_reverse_notify (G_OBJECT (context),
NULL,
GIMP_VIEW (view));
}
return hbox;
}
void
gui_create_about(GtkWidget *notebook) {
GtkWidget *vbox1;
GtkWidget *label;
GtkWidget *hseparator;
GtkWidget *logo_area;
GdkPixbuf *logo;
GtkWidget *viewport;
GtkWidget *hbuttonbox;
GSList *radiobutton_group = NULL;
label = gtk_label_new(NULL);
gtk_label_set_angle (GTK_LABEL(label), -90.0);
gtk_label_set_markup (GTK_LABEL (label), _("About"));
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox1, label);
logo_area = gtk_image_new();
logo = gdk_pixbuf_new_from_inline(-1, osmo_logo, FALSE, NULL);
gtk_widget_show(logo_area);
gtk_box_pack_start (GTK_BOX (vbox1), logo_area, FALSE, TRUE, 0);
#ifndef REV
sprintf(tmpbuf, "%s %s", _("version"), VERSION);
#else
sprintf(tmpbuf, "%s %d", _("SVN revision"), REV);
#endif
label = gtk_label_new(tmpbuf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox1), label, FALSE, TRUE, 4);
gtk_image_set_from_pixbuf (GTK_IMAGE (logo_area), logo);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);
/*--------------------------------------------------------------------------*/
hbuttonbox = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
about_radiobutton = gui_image_label_radio_button(_("About"), osmo_stock_about);
gtk_widget_show (about_radiobutton);
gtk_button_set_relief (GTK_BUTTON (about_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS(about_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (about_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (about_radiobutton));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (about_radiobutton), TRUE);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (about_radiobutton), FALSE);
gtk_container_add (GTK_CONTAINER (hbuttonbox), about_radiobutton);
g_signal_connect (G_OBJECT (about_radiobutton), "released",
G_CALLBACK(button_released_cb), NULL);
help_radiobutton = gui_image_label_radio_button(_("Key shortcuts"), osmo_stock_help);
gtk_widget_show (help_radiobutton);
gtk_button_set_relief (GTK_BUTTON (help_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS(help_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (help_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (help_radiobutton));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (help_radiobutton), FALSE);
gtk_container_add (GTK_CONTAINER (hbuttonbox), help_radiobutton);
g_signal_connect (G_OBJECT (help_radiobutton), "released",
G_CALLBACK(button_released_cb), NULL);
license_radiobutton = gui_image_label_radio_button(_("License"), osmo_stock_license);
gtk_widget_show (license_radiobutton);
gtk_button_set_relief (GTK_BUTTON (license_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS(license_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (license_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (license_radiobutton));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (license_radiobutton), FALSE);
gtk_container_add (GTK_CONTAINER (hbuttonbox), license_radiobutton);
g_signal_connect (G_OBJECT (license_radiobutton), "released",
G_CALLBACK(button_released_cb), NULL);
/*--------------------------------------------------------------------------*/
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox1), scrolled_window, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolled_window);
viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport);
gtk_container_set_border_width (GTK_CONTAINER (viewport), 0);
gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
entry_buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_get_iter_at_offset (entry_buffer, &entry_iter, 0);
gtk_text_buffer_create_tag (entry_buffer, "bold", "weight", PANGO_WEIGHT_ULTRABOLD, NULL);
gtk_text_buffer_create_tag (entry_buffer, "big", "size", 16 * PANGO_SCALE, NULL);
gtk_text_buffer_create_tag (entry_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL);
gtk_text_buffer_create_tag (entry_buffer, "center", "justification", GTK_JUSTIFY_CENTER, NULL);
gtk_text_buffer_get_iter_at_offset (entry_buffer, &entry_iter, 0);
about_textview = gtk_text_view_new_with_buffer (entry_buffer);
gtk_container_set_border_width (GTK_CONTAINER (about_textview), 1);
gtk_text_view_set_editable(GTK_TEXT_VIEW (about_textview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (about_textview), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (about_textview), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(about_textview), 2);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(about_textview), 6);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(about_textview), 6);
gtk_widget_show (about_textview);
gtk_container_add (GTK_CONTAINER (viewport), about_textview);
gui_url_setup(&about_links_list, &about_link_index, about_textview);
display_about();
}
static void
gtk_radio_tool_button_init (GtkRadioToolButton *button)
{
GtkToolButton *tool_button = GTK_TOOL_BUTTON (button);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (_gtk_tool_button_get_button (tool_button)), FALSE);
}
/**
* gimp_enum_icon_box_new_with_range:
* @enum_type: the #GType of an enum.
* @minimum: the minumim enum value
* @maximum: the maximum enum value
* @icon_prefix: the prefix of the group of icon names to use.
* @icon_size: the icon size for the icons
* @callback: a callback to connect to the "toggled" signal of each
* #GtkRadioButton that is created.
* @callback_data: data to pass to the @callback.
* @first_button: returns the first button in the created group.
*
* Just like gimp_enum_icon_box_new(), this function creates a group
* of radio buttons, but additionally it supports limiting the range
* of available enum values.
*
* Return value: a new #GtkHBox holding a group of #GtkRadioButtons.
*
* Since: GIMP 2.10
**/
GtkWidget *
gimp_enum_icon_box_new_with_range (GType enum_type,
gint minimum,
gint maximum,
const gchar *icon_prefix,
GtkIconSize icon_size,
GCallback callback,
gpointer callback_data,
GtkWidget **first_button)
{
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *image;
GEnumClass *enum_class;
GEnumValue *value;
gchar *icon_name;
GSList *group = NULL;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
g_return_val_if_fail (icon_prefix != NULL, NULL);
enum_class = g_type_class_ref (enum_type);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
g_object_weak_ref (G_OBJECT (hbox),
(GWeakNotify) g_type_class_unref, enum_class);
if (first_button)
*first_button = NULL;
for (value = enum_class->values; value->value_name; value++)
{
if (value->value < minimum || value->value > maximum)
continue;
button = gtk_radio_button_new (group);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
if (first_button && *first_button == NULL)
*first_button = button;
icon_name = g_strconcat (icon_prefix, "-", value->value_nick, NULL);
image = gtk_image_new_from_icon_name (icon_name, icon_size);
g_free (icon_name);
if (image)
{
gtk_container_add (GTK_CONTAINER (button), image);
gtk_widget_show (image);
}
gimp_help_set_help_data (button,
gimp_enum_value_get_desc (enum_class, value),
NULL);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (value->value));
if (callback)
g_signal_connect (button, "toggled",
callback,
callback_data);
}
return hbox;
}
void create_xosd_gui(Sven *sven,GtkWidget *vbox)
{
GtkWidget *hbox,*hbox1, *label,*unit_label,*button1;
GtkWidget *table, **position_icons, *position_table,*sep,*button;
GdkColor *colors;
gint n_colors;
Gtk_Osd_Pos curr_pos;
Gtk_Osd_Align curr_align;
GSList *group = NULL;
gtk_box_pack_start (GTK_BOX (vbox),(gpointer )create_header(_("XOSD")), FALSE, FALSE, 0);
table = gtk_table_new (7,2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 12);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
// Font selector.
label = gtk_label_new (_("Font:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0,0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
if(sven->osd->font!=NULL)
font_entry = gtk_font_button_new_with_font (sven->osd->font);
else
font_entry = gtk_font_button_new_with_font ("Sans 18");
gtk_table_attach (GTK_TABLE (table), font_entry, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
//Colour Selector
label = gtk_label_new (_("Colour:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_color_selection_palette_from_string (sven->osd->color,&colors,&n_colors);
colour_entry = gtk_color_button_new_with_color (colors);
gtk_table_attach (GTK_TABLE (table), colour_entry, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
//Timeout
label = gtk_label_new (_("Timeout:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0,0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
timeout_obj = gtk_adjustment_new (sven->osd->timeout, -1, 60, 1, 1, 1);
timeout_spin = gtk_spin_button_new (GTK_ADJUSTMENT (timeout_obj), 1.0, 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (timeout_spin),
(gfloat) sven->osd->timeout);
gtk_box_pack_start (GTK_BOX (hbox), timeout_spin, FALSE, FALSE, 0);
unit_label = gtk_label_new (_("seconds"));
gtk_misc_set_alignment (GTK_MISC (unit_label),0.0, 0.0);
gtk_label_set_justify (GTK_LABEL (unit_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start (GTK_BOX (hbox), unit_label, FALSE, FALSE, 0);
// Position
label = gtk_label_new (_("Position:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0,0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3,4,GTK_FILL, GTK_FILL, 0, 0);
position_icons = position_icons_new ();
position_table = gtk_table_new (3, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (position_table), 6);
gtk_table_set_col_spacings (GTK_TABLE (position_table), 6);
gtk_table_attach (GTK_TABLE (table), position_table, 1, 2, 3,4,GTK_FILL, GTK_FILL, 0, 0);
curr_pos = GTK_OSD_TOP;
for (curr_align = GTK_OSD_LEFT; curr_align <= GTK_OSD_RIGHT; curr_align++)
{
positions[curr_pos][curr_align] = gtk_radio_button_new (group);
gtk_container_add (GTK_CONTAINER (positions[curr_pos][curr_align]),position_icons[(curr_pos * 3) + curr_align]);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]), FALSE);
group =gtk_radio_button_group (GTK_RADIO_BUTTON(positions[curr_pos][curr_align]));
if (sven->osd->pos == curr_pos && sven->osd->align == curr_align)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]),TRUE);
}
gtk_table_attach (GTK_TABLE (position_table),positions[curr_pos][curr_align],curr_align, curr_align + 1,curr_pos, curr_pos + 1, GTK_FILL, GTK_FILL, 0, 0);
}
curr_pos = GTK_OSD_MIDDLE;
for (curr_align = GTK_OSD_LEFT; curr_align <= GTK_OSD_RIGHT; curr_align++)
{
positions[curr_pos][curr_align] = gtk_radio_button_new (group);
gtk_container_add (GTK_CONTAINER (positions[curr_pos][curr_align]),position_icons[(curr_pos * 3) + curr_align]);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]), FALSE);
group =gtk_radio_button_group (GTK_RADIO_BUTTON(positions[curr_pos][curr_align]));
if (sven->osd->pos == curr_pos && sven->osd->align == curr_align)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]),TRUE);
}
gtk_table_attach (GTK_TABLE (position_table),positions[curr_pos][curr_align],curr_align, curr_align + 1,1, 2, GTK_FILL, GTK_FILL, 0, 0);
}
curr_pos = GTK_OSD_BOTTOM;
for (curr_align = GTK_OSD_LEFT; curr_align <= GTK_OSD_RIGHT; curr_align++)
{
positions[curr_pos][curr_align] = gtk_radio_button_new (group);
gtk_container_add (GTK_CONTAINER (positions[curr_pos][curr_align]),position_icons[(curr_pos * 3) + curr_align]);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]), FALSE);
group =gtk_radio_button_group (GTK_RADIO_BUTTON(positions[curr_pos][curr_align]));
if (sven->osd->pos == curr_pos && sven->osd->align == curr_align)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]),TRUE);
}
gtk_table_attach (GTK_TABLE (position_table),positions[curr_pos][curr_align],curr_align, curr_align + 1,2, 3, GTK_FILL, GTK_FILL, 0, 0);
}
// Vertical Offset
label = gtk_label_new (_("Vertical Offset:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4,5,GTK_FILL, GTK_FILL, 0, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 4, 5,GTK_FILL, GTK_FILL, 0, 0);
offset_obj = gtk_adjustment_new (sven->osd->timeout, 0, 300, 1, 1, 1);
offset_spin = gtk_spin_button_new (GTK_ADJUSTMENT (offset_obj), 1.0, 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (offset_spin), sven->osd->voffset);
gtk_box_pack_start (GTK_BOX (hbox), offset_spin, FALSE, FALSE, 0);
unit_label = gtk_label_new (_("pixels"));
gtk_misc_set_alignment (GTK_MISC (unit_label), 0.0, 0.0);
gtk_label_set_justify (GTK_LABEL (unit_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start (GTK_BOX (hbox), unit_label, FALSE, FALSE, 0);
// Horizontal Offset
label = gtk_label_new (_("Horizontal Offset:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 5,6,GTK_FILL, GTK_FILL, 0, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 5,6,GTK_FILL, GTK_FILL, 0, 0);
h_offset_obj = gtk_adjustment_new (sven->osd->timeout, 0, 300, 1, 1, 1);
h_offset_spin = gtk_spin_button_new (GTK_ADJUSTMENT (h_offset_obj), 1.0, 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (h_offset_spin), sven->osd->hoffset);
gtk_box_pack_start (GTK_BOX (hbox), h_offset_spin, FALSE, FALSE, 0);
unit_label = gtk_label_new (_("pixels"));
gtk_misc_set_alignment (GTK_MISC (unit_label), 0.0, 0.0);
gtk_label_set_justify (GTK_LABEL (unit_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start (GTK_BOX (hbox), unit_label, FALSE, FALSE, 0);
// Background color
label = gtk_label_new (_("Background Color:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6,7,GTK_FILL, GTK_FILL, 0, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 6,7,GTK_FILL, GTK_FILL, 0, 0);
bg_color_enable=gtk_check_button_new_with_mnemonic (_("Enable"));
gtk_box_pack_start (GTK_BOX (hbox), bg_color_enable, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (bg_color_enable), sven->osd->bg_color_on);
gtk_color_selection_palette_from_string (sven->osd->bg_color,&colors,&n_colors);
bg_color = gtk_color_button_new_with_color (colors);
gtk_box_pack_start (GTK_BOX (hbox), bg_color, FALSE, FALSE, 0);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 10);
hbox1 = gtk_hbox_new (TRUE, 10);
gtk_widget_show (hbox1);
enable_xosd = gtk_check_button_new_with_mnemonic (_("Enable XOSD"));
gtk_widget_show (enable_xosd);
gtk_box_pack_start (GTK_BOX (hbox1), enable_xosd, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enable_xosd), sven->osd->osd_on);
enable_frame = gtk_check_button_new_with_mnemonic (_("Enable Frame"));
gtk_widget_show (enable_frame);
gtk_box_pack_start (GTK_BOX (hbox1), enable_frame, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enable_frame), sven->osd->debug_frame);
enable_shadow = gtk_check_button_new_with_mnemonic (_("Enable Shadow"));
gtk_widget_show (enable_shadow);
gtk_box_pack_start (GTK_BOX (hbox1), enable_shadow, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enable_shadow), sven->osd->drop_shadow);
gtk_box_pack_start (GTK_BOX (vbox), hbox1, FALSE, FALSE, 0);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE,5);
button1 = gtk_button_new_with_mnemonic (_("Test OSD"));
gtk_widget_show (button1);
gtk_box_pack_start (GTK_BOX (vbox), button1, FALSE, FALSE, 5);
g_signal_connect(button1, "clicked", G_CALLBACK(test_osd),sven);
gtk_widget_show_all (vbox);
}
int main( int argc, char **argv )
{
new CScene;
new TextureMgr;
GtkWidget* table;
GdkGLConfig* GLconf;
GdkGLContext* GLContext;
GtkWidget* v_box;
gtk_init( &argc, &argv );
gtk_gl_init( &argc, &argv );
da = gtk_drawing_area_new();
GLconf = gdk_gl_config_new_by_mode( (GdkGLConfigMode)(GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE) );
if( !( GLconf ) || !( gtk_widget_set_gl_capability( da, GLconf, NULL, TRUE, GDK_GL_RGBA_TYPE ) ) )
g_assert_not_reached();
g_signal_connect_after( G_OBJECT( da ), "realize", G_CALLBACK( realize_main ), NULL );
g_signal_connect( da, "configure_event", G_CALLBACK( configure ), NULL );
g_signal_connect( da, "expose_event", G_CALLBACK( expose ), NULL );
gtk_widget_show( da );
gtk_widget_realize( da );
//GLContext = gtk_widget_get_gl_context( da );
g_signal_connect_after( G_OBJECT( da ), "realize", G_CALLBACK( realize_sub ), NULL );
g_signal_connect( da, "configure_event", G_CALLBACK( configure ), NULL );
g_signal_connect( da, "expose_event", G_CALLBACK( expose ), NULL );
g_signal_connect( G_OBJECT( da ), "motion_notify_event", G_CALLBACK( mouse_motion_cb ), (gpointer)Window );
g_signal_connect( G_OBJECT( da ), "button_press_event", G_CALLBACK( mouse_click_cb ), (gpointer)Window );
g_signal_connect( G_OBJECT( da ), "button_release_event", G_CALLBACK( mouse_click_cb ), (gpointer)Window );
g_signal_connect( G_OBJECT( da ), "scroll_event", G_CALLBACK( mouse_scroll_cb ), (gpointer)Window );
g_signal_connect( G_OBJECT( da ), "key_press_event", G_CALLBACK( keyPress ), (gpointer)Window );
gtk_widget_show ( da );
Window = gtk_window_new( GTK_WINDOW_TOPLEVEL ); /// WINDOW
gtk_window_set_default_size( GTK_WINDOW(Window), 800, 500 );
gtk_window_set_title (GTK_WINDOW (Window), "Stilewski's Plant Generator");
gtk_window_set_position (GTK_WINDOW (Window), GTK_WIN_POS_CENTER);
g_signal_connect_swapped( Window, "destroy", G_CALLBACK( gtk_main_quit ), NULL );
v_box = gtk_vbox_new( FALSE, 0 );
gtk_container_add( GTK_CONTAINER( Window ), v_box );
gtk_box_pack_start( GTK_BOX( v_box ), construct_menu(), TRUE, TRUE, 0 ); /// MAIN MENU
table = gtk_table_new( 16, 16, FALSE ); /// TABLE
gtk_table_set_col_spacing( GTK_TABLE(table), 11, 8 );
gtk_table_set_row_spacing( GTK_TABLE(table), 13, 8 );
gtk_table_attach_defaults( GTK_TABLE(table), da, 0, 12, 0, 14 ); /// DRAWING AREA
gtk_table_attach_defaults( GTK_TABLE(table), construct_side_panel(), 12, 16, 0, 16 ); /// SIDE PANEL
gtk_table_attach_defaults( GTK_TABLE(table), construct_bottom_panel(), 0, 12, 14, 16 ); /// BOTTOM PANEL
gtk_box_pack_start( GTK_BOX( v_box ), table, TRUE, TRUE, 0 );
gtk_box_pack_start( GTK_BOX( v_box ), construct_statusbar(), TRUE, TRUE, 0 ); /// STATUS BAR
gtk_widget_set_events
(
da,
GDK_EXPOSURE_MASK |
GDK_SCROLL_MASK |
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_KEY_PRESS_MASK
);
gtk_toggle_button_set_mode( GTK_TOGGLE_BUTTON( checkBoxRandom ), TRUE );
gtk_widget_show( Window );
plant = new CPlant();
InitGL();
gtk_widget_show_all( Window );
g_timeout_add( 1000 / 60, applyChanges, da );
gtk_main();
}
void
sp_text_edit_dialog (void)
{
if (!dlg) {
GtkWidget *mainvb, *nb, *vb, *hb, *txt, *fontsel, *preview, *f, *tbl, *l, *px, *c, *b, *hs;
GtkTextBuffer *tb;
GList *sl;
int i;
gchar title[500];
sp_ui_dialog_title_string (SP_VERB_DIALOG_TEXT, title);
dlg = sp_window_new (title, TRUE);
if (x == -1000 || y == -1000) {
x = prefs_get_int_attribute (prefs_path, "x", 0);
y = prefs_get_int_attribute (prefs_path, "y", 0);
}
if (w ==0 || h == 0) {
w = prefs_get_int_attribute (prefs_path, "w", 0);
h = prefs_get_int_attribute (prefs_path, "h", 0);
}
if (x != 0 || y != 0)
gtk_window_move ((GtkWindow *) dlg, x, y);
else
gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h);
sp_transientize (dlg);
wd.win = dlg;
wd.stop = 0;
g_signal_connect (G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd);
gtk_signal_connect (GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_text_edit_dialog_destroy), dlg);
gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_text_edit_dialog_delete), dlg);
g_signal_connect (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_text_edit_dialog_delete), dlg);
gtk_window_set_policy (GTK_WINDOW (dlg), TRUE, TRUE, FALSE);
mainvb = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (dlg), mainvb);
nb = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (nb), 4);
gtk_box_pack_start (GTK_BOX (mainvb), nb, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "notebook", nb);
/* Vbox inside notebook */
vb = gtk_vbox_new (FALSE, 0);
/* Textview */
f = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (f), GTK_SHADOW_IN);
tb = gtk_text_buffer_new (NULL);
txt = gtk_text_view_new_with_buffer (tb);
gtk_widget_set_size_request (txt, -1, 64);
gtk_text_view_set_editable (GTK_TEXT_VIEW (txt), TRUE);
gtk_container_add (GTK_CONTAINER (f), txt);
gtk_box_pack_start (GTK_BOX (vb), f, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (tb), "changed", G_CALLBACK (sp_text_edit_dialog_text_changed), dlg);
g_object_set_data (G_OBJECT (dlg), "text", tb);
g_object_set_data (G_OBJECT (dlg), "textw", txt);
/* HBox containing font selection and layout */
hb = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vb), hb, TRUE, TRUE, 0);
fontsel = sp_font_selector_new ();
g_signal_connect (G_OBJECT (fontsel), "font_set", G_CALLBACK (sp_text_edit_dialog_font_changed), dlg);
gtk_box_pack_start (GTK_BOX (hb), fontsel, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "fontsel", fontsel);
/* Layout */
f = gtk_frame_new (_("Layout"));
gtk_box_pack_start (GTK_BOX (hb), f, FALSE, FALSE, 4);
tbl = gtk_table_new (3, 4, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (tbl), 4);
gtk_table_set_col_spacings (GTK_TABLE (tbl), 4);
gtk_container_add (GTK_CONTAINER (f), tbl);
l = gtk_label_new (_("Alignment:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (NULL);
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 1, 2, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_start", b);
px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 2, 3, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_middle", b);
px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 3, 4, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_end", b);
l = gtk_label_new (_("Orientation:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
px = gtk_image_new_from_stock (INKSCAPE_STOCK_WRITING_MODE_LR, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (NULL);
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 1, 2, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "writing_mode_lr", b);
px = gtk_image_new_from_stock (INKSCAPE_STOCK_WRITING_MODE_TB, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 2, 3, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "writing_mode_tb", b);
l = gtk_label_new (_("Line spacing:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);
c = gtk_combo_new ();
gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE);
gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE);
gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE);
gtk_widget_set_size_request (c, 64, -1);
/* Setup strings */
sl = NULL;
for (i = 0; spacings[i]; i++) {
sl = g_list_prepend (sl, (void *) spacings[i]);
}
sl = g_list_reverse (sl);
gtk_combo_set_popdown_strings ((GtkCombo *) c, sl);
g_list_free (sl);
g_signal_connect ((GObject *) ((GtkCombo *) c)->entry, "changed", (GCallback) sp_text_edit_dialog_line_spacing_changed, dlg);
gtk_table_attach (GTK_TABLE (tbl), c, 1, 4, 2, 3, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
g_object_set_data (G_OBJECT (dlg), "line_spacing", c);
/* Font preview */
preview = sp_font_preview_new ();
gtk_box_pack_start (GTK_BOX (vb), preview, TRUE, TRUE, 4);
g_object_set_data (G_OBJECT (dlg), "preview", preview);
l = gtk_label_new (_("Text and font"));
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);
/* Buttons */
hs = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (mainvb), hs, FALSE, FALSE, 0);
hb = gtk_hbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (hb), 4);
gtk_box_pack_start (GTK_BOX (mainvb), hb, FALSE, FALSE, 0);
b = gtk_button_new_with_label (_("Set as default"));
g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_set_default), dlg);
gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "default", b);
b = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_close), dlg);
gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
b = gtk_button_new_from_stock (GTK_STOCK_APPLY);
g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_apply), dlg);
gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "apply", b);
g_signal_connect (G_OBJECT (INKSCAPE), "modify_selection", G_CALLBACK (sp_text_edit_dialog_modify_selection), dlg);
g_signal_connect (G_OBJECT (INKSCAPE), "change_selection", G_CALLBACK (sp_text_edit_dialog_change_selection), dlg);
sp_text_edit_dialog_read_selection (dlg, TRUE, TRUE);
gtk_widget_show_all (dlg);
}
gtk_window_present ((GtkWindow *) dlg);
}
void CreateOneToolbar( GtkWidget * Box, int NumTable, short int PtrOnToolBarElementsList[][NBR_ELE_TOOLBAR_X_MAX], char * PtrOnToolTipsText[][NBR_ELE_TOOLBAR_X_MAX] )
{
int CurrentAvail = 0;
while( ToolbarBtnRadio[ CurrentAvail ]!=NULL && CurrentAvail<NBR_ELE_IN_TOOLBAR )
CurrentAvail++;
if ( CurrentAvail<NBR_ELE_IN_TOOLBAR )
{
StrElement ToolBarEle;
int ScanToolBarX,ScanToolBarY;
GSList * PtrListRadiosBtn = NULL;
ScanToolBarX = 0;
ScanToolBarY = 0;
ToolbarTable[ NumTable ] = gtk_table_new( NBR_ELE_TOOLBAR_X_MAX, NBR_ELE_TOOLBAR_Y_MAX, FALSE/*homogeneous*/ );
gtk_box_pack_start (GTK_BOX(Box), ToolbarTable[ NumTable ], TRUE, TRUE, 0);
do
{
ToolBarEle.Type = PtrOnToolBarElementsList[ScanToolBarY][ScanToolBarX];
ToolBarEle.ConnectedWithTop = 0;
if ( ToolBarEle.Type==EDIT_POINTER )
{
if ( PtrOnToolBarElementsList!=ToolBarElementsSequential )
NumWidgetEditPointer[ NUM_TOOLBAR_FOR_RUNGS ] = CurrentAvail;
else
NumWidgetEditPointer[ NUM_TOOLBAR_FOR_SEQ ] = CurrentAvail;
}
if ( ToolBarEle.Type!=0 )
{
GdkGC * gc = drawing_area->style->bg_gc[0];
char * pHelpText = PtrOnToolTipsText[ ScanToolBarY ][ ScanToolBarX ];
ToolbarPixmap[ CurrentAvail ] = gdk_pixmap_new( GDK_DRAWABLE(drawing_area->window), PIXELS_SIZE_IN_TOOLBAR, PIXELS_SIZE_IN_TOOLBAR, -1 );
gdk_draw_rectangle (GDK_DRAWABLE(ToolbarPixmap[ CurrentAvail ]), gc, TRUE, 0, 0, PIXELS_SIZE_IN_TOOLBAR, PIXELS_SIZE_IN_TOOLBAR);
#ifdef SEQUENTIAL_SUPPORT
if ( PtrOnToolBarElementsList==ToolBarElementsSequential )
DrawSeqElementForToolBar(ToolbarPixmap[ CurrentAvail ], 0, 0, PIXELS_SIZE_IN_TOOLBAR, ToolBarEle.Type );
else
#endif
DrawElement(ToolbarPixmap[ CurrentAvail ], 0, 0, PIXELS_SIZE_IN_TOOLBAR, PIXELS_SIZE_IN_TOOLBAR, ToolBarEle, TRUE);
ToolbarImage[ CurrentAvail ] = gtk_image_new_from_pixmap( ToolbarPixmap[ CurrentAvail ], NULL );
ToolbarBtnRadio[ CurrentAvail ] = gtk_radio_button_new( PtrListRadiosBtn );
PtrListRadiosBtn = gtk_radio_button_get_group (GTK_RADIO_BUTTON(ToolbarBtnRadio[ CurrentAvail ]));
gtk_button_set_relief (GTK_BUTTON( ToolbarBtnRadio[ CurrentAvail ] ), GTK_RELIEF_NONE);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(ToolbarBtnRadio[ CurrentAvail ]), FALSE);
gtk_container_add( GTK_CONTAINER( ToolbarBtnRadio[ CurrentAvail ] ), ToolbarImage[ CurrentAvail ] );
gtk_widget_show( ToolbarImage[ CurrentAvail ] );
gtk_table_attach( GTK_TABLE( ToolbarTable[ NumTable ] ), ToolbarBtnRadio[ CurrentAvail ],
ScanToolBarX, ScanToolBarX+1, ScanToolBarY, ScanToolBarY+1,
0, 0, 0, 0 );
gtk_signal_connect( GTK_OBJECT (ToolbarBtnRadio[ CurrentAvail ]), "clicked", (GtkSignalFunc) ButtonToolbarSignal, GINT_TO_POINTER((int)ToolBarEle.Type) );
if (pHelpText!=NULL )
gtk_tooltips_set_tip (TheTooltips, ToolbarBtnRadio[ CurrentAvail ], pHelpText, NULL);
gtk_widget_show( ToolbarBtnRadio[ CurrentAvail ] );
CurrentAvail++;
}//if ( ToolBarEle.Type!=0 )
ScanToolBarX++;
if (ScanToolBarX>=NBR_ELE_TOOLBAR_X_MAX)
{
ScanToolBarX = 0;
ScanToolBarY++;
}
}
while( PtrOnToolBarElementsList[ScanToolBarY][ScanToolBarX]!=-1 );
}
}
