void GfxSquareBrush::drawStyle(GnomeCanvasItem *rb, GdkBitmap *stipple, GdkBitmap *stubble, const guint32 &black, const guint32 &white, const Coord ¤t) { GnomeCanvasPoints *pts = gnome_canvas_points_new(4); pts->coords[0] = current(0) - size; pts->coords[1] = current(1) + size; pts->coords[2] = current(0) - size; pts->coords[3] = current(1) - size; pts->coords[4] = current(0) + size; pts->coords[5] = current(1) - size; pts->coords[6] = current(0) + size; pts->coords[7] = current(1) + size; gnome_canvas_item_new(GNOME_CANVAS_GROUP(rb), gnome_canvas_polygon_get_type(), "points", pts, "outline_color_rgba", black, "width_pixels", 0, "outline_stipple", stipple, NULL); gnome_canvas_item_new(GNOME_CANVAS_GROUP(rb), gnome_canvas_polygon_get_type(), "points", pts, "outline_color_rgba", white, "width_pixels", 0, "outline_stipple", stubble, NULL); }
static void create_rect_and_text (ETableClickToAdd *etcta) { GtkWidget *widget; GdkColor fg, bg; widget = GTK_WIDGET (GNOME_CANVAS_ITEM (etcta)->canvas); e_utils_get_theme_color_color (widget, "theme_selected_fg_color", E_UTILS_DEFAULT_THEME_SELECTED_FG_COLOR, &fg); e_utils_get_theme_color_color (widget, "theme_selected_bg_color", E_UTILS_DEFAULT_THEME_SELECTED_BG_COLOR, &bg); if (!etcta->rect) etcta->rect = gnome_canvas_item_new ( GNOME_CANVAS_GROUP (etcta), gnome_canvas_rect_get_type (), "x1", (gdouble) 0, "y1", (gdouble) 1, "x2", (gdouble) etcta->width, "y2", (gdouble) etcta->height, "fill_color_gdk", &bg, NULL); if (!etcta->text) etcta->text = gnome_canvas_item_new ( GNOME_CANVAS_GROUP (etcta), e_text_get_type (), "text", etcta->message ? etcta->message : "", "width", etcta->width - 4, "fill_color_gdk", &fg, NULL); }
static gboolean bst_canvas_link_build_async (gpointer data) { GnomeCanvasItem *item = GNOME_CANVAS_ITEM (data); if (gnome_canvas_item_check_undisposed (item)) { BstCanvasLink *clink = BST_CANVAS_LINK (item); if (!clink->arrow) clink->arrow = g_object_connect (gnome_canvas_item_new (GNOME_CANVAS_GROUP (clink), GNOME_TYPE_CANVAS_POLYGON, "outline_color_rgba", 0x000000ff, "fill_color_rgba", 0xff0000ff, NULL), "signal::destroy", gtk_widget_destroyed, &clink->arrow, "swapped_signal::event", bst_canvas_link_child_event, clink, NULL); if (!clink->tag_start) clink->tag_start = g_object_connect (gnome_canvas_item_new (GNOME_CANVAS_GROUP (clink), GNOME_TYPE_CANVAS_ELLIPSE, "outline_color_rgba", 0x000000ff, // xffff00ff, "fill_color_rgba", 0xffff00ff, NULL), "signal::destroy", gtk_widget_destroyed, &clink->tag_start, "swapped_signal::event", bst_canvas_link_child_event, clink, NULL); if (!clink->tag_end) { gboolean is_jchannel = FALSE; if (clink->icsource) is_jchannel = bst_canvas_source_is_jchannel (clink->icsource, clink->ichannel); clink->tag_end = g_object_connect (gnome_canvas_item_new (GNOME_CANVAS_GROUP (clink), GNOME_TYPE_CANVAS_ELLIPSE, "outline_color_rgba", 0x000000ff, // 0xff0000ff, "fill_color_rgba", is_jchannel ? 0x00ff00ff : 0xff0000ff, NULL), "signal::destroy", gtk_widget_destroyed, &clink->tag_end, "swapped_signal::event", bst_canvas_link_child_event, clink, NULL); } if (!clink->line) clink->line = g_object_connect (gnome_canvas_item_new (GNOME_CANVAS_GROUP (clink), GNOME_TYPE_CANVAS_LINE, "fill_color", "black", NULL), "signal::destroy", gtk_widget_destroyed, &clink->line, "swapped_signal::notify", bst_canvas_link_adjust_arrow, clink, "swapped_signal::notify", bst_canvas_link_adjust_tags, clink, NULL); bst_canvas_link_update (clink); } GnomeCanvas *canvas = g_object_steal_data (item, "bst-workaround-canvas-ref"); g_object_unref (item); if (canvas) g_object_unref (canvas); /* canvases don't properly protect their items */ return FALSE; }
static ETableGroupContainerChildNode * create_child_node (ETableGroupContainer *etgc, void *val) { ETableGroup *child; ETableGroupContainerChildNode *child_node; ETableGroup *etg = E_TABLE_GROUP(etgc); child_node = g_new (ETableGroupContainerChildNode, 1); child_node->rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP (etgc), gnome_canvas_rect_get_type (), "fill_color", "grey70", "outline_color", "grey50", NULL); child_node->text = gnome_canvas_item_new (GNOME_CANVAS_GROUP (etgc), e_text_get_type (), "anchor", GTK_ANCHOR_SW, "fill_color", "black", "draw_background", FALSE, NULL); child = e_table_group_new (GNOME_CANVAS_GROUP (etgc), etg->full_header, etg->header, etg->model, etgc->sort_info, etgc->n + 1); gnome_canvas_item_set(GNOME_CANVAS_ITEM(child), "alternating_row_colors", etgc->alternating_row_colors, "horizontal_draw_grid", etgc->horizontal_draw_grid, "vertical_draw_grid", etgc->vertical_draw_grid, "drawfocus", etgc->draw_focus, "cursor_mode", etgc->cursor_mode, "selection_model", etgc->selection_model, "length_threshold", etgc->length_threshold, "uniform_row_height", etgc->uniform_row_height, "minimum_width", etgc->minimum_width - GROUP_INDENT, NULL); g_signal_connect (child, "cursor_change", G_CALLBACK (child_cursor_change), etgc); g_signal_connect (child, "cursor_activated", G_CALLBACK (child_cursor_activated), etgc); g_signal_connect (child, "double_click", G_CALLBACK (child_double_click), etgc); g_signal_connect (child, "right_click", G_CALLBACK (child_right_click), etgc); g_signal_connect (child, "click", G_CALLBACK (child_click), etgc); g_signal_connect (child, "key_press", G_CALLBACK (child_key_press), etgc); g_signal_connect (child, "start_drag", G_CALLBACK (child_start_drag), etgc); child_node->child = child; child_node->key = e_table_model_duplicate_value (etg->model, etgc->ecol->col_idx, val); child_node->string = e_table_model_value_to_string (etg->model, etgc->ecol->col_idx, val); child_node->count = 0; return child_node; }
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 e_canvas_item_invoke_reflow (GnomeCanvasItem *item, int flags) { GnomeCanvasGroup *group; GList *list; GnomeCanvasItem *child; if (GNOME_IS_CANVAS_GROUP (item)) { group = GNOME_CANVAS_GROUP (item); for (list = group->item_list; list; list = list->next) { child = GNOME_CANVAS_ITEM (list->data); if (child->object.flags & E_CANVAS_ITEM_DESCENDENT_NEEDS_REFLOW) e_canvas_item_invoke_reflow (child, flags); } } if (item->object.flags & E_CANVAS_ITEM_NEEDS_REFLOW) { ECanvasItemReflowFunc func; func = (ECanvasItemReflowFunc) g_object_get_data (G_OBJECT (item), "ECanvasItem::reflow_callback"); if (func) func (item, flags); } item->object.flags &= ~E_CANVAS_ITEM_NEEDS_REFLOW; item->object.flags &= ~E_CANVAS_ITEM_DESCENDENT_NEEDS_REFLOW; }
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; }
static void bst_canvas_source_destroy (GtkObject *object) { BstCanvasSource *csource = BST_CANVAS_SOURCE (object); GnomeCanvasGroup *group = GNOME_CANVAS_GROUP (object); if (csource->in_move) { csource->in_move = FALSE; bse_item_ungroup_undo (csource->source); } while (csource->channel_hints) gtk_object_destroy (csource->channel_hints->data); while (group->item_list) gtk_object_destroy (group->item_list->data); if (csource->source) { bse_proxy_disconnect (csource->source, "any_signal", gtk_object_destroy, csource, "any_signal", source_channels_changed, csource, "any_signal", source_name_changed, csource, "any_signal", source_pos_changed, csource, "any_signal", source_icon_changed, csource, NULL); bse_item_unuse (csource->source); csource->source = 0; } GTK_OBJECT_CLASS (bst_canvas_source_parent_class)->destroy (object); }
static void cursor_changed (ESelectionModel *selection, int row, int col, EReflow *reflow) { int count = reflow->count; int old_cursor = reflow->cursor_row; if (old_cursor < count && old_cursor >= 0) { if (reflow->items[old_cursor]) { g_object_set (reflow->items[old_cursor], "has_cursor", FALSE, NULL); } } reflow->cursor_row = row; if (row < count && row >= 0) { if (reflow->items[row]) { g_object_set (reflow->items[row], "has_cursor", TRUE, NULL); } else { reflow->items[row] = e_reflow_model_incarnate (reflow->model, row, GNOME_CANVAS_GROUP (reflow)); g_object_set (reflow->items[row], "has_cursor", TRUE, "width", (double) reflow->column_width, NULL); } } if (reflow->do_adjustment_idle_id == 0) reflow->do_adjustment_idle_id = g_idle_add (do_adjustment, reflow); }
static void etgl_realize (GnomeCanvasItem *item) { ETableGroupLeaf *etgl = E_TABLE_GROUP_LEAF (item); if (GNOME_CANVAS_ITEM_CLASS (e_table_group_leaf_parent_class)->realize) GNOME_CANVAS_ITEM_CLASS (e_table_group_leaf_parent_class)->realize (item); etgl->item = E_TABLE_ITEM (gnome_canvas_item_new ( GNOME_CANVAS_GROUP (etgl), e_table_item_get_type (), "ETableHeader", E_TABLE_GROUP (etgl)->header, "ETableModel", etgl->ets, "alternating_row_colors", etgl->alternating_row_colors, "horizontal_draw_grid", etgl->horizontal_draw_grid, "vertical_draw_grid", etgl->vertical_draw_grid, "drawfocus", etgl->draw_focus, "cursor_mode", etgl->cursor_mode, "minimum_width", etgl->minimum_width, "length_threshold", etgl->length_threshold, "selection_model", etgl->selection_model, "uniform_row_height", etgl->uniform_row_height, NULL)); etgl->etgl_cursor_change_id = g_signal_connect ( etgl->item, "cursor_change", G_CALLBACK (etgl_cursor_change), etgl); etgl->etgl_cursor_activated_id = g_signal_connect ( etgl->item, "cursor_activated", G_CALLBACK (etgl_cursor_activated), etgl); etgl->etgl_double_click_id = g_signal_connect ( etgl->item, "double_click", G_CALLBACK (etgl_double_click), etgl); etgl->etgl_right_click_id = g_signal_connect ( etgl->item, "right_click", G_CALLBACK (etgl_right_click), etgl); etgl->etgl_click_id = g_signal_connect ( etgl->item, "click", G_CALLBACK (etgl_click), etgl); etgl->etgl_key_press_id = g_signal_connect ( etgl->item, "key_press", G_CALLBACK (etgl_key_press), etgl); etgl->etgl_start_drag_id = g_signal_connect ( etgl->item, "start_drag", G_CALLBACK (etgl_start_drag), etgl); etgl->notify_is_editing_id = e_signal_connect_notify ( etgl->item, "notify::is-editing", G_CALLBACK (etgl_item_is_editing_changed_cb), etgl); e_canvas_item_request_reflow (item); }
void GfxCircleBrush::drawStyle(GnomeCanvasItem *rb, GdkBitmap *stipple, GdkBitmap *stubble, const guint32 &black, const guint32 &white, const Coord ¤t) { // Circle gnome_canvas_item_new(GNOME_CANVAS_GROUP(rb), gnome_canvas_ellipse_get_type(), "x1", current(0)-r, "y1", (current(1)-r), "x2", current(0)+r, "y2", (current(1)+r), "outline_color_rgba", black, "outline_stipple", stipple, "width_pixels", 0, NULL); gnome_canvas_item_new(GNOME_CANVAS_GROUP(rb), gnome_canvas_ellipse_get_type(), "x1", current(0)-r, "y1", (current(1)-r), "x2", current(0)+r, "y2", (current(1)+r), "outline_color_rgba", white, "outline_stipple", stubble, "width_pixels", 0, NULL); }
static void finish_editing (ETableClickToAdd *etcta) { if (etcta->row) { ETableModel *one; e_table_item_leave_edit (E_TABLE_ITEM (etcta->row)); e_table_one_commit (E_TABLE_ONE (etcta->one)); etcta_drop_one (etcta); g_object_run_dispose (G_OBJECT (etcta->row)); etcta->row = NULL; if (etcta->text) { g_object_run_dispose (G_OBJECT (etcta->text)); etcta->text = NULL; } if (etcta->rect) { g_object_run_dispose (G_OBJECT (etcta->rect)); etcta->rect = NULL; } one = e_table_one_new (etcta->model); etcta_add_one (etcta, one); g_object_unref (one); e_selection_model_clear (E_SELECTION_MODEL (etcta->selection)); etcta->row = gnome_canvas_item_new ( GNOME_CANVAS_GROUP (etcta), e_table_item_get_type (), "ETableHeader", etcta->eth, "ETableModel", etcta->one, "minimum_width", etcta->width, "horizontal_draw_grid", TRUE, "vertical_draw_grid", TRUE, "selection_model", etcta->selection, "cursor_mode", E_CURSOR_SPREADSHEET, NULL); g_signal_connect ( etcta->row, "key_press", G_CALLBACK (item_key_press), etcta); e_signal_connect_notify ( etcta->row, "notify::is-editing", G_CALLBACK (table_click_to_add_row_is_editing_changed_cb), etcta); set_initial_selection (etcta); g_object_notify (G_OBJECT (etcta), "is-editing"); } }
static void items_inserted (EReflowModel *model, int position, int count, EReflow *reflow) { int i, oldcount; if (position < 0 || position > reflow->count) return; oldcount = reflow->count; reflow->count += count; if (reflow->count > reflow->allocated_count) { while (reflow->count > reflow->allocated_count) reflow->allocated_count += 256; reflow->heights = g_renew (int, reflow->heights, reflow->allocated_count); reflow->items = g_renew (GnomeCanvasItem *, reflow->items, reflow->allocated_count); } memmove (reflow->heights + position + count, reflow->heights + position, (reflow->count - position - count) * sizeof (int)); memmove (reflow->items + position + count, reflow->items + position, (reflow->count - position - count) * sizeof (GnomeCanvasItem *)); for (i = position; i < position + count; i++) { reflow->items[i] = NULL; reflow->heights[i] = e_reflow_model_height (reflow->model, i, GNOME_CANVAS_GROUP (reflow)); } e_selection_model_simple_set_row_count (E_SELECTION_MODEL_SIMPLE (reflow->selection), reflow->count); if (position == oldcount) e_sorter_array_append (reflow->sorter, count); else e_sorter_array_set_count (reflow->sorter, reflow->count); for (i = position; i < position + count; i ++) { int sorted = e_sorter_model_to_sorted (E_SORTER (reflow->sorter), i); int c; for (c = reflow->column_count - 1; c >= 0; c--) { int start_of_column = reflow->columns[c]; if (start_of_column <= sorted) { if (reflow->reflow_from_column == -1 || reflow->reflow_from_column > c) { reflow->reflow_from_column = c; } break; } } } reflow->need_reflow_columns = TRUE; set_empty (reflow); e_canvas_item_request_reflow(GNOME_CANVAS_ITEM (reflow)); }
static void e_minicard_label_realize (GnomeCanvasItem *item) { EMinicardLabel *e_minicard_label; GnomeCanvasGroup *group; e_minicard_label = E_MINICARD_LABEL (item); group = GNOME_CANVAS_GROUP ( item ); if (GNOME_CANVAS_ITEM_CLASS ( parent_class )->realize) (* GNOME_CANVAS_ITEM_CLASS ( parent_class )->realize) (item); e_canvas_item_request_reflow (item); e_minicard_label->rect = gnome_canvas_item_new ( group, gnome_canvas_rect_get_type (), "x1", (double) 0, "y1", (double) 0, "x2", (double) e_minicard_label->width - 1, "y2", (double) e_minicard_label->height - 1, "outline_color", NULL, NULL ); e_minicard_label->fieldname = gnome_canvas_item_new ( group, e_text_get_type (), "clip_width", (double) ( e_minicard_label->width / 2 - 4 ), "clip", TRUE, "use_ellipsis", TRUE, "fill_color", "black", "draw_background", FALSE, "im_context", E_CANVAS (item->canvas)->im_context, NULL ); e_canvas_item_move_absolute (e_minicard_label->fieldname, 2, 1); e_minicard_label->field = gnome_canvas_item_new ( group, e_text_get_type (), "clip_width", (double) ( ( e_minicard_label->width + 1 ) / 2 - 4 ), "clip", TRUE, "use_ellipsis", TRUE, "fill_color", "black", "editable", FALSE, /* e_minicard_label->editable, */ "draw_background", FALSE, "im_context", E_CANVAS (item->canvas)->im_context, NULL ); e_canvas_item_move_absolute (e_minicard_label->field, ( e_minicard_label->width / 2 + 2), 1); set_colors (e_minicard_label); e_canvas_item_request_reflow (item); }
void G_cont_create( int cont, GnomeCanvasGroup *root ) { if(!initialized) G_cont_init(); G_conts[cont].cont_group = GNOME_CANVAS_GROUP( gnome_canvas_item_new ( root, gnome_canvas_group_get_type (), "x", (double) G_conts[cont].x, "y", (double) G_conts[cont].y, NULL)); }
static void item_changed (EReflowModel *model, int i, EReflow *reflow) { if (i < 0 || i >= reflow->count) return; reflow->heights[i] = e_reflow_model_height (reflow->model, i, GNOME_CANVAS_GROUP (reflow)); if (reflow->items[i] != NULL) e_reflow_model_reincarnate (model, i, reflow->items[i]); e_sorter_array_clean (reflow->sorter); reflow->reflow_from_column = -1; reflow->need_reflow_columns = TRUE; e_canvas_item_request_reflow(GNOME_CANVAS_ITEM (reflow)); }
static void bst_canvas_link_destroy (GtkObject *object) { BstCanvasLink *clink = BST_CANVAS_LINK (object); GnomeCanvasGroup *group = GNOME_CANVAS_GROUP (object); while (group->item_list) gtk_object_destroy (group->item_list->data); bst_canvas_link_set_ocsource (clink, NULL, 0); bst_canvas_link_set_icsource (clink, NULL, 0); GTK_OBJECT_CLASS (bst_canvas_link_parent_class)->destroy (object); }
GnomeCanvasItem * gnucash_cursor_new (GnomeCanvasGroup *parent) { GnomeCanvasItem *item; GnomeCanvasItem *cursor_item; GnucashCursor *cursor; GnucashItemCursor *item_cursor; g_return_val_if_fail (parent != NULL, NULL); g_return_val_if_fail (GNOME_IS_CANVAS_GROUP(parent), NULL); item = gnome_canvas_item_new (parent, gnucash_cursor_get_type(), NULL); cursor = GNUCASH_CURSOR(item); cursor_item = gnome_canvas_item_new (GNOME_CANVAS_GROUP(item), gnucash_item_cursor_get_type(), NULL); item_cursor = GNUCASH_ITEM_CURSOR (cursor_item); item_cursor->type = GNUCASH_CURSOR_CELL; cursor->cursor[GNUCASH_CURSOR_CELL] = cursor_item; cursor_item = gnome_canvas_item_new (GNOME_CANVAS_GROUP(item), gnucash_item_cursor_get_type(), NULL); item_cursor = GNUCASH_ITEM_CURSOR (cursor_item); item_cursor->type = GNUCASH_CURSOR_BLOCK; cursor->cursor[GNUCASH_CURSOR_BLOCK] = cursor_item; return item; }
static inline void e_reflow_update_selection_row (EReflow *reflow, int row) { if (reflow->items[row]) { g_object_set(reflow->items[row], "selected", e_selection_model_is_row_selected(E_SELECTION_MODEL(reflow->selection), row), NULL); } else if (e_selection_model_is_row_selected (E_SELECTION_MODEL (reflow->selection), row)) { reflow->items[row] = e_reflow_model_incarnate (reflow->model, row, GNOME_CANVAS_GROUP (reflow)); g_object_set (reflow->items[row], "selected", e_selection_model_is_row_selected(E_SELECTION_MODEL(reflow->selection), row), "width", (double) reflow->column_width, NULL); } }
static void ec_style_set_recursive (GnomeCanvasItem *item, GtkStyle *previous_style) { guint signal_id = g_signal_lookup ("style_set", G_OBJECT_TYPE (item)); if (signal_id >= 1) { GSignalQuery query; g_signal_query (signal_id, &query); if (query.return_type == G_TYPE_NONE && query.n_params == 1 && query.param_types[0] == GTK_TYPE_STYLE) { g_signal_emit (item, signal_id, 0, previous_style); } } if (GNOME_IS_CANVAS_GROUP (item) ) { GList *items = GNOME_CANVAS_GROUP (item)->item_list; for (; items; items = items->next) ec_style_set_recursive (items->data, previous_style); } }
static void incarnate (EReflow *reflow) { int column_width; int first_column; int last_column; int first_cell; int last_cell; int i; GtkAdjustment *adjustment = gtk_layout_get_hadjustment (GTK_LAYOUT (GNOME_CANVAS_ITEM (reflow)->canvas)); column_width = reflow->column_width; first_column = adjustment->value - 1 + E_REFLOW_BORDER_WIDTH; first_column /= column_width + E_REFLOW_FULL_GUTTER; last_column = adjustment->value + adjustment->page_size + 1 - E_REFLOW_BORDER_WIDTH - E_REFLOW_DIVIDER_WIDTH; last_column /= column_width + E_REFLOW_FULL_GUTTER; last_column ++; if (first_column >= 0 && first_column < reflow->column_count) first_cell = reflow->columns[first_column]; else first_cell = 0; if (last_column >= 0 && last_column < reflow->column_count) last_cell = reflow->columns[last_column]; else last_cell = reflow->count; for (i = first_cell; i < last_cell; i++) { int unsorted = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), i); if (reflow->items[unsorted] == NULL) { if (reflow->model) { reflow->items[unsorted] = e_reflow_model_incarnate (reflow->model, unsorted, GNOME_CANVAS_GROUP (reflow)); g_object_set (reflow->items[unsorted], "selected", e_selection_model_is_row_selected(E_SELECTION_MODEL(reflow->selection), unsorted), "width", (double) reflow->column_width, NULL); } } } reflow->incarnate_idle_id = 0; }
static void set_empty(EReflow *reflow) { if (reflow->count == 0) { if (reflow->empty_text) { if (reflow->empty_message) { gnome_canvas_item_set(reflow->empty_text, "width", reflow->minimum_width, "text", reflow->empty_message, NULL); e_canvas_item_move_absolute(reflow->empty_text, reflow->minimum_width / 2, 0); } else { gtk_object_destroy(GTK_OBJECT(reflow->empty_text)); reflow->empty_text = NULL; } } else { if (reflow->empty_message) { reflow->empty_text = gnome_canvas_item_new(GNOME_CANVAS_GROUP(reflow), e_text_get_type(), "anchor", GTK_ANCHOR_N, "width", reflow->minimum_width, "clip", TRUE, "use_ellipsis", TRUE, "justification", GTK_JUSTIFY_CENTER, "text", reflow->empty_message, "draw_background", FALSE, NULL); e_canvas_item_move_absolute(reflow->empty_text, reflow->minimum_width / 2, 0); } } } else { if (reflow->empty_text) { gtk_object_destroy(GTK_OBJECT(reflow->empty_text)); reflow->empty_text = NULL; } } }
static void etfci_update (GnomeCanvasItem *item, const cairo_matrix_t *i2c, gint flags) { ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item); gdouble x1, y1, x2, y2; if (GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->update) GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->update ( item, i2c, flags); x1 = y1 = 0; x2 = etfci->width; y2 = etfci->height; gnome_canvas_matrix_transform_rect (i2c, &x1, &y1, &x2, &y2); if (item->x1 != x1 || item->y1 != y1 || item->x2 != x2 || item->y2 != y2) { gnome_canvas_request_redraw ( item->canvas, item->x1, item->y1, item->x2, item->y2); item->x1 = x1; item->y1 = y1; item->x2 = x2; item->y2 = y2; /* FIXME: Group Child bounds !? */ #if 0 gnome_canvas_group_child_bounds ( GNOME_CANVAS_GROUP (item->parent), item); #endif } gnome_canvas_request_redraw ( item->canvas, item->x1, item->y1, item->x2, item->y2); }
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); } }
static void bst_canvas_source_build (BstCanvasSource *csource) { GnomeCanvasGroup *group = GNOME_CANVAS_GROUP (csource); /* put an outer rectangle, make it transparent in aa mode, * so we can receive mouse events everywhere */ GnomeCanvasItem *rect = gnome_canvas_item_new (group, GNOME_TYPE_CANVAS_RECT, "outline_color_rgba", RGBA_BLACK, /* covers buggy canvas lines */ "x1", 0.0, "y1", 0.0, "x2", TOTAL_WIDTH (csource), "y2", TOTAL_HEIGHT (csource), (GNOME_CANVAS_ITEM (csource)->canvas->aa ? "fill_color_rgba" : NULL), 0x00000000, NULL); g_object_connect (rect, "swapped_signal::event", bst_canvas_source_child_event, csource, NULL); /* make sure no items are left over */ while (csource->channel_items) gtk_object_destroy (csource->channel_items->data); while (csource->channel_hints) gtk_object_destroy (csource->channel_hints->data); csource->built_ichannels = FALSE; csource->built_ochannels = FALSE; csource->built_ihints = FALSE; csource->built_ohints = FALSE; /* asynchronously rebuild contents */ GnomeCanvasItem *csource_item = GNOME_CANVAS_ITEM (csource); /* work around stale canvas pointers, see #340437 */ g_object_set_data_full (csource_item, "bst-workaround-canvas-ref", g_object_ref (csource_item->canvas), g_object_unref); bst_background_handler2_add (bst_canvas_source_build_async, g_object_ref (csource), NULL); }
static void model_changed (EReflowModel *model, EReflow *reflow) { int i; int count; int oldcount; count = reflow->count; oldcount = count; for (i = 0; i < count; i++) { if (reflow->items[i]) gtk_object_destroy (GTK_OBJECT (reflow->items[i])); } g_free (reflow->items); g_free (reflow->heights); reflow->count = e_reflow_model_count (model); reflow->allocated_count = reflow->count; reflow->items = g_new (GnomeCanvasItem *, reflow->count); reflow->heights = g_new (int, reflow->count); count = reflow->count; for (i = 0; i < count; i++) { reflow->items[i] = NULL; reflow->heights[i] = e_reflow_model_height (reflow->model, i, GNOME_CANVAS_GROUP (reflow)); } e_selection_model_simple_set_row_count (E_SELECTION_MODEL_SIMPLE (reflow->selection), count); e_sorter_array_set_count (reflow->sorter, reflow->count); reflow->need_reflow_columns = TRUE; if (oldcount > reflow->count) reflow_columns (reflow); set_empty (reflow); e_canvas_item_request_reflow(GNOME_CANVAS_ITEM (reflow)); }
static gboolean bst_canvas_source_build_async (gpointer data) { GnomeCanvasItem *item = GNOME_CANVAS_ITEM (data); if (gnome_canvas_item_check_undisposed (item)) { BstCanvasSource *csource = BST_CANVAS_SOURCE (item); GnomeCanvasGroup *group = GNOME_CANVAS_GROUP (csource); /* keep in mind, that creation order affects stacking */ /* add input and output channel items */ if (!csource->built_ichannels) { csource->built_ichannels = TRUE; bst_canvas_source_build_channels (csource, TRUE, /* input channels */ 0xffff00, 0x808000, /* ichannels */ 0x00afff, 0x005880, /* jchannels */ TRUE, FALSE); return TRUE; } if (!csource->built_ochannels) { csource->built_ochannels = TRUE; bst_canvas_source_build_channels (csource, FALSE, /* output channels */ 0xff0000, 0x800000, /* ochannels */ 0, 0, /* unused */ TRUE, FALSE); return TRUE; } /* add icon to group */ if (!csource->icon_item) { csource->icon_item = g_object_connect (gnome_canvas_item_new (group, GNOME_TYPE_CANVAS_PIXBUF, "x", ICON_X (csource), "y", ICON_Y (csource), "width", ICON_WIDTH (csource), "height", ICON_HEIGHT (csource), NULL), "signal::destroy", gtk_widget_destroyed, &csource->icon_item, "swapped_signal::event", bst_canvas_source_child_event, csource, NULL); source_icon_changed (csource); return TRUE; } if (!csource->text) { /* add text item, invoke name_changed callback to setup the text value */ guint ocolor = csource->source && bse_item_internal (csource->source) ? RGBA_INTERNAL : RGBA_BLACK; csource->text = gnome_canvas_item_new (group, GNOME_TYPE_CANVAS_TEXT, "fill_color_rgba", ocolor, "anchor", GTK_ANCHOR_NORTH, "justification", GTK_JUSTIFY_CENTER, "x", TEXT_X (csource), "y", TEXT_Y (csource), "font", TEXT_FONT, NULL); g_object_connect (csource->text, "signal::destroy", gtk_widget_destroyed, &csource->text, "swapped_signal::event", bst_canvas_source_child_event, csource, NULL); gnome_canvas_text_set_zoom_size (GNOME_CANVAS_TEXT (csource->text), FONT_HEIGHT); source_name_changed (csource); return TRUE; } /* add input and output channel hints */ if (!csource->built_ihints) { csource->built_ihints = TRUE; bst_canvas_source_build_channels (csource, TRUE, /* input channels */ 0xffff00, 0x808000, /* ichannels */ 0x00afff, 0x005880, /* jchannels */ FALSE, TRUE); return TRUE; } if (!csource->built_ohints) { csource->built_ohints = TRUE; bst_canvas_source_build_channels (csource, FALSE, /* output channels */ 0xff0000, 0x800000, /* ochannels */ 0, 0, /* unused */ FALSE, TRUE); return TRUE; } } GnomeCanvas *canvas = g_object_steal_data (item, "bst-workaround-canvas-ref"); g_object_unref (item); if (canvas) g_object_unref (canvas); /* canvases don't properly protect their items */ return FALSE; }
static void bst_canvas_source_build_channels (BstCanvasSource *csource, gboolean is_input, gint color1, gint color1_fade, gint color2, gint color2_fade, gboolean build_channel_items, gboolean build_channel_hints) { GnomeCanvasGroup *group = GNOME_CANVAS_GROUP (csource); const guint alpha = 0xa0; gint n_channels, color1_delta = 0, color2_delta = 0; gdouble x1, x2, y1, y2; gdouble d_y; gboolean east_channel = CHANNEL_EAST (csource, is_input); guint i; if (is_input) { n_channels = bse_source_n_ichannels (csource->source); x1 = ICHANNEL_X (csource); y1 = ICHANNEL_Y (csource); } else { n_channels = bse_source_n_ochannels (csource->source); x1 = OCHANNEL_X (csource); y1 = OCHANNEL_Y (csource); } x2 = x1 + CHANNEL_WIDTH (csource); y2 = y1 + CHANNEL_HEIGHT (csource); d_y = y2 - y1; if (n_channels) d_y /= n_channels; if (n_channels > 1) { gint cd_red, cd_blue, cd_green; cd_red = ((color1_fade & 0xff0000) - (color1 & 0xff0000)) / (n_channels - 1); cd_green = ((color1_fade & 0x00ff00) - (color1 & 0x00ff00)) / (n_channels - 1); cd_blue = ((color1_fade & 0x0000ff) - (color1 & 0x0000ff)) / (n_channels - 1); color1_delta = (cd_red & ~0xffff) + (cd_green & ~0xff) + cd_blue; cd_red = ((color2_fade & 0xff0000) - (color2 & 0xff0000)) / (n_channels - 1); cd_green = ((color2_fade & 0x00ff00) - (color2 & 0x00ff00)) / (n_channels - 1); cd_blue = ((color2_fade & 0x0000ff) - (color2 & 0x0000ff)) / (n_channels - 1); color2_delta = (cd_red & ~0xffff) + (cd_green & ~0xff) + cd_blue; } else if (n_channels == 0) { GnomeCanvasItem *item; if (build_channel_items) { item = g_object_connect (gnome_canvas_item_new (group, GNOME_TYPE_CANVAS_RECT, "fill_color_rgba", (0xc3c3c3 << 8) | alpha, "outline_color_rgba", RGBA_BLACK, "x1", x1, "y1", y1, "x2", x2, "y2", y2, NULL), "swapped_signal::destroy", channel_item_remove, csource, "swapped_signal::event", bst_canvas_source_child_event, csource, NULL); csource->channel_items = g_slist_prepend (csource->channel_items, item); } } for (i = 0; i < n_channels; i++) { GnomeCanvasItem *item; gboolean is_jchannel = is_input && bse_source_is_joint_ichannel_by_id (csource->source, i); const gchar *label = (is_input ? bse_source_ichannel_label : bse_source_ochannel_label) (csource->source, i); guint tmp_color = is_jchannel ? color2 : color1; y2 = y1 + d_y; if (build_channel_items) { item = gnome_canvas_item_new (group, GNOME_TYPE_CANVAS_RECT, "fill_color_rgba", (tmp_color << 8) | alpha, "outline_color_rgba", RGBA_BLACK, "x1", x1, "y1", y1, "x2", x2, "y2", y2, NULL); g_object_connect (item, "swapped_signal::destroy", channel_item_remove, csource, "swapped_signal::event", bst_canvas_source_child_event, csource, NULL); csource->channel_items = g_slist_prepend (csource->channel_items, item); } if (build_channel_hints) { item = gnome_canvas_item_new (group, GNOME_TYPE_CANVAS_TEXT, "fill_color_rgba", (0x000000 << 8) | 0x80, "anchor", east_channel ? GTK_ANCHOR_WEST : GTK_ANCHOR_EAST, "justification", GTK_JUSTIFY_RIGHT, "x", east_channel ? TOTAL_WIDTH (csource) + BORDER_PAD * 2. : -BORDER_PAD, "y", (y1 + y2) / 2., "font", CHANNEL_FONT, "text", csource->show_hints ? label : "", NULL); g_object_connect (item, "swapped_signal::destroy", channel_name_remove, csource, NULL); gnome_canvas_text_set_zoom_size (GNOME_CANVAS_TEXT (item), FONT_HEIGHT); g_object_set_data_full (G_OBJECT (item), "hint_text", g_strdup (label), g_free); csource->channel_hints = g_slist_prepend (csource->channel_hints, item); } color1 += color1_delta; color2 += color2_delta; y1 = y2; } }
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); }
/* Handles the events on the ETableClickToAdd, particularly * it creates the ETableItem and passes in some events. */ static gint etcta_event (GnomeCanvasItem *item, GdkEvent *e) { ETableClickToAdd *etcta = E_TABLE_CLICK_TO_ADD (item); switch (e->type) { case GDK_FOCUS_CHANGE: if (!e->focus_change.in) return TRUE; /* coverity[fallthrough] */ case GDK_BUTTON_PRESS: if (etcta->text) { g_object_run_dispose (G_OBJECT (etcta->text)); etcta->text = NULL; } if (etcta->rect) { g_object_run_dispose (G_OBJECT (etcta->rect)); etcta->rect = NULL; } if (!etcta->row) { ETableModel *one; one = e_table_one_new (etcta->model); etcta_add_one (etcta, one); g_object_unref (one); e_selection_model_clear (E_SELECTION_MODEL (etcta->selection)); etcta->row = gnome_canvas_item_new ( GNOME_CANVAS_GROUP (item), e_table_item_get_type (), "ETableHeader", etcta->eth, "ETableModel", etcta->one, "minimum_width", etcta->width, "horizontal_draw_grid", TRUE, "vertical_draw_grid", TRUE, "selection_model", etcta->selection, "cursor_mode", E_CURSOR_SPREADSHEET, NULL); g_signal_connect ( etcta->row, "key_press", G_CALLBACK (item_key_press), etcta); e_signal_connect_notify ( etcta->row, "notify::is-editing", G_CALLBACK (table_click_to_add_row_is_editing_changed_cb), etcta); e_canvas_item_grab_focus (GNOME_CANVAS_ITEM (etcta->row), TRUE); set_initial_selection (etcta); g_object_notify (G_OBJECT (etcta), "is-editing"); } break; case GDK_KEY_PRESS: switch (e->key.keyval) { case GDK_KEY_Tab: case GDK_KEY_KP_Tab: case GDK_KEY_ISO_Left_Tab: finish_editing (etcta); break; default: return FALSE; case GDK_KEY_Escape: if (etcta->row) { e_table_item_leave_edit (E_TABLE_ITEM (etcta->row)); etcta_drop_one (etcta); g_object_run_dispose (G_OBJECT (etcta->row)); etcta->row = NULL; create_rect_and_text (etcta); e_canvas_item_move_absolute (etcta->text, 3, 3); } break; } break; default: return FALSE; } return TRUE; }