static void panel_icon_grid_init(PanelIconGrid *ig)
{
gtk_widget_set_has_window(GTK_WIDGET(ig), FALSE);
gtk_widget_set_redraw_on_allocate(GTK_WIDGET(ig), FALSE);
ig->orientation = GTK_ORIENTATION_HORIZONTAL;
}
void
moz_container_init (MozContainer *container)
{
gtk_widget_set_can_focus(GTK_WIDGET(container), TRUE);
gtk_container_set_resize_mode(GTK_CONTAINER(container), GTK_RESIZE_IMMEDIATE);
gtk_widget_set_redraw_on_allocate(GTK_WIDGET(container), FALSE);
}
int main (int argc, char** argv)
{
gtk_init(&argc, &argv);
_engine.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(_engine.window), 800, 600);
gtk_window_set_title(GTK_WINDOW(_engine.window), "OpenGL ES2 in GTK2 application");
gtk_widget_show_all(_engine.window);
//_egl_init(&_engine);
//_s52_init(&_engine);
gtk_widget_set_app_paintable (_engine.window, TRUE );
gtk_widget_set_double_buffered (_engine.window, FALSE);
gtk_widget_set_redraw_on_allocate(_engine.window, TRUE );
g_signal_connect(G_OBJECT(_engine.window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(_engine.window), "key_release_event", G_CALLBACK(_key_release_event), NULL);
g_signal_connect(G_OBJECT(_engine.window), "configure_event", G_CALLBACK(_configure_event), NULL);
_engine.do_S52init = TRUE;
g_timeout_add(500, _s52_draw_cb, &_engine); // 0.5 sec
gtk_main();
_s52_done(&_engine);
_egl_done(&_engine);
g_print("%s .. done\n", argv[0]);
return 0;
}
/* Establish an icon grid in a specified container widget.
* The icon grid manages the contents of the container.
* The orientation, geometry of the elements, and spacing can be varied. All elements are the same size. */
IconGrid * icon_grid_new(
Panel * panel, GtkWidget * container,
GtkOrientation orientation, gint child_width, gint child_height, gint spacing, gint border, gint target_dimension)
{
/* Create a structure representing the icon grid and collect the parameters. */
IconGrid * ig = g_new0(IconGrid, 1);
ig->panel = panel;
ig->container = container;
ig->orientation = orientation;
ig->child_width = child_width;
ig->constrained_child_width = child_width;
ig->child_height = child_height;
ig->spacing = spacing;
ig->border = border;
ig->target_dimension = target_dimension;
/* Create a layout container. */
ig->widget = gtk_fixed_new();
g_object_add_weak_pointer(G_OBJECT(ig->widget), (gpointer*)&ig->widget);
GTK_WIDGET_SET_FLAGS(ig->widget, GTK_NO_WINDOW);
gtk_widget_set_redraw_on_allocate(ig->widget, FALSE);
gtk_container_add(GTK_CONTAINER(ig->container), ig->widget);
gtk_widget_show(ig->widget);
/* Connect signals. */
g_signal_connect(G_OBJECT(ig->widget), "size-request", G_CALLBACK(icon_grid_size_request), (gpointer) ig);
g_signal_connect(G_OBJECT(container), "size-request", G_CALLBACK(icon_grid_size_request), (gpointer) ig);
g_signal_connect(G_OBJECT(container), "size-allocate", G_CALLBACK(icon_grid_size_allocate), (gpointer) ig);
return ig;
}
static void
gd_stack_init (GdStack *stack)
{
stack->priv = GD_STACK_GET_PRIVATE (stack);
gtk_widget_set_has_window ((GtkWidget*) stack, TRUE);
gtk_widget_set_redraw_on_allocate ((GtkWidget*) stack, TRUE);
}
// ---- choice dialog without text entry
gint gx_nchoice_dialog_without_entry(
const char* window_title,
const char* msg,
const guint nchoice,
const char* label[],
const gint resp[],
const gint default_response,
Glib::RefPtr<Gdk::Pixbuf> gw_ib) {
GtkWidget* dialog = gtk_dialog_new();
GtkWidget* text_label = gtk_label_new(msg);
GtkWidget* image = gtk_image_new_from_pixbuf(gw_ib->gobj());
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), text_label);
GdkColor colorGreen;
gdk_color_parse("#e1e1ed", &colorGreen);
gtk_widget_modify_fg(text_label, GTK_STATE_NORMAL, &colorGreen);
GdkColor colorBlack;
gdk_color_parse("#10101e", &colorBlack);
gtk_widget_modify_bg(dialog, GTK_STATE_NORMAL, &colorBlack);
g_signal_connect(GTK_DIALOG(dialog)->vbox, "expose-event",
G_CALLBACK(gx_cairo::start_box_expose), NULL);
gtk_widget_set_redraw_on_allocate(GTK_WIDGET(GTK_DIALOG(dialog)->vbox),true);
GtkStyle* text_style = gtk_widget_get_style(text_label);
pango_font_description_set_size(text_style->font_desc, 10*PANGO_SCALE);
pango_font_description_set_weight(text_style->font_desc, PANGO_WEIGHT_BOLD);
gtk_widget_modify_font(text_label, text_style->font_desc);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_action_area(GTK_DIALOG(dialog))), image);
for (guint i = 0; i < nchoice; i++) {
GtkWidget* button =
gtk_dialog_add_button(GTK_DIALOG(dialog), label[i], resp[i]);
gdk_color_parse("#555555", &colorBlack);
gtk_widget_modify_bg(button, GTK_STATE_NORMAL, &colorBlack);
}
// set default
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), default_response);
gtk_window_set_title(GTK_WINDOW(dialog), window_title);
gtk_widget_show(text_label);
gtk_widget_show(image);
gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE);
g_signal_connect(dialog, "map", G_CALLBACK(on_gx_nchoice_map), NULL);
// --- run dialog and check response
gint response = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return response;
}
static GObject * gmpc_widgets_qtable_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
GObject * obj;
GObjectClass * parent_class;
GmpcWidgetsQtable * self;
parent_class = G_OBJECT_CLASS (gmpc_widgets_qtable_parent_class);
obj = parent_class->constructor (type, n_construct_properties, construct_properties);
self = GMPC_WIDGETS_QTABLE (obj);
gtk_widget_set_has_window ((GtkWidget*) self, FALSE);
gtk_widget_set_redraw_on_allocate ((GtkWidget*) self, FALSE);
return obj;
}
static void
lyric_show_viewport_init(LyricShowViewport *lsv)
{
lsv->priv = LYRIC_SHOW_VIEWPORT_GET_PRIVATE(lsv);
gtk_widget_set_redraw_on_allocate(GTK_WIDGET(lsv),TRUE);
gtk_container_set_resize_mode (GTK_CONTAINER (lsv), GTK_RESIZE_PARENT);
gtk_widget_add_events(GTK_WIDGET(lsv),
GDK_BUTTON_PRESS_MASK|
GDK_BUTTON_RELEASE_MASK|
GDK_BUTTON1_MOTION_MASK);
}
static void
hd_status_area_box_init (HDStatusAreaBox *box)
{
gtk_widget_set_has_window(GTK_WIDGET(box), FALSE);
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (box),
FALSE);
box->priv = G_TYPE_INSTANCE_GET_PRIVATE ((box), HD_TYPE_STATUS_AREA_BOX, HDStatusAreaBoxPrivate);
box->priv->children = NULL;
box->priv->max_visible_children = MAX_VISIBLE_CHILDREN_LANDSCAPE;
}
static void
gtk_revealer_init (GtkRevealer *revealer)
{
GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);
priv->transition_type = GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN;
priv->transition_duration = 250;
priv->current_pos = 0.0;
priv->target_pos = 0.0;
gtk_widget_set_has_window ((GtkWidget*) revealer, TRUE);
gtk_widget_set_redraw_on_allocate ((GtkWidget*) revealer, FALSE);
}
GtkWidget *CreateTerminalWindow(void)
{
input_method = gtk_im_multicontext_new();
load_font_sizes();
terminal = gtk_event_box_new();
gtk_widget_set_app_paintable(terminal,TRUE);
gtk_widget_set_redraw_on_allocate(terminal,TRUE);
g_signal_connect(G_OBJECT(terminal), "destroy", G_CALLBACK(destroy), NULL);
/*
g_signal_connect(G_OBJECT(terminal), "direction-changed", G_CALLBACK(direction_changed), NULL);
g_signal_connect(G_OBJECT(terminal), "style-set", G_CALLBACK(style_set), NULL);
*/
// Configure terminal widget
GTK_WIDGET_SET_FLAGS(terminal, GTK_CAN_DEFAULT|GTK_CAN_FOCUS);
// http://developer.gnome.org/doc/API/2.0/gdk/gdk-Events.html#GdkEventMask
gtk_widget_add_events(terminal,GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_MOTION_MASK|GDK_BUTTON_RELEASE_MASK|GDK_POINTER_MOTION_MASK|GDK_ENTER_NOTIFY_MASK);
g_signal_connect(G_OBJECT(terminal), "expose_event", G_CALLBACK(expose), 0);
g_signal_connect(G_OBJECT(terminal), "configure-event", G_CALLBACK(configure), 0);
g_signal_connect(G_OBJECT(terminal), "size-allocate", G_CALLBACK(size_allocate), 0);
g_signal_connect(G_OBJECT(terminal), "key-press-event", G_CALLBACK(key_press), 0);
g_signal_connect(G_OBJECT(terminal), "key-release-event", G_CALLBACK(key_release), 0);
g_signal_connect(G_OBJECT(terminal), "realize", G_CALLBACK(realize), 0);
g_signal_connect(G_OBJECT(terminal), "focus-in-event", G_CALLBACK(focus_in), 0);
g_signal_connect(G_OBJECT(terminal), "focus-out-event", G_CALLBACK(focus_out), 0);
// Connect mouse events
g_signal_connect(G_OBJECT(terminal), "button-press-event", G_CALLBACK(mouse_button_press), 0);
g_signal_connect(G_OBJECT(terminal), "button-release-event", G_CALLBACK(mouse_button_release), 0);
g_signal_connect(G_OBJECT(terminal), "motion-notify-event", G_CALLBACK(mouse_motion), 0);
g_signal_connect(G_OBJECT(terminal), "enter-notify-event", G_CALLBACK(mouse_enter), 0);
g_signal_connect(G_OBJECT(terminal), "scroll-event", G_CALLBACK(mouse_scroll), 0);
// Connect input method events
g_signal_connect(G_OBJECT(input_method), "commit", G_CALLBACK(im_commit), 0);
register_tchange(CROSSHAIR,set_crosshair);
register_tchange(CURSOR_POS,set_showcursor);
register_tchange(CURSOR_BLINK,set_blink);
register_tchange(RECTANGLE_SELECT,set_rectangle_select);
register_tchange(INSERT,set_insert);
return terminal;
}
static GtkWidget*
create_alignment (void)
{
GtkWidget *alignment;
alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
/* make the alignment visible */
gtk_widget_set_redraw_on_allocate (alignment, TRUE);
g_signal_connect (G_OBJECT (alignment),
"draw",
G_CALLBACK (on_draw_alignment),
NULL);
return alignment;
}
/* {EV_WIDGET_IMP}.make */
void F1096_14500 (EIF_REFERENCE Current)
{
GTCX
EIF_POINTER tp1;
RTLD;
RTLI(1);
RTLR(0,Current);
RTGC;
F1081_14166(Current);
tp1 = *(EIF_POINTER *)(Current + O10979[Dtype(Current)-1078]);
gtk_widget_set_redraw_on_allocate((GtkWidget*) tp1, (gboolean) (EIF_BOOLEAN) 0);
F1029_13080(Current, (EIF_BOOLEAN) 1);
RTLE;
}
static void
gtk_revealer_init (GtkRevealer *revealer)
{
GtkRevealerPrivate *priv;
priv = G_TYPE_INSTANCE_GET_PRIVATE (revealer, GTK_TYPE_REVEALER, GtkRevealerPrivate);
revealer->priv = priv;
priv->transition_type = GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN;
priv->transition_duration = 250;
priv->current_pos = 0.0;
priv->target_pos = 0.0;
gtk_widget_set_has_window ((GtkWidget*) revealer, TRUE);
gtk_widget_set_redraw_on_allocate ((GtkWidget*) revealer, FALSE);
}
// ---- popup warning
int gx_message_popup(const char* msg) {
// check msg validity
if (!msg) {
gx_print_warning("Message Popup",
string(_("warning message does not exist")));
return -1;
}
// build popup window
GtkWidget *about;
GtkWidget *label;
GtkWidget *ok_button;
about = gtk_dialog_new();
ok_button = gtk_button_new_from_stock(GTK_STOCK_OK);
label = gtk_label_new(msg);
GtkStyle *style = gtk_widget_get_style(label);
pango_font_description_set_size(style->font_desc, 10*PANGO_SCALE);
pango_font_description_set_weight(style->font_desc, PANGO_WEIGHT_BOLD);
gtk_widget_modify_font(label, style->font_desc);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(about)->vbox), label);
GTK_BOX(GTK_DIALOG(about)->action_area)->spacing = 3;
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(about)->action_area), ok_button);
g_signal_connect_swapped(ok_button, "clicked",
G_CALLBACK(gtk_widget_destroy), about);
g_signal_connect(GTK_DIALOG(about)->vbox, "expose-event", G_CALLBACK(gx_cairo::start_box_expose), NULL);
gtk_widget_set_redraw_on_allocate(GTK_WIDGET(GTK_DIALOG(about)->vbox),true);
gtk_widget_show(ok_button);
gtk_widget_show(label);
return gtk_dialog_run (GTK_DIALOG(about));
}
static void ygtk_fixed_init (YGtkFixed *fixed)
{
gtk_widget_set_has_window(GTK_WIDGET(fixed), FALSE);
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (fixed), FALSE);
}
int
main (int argc, char *argv[])
{
SnraClient *client = NULL;
int ret = 1;
const gchar *server = NULL;
GOptionContext *ctx;
GError *error = NULL;
GtkWidget *window, *eventbox, *button;
ctx = g_option_context_new ("Aurena fullscreen client");
g_option_context_add_group (ctx, gtk_get_option_group(TRUE));
g_option_context_add_group (ctx, gst_init_get_option_group());
if (!g_option_context_parse (ctx, &argc, &argv, &error)) {
g_print ("Arguments error: %s", error->message);
return 1;
}
g_option_context_free (ctx);
if (argc > 1) {
/* Connect directly to the requested server, no avahi */
server = argv[1];
}
avahi_set_allocator (avahi_glib_allocator ());
client = snra_client_new (server, SNRA_CLIENT_PLAYER);
if (client == NULL)
goto fail;
g_object_set (gtk_settings_get_default (),
"gtk-application-prefer-dark-theme", TRUE, NULL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_double_buffered (window, FALSE);
gtk_widget_set_redraw_on_allocate (window, FALSE);
gtk_widget_set_app_paintable (window, TRUE);
g_signal_connect_after (window, "delete-event", G_CALLBACK (quit_clicked),
NULL);
eventbox = gtk_event_box_new ();
g_object_set (eventbox,
"halign", GTK_ALIGN_END,
"valign", GTK_ALIGN_START,
"expand", FALSE,
NULL);
gtk_widget_set_double_buffered (eventbox, TRUE);
gtk_widget_set_redraw_on_allocate (eventbox, TRUE);
gtk_widget_set_app_paintable (eventbox, FALSE);
gtk_container_add (GTK_CONTAINER (window), eventbox);
button = gtk_button_new_from_stock (GTK_STOCK_QUIT);
gtk_container_add (GTK_CONTAINER (eventbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (quit_clicked), NULL);
gtk_window_fullscreen (GTK_WINDOW (window));
gtk_widget_show_all (window);
g_signal_connect (client, "player-created", G_CALLBACK(player_created),
window);
gtk_widget_realize (button);
gdk_window_ensure_native (gtk_widget_get_window (eventbox));
ml = g_main_loop_new (NULL, FALSE);
g_main_loop_run (ml);
ret = 0;
fail:
if (client)
g_object_unref (client);
if (ml)
g_main_loop_unref (ml);
return ret;
}
static void
gdaui_bar_init (GdauiBar *bar)
{
GtkWidget *widget = GTK_WIDGET (bar);
GtkWidget *content_area;
GtkWidget *action_area;
bar->priv = g_new0 (GdauiBarPrivate, 1);
content_area = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (content_area);
gtk_box_pack_start (GTK_BOX (bar), content_area, TRUE, TRUE, 0);
action_area = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (action_area);
gtk_box_pack_start (GTK_BOX (bar), action_area, FALSE, TRUE, 0);
gtk_widget_set_app_paintable (widget, TRUE);
gtk_widget_set_redraw_on_allocate (widget, TRUE);
bar->priv->content_area = content_area;
bar->priv->action_area = action_area;
/* set default spacings */
gtk_box_set_spacing (GTK_BOX (bar->priv->action_area), ACTION_AREA_DEFAULT_SPACING);
gtk_container_set_border_width (GTK_CONTAINER (bar->priv->action_area), ACTION_AREA_DEFAULT_BORDER);
gtk_box_set_spacing (GTK_BOX (bar->priv->content_area), CONTENT_AREA_DEFAULT_SPACING);
gtk_container_set_border_width (GTK_CONTAINER (bar->priv->content_area), CONTENT_AREA_DEFAULT_BORDER);
bar->priv->show_icon = FALSE;
bar->priv->icon = gtk_image_new ();
gtk_misc_set_alignment (GTK_MISC (bar->priv->icon), 1., 0.5);
gtk_widget_hide (bar->priv->icon);
gtk_box_pack_end (GTK_BOX (bar->priv->content_area), bar->priv->icon,
FALSE, TRUE, 0);
bar->priv->label = gtk_label_new ("");
gtk_label_set_selectable (GTK_LABEL (bar->priv->label), FALSE);
gtk_misc_set_alignment (GTK_MISC (bar->priv->label), 0., 0.5);
gtk_box_pack_end (GTK_BOX (bar->priv->content_area), bar->priv->label,
TRUE, TRUE, 0);
gtk_widget_show (bar->priv->label);
/* CSS theming */
GtkStyleContext *context;
if (!css_provider) {
#define CSS ".gdauibar {\n" \
"background-color: #b3b3b3;\n" \
"padding: 5px;\n" \
"}" \
".gdauibar_button {\n" \
"-GtkButton-default-border : 0px;\n" \
"-GtkButton-default-outside-border : 0px;\n" \
"-GtkWidget-focus-line-width : 0px;\n" \
"-GtkWidget-focus-padding : 0px;\n" \
"padding: 0px;\n" \
"-GtkButtonBox-child-internal-pad-x : 1px;\n" \
"-GtkButtonBox-child-min-width : 0px;\n" \
"border-style: none;\n" \
"}" \
".gdauibar_entry {\n" \
"-GtkWidget-focus-line-width : 0px;\n" \
"-GtkWidget-focus-padding : 0px;\n" \
"padding: 1px;\n" \
"-GtkButtonBox-child-internal-pad-x : 1px;\n" \
"-GtkButtonBox-child-min-width : 0px;\n" \
"border-style: solid;\n" \
"border-radius: 5px;\n" \
"}"
css_provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (css_provider), CSS, -1, NULL);
}
context = gtk_widget_get_style_context (GTK_WIDGET (bar));
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar");
}
static VALUE
rg_set_redraw_on_allocate(VALUE self, VALUE redraw_on_allocate)
{
gtk_widget_set_redraw_on_allocate(_SELF(self), RVAL2CBOOL(redraw_on_allocate));
return self;
}
static void
ol_scroll_window_init (OlScrollWindow *self)
{
/*basic*/
self->percentage = 0.0;
self->whole_lyrics = NULL;
self->current_lyric_id = -1;
/*privat data*/
OlScrollWindowPrivate *priv = OL_SCROLL_WINDOW_GET_PRIVATE (self);
priv->line_count = DEFAULT_LINE_COUNT;
priv->active_color = DEFAULT_ACTIVE_COLOR;
priv->inactive_color = DEFAULT_INACTIVE_COLOR;
priv->bg_color = DEFAULT_BG_COLOR;
priv->font_name = g_strdup (DEFAULT_FONT_NAME);
priv->alignment = DEFAULT_ALIGNMENT;
priv->line_margin = DEFAULT_LINE_MARGIN;
priv->padding_x = DEFAULT_PADDING_X;
priv->padding_y = DEFAULT_PADDING_Y;
priv->corner_radius = DEFAULT_CORNER_RADIUS;
priv->bg_opacity = DEFAULT_BG_OPACITY;
priv->frame_width = DEFAULT_FRAME_WIDTH;
priv->text = NULL;
priv->scroll_mode = OL_SCROLL_WINDOW_ALWAYS;
priv->can_seek = FALSE;
priv->seeking = FALSE;
/*set allocation*/
gtk_window_resize(GTK_WINDOW(self), DEFAULT_WIDTH, DEFAULT_HEIGHT);
gtk_widget_add_events (GTK_WIDGET (self),
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_DESTROY);
/* Set RGBA Colormap */
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (self));
GdkColormap* colormap = gdk_screen_get_rgba_colormap (screen);
if (colormap == NULL)
colormap = gdk_screen_get_rgb_colormap (screen);
gtk_widget_set_colormap (GTK_WIDGET (self), colormap);
gtk_window_set_decorated (GTK_WINDOW(self), FALSE);
gtk_widget_set_app_paintable (GTK_WIDGET (self), TRUE);
/* We need an additional widget to paint on */
priv->window_container = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
gtk_widget_set_redraw_on_allocate(priv->window_container, TRUE);
gtk_container_add (GTK_CONTAINER (self), priv->window_container);
/* Set toolbar container */
priv->toolbar_container = GTK_CONTAINER (gtk_alignment_new (1.0, 0.0, 0.0, 0.0));
gtk_alignment_set_padding (GTK_ALIGNMENT (priv->toolbar_container),
priv->padding_x, priv->padding_x,
priv->padding_x, priv->padding_x);
gtk_container_add (GTK_CONTAINER (priv->window_container),
GTK_WIDGET (priv->toolbar_container));
gtk_widget_show_all (priv->window_container);
/* Set tooltips */
ol_scroll_window_update_tooltip (self);
/* Connect signals */
g_signal_connect (G_OBJECT (priv->window_container), "expose-event",
G_CALLBACK (ol_scroll_window_expose), self);
g_signal_connect (G_OBJECT (self), "button-press-event",
G_CALLBACK (ol_scroll_window_button_press), self);
g_signal_connect (G_OBJECT (self), "button-release-event",
G_CALLBACK (ol_scroll_window_button_release), self);
g_signal_connect (G_OBJECT (self), "motion-notify-event",
G_CALLBACK (ol_scroll_window_motion_notify), self);
}
static void ygtk_ratio_box_init (YGtkRatioBox *box)
{
gtk_widget_set_has_window (GTK_WIDGET(box), FALSE);
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (box), FALSE);
}
static void ygtk_adj_size_init (YGtkAdjSize *adj_size)
{
gtk_widget_set_has_window(GTK_WIDGET(adj_size), FALSE);
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (adj_size), FALSE);
}
static void
dma_data_view_create_widget (DmaDataView *view)
{
GtkAdjustment *adj;
GtkWidget* wid;
PangoFontDescription *font_desc;
wid = GTK_WIDGET (view);
gtk_widget_set_has_window (wid, FALSE);
gtk_widget_set_can_focus (wid, TRUE);
gtk_widget_set_redraw_on_allocate (wid, FALSE);
view->char_by_byte = 2;
view->bytes_by_line = 16;
view->line_by_page = 16;
view->hadjustment = NULL;
view->vadjustment = NULL;
view->shadow_type = GTK_SHADOW_IN;
view->goto_window = NULL;
view->goto_entry = NULL;
font_desc = pango_font_description_from_string ("Monospace 10");
view->buffer_range = GTK_ADJUSTMENT (gtk_adjustment_new (0,
dma_data_buffer_get_lower (view->buffer),
dma_data_buffer_get_upper (view->buffer)
,1,4,4));
g_signal_connect (view->buffer_range, "value_changed",
G_CALLBACK (dma_data_view_value_changed), view);
gtk_widget_push_composite_child ();
wid = gtk_vscrollbar_new (view->buffer_range);
g_object_ref (wid);
view->range = wid;
gtk_widget_set_parent (wid, GTK_WIDGET (view));
adj = view->view_range;
gtk_widget_show (wid);
wid = dma_chunk_view_new ();
g_object_ref (wid);
gtk_widget_modify_font (wid, font_desc);
gtk_widget_set_parent (wid, GTK_WIDGET (view));
gtk_widget_set_size_request (wid, -1, 0);
gtk_widget_show (wid);
gtk_text_view_set_editable (GTK_TEXT_VIEW (wid), FALSE);
view->ascii = wid;
view->ascii_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (wid));
dma_chunk_view_set_scroll_adjustment (DMA_CHUNK_VIEW (wid), view->buffer_range);
g_signal_connect (wid, "populate_popup",
G_CALLBACK (dma_data_view_populate_popup), view);
wid = dma_chunk_view_new ();
g_object_ref (wid);
gtk_widget_modify_font (wid, font_desc);
gtk_widget_set_parent (wid, GTK_WIDGET (view));
gtk_widget_set_size_request (wid, -1, 0);
gtk_widget_show (wid);
gtk_text_view_set_editable (GTK_TEXT_VIEW (wid), FALSE);
view->data = wid;
view->data_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (wid));
dma_chunk_view_set_scroll_adjustment (DMA_CHUNK_VIEW (wid), view->buffer_range);
g_signal_connect (wid, "populate_popup",
G_CALLBACK (dma_data_view_populate_popup), view);
wid = dma_chunk_view_new ();
g_object_ref (wid);
gtk_widget_modify_font (wid, font_desc);
gtk_widget_set_parent (wid, GTK_WIDGET (view));
gtk_widget_set_size_request (wid, -1, 0);
gtk_widget_show (wid);
gtk_text_view_set_editable (GTK_TEXT_VIEW (wid), FALSE);
view->address = wid;
view->adr_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (wid));
dma_chunk_view_set_scroll_adjustment (DMA_CHUNK_VIEW (wid), view->buffer_range);
g_signal_connect (wid, "populate_popup",
G_CALLBACK (dma_data_view_populate_popup), view);
gtk_widget_pop_composite_child ();
pango_font_description_free (font_desc);
}
gint main (gint argc, gchar *argv[])
{
#ifdef HAVE_X11
XInitThreads();
#endif
gtk_init (&argc, &argv);
gst_init (&argc, &argv);
GstElement* pipeline = gst_pipeline_new ("pipeline");
//window that contains several ares where the video is drawn
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window, 640, 240);
gtk_window_move (GTK_WINDOW (window), 300, 10);
gtk_window_set_title (GTK_WINDOW (window), "click on left, right or outside the main window to switch the drawing area");
GdkGeometry geometry;
geometry.min_width = 1;
geometry.min_height = 1;
geometry.max_width = -1;
geometry.max_height = -1;
gtk_window_set_geometry_hints (GTK_WINDOW (window), window, &geometry, GDK_HINT_MIN_SIZE);
//window to control the states
GtkWidget* window_control = gtk_window_new (GTK_WINDOW_TOPLEVEL);
geometry.min_width = 1;
geometry.min_height = 1;
geometry.max_width = -1;
geometry.max_height = -1;
gtk_window_set_geometry_hints (GTK_WINDOW (window_control), window_control, &geometry, GDK_HINT_MIN_SIZE);
gtk_window_set_resizable (GTK_WINDOW (window_control), FALSE);
gtk_window_move (GTK_WINDOW (window_control), 10, 10);
GtkWidget* table = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window_control), table);
//control state null
GtkWidget* button_state_null = gtk_button_new_with_label ("GST_STATE_NULL");
g_signal_connect (G_OBJECT (button_state_null), "clicked",
G_CALLBACK (button_state_null_cb), pipeline);
gtk_grid_attach (GTK_GRID (table), button_state_null, 0, 0, 1, 1);
gtk_widget_show (button_state_null);
//control state ready
GtkWidget* button_state_ready = gtk_button_new_with_label ("GST_STATE_READY");
g_signal_connect (G_OBJECT (button_state_ready), "clicked",
G_CALLBACK (button_state_ready_cb), pipeline);
gtk_grid_attach (GTK_GRID (table), button_state_ready, 0, 1, 1, 1);
gtk_widget_show (button_state_ready);
//control state paused
GtkWidget* button_state_paused = gtk_button_new_with_label ("GST_STATE_PAUSED");
g_signal_connect (G_OBJECT (button_state_paused), "clicked",
G_CALLBACK (button_state_paused_cb), pipeline);
gtk_grid_attach (GTK_GRID (table), button_state_paused, 0, 2, 1, 1);
gtk_widget_show (button_state_paused);
//control state playing
GtkWidget* button_state_playing = gtk_button_new_with_label ("GST_STATE_PLAYING");
g_signal_connect (G_OBJECT (button_state_playing), "clicked",
G_CALLBACK (button_state_playing_cb), pipeline);
gtk_grid_attach (GTK_GRID (table), button_state_playing, 0, 3, 1, 1);
gtk_widget_show (button_state_playing);
gtk_widget_show (table);
gtk_widget_show (window_control);
//configure the pipeline
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(destroy_cb), pipeline);
GstElement* videosrc = gst_element_factory_make ("videotestsrc", "videotestsrc");
GstElement* videosink = gst_element_factory_make ("glimagesink", "glimagesink");
gst_bin_add_many (GST_BIN (pipeline), videosrc, videosink, NULL);
gboolean link_ok = gst_element_link_many(videosrc, videosink, NULL);
if(!link_ok)
{
g_warning("Failed to link videosrc to videosink!\n") ;
return -1;
}
//areas where the video is drawn
GtkWidget* table_areas = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), table_areas);
GtkWidget* area_top_left = gtk_drawing_area_new();
gtk_widget_add_events(area_top_left, GDK_BUTTON_PRESS_MASK);
gtk_widget_set_size_request (area_top_left, 320, 240);
gtk_grid_attach (GTK_GRID (table_areas), area_top_left, 0, 0, 1, 1);
GtkWidget* area_top_right = gtk_drawing_area_new();
gtk_widget_add_events(area_top_right, GDK_BUTTON_PRESS_MASK);
gtk_widget_set_size_request (area_top_right, 320, 240);
gtk_grid_attach (GTK_GRID (table_areas), area_top_right, 1, 0, 1, 1);
gtk_widget_set_redraw_on_allocate (area_top_left, TRUE);
gtk_widget_set_redraw_on_allocate (area_top_right, TRUE);
gtk_widget_realize(area_top_left);
gtk_widget_realize(area_top_right);
GstBus* bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_set_sync_handler (bus, (GstBusSyncHandler) create_window, area_top_right, NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect(bus, "message::error", G_CALLBACK(end_stream_cb), pipeline);
g_signal_connect(bus, "message::warning", G_CALLBACK(end_stream_cb), pipeline);
g_signal_connect(bus, "message::eos", G_CALLBACK(end_stream_cb), pipeline);
gst_object_unref (bus);
//needed when being in GST_STATE_READY, GST_STATE_PAUSED
//or resizing/obscuring the window
g_signal_connect(area_top_left, "draw", G_CALLBACK(expose_cb), videosink);
g_signal_connect(area_top_left, "configure-event", G_CALLBACK(resize_cb), videosink);
g_signal_connect(area_top_right, "draw", G_CALLBACK(expose_cb), videosink);
g_signal_connect(area_top_right, "configure-event", G_CALLBACK(resize_cb), videosink);
//switch the drawing area
g_signal_connect(area_top_left, "button-press-event", G_CALLBACK(on_click_drawing_area), videosink);
g_signal_connect(area_top_right, "button-press-event", G_CALLBACK(on_click_drawing_area), videosink);
gtk_widget_show_all (window);
gst_element_set_state(pipeline, GST_STATE_PLAYING);
gtk_main();
return 0;
}
