static void _add_property_button_clicked(GtkWidget *widget, gpointer user_data)
{
dt_lib_camera_t *lib = (dt_lib_camera_t *)user_data;
const gchar *label = gtk_entry_get_text(GTK_ENTRY(lib->gui.plabel));
const gchar *property = gtk_entry_get_text(GTK_ENTRY(lib->gui.pname));
/* let's try to add property */
if(label && property)
{
dt_lib_camera_property_t *prop = NULL;
if((prop = _lib_property_add_new(lib, label, property)) != NULL)
{
gtk_grid_insert_row(lib->gui.main_grid, lib->gui.prop_end); // make space for the new row
_lib_property_add_to_gui(prop, lib);
gchar key[256] = { "plugins/capture/tethering/properties/" };
g_strlcat(key, label, sizeof(key));
gchar *p = key;
const char *end = key + strlen(key);
while(p++ < end)
if(*p == ' ') *p = '_';
dt_conf_set_string(key, property);
/* clean entries */
gtk_entry_set_text(GTK_ENTRY(lib->gui.plabel), "");
gtk_entry_set_text(GTK_ENTRY(lib->gui.pname), "");
}
}
}
static unsigned add_one_row_to_grid(GtkGrid *table)
{
gulong rows = (gulong)g_object_get_data(G_OBJECT(table), "n-rows");
gtk_grid_insert_row(table, rows);
g_object_set_data(G_OBJECT(table), "n-rows", (gpointer)(rows + 1));
return rows;
}
static gboolean
add_row (GtkWidget *grid, guint row, const char* fieldname, const char *value,
gboolean showempty)
{
GtkWidget *label, *al;
if (!value && !showempty)
return FALSE;
gtk_grid_insert_row (GTK_GRID(grid), row);
label = get_label (fieldname, TRUE);
al = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
gtk_container_add (GTK_CONTAINER (al), label);
gtk_grid_attach (GTK_GRID(grid), al, 0, row, 1, 1);
al = gtk_alignment_new (0.0, 1.0, 0.0, 0.0);
label = get_label (value, FALSE);
gtk_container_add (GTK_CONTAINER (al), label);
gtk_grid_attach (GTK_GRID(grid), al, 1, row, 1, 1);
return TRUE;
}
static void _lib_property_add_to_gui(dt_lib_camera_property_t *prop, dt_lib_camera_t *lib)
{
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_grid_insert_row(lib->gui.main_grid, lib->gui.prop_end); // make space for the new row
gtk_grid_attach(lib->gui.main_grid, GTK_WIDGET(hbox), 0, lib->gui.prop_end, 2, 1);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
gtk_widget_show_all(GTK_WIDGET(hbox));
lib->gui.rows++;
lib->gui.prop_end++;
}
static void
insert_cb (GtkButton *button, GtkWidget *window)
{
GtkGrid *g, *g1, *g2, *g3, *g4;
GtkWidget *child;
gboolean inserted;
g = GTK_GRID (gtk_bin_get_child (GTK_BIN (window)));
g1 = GTK_GRID (gtk_grid_get_child_at (g, 0, 0));
g2 = GTK_GRID (gtk_grid_get_child_at (g, 1, 0));
g3 = GTK_GRID (gtk_grid_get_child_at (g, 0, 1));
g4 = GTK_GRID (gtk_grid_get_child_at (g, 1, 1));
inserted = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "inserted"));
if (inserted)
{
gtk_grid_remove_row (g1, 1);
gtk_grid_remove_column (g2, 1);
gtk_grid_remove_row (g3, 1);
gtk_grid_remove_column (g4, 1);
}
else
{
gtk_grid_insert_row (g1, 1);
gtk_grid_attach (g1, test_widget ("(0, 1)", "red"), 0, 1, 1, 1);
gtk_grid_attach (g1, test_widget ("(2, 1)", "red"), 2, 1, 1, 1);
gtk_grid_insert_column (g2, 1);
gtk_grid_attach (g2, test_widget ("(1, 0)", "red"), 1, 0, 1, 1);
gtk_grid_attach (g2, test_widget ("(1, 2)", "red"), 1, 2, 1, 1);
child = gtk_grid_get_child_at (g3, 0, 0);
gtk_grid_insert_next_to (g3, child, GTK_POS_BOTTOM);
gtk_grid_attach (g3, test_widget ("(0, 1)", "red"), 0, 1, 1, 1);
gtk_grid_attach (g3, test_widget ("(2, 1)", "red"), 2, 1, 1, 1);
child = gtk_grid_get_child_at (g4, 0, 0);
gtk_grid_insert_next_to (g4, child, GTK_POS_RIGHT);
gtk_grid_attach (g4, test_widget ("(1, 0)", "red"), 1, 0, 1, 1);
gtk_grid_attach (g4, test_widget ("(1, 2)", "red"), 1, 2, 1, 1);
gtk_widget_show_all (GTK_WIDGET (g));
}
gtk_button_set_label (button, inserted ? "Insert" : "Remove");
g_object_set_data (G_OBJECT (button), "inserted", GINT_TO_POINTER (!inserted));
}
void SurfaceDialog::addSurfaceEvent(){
gtk_widget_set_sensitive(GTK_WIDGET(m_rbBezier), false);
gtk_widget_set_sensitive(GTK_WIDGET(m_rbBSpline), false);
int num = 0;
if(m_type == ObjType::BEZIER_SURFACE){
num = 3;
}else if(m_type == ObjType::BSPLINE_SURFACE){
num = 1;
}
char *tmpSide = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(m_comboBox));
std::string side(tmpSide);
delete tmpSide;
if(side == "Ao lado"){
for(int col = 0; col < num; col++){
gtk_grid_insert_column(GTK_GRID(m_grid), m_max_j);
for(int line = 0; line < m_max_i; line++){
gtk_grid_attach (GTK_GRID(m_grid),
gtk_label_new(NULL),
m_max_j, line, 1, 1);
gtk_widget_show(gtk_grid_get_child_at(GTK_GRID(m_grid), m_max_j, line));
}
++m_max_j;
}
}else if(side == "Abaixo"){
for(int line = 0; line < num; line++){
gtk_grid_insert_row(GTK_GRID(m_grid), m_max_i);
for(int col = 0; col < m_max_j; col++){
gtk_grid_attach (GTK_GRID(m_grid),
gtk_label_new(NULL),
col, m_max_i, 1, 1);
gtk_widget_show(gtk_grid_get_child_at(GTK_GRID(m_grid), col, m_max_i));
}
++m_max_i;
}
}
}
static void
gog_trend_line_populate_editor (GogObject *gobj,
GOEditor *editor,
GogDataAllocator *dalloc,
GOCmdContext *cc)
{
GtkWidget *w, *box;
GogTrendLine *line = GOG_TREND_LINE (gobj);
box = go_editor_get_page (editor, _("Properties"));
if (!box)
box = go_editor_get_page (editor, _("Details"));
if (!box) {
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (box), 12);
gtk_widget_show_all (box);
go_editor_add_page (editor, box, _("Legend"));
}
w = gtk_check_button_new_with_mnemonic (_("_Show in Legend"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
gog_trend_line_has_legend (line));
g_signal_connect (G_OBJECT (w),
"toggled",
G_CALLBACK (cb_show_in_legend), gobj);
if (GTK_IS_BOX (box))
gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 0);
else if (GTK_IS_GRID (box)) {
GtkGrid *grid = GTK_GRID (box);
gtk_grid_insert_row (grid, 1);
gtk_grid_attach (grid, w, 0, 1, 2, 1);
} else if (GTK_IS_CONTAINER (box))
gtk_container_add (GTK_CONTAINER (box), w);
else
g_warning ("Unsupported container");
gtk_widget_show (w);
(GOG_OBJECT_CLASS (trend_line_parent_klass)->populate_editor) (gobj, editor, dalloc, cc);
}
void
dialog_so_size (WBCGtk *wbcg, GObject *so)
{
GtkBuilder *gui;
SOSizeState *state;
GtkGrid *grid;
int width, height;
g_return_if_fail (wbcg != NULL);
if (gnm_dialog_raise_if_exists (wbcg, SO_SIZE_DIALOG_KEY))
return;
gui = gnm_gtk_builder_load ("res:ui/sheetobject-size.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new (SOSizeState, 1);
state->wbcg = wbcg;
state->sv = wb_control_cur_sheet_view (GNM_WBC (wbcg));
state->sheet = sv_sheet (state->sv);
state->scg = wbcg_get_nth_scg (wbcg, state->sheet->index_in_wb);
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (state->gui, "object-size");
state->so = GNM_SO (so);
g_object_ref (so);
state->nameentry = GTK_ENTRY (go_gtk_builder_get_widget (state->gui, "name-entry"));
state->old_anchor = NULL;
state->old_name = NULL;
g_object_get (so, "name", &state->old_name, NULL);
if (state->old_name == NULL)
state->old_name = g_strdup ("");
gtk_entry_set_text (state->nameentry, state->old_name);
state->so_name_changed = FALSE;
g_signal_connect (G_OBJECT (state->nameentry),
"focus-out-event",
G_CALLBACK (cb_dialog_so_size_name_changed),
state);
state->so_print_check_changed = FALSE;
state->wpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "w-pts-label"));
state->wspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "w-spin"));
state->hpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "h-pts-label"));
state->hspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "h-spin"));
state->xpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "x-pts-label"));
state->xspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "x-spin"));
state->ypoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "y-pts-label"));
state->yspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "y-spin"));
state->print_check = GTK_WIDGET (go_gtk_builder_get_widget (state->gui,
"print-check"));
state->modecombo = GNM_SO_ANCHOR_MODE_CHOOSER (gnm_so_anchor_mode_chooser_new (sheet_object_can_resize (state->so)));
dialog_so_size_load (state);
state->active_anchor = sheet_object_anchor_dup (sheet_object_get_anchor
(state->so));
width = state->coords[2] - state->coords[0];
height = state->coords[3] - state->coords[1];
gtk_spin_button_set_value (state->wspin, (width < 0) ? - width : width);
gtk_spin_button_set_value (state->hspin, (height < 0) ? - height : height);
gtk_spin_button_set_value (state->xspin, 0.);
gtk_spin_button_set_value (state->yspin, 0.);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->print_check),
!(state->so->flags & SHEET_OBJECT_PRINT));
gnm_so_anchor_mode_chooser_set_mode (state->modecombo,
state->so->anchor.mode);
grid = GTK_GRID (gtk_builder_get_object (state->gui, "main-grid"));
gtk_grid_insert_row (grid, 7);
gtk_grid_attach (grid, GTK_WIDGET (state->modecombo), 0, 7, 2, 1);
gtk_widget_set_halign (GTK_WIDGET (state->modecombo), GTK_ALIGN_START);
gtk_widget_show (GTK_WIDGET (state->modecombo));
g_signal_connect (G_OBJECT (state->wspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->wpoints);
g_signal_connect (G_OBJECT (state->hspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->hpoints);
g_signal_connect (G_OBJECT (state->xspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->xpoints);
g_signal_connect (G_OBJECT (state->yspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->ypoints);
g_signal_connect (G_OBJECT (state->print_check),
"toggled",
G_CALLBACK (cb_dialog_so_size_print_check_toggled),
state);
cb_dialog_so_size_value_changed_update_points (state->wspin, GTK_LABEL (state->wpoints));
cb_dialog_so_size_value_changed_update_points (state->hspin, GTK_LABEL (state->hpoints));
cb_dialog_so_size_value_changed_update_points (state->xspin, GTK_LABEL (state->xpoints));
cb_dialog_so_size_value_changed_update_points (state->yspin, GTK_LABEL (state->ypoints));
g_signal_connect (G_OBJECT (state->wspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->hspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->xspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->yspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->modecombo),
"changed",
G_CALLBACK (cb_dialog_so_size_mode_changed), state);
state->ok_button = go_gtk_builder_get_widget (state->gui, "ok_button");
g_signal_connect (G_OBJECT (state->ok_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_ok_clicked), state);
state->apply_button = go_gtk_builder_get_widget (state->gui, "apply_button");
g_signal_connect (G_OBJECT (state->apply_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_apply_clicked), state);
state->cancel_button = go_gtk_builder_get_widget (state->gui, "cancel_button");
g_signal_connect (G_OBJECT (state->cancel_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_cancel_clicked), state);
gnm_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_SO_SIZE);
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_dialog_so_size_destroy);
gnm_keyed_dialog (wbcg, GTK_WINDOW (state->dialog),
SO_SIZE_DIALOG_KEY);
dialog_so_size_button_sensitivity (state);
gtk_widget_show (state->dialog);
}
static void
gst_switch_ptz_init (GstSwitchPTZ * ptz)
{
GtkWidget *box_main, *box_video, *box_control;
GtkWidget *box_control_pan, *box_control_tilt, *box_control_zoom;
GtkWidget *scale_pan, *scale_tilt, *control_grid, *box_buttons_tilt;
GtkWidget *control_buttons[3][3] = { {NULL} };
GtkWidget *box_zoom, *zoom_minus, *zoom_reset, *zoom_plus;
GtkWidget *scrollwin;
GtkWidget *scale_zoom;
GtkWidget *scale_pan_speed, *scale_tilt_speed, *scale_zoom_speed;
GtkWidget *label_pan_speed, *label_tilt_speed, *label_zoom_speed;
GtkWidget *label;
const gchar *control_labels[3][3] = {
/*
{" \\ ", " ^ ", " / "},
{" < ", " * ", " > "},
{" / ", " v ", " \\ "},
*/
/*
{ " \\ ", GTK_STOCK_GO_UP, " / " },
{ GTK_STOCK_GO_BACK, GTK_STOCK_HOME, GTK_STOCK_GO_FORWARD },
{ " / ", GTK_STOCK_GO_DOWN, " \\ " },
*/
{"icons/up_left.png", "icons/up.png", "icons/up_right.png"},
{"icons/left.png", "icons/center.png", "icons/right.png"},
{"icons/down_left.png", "icons/down.png", "icons/down_right.png"},
};
int n, m;
const char *title = NULL;
ptz->controller = gst_cam_controller_new (ptz_control_protocol);
if (ptz->controller == NULL) {
return;
}
gst_cam_controller_open (ptz->controller, ptz_device_name);
title = ptz->controller->device_info;
if (title == NULL)
title = "??? - PTZ Controller";
ptz->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (ptz->window), 640, 480);
gtk_window_set_title (GTK_WINDOW (ptz->window), title);
g_signal_connect (G_OBJECT (ptz->window), "delete-event",
G_CALLBACK (gst_switch_ptz_window_closed), ptz);
box_main = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
box_video = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
box_control = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrollwin, 200, -1);
gtk_widget_set_vexpand (scrollwin, TRUE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrollwin),
box_control);
gtk_box_pack_start (GTK_BOX (box_main), box_video, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_main), scrollwin, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (ptz->window), box_main);
gtk_container_set_border_width (GTK_CONTAINER (ptz->window), 5);
ptz->video_view = gtk_drawing_area_new ();
gtk_widget_set_name (ptz->video_view, "video");
gtk_widget_set_double_buffered (ptz->video_view, FALSE);
gtk_widget_set_hexpand (ptz->video_view, TRUE);
gtk_widget_set_vexpand (ptz->video_view, TRUE);
gtk_widget_set_events (ptz->video_view, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
gtk_box_pack_start (GTK_BOX (box_video), ptz->video_view, TRUE, TRUE, 0);
scale_pan =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
ptz->controller->pan_min, ptz->controller->pan_max, 1.0);
scale_tilt =
gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
ptz->controller->tilt_min, ptz->controller->tilt_max, 1.0);
//gtk_range_set_slider_size_fixed (GTK_RANGE (scale_pan), TRUE);
gtk_widget_set_size_request (scale_pan, 300, -1);
gtk_scale_set_value_pos (GTK_SCALE (scale_pan), GTK_POS_RIGHT);
gtk_scale_set_value_pos (GTK_SCALE (scale_tilt), GTK_POS_BOTTOM);
gtk_range_set_inverted (GTK_RANGE (scale_tilt), TRUE);
ptz->adjust_pan = gtk_range_get_adjustment (GTK_RANGE (scale_pan));
ptz->adjust_tilt = gtk_range_get_adjustment (GTK_RANGE (scale_tilt));
g_signal_connect (gtk_range_get_adjustment (GTK_RANGE (scale_pan)),
"value-changed", G_CALLBACK (gst_switch_ptz_pan_changed), ptz);
g_signal_connect (gtk_range_get_adjustment (GTK_RANGE (scale_tilt)),
"value-changed", G_CALLBACK (gst_switch_ptz_tilt_changed), ptz);
control_grid = gtk_grid_new ();
gtk_grid_insert_row (GTK_GRID (control_grid), 0);
gtk_grid_insert_row (GTK_GRID (control_grid), 1);
gtk_grid_insert_row (GTK_GRID (control_grid), 2);
gtk_grid_insert_column (GTK_GRID (control_grid), 0);
gtk_grid_insert_column (GTK_GRID (control_grid), 1);
gtk_grid_insert_column (GTK_GRID (control_grid), 2);
for (n = 0; n < 3; ++n) {
for (m = 0; m < 3; ++m) {
GtkWidget *btn = control_buttons[m][n] = gtk_button_new ();
gtk_grid_attach (GTK_GRID (control_grid), btn, n, m, 1, 1);
gtk_widget_set_size_request (btn, 70, 70);
gtk_button_set_image (GTK_BUTTON (btn),
gtk_image_new_from_file (control_labels[m][n]));
}
}
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), "<b>Pan/Tilt:</b>");
box_buttons_tilt = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (box_control), label, TRUE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_control), scale_pan, FALSE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_buttons_tilt), scale_tilt, FALSE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_buttons_tilt), control_grid, FALSE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control), box_buttons_tilt, FALSE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_control), gtk_label_new (""), TRUE, TRUE,
10);
box_zoom = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
zoom_minus = gtk_button_new ();
zoom_reset = gtk_button_new ();
zoom_plus = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (zoom_minus),
gtk_image_new_from_file ("icons/zoom_out.png"));
gtk_button_set_image (GTK_BUTTON (zoom_reset),
gtk_image_new_from_file ("icons/zoom.png"));
gtk_button_set_image (GTK_BUTTON (zoom_plus),
gtk_image_new_from_file ("icons/zoom_in.png"));
gtk_widget_set_size_request (zoom_minus, 70, 70);
gtk_widget_set_size_request (zoom_reset, 70, 70);
gtk_widget_set_size_request (zoom_plus, 70, 70);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), "<b>Zoom:</b>");
gtk_box_pack_start (GTK_BOX (box_control), label, TRUE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_zoom), gtk_label_new (""), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_zoom), zoom_minus, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_zoom), zoom_reset, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_zoom), zoom_plus, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_zoom), gtk_label_new (""), TRUE, TRUE, 10);
scale_zoom =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 1.0, 0.01);
gtk_range_set_value (GTK_RANGE (scale_zoom), 0.5);
ptz->adjust_zoom = gtk_range_get_adjustment (GTK_RANGE (scale_zoom));
label = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (label), scale_zoom, TRUE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_control), label, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (box_control), box_zoom, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (box_control), gtk_label_new (""), TRUE, TRUE,
10);
g_signal_connect (zoom_minus, "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_zoom_minus), ptz);
g_signal_connect (zoom_reset, "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_zoom_reset), ptz);
g_signal_connect (zoom_plus, "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_zoom_plus), ptz);
g_signal_connect (zoom_minus, "released",
G_CALLBACK (gst_switch_ptz_button_released_zoom_minus), ptz);
g_signal_connect (zoom_plus, "released",
G_CALLBACK (gst_switch_ptz_button_released_zoom_plus), ptz);
scale_pan_speed =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
ptz->controller->pan_speed_min, ptz->controller->pan_speed_max, 1.0);
scale_tilt_speed =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
ptz->controller->tilt_speed_min, ptz->controller->tilt_speed_max, 1.0);
scale_zoom_speed =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 1.0, 0.01);
gtk_range_set_value (GTK_RANGE (scale_pan_speed),
ptz->controller->pan_speed_max);
gtk_range_set_value (GTK_RANGE (scale_tilt_speed),
ptz->controller->tilt_speed_max);
gtk_range_set_value (GTK_RANGE (scale_zoom_speed), 1.0);
ptz->adjust_pan_speed =
gtk_range_get_adjustment (GTK_RANGE (scale_pan_speed));
ptz->adjust_tilt_speed =
gtk_range_get_adjustment (GTK_RANGE (scale_tilt_speed));
ptz->adjust_zoom_speed =
gtk_range_get_adjustment (GTK_RANGE (scale_zoom_speed));
label_pan_speed = gtk_label_new ("");
label_tilt_speed = gtk_label_new ("");
label_zoom_speed = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label_pan_speed), "<b>P:</b>");
gtk_label_set_markup (GTK_LABEL (label_tilt_speed), "<b>T:</b>");
gtk_label_set_markup (GTK_LABEL (label_zoom_speed), "<b>Z:</b>");
box_control_pan = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box_control_tilt = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box_control_zoom = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), "<b>Speeds:</b>");
gtk_box_pack_start (GTK_BOX (box_control), label, FALSE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_control_pan), label_pan_speed, FALSE, FALSE,
0);
gtk_box_pack_start (GTK_BOX (box_control_pan), scale_pan_speed, TRUE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control_tilt), label_tilt_speed, FALSE,
FALSE, 0);
gtk_box_pack_start (GTK_BOX (box_control_tilt), scale_tilt_speed, TRUE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control_zoom), label_zoom_speed, FALSE,
FALSE, 0);
gtk_box_pack_start (GTK_BOX (box_control_zoom), scale_zoom_speed, TRUE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control), box_control_pan, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_control), box_control_tilt, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_control), box_control_zoom, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_control), gtk_label_new (""), TRUE, TRUE,
10);
{
double v, tick = 50;
gchar *s;
gchar buf[64] = { 0 };
int n;
const gchar *fmt = "<small><sub>%d</sub></small>";
const gchar *fmtb = "<small><sub><b>%d</b></sub></small>";
g_sprintf ((s = buf), fmtb, 0);
gtk_scale_add_mark (GTK_SCALE (scale_pan), 0, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->pan_min);
gtk_scale_add_mark (GTK_SCALE (scale_pan), ptz->controller->pan_min,
GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->pan_max);
gtk_scale_add_mark (GTK_SCALE (scale_pan), ptz->controller->pan_max,
GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, 0);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), 0, GTK_POS_RIGHT, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->tilt_min);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), ptz->controller->tilt_min,
GTK_POS_RIGHT, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->tilt_max);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), ptz->controller->tilt_max,
GTK_POS_RIGHT, s);
for (v = -tick; ptz->controller->pan_min <= v; v -= tick) {
if (v - ptz->controller->pan_min < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_pan), v, GTK_POS_BOTTOM, s);
}
for (v = tick; v <= ptz->controller->pan_max; v += tick) {
if (ptz->controller->pan_max - v < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_pan), v, GTK_POS_BOTTOM, s);
}
for (v = -tick; ptz->controller->tilt_min <= v; v -= tick) {
if (v - ptz->controller->tilt_min < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), v, GTK_POS_RIGHT, s);
}
for (v = tick; v <= ptz->controller->tilt_max; v += tick) {
if (ptz->controller->tilt_max - v < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), v, GTK_POS_RIGHT, s);
}
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->pan_speed_min + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_pan_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->pan_speed_max + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_pan_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
(ptz->controller->pan_speed_max -
ptz->controller->pan_speed_min) / 2 + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_pan_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->tilt_speed_min + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_tilt_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->tilt_speed_max + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_tilt_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
(ptz->controller->tilt_speed_max -
ptz->controller->tilt_speed_min) / 2 + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_tilt_speed), v, GTK_POS_BOTTOM, s);
fmtb = "<small><sub><b>%.1f</b></sub></small>";
g_sprintf ((s = buf), fmtb, (v = 0.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 1.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_zoom_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 0.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 1.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_zoom), v, GTK_POS_BOTTOM, s);
}
if (strcmp (ptz_control_protocol, "visca-sony") == 0) {
gtk_widget_set_sensitive (box_control_pan, FALSE);
gtk_widget_set_sensitive (box_control_tilt, FALSE);
gtk_widget_set_sensitive (box_control_zoom, FALSE);
}
/*
g_signal_connect (G_OBJECT (scale_pan_speed), "value-changed",
G_CALLBACK (gst_switch_ptz_window_closed), ptz);
*/
g_signal_connect (ptz->adjust_pan_speed, "value-changed",
G_CALLBACK (gst_switch_ptz_pan_speed_changed), ptz);
g_signal_connect (ptz->adjust_tilt_speed, "value-changed",
G_CALLBACK (gst_switch_ptz_tilt_speed_changed), ptz);
g_signal_connect (ptz->adjust_zoom_speed, "value-changed",
G_CALLBACK (gst_switch_ptz_zoom_speed_changed), ptz);
g_signal_connect (ptz->adjust_zoom, "value-changed",
G_CALLBACK (gst_switch_ptz_zoom_changed), ptz);
g_signal_connect (control_buttons[0][0], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_left_top), ptz);
g_signal_connect (control_buttons[0][1], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_top), ptz);
g_signal_connect (control_buttons[0][2], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_top_right), ptz);
g_signal_connect (control_buttons[1][0], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_left), ptz);
g_signal_connect (control_buttons[1][1], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_center), ptz);
g_signal_connect (control_buttons[1][2], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_right), ptz);
g_signal_connect (control_buttons[2][0], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_bottom_left), ptz);
g_signal_connect (control_buttons[2][1], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_bottom), ptz);
g_signal_connect (control_buttons[2][2], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_right_bottom), ptz);
g_signal_connect (control_buttons[0][0], "released",
G_CALLBACK (gst_switch_ptz_button_released_left_top), ptz);
g_signal_connect (control_buttons[0][1], "released",
G_CALLBACK (gst_switch_ptz_button_released_top), ptz);
g_signal_connect (control_buttons[0][2], "released",
G_CALLBACK (gst_switch_ptz_button_released_top_right), ptz);
g_signal_connect (control_buttons[1][0], "released",
G_CALLBACK (gst_switch_ptz_button_released_left), ptz);
g_signal_connect (control_buttons[1][2], "released",
G_CALLBACK (gst_switch_ptz_button_released_right), ptz);
g_signal_connect (control_buttons[2][0], "released",
G_CALLBACK (gst_switch_ptz_button_released_bottom_left), ptz);
g_signal_connect (control_buttons[2][1], "released",
G_CALLBACK (gst_switch_ptz_button_released_bottom), ptz);
g_signal_connect (control_buttons[2][2], "released",
G_CALLBACK (gst_switch_ptz_button_released_right_bottom), ptz);
do_update = TRUE;
gst_switch_ptz_update_xy (ptz);
do_update = FALSE;
g_timeout_add (300, (GSourceFunc) gst_switch_ptz_update, ptz);
g_timeout_add (100, (GSourceFunc) gst_switch_ptz_update_xy, ptz);
//g_timeout_add (50, (GSourceFunc) gst_switch_ptz_update_d, ptz);
}
int main(int argc, char *argv[]) {
GtkWidget *window;
GtkWidget *table;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *entry1;
GtkWidget *entry2;
GtkWidget *entry3;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(window), "GtkEntry");
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
table = gtk_grid_new();
gtk_grid_insert_row (GTK_GRID(table),0);
gtk_grid_insert_row (GTK_GRID(table),1);
gtk_grid_insert_row (GTK_GRID(table),2);
gtk_grid_insert_column (GTK_GRID(table),0);
gtk_grid_insert_column (GTK_GRID(table),1);
gtk_grid_set_row_homogeneous(GTK_GRID(table),TRUE);
gtk_grid_set_column_homogeneous(GTK_GRID(table),TRUE);
gtk_container_add(GTK_CONTAINER(window), table);
label1 = gtk_label_new("Name");
label2 = gtk_label_new("Age");
label3 = gtk_label_new("Occupation");
gtk_grid_attach(GTK_GRID(table), label1, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(table), label2, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(table), label3, 0, 2, 1, 1);
entry1 = gtk_entry_new();
entry2 = gtk_entry_new();
entry3 = gtk_entry_new();
gtk_grid_attach(GTK_GRID(table), entry1, 1, 0, 1, 1);
gtk_grid_attach(GTK_GRID(table), entry2, 1, 1, 1, 1);
gtk_grid_attach(GTK_GRID(table), entry3, 1, 2, 1, 1);
gtk_widget_show(table);
gtk_widget_show(label1);
gtk_widget_show(label2);
gtk_widget_show(label3);
gtk_widget_show(entry1);
gtk_widget_show(entry2);
gtk_widget_show(entry3);
gtk_widget_show(window);
g_signal_connect(window, "destroy",
G_CALLBACK(gtk_main_quit), NULL);
gtk_main();
return 0;
}
static void
create_sys_view (GsmApplication *app, GtkBuilder * builder)
{
GtkBox *cpu_graph_box, *mem_graph_box, *net_graph_box;
GtkLabel *label,*cpu_label;
GtkGrid *table;
GsmColorButton *color_picker;
LoadGraph *cpu_graph, *mem_graph, *net_graph;
gint i;
gchar *title_text;
gchar *label_text;
gchar *title_template;
// Translators: color picker title, %s is CPU, Memory, Swap, Receiving, Sending
title_template = g_strdup(_("Pick a Color for “%s”"));
/* The CPU BOX */
cpu_graph_box = GTK_BOX (gtk_builder_get_object (builder, "cpu_graph_box"));
cpu_graph = new LoadGraph(LOAD_GRAPH_CPU);
gtk_box_pack_start (cpu_graph_box,
GTK_WIDGET (load_graph_get_widget(cpu_graph)),
TRUE,
TRUE,
0);
GtkGrid* cpu_table = GTK_GRID (gtk_builder_get_object (builder, "cpu_table"));
gint cols = 4;
for (i=0;i<app->config.num_cpus; i++) {
GtkBox *temp_hbox;
temp_hbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0));
gtk_widget_show (GTK_WIDGET (temp_hbox));
if (i < cols) {
gtk_grid_insert_column(cpu_table, i%cols);
}
if ((i+1)%cols ==cols) {
gtk_grid_insert_row(cpu_table, (i+1)/cols);
}
gtk_grid_attach(cpu_table, GTK_WIDGET (temp_hbox), i%cols, i/cols, 1, 1);
color_picker = gsm_color_button_new (&cpu_graph->colors.at(i), GSMCP_TYPE_CPU);
g_signal_connect (G_OBJECT (color_picker), "color-set",
G_CALLBACK (cb_cpu_color_changed), GINT_TO_POINTER (i));
gtk_box_pack_start (temp_hbox, GTK_WIDGET (color_picker), FALSE, TRUE, 0);
gtk_widget_set_size_request(GTK_WIDGET(color_picker), 32, -1);
if(app->config.num_cpus == 1) {
label_text = g_strdup (_("CPU"));
} else {
label_text = g_strdup_printf (_("CPU%d"), i+1);
}
title_text = g_strdup_printf(title_template, label_text);
label = GTK_LABEL (gtk_label_new (label_text));
gsm_color_button_set_title(color_picker, title_text);
g_free(title_text);
gtk_box_pack_start (temp_hbox, GTK_WIDGET (label), FALSE, FALSE, 6);
gtk_widget_show (GTK_WIDGET (label));
g_free (label_text);
cpu_label = GTK_LABEL (gtk_label_new (NULL));
gtk_widget_set_valign (GTK_WIDGET (cpu_label), GTK_ALIGN_CENTER);
gtk_widget_set_halign (GTK_WIDGET (cpu_label), GTK_ALIGN_START);
gtk_box_pack_start (temp_hbox, GTK_WIDGET (cpu_label), FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (cpu_label));
load_graph_get_labels(cpu_graph)->cpu[i] = cpu_label;
}
app->cpu_graph = cpu_graph;
/** The memory box */
mem_graph_box = GTK_BOX (gtk_builder_get_object (builder, "mem_graph_box"));
mem_graph = new LoadGraph(LOAD_GRAPH_MEM);
gtk_box_pack_start (mem_graph_box,
GTK_WIDGET (load_graph_get_widget(mem_graph)),
TRUE,
TRUE,
0);
table = GTK_GRID (gtk_builder_get_object (builder, "mem_table"));
color_picker = load_graph_get_mem_color_picker(mem_graph);
g_signal_connect (G_OBJECT (color_picker), "color-set",
G_CALLBACK (cb_mem_color_changed), app);
title_text = g_strdup_printf(title_template, _("Memory"));
gsm_color_button_set_title(color_picker, title_text);
g_free(title_text);
label = GTK_LABEL (gtk_builder_get_object(builder, "memory_label"));
gtk_grid_attach_next_to (table, GTK_WIDGET (color_picker), GTK_WIDGET (label), GTK_POS_LEFT, 1, 2);
gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(mem_graph)->memory), GTK_WIDGET (label), GTK_POS_BOTTOM, 1, 1);
color_picker = load_graph_get_swap_color_picker(mem_graph);
g_signal_connect (G_OBJECT (color_picker), "color-set",
G_CALLBACK (cb_swap_color_changed), app);
title_text = g_strdup_printf(title_template, _("Swap"));
gsm_color_button_set_title(GSM_COLOR_BUTTON(color_picker), title_text);
g_free(title_text);
label = GTK_LABEL (gtk_builder_get_object(builder, "swap_label"));
gtk_grid_attach_next_to (table, GTK_WIDGET (color_picker), GTK_WIDGET (label), GTK_POS_LEFT, 1, 2);
gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(mem_graph)->swap), GTK_WIDGET (label), GTK_POS_BOTTOM, 1, 1);
app->mem_graph = mem_graph;
/* The net box */
net_graph_box = GTK_BOX (gtk_builder_get_object (builder, "net_graph_box"));
net_graph = new LoadGraph(LOAD_GRAPH_NET);
gtk_box_pack_start (net_graph_box,
GTK_WIDGET (load_graph_get_widget(net_graph)),
TRUE,
TRUE,
0);
table = GTK_GRID (gtk_builder_get_object (builder, "net_table"));
color_picker = gsm_color_button_new (
&net_graph->colors.at(0), GSMCP_TYPE_NETWORK_IN);
g_signal_connect (G_OBJECT (color_picker), "color-set",
G_CALLBACK (cb_net_in_color_changed), app);
title_text = g_strdup_printf(title_template, _("Receiving"));
gsm_color_button_set_title(color_picker, title_text);
g_free(title_text);
label = GTK_LABEL (gtk_builder_get_object(builder, "receiving_label"));
gtk_grid_attach_next_to (table, GTK_WIDGET (color_picker), GTK_WIDGET (label), GTK_POS_LEFT, 1, 2);
gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(net_graph)->net_in), GTK_WIDGET (label), GTK_POS_RIGHT, 1, 1);
label = GTK_LABEL (gtk_builder_get_object(builder, "total_received_label"));
gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(net_graph)->net_in_total), GTK_WIDGET (label), GTK_POS_RIGHT, 1, 1);
color_picker = gsm_color_button_new (
&net_graph->colors.at(1), GSMCP_TYPE_NETWORK_OUT);
g_signal_connect (G_OBJECT (color_picker), "color-set",
G_CALLBACK (cb_net_out_color_changed), app);
title_text = g_strdup_printf(title_template, _("Sending"));
gsm_color_button_set_title(color_picker, title_text);
g_free(title_text);
label = GTK_LABEL (gtk_builder_get_object(builder, "sending_label"));
gtk_grid_attach_next_to (table, GTK_WIDGET (color_picker), GTK_WIDGET (label), GTK_POS_LEFT, 1, 2);
gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(net_graph)->net_out), GTK_WIDGET (label), GTK_POS_RIGHT, 1, 1);
label = GTK_LABEL (gtk_builder_get_object(builder, "total_sent_label"));
gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(net_graph)->net_out_total), GTK_WIDGET (label), GTK_POS_RIGHT, 1, 1);
app->net_graph = net_graph;
g_free (title_template);
}
int main( int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *table;
GtkWidget *info;
GtkWidget *warn;
GtkWidget *que;
GtkWidget *err;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 220, 150);
gtk_window_set_title(GTK_WINDOW(window), "Message dialogs");
table = gtk_grid_new();
gtk_grid_insert_row (GTK_GRID(table),0);
gtk_grid_insert_row (GTK_GRID(table),1);
gtk_grid_insert_column (GTK_GRID(table),0);
gtk_grid_insert_column (GTK_GRID(table),1);
gtk_grid_set_row_homogeneous(GTK_GRID(table),TRUE);
gtk_grid_set_column_homogeneous(GTK_GRID(table),TRUE);
gtk_grid_set_row_spacing(GTK_GRID(table), 2);
gtk_grid_set_column_spacing(GTK_GRID(table), 2);
info = gtk_button_new_with_label("Info");
warn = gtk_button_new_with_label("Warning");
que = gtk_button_new_with_label("Question");
err = gtk_button_new_with_label("Error");
gtk_grid_attach(GTK_GRID(table), info, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(table), warn, 1, 0, 1, 1);
gtk_grid_attach(GTK_GRID(table), que, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(table), err, 1, 1, 1, 1);
gtk_container_add(GTK_CONTAINER(window), table);
gtk_container_set_border_width(GTK_CONTAINER(window), 15);
g_signal_connect(G_OBJECT(info), "clicked",
G_CALLBACK(show_info), (gpointer) window);
g_signal_connect(G_OBJECT(warn), "clicked",
G_CALLBACK(show_warning), (gpointer) window);
g_signal_connect(G_OBJECT(que), "clicked",
G_CALLBACK(show_question), (gpointer) window);
g_signal_connect(G_OBJECT(err), "clicked",
G_CALLBACK(show_error), (gpointer) window);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), G_OBJECT(window));
gtk_widget_show_all(window);
gtk_main();
return 0;
}
