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