adding image widget on gtklayout - gtk

I have put an image on gtklayout calling put method, but i could not get the image visible.
What is the procedure for putting an image gtklayout object so that it appears as its back ground.
Regards,
iSight

pls check if the code below would work for you:
int main( int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *layout;
GtkWidget *image;
GtkWidget *button;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 290, 200);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
layout = gtk_layout_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER (window), layout);
gtk_widget_show(layout);
image = gtk_image_new_from_file("/home/my_test_image.jpg"); // put path to your image here
gtk_layout_put(GTK_LAYOUT(layout), image, 0, 0);
button = gtk_button_new_with_label("Button");
gtk_layout_put(GTK_LAYOUT(layout), button, 150, 50);
gtk_widget_set_size_request(button, 80, 35);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
hope this helps, regards

Related

Alternative to deprecated gtk_alignment_new

I used the GtkAlignment widget to control the alignment and size of its child widget. But gtk_alignment_new has been deprecated since version 3.14 and should not be used in newly-written code. What functions should I use as alternatives to let the code be gtk3+ compatible?
#include <gtk/gtk.h>
int main(int argc, char *argv[]) {
GtkWidget *window;
GtkWidget *button;
GtkWidget *halign;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Tooltip");
gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
gtk_container_set_border_width(GTK_CONTAINER(window), 15);
button = gtk_button_new_with_label("Button");
gtk_widget_set_tooltip_text(button, "Button widget");
halign = gtk_alignment_new(0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(halign), button);
gtk_container_add(GTK_CONTAINER(window), halign);
gtk_widget_show_all(window);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
gtk_main();
return 0;
}
As suggested in the comment, use these two functions instead:
void gtk_widget_set_halign (GtkWidget *widget, GtkAlign align);
Sets the horizontal alignment of widget.
gtk_widget_get_valign (GtkWidget *widget); Sets the vertical alignment of widget.
The enum GtkAlign types are the following:
GTK_ALIGN_START: The 'start' of the layout. Vertically this is the top, horizontally this is left/right according to LTR/RTL
GTK_ALIGN_END: Opposite of GTK_ALIGN_START
GTK_ALIGN_CENTER: The middle of the layout
GTK_ALIGN_FILL : Take all available space
for scaling use GTK_ALIGN_FILL.
So the gtk3+ compatible alternative for your code is the following:
#include <gtk/gtk.h>
int main(int argc, char *argv[]) {
GtkWidget *window;
GtkWidget *button;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Tooltip");
gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
gtk_container_set_border_width(GTK_CONTAINER(window), 15);
button = gtk_button_new_with_label("Button");
gtk_widget_set_tooltip_text(button, "Button widget");
gtk_widget_set_halign (button, GTK_ALIGN_START);
gtk_widget_set_valign (button, GTK_ALIGN_START);
gtk_container_add (GTK_CONTAINER (window), button);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}

GtkNotebook does not show tab label content

In an application with a GtkNotebook and a GtkBox as tab label, the tab label is visible, but the content of the tab label is not. How can I make the content of the tab label visible?
#include <gtk/gtk.h>
int main (int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget* notebook = gtk_notebook_new();
GtkWidget* page_content = gtk_label_new("Content");
GtkWidget* tab_label = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget* label_content_1 = gtk_label_new("Title");
GtkWidget* label_content_2 = gtk_button_new_with_label("Close");
gtk_box_pack_start(GTK_BOX(tab_label), label_content_1, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(tab_label), label_content_2, FALSE, FALSE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page_content, tab_label);
gtk_container_add(GTK_CONTAINER(window), notebook);
gtk_widget_show_all(GTK_WIDGET(window));
gtk_main();
}
I got it working by showing the widgets in GTK_BOX explicitly, and calling gtk_notebook_set_show_tabs:
#include <gtk-3.0/gtk/gtk.h>
int main (int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget* notebook = gtk_notebook_new();
GtkWidget* page_content = gtk_label_new("Content");
GtkWidget* tab_label = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget* label_content_1 = gtk_label_new("Title");
GtkWidget* label_content_2 = gtk_button_new_with_label("Close");
gtk_widget_show(GTK_WIDGET(label_content_1));
gtk_widget_show(GTK_WIDGET(label_content_2));
gtk_widget_show(GTK_WIDGET(tab_label));
gtk_box_pack_start(GTK_BOX(tab_label), label_content_1, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(tab_label), label_content_2, FALSE, FALSE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page_content, tab_label);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), TRUE);
gtk_container_add(GTK_CONTAINER(window), notebook);
gtk_widget_show_all(GTK_WIDGET(window));
gtk_main();
}
I am not in a position to explain the reason behind that though.
You may find this link about tabs with close button interesting.

How I can maximize GtkGrid to fill the entire GtkWindow?

I made a basic GtkGrid application with a simple layout but I can't make the GtkGrid fill the entire GtkWindow. This is the code for creating the layout:
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
GtkWidget *grid = gtk_grid_new();
g_signal_connect(window,"destroy", G_CALLBACK(gtk_main_quit), NULL);
GtkWidget *vpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_position (GTK_PANED (vpaned), 400);
GtkWidget *label = gtk_label_new("Label1111111111111111111111111111111");
GtkWidget *label2 = gtk_label_new("Label2");
GtkWidget *label3 = gtk_label_new("Label3");
GtkWidget *label4 = gtk_label_new("Label4");
gtk_paned_pack1 (GTK_PANED (vpaned), label, FALSE, TRUE);
gtk_paned_pack2 (GTK_PANED (vpaned), label2, FALSE, TRUE);
gtk_widget_show (label);
gtk_widget_show (label2);
gtk_widget_show (label3);
gtk_widget_show (label4);
gtk_widget_show (vpaned);
gtk_grid_attach(GTK_GRID(grid), label3, 0,0,1,1);
gtk_grid_attach(GTK_GRID(grid), vpaned, 0,1,1,1);
gtk_grid_attach(GTK_GRID(grid), label4, 0,2,1,1);
gtk_widget_show(grid);
gtk_container_add(GTK_CONTAINER(window), grid);
gtk_widget_show (window);
You may have a look at expand property and assure it is set to TRUE (default if you do your UI within glade designer)

How to manually draw the GtkTreeView expander

I'm using a GtkTreeView widget and I want to change the appearance of the "expander" icon that opens and closes child rows: I want the icons to be the triangels that we're all familiar with, but they're appearing as boxed "+" and "-" symbols instead.
At first I thought there must be a style enumeration that I can set, but I cannot find one. Then, I thought maybe there's a style property I can set in my theme's gtkrc file, but I don't think there is one. Finally, I resorted to trying to manually override the draw method like so:
GtkWidget *pTreeView = gtk_tree_view_new_with_model((GtkTreeModel *)pTreeModel);
(GTK_STYLE_GET_CLASS(pTreeView->style))->draw_expander = my_draw_expander_override;
But my_draw_expander_override() never gets called and the expanders are still the boxed "+" and "-" icons.
Does anyone know how can I change the appearance of the GtkTreeView expander icons or just draw them myself?
Thanks a bunch in advance!
Here the sample code of how to overwrite draw_expander. You'll definetely have to take a look in the manual to get all the parameters right.
#include <gtk/gtk.h>
#include <cairo.h>
enum {
COL_1,
N_COLS
};
void draw_expander (GtkStyle *style,
GdkWindow *window,
GtkStateType state_type,
GdkRectangle *area,
GtkWidget *widget,
const gchar *detail,
gint x,
gint y,
GtkExpanderStyle expander_style) {
cairo_t *cr;
cr = gdk_cairo_create (window);
cairo_set_source_rgb(cr, 0, 0, 0);
cairo_move_to (cr, 0, 0);
cairo_line_to (cr, 0, 10);
cairo_line_to (cr, 10, 5);
cairo_close_path (cr);
cairo_stroke (cr);
}
GtkWidget *build_view (); /* just supply your own */
int main (int argc, char *argv[]) {
gtk_init (&argc, &argv);
GtkWidget *window;
GtkWidget *view;
window = g_object_new (GTK_TYPE_WINDOW, NULL);
view = build_view ();
gtk_container_add (GTK_CONTAINER (window), view);
GtkStyle *style = gtk_widget_get_style (view);
GtkStyleClass *klass = GTK_STYLE_GET_CLASS (style);
klass->draw_expander = draw_expander;
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
Maybe you should just try to switch to a theme that draws expanders the way you want them to be displayed, as I am quite sure some of your users might find it a little rude if you "force" them to approve that triangles are the one and only way to draw expanders and deny them any chance to change this.
That's especially what themes were made for - such that everybody can have the look she wants.
Well, anyway unfortunately actually GTK is in a transition from version 2 to version 3, so depending on the version you are using you would have to overwrite another signal.
It should be a little bit easier in GTK 3 since you already get your cairo context in the "draw" signal, but it's also possible in GTK 2, here you would have to use the "expose-event" signal.
Here as an example here a snippet of how to do it with GTK version 2. As I am no real artist it might not look too nice, but I'm sure you will come up with a nice design.
... ah, and don't forget to change the way it's painted depedning on its state ...
#include <gtk/gtk.h>
#include <cairo.h>
gboolean draw (GtkWidget *widget, GdkEventExpose *event, gpointer data) {
cairo_t *cr;
cr = gdk_cairo_create (widget->window);
cairo_set_source_rgb(cr, 0, 0, 0);
cairo_move_to (cr, 0, 0);
cairo_line_to (cr, 0, 10);
cairo_line_to (cr, 10, 5);
cairo_close_path (cr);
cairo_stroke (cr);
return TRUE;
}
int main (int argc, char *argv[]) {
gtk_init (&argc, &argv);
GtkWidget *window;
GtkWidget *expander;
window = g_object_new (GTK_TYPE_WINDOW, NULL);
expander = g_object_new (GTK_TYPE_EXPANDER, NULL);
gtk_container_add (GTK_CONTAINER (window), expander);
g_signal_connect (expander, "expose-event", draw, NULL);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
EDIT:
As I saw you don't seem to want to change the appearance for just one instance, but for ALL expanders. To accomplish this you would have to overwrite the default handler like this:
#include <gtk/gtk.h>
#include <cairo.h>
gboolean draw (GtkWidget *widget, GdkEventExpose *event) {
cairo_t *cr;
cr = gdk_cairo_create (widget->window);
cairo_set_source_rgb(cr, 0, 0, 0);
cairo_move_to (cr, 0, 0);
cairo_line_to (cr, 0, 10);
cairo_line_to (cr, 10, 5);
cairo_close_path (cr);
cairo_stroke (cr);
return TRUE;
}
int main (int argc, char *argv[]) {
gtk_init (&argc, &argv);
GtkWidget *window;
GtkWidget *expander;
GtkWidgetClass *klass;
window = g_object_new (GTK_TYPE_WINDOW, NULL);
expander = g_object_new (GTK_TYPE_EXPANDER, NULL);
gtk_container_add (GTK_CONTAINER (window), expander);
klass = g_type_class_peek (GTK_TYPE_EXPANDER);
klass->expose_event = draw;
gtk_widget_show_all (window);
gtk_main ();
return 0;
}

opencv image update in gtk for video streaming linux with C programming

I am using opencv 1.0.0 and gtk2.0. I want to grab images continuously from a video stream. So far I have successfully been able to grab still image. This is non standard IP camera not VGA/USB /V4L one so need to know explicit method to refresh or update images continuously for video streaming!
GtkWidget *image;
...
...
IplImage* bayerImage = NULL;
IplImage* rgbImage = NULL;
...
...
...
cvCvtColor( bayerImage, rgbImage, CV_BayerBG2RGB );
// Usually opencv image is BGR, so we need to change it to RGB
pix = gdk_pixbuf_new_from_data ((guchar*)rgbImage->imageData,
GDK_COLORSPACE_RGB,
FALSE,
rgbImage->depth,
rgbImage->width,
rgbImage->height,
(rgbImage->widthStep),
NULL,
NULL);
image = gtk_image_new_from_pixbuf (pix);
/* (c) 2010 Virgoptrex. Feel Free to use. Leave credits intact */
#include gtk/gtk.h
gint t=0;
gboolean
expose_event_callback (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
//g_object_ref_sink (widget->window);
// gdk_drawable_ref (widget->window);
gdk_draw_arc (widget->window,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
TRUE,
0, 0, widget->allocation.width, widget->allocation.height,
0, 64 * 18*t);
//gdk_drawable_unref (widget->window);
return TRUE;
}
static gboolean
time_handler(GtkWidget *widget)
{
gtk_widget_queue_draw(GTK_WIDGET(widget));
if (t<20)
{ t++; }
else if (t >=20)
{ t=0; }
printf("hello %d\n",t);
return TRUE;
}
int main( int argc,
char *argv[] )
{
GtkWidget *window;
GtkWidget *aspect_frame;
GtkWidget *drawing_area;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Aspect Frame");
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* Create an aspect_frame and add it to our toplevel window */
aspect_frame = gtk_aspect_frame_new ("2x1", /* label */
0.5, /* center x */
0.5, /* center y */
2, /* xsize/ysize = 2 */
FALSE /* ignore child's aspect */);
gtk_container_add (GTK_CONTAINER (window), aspect_frame);
gtk_widget_show (aspect_frame);
/* Now add a child widget to the aspect frame */
drawing_area = gtk_drawing_area_new ();
/* Ask for a 200x200 window, but the AspectFrame will give us a 200x100
* window since we are forcing a 2x1 aspect ratio */
gtk_widget_set_size_request (drawing_area, 200, 200);
gtk_container_add (GTK_CONTAINER (aspect_frame), drawing_area);
gtk_widget_show (drawing_area);
g_signal_connect (G_OBJECT (drawing_area), "expose_event",
G_CALLBACK (expose_event_callback), NULL);
g_timeout_add(100, (GSourceFunc) time_handler, (gpointer)drawing_area);
gtk_widget_show (window);
gtk_main ();
return 0;
}