static gboolean grab_cancelled_check (gpointer data) { ECanvas *canvas = data; if (GNOME_CANVAS (canvas)->grabbed_item == NULL) { canvas->grab_cancelled_cb = NULL; canvas->grab_cancelled_check_id = 0; canvas->grab_cancelled_time = 0; canvas->grab_cancelled_data = NULL; return FALSE; } if (gtk_grab_get_current ()) { gnome_canvas_item_ungrab(GNOME_CANVAS (canvas)->grabbed_item, canvas->grab_cancelled_time); if (canvas->grab_cancelled_cb) { canvas->grab_cancelled_cb (canvas, GNOME_CANVAS (canvas)->grabbed_item, canvas->grab_cancelled_data); } canvas->grab_cancelled_cb = NULL; canvas->grab_cancelled_check_id = 0; canvas->grab_cancelled_time = 0; canvas->grab_cancelled_data = NULL; return FALSE; } return TRUE; }
void diagwin_t::populate() { GnomeCanvasGroup *root = gnome_canvas_root(GNOME_CANVAS(canvas_)); _log.debug("diagwin_t::populate\n"); while (root->item_list != 0) { gtk_object_destroy(GTK_OBJECT(root->item_list->data)); } set_diagram_colors(diagram_); diagram_->prepare(); scenegen_t *sg = new canvas_scenegen_t(GNOME_CANVAS(canvas_)); diagram_->render(sg); delete sg; /* setup the canvas to show the whole diagram */ dbounds_t bounds; diagram_->get_bounds(&bounds); gnome_canvas_set_scroll_region(GNOME_CANVAS(canvas_), bounds.x1, bounds.y1, bounds.x2, bounds.y2); if (!GTK_WIDGET_REALIZED(canvas_)) gtk_signal_connect(GTK_OBJECT(canvas_), "realize", GTK_SIGNAL_FUNC(diagwin_realize_cb), 0); else zoom_all(); }
static GtkWidget * zenity_create_monk (void) { GtkWidget *canvas_board; GnomeCanvasItem *canvas_item; GdkPixbuf *pixbuf; GdkColor color = { 0, 0xffff, 0xffff, 0xffff }; canvas_board = gnome_canvas_new (); gnome_canvas_set_scroll_region (GNOME_CANVAS (canvas_board), 0, 0, ZENITY_CANVAS_X, ZENITY_CANVAS_Y); gtk_widget_set_size_request (canvas_board, ZENITY_CANVAS_X, ZENITY_CANVAS_Y); gdk_colormap_alloc_color (gtk_widget_get_colormap (GTK_WIDGET (canvas_board)), &color, FALSE, TRUE); gtk_widget_modify_bg (GTK_WIDGET (canvas_board), GTK_STATE_NORMAL, &color); pixbuf = gdk_pixbuf_new_from_file (ZENITY_CLOTHES_PATH "monk.png", NULL); canvas_item = gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (canvas_board)->root), GNOME_TYPE_CANVAS_PIXBUF, "x", (ZENITY_CANVAS_X / 2.0)/2.0 + 10.0, "y", (ZENITY_CANVAS_Y / 2.0)/2.0 - 50.0, "pixbuf", pixbuf, "anchor", GTK_ANCHOR_NW, NULL); zenity_create_clothes (canvas_board); return canvas_board; }
void ghack_map_cursor_to(GtkWidget *win, int x, int y, gpointer data) { GnomeCanvasGroup *group; static GnomeCanvasRE *cursor = NULL; double x1, y1, x2, y2; float hp; guint r, g, b; x1 = x * ghack_glyph_width() - 1; y1 = y * ghack_glyph_height() - 1; x2 = x1 + ghack_glyph_width() + 2; y2 = y1 + ghack_glyph_height() + 2; hp = u.mtimedone ? (u.mhmax ? (float) u.mh / u.mhmax : 1) : (u.uhpmax ? (float) u.uhp / u.uhpmax : 1); r = 255; g = (hp >= 0.75) ? 255 : (hp >= 0.25 ? 255 * 2 * (hp - 0.25) : 0); b = (hp >= 0.75) ? 255 * 4 * (hp - 0.75) : (hp >= 0.25 ? 0 : 255 * 4 * (0.25 - hp)); group = gnome_canvas_root(GNOME_CANVAS(ghack_map.canvas)); if (!cursor) { cursor = GNOME_CANVAS_RE(gnome_canvas_item_new( group, gnome_canvas_rect_get_type(), "width_units", 1.0, NULL)); } gnome_canvas_item_set(GNOME_CANVAS_ITEM(cursor), "outline_color_rgba", GNOME_CANVAS_COLOR(r, g, b), "x1", x1, "y1", y1, "x2", x2, "y2", y2, NULL); gnome_canvas_item_raise_to_top(GNOME_CANVAS_ITEM(cursor)); gnome_canvas_item_show(GNOME_CANVAS_ITEM(cursor)); }
void ghack_map_print_glyph(GtkObject *win, guint x, guint y, GdkImlibImage *im, gpointer data) { GnomeCanvasGroup *group; int i = y * COLNO + x; int glyph = glyph_at(x, y); GnomeCanvasImage *canvas_image = GNOME_CANVAS_IMAGE(ghack_map.map[i]); group = gnome_canvas_root(GNOME_CANVAS(ghack_map.canvas)); gnome_canvas_item_set(GNOME_CANVAS_ITEM(canvas_image), "image", im, NULL); gnome_canvas_item_show(GNOME_CANVAS_ITEM(canvas_image)); canvas_image = GNOME_CANVAS_IMAGE(ghack_map.overlay[i]); if (x == u.ux && y == u.uy) ghack_map_cliparound(NULL, x, y, NULL); if (glyph_is_pet(glyph) #ifdef TEXTCOLOR && iflags.hilite_pet #endif ) { gnome_canvas_item_raise_to_top(GNOME_CANVAS_ITEM(canvas_image)); gnome_canvas_item_show(GNOME_CANVAS_ITEM(canvas_image)); } else { gnome_canvas_item_hide(GNOME_CANVAS_ITEM(canvas_image)); } }
static gint canvas_focus_out_event (GtkWidget *widget, GdkEventFocus *event) { GnomeCanvas *canvas; ECanvas *ecanvas; GdkEvent full_event = { 0 }; canvas = GNOME_CANVAS (widget); ecanvas = E_CANVAS (widget); /* XXX Can't access flags directly anymore, but is it really needed? * If so, could we call gtk_widget_send_focus_change() instead? */ #if 0 GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS); #endif gtk_im_context_focus_out (ecanvas->im_context); if (canvas->focused_item) { full_event.type = event->type; full_event.focus_change = *event; return canvas_emit_event (canvas, &full_event); } else { return FALSE; } }
GtkWidget * gnc_header_new (GnucashSheet *sheet) { GnomeCanvasGroup *group; GnomeCanvasItem *item; GtkWidget *canvas; canvas = gnome_canvas_new (); g_signal_connect (G_OBJECT (canvas), "realize", G_CALLBACK (gnc_header_realized), NULL); group = GNOME_CANVAS_GROUP (GNOME_CANVAS (canvas)->root); item = gnome_canvas_item_new (group, gnc_header_get_type (), "sheet", sheet, "cursor_name", CURSOR_HEADER, NULL); sheet->header_item = item; gtk_widget_show (canvas); return canvas; }
static void canvas_style_set (GtkWidget *widget, GtkStyle *previous_style) { canvas_style_set_recursive ( GNOME_CANVAS_ITEM (gnome_canvas_root ( GNOME_CANVAS (widget))), previous_style); }
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; }
/* Goes through all known links and checks whether there already exists * a corresponding canvas_link. If not, create it.*/ static gint check_new_link (link_id_t * link_id, link_t * link, GtkWidget * canvas) { canvas_link_t *new_canvas_link; GnomeCanvasGroup *group; GnomeCanvasPoints *points; guint i = 0; if (!g_tree_lookup (canvas_links, link_id)) { group = gnome_canvas_root (GNOME_CANVAS (canvas)); new_canvas_link = g_malloc (sizeof (canvas_link_t)); g_assert(new_canvas_link); new_canvas_link->canvas_link_id = *link_id; /* We set the lines position using groups positions */ points = gnome_canvas_points_new (3); for (; i <= 5; i++) points->coords[i] = 0.0; new_canvas_link->src_item = gnome_canvas_item_new (group, gnome_canvas_polygon_get_type (), "points", points, "fill_color", "tan", NULL); addref_canvas_obj(G_OBJECT (new_canvas_link->src_item)); new_canvas_link->dst_item = gnome_canvas_item_new (group, gnome_canvas_polygon_get_type (), "points", points, "fill_color", "tan", NULL); addref_canvas_obj(G_OBJECT (new_canvas_link->dst_item)); g_tree_insert (canvas_links, &new_canvas_link->canvas_link_id, new_canvas_link); gnome_canvas_item_lower_to_bottom (new_canvas_link->src_item); gnome_canvas_item_lower_to_bottom (new_canvas_link->dst_item); gnome_canvas_points_unref (points); g_signal_connect (G_OBJECT (new_canvas_link->src_item), "event", (GtkSignalFunc) link_item_event, new_canvas_link); g_signal_connect (G_OBJECT (new_canvas_link->dst_item), "event", (GtkSignalFunc) link_item_event, new_canvas_link); } return FALSE; } /* check_new_link */
void ghack_map_clear(GtkWidget *win, gpointer data) { int i; for (i = 0; i < ROWNO * COLNO; i++) { if (GNOME_IS_CANVAS_IMAGE(ghack_map.map[i])) { gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ghack_map.map[i])); } if (GNOME_IS_CANVAS_IMAGE(ghack_map.overlay[i])) { gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ghack_map.overlay[i])); } } gnome_canvas_update_now(GNOME_CANVAS(ghack_map.canvas)); }
void diagwin_t::zoom_all() { double zoomx, zoomy; dbounds_t bounds; diagram_->get_bounds(&bounds); zoomx = canvas_->allocation.width / bounds.width(); zoomy = canvas_->allocation.height / bounds.height(); zoom_ = MIN(zoomx, zoomy); _log.debug("diagwin_t::zoom_all: zoomx=%g zoomy=%g zoom=%g\n", zoomx, zoomy, zoom_); gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas_), zoom_); }
/* Key event handler for the canvas */ static gint e_canvas_key (GtkWidget *widget, GdkEventKey *event) { GnomeCanvas *canvas; GdkEvent full_event; g_return_val_if_fail (widget != NULL, FALSE); g_return_val_if_fail (GNOME_IS_CANVAS (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); canvas = GNOME_CANVAS (widget); full_event.key = *event; return emit_event (canvas, &full_event); }
static gint canvas_key_event (GtkWidget *widget, GdkEventKey *event) { GnomeCanvas *canvas; GdkEvent full_event = { 0 }; g_return_val_if_fail (GNOME_IS_CANVAS (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); canvas = GNOME_CANVAS (widget); full_event.type = event->type; full_event.key = *event; return canvas_emit_event (canvas, &full_event); }
void gnc_header_reconfigure (GncHeader *header) { GnomeCanvas *canvas; GtkWidget *widget; GnucashSheet *sheet; SheetBlockStyle *old_style; int w, h; g_return_if_fail (header != NULL); g_return_if_fail (GNC_IS_HEADER (header)); canvas = GNOME_CANVAS_ITEM(header)->canvas; widget = GTK_WIDGET (header->sheet); sheet = GNUCASH_SHEET(header->sheet); old_style = header->style; header->style = gnucash_sheet_get_style_from_cursor (sheet, header->cursor_name); if (header->style == NULL) return; sheet->width = header->style->dimensions->width; w = header->style->dimensions->width; h = header->style->dimensions->height; h *= header->num_phys_rows; h /= header->style->nrows; h += 2; if (header->height != h || header->width != w || header->style != old_style) { header->height = h; header->width = w; gnome_canvas_set_scroll_region (GNOME_CANVAS(canvas), 0, 0, w, h); gtk_widget_set_size_request (GTK_WIDGET(canvas), -1, h); gnc_header_request_redraw (header); } }
diagwin_t::diagwin_t(diagram_t *di) { GladeXML *xml; zoom_ = 1.0; diagram_ = di; /* load the interface & connect signals */ xml = ui_load_tree("diag"); set_window(glade_xml_get_widget(xml, "diag")); set_title(diagram_->title()); canvas_ = glade_xml_get_widget(xml, "diag_canvas"); gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas_), zoom_); ui_register_windows_menu(ui_get_dummy_menu(xml, "diag_windows_dummy")); }
/* Focus out handler for the canvas */ static gint e_canvas_focus_out (GtkWidget *widget, GdkEventFocus *event) { GnomeCanvas *canvas; ECanvas *ecanvas; GdkEvent full_event; canvas = GNOME_CANVAS (widget); ecanvas = E_CANVAS (widget); GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS); gtk_im_context_focus_out (ecanvas->im_context); if (canvas->focused_item) { full_event.focus_change = *event; return emit_event (canvas, &full_event); } else { return FALSE; } }
void ghack_handle_button_press(GtkWidget *widget, GdkEventButton *event, gpointer data) { GHClick *click; double x1, y1; if (event->type != GDK_BUTTON_PRESS) return; gnome_canvas_window_to_world(GNOME_CANVAS(widget), event->x, event->y, &x1, &y1); /* g_message("I got a click at %f,%f with button %d \n", x1, y1, event->button); */ /* We allocate storage here, so we need to remember if (g_numClicks>0) * to blow this away when closing the app using something like * while (g_clickBuffer) * { * g_free((GHClick)g_clickBuffer->data); * g_clickBuffer = g_clickBuffer->next; * } * g_list_free( g_clickBuffer ); * */ click = g_new(GHClick, 1); click->x = (int) x1 / ghack_glyph_width(); click->y = (int) y1 / ghack_glyph_height(); click->mod = (event->button == 1) ? CLICK_1 : CLICK_2; g_clickBuffer = g_list_prepend(g_clickBuffer, click); /* Could use g_list_length(), but it is stupid and just * traverses the list while counting, so we'll just do * the counting ourselves in advance. */ g_numClicks++; }
static void zenity_create_clothes (GtkWidget *canvas_board) { GdkPixbuf *pixbuf; GnomeCanvasItem *canvas_item; gchar *pixbuf_path; size_t i; for (i = 0; i < G_N_ELEMENTS (monk_clothes); i++) { pixbuf_path = g_strconcat (ZENITY_CLOTHES_PATH, monk_clothes[i].filename, NULL); pixbuf = gdk_pixbuf_new_from_file (pixbuf_path, NULL); canvas_item = gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (canvas_board)->root), GNOME_TYPE_CANVAS_PIXBUF, "x", monk_clothes[i].x, "y", monk_clothes[i].y, "pixbuf", pixbuf, "anchor", GTK_ANCHOR_NW, NULL); g_signal_connect (G_OBJECT (canvas_item), "event", G_CALLBACK (zenity_move_clothes_event), NULL); } }
GtkWidget * ui_common_create_view_axis_indicator(AmitkLayout layout) { GtkWidget * axis_indicator; AmitkView i_view; #ifdef AMIDE_LIBGNOMECANVAS_AA axis_indicator = gnome_canvas_new_aa(); #else axis_indicator = gnome_canvas_new(); #endif switch(layout) { case AMITK_LAYOUT_ORTHOGONAL: gtk_widget_set_size_request(axis_indicator, 2.0*AXIS_WIDTH, 2.0*ORTHOGONAL_AXIS_HEIGHT); gnome_canvas_set_scroll_region(GNOME_CANVAS(axis_indicator), 0.0, 0.0, 2.0*AXIS_WIDTH, 2.0*ORTHOGONAL_AXIS_HEIGHT); ui_common_draw_view_axis(GNOME_CANVAS(axis_indicator), 0, 0, AMITK_VIEW_TRANSVERSE, layout, AXIS_WIDTH, ORTHOGONAL_AXIS_HEIGHT); ui_common_draw_view_axis(GNOME_CANVAS(axis_indicator), 1, 0, AMITK_VIEW_CORONAL, layout, AXIS_WIDTH, ORTHOGONAL_AXIS_HEIGHT); ui_common_draw_view_axis(GNOME_CANVAS(axis_indicator), 0, 1, AMITK_VIEW_SAGITTAL, layout, AXIS_WIDTH, ORTHOGONAL_AXIS_HEIGHT); break; case AMITK_LAYOUT_LINEAR: default: gtk_widget_set_size_request(axis_indicator, 3.0*AXIS_WIDTH, LINEAR_AXIS_HEIGHT); gnome_canvas_set_scroll_region(GNOME_CANVAS(axis_indicator), 0.0, 0.0, 3.0*AXIS_WIDTH, LINEAR_AXIS_HEIGHT); for (i_view=0;i_view< AMITK_VIEW_NUM;i_view++) ui_common_draw_view_axis(GNOME_CANVAS(axis_indicator), 0, i_view, i_view, layout, AXIS_WIDTH, LINEAR_AXIS_HEIGHT); break; } return GTK_WIDGET(axis_indicator); }
void diagwin_t::zoom_to(double factor) { zoom_ = factor; gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas_), zoom_); }
void ui_common_study_preferences_widgets(GtkWidget * packing_table, gint table_row, GtkWidget ** proi_width_spin, GnomeCanvasItem ** proi_item, #ifdef AMIDE_LIBGNOMECANVAS_AA GtkWidget ** proi_transparency_spin, #else GtkWidget ** pline_style_menu, GtkWidget ** pfill_roi_button, #endif GtkWidget ** playout_button1, GtkWidget ** playout_button2, GtkWidget ** ppanel_layout_button1, GtkWidget ** ppanel_layout_button2, GtkWidget ** ppanel_layout_button3, GtkWidget ** pmaintain_size_button, GtkWidget ** ptarget_size_spin) { GtkWidget * label; GtkObject * adjustment; GtkWidget * roi_canvas; GnomeCanvasPoints * roi_line_points; GtkWidget * image; GtkWidget * hseparator; #ifndef AMIDE_LIBGNOMECANVAS_AA GdkLineStyle i_line_style; #endif /* widgets to change the roi's size */ label = gtk_label_new(_("ROI Width (pixels)")); gtk_table_attach(GTK_TABLE(packing_table), label, 0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); gtk_widget_show(label); adjustment = gtk_adjustment_new(AMITK_PREFERENCES_MIN_ROI_WIDTH, AMITK_PREFERENCES_MIN_ROI_WIDTH, AMITK_PREFERENCES_MAX_ROI_WIDTH,1.0, 1.0, 0.0); *proi_width_spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1.0, 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(*proi_width_spin),FALSE); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(*proi_width_spin), TRUE); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*proi_width_spin), TRUE); gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(*proi_width_spin), GTK_UPDATE_ALWAYS); gtk_table_attach(GTK_TABLE(packing_table), *proi_width_spin, 1,2, table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING); gtk_widget_show(*proi_width_spin); /* a little canvas indicator thingie to show the user who the new preferences will look */ #ifdef AMIDE_LIBGNOMECANVAS_AA roi_canvas = gnome_canvas_new_aa(); #else roi_canvas = gnome_canvas_new(); #endif gtk_widget_set_size_request(roi_canvas, 100, 100); gnome_canvas_set_scroll_region(GNOME_CANVAS(roi_canvas), 0.0, 0.0, 100.0, 100.0); gtk_table_attach(GTK_TABLE(packing_table), roi_canvas, 2,3,table_row,table_row+2, GTK_FILL, 0, X_PADDING, Y_PADDING); gtk_widget_show(roi_canvas); /* the box */ roi_line_points = gnome_canvas_points_new(5); roi_line_points->coords[0] = 25.0; /* x1 */ roi_line_points->coords[1] = 25.0; /* y1 */ roi_line_points->coords[2] = 75.0; /* x2 */ roi_line_points->coords[3] = 25.0; /* y2 */ roi_line_points->coords[4] = 75.0; /* x3 */ roi_line_points->coords[5] = 75.0; /* y3 */ roi_line_points->coords[6] = 25.0; /* x4 */ roi_line_points->coords[7] = 75.0; /* y4 */ roi_line_points->coords[8] = 25.0; /* x4 */ roi_line_points->coords[9] = 25.0; /* y4 */ *proi_item = gnome_canvas_item_new(gnome_canvas_root(GNOME_CANVAS(roi_canvas)), #ifdef AMIDE_LIBGNOMECANVAS_AA gnome_canvas_polygon_get_type(), #else gnome_canvas_line_get_type(), #endif "points", roi_line_points, NULL); gnome_canvas_points_unref(roi_line_points); table_row++; #ifdef AMIDE_LIBGNOMECANVAS_AA /* widget to change the transparency level */ /* only works for anti-aliased canvases */ /* widgets to change the roi's size */ label = gtk_label_new(_("ROI Transparency")); gtk_table_attach(GTK_TABLE(packing_table), label, 0, 1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); gtk_widget_show(label); *proi_transparency_spin = gtk_spin_button_new_with_range(0.0,1.0,AMITK_PREFERENCES_DEFAULT_CANVAS_ROI_TRANSPARENCY); gtk_spin_button_set_increments(GTK_SPIN_BUTTON(*proi_transparency_spin),0.1,0.1); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*proi_transparency_spin),FALSE); gtk_table_attach(GTK_TABLE(packing_table), *proi_transparency_spin, 1,2, table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING); gtk_widget_show(*proi_transparency_spin); table_row++; #else /* widgets to change the roi's line style */ /* Anti-aliased canvas doesn't yet support this */ /* also need to remove #ifndef for relevant lines in amitk_canvas_object.c and other locations */ label = gtk_label_new(_("ROI Line Style:")); gtk_table_attach(GTK_TABLE(packing_table), label, 0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); gtk_widget_show(label); *pline_style_menu = gtk_combo_box_new_text(); for (i_line_style=0; i_line_style<=GDK_LINE_DOUBLE_DASH; i_line_style++) gtk_combo_box_append_text(GTK_COMBO_BOX(*pline_style_menu), line_style_names[i_line_style]); gtk_widget_set_size_request (*pline_style_menu, 125, -1); gtk_table_attach(GTK_TABLE(packing_table), *pline_style_menu, 1,2, table_row,table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING); gtk_widget_show(*pline_style_menu); table_row++; /* do we want to fill in isocontour roi's */ label = gtk_label_new(_("Draw Isocontours/Freehands Filled:")); gtk_table_attach(GTK_TABLE(packing_table), label, 0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); gtk_widget_show(label); *pfill_roi_button = gtk_check_button_new(); gtk_table_attach(GTK_TABLE(packing_table), *pfill_roi_button, 1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); gtk_widget_show(*pfill_roi_button); table_row++; #endif hseparator = gtk_hseparator_new(); gtk_table_attach(GTK_TABLE(packing_table), hseparator, 0, 3, table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING); table_row++; gtk_widget_show(hseparator); label = gtk_label_new(_("Canvas Layout:")); gtk_table_attach(GTK_TABLE(packing_table), label, 0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); gtk_widget_show(label); /* the radio buttons */ *playout_button1 = gtk_radio_button_new(NULL); image = gtk_image_new_from_stock("amide_icon_layout_linear",GTK_ICON_SIZE_DIALOG); gtk_button_set_image(GTK_BUTTON(*playout_button1), image); gtk_table_attach(GTK_TABLE(packing_table), *playout_button1, 1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); g_object_set_data(G_OBJECT(*playout_button1), "layout", GINT_TO_POINTER(AMITK_LAYOUT_LINEAR)); gtk_widget_show(*playout_button1); *playout_button2 = gtk_radio_button_new(NULL); gtk_radio_button_set_group(GTK_RADIO_BUTTON(*playout_button2), gtk_radio_button_get_group(GTK_RADIO_BUTTON(*playout_button1))); image = gtk_image_new_from_stock("amide_icon_layout_orthogonal",GTK_ICON_SIZE_DIALOG); gtk_button_set_image(GTK_BUTTON(*playout_button2), image); gtk_table_attach(GTK_TABLE(packing_table), *playout_button2, 2,3, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); g_object_set_data(G_OBJECT(*playout_button2), "layout", GINT_TO_POINTER(AMITK_LAYOUT_ORTHOGONAL)); gtk_widget_show(*playout_button2); table_row++; label = gtk_label_new(_("Multiple Canvases Layout:")); gtk_table_attach(GTK_TABLE(packing_table), label, 0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); gtk_widget_show(label); /* the radio buttons */ *ppanel_layout_button1 = gtk_radio_button_new(NULL); image = gtk_image_new_from_stock("amide_icon_panels_mixed", GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button1), image); gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button1, 1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); g_object_set_data(G_OBJECT(*ppanel_layout_button1), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_MIXED)); gtk_widget_show(*ppanel_layout_button1); *ppanel_layout_button2 = gtk_radio_button_new(NULL); gtk_radio_button_set_group(GTK_RADIO_BUTTON(*ppanel_layout_button2), gtk_radio_button_get_group(GTK_RADIO_BUTTON(*ppanel_layout_button1))); image = gtk_image_new_from_stock("amide_icon_panels_linear_x", GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button2), image); gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button2, 2,3, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); g_object_set_data(G_OBJECT(*ppanel_layout_button2), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_LINEAR_X)); gtk_widget_show(*ppanel_layout_button2); *ppanel_layout_button3 = gtk_radio_button_new(NULL); gtk_radio_button_set_group(GTK_RADIO_BUTTON(*ppanel_layout_button3), gtk_radio_button_get_group(GTK_RADIO_BUTTON(*ppanel_layout_button1))); image = gtk_image_new_from_stock("amide_icon_panels_linear_y", GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button3), image); gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button3, 3,4, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); g_object_set_data(G_OBJECT(*ppanel_layout_button3), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_LINEAR_Y)); gtk_widget_show(*ppanel_layout_button3); table_row++; /* do we want the size of the canvas to not resize */ label = gtk_label_new(_("Maintain view size constant:")); gtk_table_attach(GTK_TABLE(packing_table), label, 0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); gtk_widget_show(label); *pmaintain_size_button = gtk_check_button_new(); gtk_table_attach(GTK_TABLE(packing_table), *pmaintain_size_button, 1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); gtk_widget_show(*pmaintain_size_button); table_row++; /* widgets to change the amount of empty space in the center of the target */ label = gtk_label_new(_("Target Empty Area (pixels)")); gtk_table_attach(GTK_TABLE(packing_table), label, 0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING); gtk_widget_show(label); adjustment = gtk_adjustment_new(AMITK_PREFERENCES_MIN_TARGET_EMPTY_AREA, AMITK_PREFERENCES_MIN_TARGET_EMPTY_AREA, AMITK_PREFERENCES_MAX_TARGET_EMPTY_AREA, 1.0, 1.0, 0.0); *ptarget_size_spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1.0, 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(*ptarget_size_spin),FALSE); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(*ptarget_size_spin), TRUE); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*ptarget_size_spin), TRUE); gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(*ptarget_size_spin), GTK_UPDATE_ALWAYS); gtk_table_attach(GTK_TABLE(packing_table), *ptarget_size_spin, 1,2, table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING); gtk_widget_show(*ptarget_size_spin); return; }
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); }
static int wire_item_event (WireItem *wire_item, const GdkEvent *event, SchematicView *sv) { SheetPos start_pos, length; Wire *wire; Sheet *sheet; GnomeCanvas *canvas; static double last_x, last_y; double dx, dy, zoom; /* The selected group's bounding box in window resp. canvas coordinates. */ double x1, y1, x2, y2; static double bb_x1, bb_y1, bb_x2, bb_y2; int cx1, cy1, cx2, cy2; double snapped_x, snapped_y; int sheet_width, sheet_height; SheetPos pos; sheet = schematic_view_get_sheet (sv); canvas = GNOME_CANVAS (sheet); g_object_get (G_OBJECT (wire_item), "data", &wire, NULL); wire_get_pos_and_length (WIRE (wire), &start_pos, &length); sheet_get_zoom (sheet, &zoom); switch (event->type) { case GDK_BUTTON_PRESS: switch (event->button.button) { case 1: { g_signal_stop_emission_by_name (G_OBJECT (sheet), "event"); double x, y; x = event->button.x - start_pos.x; y = event->button.y - start_pos.y; if ((x > -RESIZER_SIZE) && (x < RESIZER_SIZE) && (y > -RESIZER_SIZE) && (y < RESIZER_SIZE)) { gtk_widget_grab_focus (GTK_WIDGET (sheet)); sheet->state = SHEET_STATE_DRAG_START; wire_item->priv->resize_state = WIRE_RESIZER_1; last_x = event->button.x; last_y = event->button.y; item_data_unregister (ITEM_DATA (wire)); return TRUE; } if ((x > (length.x-RESIZER_SIZE)) && (x < (length.x+RESIZER_SIZE)) && (y > (length.y-RESIZER_SIZE)) && (y < (length.y+RESIZER_SIZE))) { gtk_widget_grab_focus (GTK_WIDGET (sheet)); sheet->state = SHEET_STATE_DRAG_START; wire_item->priv->resize_state = WIRE_RESIZER_2; last_x = event->button.x; last_y = event->button.y; item_data_unregister (ITEM_DATA (wire)); return TRUE; } } break; } break; case GDK_MOTION_NOTIFY: if (sheet->state != SHEET_STATE_DRAG && sheet->state != SHEET_STATE_DRAG_START) break; if (wire_item->priv->resize_state == WIRE_RESIZER_NONE) break; if (sheet->state == SHEET_STATE_DRAG_START || sheet->state == SHEET_STATE_DRAG) { sheet->state = SHEET_STATE_DRAG; snapped_x = event->motion.x; snapped_y = event->motion.y; snap_to_grid (sheet->grid, &snapped_x, &snapped_y); dx = snapped_x - last_x; dy = snapped_y - last_y; last_x = snapped_x; last_y = snapped_y; wire_get_pos_and_length (wire, &pos, &length); if (wire_item->priv->resize_state == WIRE_RESIZER_1) { switch (wire->priv->direction) { case WIRE_DIR_VERT: /* Vertical Wire */ pos.y = last_y; length.y -= dy; break; case WIRE_DIR_HORIZ: /* Horizontal Wire */ pos.x = last_x; length.x -= dx; break; default: pos.y = last_y; length.y -= dy; pos.x = last_x; length.x -= dx; } } else { switch (wire->priv->direction) { case WIRE_DIR_VERT: /* Vertical Wire */ length.y += dy; break; case WIRE_DIR_HORIZ: /* Horizontal Wire */ length.x += dx; break; default: length.y += dy; length.x += dx; } } snap_to_grid (sheet->grid, &length.x, &length.y); item_data_set_pos (sheet_item_get_data (SHEET_ITEM (wire_item)), &pos); wire_set_length (wire, &length); return TRUE; } break; case GDK_BUTTON_RELEASE: switch (event->button.button) { case 1: if (sheet->state != SHEET_STATE_DRAG && sheet->state != SHEET_STATE_DRAG_START) break; if (wire_item->priv->resize_state == WIRE_RESIZER_NONE) break; g_signal_stop_emission_by_name (G_OBJECT (wire_item), "event"); //gtk_timeout_remove (priv->scroll_timeout_id); // Esto no esta bien. sheet->state = SHEET_STATE_NONE; gnome_canvas_item_ungrab (GNOME_CANVAS_ITEM (wire_item), event->button.time); wire_item->priv->resize_state = WIRE_RESIZER_NONE; sheet->state = SHEET_STATE_NONE; item_data_register (ITEM_DATA (wire)); return TRUE; } break; default: return sheet_item_event (SHEET_ITEM (wire_item), event, sv); } return sheet_item_event (SHEET_ITEM (wire_item), event, sv); }
/* Checks if there is a canvas_node per each node. If not, one canvas_node * must be created and initiated */ static gint check_new_node (node_t * node, GtkWidget * canvas) { canvas_node_t *new_canvas_node; GnomeCanvasGroup *group; if (!node) return FALSE; if (display_node (node) && !g_tree_lookup (canvas_nodes, &node->node_id)) { new_canvas_node = g_malloc (sizeof (canvas_node_t)); g_assert(new_canvas_node); new_canvas_node->canvas_node_id = node->node_id; /* Create a new group to hold the node and its labels */ group = gnome_canvas_root (GNOME_CANVAS (canvas)); group = GNOME_CANVAS_GROUP (gnome_canvas_item_new (group, GNOME_TYPE_CANVAS_GROUP, "x", 100.0, "y", 100.0, NULL)); addref_canvas_obj(G_OBJECT (group)); new_canvas_node->group_item = group; new_canvas_node->node_item = gnome_canvas_item_new (group, GNOME_TYPE_CANVAS_ELLIPSE, "x1", 0.0, "x2", 0.0, "y1", 0.0, "y2", 0.0, "fill_color", "white", "outline_color", "black", "width_pixels", 0, NULL); addref_canvas_obj(G_OBJECT (new_canvas_node->node_item)); new_canvas_node->text_item = gnome_canvas_item_new (group, GNOME_TYPE_CANVAS_TEXT, "text", node->name->str, "x", 0.0, "y", 0.0, "anchor", GTK_ANCHOR_CENTER, "font", pref.fontname, "fill_color", pref.text_color, NULL); addref_canvas_obj(G_OBJECT (new_canvas_node->text_item)); gnome_canvas_item_raise_to_top (GNOME_CANVAS_ITEM (new_canvas_node->text_item)); g_signal_connect (G_OBJECT (new_canvas_node->group_item), "event", (GtkSignalFunc) node_item_event, new_canvas_node); if (!new_canvas_node->node_item || !new_canvas_node->text_item) g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, _("Canvas node null")); /* * We hide them until we are sure that they will get a proper position * in reposition_nodes */ gnome_canvas_item_hide (new_canvas_node->node_item); gnome_canvas_item_hide (new_canvas_node->text_item); new_canvas_node->is_new = TRUE; new_canvas_node->shown = TRUE; g_tree_insert (canvas_nodes, &new_canvas_node->canvas_node_id, new_canvas_node); g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, _("Creating canvas_node: %s. Number of nodes %d"), node->name->str, g_tree_nnodes (canvas_nodes)); need_reposition = TRUE; } return FALSE; /* False to keep on traversing */ } /* check_new_node */
void gnucash_cursor_configure (GnucashCursor *cursor) { GnomeCanvasItem *item; GnucashItemCursor *block_cursor; GnucashItemCursor *cell_cursor; GnomeCanvas *canvas; gint x, y, w, h; double wx, wy; g_return_if_fail (cursor != NULL); g_return_if_fail (GNUCASH_IS_CURSOR (cursor)); canvas = GNOME_CANVAS(GNOME_CANVAS_ITEM(cursor)->canvas); item = GNOME_CANVAS_ITEM (cursor); gnucash_cursor_get_pixel_coords (cursor, &x, &y, &w, &h); gnome_canvas_item_set (GNOME_CANVAS_ITEM(cursor), "GnomeCanvasGroup::x", (double)x, "GnomeCanvasGroup::y", (double)y, NULL); cursor->w = w; cursor->h = h + 1; item->x1 = cursor->x = x; item->y1 = cursor->y = y; item->x2 = x + w; item->y2 = y + h + 1; item = cursor->cursor[GNUCASH_CURSOR_BLOCK]; block_cursor = GNUCASH_ITEM_CURSOR (item); wx = 0; wy = 0; gnome_canvas_item_i2w (item, &wx, &wy); gnome_canvas_w2c (canvas, wx, wy, &block_cursor->x, &block_cursor->y); block_cursor->w = w; block_cursor->h = h + 1; item->x1 = block_cursor->x; item->y1 = block_cursor->y; item->x2 = block_cursor->x + w; item->y2 = block_cursor->y + h + 1; item = cursor->cursor[GNUCASH_CURSOR_CELL]; cell_cursor = GNUCASH_ITEM_CURSOR(item); gnucash_sheet_style_get_cell_pixel_rel_coords (cursor->style, cell_cursor->row, cell_cursor->col, &x, &y, &w, &h); wx = x - block_cursor->x; wy = y; gnome_canvas_item_i2w (item, &wx, &wy); gnome_canvas_w2c (canvas, wx, wy, &cell_cursor->x, &cell_cursor->y); cell_cursor->w = w; cell_cursor->h = h; item->x1 = cell_cursor->x; item->y1 = cell_cursor->y; item->x2 = cell_cursor->x + w; item->y2 = cell_cursor->y + h; }
void ghack_reinit_map_window() { GnomeCanvasImage *bg; double width, height, x, y; int i; /* ghack_map_clear(NULL, NULL); */ width = COLNO * ghack_glyph_width(); height = ROWNO * ghack_glyph_height(); gnome_canvas_set_scroll_region(GNOME_CANVAS(ghack_map.canvas), 0, 0, width + 2 * ghack_glyph_width(), height + 2 * ghack_glyph_height()); /* remove everything currently in the canvas map */ gtk_object_destroy(GTK_OBJECT(myCanvasGroup)); /* Put some groups back */ 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 */ if (background != NULL) { /* 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)); } } if (petmark != NULL) { /* 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++])); } } } ghack_map_cliparound(NULL, u.ux, u.uy, NULL); ghack_map_cursor_to(NULL, u.ux, u.uy, NULL); gnome_canvas_update_now(ghack_map.canvas); doredraw(); }
/* TODO I think I should update all links as well, so as not having * stale graphics if the diagram has been resized */ static gint reposition_canvas_nodes (guint8 * ether_addr, canvas_node_t * canvas_node, GtkWidget * canvas) { static gfloat angle = 0.0; static guint node_i = 0, n_nodes = 0; gdouble x = 0, y = 0, xmin, ymin, xmax, ymax, text_compensation = 50; gdouble x_rad_max, y_rad_max; gdouble oddAngle = angle; if (!canvas_node->shown) { gnome_canvas_item_hide (canvas_node->node_item); gnome_canvas_item_hide (canvas_node->text_item); return FALSE; } gnome_canvas_get_scroll_region (GNOME_CANVAS (canvas), &xmin, &ymin, &xmax, &ymax); if (!n_nodes) n_nodes = node_i = displayed_nodes; xmin += text_compensation; xmax -= text_compensation; /* Reduce the drawable area so that * the node name is not lost * TODO: Need a function to calculate * text_compensation depending on font size */ x_rad_max = 0.9 * (xmax - xmin) / 2; y_rad_max = 0.9 * (ymax - ymin) / 2; /* TODO I've done all the stationary changes in a hurry * I should review it an tidy up all this stuff */ if (pref.stationary) { if (canvas_node->is_new) { static guint count = 0, base = 1; gdouble angle = 0; if (count == 0) { angle = M_PI * 2.0f; count++; } else { if (count > 2 * base) { base *= 2; count = 1; } angle = M_PI * (gdouble) count / ((gdouble) base); count += 2; } x = x_rad_max * cos (angle); y = y_rad_max * sin (angle); } } else { if (n_nodes % 2 == 0) /* spacing is better when n_nodes is odd and Y is linear */ oddAngle = (angle * n_nodes) / (n_nodes + 1); if (n_nodes > 7) { x = x_rad_max * cos (oddAngle); y = y_rad_max * asin (sin (oddAngle)) / (M_PI / 2); } else { x = x_rad_max * cos (angle); y = y_rad_max * sin (angle); } } if (!pref.stationary || canvas_node->is_new) { gnome_canvas_item_set (GNOME_CANVAS_ITEM (canvas_node->group_item), "x", x, "y", y, NULL); canvas_node->is_new = FALSE; } if (need_font_refresh) { /* We update the text font */ gnome_canvas_item_set (canvas_node->text_item, "font", pref.fontname, "fill_color", pref.text_color, NULL); } if (pref.diagram_only) { gnome_canvas_item_hide (canvas_node->text_item); } else { gnome_canvas_item_show (canvas_node->text_item); gnome_canvas_item_request_update (canvas_node->text_item); } gnome_canvas_item_show (canvas_node->node_item); gnome_canvas_item_request_update (canvas_node->node_item); node_i--; if (node_i) angle += 2 * M_PI / n_nodes; else { angle = 0.0; n_nodes = 0; } return FALSE; } /* reposition_canvas_nodes */
gboolean starchart_event_pointer_motion (GtkWidget *widget, GdkEventMotion *event, gpointer user_data) { gint x, y; gint16 vpx, vpy; gdouble wx, wy; static guint interleave; static gint pointer_x = 0, pointer_y = 0; static gboolean panning = FALSE; /* First get canvas coords */ x = (gint) event->x; y = (gint) event->y; /* If we are dragging the starchart to pan... */ if((event->state & (GDK_BUTTON1_MASK)) == (GDK_BUTTON1_MASK)) { gint offset_x, offset_y; /* Check if extra panels are closed, panning is deactivated when open */ if (!gwp_game_state_get_extra_panel_open(game_state)) { /* Set drag cursor */ if(!panning) { starchart_set_pan_cursor(); panning = TRUE; } /* Do panning */ if((interleave++ % MOUSE_INTERLEAVE) == 0) { gnome_canvas_get_scroll_offsets(starchart_get_canvas(), &offset_x, &offset_y); starchart_scroll_to(offset_x + (pointer_x - x) * (MOUSE_INTERLEAVE+1), offset_y + (pointer_y - y) * (MOUSE_INTERLEAVE+1)); } } } /* If not panning... */ else { /* Reset cursor */ if(panning) { starchart_set_default_cursor(); panning = FALSE; } /* Translate coords to World system */ gnome_canvas_c2w(GNOME_CANVAS(widget), x, y, &wx, &wy); /* Assign VP coords to game state*/ vp_coord_w2v (wx, wy, &vpx, &vpy); g_object_set (game_state, "x-coord", vpx, "y-coord", vpy, NULL); /* Update coord indicator */ starchart_update_coord_panel(widget, wx, wy); /* Distance calculation stuff */ /* starchart_update_distance_calc (wx, wy);*/ } pointer_x = (gint) event->x; pointer_y = (gint) event->y; return FALSE; }
void init_stuff (int argc, char *argv[]) { GtkWidget *w; GList *dev_list; GdkDevice *device; GdkScreen *screen; int i, j; struct Brush *b; gboolean can_xinput, success; gchar *tmppath, *tmpfn; // create some data structures needed to populate the preferences ui.default_page.bg = g_new(struct Background, 1); // initialize config file names tmppath = g_build_filename(g_get_home_dir(), CONFIG_DIR, NULL); mkdir(tmppath, 0700); // safer (MRU data may be confidential) ui.mrufile = g_build_filename(tmppath, MRU_FILE, NULL); ui.configfile = g_build_filename(tmppath, CONFIG_FILE, NULL); g_free(tmppath); // initialize preferences init_config_default(); load_config_from_file(); ui.font_name = g_strdup(ui.default_font_name); ui.font_size = ui.default_font_size; ui.hiliter_alpha_mask = 0xffffff00 + (guint)(255*ui.hiliter_opacity); // we need an empty canvas prior to creating the journal structures canvas = GNOME_CANVAS (gnome_canvas_new_aa ()); // initialize data ui.default_page.bg->canvas_item = NULL; ui.layerbox_length = 0; if (argc > 2 || (argc == 2 && argv[1][0] == '-')) { printf(_("Invalid command line parameters.\n" "Usage: %s [filename.xoj]\n"), argv[0]); gtk_exit(0); } undo = NULL; redo = NULL; journal.pages = NULL; bgpdf.status = STATUS_NOT_INIT; new_journal(); ui.cur_item_type = ITEM_NONE; ui.cur_item = NULL; ui.cur_path.coords = NULL; ui.cur_path_storage_alloc = 0; ui.cur_path.ref_count = 1; ui.cur_widths = NULL; ui.cur_widths_storage_alloc = 0; ui.selection = NULL; ui.cursor = NULL; ui.pen_cursor_pix = ui.hiliter_cursor_pix = NULL; ui.cur_brush = &(ui.brushes[0][ui.toolno[0]]); for (j=0; j<=NUM_BUTTONS; j++) for (i=0; i < NUM_STROKE_TOOLS; i++) { b = &(ui.brushes[j][i]); b->tool_type = i; if (b->color_no>=0) { b->color_rgba = predef_colors_rgba[b->color_no]; if (i == TOOL_HIGHLIGHTER) { b->color_rgba &= ui.hiliter_alpha_mask; } } b->thickness = predef_thickness[i][b->thickness_no]; } for (i=0; i<NUM_STROKE_TOOLS; i++) g_memmove(ui.default_brushes+i, &(ui.brushes[0][i]), sizeof(struct Brush)); ui.cur_mapping = 0; ui.which_unswitch_button = 0; ui.in_proximity = FALSE; ui.warned_generate_fontconfig = FALSE; reset_recognizer(); // initialize various interface elements gtk_window_set_default_size(GTK_WINDOW (winMain), ui.window_default_width, ui.window_default_height); if (ui.maximize_at_start) gtk_window_maximize(GTK_WINDOW (winMain)); update_toolbar_and_menu(); update_font_button(); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("journalApplyAllPages")), ui.bg_apply_all_pages); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("journalNewPageKeepsBG")), ui.new_page_bg_from_pdf); if (ui.fullscreen) { gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), TRUE); gtk_toggle_tool_button_set_active( GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), TRUE); gtk_window_fullscreen(GTK_WINDOW(winMain)); } gtk_button_set_relief(GTK_BUTTON(GET_COMPONENT("buttonColorChooser")), GTK_RELIEF_NONE); allow_all_accels(); add_scroll_bindings(); // prevent interface items from stealing focus // glade doesn't properly handle can_focus, so manually set it gtk_combo_box_set_focus_on_click(GTK_COMBO_BOX(GET_COMPONENT("comboLayer")), FALSE); g_signal_connect(GET_COMPONENT("spinPageNo"), "activate", G_CALLBACK(handle_activate_signal), NULL); gtk_container_forall(GTK_CONTAINER(winMain), unset_flags, (gpointer)GTK_CAN_FOCUS); GTK_WIDGET_SET_FLAGS(GTK_WIDGET(canvas), GTK_CAN_FOCUS); GTK_WIDGET_SET_FLAGS(GTK_WIDGET(GET_COMPONENT("spinPageNo")), GTK_CAN_FOCUS); // install hooks on button/key/activation events to make the spinPageNo lose focus gtk_container_forall(GTK_CONTAINER(winMain), install_focus_hooks, NULL); // set up and initialize the canvas gtk_widget_show (GTK_WIDGET (canvas)); w = GET_COMPONENT("scrolledwindowMain"); gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (canvas)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_events (GTK_WIDGET (canvas), GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_PROXIMITY_IN_MASK | GDK_PROXIMITY_OUT_MASK); gnome_canvas_set_pixels_per_unit (canvas, ui.zoom); gnome_canvas_set_center_scroll_region (canvas, TRUE); gtk_layout_get_hadjustment(GTK_LAYOUT (canvas))->step_increment = ui.scrollbar_step_increment; gtk_layout_get_vadjustment(GTK_LAYOUT (canvas))->step_increment = ui.scrollbar_step_increment; // set up the page size and canvas size update_page_stuff(); g_signal_connect ((gpointer) canvas, "button_press_event", G_CALLBACK (on_canvas_button_press_event), NULL); g_signal_connect ((gpointer) canvas, "button_release_event", G_CALLBACK (on_canvas_button_release_event), NULL); g_signal_connect ((gpointer) canvas, "enter_notify_event", G_CALLBACK (on_canvas_enter_notify_event), NULL); g_signal_connect ((gpointer) canvas, "leave_notify_event", G_CALLBACK (on_canvas_leave_notify_event), NULL); g_signal_connect ((gpointer) canvas, "proximity_in_event", G_CALLBACK (on_canvas_proximity_event), NULL); g_signal_connect ((gpointer) canvas, "proximity_out_event", G_CALLBACK (on_canvas_proximity_event), NULL); g_signal_connect ((gpointer) canvas, "expose_event", G_CALLBACK (on_canvas_expose_event), NULL); g_signal_connect ((gpointer) canvas, "key_press_event", G_CALLBACK (on_canvas_key_press_event), NULL); g_signal_connect ((gpointer) canvas, "motion_notify_event", G_CALLBACK (on_canvas_motion_notify_event), NULL); g_signal_connect ((gpointer) gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), "value-changed", G_CALLBACK (on_vscroll_changed), NULL); g_signal_connect ((gpointer) gtk_layout_get_hadjustment(GTK_LAYOUT(canvas)), "value-changed", G_CALLBACK (on_hscroll_changed), NULL); g_object_set_data (G_OBJECT (winMain), "canvas", canvas); screen = gtk_widget_get_screen(winMain); ui.screen_width = gdk_screen_get_width(screen); ui.screen_height = gdk_screen_get_height(screen); can_xinput = FALSE; dev_list = gdk_devices_list(); while (dev_list != NULL) { device = (GdkDevice *)dev_list->data; if (device != gdk_device_get_core_pointer() && device->num_axes >= 2) { /* get around a GDK bug: map the valuator range CORRECTLY to [0,1] */ #ifdef ENABLE_XINPUT_BUGFIX gdk_device_set_axis_use(device, 0, GDK_AXIS_IGNORE); gdk_device_set_axis_use(device, 1, GDK_AXIS_IGNORE); #endif gdk_device_set_mode(device, GDK_MODE_SCREEN); if (g_strrstr(device->name, "raser")) gdk_device_set_source(device, GDK_SOURCE_ERASER); can_xinput = TRUE; } dev_list = dev_list->next; } if (!can_xinput) gtk_widget_set_sensitive(GET_COMPONENT("optionsUseXInput"), FALSE); ui.use_xinput = ui.allow_xinput && can_xinput; gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsProgressiveBG")), ui.progressive_bg); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsPrintRuling")), ui.print_ruling); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutoloadPdfXoj")), ui.autoload_pdf_xoj); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutosaveXoj")), ui.autosave_enabled); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsLeftHanded")), ui.left_handed); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsShortenMenus")), ui.shorten_menus); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutoSavePrefs")), ui.auto_save_prefs); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsButtonSwitchMapping")), ui.button_switch_mapping); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsLargePenCursor")), ui.large_pencursor); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsPenCursor")), ui.pen_cursor); hide_unimplemented(); update_undo_redo_enabled(); update_copy_paste_enabled(); update_vbox_order(ui.vertical_order[ui.fullscreen?1:0]); gtk_widget_grab_focus(GTK_WIDGET(canvas)); // show everything... gtk_widget_show (winMain); update_cursor(); /* this will cause extension events to get enabled/disabled, but we need the windows to be mapped first */ gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsUseXInput")), ui.use_xinput); /* fix a bug in GTK+ 2.16 and 2.17: scrollbars shouldn't get extended input events from pointer motion when cursor moves into main window */ if (!gtk_check_version(2, 16, 0)) { g_signal_connect ( GET_COMPONENT("menubar"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("toolbarMain"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("toolbarPen"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("statusbar"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( (gpointer)(gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(w))), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( (gpointer)(gtk_scrolled_window_get_hscrollbar(GTK_SCROLLED_WINDOW(w))), "event", G_CALLBACK (filter_extended_events), NULL); } // load the MRU init_mru(); // and finally, open a file specified on the command line // (moved here because display parameters weren't initialized yet...) if (argc == 1) return; set_cursor_busy(TRUE); if (g_path_is_absolute(argv[1])) tmpfn = g_strdup(argv[1]); else { tmppath = g_get_current_dir(); tmpfn = g_build_filename(tmppath, argv[1], NULL); g_free(tmppath); } success = open_journal(tmpfn); g_free(tmpfn); set_cursor_busy(FALSE); if (!success) { w = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), argv[1]); gtk_dialog_run(GTK_DIALOG(w)); gtk_widget_destroy(w); } }