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 ); } }