static gboolean draw_simple_image(GtkStyle *style, GdkWindow *window, GdkRectangle *area, GtkWidget *widget, ThemeMatchData *match_data, gboolean draw_center, gboolean allow_setbg, gint x, gint y, gint width, gint height) { ThemeImage *image; gboolean setbg = FALSE; if ((width == -1) && (height == -1)) { gdk_window_get_size(window, &width, &height); if (allow_setbg) setbg = TRUE; } else if (width == -1) gdk_window_get_size(window, &width, NULL); else if (height == -1) gdk_window_get_size(window, NULL, &height); if (!(match_data->flags & THEME_MATCH_ORIENTATION)) { match_data->flags |= THEME_MATCH_ORIENTATION; if (height > width) match_data->orientation = GTK_ORIENTATION_VERTICAL; else match_data->orientation = GTK_ORIENTATION_HORIZONTAL; } image = match_theme_image (style, match_data); if (image) { if (image->background) { theme_pixbuf_render (image->background, window, NULL, area, draw_center ? COMPONENT_ALL : COMPONENT_ALL | COMPONENT_CENTER, FALSE, x, y, width, height); } if (image->overlay && draw_center) theme_pixbuf_render (image->overlay, window, NULL, area, COMPONENT_ALL, TRUE, x, y, width, height); return TRUE; } else return FALSE; }
static void _lib_geolocation_show_offset_window(GtkWidget *widget, dt_lib_module_t *self) { dt_lib_geolocation_t *d = self->data; gint x, y; gint px, py, center_w, center_h, window_w, window_h; GtkWidget *window = dt_ui_main_window(darktable.gui->ui); GtkWidget *center = dt_ui_center(darktable.gui->ui); gdk_window_get_origin(gtk_widget_get_window(center), &px, &py); gdk_window_get_size(gtk_widget_get_window(center),¢er_w,¢er_h); d->floating_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); GTK_WIDGET_SET_FLAGS(d->floating_window, GTK_CAN_FOCUS); gtk_window_set_decorated(GTK_WINDOW(d->floating_window), FALSE); gtk_window_set_has_frame(GTK_WINDOW(d->floating_window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(d->floating_window), GDK_WINDOW_TYPE_HINT_POPUP_MENU); gtk_window_set_transient_for(GTK_WINDOW(d->floating_window), GTK_WINDOW(window)); gtk_window_set_opacity(GTK_WINDOW(d->floating_window), 0.8); gtk_window_set_modal(GTK_WINDOW(d->floating_window), TRUE); GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1, 1); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 5, 5, 5); GtkWidget *vbox = gtk_vbox_new(TRUE, 5); gtk_container_add(GTK_CONTAINER(alignment), vbox); d->floating_window_entry = gtk_entry_new(); gtk_widget_add_events(d->floating_window_entry, GDK_FOCUS_CHANGE_MASK); g_signal_connect_swapped(d->floating_window, "focus-out-event", G_CALLBACK(gtk_widget_destroy), d->floating_window); g_object_set(G_OBJECT(d->floating_window_entry), "tooltip-text", _("enter the time shown on the selected picture\nformat: hh:mm:ss"), (char *)NULL); gtk_editable_select_region(GTK_EDITABLE(d->floating_window_entry), 0, -1); gtk_box_pack_start(GTK_BOX(vbox), d->floating_window_entry, TRUE, TRUE, 0); g_signal_connect(d->floating_window_entry, "key-press-event", G_CALLBACK(_lib_geolocation_floating_key_press), self); GtkWidget *hbox = gtk_hbox_new(TRUE, 5); GtkWidget *cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); GtkWidget *ok_button = gtk_button_new_from_stock(GTK_STOCK_OK); gtk_box_pack_start(GTK_BOX(hbox), cancel_button, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 0); g_signal_connect_swapped(G_OBJECT(cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), d->floating_window); g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(_lib_geolocation_calculate_offset_callback), self); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(d->floating_window), alignment); gtk_widget_show_all(d->floating_window); gtk_widget_grab_focus(d->floating_window_entry); gdk_window_get_size(gtk_widget_get_window(d->floating_window), &window_w, &window_h); x = px + 0.5*(center_w-window_w); y = py + center_h - 20 - window_h; gtk_window_move(GTK_WINDOW(d->floating_window), x, y); gtk_window_present(GTK_WINDOW(d->floating_window)); }
void ShowDialog(UIDialog* dialog, gchar* default_widget) { gint sw, sh; gint px, py; gint pw, ph; gint cw, ch; gint ox, oy; if( dialog->parent != NULL ) { sw = gdk_screen_width(); sh = gdk_screen_height(); gtk_widget_realize(dialog->window); gtk_window_set_transient_for(GTK_WINDOW(dialog->window), GTK_WINDOW(dialog->parent->window)); gdk_window_get_root_origin(dialog->parent->window->window, &px, &py); gdk_window_get_size(dialog->parent->window->window, &pw, &ph); gdk_window_get_size(dialog->window->window, &cw, &ch); ox = (pw - cw) / 2; if( ox < 20 ) ox = 20; oy = (ph - ch) / 2; if( oy < 20 ) oy = 20; if( px + ox + cw > sw ) ox = sw - cw - px - 20; if( py + oy + ch > sh ) oy = sh - ch - py - 20; if( dialog->pos_x == 0 ) dialog->pos_x = px + ox; if( dialog->pos_y == 0 ) dialog->pos_y = py + oy; } gtk_widget_set_uposition(dialog->window, dialog->pos_x, dialog->pos_y); if( default_widget ) { GtkWidget* widget = LookupWidget(dialog->window, default_widget); if( widget ) { gtk_widget_grab_focus(widget); gtk_widget_grab_default(widget); } } gtk_widget_show(dialog->window); gtk_main(); }
bool wxBitmap::CreateFromXpm( const char **bits ) { UnRef(); wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") ) GdkVisual *visual = wxTheApp->GetGdkVisual(); m_refData = new wxBitmapRefData(); GdkBitmap *mask = (GdkBitmap*) NULL; M_BMPDATA->m_pixmap = gdk_pixmap_create_from_xpm_d( wxGetRootWindow()->window, &mask, NULL, (gchar **) bits ); wxCHECK_MSG( M_BMPDATA->m_pixmap, FALSE, wxT("couldn't create pixmap") ); if (mask) { M_BMPDATA->m_mask = new wxMask(); M_BMPDATA->m_mask->m_bitmap = mask; } gdk_window_get_size( M_BMPDATA->m_pixmap, &(M_BMPDATA->m_width), &(M_BMPDATA->m_height) ); M_BMPDATA->m_bpp = visual->depth; // Can we get a different depth from create_from_xpm_d() ? return TRUE; }
void ui_signal_export (GtkMenuItem * item, gpointer data) { GtkWidget *dialog; GtkWidget *window = GET_OBJECT("window"); GtkFileFilter * filter_auto; GtkFileFilter * filter_pdf; GtkFileFilter * filter_svg; GtkFileFilter * filter_png; dialog = gtk_file_chooser_dialog_new (_("Export"), GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); /* Set filters */ filter_auto = gtk_file_filter_new(); filter_pdf = gtk_file_filter_new(); filter_svg = gtk_file_filter_new(); filter_png = gtk_file_filter_new(); gtk_file_filter_add_pattern (filter_auto, "*"); gtk_file_filter_add_mime_type (filter_pdf, "application/pdf"); gtk_file_filter_add_mime_type (filter_svg, "image/svg+xml"); gtk_file_filter_add_mime_type (filter_png, "image/png"); gtk_file_filter_set_name (filter_pdf, "Portable Document Format (PDF)"); gtk_file_filter_set_name (filter_svg, "Scalable Vector Graphcis (SVG)"); gtk_file_filter_set_name (filter_png, "Portable Networks Graphcis (PNG)"); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_png); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_pdf); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_svg); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *filename; char * ext; gint width, height; GtkFileFilter * filter; gboolean successp; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)); gdk_window_get_size (hexboard->window, &width, &height); if (filter == filter_pdf) ext = "pdf"; else if (filter == filter_png) ext = "png"; else if (filter == filter_svg) ext = "svg"; successp = hexboard_save_as_image (HEXBOARD(hexboard), filename, ext, width, height); if (!successp) g_message (_("An error ocurred while export the board.")); g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Board was exported to %s."), filename); g_free (filename); } gtk_widget_destroy (dialog); }
/** * windows resize funtion */ static gboolean resize_window (GtkWidget *widget, GdkEventMotion *mev) { int w,h; if(isFullSreen) gdk_window_get_size(widget->window,&w,&h); else { w = DEFAULT_WIDTH; h = DEFAULT_HEIGHT; } if(w!=window_w && h!=window_h){ window_w = w; window_h = h; surface = cairo_surface_create_similar ( surface, CAIRO_CONTENT_COLOR_ALPHA, w, h); gtk_widget_set_size_request(widget,w,h); CleanPaint(); } /* tell the canvas widget that it needs to redraw itself */ gtk_widget_queue_draw (widget); return FALSE; }
//do_draw will be executed in a separate thread whenever we would like to update //our animation void *do_draw(void * user_data){ //return false; currently_drawing = 1; GtkWidget * widget = (GtkWidget * ) user_data; int width, height; gdk_threads_enter(); //gdk_drawable_get_size(canvas, &width, &height); gdk_window_get_size(widget->window,&width,&height); //cairo_t * cr = gdk_cairo_create (widget->window); gdk_threads_leave(); //create a gtk-independant surface to draw on cairo_surface_t *cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); cairo_t *cr = cairo_create(cst); // all drawing here cairo_set_source_rgb (cr, 0.0,0.0,0.0); cairo_paint (cr); //do some time-consuming drawing static int i = 0; ++i; i = i % 300; //give a little movement to our animation int j,k; for(k=0; k<100; ++k){ //lets just redraw lots of times to use a lot of proc power for(j=0; j < 1000; ++j){ cairo_set_source_rgb (cr, (double)j/1000.0, (double)j/1000.0, 1.0 - (double)j/1000.0); cairo_move_to(cr, i,j/2); cairo_line_to(cr, i+100,j/2); cairo_stroke(cr); } } cairo_destroy(cr); //When dealing with gdkPixmap's, we need to make sure not to //access them from outside gtk_main(). gdk_threads_enter(); cairo_t *cr_pixmap = gdk_cairo_create(pixmap); cairo_set_source_surface (cr_pixmap, cst, 0, 0); cairo_paint(cr_pixmap); cairo_destroy(cr_pixmap); gdk_threads_leave(); // cairo_surface_destroy(cst); printf(":%d",i); if(dtime!=time(NULL)) { printf("%d %d\n",(int) time(NULL),d_fps); dtime = time(NULL) ; d_fps = 1; } else { d_fps++; } currently_drawing = 0; return NULL; }
void WinDraw_InitWindowSize(WORD width, WORD height) { static BOOL inited = FALSE; if (!inited) { GdkWindow *t, *root = window->window; while ((t = gdk_window_get_parent(root)) != 0) root = t; gdk_window_get_size(root, &root_width, &root_height); inited = TRUE; } gdk_window_get_position(window->window, &winx, &winy); winw = width; winh = height; if (root_width < winw) winx = (root_width - winw) / 2; else if (winx < 0) winx = 0; else if ((winx + winw) > root_width) winx = root_width - winw; if (root_height < winh) winy = (root_height - winh) / 2; else if (winy < 0) winy = 0; else if ((winy + winh) > root_height) winy = root_height - winh; }
void menu_calc_popup_position (GtkMenu *menu, gint *x_ret, gint *y_ret, gboolean *push_in, gpointer data) { GdkWindow *window = data; gint x = 0, y = 0, w = 0, h = 0, cursor_x = 0, cursor_y = 0; GdkModifierType mask; g_return_if_fail (x_ret && y_ret); g_return_if_fail (window); gdk_window_get_pointer (window, &cursor_x, &cursor_y, &mask); gdk_window_get_origin (window, &x, &y); gdk_window_get_size (window, &w, &h); if (cursor_x < 0 || cursor_x > w || cursor_y < 0 || cursor_y > h) { *x_ret = x + w / 2; *y_ret = y + h / 2; } else { *x_ret = x + cursor_x; *y_ret = y + cursor_y; } }
void create_server_pixmap (GtkWidget *window, struct pixmap *stype, int n, GdkPixmap **pix, GdkBitmap **mask) { GdkGC *white_gc; int hb, wb, hs, ws; if (!GTK_WIDGET_REALIZED (window)) gtk_widget_realize (window); gdk_window_get_size (buddy_pix[1].pix, &wb, &hb); gdk_window_get_size (stype->pix, &ws, &hs); *pix = gdk_pixmap_new (window->window, wb + ws, MAX (hs, hb), -1); *mask = gdk_pixmap_new (window->window, wb + ws, MAX (hs, hb), 1); white_gc = window->style->base_gc[GTK_STATE_NORMAL]; if (!masks_gc) { masks_gc = gdk_gc_new (*mask); gdk_gc_set_exposures (masks_gc, FALSE); } mask_pattern.pixel = 0; gdk_gc_set_foreground (masks_gc, &mask_pattern); gdk_draw_rectangle (*mask, masks_gc, TRUE, 0, 0, -1, -1); mask_pattern.pixel = 1; gdk_gc_set_foreground (masks_gc, &mask_pattern); if (n) { ensure_buddy_pix (window, n); gdk_gc_set_clip_origin (white_gc, 0, 0); gdk_gc_set_clip_mask (white_gc, buddy_pix[n].mask); gdk_draw_pixmap (*pix, white_gc, buddy_pix[n].pix, 0, 0, 0, 0, wb, hb); gdk_draw_pixmap (*mask, masks_gc, buddy_pix[n].mask, 0, 0, 0, 0, wb, hb); } gdk_gc_set_clip_origin (white_gc, wb, 0); gdk_gc_set_clip_mask (white_gc, stype->mask); gdk_draw_pixmap (*pix, white_gc, stype->pix, 0, 0, wb, 0, ws, hs); gdk_draw_pixmap (*mask, masks_gc, stype->mask, 0, 0, wb, 0, ws, hs); gdk_gc_set_clip_origin (white_gc, 0, 0); gdk_gc_set_clip_mask (white_gc, NULL); }
static GdkPixmap * scale_pixmap (GdkWindow *window, GdkPixmap *pixmap, gdouble scale_x, gdouble scale_y) { GdkGC *gc; GdkColormap *colormap; GdkColorContext *cc; GdkVisual *visual; GdkImage *image; GdkPixmap *new_pixmap; gint x, y, width, height, new_width, new_height; if(!pixmap) return NULL; if(!window) return NULL; gc = gdk_gc_new(pixmap); colormap = gdk_colormap_get_system (); visual = gdk_visual_get_system (); cc = gdk_color_context_new(visual, colormap); gdk_window_get_size(pixmap, &width, &height); if(scale_x == 1.0 && scale_y == 1.0){ new_pixmap = gdk_pixmap_new(window, width, height, -1); gdk_draw_pixmap(new_pixmap, gc, pixmap, 0, 0, 0, 0, width, height); return new_pixmap; } new_width = roundint(width * scale_x); new_height = roundint(height * scale_y); new_pixmap = gdk_pixmap_new(window, new_width, new_height, -1); image = gdk_image_get(pixmap, 0, 0, width, height); for(x = 0; x < new_width; x++){ for(y = 0; y < new_height; y++){ GdkColor color; gint px, py; px = MIN(roundint(x / scale_x), width - 1); py = MIN(roundint(y / scale_y), height - 1); color.pixel = gdk_image_get_pixel(image, px, py); gdk_color_context_query_color(cc, &color); gdk_gc_set_foreground(gc, &color); gdk_draw_point(new_pixmap, gc, x, y); } } gdk_image_destroy(image); gdk_color_context_free(cc); return new_pixmap; }
static void gimv_zalbum_update_max_cell_size (GimvZAlbum *album, GimvZAlbumCell *cell) { gint pix_width, pix_height, iwidth, iheight, cell_width, cell_height; gint string_area_width, str_width, str_height; g_return_if_fail (album); g_return_if_fail (cell); if (cell->ipix) { gdk_window_get_size (cell->ipix, &iwidth, &iheight); } else { iwidth = album->max_pix_width; iheight = album->max_pix_height; } album->max_pix_width = MAX(album->max_pix_width, iwidth); album->max_pix_height = MAX(album->max_pix_height, iheight); if (cell->name) { get_string_area_size (album, cell->name, &str_width, &str_height, NULL); /* str_width = gdk_string_width (font, cell->name); str_height = gdk_string_height (font, cell->name); */ } else { str_width = 0; str_height = 0; } switch (album->label_pos) { case GIMV_ZALBUM_CELL_LABEL_LEFT: case GIMV_ZALBUM_CELL_LABEL_RIGHT: { pix_width = album->max_pix_width; pix_height = album->max_pix_height; string_area_width = str_width + LABEL_HPADDING; break; } case GIMV_ZALBUM_CELL_LABEL_BOTTOM: case GIMV_ZALBUM_CELL_LABEL_TOP: default: pix_width = iwidth; pix_height = iheight; string_area_width = 0; break; } cell_width = pix_width + string_area_width; cell_height = MAX (pix_height, str_height); album->max_cell_width = MAX (MAX(album->max_cell_width, cell_width), album->max_pix_width); album->max_cell_height = MAX (MAX(album->max_cell_height, cell_height), album->max_pix_height); }
/* configure_event: * React to a configure event, perhaps changing the backing image size. */ void configure_event(GtkWidget *widget, GdkEvent *event, gpointer data) { if (darea) drawable = darea->window; gdk_window_get_size(drawable, &width, &height); if (!backing_image || backing_image->width != width || backing_image->height != height) make_backing_image(); update_window(); }
static void _preset_popup_posistion(GtkMenu *menu, gint *x,gint *y,gboolean *push_in, gpointer data) { gint w,h; gint ww,wh; GtkRequisition requisition; gdk_window_get_size(GTK_WIDGET(data)->window,&w,&h); gdk_window_get_size(dt_ui_main_window(darktable.gui->ui)->window,&ww,&wh); gdk_window_get_origin (GTK_WIDGET(data)->window, x, y); gtk_widget_size_request (GTK_WIDGET (menu), &requisition); /* align left panel popupmenu to right edge */ if (*x < ww/2) (*x)+=w-requisition.width; (*y)+=GTK_WIDGET(data)->allocation.height; }
int pixmap_width (GdkPixmap *pixmap) { int height, width; if (!pixmap) return 0; gdk_window_get_size (pixmap, &width, &height); return width; }
static void gtk_ui_popup_dialog(int index) { GtkWidget *popup; int tx, ty, tw, th; int px, py, pw, ph; popup = dialogs[index]; gdk_window_get_origin(toplevel->window, &tx, &ty); gdk_window_get_size(toplevel->window, &tw, &th); gdk_window_get_size(popup->window, &pw, &ph); px = tx + (tw - pw) / 2; py = ty + (th - ph) / 2; gtk_window_set_position(GTK_WINDOW(popup), GTK_WIN_POS_NONE); gtk_widget_set_uposition(popup, px, py); gtk_widget_show_all(popup); gtk_main(); }
static void save_options() { char filename[256]; FILE *fd; int i, numchans; int x,y,w,h; sprintf(filename, "%s/%s", getenv("HOME"), ".studio"); chk_dir(filename); sprintf(filename, "%s/%s/%s.tv-conf",getenv("HOME"),".studio", tv_config_file); fd = fopen(filename, "w"); if (!fd) { printf("WARNING: cannot open config file: %s\n", filename); return; } gdk_window_get_size(window->window, &w, &h); gdk_window_get_origin(window->window, &x, &y); fprintf(fd, "[StudioTV]\n"); fprintf(fd, "default_port = %d\n", port); fprintf(fd, "default_width = %d\n", w); fprintf(fd, "default_height = %d\n", h); fprintf(fd, "default_x = %d\n", x); fprintf(fd, "default_y = %d\n", y); fprintf(fd, "default_encoding_id = %d\n", encoding_id); #ifdef OSS fprintf(fd, "default_mixer_dev = %s\n", mixer_dev); fprintf(fd, "default_audio_src = %d\n", audio_src); #endif #ifdef HAVE_LIRC fprintf(fd, "default_lirc_dev = %s\n", lirc_dev); for(i=0;i<RC_NUM_KEYS;i++) fprintf(fd, "remote_control_key_%d = %s\n", i, remote_buttons[i]); #endif if (channels) { numchans = 0; for (i=0;channels[i];i++) { fprintf(fd, "channel_frequency_%d = %d\n", i, channels[i]->frequency); fprintf(fd, "channel_name_%d = %s\n", i, channels[i]->name); numchans = i; } fprintf(fd, "num_chans = %d\n", numchans+1); } fclose(fd); if (verbose) g_print("Configuration saved to %s\n", filename); }
/** \brief concatenate two pixmaps * * horizontal concatenation * @param window * @param dest destination pixmap * @param s1 first pixmap * @param s2 second pixmap * @returns dest for convenience */ struct pixmap* cat_pixmaps (GtkWidget *window, struct pixmap *dest, struct pixmap* s1, struct pixmap* s2) { GdkGC *white_gc; int h1, w1, h2, w2; if (!GTK_WIDGET_REALIZED (window)) gtk_widget_realize (window); gdk_window_get_size (s1->pix, &w1, &h1); gdk_window_get_size (s2->pix, &w2, &h2); dest->pix = gdk_pixmap_new (window->window, w1 + w2, MAX (h1, h2), -1); dest->mask = gdk_pixmap_new (window->window, w1 + w2, MAX (h1, h2), 1); white_gc = window->style->base_gc[GTK_STATE_NORMAL]; if (!masks_gc) { masks_gc = gdk_gc_new (dest->mask); gdk_gc_set_exposures (masks_gc, FALSE); } mask_pattern.pixel = 0; gdk_gc_set_foreground (masks_gc, &mask_pattern); gdk_draw_rectangle (dest->mask, masks_gc, TRUE, 0, 0, -1, -1); mask_pattern.pixel = 1; gdk_gc_set_foreground (masks_gc, &mask_pattern); gdk_gc_set_clip_origin (white_gc, 0, 0); gdk_gc_set_clip_mask (white_gc, s1->mask); gdk_draw_pixmap (dest->pix, white_gc, s1->pix, 0, 0, 0, 0, w1, h1); gdk_draw_pixmap (dest->mask, masks_gc, s1->mask, 0, 0, 0, 0, w1, h1); gdk_gc_set_clip_origin (white_gc, w1, 0); gdk_gc_set_clip_mask (white_gc, s2->mask); gdk_draw_pixmap (dest->pix, white_gc, s2->pix, 0, 0, w1, 0, w2, h2); gdk_draw_pixmap (dest->mask, masks_gc, s2->mask, 0, 0, w1, 0, w2, h2); gdk_gc_set_clip_origin (white_gc, 0, 0); gdk_gc_set_clip_mask (white_gc, NULL); return dest; }
int calculate_clist_row_height (GtkWidget *clist, GdkPixmap *pixmap) { int pix_h, pix_w; int height; gdk_window_get_size (pixmap, &pix_w, &pix_h); height=pix_h+1; return height; }
/* The following is based on a similar routine found in most * GTK2 engines, I have no idea which one came up with it first... */ gboolean sanitize_parameters(GtkStyle * style, GdkWindow * window, gint * width, gint * height) { if (!style) return FALSE; if (!window) return FALSE; if ((width) && (height)) { if ((*width == -1) && (*height == -1)) gdk_window_get_size(window, width, height); else if (*width == -1) gdk_window_get_size(window, width, NULL); else if (*height == -1) gdk_window_get_size(window, NULL, height); } return TRUE; }
void show_splash() { gint x, y; GdkWindow *root_win = NULL; gint root_x, root_y; GtkWidget *vbox; GtkWidget *label; GtkWidget *frame; #ifdef __WIN32__ root_x = GetSystemMetrics(SM_CXSCREEN); root_y = GetSystemMetrics(SM_CYSCREEN); #else root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ()); gdk_window_get_size(root_win, &root_x, &root_y); #endif x = (root_x - SPLASH_WIDTH) /2; y = (root_y - SPLASH_HEIGHT) /2; splash = gtk_window_new (GTK_WINDOW_POPUP); gtk_widget_set_size_request(splash, SPLASH_WIDTH, SPLASH_HEIGHT); gtk_window_move(GTK_WINDOW(splash), x, y); frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT); gtk_container_add (GTK_CONTAINER (splash), frame); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), vbox); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), "<span size=\"x-large\" foreground=\"#a04040\" weight=\"ultrabold\">Welcome to EBView</span>"); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(label), TRUE, TRUE, 0); label = gtk_label_new(_("Loading dictionary...")); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(label), TRUE, TRUE, 0); splash_label = gtk_label_new(""); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(splash_label), TRUE, TRUE, 0); gtk_widget_show_all(splash); loading_dictgroup = 1; tag_timeout = gtk_timeout_add(200, load_watch_thread, NULL); load_dictgroup_background(); gtk_main(); }
void ensure_buddy_pix (GtkWidget *window, int n) { int width, height; GdkGC *white_gc; int pri; int sec; if (!buddy_pix[1].pix) /* not initialized */ return; if (n < 0 || n > 9 || buddy_pix[n].pix) return; sec = ((n & 0x04) != 0)? 0x04 : 0x02; pri = n & ~sec; ensure_buddy_pix (window, pri); if (!pri || !sec) return; if (!GTK_WIDGET_REALIZED (window)) gtk_widget_realize (window); gdk_window_get_size (buddy_pix[1].pix, &width, &height); buddy_pix[n].pix = gdk_pixmap_new (window->window, width, height, -1); buddy_pix[n].mask = gdk_pixmap_new (window->window, width, height, 1); white_gc = window->style->white_gc; if (!masks_gc) { masks_gc = gdk_gc_new (buddy_pix[n].mask); gdk_gc_set_exposures (masks_gc, FALSE); } gdk_gc_set_foreground (masks_gc, &window->style->white); gdk_draw_pixmap (buddy_pix[n].pix, white_gc, buddy_pix[pri].pix, 0, 0, 0, 0, width, height); gdk_draw_pixmap (buddy_pix[n].mask, masks_gc, buddy_pix[pri].mask, 0, 0, 0, 0, width, height); gdk_gc_set_clip_mask (white_gc, buddy_pix[sec].mask); gdk_draw_pixmap (buddy_pix[n].pix, white_gc, buddy_pix[sec].pix, 0, 0, 0, 0, width, height); gdk_gc_set_clip_mask (white_gc, NULL); gdk_gc_set_clip_mask (masks_gc, buddy_pix[sec].mask); gdk_draw_rectangle (buddy_pix[n].mask, masks_gc, TRUE, 0, 0, width, height); gdk_gc_set_clip_mask (masks_gc, NULL); }
static void view_resize (View *view) { gint width, height; gdk_window_get_size (GTK_WIDGET(view->context)->window, &width, &height); gl_drawing_area_make_current (view->context); glViewport(0, 0, width, height); glMatrixMode (GL_PROJECTION); glLoadIdentity (); gluPerspective (45.0, (float)width / (float)height, 0.1, 2500.0); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); glDepthRange (0.1, 2000.0); }
void DrawPixmap(GdkWindow* window, GdkGC* gc, gint dstx, gint dsty, GdkPixmap* pixmap, GdkBitmap* mask) { gint map_w, map_h; gdk_window_get_size(pixmap, &map_w, &map_h); gdk_gc_set_clip_mask(gc, mask); gdk_gc_set_clip_origin(gc, dstx, dsty); gdk_draw_pixmap(window, gc, pixmap, 0,0, // srcx, srcy dstx, dsty, map_w, map_h); gdk_gc_set_clip_mask(gc, NULL); }
void wxDropSource::PrepareIcon( int action, GdkDragContext *context ) { // get the right icon to display wxIcon *icon = NULL; if ( action & GDK_ACTION_MOVE ) icon = &m_iconMove; else if ( action & GDK_ACTION_COPY ) icon = &m_iconCopy; else icon = &m_iconNone; GdkBitmap *mask; if ( icon->GetMask() ) mask = icon->GetMask()->GetBitmap(); else mask = NULL; GdkPixmap *pixmap = icon->GetPixmap(); gint width,height; gdk_window_get_size (pixmap, &width, &height); GdkColormap *colormap = gtk_widget_get_colormap( m_widget ); gtk_widget_push_visual (gdk_colormap_get_visual (colormap)); gtk_widget_push_colormap (colormap); m_iconWindow = gtk_window_new (GTK_WINDOW_POPUP); gtk_widget_set_events (m_iconWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); gtk_widget_set_app_paintable (GTK_WIDGET (m_iconWindow), TRUE); gtk_widget_pop_visual (); gtk_widget_pop_colormap (); gtk_widget_set_usize (m_iconWindow, width, height); gtk_widget_realize (m_iconWindow); gtk_signal_connect( GTK_OBJECT(m_iconWindow), "configure_event", GTK_SIGNAL_FUNC(gtk_dnd_window_configure_callback), (gpointer)this ); gdk_window_set_back_pixmap (m_iconWindow->window, pixmap, FALSE); if (mask) gtk_widget_shape_combine_mask (m_iconWindow, mask, 0, 0); gtk_drag_set_icon_widget( context, m_iconWindow, 0, 0 ); }
static gboolean list_motion_notify(GtkWidget *widget, GdkEventMotion *event, gpointer user_data) { gint mx,my; gint wx,wy,ww,wh; gdk_window_get_root_origin(widget->window,&wx,&wy); gdk_window_get_size(widget->window,&ww,&wh); mx = (gint) (event->x_root); my = (gint) (event->y_root); /*printf("mouse: <%d,%d>, window: <%d,%d>+<%d,%d>\n",mx,my,wx,wy,ww,wh);*/ if (mx < wx || mx > wx+ww || my < wy || my > wy+wh) gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "motion-notify-event"); return FALSE; }
static void gtk_ui_make_main_window(int size) { GdkWindowHints flags; GdkGeometry geom; gint winwidth, winheight; screensize = size; base = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(toplevel), base); menubar = CreateMenuBar(); gtk_box_pack_start(GTK_BOX(base), menubar, FALSE, FALSE, 0); field = CreateDrawingArea(size, size); gtk_box_pack_start(GTK_BOX(base), field, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(field), "button-press-event", GTK_SIGNAL_FUNC(button_press), NULL); gtk_signal_connect(GTK_OBJECT(field), "button-release-event", GTK_SIGNAL_FUNC(button_release), NULL); gtk_signal_connect(GTK_OBJECT(field), "enter-notify-event", GTK_SIGNAL_FUNC(enter_window), NULL); gtk_signal_connect(GTK_OBJECT(field), "leave-notify-event", GTK_SIGNAL_FUNC(leave_window), NULL); gtk_signal_connect(GTK_OBJECT(field), "expose-event", GTK_SIGNAL_FUNC(redraw_window), NULL); gtk_widget_set_events(field, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_EXPOSURE_MASK); gtk_widget_show_all(toplevel); gdk_window_get_size(toplevel->window, &winwidth, &winheight); geom.min_width = geom.max_width = geom.base_width = winwidth; geom.min_height = geom.max_height = geom.base_height = winheight; geom.width_inc = geom.height_inc = 0; flags = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE | GDK_HINT_RESIZE_INC; gdk_window_set_geometry_hints(toplevel->window, &geom, flags); gdk_color_parse("white", &white); gdk_color_parse("black", &black); }
void on_window1_size_request(GtkWidget * widget, GtkRequisition * requisition, gpointer user_data) { static gint old_h; gint w, h; if (widget->window == NULL) gtk_window_get_default_size(GTK_WINDOW(main_wnd), &w, &h); else gdk_window_get_size(widget->window, &w, &h); if (h == old_h) return; old_h = h; gtk_paned_set_position(GTK_PANED(vpaned), 2 * h / 3); }
static GdkPixmap * scale_pixmap (GdkWindow *window, GdkPixmap *pixmap, gdouble scale_x, gdouble scale_y) { GdkGC *gc = NULL; GdkPixmap *new_pixmap; gint width, height, new_width, new_height; GdkPixbuf *pixbuf = NULL; GdkPixbuf *aux_pixbuf = NULL; if(!pixmap) return NULL; if(!window) return NULL; gdk_window_get_size(pixmap, &width, &height); gc = gdk_gc_new(window); if(scale_x == 1.0 && scale_y == 1.0){ new_pixmap = gdk_pixmap_new(window, width, height, -1); gdk_draw_pixmap(new_pixmap, gc, pixmap, 0, 0, 0, 0, width, height); gdk_gc_unref(gc); return new_pixmap; } new_width = roundint(width * scale_x); new_height = roundint(height * scale_y); pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, gdk_drawable_get_colormap(window), 0, 0, 0, 0, width, height); aux_pixbuf = gdk_pixbuf_scale_simple(pixbuf, new_width, new_height, GDK_INTERP_BILINEAR); new_pixmap = gdk_pixmap_new(pixmap, new_width, new_height, -1); gdk_draw_pixbuf(new_pixmap, gc, aux_pixbuf, 0, 0, 0, 0, new_width, new_height, GDK_RGB_DITHER_MAX, 0, 0); gdk_pixbuf_unref(pixbuf); gdk_pixbuf_unref(aux_pixbuf); gdk_gc_unref(gc); return new_pixmap; }
void UpdateDialog(UIDialog* dialog, GdkRectangle* rect) { gint window_w, window_h; GdkRectangle window_rect; if( dialog->window->window != NULL ) { if( rect == NULL ) { gdk_window_get_size(dialog->window->window, &window_w, &window_h); window_rect.x = 0; window_rect.y = 0; window_rect.width = window_w; window_rect.height = window_h; rect = &window_rect; } gtk_widget_draw(dialog->window, rect); } }