static SeahorseKeyserverResultsRow*
seahorse_keyserver_results_row_new (GObject *item)
{
g_autoptr(SeahorseKeyserverResultsRow) row = NULL;
g_autoptr(GtkWidget) grid = NULL;
g_autoptr(GtkWidget) label = NULL;
g_autoptr(GtkWidget) import_button = NULL;
gchar *item_label;
gboolean item_exportable;
g_object_get (item, "markup", &item_label, "exportable", &item_exportable,
NULL);
row = g_object_new (SEAHORSE_TYPE_KEYSERVER_RESULTS_ROW, NULL);
gtk_list_box_row_set_selectable (GTK_LIST_BOX_ROW (row), FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (row), item_exportable);
gtk_widget_show (GTK_WIDGET (row));
row->key = item;
grid = gtk_grid_new ();
g_object_set (grid, "margin", 6, NULL);
gtk_widget_show (grid);
label = gtk_label_new (item_label);
gtk_widget_set_hexpand (label, TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), g_steal_pointer (&label), 0, 0, 1, 1);
import_button = gtk_button_new_from_icon_name ("document-save-symbolic",
GTK_ICON_SIZE_BUTTON);
row->import_button = GTK_BUTTON (import_button);
g_signal_connect_object (import_button, "clicked",
G_CALLBACK (on_import_button_clicked), row, 0);
gtk_widget_set_visible (import_button, TRUE);
gtk_widget_set_valign (import_button, GTK_ALIGN_START);
gtk_widget_set_halign (import_button, GTK_ALIGN_END);
gtk_style_context_add_class (gtk_widget_get_style_context (import_button),
"flat");
if (item_exportable)
gtk_widget_set_tooltip_text (import_button, _("Import"));
else
gtk_widget_set_tooltip_text (import_button, _("Can’t import key"));
gtk_grid_attach (GTK_GRID (grid), g_steal_pointer (&import_button), 1, 0, 1, 1);
gtk_container_add (GTK_CONTAINER (row), g_steal_pointer (&grid));
return g_steal_pointer (&row);
}
GtkWidget *
pragha_hig_workarea_table_new()
{
GtkWidget *table;
table = gtk_grid_new ();
gtk_container_set_border_width(GTK_CONTAINER(table), 12);
gtk_grid_set_row_spacing (GTK_GRID(table), 12);
gtk_grid_set_column_spacing (GTK_GRID(table), 6);
return table;
}
static GtkWidget* do_config (MaintainrProjectbox *item)
{
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *hbox;
GtkWidget *button;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_widget_set_halign (vbox, GTK_ALIGN_CENTER);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
table = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (table), 5);
gtk_container_set_border_width (GTK_CONTAINER (table), 0);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
gtk_widget_set_hexpand (table, TRUE);
item->priv->project_name = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (item->priv->project_name), "Untitled");
gtk_grid_attach (GTK_GRID (table), gtk_label_new ("Name"), 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (table), item->priv->project_name, 1, 0, 1, 1);
item->priv->priority = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (item->priv->priority), NULL, "High");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (item->priv->priority), NULL, "Medium");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (item->priv->priority), NULL, "Low");
gtk_grid_attach (GTK_GRID (table), gtk_label_new ("Priority"), 0, 1, 1, 1);
gtk_grid_attach (GTK_GRID (table), item->priv->priority, 1, 1, 1, 1);
item->priv->services_confs = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox), item->priv->services_confs, TRUE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("edit-delete", GTK_ICON_SIZE_BUTTON));
gtk_widget_set_tooltip_text (button, "Remove this project from the list");
g_signal_connect (button, "clicked", G_CALLBACK (delete_project), item);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("document-save", GTK_ICON_SIZE_BUTTON));
gtk_widget_set_tooltip_text (button, "Save settings and back to the main screen");
g_signal_connect (button, "clicked", G_CALLBACK (save_conf), item);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
return vbox;
}
void generaCapacidadU(GtkWidget *widget, gpointer user_data)
{
GtkWidget *table;
GtkWidget *createKnapsack;
table = gtk_grid_new();
capacidades= calloc(nObjetos+1,sizeof(GtkWidget));
int i;
for(i=0; i<nObjetos+1;i++)
capacidades[i]=calloc(nObjetos+1,sizeof(GtkWidget));
gtk_container_add (GTK_CONTAINER (SRWindowCapacity), table);
int x;
int y;
for(x=0;x<3;x++){
for(y=0; y<nObjetos+1;y++){
GtkWidget *label;
printf("x= %d y y=%d\n",x,y );
if(x==0 && y==0){
label=gtk_label_new ("Objetos");
gtk_grid_attach (GTK_GRID (table), label, x, y, 1, 1);
}else{
if(y==0){
if(x==1){
label=gtk_label_new("Valor");
}else if(x==2){
label=gtk_label_new("Peso");
}
gtk_grid_attach (GTK_GRID (table), label, x, y, 1, 1);
}else if(x==0){
label=gtk_label_new(gtk_entry_get_text (objetos[y-1]));
gtk_grid_attach (GTK_GRID (table), label, x, y, 1, 1);
}else{
GtkWidget *entry;
entry = gtk_entry_new ();
gtk_grid_attach (GTK_GRID (table), entry, x, y, 1, 1);
printf("Almacenando en x= %d y y=%d\n",x,y);
capacidades[x-1][y-1]= entry;
printf("Almacenando en x-1= %d y y-1=%d\n",x-1,y-1);
}
}//fin if
}// end primer for
}//end for
createKnapsack = gtk_button_new_with_label("Ejecutar algoritmo Unbounded Knapsack");
g_signal_connect (createKnapsack, "clicked", G_CALLBACK (ejecutarUnboundedKnapsack), NULL);
gtk_grid_attach (GTK_GRID (table), createKnapsack, 1, nObjetos+2, 1, 1);
gtk_widget_show_all (window);
printf("Salgo de la funcion\n");
}
/* test custom positioning */
static GtkWidget *
test_relative (void)
{
GtkWidget *win;
GtkWidget *grid;
GtkWidget *overlay;
GtkWidget *text;
GtkWidget *child;
GdkRGBA color;
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (win), "Custom positioning");
overlay = gtk_overlay_new ();
gdk_rgba_parse (&color, "yellow");
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_widget_override_background_color (overlay, 0, &color);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_container_add (GTK_CONTAINER (win), overlay);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (overlay), grid);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Above"), 1, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Below"), 1, 2, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Left"), 0, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Right"), 2, 1, 1, 1);
text = gtk_text_view_new ();
gtk_widget_set_size_request (text, 200, 200);
g_object_set (text, "margin", 5, NULL);
gtk_widget_set_hexpand (text, TRUE);
gtk_widget_set_vexpand (text, TRUE);
gtk_grid_attach (GTK_GRID (grid), text, 1, 1, 1, 1);
g_signal_connect (overlay, "get-child-position",
G_CALLBACK (get_child_position), text);
child = gtk_label_new ("Top left overlay");
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_object_set (child, "margin", 1, NULL);
child = gtk_label_new ("Bottom right overlay");
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_END);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_object_set (child, "margin", 1, NULL);
return win;
}
static void
activate (GtkApplication *app,
gpointer user_data)
{
/* Declare variables */
GtkWidget *window;
GtkWidget *label;
GtkWidget *grid;
GtkWidget *spin_button;
GtkAdjustment *adjustment;
/* Create a window with a title, a border width, and a default size */
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "SpinButton Example");
gtk_window_set_default_size (GTK_WINDOW (window), 210, 70);
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
/* Create a label to be shown in the window */
label = gtk_label_new ("Choose a number");
/* Create an adjustment representing an adjustable bounded value */
adjustment = gtk_adjustment_new (0, 0, 100, 1, 0, 0);
/* Create a spin button that is to be as wide as possible */
spin_button = gtk_spin_button_new (adjustment, 1, 0);
gtk_widget_set_hexpand (spin_button, TRUE);
/* Connecting the "value-changed" signal for the spinbutton
* to the appropriate callback function.
*/
g_signal_connect (spin_button,
"value-changed",
G_CALLBACK (spin_clicked),
label);
/* Create a grid and arrange everything accordingly */
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE);
gtk_grid_attach (GTK_GRID (grid), spin_button, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
gtk_container_add (GTK_CONTAINER (window), grid);
gtk_widget_show_all (window);
}
GtkWidget*sc_image_text_item_new(const guint8*data,const char*text,int siz)
{
GtkWidget*image;
GtkWidget*item=gtk_menu_item_new();
GtkWidget*box=gtk_grid_new();//gtk_box_new(GTK_ORIENTATION_HORIZONTAL,2);
GtkWidget*label=gtk_label_new(text);
gtk_label_set_justify(GTK_LABEL(label),GTK_JUSTIFY_RIGHT);
gtk_widget_set_hexpand(label,TRUE);
gtk_widget_set_halign(label,GTK_ALIGN_START);
GdkPixbuf*pxf=gdk_pixbuf_new_from_inline(-1,data,FALSE,NULL);
GdkPixbuf*real_pxf;
if(!pxf) {
image=gtk_image_new_from_icon_name("image-x-generic",GTK_ICON_SIZE_BUTTON);
} else {
real_pxf=gdk_pixbuf_scale_simple(pxf,siz,siz,GDK_INTERP_HYPER);
g_object_unref(pxf);
image=gtk_image_new_from_pixbuf(real_pxf);
g_object_set(image,"pixel-size",GTK_IMAGE_PIXBUF,NULL);
}
g_object_unref(real_pxf);
// gtk_widget_set_hexpand(image,FALSE);
// gtk_widget_set_halign(image,GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(box),image,0,0,1,1);
gtk_grid_attach(GTK_GRID(box),label,1,0,1,1);
gtk_grid_set_column_spacing(GTK_GRID(box),20);
// gtk_box_pack_start(GTK_BOX(box),image,TRUE,FALSE,0);
// gtk_box_pack_end(GTK_BOX(box),label,TRUE,TRUE,0);
gtk_container_add(GTK_CONTAINER(item),box);
gtk_container_set_border_width(GTK_CONTAINER(box),0);
gtk_container_set_border_width(GTK_CONTAINER(item),0);
return item;
}
static GtkWidget *
test_stacking (void)
{
GtkWidget *win;
GtkWidget *overlay;
GtkWidget *main_child;
GtkWidget *label;
GtkWidget *child;
GtkWidget *grid;
GtkWidget *check1;
GtkWidget *check2;
GdkRGBA color;
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (win), "Stacking");
grid = gtk_grid_new ();
overlay = gtk_overlay_new ();
main_child = gtk_event_box_new ();
gdk_rgba_parse (&color, "green");
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_widget_override_background_color (main_child, 0, &color);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_widget_set_hexpand (main_child, TRUE);
gtk_widget_set_vexpand (main_child, TRUE);
label = gtk_label_new ("Main child");
child = gtk_label_new ("Overlay");
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_END);
check1 = gtk_check_button_new_with_label ("Show main");
g_object_bind_property (main_child, "visible", check1, "active", G_BINDING_BIDIRECTIONAL);
check2 = gtk_check_button_new_with_label ("Show overlay");
g_object_bind_property (child, "visible", check2, "active", G_BINDING_BIDIRECTIONAL);
gtk_container_add (GTK_CONTAINER (main_child), label);
gtk_container_add (GTK_CONTAINER (overlay), main_child);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
gtk_grid_attach (GTK_GRID (grid), overlay, 1, 0, 1, 3);
gtk_container_add (GTK_CONTAINER (win), grid);
gtk_grid_attach (GTK_GRID (grid), check1, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check2, 0, 1, 1, 1);
child = gtk_label_new ("");
gtk_widget_set_vexpand (child, TRUE);
gtk_grid_attach (GTK_GRID (grid), child, 0, 2, 1, 1);
return win;
}
void gui_init(dt_lib_module_t *self)
{
dt_lib_select_t *d = (dt_lib_select_t *)malloc(sizeof(dt_lib_select_t));
self->data = d;
self->widget = gtk_grid_new();
GtkGrid *grid = GTK_GRID(self->widget);
gtk_grid_set_row_spacing(grid, DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_spacing(grid, DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_homogeneous(grid, TRUE);
int line = 0;
GtkWidget *button;
button = gtk_button_new_with_label(_("select all"));
ellipsize_button(button);
d->select_all_button = button;
gtk_widget_set_tooltip_text(button, _("select all images in current collection"));
gtk_grid_attach(grid, button, 0, line, 1, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(0));
button = gtk_button_new_with_label(_("select none"));
ellipsize_button(button);
d->select_none_button = button;
gtk_widget_set_tooltip_text(button, _("clear selection"));
gtk_grid_attach(grid, button, 1, line++, 1, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(1));
button = gtk_button_new_with_label(_("invert selection"));
ellipsize_button(button);
gtk_widget_set_tooltip_text(button, _("select unselected images\nin current collection"));
d->select_invert_button = button;
gtk_grid_attach(grid, button, 0, line, 1, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(2));
button = gtk_button_new_with_label(_("select film roll"));
ellipsize_button(button);
d->select_film_roll_button = button;
gtk_widget_set_tooltip_text(button, _("select all images which are in the same\nfilm roll as the selected images"));
gtk_grid_attach(grid, button, 1, line++, 1, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(3));
button = gtk_button_new_with_label(_("select untouched"));
ellipsize_button(button);
d->select_untouched_button = button;
gtk_widget_set_tooltip_text(button, _("select untouched images in\ncurrent collection"));
gtk_grid_attach(grid, button, 0, line, 1, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(4));
}
static GtkGrid*
kolab_backend_sync_conflict_ui_grid_new (void)
{
GtkGrid *grid = NULL;
grid = GTK_GRID (gtk_grid_new ());
gtk_grid_set_row_homogeneous (grid, FALSE);
gtk_grid_set_row_spacing (grid, 6);
gtk_grid_set_column_homogeneous (grid, FALSE);
gtk_grid_set_column_spacing (grid, 16);
gtk_container_set_border_width (GTK_CONTAINER (grid), KOLAB_SYNC_CONFLICT_WIDGET_BORDER_WIDTH);
/* gtk_container_set_resize_mode (GTK_CONTAINER (grid), GTK_RESIZE_QUEUE); */
return grid;
}
static GtkWidget *grid2x2(GtkWidget *top_left, GtkWidget *top_right,
GtkWidget *bottom_left, GtkWidget *bottom_right)
{
GtkWidget *grid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(grid), 12);
gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
gtk_container_set_border_width(GTK_CONTAINER(grid), 12);
gtk_grid_attach(GTK_GRID(grid), top_left, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid), top_right, 1, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid), bottom_left, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid), bottom_right, 1, 1, 1, 1);
gtk_widget_show(grid);
return grid;
}
/* test that margins and non-zero allocation x/y
* of the main widget are handled correctly
*/
static GtkWidget *
test_nonzerox (void)
{
GtkWidget *win;
GtkWidget *grid;
GtkWidget *overlay;
GtkWidget *text;
GtkWidget *child;
GdkRGBA color;
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (win), "Non-zero X");
grid = gtk_grid_new ();
g_object_set (grid, "margin", 5, NULL);
gtk_container_add (GTK_CONTAINER (win), grid);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Above"), 1, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Below"), 1, 2, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Left"), 0, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Right"), 2, 1, 1, 1);
overlay = gtk_overlay_new ();
gdk_rgba_parse (&color, "red");
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_widget_override_background_color (overlay, 0, &color);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_grid_attach (GTK_GRID (grid), overlay, 1, 1, 1, 1);
text = gtk_text_view_new ();
gtk_widget_set_size_request (text, 200, 200);
gtk_widget_set_hexpand (text, TRUE);
gtk_widget_set_vexpand (text, TRUE);
gtk_container_add (GTK_CONTAINER (overlay), text);
child = gtk_label_new ("I'm the overlay");
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_START);
g_object_set (child, "margin", 3, NULL);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
child = gtk_label_new ("No, I'm the overlay");
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_END);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_object_set (child, "margin", 3, NULL);
return win;
}
static gboolean
vfo_press_event_cb (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
if((int)event->x < (my_width/2)) {
lock_cb(NULL,NULL);
} else {
GtkWidget *dialog=gtk_dialog_new_with_buttons("Step",GTK_WINDOW(parent_window),GTK_DIALOG_DESTROY_WITH_PARENT,NULL,NULL);
GtkWidget *content=gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget *grid=gtk_grid_new();
gtk_grid_set_column_homogeneous(GTK_GRID(grid),TRUE);
gtk_grid_set_row_homogeneous(GTK_GRID(grid),TRUE);
GtkWidget *step_rb=NULL;
int i=0;
while(steps[i]!=0) {
if(i==0) {
step_rb=gtk_radio_button_new_with_label(NULL,step_labels[i]);
} else {
step_rb=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(step_rb),step_labels[i]);
}
gtk_widget_override_font(step_rb, pango_font_description_from_string("FreeMono 18"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (step_rb), steps[i]==step);
gtk_widget_show(step_rb);
gtk_grid_attach(GTK_GRID(grid),step_rb,i%5,i/5,1,1);
g_signal_connect(step_rb,"pressed",G_CALLBACK(vfo_step_select_cb),(gpointer *)i);
i++;
}
gtk_container_add(GTK_CONTAINER(content),grid);
GtkWidget *close_button=gtk_dialog_add_button(GTK_DIALOG(dialog),"Close",GTK_RESPONSE_OK);
gtk_widget_override_font(close_button, pango_font_description_from_string("FreeMono 18"));
gtk_widget_show_all(dialog);
g_signal_connect_swapped (dialog,
"response",
G_CALLBACK (gtk_widget_destroy),
dialog);
int result=gtk_dialog_run(GTK_DIALOG(dialog));
}
return TRUE;
}
static gboolean lang_dialog(GtkWidget *eventbox, GdkEventButton *event, void *param)
{
struct button_data *data = g_malloc(sizeof(*data));
GtkWidget *dialog;
#if (GTKVER == 3)
GtkWidget *table = gtk_grid_new();
#else
GtkWidget *table = gtk_table_new((NUM_LANGS+1)/2, 4, TRUE);
#endif
gint i;
//gtk_table_set_row_spacings(table, 5);
//gtk_table_set_col_spacings(table, 5);
dialog = gtk_dialog_new();
data->cb = param;
data->dialog = dialog;
for (i = 0; i < NUM_LANGS; i++) {
gint col = (i&1) ? 2 : 0;
gint row = i/2;
GtkWidget *button = data->buttons[i] = gtk_button_new_with_label(lang_names_in_own_language[i]);
gtk_button_set_image(GTK_BUTTON(button), get_picture(flags_files[i])/*flags[i]*/);
gtk_button_set_image_position(GTK_BUTTON(button), GTK_POS_LEFT);
//gtk_button_set_alignment(GTK_BUTTON(button), 0.0, 0.5); XXXXXX
#if (GTKVER == 3)
gtk_grid_attach(GTK_GRID(table), button, col, row, 1, 1);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(lang_dialog_cb), data);
#else
gtk_table_attach_defaults(GTK_TABLE(table), button,
col, col+1, row, row+1);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(lang_dialog_cb), data);
#endif
}
#if (GTKVER == 3)
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
table, TRUE, TRUE, 0);
#else
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), table);
#endif
gtk_widget_show_all(dialog);
return TRUE;
}
int main (int argc, char *argv[]) {
/*FIXME Clean this main */
GtkWidget *window, *entry, *grid, *frame, *combo1, *combo2, *combo3;
gtk_init(&argc, &argv);
/* Creates main window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
initialize_window(window);
/* Creates a grid */
grid = gtk_grid_new ();
gtk_container_add(GTK_CONTAINER(window), grid);
/* Creates a text entry and attaches to grid */
entry = new_entry_with_buffer(NULL, 0);
GtkEntryBuffer *buffer = gtk_entry_get_buffer((GtkEntry *)entry);
gtk_grid_attach(GTK_GRID(grid), entry, 0, 0, 3, 1);
/*FIXME Regulate paramaters via xml */
/* Creates favorite bands' combo and attaches to grid */
combo1 = new_combo_box_with_text("Velvet Underground", "Joy Division", "My Bloody Valentine");
g_signal_connect( G_OBJECT(combo1), "changed", G_CALLBACK( cb_changed ), GTK_ENTRY_BUFFER(buffer));
frame = gtk_frame_new("Favorite Bands");
gtk_container_add(GTK_CONTAINER(frame), combo1);
gtk_grid_attach(GTK_GRID(grid), frame, 0, 1, 1, 1);
/* Creates favorite foods' combo and attaches to grid */
combo2 = new_combo_box_with_text("Mexican", "Japanese", "Italian");
g_signal_connect( G_OBJECT(combo2), "changed", G_CALLBACK( cb_changed ), GTK_ENTRY_BUFFER(buffer));
frame = gtk_frame_new("Favorite Foods");
gtk_container_add(GTK_CONTAINER(frame), combo2);
gtk_grid_attach(GTK_GRID(grid), frame, 1, 1, 1, 1);
/* Creates favorite movies' combo and attaches to grid */
combo3 = new_combo_box_with_text("Dekalog", "Acossado", "Magnolia");
g_signal_connect( G_OBJECT(combo3), "changed", G_CALLBACK( cb_changed ), GTK_ENTRY_BUFFER(buffer));
frame = gtk_frame_new("Favorite Movies");
gtk_container_add(GTK_CONTAINER(frame), combo3);
gtk_grid_attach(GTK_GRID(grid), frame, 2, 1, 1, 1);
/* Shows all widgets recursively */
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static void
spanning_grid (void)
{
GtkWidget *window;
GtkWidget *g;
GtkWidget *c;
/* inspired by bug 698660
* the row/column that are empty except for the spanning
* child need to stay collapsed
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Spanning");
g = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), g);
c = test_widget ("0", "blue");
gtk_widget_set_hexpand (c, TRUE);
gtk_grid_attach (GTK_GRID (g), c, 0, 4, 4, 1);
c = test_widget ("1", "green");
gtk_widget_set_vexpand (c, TRUE);
gtk_grid_attach (GTK_GRID (g), c, 4, 0, 1, 4);
c = test_widget ("2", "red");
gtk_widget_set_hexpand (c, TRUE);
gtk_widget_set_vexpand (c, TRUE);
gtk_grid_attach (GTK_GRID (g), c, 3, 3, 1, 1);
c = test_widget ("3", "yellow");
gtk_grid_attach (GTK_GRID (g), c, 0, 3, 2, 1);
c = test_widget ("4", "orange");
gtk_grid_attach (GTK_GRID (g), c, 3, 0, 1, 2);
c = test_widget ("5", "purple");
gtk_grid_attach (GTK_GRID (g), c, 1, 1, 1, 1);
c = test_widget ("6", "white");
gtk_grid_attach (GTK_GRID (g), c, 0, 1, 1, 1);
c = test_widget ("7", "cyan");
gtk_grid_attach (GTK_GRID (g), c, 1, 0, 1, 1);
gtk_widget_show_all (window);
}
//pack items
void gtk_packing()
{
vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL,5);
grid=gtk_grid_new();
gtk_container_add(GTK_CONTAINER(window),vbox);
gtk_box_pack_start(GTK_BOX(vbox),reset_button,0,0,10);
gtk_box_pack_start(GTK_BOX(vbox),grid,1,1,10);
gtk_box_pack_start(GTK_BOX(vbox),result,1,1,10);
gtk_box_pack_start(GTK_BOX(vbox),stat,1,1,10);
int i,j;
for(i=0;i<15;i++)
for(j=0;j<15;j++)
gtk_grid_attach(GTK_GRID(grid),buttons[i][j],j,i,1,1);
}
int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *grid;
gtk_init(&argc,&argv);
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
button=gtk_button_new_with_label("this is a label");
grid=gtk_grid_new();
gtk_container_add(GTK_CONTAINER(window),grid);
gtk_grid_attach(GTK_GRID(grid),button,1,1,1,1);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static void
MergeDialogSetup(GtkWidget *wi, void *data, int makewidget)
{
GtkWidget *w, *frame, *table;
struct MergeDialog *d;
char title[64];
int i;
d = (struct MergeDialog *) data;
snprintf(title, sizeof(title), _("Merge %d"), d->Id);
gtk_window_set_title(GTK_WINDOW(wi), title);
if (makewidget) {
#if GTK_CHECK_VERSION(3, 4, 0)
table = gtk_grid_new();
#else
table = gtk_table_new(1, 2, FALSE);
#endif
i = 0;
w = create_file_entry(d->Obj);
add_widget_to_table(table, w, _("_File:"), TRUE, i++);
d->file = w;
w = create_spin_entry_type(SPIN_BUTTON_TYPE_POSITION, TRUE, TRUE);
add_widget_to_table(table, w, _("_Top Margin:"), FALSE, i++);
d->topmargin = w;
w = create_spin_entry_type(SPIN_BUTTON_TYPE_POSITION, TRUE, TRUE);
add_widget_to_table(table, w, _("_Left Margin:"), FALSE, i++);
d->leftmargin = w;
w = create_spin_entry_type(SPIN_BUTTON_TYPE_PERCENT, TRUE, TRUE);
add_widget_to_table(table, w, _("_Zoom:"), FALSE, i++);
d->zoom = w;
frame = gtk_frame_new(NULL);
gtk_container_add(GTK_CONTAINER(frame), table);
gtk_box_pack_start(GTK_BOX(d->vbox), frame, TRUE, TRUE, 4);
add_copy_button_to_box(GTK_WIDGET(d->vbox), G_CALLBACK(MergeDialogCopy), d, "merge");
gtk_widget_show_all(GTK_WIDGET(d->vbox));
}
MergeDialogSetupItem(d, TRUE, d->Id);
}
void
table_mass_create (TableMass * table, Mass * m, JBDOUBLE e)
{
char buffer[JB_BUFFER_SIZE];
table->label_initial = (GtkLabel *) gtk_label_new (gettext ("Initial mass"));
table->label_final = (GtkLabel *) gtk_label_new (gettext ("Final mass"));
table->label_inlet =
(GtkLabel *) gtk_label_new (gettext ("Inlet contributions"));
table->label_inner =
(GtkLabel *) gtk_label_new (gettext ("Inner contributions"));
table->label_outlet =
(GtkLabel *) gtk_label_new (gettext ("Oulet contributions"));
table->label_error =
(GtkLabel *) gtk_label_new (gettext ("Conservation error"));
table->entry_initial = (GtkEntry *) gtk_entry_new ();
gtk_widget_set_sensitive (GTK_WIDGET (table->entry_initial), 0);
jbw_float_entry_set_value (table->entry_initial, m->m0);
table->entry_final = (GtkEntry *) gtk_entry_new ();
gtk_widget_set_sensitive (GTK_WIDGET (table->entry_final), 0);
jbw_float_entry_set_value (table->entry_final, m->m);
table->entry_inlet = (GtkEntry *) gtk_entry_new ();
gtk_widget_set_sensitive (GTK_WIDGET (table->entry_inlet), 0);
jbw_float_entry_set_value (table->entry_inlet, m->inlet);
table->entry_inner = (GtkEntry *) gtk_entry_new ();
gtk_widget_set_sensitive (GTK_WIDGET (table->entry_inner), 0);
jbw_float_entry_set_value (table->entry_inner, m->inner);
table->entry_outlet = (GtkEntry *) gtk_entry_new ();
gtk_widget_set_sensitive (GTK_WIDGET (table->entry_outlet), 0);
jbw_float_entry_set_value (table->entry_outlet, m->outlet);
table->entry_error = (GtkEntry *) gtk_entry_new ();
gtk_widget_set_sensitive (GTK_WIDGET (table->entry_error), 0);
snprintf (buffer, JB_BUFFER_SIZE, FGL "%%", e);
gtk_entry_set_text (table->entry_error, buffer);
table->table = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach (table->table, GTK_WIDGET (table->label_initial), 0, 0, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->entry_initial), 1, 0, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->label_final), 0, 1, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->entry_final), 1, 1, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->label_inlet), 0, 2, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->entry_inlet), 1, 2, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->label_inner), 0, 3, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->entry_inner), 1, 3, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->label_outlet), 0, 4, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->entry_outlet), 1, 4, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->label_error), 0, 5, 1, 1);
gtk_grid_attach (table->table, GTK_WIDGET (table->entry_error), 1, 5, 1, 1);
}
static GtkWidget *
pref_file_page_initializer (PrefState *state,
G_GNUC_UNUSED gpointer data,
G_GNUC_UNUSED GtkNotebook *notebook,
G_GNUC_UNUSED gint page_num)
{
GtkWidget *page = gtk_grid_new ();
gint row = 0;
g_object_set (page, "column-spacing", 12, "row-spacing", 6,
"vexpand", TRUE, NULL);
int_pref_create_widget (gnm_conf_get_core_xml_compression_level_node (),
page, row++, 9, 0, 9, 1,
gnm_conf_set_core_xml_compression_level,
gnm_conf_get_core_xml_compression_level,
_("Default Compression Level For "
"Gnumeric Files"));
int_pref_create_widget (gnm_conf_get_core_workbook_autosave_time_node (),
page, row++, 0, 0, 365*24*60*60, 60,
gnm_conf_set_core_workbook_autosave_time,
gnm_conf_get_core_workbook_autosave_time,
_("Default autosave frequency in seconds"));
bool_pref_create_widget (gnm_conf_get_core_file_save_def_overwrite_node (),
page, row++,
gnm_conf_set_core_file_save_def_overwrite,
gnm_conf_get_core_file_save_def_overwrite,
_("Default To Overwriting Files"));
bool_pref_create_widget (gnm_conf_get_core_file_save_single_sheet_node (),
page, row++,
gnm_conf_set_core_file_save_single_sheet,
gnm_conf_get_core_file_save_single_sheet,
_("Warn When Exporting Into Single "
"Sheet Format"));
bool_pref_create_widget (gnm_conf_get_plugin_latex_use_utf8_node (),
page, row++,
gnm_conf_set_plugin_latex_use_utf8,
gnm_conf_get_plugin_latex_use_utf8,
_("Use UTF-8 in LaTeX Export"));
custom_pref_create_widget_ecd ( gnm_conf_get_core_file_save_extension_check_disabled_node (),
page, row++,
gnm_conf_set_core_file_save_extension_check_disabled_wrap,
gnm_conf_get_core_file_save_extension_check_disabled_wrap,
_("Disable Extension Check for Configurable Text Exporter"));
gtk_widget_show_all (page);
return page;
}
static void
scrolling (void)
{
GtkWidget *window;
GtkWidget *sw;
GtkWidget *viewport;
GtkWidget *grid;
GtkWidget *child;
gint i;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Scrolling");
sw = gtk_scrolled_window_new (NULL, NULL);
viewport = gtk_viewport_new (NULL, NULL);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), sw);
gtk_container_add (GTK_CONTAINER (sw), viewport);
gtk_container_add (GTK_CONTAINER (viewport), grid);
child = oriented_test_widget ("#800080", "#800080", -45.0);
gtk_grid_attach (GTK_GRID (grid), child, 0, 0, 1, 1);
gtk_widget_set_hexpand (child, TRUE);
gtk_widget_set_vexpand (child, TRUE);
for (i = 1; i < 16; i++)
{
gchar *color;
color = g_strdup_printf ("#%02x00%02x", 128 + 8*i, 128 - 8*i);
child = test_widget (color, color);
gtk_grid_attach (GTK_GRID (grid), child, 0, i, i + 1, 1);
gtk_widget_set_hexpand (child, TRUE);
g_free (color);
}
for (i = 1; i < 16; i++)
{
gchar *color;
color = g_strdup_printf ("#%02x00%02x", 128 - 8*i, 128 + 8*i);
child = oriented_test_widget (color, color, -90.0);
gtk_grid_attach (GTK_GRID (grid), child, i, 0, 1, i);
gtk_widget_set_vexpand (child, TRUE);
g_free (color);
}
gtk_widget_show_all (window);
}
void ssh_createdialog(GtkWidget *widget) {
GtkWidget *vbox;
GtkWidget *tbl;
GtkWidget *l1, *l2;
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_container_add(GTK_CONTAINER(widget), vbox);
gtk_widget_show(vbox);
check_enablessh = gtk_check_button_new_with_label(
_("Enable SSH tunneling"));
gtk_box_pack_start(GTK_BOX(vbox), check_enablessh, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(GTK_CHECK_BUTTON(check_enablessh)), "toggled",
G_CALLBACK(sig_enablessh), NULL);
gtk_widget_show(check_enablessh);
tbl = gtk_grid_new();
gtk_container_set_border_width(GTK_CONTAINER(tbl), 10);
gtk_grid_set_row_spacing(GTK_GRID(tbl), 5);
gtk_grid_set_column_spacing(GTK_GRID(tbl), 10);
gtk_box_pack_start(GTK_BOX(vbox), tbl, TRUE, TRUE, 5);
gtk_widget_show(tbl);
l1 = gtk_label_new(_("Username:"******"changed",
G_CALLBACK(sig_sshuser), NULL);
gtk_grid_attach(GTK_GRID(tbl), input_user, 1, 0, 1, 1);
gtk_widget_show(input_user);
l2 = gtk_label_new(_("Hostname:"));
gtk_grid_attach(GTK_GRID(tbl), l2, 0, 1, 1, 1);
gtk_widget_show(l2);
input_host = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(input_host), 255);
g_signal_connect(G_OBJECT(GTK_ENTRY(input_host)), "changed",
G_CALLBACK(sig_sshhost), NULL);
gtk_grid_attach(GTK_GRID(tbl), input_host, 1, 1, 1, 1);
gtk_widget_show(input_host);
}
int
main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *grid;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *radio1;
GtkWidget *radio2;
GtkListStore *store;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Completion");
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
grid = gtk_grid_new();
gtk_container_add(GTK_CONTAINER(window), grid);
label = gtk_label_new("There are completions for numbers from 'one' to 'ten'");
gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 2, 1);
radio1 = gtk_radio_button_new_with_label(NULL, "Popup");
gtk_grid_attach(GTK_GRID(grid), radio1, 0, 1, 1, 1);
radio2 = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(radio1), "Inline");
gtk_grid_attach(GTK_GRID(grid), radio2, 1, 1, 1, 1);
entry = gtk_entry_new();
gtk_grid_attach(GTK_GRID(grid), entry, 0, 2, 2, 1);
store = create_completion_list_store();
g_completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(g_completion, GTK_TREE_MODEL(store));
gtk_entry_completion_set_text_column(g_completion, 0);
gtk_entry_set_completion(GTK_ENTRY(entry), g_completion);
g_signal_connect(radio1, "toggled", G_CALLBACK(popup_radio_toggled), NULL);
g_signal_connect(radio2, "toggled", G_CALLBACK(inline_radio_toggled), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static GtkWidget* remmina_init_dialog_container_new(guint table_rows, guint table_columns, gboolean homogeneous)
{
GtkWidget *table;
#if GTK_VERSION == 3
table = gtk_grid_new();
gtk_widget_show(table);
gtk_grid_set_row_spacing(GTK_GRID(table), 8);
gtk_grid_set_column_spacing(GTK_GRID(table), 8);
gtk_grid_set_column_homogeneous (GTK_GRID(table), homogeneous);
#elif GTK_VERSION == 2
table = gtk_table_new(table_rows, table_columns, homogeneous);
gtk_widget_show(table);
gtk_table_set_row_spacings(GTK_TABLE(table), 8);
gtk_table_set_col_spacings(GTK_TABLE(table), 8);
#endif
return table;
}
static int
float_editor_setup(struct gtk_common_data *mdata,
const struct sol_flow_node_options *options)
{
const struct float_editor_note_type *float_node;
GtkWidget *grid;
grid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(grid), 4);
g_object_set(grid, "halign", GTK_ALIGN_CENTER, NULL);
mdata->widget = grid;
float_node = (const struct float_editor_note_type *)sol_flow_node_get_type(mdata->node);
float_node->setup_widget(mdata);
return 0;
}
void setup_ui(int *argc, char ***argv)
{
GtkWidget *window;
GtkGrid *box;
GtkButton *commit;
int i;
gtk_init(argc, argv);
window = GTK_WIDGET(gtk_window_new(GTK_WINDOW_TOPLEVEL));
box = GTK_GRID(gtk_grid_new());
gtk_container_set_border_width(GTK_CONTAINER(window), 12);
gtk_grid_set_column_spacing(box, 12);
gtk_grid_set_row_spacing(box, 6);
for (i = 0; i < nProps; i++) {
GtkRange *scale;
GtkWidget *label;
label = gtk_label_new(props[i].name);
gtk_widget_set_halign(label, GTK_ALIGN_END);
gtk_grid_attach(box, label, 0, i, 1, 1);
scale = GTK_RANGE(gtk_scale_new(GTK_ORIENTATION_HORIZONTAL,
gtk_adjustment_new(props[i].default_value, props[i].min, props[i].max, 0.001, 0.001, 0.001)));
g_signal_connect(scale, "value-changed", G_CALLBACK(update_reverb), NULL);
gtk_widget_set_size_request(GTK_WIDGET(scale), 200, -1);
gtk_grid_attach(box, GTK_WIDGET(scale), 1, i, 1, 1);
label = gtk_label_new(props[i].desc);
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(box, label, 2, i, 1, 1);
props[i].value = scale;
}
commit = GTK_BUTTON(gtk_button_new_with_label("Commit Reverb Settings"));
g_signal_connect(commit, "clicked", G_CALLBACK(update_reverb), NULL);
gtk_grid_attach(box, GTK_WIDGET(commit), 0, nProps, 3, 1);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(box));
gtk_widget_show_all(window);
}
/** \brief Create sound chip settings widget
*
* \param[in] parent parent widget (unused)
*
* \return GtkGrid
*/
GtkWidget *settings_soundchip_widget_create(GtkWidget *parent)
{
GtkWidget *layout;
GtkWidget *sid_widget = NULL;
layout = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(layout), 8);
gtk_grid_set_row_spacing(GTK_GRID(layout), 8);
g_object_set(layout, "margin", 16, NULL);
sid_widget = sid_sound_widget_create(layout);
gtk_grid_attach(GTK_GRID(layout), sid_widget, 0, 0, 1, 1);
gtk_widget_show_all(layout);
return layout;
}
GtkGrid* createWindowAndMainGrid(int argc, char *argv[], void (*destroyFuncPtr) (GtkWidget *widget, gpointer), void (*deleteEventFuncPtr) (GtkWidget *widget, GdkEvent *event, gpointer data)){
GtkWidget *window;
GtkGrid* mainGrid;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "delete-event", G_CALLBACK(deleteEventFuncPtr), NULL);
g_signal_connect(window, "destroy", G_CALLBACK(destroyFuncPtr), NULL);
mainGrid = gtk_grid_new();
gtk_container_add(GTK_CONTAINER(window),mainGrid);
gtk_widget_show(window);
gtk_widget_show(mainGrid);
return mainGrid;
}
int main(int argc, char **argv) {
GtkWidget *window;
GtkWidget *pause, *prev, *next;
GtkWidget *button;
GtkWidget *grid;
gtk_init(&argc, &argv);
// window settings
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "gmpd");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
// button grid settings
grid = gtk_grid_new();
gtk_container_add(GTK_CONTAINER(window), grid);
// button previous
prev = gtk_button_new_with_label("Previous");
g_signal_connect(prev, "clicked", G_CALLBACK(mpd_com), (gpointer)"prev");
gtk_grid_attach(GTK_GRID(grid), prev, 0, 0, 1, 1);
// button next
next = gtk_button_new_with_label("Next");
g_signal_connect(next, "clicked", G_CALLBACK(mpd_com), (gpointer)"next");
gtk_grid_attach(GTK_GRID(grid), next, 1, 0, 1, 1);
// button quit
button = gtk_button_new_with_label("Quit");
g_signal_connect(button, "clicked", G_CALLBACK(gtk_main_quit), NULL);
gtk_grid_attach(GTK_GRID(grid), button, 0, 1, 1, 1);
// button play pause
pause = gtk_button_new_with_label("Play / Pause");
g_signal_connect(pause, "clicked", G_CALLBACK(mpd_com), (gpointer)"toggle");
gtk_grid_attach(GTK_GRID(grid), pause, 1, 1, 1, 1);
// show everything
gtk_widget_show_all(window);
gtk_main();
return 0;
}
