/**
* Callback to initialize SPSVGSPViewWidget object.
*/
static void sp_svg_view_widget_init(SPSVGSPViewWidget *vw)
{
SPCanvasItem *parent;
/* Settings */
vw->resize = FALSE;
vw->maxwidth = 400.0;
vw->maxheight = 400.0;
/* ScrolledWindow */
vw->sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(vw->sw), GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (vw->sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (vw), vw->sw);
gtk_widget_show (vw->sw);
/* Canvas */
#if !GTK_CHECK_VERSION(3,0,0)
GdkColormap *cmap = gdk_colormap_get_system();
gtk_widget_push_colormap(cmap);
#endif
vw->canvas = SPCanvas::createAA();
#if GTK_CHECK_VERSION(3,0,0)
GtkCssProvider *css_provider = gtk_css_provider_new();
GtkStyleContext *style_context = gtk_widget_get_style_context(GTK_WIDGET(vw->canvas));
gtk_css_provider_load_from_data(css_provider,
"SPCanvas {\n"
" background-color: white;\n"
"}\n",
-1, NULL);
gtk_style_context_add_provider(style_context,
GTK_STYLE_PROVIDER(css_provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
#else
gtk_widget_pop_colormap ();
GtkStyle *style = gtk_style_copy (gtk_widget_get_style (vw->canvas));
style->bg[GTK_STATE_NORMAL] = style->white;
gtk_widget_set_style (vw->canvas, style);
#endif
#if GTK_CHECK_VERSION(3,0,0)
gtk_container_add (GTK_CONTAINER (vw->sw), vw->canvas);
#else
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (vw->sw), vw->canvas);
#endif
gtk_widget_show (vw->canvas);
/* View */
parent = sp_canvas_item_new(SP_CANVAS(vw->canvas)->getRoot(), SP_TYPE_CANVAS_GROUP, NULL);
Inkscape::UI::View::View *view = Inkscape::GC::release(new SPSVGView (SP_CANVAS_GROUP (parent)));
sp_view_widget_set_view (SP_VIEW_WIDGET (vw), view);
}
void iupgtkPushVisualAndColormap(void* visual, void* colormap)
{
GdkColormap* gdk_colormap;
GdkVisual *gdk_visual = gdkx_visual_get(XVisualIDFromVisual((Visual*)visual));
if (colormap)
gdk_colormap = gdk_x11_colormap_foreign_new(gdk_visual, (Colormap)colormap);
else
gdk_colormap = gdk_colormap_new(gdk_visual, FALSE);
gtk_widget_push_colormap(gdk_colormap);
/* gtk_widget_push_visual is now deprecated */
}
static void do_gtkdisplay(void)
{
GIOChannel *chan;
struct imgrect *ir;
/* have our main loop poll the pipe file descriptor */
chan = g_io_channel_unix_new(imgpipe_readfd);
g_io_add_watch(chan, G_IO_IN | G_IO_ERR | G_IO_HUP, (GIOFunc)pipe_event, NULL);
fcntl(imgpipe_readfd, F_SETFL, O_NONBLOCK);
/* set up list of image rectangles. */
imgrects = xcalloc(nimgrects = 16, sizeof *imgrects);
/* do some init thing */
gtk_init(0, NULL);
gtk_widget_push_colormap(gdk_rgb_get_colormap());
/* Make our own window. */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(window, DEFAULT_WIDTH + 2 * BORDER, DEFAULT_HEIGHT + 2 * BORDER);
darea = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window), darea);
gtk_widget_set_events(darea, GDK_EXPOSURE_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
g_signal_connect(G_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC(delete_event), NULL);
g_signal_connect(G_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(destroy), NULL);
g_signal_connect(G_OBJECT(darea), "expose-event", GTK_SIGNAL_FUNC(expose_event), NULL);
g_signal_connect(G_OBJECT(darea), "configure_event", GTK_SIGNAL_FUNC(expose_event), NULL);
/* mouse button press/release for saving images */
g_signal_connect(G_OBJECT(darea), "button_press_event", GTK_SIGNAL_FUNC(button_press_event), NULL);
g_signal_connect(G_OBJECT(darea), "button_release_event", GTK_SIGNAL_FUNC(button_release_event), NULL);
gtk_widget_show_all(window);
gtk_main();
/* Get rid of all remaining images. */
for (ir = imgrects; ir < imgrects + nimgrects; ++ir)
if (ir->filename)
unlink(ir->filename);
img_delete(backing_image);
gtk_exit(0);
return; /* NOTREACHED */
}
void iupgtkPushVisualAndColormap(void* visual, void* colormap)
{
#if GTK_CHECK_VERSION(3, 0, 0)
(void)visual;
(void)colormap;
#else
GdkColormap* gdk_colormap;
GdkVisual *gdk_visual = gdk_visual_get_best();
gdk_colormap = gdk_colormap_new(gdk_visual, FALSE);
gtk_widget_push_colormap(gdk_colormap);
/* gtk_widget_push_visual is now deprecated */
#endif
}
void pixmaps_init(void)
{
if(pixmap_cache) return;
gtk_widget_push_colormap(gdk_rgb_get_colormap());
pixmap_cache = g_fscache_new((GFSLoadFunc) image_from_file, NULL, NULL);
g_timeout_add(10000, purge, NULL);
/*
GtkIconFactory *factory;
int i;
factory = gtk_icon_factory_new();
for (i = 0; i < G_N_ELEMENTS(stocks); i++)
{
GdkPixbuf *pixbuf;
GError *error = NULL;
gchar *path;
GtkIconSet *iset;
const gchar *name = stocks[i];
path = g_strconcat(app_dir, "/images/", name, ".png", NULL);
pixbuf = gdk_pixbuf_new_from_file(path, &error);
if (!pixbuf)
{
g_warning("%s", error->message);
g_error_free(error);
pixbuf = gdk_pixbuf_new_from_xpm_data(bad_xpm);
}
g_free(path);
iset = gtk_icon_set_new_from_pixbuf(pixbuf);
g_object_unref(G_OBJECT(pixbuf));
gtk_icon_factory_add(factory, name, iset);
gtk_icon_set_unref(iset);
}
gtk_icon_factory_add_default(factory);
*/
mount_icon_size = gtk_icon_size_register("rox-mount-size", 14, 14);
load_default_pixmaps();
//option_register_widget("thumbs-purge-cache", thumbs_purge_cache);
}
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 TEG_STATUS canvas_create_map( void )
{
char *filename;
GnomeCanvasGroup* root;
GdkPixbuf *im;
GnomeCanvasItem *image;
gtk_widget_push_colormap (gdk_rgb_get_cmap ());
canvas_map = gnome_canvas_new ();
root = gnome_canvas_root(GNOME_CANVAS(canvas_map));
filename = theme_load_file( gui_theme.board );
im = gdk_pixbuf_new_from_file(filename, NULL);
if (im){
image = gnome_canvas_item_new (
root,
gnome_canvas_pixbuf_get_type (),
"pixbuf", im,
"x", 0.0,
"y", 0.0,
"width", (double) gdk_pixbuf_get_width(im),
"height", (double) gdk_pixbuf_get_height(im),
"anchor", GTK_ANCHOR_NW,
NULL);
canvas_create_countries(root);
armies_init(root);
dices_init(root);
gnome_canvas_set_scroll_region(GNOME_CANVAS(canvas_map),0,0,gdk_pixbuf_get_width(im),gdk_pixbuf_get_height(im));
gdk_pixbuf_unref(im);
} else {
g_warning (_("Could not find the %s file"),gui_theme.board);
return TEG_STATUS_ERROR;
}
gtk_widget_pop_colormap ();
gtk_widget_pop_visual ();
return TEG_STATUS_SUCCESS;
}
void iupgtkPushVisualAndColormap(void* visual, void* colormap)
{
#if GTK_CHECK_VERSION(3, 0, 0)
(void)visual;
(void)colormap;
#else
GdkColormap* gdk_colormap;
#if GTK_CHECK_VERSION(2, 24, 0)
GdkScreen* screen = gdk_screen_get_default();
GdkVisual* gdk_visual = gdk_x11_screen_lookup_visual(screen, XVisualIDFromVisual((Visual*)visual));
#else
GdkVisual* gdk_visual = gdkx_visual_get(XVisualIDFromVisual((Visual*)visual));
#endif
if (colormap)
gdk_colormap = gdk_x11_colormap_foreign_new(gdk_visual, (Colormap)colormap);
else
gdk_colormap = gdk_colormap_new(gdk_visual, FALSE);
gtk_widget_push_colormap(gdk_colormap);
/* gtk_widget_push_visual is now deprecated */
#endif
}
static void
create_same_board (char *fname)
{
gtk_widget_push_visual (gdk_imlib_get_visual ());
gtk_widget_push_colormap (gdk_imlib_get_colormap ());
draw_area = gtk_drawing_area_new ();
gtk_widget_pop_colormap ();
gtk_widget_pop_visual ();
gtk_widget_set_events (draw_area, gtk_widget_get_events (draw_area) | GAME_EVENTS);
gtk_box_pack_start_defaults (GTK_BOX(vb), draw_area);
gtk_widget_realize (draw_area);
gtk_widget_show (draw_area);
load_scenario (fname);
gtk_drawing_area_size (GTK_DRAWING_AREA (draw_area),
STONE_COLS * STONE_SIZE,
STONE_LINES * STONE_SIZE);
gtk_signal_connect (GTK_OBJECT(draw_area), "event", (GtkSignalFunc) area_event, 0);
}
bool wxGLCanvas::Create(wxWindow *parent,
const wxGLAttributes& dispAttrs,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name,
const wxPalette& palette)
{
m_noExpose = true;
m_nativeSizeEvent = true;
if ( !InitVisual(dispAttrs) )
return false;
GdkVisual *visual = gdkx_visual_get( GetXVisualInfo()->visualid );
GdkColormap *colormap = gdk_colormap_new( visual, TRUE );
gtk_widget_push_colormap( colormap );
gtk_widget_push_visual( visual );
wxWindow::Create( parent, id, pos, size, style, name );
m_glWidget = m_wxwindow;
gtk_pizza_set_clear( GTK_PIZZA(m_wxwindow), FALSE );
#if WXWIN_COMPATIBILITY_2_8
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
GTK_SIGNAL_FUNC(gtk_glwindow_realized_callback), (gpointer) this);
#endif // WXWIN_COMPATIBILITY_2_8
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "map",
GTK_SIGNAL_FUNC(gtk_glwindow_map_callback), (gpointer) this);
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
GTK_SIGNAL_FUNC(gtk_glwindow_expose_callback), (gpointer) this);
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
GTK_SIGNAL_FUNC(gtk_glwindow_draw_callback), (gpointer) this);
gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
GTK_SIGNAL_FUNC(gtk_glcanvas_size_callback), (gpointer) this);
gtk_widget_pop_visual();
gtk_widget_pop_colormap();
#if WXWIN_COMPATIBILITY_2_8
// if our parent window is already visible, we had been realized before we
// connected to the "realize" signal and hence our m_glContext hasn't been
// initialized yet and we have to do it now
if (GTK_WIDGET_REALIZED(m_wxwindow))
gtk_glwindow_realized_callback( m_wxwindow, this );
#endif // WXWIN_COMPATIBILITY_2_8
if (GTK_WIDGET_MAPPED(m_wxwindow))
gtk_glwindow_map_callback( m_wxwindow, this );
return true;
}
GtkWidget *
ghack_init_map_window()
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *table;
GtkWidget *frame;
GtkWidget *w;
GtkWidget *hSeparator;
GtkAdjustment *adj;
GnomeCanvasImage *bg;
double width, height, x, y;
int i;
width = COLNO * ghack_glyph_width();
height = ROWNO * ghack_glyph_height();
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
gtk_widget_show(vbox);
/* Add in a horiz seperator */
hSeparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), hSeparator, FALSE, FALSE, 2);
gtk_widget_show(hSeparator);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
/* Create the Zoom spinbutton.
*/
ghack_map.zoom = 1.0;
w = gtk_label_new("Zoom:");
gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, FALSE, 0);
gtk_widget_show(w);
adj =
GTK_ADJUSTMENT(gtk_adjustment_new(1.00, 0.5, 3.00, 0.05, 0.50, 0.50));
w = gtk_spin_button_new(adj, 0.5, 2);
gtk_widget_set_usize(w, 50, 0);
gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, FALSE, 0);
gtk_widget_show(w);
/* Canvas and scrollbars
*/
gtk_widget_push_visual(gdk_imlib_get_visual());
gtk_widget_push_colormap(gdk_imlib_get_colormap());
ghack_map.canvas = GNOME_CANVAS(gnome_canvas_new());
// gtk_widget_push_visual(gdk_rgb_get_visual());
// gtk_widget_push_colormap(gdk_rgb_get_cmap());
// ghack_map.canvas = GNOME_CANVAS (gnome_canvas_new_aa());
gtk_widget_pop_colormap();
gtk_widget_pop_visual();
gtk_widget_show(GTK_WIDGET(ghack_map.canvas));
table = gtk_table_new(2, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 4);
gtk_table_set_col_spacings(GTK_TABLE(table), 4);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
gtk_widget_show(table);
frame = gtk_frame_new(NULL);
ghack_map.frame = frame;
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL | GTK_SHRINK,
GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0);
gtk_widget_show(frame);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(ghack_map.canvas));
gnome_canvas_set_scroll_region(GNOME_CANVAS(ghack_map.canvas), 0, 0,
width + 2 * ghack_glyph_width(),
height + 2 * ghack_glyph_height());
gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(ghack_map.canvas), 1.0);
w = gtk_hscrollbar_new(GTK_LAYOUT(ghack_map.canvas)->hadjustment);
gtk_table_attach(GTK_TABLE(table), w, 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
gtk_widget_show(w);
w = gtk_vscrollbar_new(GTK_LAYOUT(ghack_map.canvas)->vadjustment);
gtk_table_attach(GTK_TABLE(table), w, 1, 2, 0, 1, GTK_FILL,
GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0);
gtk_widget_show(w);
myCanvasGroup = GNOME_CANVAS_GROUP(gnome_canvas_item_new(
gnome_canvas_root(GNOME_CANVAS(ghack_map.canvas)),
gnome_canvas_group_get_type(), "x", 0.0, "y", 0.0, NULL));
/* Tile the map background with a pretty image */
background = gdk_imlib_load_image((char *) "mapbg.xpm");
if (background == NULL) {
g_warning(
"Bummer! Failed to load the map background image (mapbg.xpm)!");
} else {
gdk_imlib_render(background, background->rgb_width,
background->rgb_height);
/* Tile the map background */
for (y = 0; y < height + background->rgb_height;
y += background->rgb_height) {
for (x = 0; x < width + background->rgb_width;
x += background->rgb_width) {
bg = GNOME_CANVAS_IMAGE(gnome_canvas_item_new(
myCanvasGroup, gnome_canvas_image_get_type(), "x",
(double) x, "y", (double) y, "width",
(double) background->rgb_width, "height",
(double) background->rgb_height, "image", background,
"anchor", (GtkAnchorType) GTK_ANCHOR_CENTER, NULL));
gnome_canvas_item_lower_to_bottom(GNOME_CANVAS_ITEM(bg));
}
}
}
/* ghack_map.map is an array of canvas images. Each cell of
* the array will contain one tile. Here, we create the
* space for the cells and then create the cells for easy
* access later.
*/
for (i = 0, y = 0; y < height; y += ghack_glyph_height()) {
for (x = 0; x < width; x += ghack_glyph_width()) {
ghack_map.map[i++] = GNOME_CANVAS_IMAGE(gnome_canvas_item_new(
myCanvasGroup, gnome_canvas_image_get_type(), "x", (double) x,
"y", (double) y, "width", (double) ghack_glyph_width(),
"height", (double) ghack_glyph_height(), "anchor",
GTK_ANCHOR_NORTH_WEST, NULL));
}
}
/* Set up the pet mark image */
petmark = gdk_imlib_create_image_from_xpm_data(pet_mark_xpm);
if (petmark == NULL) {
g_warning("Bummer! Failed to load the pet_mark image!");
} else {
gdk_imlib_render(petmark, petmark->rgb_width, petmark->rgb_height);
/* ghack_map.overlay is an array of canvas images used to
* overlay tile images...
*/
for (i = 0, y = 0; y < height; y += ghack_glyph_height()) {
for (x = 0; x < width; x += ghack_glyph_width()) {
ghack_map.overlay[i] =
GNOME_CANVAS_IMAGE(gnome_canvas_item_new(
myCanvasGroup, gnome_canvas_image_get_type(), "x",
(double) x, "y", (double) y, "width",
(double) petmark->rgb_width, "height",
(double) petmark->rgb_height, "image", petmark,
"anchor", GTK_ANCHOR_NORTH_WEST, NULL));
gnome_canvas_item_lower_to_bottom(
GNOME_CANVAS_ITEM(ghack_map.overlay[i++]));
}
}
}
/* Resize the canvas when the spinbutton changes
*/
gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
(GtkSignalFunc) ghack_map_window_zoom,
ghack_map.canvas);
/* Game signals
*/
gtk_signal_connect(GTK_OBJECT(vbox), "ghack_curs",
GTK_SIGNAL_FUNC(ghack_map_cursor_to), NULL);
gtk_signal_connect(GTK_OBJECT(vbox), "ghack_putstr",
GTK_SIGNAL_FUNC(ghack_map_putstr), NULL);
gtk_signal_connect(GTK_OBJECT(vbox), "ghack_print_glyph",
GTK_SIGNAL_FUNC(ghack_map_print_glyph), NULL);
gtk_signal_connect(GTK_OBJECT(vbox), "ghack_clear",
GTK_SIGNAL_FUNC(ghack_map_clear), NULL);
gtk_signal_connect(GTK_OBJECT(vbox), "ghack_display",
GTK_SIGNAL_FUNC(ghack_map_display), NULL);
gtk_signal_connect(GTK_OBJECT(vbox), "ghack_cliparound",
GTK_SIGNAL_FUNC(ghack_map_cliparound), NULL);
gtk_signal_connect(GTK_OBJECT(ghack_map.canvas), "button_press_event",
GTK_SIGNAL_FUNC(ghack_handle_button_press), NULL);
gtk_signal_connect(GTK_OBJECT(ghack_map.canvas), "gnome_delay_output",
GTK_SIGNAL_FUNC(ghack_delay), NULL);
return GTK_WIDGET(vbox);
}
bool wxGLCanvas::Create( wxWindow *parent,
const wxGLContext *shared,
const wxGLCanvas *shared_context_of,
wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name,
int *attribList,
const wxPalette& palette)
{
m_sharedContext = (wxGLContext*)shared; // const_cast
m_sharedContextOf = (wxGLCanvas*)shared_context_of; // const_cast
m_glContext = (wxGLContext*) NULL;
m_exposed = false;
m_noExpose = true;
m_nativeSizeEvent = true;
m_fbc = NULL;
m_vi = NULL;
// to be sure the glx version is known
wxGLCanvas::QueryGLXVersion();
if (wxGLCanvas::GetGLXVersion() >= 13)
{
// GLX >= 1.3 uses a GLXFBConfig
GLXFBConfig * fbc = NULL;
if (wxTheApp->m_glFBCInfo != NULL)
{
fbc = (GLXFBConfig *) wxTheApp->m_glFBCInfo;
m_canFreeFBC = false; // owned by wxTheApp - don't free upon destruction
}
else
{
fbc = (GLXFBConfig *) wxGLCanvas::ChooseGLFBC(attribList);
m_canFreeFBC = true;
}
m_fbc = fbc; // save for later use
wxCHECK_MSG( m_fbc, false, _T("required FBConfig couldn't be found") );
}
XVisualInfo *vi = NULL;
if (wxTheApp->m_glVisualInfo != NULL)
{
vi = (XVisualInfo *)wxTheApp->m_glVisualInfo;
m_canFreeVi = false; // owned by wxTheApp - don't free upon destruction
}
else
{
if (wxGLCanvas::GetGLXVersion() >= 13)
// GLX >= 1.3
vi = glXGetVisualFromFBConfig(GDK_DISPLAY(), m_fbc[0]);
else
// GLX <= 1.2
vi = (XVisualInfo *) ChooseGLVisual(attribList);
m_canFreeVi = true;
}
m_vi = vi; // save for later use
wxCHECK_MSG( m_vi, false, _T("required visual couldn't be found") );
GdkVisual *visual;
GdkColormap *colormap;
// MR: This needs a fix for lower gtk+ versions too. Might need to rethink logic (FIXME)
#if 0
if (!gtk_check_version(2,2,0))
{
wxWindow::Create( parent, id, pos, size, style, name );
m_glWidget = m_wxwindow;
GdkScreen *screen = gtk_widget_get_screen( m_glWidget );
colormap = gdk_screen_get_default_colormap(screen);
visual = gdk_colormap_get_visual(colormap);
if (GDK_VISUAL_XVISUAL(visual)->visualid != vi->visualid)
{
visual = gdk_x11_screen_lookup_visual( screen, vi->visualid );
colormap = gdk_colormap_new(visual, FALSE);
}
gtk_widget_set_colormap( m_glWidget, colormap );
}
else
#endif
{
visual = gdkx_visual_get( vi->visualid );
colormap = gdk_colormap_new( visual, TRUE );
gtk_widget_push_colormap( colormap );
gtk_widget_push_visual( visual );
wxWindow::Create( parent, id, pos, size, style, name );
m_glWidget = m_wxwindow;
}
gtk_pizza_set_clear( GTK_PIZZA(m_wxwindow), FALSE );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
GTK_SIGNAL_FUNC(gtk_glwindow_realized_callback), (gpointer) this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "map",
GTK_SIGNAL_FUNC(gtk_glwindow_map_callback), (gpointer) this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
GTK_SIGNAL_FUNC(gtk_glwindow_expose_callback), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
GTK_SIGNAL_FUNC(gtk_glwindow_draw_callback), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
GTK_SIGNAL_FUNC(gtk_glcanvas_size_callback), (gpointer)this );
gtk_widget_pop_visual();
gtk_widget_pop_colormap();
// if our parent window is already visible, we had been realized before we
// connected to the "realize" signal and hence our m_glContext hasn't been
// initialized yet and we have to do it now
if (GTK_WIDGET_REALIZED(m_wxwindow))
gtk_glwindow_realized_callback( m_wxwindow, this );
if (GTK_WIDGET_MAPPED(m_wxwindow))
gtk_glwindow_map_callback( m_wxwindow, this );
return true;
}
int gnoclCanvasCmd( ClientData data, Tcl_Interp *interp,
int objc, Tcl_Obj * const objv[] )
{
CanvasParams *para;
int ret;
if( gnoclParseOptions( interp, objc, objv, canvasOptions ) != TCL_OK )
{
gnoclClearOptions( canvasOptions );
return TCL_ERROR;
}
para = g_new( CanvasParams, 1 );
/* what is that for? Found in canvas demos. */
gtk_widget_push_colormap( gdk_rgb_get_cmap() );
/* antialiased is default */
if( canvasOptions[antialiasedIdx].status == GNOCL_STATUS_CHANGED &&
canvasOptions[antialiasedIdx].val.b == 0 )
{
para->canvas = GNOME_CANVAS( gnome_canvas_new( ) );
}
else
para->canvas = GNOME_CANVAS( gnome_canvas_new_aa( ) );
gtk_widget_show( GTK_WIDGET( para->canvas ) );
/*
TODO: what is that for? Found in canvas demos.
gtk_widget_pop_colormap();
*/
gnome_canvas_set_center_scroll_region( para->canvas, 0 );
ret = gnoclSetOptions( interp, canvasOptions,
G_OBJECT( para->canvas ), -1 );
if( ret == TCL_OK )
ret = configure( interp, para, canvasOptions );
gnoclClearOptions( canvasOptions );
if( ret != TCL_OK )
{
gtk_widget_destroy( GTK_WIDGET( para->canvas ) );
g_free( para );
return TCL_ERROR;
}
para->name = gnoclGetAutoWidgetId();
gnoclMemNameAndWidget( para->name, GTK_WIDGET( para->canvas ) );
/* TODO: g_hash_table_new_full */
para->tagToItems = g_hash_table_new_full( g_str_hash, g_str_equal,
g_free, ptrArrayFree );
para->interp = interp;
g_signal_connect_after( G_OBJECT( para->canvas ), "destroy",
G_CALLBACK( destroyFunc ), para );
Tcl_CreateObjCommand( interp, para->name, canvasFunc, para, NULL );
Tcl_SetObjResult( interp, Tcl_NewStringObj( para->name, -1 ) );
return TCL_OK;
}
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;
#ifndef __WXGTK3__
GdkBitmap *mask;
if ( icon->GetMask() )
mask = *icon->GetMask();
else
mask = NULL;
GdkPixmap *pixmap = icon->GetPixmap();
GdkColormap *colormap = gtk_widget_get_colormap( m_widget );
gtk_widget_push_colormap (colormap);
#endif
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 (m_iconWindow, TRUE);
#ifdef __WXGTK3__
gtk_widget_set_visual(m_iconWindow, gtk_widget_get_visual(m_widget));
#else
gtk_widget_pop_colormap ();
#endif
gtk_widget_set_size_request (m_iconWindow, icon->GetWidth(), icon->GetHeight());
gtk_widget_realize (m_iconWindow);
g_signal_connect (m_iconWindow, "configure_event",
G_CALLBACK (gtk_dnd_window_configure_callback), this);
#ifdef __WXGTK3__
cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(m_iconWindow));
icon->SetSourceSurface(cr, 0, 0);
cairo_pattern_t* pattern = cairo_get_source(cr);
gdk_window_set_background_pattern(gtk_widget_get_window(m_iconWindow), pattern);
cairo_destroy(cr);
cairo_surface_t* mask = NULL;
if (icon->GetMask())
mask = *icon->GetMask();
if (mask)
{
cairo_region_t* region = gdk_cairo_region_create_from_surface(mask);
gtk_widget_shape_combine_region(m_iconWindow, region);
cairo_region_destroy(region);
}
#else
gdk_window_set_back_pixmap(gtk_widget_get_window(m_iconWindow), pixmap, false);
if (mask)
gtk_widget_shape_combine_mask (m_iconWindow, mask, 0, 0);
#endif
gtk_drag_set_icon_widget( context, m_iconWindow, 0, 0 );
}
int main(int argc, char *argv[])
{
int has_rc=0;
GtkWidget *mainWin;
GtkWidget *table;
GtkWidget *menu_bar;
GtkWidget *index_page;
GtkWidget *button;
GtkWidget *label, *box, *sbox, *pbox;
GtkWidget *vseparator;
GtkWidget *post_process_button;
GtkStyle *style;
GtkWidget *gpixmap;
GdkPixmap *pixmap;
GdkBitmap *bitmap;
char title[256];
char *envhome;
#ifdef ENABLE_NLS
bindtextdomain (PACKAGE, PACKAGE_LOCALE_DIR);
textdomain (PACKAGE);
#endif
signal(SIGSEGV, crash);
#ifdef sun
__progname = argv[0];
#endif
Thumbnails.next = NULL;
Images.next=NULL;
/* Set the priority (taken from PhotoPC photopc.c) */
#ifdef linux
if (geteuid() == 0) {
struct sched_param sp;
int rc,minp,maxp;
minp=sched_get_priority_min(SCHED_FIFO);
maxp=sched_get_priority_max(SCHED_FIFO);
sp.sched_priority=minp+(maxp-minp)/2;
if ((rc=sched_setscheduler(0,SCHED_FIFO,&sp)) == -1)
fprintf(stderr,"failed to set priority\n");
}
#endif
filesel_cwd = (char *)malloc(sizeof(char)*1024);
getcwd(filesel_cwd, 1024);
strcat(filesel_cwd, "/");
/* Make sure there's a .gphoto directory in their home ---- */
envhome = getenv("HOME");
gphotoDir = (char *)malloc(sizeof(char)*(strlen(envhome)+9));
memset(gphotoDir, 0, sizeof(char)*(strlen(envhome)+9));
sprintf(gphotoDir, "%s/.gphoto", envhome);
(void)mkdir(gphotoDir, 0744);
/* Command line mode anyone? ----------------------------- */
if (argc > 1) {
command_line_mode = 1;
has_rc = load_config();
command_line(argc, argv);
} else
command_line_mode = 0;
/* Check for DISPLAY. If not set, exit */
if (!getenv("DISPLAY")) {
printf(N_("Error: $DISPLAY variable is not set\n"));
printf(N_("Please run \"gphoto -h\" for command-line options.\n"));
_exit(0);
}
fprintf(stdout,
N_("gPhoto %s (%s)\n"),
VERSION, __DATE__);
fprintf(stdout,
N_("Copyright (C) 1998-2000 Scott Fritzinger <*****@*****.**>\n\n"));
fprintf(stdout,
N_("Usage: gphoto [-h] [-c] [-n] [-s # filename] [-t # filename]\n"));
fprintf(stdout, N_(" [-d #] [-p filename] [-l filename]\n"));
gtk_init(&argc, &argv);
#if 1 /* by fujisawa */
gdk_imlib_init();
#endif
gtk_widget_push_visual(gdk_imlib_get_visual());
gtk_widget_push_colormap(gdk_imlib_get_colormap());
library_name = gtk_label_new("");
has_rc = load_config();
/* set up the main window -------------------------------- */
mainWin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_border_width(GTK_CONTAINER(mainWin), 0);
sprintf(title, "gPhoto %s", VERSION);
gtk_window_set_title(GTK_WINDOW(mainWin), title);
gtk_signal_connect(GTK_OBJECT(mainWin), "delete_event",
GTK_SIGNAL_FUNC(delete_event), NULL);
gtk_widget_set_usize(mainWin, 730, 480);
gtk_widget_realize(mainWin);
/* set up the menu --------------------------------------- */
menu_bar = gtk_vbox_new(FALSE, 0);
create_menu(menu_bar);
gtk_widget_show_all(menu_bar);
/* button bar -------------------------------------------- */
box = gtk_hbox_new(FALSE, 0);
create_toolbar(box, mainWin);
gtk_widget_show(box);
gtk_container_border_width(GTK_CONTAINER(box), 5);
/* accelerator keys--------------------------------------- */
gtk_accel_group_attach(mainag,GTK_OBJECT(mainWin));
/* Index Page notebook ----------------------------------- */
index_page = gtk_table_new(1,1,FALSE);
gtk_widget_show(index_page);
index_window = gtk_scrolled_window_new(NULL,NULL);
index_vp=gtk_viewport_new(NULL,NULL);
gtk_container_add(GTK_CONTAINER(index_window), index_vp);
gtk_widget_show(index_vp);
gtk_widget_show(index_window);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(index_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_table_attach_defaults(GTK_TABLE(index_page),index_window,0,1,0,1);
notebook = gtk_notebook_new();
gtk_widget_show(notebook);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
label = gtk_label_new(N_("Image Index"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), index_page,
label);
sbox = gtk_hbox_new(FALSE, 5);
gtk_widget_show(sbox);
status_bar = gtk_label_new("");
gtk_widget_show(status_bar);
gtk_label_set_justify(GTK_LABEL(status_bar), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(sbox), status_bar, FALSE, FALSE, 0);
update_status("Select \"Camera->Download Index->Thumbnails\" to begin.");
progress = gtk_progress_bar_new();
gtk_widget_show(progress);
gtk_box_pack_end(GTK_BOX(sbox), progress, FALSE, FALSE, 0);
vseparator = gtk_vseparator_new();
gtk_widget_show(vseparator);
gtk_box_pack_end(GTK_BOX(sbox), vseparator, FALSE, FALSE, 0);
post_process = 0;
post_process_button = gtk_button_new();
gtk_widget_show(post_process_button);
gtk_button_set_relief(GTK_BUTTON(post_process_button),GTK_RELIEF_NONE);
gtk_signal_connect (GTK_OBJECT(post_process_button), "clicked",
GTK_SIGNAL_FUNC(post_process_change), mainWin);
gtk_box_pack_end(GTK_BOX(sbox), post_process_button, FALSE, FALSE, 0);
pbox = gtk_hbox_new(FALSE, 3);
gtk_widget_show(pbox);
gtk_container_add(GTK_CONTAINER(post_process_button), pbox);
style = gtk_widget_get_style(mainWin);
pixmap = gdk_pixmap_create_from_xpm_d(mainWin->window, &bitmap,
&style->bg[GTK_STATE_NORMAL],(gchar **)post_processing_off_xpm);
post_process_pixmap = gtk_pixmap_new(pixmap, bitmap);
gtk_widget_show(post_process_pixmap);
gtk_box_pack_start(GTK_BOX(pbox),post_process_pixmap,FALSE,FALSE,0);
label = gtk_label_new("Post Process");
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(pbox),label,FALSE,FALSE,0);
vseparator = gtk_vseparator_new();
gtk_widget_show(vseparator);
gtk_box_pack_end(GTK_BOX(sbox), vseparator, FALSE, FALSE, 0);
gtk_widget_show(library_name);
/* gtk_widget_set_usize(library_name, 200, 16);*/
gtk_label_set_justify(GTK_LABEL(library_name), GTK_JUSTIFY_LEFT);
button = gtk_button_new();
gtk_widget_show(button);
gtk_button_set_relief(GTK_BUTTON(button),GTK_RELIEF_NONE);
gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(port_dialog), NULL);
gtk_container_add(GTK_CONTAINER(button), library_name);
gtk_box_pack_end(GTK_BOX(sbox), button, FALSE, FALSE, 0);
pixmap = gdk_pixmap_create_from_xpm_d(mainWin->window, &bitmap,
&style->bg[GTK_STATE_NORMAL],
(gchar **)splash_xpm);
gpixmap = gtk_pixmap_new(pixmap, bitmap);
gtk_widget_show(gpixmap);
/* Main window layout ------------------------------------ */
table =gtk_table_new(4,1,FALSE);
gtk_container_add(GTK_CONTAINER(mainWin), table);
gtk_widget_show(table);
gtk_table_attach(GTK_TABLE(table),menu_bar, 0, 1, 0, 1,
GTK_FILL|GTK_EXPAND, GTK_FILL, 0 , 0);
gtk_table_attach(GTK_TABLE(table), box, 0, 1, 1, 2,
GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table),notebook, 0, 1, 2, 3);
gtk_table_attach(GTK_TABLE(table),sbox, 0, 1, 3, 4,
GTK_FILL|GTK_EXPAND, GTK_FILL, 0 , 0);
index_table = gtk_hbox_new(FALSE, 0);
gtk_widget_show(index_table);
gtk_container_add( GTK_CONTAINER(index_vp), index_table);
gtk_box_pack_start(GTK_BOX(index_table), gpixmap, TRUE, FALSE, 0);
/* If not command-line mode... --------------------------- */
gtk_widget_show(mainWin);
if (!has_rc) {
/* put anything here to do on the first run */
developer_dialog_create();
error_dialog(
"Could not load config file.\n"
"Resetting to defaults.\n"
"Click on \"Select Port-Camera Model\n"
"in the Configure menu to set your\n"
"camera model and serial port\n");
}
gtk_main();
return 0;
}
static VALUE
rg_s_push_colormap(G_GNUC_UNUSED VALUE self, VALUE cmap)
{
gtk_widget_push_colormap(GDK_COLORMAP(RVAL2GOBJ(cmap)));
return cmap;
}
bool wxGLCanvas::Create( wxWindow *parent,
const wxGLContext *shared,
const wxGLCanvas *shared_context_of,
wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name,
int *attribList,
const wxPalette& palette)
{
m_sharedContext = (wxGLContext*)shared; // const_cast
m_sharedContextOf = (wxGLCanvas*)shared_context_of; // const_cast
m_glContext = (wxGLContext*) NULL;
m_exposed = FALSE;
m_noExpose = TRUE;
m_nativeSizeEvent = TRUE;
m_fbc = NULL;
m_vi = NULL;
// to be sure the glx version is known
wxGLCanvas::QueryGLXVersion();
if (wxGLCanvas::GetGLXVersion() >= 13)
{
// GLX >= 1.3 uses a GLXFBConfig
GLXFBConfig * fbc = NULL;
if (wxTheApp->m_glFBCInfo != NULL)
{
fbc = (GLXFBConfig *) wxTheApp->m_glFBCInfo;
m_canFreeFBC = FALSE; // owned by wxTheApp - don't free upon destruction
}
else
{
fbc = (GLXFBConfig *) wxGLCanvas::ChooseGLFBC(attribList);
m_canFreeFBC = TRUE;
}
m_fbc = fbc; // save for later use
wxCHECK_MSG( m_fbc, FALSE, _T("required FBConfig couldn't be found") );
}
XVisualInfo *vi = NULL;
if (wxTheApp->m_glVisualInfo != NULL)
{
vi = (XVisualInfo *)wxTheApp->m_glVisualInfo;
m_canFreeVi = FALSE; // owned by wxTheApp - don't free upon destruction
}
else
{
if (wxGLCanvas::GetGLXVersion() >= 13)
// GLX >= 1.3
vi = glXGetVisualFromFBConfig(GDK_DISPLAY(), m_fbc[0]);
else
// GLX <= 1.2
vi = (XVisualInfo *) ChooseGLVisual(attribList);
m_canFreeVi = TRUE;
}
m_vi = vi; // save for later use
wxCHECK_MSG( m_vi, FALSE, _T("required visual couldn't be found") );
GdkVisual *visual = gdkx_visual_get( vi->visualid );
GdkColormap *colormap = gdk_colormap_new( visual, TRUE );
gtk_widget_push_colormap( colormap );
gtk_widget_push_visual( visual );
wxWindow::Create( parent, id, pos, size, style, name );
m_glWidget = m_wxwindow;
#ifdef __WXGTK20__
gtk_widget_set_double_buffered( m_glWidget, FALSE );
#endif
gtk_pizza_set_clear( GTK_PIZZA(m_wxwindow), FALSE );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
GTK_SIGNAL_FUNC(gtk_glwindow_realized_callback), (gpointer) this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "map",
GTK_SIGNAL_FUNC(gtk_glwindow_map_callback), (gpointer) this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
GTK_SIGNAL_FUNC(gtk_glwindow_expose_callback), (gpointer)this );
#ifndef __WXGTK20__
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
GTK_SIGNAL_FUNC(gtk_glwindow_draw_callback), (gpointer)this );
#endif
gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
GTK_SIGNAL_FUNC(gtk_glcanvas_size_callback), (gpointer)this );
gtk_widget_pop_visual();
gtk_widget_pop_colormap();
// if our parent window is already visible, we had been realized before we
// connected to the "realize" signal and hence our m_glContext hasn't been
// initialized yet and we have to do it now
if (GTK_WIDGET_REALIZED(m_wxwindow))
gtk_glwindow_realized_callback( m_wxwindow, this );
if (GTK_WIDGET_MAPPED(m_wxwindow))
gtk_glwindow_map_callback( m_wxwindow, this );
return TRUE;
}
void
multi_cols_test (void)
{
GtkWidget *canvas, *window;
ETableModel *e_table_model;
ETableHeader *e_table_header, *e_table_header_multiple;
ETableCol *col_0, *col_1;
ECell *cell_left_just, *cell_image_toggle;
GnomeCanvasItem *item;
gtk_widget_push_colormap (gdk_rgb_get_cmap ());
e_table_model = e_table_simple_new (
col_count, row_count, value_at,
set_value_at, is_cell_editable,
duplicate_value, free_value,
initialize_value, value_is_empty,
value_to_string,
NULL);
/*
* Header
*/
e_table_header = e_table_header_new ();
cell_left_just = e_cell_text_new (e_table_model, NULL, GTK_JUSTIFY_LEFT);
{
GdkPixbuf **images = g_new (GdkPixbuf *, 3);
int i;
images [0] = gdk_pixbuf_new_from_file ("image1.png");
images [1] = gdk_pixbuf_new_from_file ("image2.png");
images [2] = gdk_pixbuf_new_from_file ("image3.png");
cell_image_toggle = e_cell_toggle_new (0, 3, images);
for (i = 0; i < 3; i++)
gdk_pixbuf_unref (images [i]);
g_free (images);
}
col_1 = e_table_col_new (1, "Item Name", 1.0, 20, cell_left_just, e_str_compare, TRUE);
e_table_header_add_column (e_table_header, col_1, 0);
col_0 = e_table_col_new (0, "A", 0.0, 48, cell_image_toggle, e_int_compare, TRUE);
e_table_header_add_column (e_table_header, col_0, 1);
/*
* Second test
*/
e_table_header_multiple = e_table_header_new ();
e_table_header_add_column (e_table_header_multiple, col_0, 0);
e_table_header_add_column (e_table_header_multiple, col_1, 1);
e_table_header_add_column (e_table_header_multiple, col_1, 2);
/*
* GUI
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
canvas = e_canvas_new ();
g_signal_connect (canvas, "size_allocate",
G_CALLBACK (set_canvas_size), NULL);
gtk_container_add (GTK_CONTAINER (window), canvas);
gtk_widget_show_all (window);
gnome_canvas_item_new (
gnome_canvas_root (GNOME_CANVAS (canvas)),
e_table_header_item_get_type (),
"ETableHeader", e_table_header,
NULL);
item = gnome_canvas_item_new (
gnome_canvas_root (GNOME_CANVAS (canvas)),
e_table_item_get_type (),
"ETableHeader", e_table_header,
"ETableModel", e_table_model,
"drawgrid", TRUE,
"drawfocus", TRUE,
"cursor_mode", E_TABLE_CURSOR_SIMPLE,
#if 0
"spreadsheet", TRUE,
#endif
NULL);
e_canvas_item_move_absolute (item, 0, 30);
gnome_canvas_item_new (
gnome_canvas_root (GNOME_CANVAS (canvas)),
e_table_header_item_get_type (),
"ETableHeader", e_table_header_multiple,
NULL);
item = gnome_canvas_item_new (
gnome_canvas_root (GNOME_CANVAS (canvas)),
e_table_item_get_type (),
"ETableHeader", e_table_header_multiple,
"ETableModel", e_table_model,
"drawgrid", TRUE,
"drawfocus", TRUE,
#if 0
"spreadsheet", TRUE,
#endif
"cursor_mode", E_TABLE_CURSOR_SIMPLE,
NULL);
e_canvas_item_move_absolute (item, 300, 30);
}
