again about gdk gtk

//the simple sample

//

#include <stdlib.h>
#include <gtk/gtk.h>
#include <assert.h>
/*
 *
 */
static void destroy(GtkWidget * widget, gpointer data)
{
    gtk_main_quit();
}

int main(int argc, char** argv)
{
    gtk_init(&argc, &argv);

    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    assert(window != NULL);
   
    gtk_container_set_border_width(GTK_CONTAINER(window), 100);

    g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);

    gtk_widget_show_all(window);

    gtk_main();

    return (EXIT_SUCCESS);
}

 

//

//control close event

#include <stdlib.h>
#include <gtk/gtk.h>
#include <assert.h>
/*
 *
 */
static void destroy(GtkWidget * widget, gpointer data)
{
    gtk_main_quit();
}

static gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
{
    g_print("delete event occurred, I'll cancel this operation/n");
    gulong *gpdelete = (gulong*)data;
    g_signal_handler_disconnect(widget, *gpdelete);
    g_print("disconnect, i'll canot capture the delete-event/n");
    return TRUE;
}

static void hello(GtkWidget *widget, gpointer data)
{
    g_print("Hello World - %s was pressed/n", (gchar*)data);
}

int main(int argc, char** argv)
{
    gtk_init(&argc, &argv);

    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    assert(window != NULL);
    gtk_window_set_title(GTK_WINDOW(window),"Hello buttons");

    gtk_container_set_border_width(GTK_CONTAINER(window), 100);


    g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);

    //
    gulong gdelete = 0;
    gdelete = g_signal_connect(G_OBJECT(window), "delete_event",
            G_CALLBACK(delete_event), &gdelete);

    GtkWidget *button = gtk_button_new_with_label("Hello World");
    assert(button != NULL);
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(hello), NULL);
    g_signal_connect_swapped(G_OBJECT(button), "clicked",
            G_CALLBACK(gtk_widget_destroy), G_OBJECT(window));
    gtk_container_add(GTK_CONTAINER(window), button);
    //

    gtk_widget_show_all(window);

    gtk_main();

    return (EXIT_SUCCESS);
}

 

//

//you can use layout

#include <stdlib.h>
#include <gtk/gtk.h>
#include <assert.h>
/*
 *
 */
static void destroy(GtkWidget * widget, gpointer data)
{
    gtk_main_quit();
}

static gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
{
    g_print("delete event occurred, I'll cancel this operation/n");
    gulong *gpdelete = (gulong*)data;
    g_signal_handler_disconnect(widget, *gpdelete);
    g_print("disconnect, i'll canot capture the delete-event/n");
    return TRUE;
}

static void hello(GtkWidget *widget, gpointer data)
{
    g_print("Hello World - %s was pressed/n", (gchar*)data);
}

GtkWidget *xpm_label_box(gchar *xpm_filename, gchar *label_text)
{
    GtkWidget *hbox = NULL, *label = NULL, *image = NULL;
    hbox = gtk_hbox_new(FALSE, 0);
    gtk_container_set_border_width(GTK_CONTAINER(hbox), 2);

    image = gtk_image_new_from_file(xpm_filename);
    label = gtk_label_new(label_text);

    gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 3);
    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 3);

    gtk_widget_show(image);
    gtk_widget_show(label);

    return hbox;
}

int main(int argc, char** argv)
{
    gtk_init(&argc, &argv);

    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    assert(window != NULL);
    gtk_window_set_title(GTK_WINDOW(window),"Hello buttons");

    gtk_container_set_border_width(GTK_CONTAINER(window), 100);


    g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);

    gulong gdelete = 0;
    gdelete = g_signal_connect(G_OBJECT(window), "delete_event",
            G_CALLBACK(delete_event), &gdelete);

    //
    GtkWidget *hBox = gtk_hbox_new(FALSE, 50);
    assert(hBox != NULL);
    gtk_container_add(GTK_CONTAINER(window), hBox);

    GtkWidget *button = gtk_button_new_with_label("Hello World");
    assert(button != NULL);
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(hello), (void*)"button1");
    g_signal_connect_swapped(G_OBJECT(button), "clicked",
            G_CALLBACK(gtk_widget_destroy), G_OBJECT(window));

    //gtk_container_add(GTK_CONTAINER(window), button);
    gtk_box_pack_start(GTK_BOX(hBox), button, FALSE, TRUE, 0);
    //

    button = gtk_button_new_with_label("Button..");
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(hello), (void*)"button2");
    gtk_box_pack_start(GTK_BOX(hBox), button, FALSE, TRUE, 0);

    //
    GtkWidget *table = gtk_table_new(2,3,TRUE);
    button = gtk_button_new_with_label("B1");
    gtk_table_attach_defaults(GTK_TABLE(table), button, 0, 1, 0, 1);
    button = gtk_button_new_with_label("B2");
    gtk_table_attach_defaults(GTK_TABLE(table), button, 1, 2, 0, 1);
    button = gtk_button_new_with_label("B3");
    gtk_table_attach_defaults(GTK_TABLE(table), button, 0, 2, 1, 2);

    gtk_box_pack_start(GTK_BOX(hBox), table, TRUE, TRUE, 100);

    button = xpm_label_box("~/info.png", "cool button");
    gtk_table_attach_defaults(GTK_TABLE(table), button, 2, 3, 0, 2);

    //
    GtkWidget *vBox = gtk_vbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(hBox), vBox, TRUE, TRUE, 0);

    button = gtk_radio_button_new_with_label(NULL, "radio butt_on 1");
    gtk_box_pack_start(GTK_BOX(vBox), button, TRUE, TRUE, 0);
    button = gtk_radio_button_new_with_mnemonic(
            gtk_radio_button_get_group(GTK_RADIO_BUTTON(button)), "radio butto_n 2");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
    gtk_box_pack_start(GTK_BOX(vBox), button, TRUE, TRUE, 0);


    gtk_widget_show_all(window);

    gtk_main();

    return (EXIT_SUCCESS);
}

 

//

//adjustment

#include <stdlib.h>
#include <gtk/gtk.h>
/*
 *
 */
GtkWidget *hscale, *vscale;

void cb_pos_menu_select(GtkWidget *item, GtkPositionType pos)
{
    gtk_scale_set_value_pos(GTK_SCALE(hscale), pos);
    gtk_scale_set_value_pos(GTK_SCALE(vscale), pos);
}

void cb_update_menu_select(GtkWidget *item, GtkUpdateType policy)
{
    gtk_range_set_update_policy(GTK_RANGE(hscale), policy);
    gtk_range_set_update_policy(GTK_RANGE(vscale), policy);
}

void cb_digits_scale(GtkAdjustment *adj)
{
    gtk_scale_set_digits(GTK_SCALE(hscale), (gint)adj->value);
    gtk_scale_set_digits(GTK_SCALE(vscale), (gint)adj->value);
}

void cb_page_size(GtkAdjustment *get, GtkAdjustment*set)
{
    set->page_size = get->value;
    set->page_increment = get->value;
    gtk_adjustment_set_value(set,
            CLAMP(set->value, set->lower, (set->upper - set->page_size)));
}

void cb_draw_value(GtkToggleButton *button)
{
    gtk_scale_set_draw_value(GTK_SCALE(hscale), button->active);
    gtk_scale_set_draw_value(GTK_SCALE(vscale), button->active);
}

// conven
GtkWidget *make_menu_item(gchar *name, GCallback callback, gpointer data)
{
    GtkWidget *item;
    item = gtk_menu_item_new_with_label(name);
    g_signal_connect(G_OBJECT(item), "activate", callback, data);
    gtk_widget_show(item);
    return item;
}

void scale_set_default_values(GtkScale *scale)
{
    gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_CONTINUOUS);
    gtk_scale_set_digits(scale, 1);
    gtk_scale_set_value_pos(scale, GTK_POS_TOP);
    gtk_scale_set_draw_value(scale, TRUE);
}


void create_range_controls(void)
{
    GtkWidget *window;
    GtkWidget *box1, *box2, *box3;
    GtkWidget *button;
    GtkWidget *scrollbar;
    GtkWidget *separator;
    GtkWidget *opt, *menu, *item;
    GtkWidget *label;
    GtkWidget *scale;
    GtkObject *adj1, *adj2;

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    g_signal_connect(G_OBJECT(window), "destroy",
            G_CALLBACK(gtk_main_quit), NULL);
    gtk_window_set_title(GTK_WINDOW(window), "range controls");

    box1 = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(window), box1);
    gtk_widget_show(box1);

    box2 = gtk_hbox_new(FALSE, 10);
    gtk_container_set_border_width(GTK_CONTAINER(box2), 10);
    gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
    gtk_widget_show(box2);

    /*
     * value, lower, upper, step_increment, page_increment, page_size
     * not that, page_size is valid only for scrollbar, and
     * the max value is (upper - page_size)
   */
     adj1 = gtk_adjustment_new(0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
    
     vscale = gtk_vscale_new(GTK_ADJUSTMENT(adj1));
     scale_set_default_values(GTK_SCALE(vscale));
     gtk_box_pack_start(GTK_BOX(box2), vscale, TRUE, TRUE, 0);
     gtk_widget_show(vscale);

     box3 = gtk_vbox_new(FALSE, 10);
     gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
     gtk_widget_show(box3);

     // use the same one adjustment

     hscale = gtk_hscale_new(GTK_ADJUSTMENT(adj1));
     gtk_widget_set_size_request(GTK_WIDGET(hscale), 200, -1);
     scale_set_default_values(GTK_SCALE(hscale));
     gtk_box_pack_start(GTK_BOX(box3), hscale, TRUE, TRUE, 0);
     gtk_widget_show(hscale);

     // use the same again
     scrollbar = gtk_hscrollbar_new(GTK_ADJUSTMENT(adj1));
     //gtk_range_set_update_policy(GTK_RANGE(scrollbar), GTK_UPDATE_CONTINUOUS);
     gtk_box_pack_start(GTK_BOX(box3), scrollbar, TRUE, TRUE, 0);
     gtk_widget_show(scrollbar);

     box2 = gtk_hbox_new(FALSE, 10);
     gtk_container_set_border_width(GTK_CONTAINER(box2), 10);
     gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
     gtk_widget_show(box2);

     // use a checkbox to ctl show blictrl
     button = gtk_check_button_new_with_label("Display value on scale widgets");
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
     g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(cb_draw_value)
             , NULL);
     gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
     gtk_widget_show(button);

     box2 = gtk_hbox_new(FALSE, 10);
     gtk_container_set_border_width(GTK_CONTAINER(box2), 10);
     gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);

     // use a menu to chage scale value's pos
     label = gtk_label_new("Scale Value Position:");
     gtk_box_pack_start(GTK_BOX(box2), label, FALSE, FALSE, 0);
     gtk_widget_show(label);

     opt = gtk_option_menu_new();
     menu = gtk_menu_new();
     item = make_menu_item("Top", G_CALLBACK(cb_pos_menu_select),
             GINT_TO_POINTER(GTK_POS_TOP));
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

    item = make_menu_item("Bottom", G_CALLBACK(cb_pos_menu_select),
            GINT_TO_POINTER(GTK_POS_BOTTOM));
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

     item = make_menu_item("Left", G_CALLBACK(cb_pos_menu_select),
            GINT_TO_POINTER(GTK_POS_LEFT));
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

    item = make_menu_item("Right", G_CALLBACK(cb_pos_menu_select),
          GINT_TO_POINTER(GTK_POS_RIGHT));
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

     gtk_option_menu_set_menu(GTK_OPTION_MENU(opt), menu);
     gtk_box_pack_start(GTK_BOX(box2), opt, TRUE, TRUE, 0);
     gtk_widget_show(opt);

     //
     box2 = gtk_hbox_new(FALSE, 10);
     gtk_container_set_border_width(GTK_CONTAINER(box2), 10);
     gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);

     opt = gtk_option_menu_new();
     menu = gtk_menu_new();

     item = make_menu_item("Continuous", G_CALLBACK(cb_update_menu_select),
            GINT_TO_POINTER(GTK_UPDATE_CONTINUOUS));
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

     item = make_menu_item("Discontinuous", G_CALLBACK(cb_update_menu_select),
            GINT_TO_POINTER(GTK_UPDATE_DISCONTINUOUS));
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

     item = make_menu_item("Delayed", G_CALLBACK(cb_update_menu_select),
            GINT_TO_POINTER(GTK_UPDATE_DELAYED));
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

     gtk_option_menu_set_menu(GTK_OPTION_MENU(opt), menu);
     gtk_box_pack_start(GTK_BOX(box2), opt, TRUE, TRUE, 0);
     gtk_widget_show(opt);

     //
     box2 = gtk_hbox_new(FALSE, 10);
     gtk_container_set_border_width(GTK_CONTAINER(box2), 10);
     gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);

     label = gtk_label_new("Scale Digits:");
     gtk_box_pack_start(GTK_BOX(box2), label, FALSE, FALSE, 0);
     gtk_widget_show(label);

     adj2 = gtk_adjustment_new(1.0, 0.0, 5.0, 1.0, 1.0, 0.0);
     g_signal_connect(G_OBJECT(adj2), "value_changed"
             , G_CALLBACK(cb_digits_scale), NULL);
     scale = gtk_hscale_new(GTK_ADJUSTMENT(adj2));
     gtk_scale_set_digits(GTK_SCALE(scale), 0);
     gtk_box_pack_start(GTK_BOX(box2), scale, TRUE, TRUE, 0);
     gtk_widget_show(scale);

    

     gtk_widget_show_all(window);
}

int main(int argc, char** argv)
{
    gtk_init(&argc, &argv);

    create_range_controls();

    gtk_main();
    return (EXIT_SUCCESS);
}
//

// use glade

#include <stdlib.h>
#include <gtk/gtk.h>
#include <libglade-2.0/glade/glade.h>
/*
 *
 */
int main(int argc, char** argv)
{

    GladeXML *gxml;
    GtkWidget *window;

    gtk_init(&argc, &argv);
    gxml = glade_xml_new("/home/cogent/win.glade", NULL, NULL);
    window = glade_xml_get_widget(gxml, "gh");
    g_object_unref(G_OBJECT(gxml));
    gtk_widget_show(window);
    gtk_main();
    return (EXIT_SUCCESS);
}

 

//

//capture screen

#include <stdlib.h>
#include <gtk/gtk.h>
#include <unistd.h>
#include <X11/X.h>
/*
 *
 */
void do_capture_screenshot(char *file, int sec)
{
    gint x, y;
    GdkScreen *cur_screen = NULL;
    GdkWindow *window = NULL;
    GdkPixbuf *pixbuf_screenshot = NULL;
    GdkRectangle rect, screen_rect;

    g_print("ready to capture.../r/n");

    //sleep(sec);

    if(cur_screen == NULL)
        cur_screen = gdk_screen_get_default();
    screen_rect.x = 0;
    screen_rect.y = 0;
    screen_rect.width = gdk_screen_get_width(cur_screen);
    screen_rect.height = gdk_screen_get_height(cur_screen);

    window = gdk_screen_get_root_window(cur_screen);

    gdk_window_get_origin(window, &x, &y);

    rect.x = x;
    rect.y = y;
    gdk_drawable_get_size(GDK_DRAWABLE(window), &rect.width, &rect.height);

    if(!gdk_rectangle_intersect(&rect, &screen_rect, &rect))
    {
        g_print("Capture failed!.../r/n");
    }

    pixbuf_screenshot = gdk_pixbuf_get_from_drawable(NULL, window, NULL,
            rect.x - x, rect.y - y, 0, 0, rect.width, rect.height);
    gdk_pixbuf_save(pixbuf_screenshot, file, "jpeg", NULL, "quality", "100", NULL);

    GdkPixbuf *dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 200, 200);

    gdk_pixbuf_copy_area(pixbuf_screenshot, 0, 0, 200, 200, dest, 0, 0);

    gdk_pixbuf_save(dest, "/home/cogent/area", "jpeg", NULL, "quality", "100", NULL);

    g_object_unref(pixbuf_screenshot);





    g_print("Capture saved!!/r/n");

    return;
}
int main(int argc, char** argv)
{
    gtk_init(&argc, &argv);
   
    do_capture_screenshot("/home/cogent/captured", 5);
    return (EXIT_SUCCESS);
}

 

//

// functions to capture

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <gtk/gtk.h>
#include <assert.h>
#include <string.h>
/*
 *
 */
typedef  void* HBITMAP;
typedef void* HWND;
#define BOOL int
#define WORD char
#define BYTE char
#define LPBYTE char*
#define DWORD int
#define CONST const

struct RECT
{
    long left;
    long top;
    long right;
    long bottom;
};

HBITMAP CaptureControlBitmap(HWND hControlWnd /*= NULL*/, RECT *prtControl /*= NULL*/)
{
    printf("begin capture, wait/n");
    sleep(3);
    printf("begin capture/n");
    GdkWindow *pGdkWnd = (GdkWindow*)hControlWnd;

    GdkPixbuf *pixbuf = NULL;
   
    int width = 0, height = 0;
    gdk_drawable_get_size(GDK_DRAWABLE(pGdkWnd), &width, &height);
   
    pixbuf = gdk_pixbuf_get_from_drawable(NULL, pGdkWnd, NULL,
            0, 0, 0, 0, width, height);
    int x = gdk_pixbuf_get_bits_per_sample(pixbuf);
    gdk_pixbuf_save(pixbuf, "/home/cogent/mycap.png", "png", NULL, "quality", "100", NULL);

    return pixbuf;
}

BOOL HBitmapToBuffer(HBITMAP hBitmap, LPBYTE pBuffer, DWORD *pdwBuffer)
{
    gchar *pBufTmp = NULL;
    gsize bufTmpSize = 0;
    GError *err = NULL;
    if(!gdk_pixbuf_save_to_buffer((GdkPixbuf*)hBitmap, &pBufTmp, &bufTmpSize, "jpeg"
            , &err, "quality", "100", NULL))
    {
        printf("error : %s", err->message);
        g_error_free(err);
        return FALSE;
    }

    if(pBuffer == NULL)
    {
        if(pdwBuffer == NULL)
            return FALSE;
        *pdwBuffer = bufTmpSize;
        return TRUE;
    }

    if(pdwBuffer != NULL && *pdwBuffer < bufTmpSize)
    {
        *pdwBuffer = bufTmpSize;
        return FALSE;
    }

    memcpy(pBuffer, pBufTmp, bufTmpSize);

    return TRUE;
}

BOOL HBitmapToBufferOnlyData(HBITMAP hBitmap, LPBYTE pBuffer, DWORD *pdwBuffer)
{
    return HBitmapToBuffer(hBitmap, pBuffer, pdwBuffer);
}

HBITMAP LoadBitmapFromBuffer(CONST BYTE *pBuf, int nSize)
{
    GdkPixbufLoader *loader;
    GdkPixbuf *pixbuf;

    loader = gdk_pixbuf_loader_new();

    GError *err;
    if(gdk_pixbuf_loader_write(loader, (const guchar*)pBuf, nSize, &err)
            && gdk_pixbuf_loader_close(loader, &err))
    {
        pixbuf = (GdkPixbuf*)g_object_ref(gdk_pixbuf_loader_get_pixbuf(loader));
        g_object_unref(loader);
        return pixbuf;
    }
    return NULL;
}

BOOL DeleteHBitmap(HBITMAP hBitmap)
{
    GdkPixbuf *pixbuf = (GdkPixbuf*)hBitmap;
    if(pixbuf != NULL)
        g_object_unref(pixbuf);
    return TRUE;
}

BOOL GetHBitmapInfo(HBITMAP hBitmap, int *pnWidth, int *pnHeight, WORD *pwBitsPixel)
{
    if(hBitmap == NULL)
        return FALSE;

    GdkPixbuf *pixbuf = (GdkPixbuf*)hBitmap;

    if(pnWidth != NULL)
    {
        *pnWidth = gdk_pixbuf_get_width(pixbuf);
    }

    if(pnHeight != NULL)
    {
        *pnHeight = gdk_pixbuf_get_height(pixbuf);
    }

    if(pwBitsPixel != NULL)
    {
        *pwBitsPixel = gdk_pixbuf_get_bits_per_sample(pixbuf);
    }

    return TRUE;
   
}


HBITMAP ClipBitmap(HBITMAP hSrcBitmap, RECT &rtNewBitmap)
{
    GdkPixbuf *srcpixbuf = (GdkPixbuf*)hSrcBitmap;

    GdkRectangle img_rect = {0};
    img_rect.width = gdk_pixbuf_get_width(srcpixbuf);
    img_rect.height = gdk_pixbuf_get_height(srcpixbuf);
   
    GdkRectangle new_rect = {0};
    new_rect.x = rtNewBitmap.left;
    new_rect.y = rtNewBitmap.top;
    new_rect.width = rtNewBitmap.right - rtNewBitmap.left + 1;
    new_rect.height = rtNewBitmap.bottom - rtNewBitmap.top + 1;
    if(!gdk_rectangle_intersect(&new_rect, &img_rect, &new_rect))
    {
        g_print("Capture failed!.../r/n");
        return NULL;
    }

    GdkPixbuf *destPixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, new_rect.width
            , new_rect.height);
    gdk_pixbuf_copy_area(srcpixbuf, new_rect.x, new_rect.y, new_rect.width,
            new_rect.height, destPixbuf, 0, 0);
    return destPixbuf;
}

static void destroy(GtkWidget * widget, gpointer data)
{
    gtk_main_quit();
}

GdkPixmap *load_pixmap(GtkWidget *widget, gchar *filename)
{
    GdkPixbuf *pixbuf = NULL;
    GdkPixmap *pixmap = NULL;

    pixbuf = gdk_pixbuf_new_from_file(filename, NULL);
    if(!widget->window)
        printf("Null widget/n");
    pixmap = gdk_pixmap_new(widget->window, gdk_pixbuf_get_width(pixbuf)
            , gdk_pixbuf_get_height(pixbuf), -1);
    gdk_pixbuf_render_to_drawable(pixbuf, pixmap, widget->style->fg_gc[GTK_STATE_NORMAL]
            , 0, 0, 0, 0, gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf)
            , GDK_RGB_DITHER_NORMAL, 0, 0);
    g_object_unref(pixbuf);
    return pixmap;
}

static void hello(GtkWidget *widget, gpointer data)
{
    g_print("Hello World - was pressed/n");
    GtkWidget *window = (GtkWidget*)data;

    static int x = 0;
    if(x++ == 0)
    {
    GdkPixmap *bg = load_pixmap(window, "/home/cogent/bg");
    gdk_window_set_back_pixmap(window->window, bg, FALSE);
    gdk_window_clear(window->window);
    printf("set bg iamge/n");
    }


    HBITMAP hBitmap = CaptureControlBitmap(window->window);
   
    DWORD dwLen = 0;
    HBitmapToBuffer(hBitmap, NULL, &dwLen);
    char *pBuffer = (char*)malloc(dwLen);
    HBitmapToBuffer(hBitmap, pBuffer, &dwLen);

    HBITMAP hBitmapNew = LoadBitmapFromBuffer(pBuffer, dwLen);
    gdk_pixbuf_save((GdkPixbuf*)hBitmapNew, "/home/cogent/mycap_trans", "jpeg", NULL, "quality", "100", NULL);

    RECT rtNew;
    rtNew.left = 0;
    rtNew.top = 10;
    rtNew.right = 200;
    rtNew.bottom = 200;
    HBITMAP hClipedBmp = ClipBitmap(hBitmapNew, rtNew);
    gdk_pixbuf_save((GdkPixbuf*)hClipedBmp, "/home/cogent/mycap_cliped", "jpeg", NULL, "quality", "100", NULL);


    int w, h;
    WORD c;
    GetHBitmapInfo(hBitmapNew, &w, &h, &c);
    DeleteHBitmap(hBitmapNew);
    DeleteHBitmap(hBitmap);
}



int main(int argc, char** argv)
{
    gtk_init(&argc, &argv);

    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    assert(window != NULL);

    gtk_container_set_border_width(GTK_CONTAINER(window), 100);

    g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);

    gtk_window_move(GTK_WINDOW(window), 100, 0);
    gtk_window_resize(GTK_WINDOW(window), 500, 500);
    gtk_window_set_modal(GTK_WINDOW(window), false);

    GtkWidget *hBox = gtk_hbox_new(FALSE, 50);
    assert(hBox != NULL);
   
    gtk_container_add(GTK_CONTAINER(window), hBox);

    GtkWidget *button = gtk_button_new_with_label("Hello World");
    assert(button != NULL);
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(hello), window);
    gtk_box_pack_start(GTK_BOX(hBox), button, FALSE, TRUE, 0);



    gtk_widget_show_all(window);

    gtk_main();

    return (EXIT_SUCCESS);
}