//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);
}