static void
gimp_combo_tag_entry_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
GimpComboTagEntry *entry = GIMP_COMBO_TAG_ENTRY (widget);
GtkStyle *style = gtk_widget_get_style (widget);
GdkColor color;
PangoAttribute *attribute;
if (GTK_WIDGET_CLASS (parent_class)->style_set)
GTK_WIDGET_CLASS (parent_class)->style_set (widget, previous_style);
if (entry->normal_item_attr)
pango_attr_list_unref (entry->normal_item_attr);
entry->normal_item_attr = pango_attr_list_new ();
if (style->font_desc)
{
attribute = pango_attr_font_desc_new (style->font_desc);
pango_attr_list_insert (entry->normal_item_attr, attribute);
}
color = style->text[GTK_STATE_NORMAL];
attribute = pango_attr_foreground_new (color.red, color.green, color.blue);
pango_attr_list_insert (entry->normal_item_attr, attribute);
if (entry->selected_item_attr)
pango_attr_list_unref (entry->selected_item_attr);
entry->selected_item_attr = pango_attr_list_copy (entry->normal_item_attr);
color = style->text[GTK_STATE_SELECTED];
attribute = pango_attr_foreground_new (color.red, color.green, color.blue);
pango_attr_list_insert (entry->selected_item_attr, attribute);
color = style->base[GTK_STATE_SELECTED];
attribute = pango_attr_background_new (color.red, color.green, color.blue);
pango_attr_list_insert (entry->selected_item_attr, attribute);
if (entry->insensitive_item_attr)
pango_attr_list_unref (entry->insensitive_item_attr);
entry->insensitive_item_attr = pango_attr_list_copy (entry->normal_item_attr);
color = style->text[GTK_STATE_INSENSITIVE];
attribute = pango_attr_foreground_new (color.red, color.green, color.blue);
pango_attr_list_insert (entry->insensitive_item_attr, attribute);
color = style->base[GTK_STATE_INSENSITIVE];
attribute = pango_attr_background_new (color.red, color.green, color.blue);
pango_attr_list_insert (entry->insensitive_item_attr, attribute);
entry->selected_item_color = style->base[GTK_STATE_SELECTED];
if (entry->arrow_pixbuf)
{
g_object_unref (entry->arrow_pixbuf);
entry->arrow_pixbuf = NULL;
}
}
JNIEXPORT jlong JNICALL
Java_org_gnome_pango_PangoAttrList_pango_1attr_1list_1copy
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
PangoAttrList* result;
jlong _result;
PangoAttrList* self;
// convert parameter self
self = (PangoAttrList*) _self;
// call function
result = pango_attr_list_copy(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jlong) result;
// and finally
return _result;
}
static void
gnm_notebook_button_ensure_layout (GnmNotebookButton *nbb)
{
const char *text = gtk_label_get_text (GTK_LABEL (nbb));
if (nbb->layout) {
if (strcmp (text, pango_layout_get_text (nbb->layout)) == 0)
return;
pango_layout_set_text (nbb->layout, text, -1);
pango_layout_set_text (nbb->layout_active, text, -1);
} else {
PangoAttrList *attrs, *attrs_active;
PangoAttribute *attr;
PangoFontDescription *desc;
GtkWidget *widget = GTK_WIDGET (nbb);
GtkStyleContext *context =
gtk_widget_get_style_context (widget);
nbb->layout = gtk_widget_create_pango_layout (widget, text);
nbb->layout_active = gtk_widget_create_pango_layout (widget, text);
/* Common */
attrs = pango_attr_list_new ();
if (nbb->bg) {
attr = go_color_to_pango
(go_color_from_gdk_rgba (nbb->bg, NULL),
FALSE);
attr->start_index = 0;
attr->end_index = -1;
pango_attr_list_insert (attrs, attr);
}
attrs_active = pango_attr_list_copy (attrs);
/* Normal */
gtk_style_context_get (context, GTK_STATE_FLAG_NORMAL,
"font", &desc, NULL);
attr = pango_attr_font_desc_new (desc);
attr->start_index = 0;
attr->end_index = -1;
pango_attr_list_insert (attrs, attr);
pango_font_description_free (desc);
pango_layout_set_attributes (nbb->layout, attrs);
pango_attr_list_unref (attrs);
/* Active */
gtk_style_context_get (context, GTK_STATE_FLAG_ACTIVE,
"font", &desc, NULL);
attr = pango_attr_font_desc_new (desc);
attr->start_index = 0;
attr->end_index = -1;
pango_attr_list_insert (attrs_active, attr);
pango_font_description_free (desc);
pango_layout_set_attributes (nbb->layout_active, attrs_active);
pango_attr_list_unref (attrs_active);
}
pango_layout_get_extents (nbb->layout, NULL, &nbb->logical);
pango_layout_get_extents (nbb->layout_active, NULL, &nbb->logical_active);
}
PangoAttrList *
go_pango_translate_attributes (PangoAttrList *attrs)
{
PangoAttrList *n_attrs, *filtered;
if (attrs == NULL)
return NULL;
n_attrs = pango_attr_list_copy (attrs);
filtered = pango_attr_list_filter (n_attrs, filter_func, NULL);
if (filtered == NULL) {
pango_attr_list_unref (n_attrs);
return attrs;
} else {
PangoAttrIterator *iter, *f_iter;
f_iter = pango_attr_list_get_iterator (filtered);
do {
gint f_range_start, f_range_end;
gint range_start, range_end;
/* We need to restart everytime since we are changing n_attrs */
iter = pango_attr_list_get_iterator (n_attrs);
pango_attr_iterator_range (f_iter, &f_range_start,
&f_range_end);
pango_attr_iterator_range (iter, &range_start,
&range_end);
while (range_end <= f_range_start) {
if (!pango_attr_iterator_next (iter))
break;
pango_attr_iterator_range (iter, &range_start,
&range_end);
}
/* Now range_end > f_range_start >= range_start */
go_pango_translate_here (iter, f_iter, n_attrs);
pango_attr_iterator_destroy (iter);
} while (pango_attr_iterator_next (f_iter));
pango_attr_iterator_destroy (f_iter);
}
pango_attr_list_unref (filtered);
return n_attrs;
}
static void
wbcg_edit_init_markup (WBCGtk *wbcg, PangoAttrList *markup)
{
SheetView const *sv;
char const *text;
GnmStyle const *style;
g_return_if_fail (wbcg->edit_line.full_content == NULL);
wbcg->edit_line.markup = markup;
sv = wb_control_cur_sheet_view (GNM_WBC (wbcg));
style = sheet_style_get (sv->sheet, sv->edit_pos.col, sv->edit_pos.row);
wbcg->edit_line.cell_attrs = gnm_style_generate_attrs_full (style);
wbcg->edit_line.full_content = pango_attr_list_copy (wbcg->edit_line.cell_attrs);
pango_attr_list_splice (wbcg->edit_line.full_content, markup, 0, 0);
text = gtk_entry_get_text (wbcg_get_entry (wbcg));
set_cur_fmt (wbcg, strlen (text) - 1);
}
/* This function is used by gtk_text_cell_accessible_get_offset_at_point()
* and gtk_text_cell_accessible_get_character_extents(). There is no
* cached PangoLayout so we must create a temporary one using this function.
*/
static PangoLayout *
create_pango_layout (GtkTextCellAccessible *text)
{
GdkRGBA *foreground_rgba;
PangoAttrList *attr_list, *attributes;
PangoLayout *layout;
PangoUnderline uline, underline;
PangoFontMask mask;
PangoFontDescription *font_desc;
gboolean foreground_set, strikethrough_set, strikethrough;
gboolean scale_set, underline_set, rise_set;
gchar *renderer_text;
gdouble scale;
gint rise;
GtkRendererCellAccessible *gail_renderer;
GtkCellRendererText *gtk_renderer;
gail_renderer = GTK_RENDERER_CELL_ACCESSIBLE (text);
gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
g_object_get (gtk_renderer,
"text", &renderer_text,
"attributes", &attributes,
"foreground-set", &foreground_set,
"foreground-rgba", &foreground_rgba,
"strikethrough-set", &strikethrough_set,
"strikethrough", &strikethrough,
"font-desc", &font_desc,
"scale-set", &scale_set,
"scale", &scale,
"underline-set", &underline_set,
"underline", &underline,
"rise-set", &rise_set,
"rise", &rise,
NULL);
layout = gtk_widget_create_pango_layout (get_widget (text), renderer_text);
if (attributes)
attr_list = pango_attr_list_copy (attributes);
else
attr_list = pango_attr_list_new ();
if (foreground_set)
{
add_attr (attr_list, pango_attr_foreground_new (foreground_rgba->red * 65535,
foreground_rgba->green * 65535,
foreground_rgba->blue * 65535));
}
if (strikethrough_set)
add_attr (attr_list,
pango_attr_strikethrough_new (strikethrough));
mask = pango_font_description_get_set_fields (font_desc);
if (mask & PANGO_FONT_MASK_FAMILY)
add_attr (attr_list,
pango_attr_family_new (pango_font_description_get_family (font_desc)));
if (mask & PANGO_FONT_MASK_STYLE)
add_attr (attr_list, pango_attr_style_new (pango_font_description_get_style (font_desc)));
if (mask & PANGO_FONT_MASK_VARIANT)
add_attr (attr_list, pango_attr_variant_new (pango_font_description_get_variant (font_desc)));
if (mask & PANGO_FONT_MASK_WEIGHT)
add_attr (attr_list, pango_attr_weight_new (pango_font_description_get_weight (font_desc)));
if (mask & PANGO_FONT_MASK_STRETCH)
add_attr (attr_list, pango_attr_stretch_new (pango_font_description_get_stretch (font_desc)));
if (mask & PANGO_FONT_MASK_SIZE)
add_attr (attr_list, pango_attr_size_new (pango_font_description_get_size (font_desc)));
if (scale_set && scale != 1.0)
add_attr (attr_list, pango_attr_scale_new (scale));
if (underline_set)
uline = underline;
else
uline = PANGO_UNDERLINE_NONE;
if (uline != PANGO_UNDERLINE_NONE)
add_attr (attr_list,
pango_attr_underline_new (underline));
if (rise_set)
add_attr (attr_list, pango_attr_rise_new (rise));
pango_layout_set_attributes (layout, attr_list);
pango_layout_set_width (layout, -1);
pango_attr_list_unref (attr_list);
pango_font_description_free (font_desc);
pango_attr_list_unref (attributes);
g_free (renderer_text);
gdk_rgba_free (foreground_rgba);
return layout;
}
void
go_load_pango_attributes_into_buffer (PangoAttrList *markup, GtkTextBuffer *buffer, gchar const *str)
{
PangoAttrIterator * iter;
PangoAttrList *copied_markup;
PangoAttrList *our_markup;
if (markup == NULL)
return;
/* For some styles we create named tags. The names are taken from the Pango enums */
copied_markup = pango_attr_list_copy (markup);
our_markup = pango_attr_list_filter (copied_markup,
go_load_pango_attributes_into_buffer_named_filter,
NULL);
pango_attr_list_unref (copied_markup);
if (our_markup != NULL) {
iter = pango_attr_list_get_iterator (our_markup);
do {
GSList *attr = pango_attr_iterator_get_attrs (iter);
if (attr != NULL) {
GSList *ptr;
gint start, end;
GtkTextIter start_iter, end_iter;
char const *name;
pango_attr_iterator_range (iter, &start, &end);
start = go_load_pango_byte_to_char (str, start);
end = go_load_pango_byte_to_char (str, end);
gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start);
gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end);
for (ptr = attr; ptr != NULL; ptr = ptr->next) {
PangoAttribute *attribute = ptr->data;
GtkTextTag *tag;
int val;
switch (attribute->klass->type) {
case PANGO_ATTR_STYLE:
name = (((PangoAttrInt *)attribute)->value
== PANGO_STYLE_NORMAL)
? "PANGO_STYLE_NORMAL" :
"PANGO_STYLE_ITALIC";
tag = gtk_text_tag_table_lookup
(gtk_text_buffer_get_tag_table (buffer),
name);
gtk_text_buffer_apply_tag (buffer, tag,
&start_iter, &end_iter);
break;
case PANGO_ATTR_STRIKETHROUGH:
name = (((PangoAttrInt *)attribute)->value) ?
"PANGO_STRIKETHROUGH_TRUE" :
"PANGO_STRIKETHROUGH_FALSE";
tag = gtk_text_tag_table_lookup
(gtk_text_buffer_get_tag_table (buffer),
name);
gtk_text_buffer_apply_tag (buffer, tag,
&start_iter, &end_iter);
break;
case PANGO_ATTR_UNDERLINE:
val = ((PangoAttrInt *)attribute)->value;
if (val == PANGO_UNDERLINE_NONE)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_NONE",
&start_iter, &end_iter);
else if (val == PANGO_UNDERLINE_SINGLE)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_SINGLE",
&start_iter, &end_iter);
else if (val == PANGO_UNDERLINE_DOUBLE)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_DOUBLE",
&start_iter, &end_iter);
else if (val == PANGO_UNDERLINE_LOW)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_LOW",
&start_iter, &end_iter);
else if (val == PANGO_UNDERLINE_ERROR)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_ERROR",
&start_iter, &end_iter);
break;
case PANGO_ATTR_WEIGHT:
val = ((PangoAttrInt *)attribute)->value;
if (val < (PANGO_WEIGHT_THIN + PANGO_WEIGHT_ULTRALIGHT)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_THIN",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_ULTRALIGHT + PANGO_WEIGHT_LIGHT)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_ULTRALIGHT",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_LIGHT + PANGO_WEIGHT_BOOK)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_LIGHT",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_BOOK + PANGO_WEIGHT_NORMAL)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_BOOK",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_NORMAL + PANGO_WEIGHT_MEDIUM)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_NORMAL",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_MEDIUM + PANGO_WEIGHT_SEMIBOLD)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_MEDIUM",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_SEMIBOLD + PANGO_WEIGHT_BOLD)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_SEMIBOLD",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_BOLD + PANGO_WEIGHT_ULTRABOLD)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_BOLD",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_ULTRABOLD + PANGO_WEIGHT_HEAVY)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_ULTRABOLD",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_HEAVY + PANGO_WEIGHT_ULTRAHEAVY)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_HEAVY",
&start_iter, &end_iter);
else gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_ULTRAHEAVY",
&start_iter, &end_iter);
break;
default:
break;
}
}
g_slist_free_full (attr, (GDestroyNotify)pango_attribute_destroy);
}
} while (pango_attr_iterator_next (iter));
pango_attr_iterator_destroy (iter);
pango_attr_list_unref (our_markup);
}
/* For other styles (that are not at true/false type styles) we use unnamed styles */
copied_markup = pango_attr_list_copy (markup);
our_markup = pango_attr_list_filter (copied_markup,
go_load_pango_attributes_into_buffer_filter,
NULL);
pango_attr_list_unref (copied_markup);
if (our_markup != NULL) {
iter = pango_attr_list_get_iterator (our_markup);
do {
GSList *attr = pango_attr_iterator_get_attrs (iter);
if (attr != NULL) {
char *string;
GSList *ptr;
gint start, end;
GtkTextIter start_iter, end_iter;
GtkTextTag *tag = gtk_text_buffer_create_tag (buffer, NULL, NULL);
for (ptr = attr; ptr != NULL; ptr = ptr->next) {
PangoAttribute *attribute = ptr->data;
switch (attribute->klass->type) {
case PANGO_ATTR_FOREGROUND:
string = pango_color_to_string
(&((PangoAttrColor *)attribute)->color);
g_object_set (G_OBJECT (tag),
"foreground", string,
"foreground-set", TRUE,
NULL);
g_free (string);
break;
case PANGO_ATTR_RISE:
g_object_set (G_OBJECT (tag),
"rise",
((PangoAttrInt *)attribute)->value,
"rise-set", TRUE,
NULL);
break;
default:
break;
}
}
pango_attr_iterator_range (iter, &start, &end);
start = go_load_pango_byte_to_char (str, start);
end = go_load_pango_byte_to_char (str, end);
gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start);
gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end);
gtk_text_buffer_apply_tag (buffer, tag, &start_iter, &end_iter);
g_slist_free_full (attr, (GDestroyNotify)pango_attribute_destroy);
}
} while (pango_attr_iterator_next (iter));
pango_attr_iterator_destroy (iter);
pango_attr_list_unref (our_markup);
}
}
static gboolean
gimp_tag_popup_list_expose (GtkWidget *widget,
GdkEventExpose *event,
GimpTagPopup *popup)
{
GdkWindow *window = gtk_widget_get_window (widget);
GtkStyle *style = gtk_widget_get_style (widget);
cairo_t *cr;
PangoAttribute *attribute;
PangoAttrList *attributes;
gint i;
cr = gdk_cairo_create (event->window);
gdk_cairo_region (cr, event->region);
cairo_clip (cr);
cairo_set_line_width (cr, 1.0);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
for (i = 0; i < popup->tag_count; i++)
{
PopupTagData *tag_data = &popup->tag_data[i];
pango_layout_set_text (popup->layout,
gimp_tag_get_name (tag_data->tag), -1);
switch (tag_data->state)
{
case GTK_STATE_SELECTED:
attributes = pango_attr_list_copy (popup->combo_entry->selected_item_attr);
break;
case GTK_STATE_INSENSITIVE:
attributes = pango_attr_list_copy (popup->combo_entry->insensitive_item_attr);
break;
default:
attributes = pango_attr_list_copy (popup->combo_entry->normal_item_attr);
break;
}
if (tag_data == popup->prelight &&
tag_data->state != GTK_STATE_INSENSITIVE)
{
attribute = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
pango_attr_list_insert (attributes, attribute);
}
pango_layout_set_attributes (popup->layout, attributes);
pango_attr_list_unref (attributes);
if (tag_data->state == GTK_STATE_SELECTED)
{
gdk_cairo_set_source_color (cr,
&popup->combo_entry->selected_item_color);
cairo_rectangle (cr,
tag_data->bounds.x - 1,
tag_data->bounds.y - popup->scroll_y,
tag_data->bounds.width + 2,
tag_data->bounds.height);
cairo_fill (cr);
cairo_translate (cr, 0.5, 0.5);
cairo_move_to (cr,
tag_data->bounds.x,
tag_data->bounds.y - popup->scroll_y - 1);
cairo_line_to (cr,
tag_data->bounds.x + tag_data->bounds.width - 1,
tag_data->bounds.y - popup->scroll_y - 1);
cairo_move_to (cr,
tag_data->bounds.x,
tag_data->bounds.y - popup->scroll_y + tag_data->bounds.height);
cairo_line_to (cr,
tag_data->bounds.x + tag_data->bounds.width - 1,
tag_data->bounds.y - popup->scroll_y + tag_data->bounds.height);
cairo_stroke (cr);
cairo_translate (cr, -0.5, -0.5);
}
cairo_move_to (cr,
(tag_data->bounds.x +
GIMP_TAG_POPUP_PADDING),
(tag_data->bounds.y -
popup->scroll_y +
GIMP_TAG_POPUP_PADDING));
pango_cairo_show_layout (cr, popup->layout);
if (tag_data == popup->prelight &&
tag_data->state != GTK_STATE_INSENSITIVE &&
! popup->single_select_disabled)
{
gtk_paint_focus (style, window,
tag_data->state,
&event->area, widget, NULL,
tag_data->bounds.x,
tag_data->bounds.y - popup->scroll_y,
tag_data->bounds.width,
tag_data->bounds.height);
}
}
cairo_destroy (cr);
return FALSE;
}
/*
* This function is used by gail_text_cell_get_offset_at_point()
* and gail_text_cell_get_character_extents(). There is no
* cached PangoLayout for gailtextcell so we must create a temporary
* one using this function.
*/
static PangoLayout*
create_pango_layout(GtkCellRendererText *gtk_renderer,
GtkWidget *widget)
{
PangoAttrList *attr_list;
PangoLayout *layout;
PangoUnderline uline;
PangoFontMask mask;
layout = gtk_widget_create_pango_layout (widget, gtk_renderer->text);
if (gtk_renderer->extra_attrs)
attr_list = pango_attr_list_copy (gtk_renderer->extra_attrs);
else
attr_list = pango_attr_list_new ();
if (gtk_renderer->foreground_set)
{
PangoColor color;
color = gtk_renderer->foreground;
add_attr (attr_list, pango_attr_foreground_new (color.red,
color.green, color.blue));
}
if (gtk_renderer->strikethrough_set)
add_attr (attr_list,
pango_attr_strikethrough_new (gtk_renderer->strikethrough));
mask = pango_font_description_get_set_fields (gtk_renderer->font);
if (mask & PANGO_FONT_MASK_FAMILY)
add_attr (attr_list,
pango_attr_family_new (pango_font_description_get_family (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_STYLE)
add_attr (attr_list, pango_attr_style_new (pango_font_description_get_style (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_VARIANT)
add_attr (attr_list, pango_attr_variant_new (pango_font_description_get_variant (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_WEIGHT)
add_attr (attr_list, pango_attr_weight_new (pango_font_description_get_weight (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_STRETCH)
add_attr (attr_list, pango_attr_stretch_new (pango_font_description_get_stretch (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_SIZE)
add_attr (attr_list, pango_attr_size_new (pango_font_description_get_size (gtk_renderer->font)));
if (gtk_renderer->scale_set &&
gtk_renderer->font_scale != 1.0)
add_attr (attr_list, pango_attr_scale_new (gtk_renderer->font_scale));
if (gtk_renderer->underline_set)
uline = gtk_renderer->underline_style;
else
uline = PANGO_UNDERLINE_NONE;
if (uline != PANGO_UNDERLINE_NONE)
add_attr (attr_list,
pango_attr_underline_new (gtk_renderer->underline_style));
if (gtk_renderer->rise_set)
add_attr (attr_list, pango_attr_rise_new (gtk_renderer->rise));
pango_layout_set_attributes (layout, attr_list);
pango_layout_set_width (layout, -1);
pango_attr_list_unref (attr_list);
return layout;
}
static void
text_entry_update_layout(struct text_entry *entry)
{
char *text;
PangoAttrList *attr_list;
assert(entry->cursor <= (strlen(entry->text) +
(entry->preedit.text ? strlen(entry->preedit.text) : 0)));
if (entry->preedit.text) {
text = malloc(strlen(entry->text) + strlen(entry->preedit.text) + 1);
strncpy(text, entry->text, entry->cursor);
strcpy(text + entry->cursor, entry->preedit.text);
strcpy(text + entry->cursor + strlen(entry->preedit.text),
entry->text + entry->cursor);
} else {
text = strdup(entry->text);
}
if (entry->cursor != entry->anchor) {
int start_index = MIN(entry->cursor, entry->anchor);
int end_index = MAX(entry->cursor, entry->anchor);
PangoAttribute *attr;
attr_list = pango_attr_list_copy(entry->preedit.attr_list);
if (!attr_list)
attr_list = pango_attr_list_new();
attr = pango_attr_background_new(0.3 * 65535, 0.3 * 65535, 65535);
attr->start_index = start_index;
attr->end_index = end_index;
pango_attr_list_insert(attr_list, attr);
attr = pango_attr_foreground_new(65535, 65535, 65535);
attr->start_index = start_index;
attr->end_index = end_index;
pango_attr_list_insert(attr_list, attr);
} else {
attr_list = pango_attr_list_ref(entry->preedit.attr_list);
}
if (entry->preedit.text && !entry->preedit.attr_list) {
PangoAttribute *attr;
if (!attr_list)
attr_list = pango_attr_list_new();
attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
attr->start_index = entry->cursor;
attr->end_index = entry->cursor + strlen(entry->preedit.text);
pango_attr_list_insert(attr_list, attr);
}
if (entry->layout) {
pango_layout_set_text(entry->layout, text, -1);
pango_layout_set_attributes(entry->layout, attr_list);
}
free(text);
pango_attr_list_unref(attr_list);
}
static PangoLayout*
create_layout(HippoCanvasText *text,
int allocation_width)
{
HippoCanvasBox *box = HIPPO_CANVAS_BOX(text);
PangoLayout *layout;
HippoCanvasStyle *style = hippo_canvas_context_get_style(HIPPO_CANVAS_CONTEXT(text));
g_return_val_if_fail(box->context != NULL, NULL);
layout = hippo_canvas_context_create_layout(box->context);
if (box->font_desc) {
PangoFontDescription *merged = pango_font_description_copy(hippo_canvas_style_get_font(style));
pango_font_description_merge(merged, box->font_desc, TRUE);
pango_layout_set_font_description(layout, merged);
pango_font_description_free(merged);
} else {
pango_layout_set_font_description(layout, hippo_canvas_style_get_font(style));
}
{
PangoAttrList *attrs;
HippoTextDecoration decoration = hippo_canvas_style_get_text_decoration(style);
if (text->attributes)
attrs = pango_attr_list_copy(text->attributes);
else
attrs = pango_attr_list_new();
if (ABS(1.0 - text->font_scale) > .000001) {
PangoAttribute *attr = pango_attr_scale_new(text->font_scale);
attr->start_index = 0;
attr->end_index = G_MAXUINT;
pango_attr_list_insert(attrs, attr);
}
if ((decoration & HIPPO_TEXT_DECORATION_UNDERLINE) != 0) {
PangoAttribute *attr = pango_attr_underline_new(TRUE);
attr->start_index = 0;
attr->end_index = G_MAXUINT;
pango_attr_list_insert(attrs, attr);
}
if ((decoration & HIPPO_TEXT_DECORATION_LINE_THROUGH) != 0) {
PangoAttribute *attr = pango_attr_strikethrough_new(TRUE);
attr->start_index = 0;
attr->end_index = G_MAXUINT;
pango_attr_list_insert(attrs, attr);
}
pango_layout_set_attributes(layout, attrs);
pango_attr_list_unref(attrs);
}
if (text->text != NULL) {
pango_layout_set_text(layout, text->text, -1);
}
if (allocation_width >= 0) {
int layout_width, layout_height;
pango_layout_get_size(layout, &layout_width, &layout_height);
layout_width /= PANGO_SCALE;
layout_height /= PANGO_SCALE;
/* Force layout smaller if required, but we don't want to make
* the layout _wider_ because it breaks alignment, so only do
* this if required.
*/
if (layout_width > allocation_width) {
pango_layout_set_width(layout, allocation_width * PANGO_SCALE);
/* If we set ellipsize, then it overrides wrapping. If we get
* too-small allocation for HIPPO_CANVAS_SIZE_FULL_WIDTH, then
* we want to ellipsize instead of wrapping.
*/
if (text->size_mode == HIPPO_CANVAS_SIZE_WRAP_WORD) {
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
} else {
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
}
/* For now if we say ellipsize end, we always just want one line.
* Maybe this should be an orthogonal property?
*/
if (text->size_mode == HIPPO_CANVAS_SIZE_ELLIPSIZE_END) {
pango_layout_set_single_paragraph_mode(layout, TRUE);
/* Pango's line separator character in this case is ugly, so we
* fix it. Not a very efficient approach, but oh well.
*/
if (text->text != NULL) {
char *new_text = remove_newlines(text->text);
/* avoid making the layout recompute everything
* if we didn't have newlines anyhow
*/
if (strcmp(text->text, new_text) != 0) {
pango_layout_set_text(layout, new_text, -1);
}
g_free(new_text);
}
}
}
}
return layout;
}
/**
* wbcg_edit_finish:
* @wbcg: #WBCGtk
* @result: what should we do with the content
* @showed_dialog: If non-NULL will indicate if a dialog was displayed.
*
* Return: TRUE if editing completed successfully, or we were no editing.
**/
gboolean
wbcg_edit_finish (WBCGtk *wbcg, WBCEditResult result,
gboolean *showed_dialog)
{
Sheet *sheet;
SheetView *sv;
WorkbookControl *wbc;
WorkbookView *wbv;
g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
wbc = GNM_WBC (wbcg);
wbv = wb_control_view (wbc);
wbcg_focus_cur_scg (wbcg);
gnm_expr_entry_close_tips (wbcg_get_entry_logical (wbcg));
if (showed_dialog != NULL)
*showed_dialog = FALSE;
/* Remove the range selection cursor if it exists */
if (NULL != wbcg->rangesel)
scg_rangesel_stop (wbcg->rangesel, result == WBC_EDIT_REJECT);
if (!wbcg_is_editing (wbcg)) {
/* We may have a guru up even if we are not editing. remove it.
* Do NOT remove until later it if we are editing, it is possible
* that we may want to continue editing.
*/
if (wbcg->edit_line.guru != NULL) {
GtkWidget *w = wbcg->edit_line.guru;
wbc_gtk_detach_guru (wbcg);
gtk_widget_destroy (w);
}
return TRUE;
}
g_return_val_if_fail (IS_SHEET (wbcg->editing_sheet), TRUE);
sheet = wbcg->editing_sheet;
sv = sheet_get_view (sheet, wbv);
/* Save the results before changing focus */
if (result != WBC_EDIT_REJECT) {
ValidationStatus valid = GNM_VALIDATION_STATUS_VALID;
char *free_txt = NULL;
char const *txt;
GnmStyle const *mstyle;
char const *expr_txt = NULL;
GOFormat const *fmt;
GnmValue *value;
GOUndo *u = NULL;
GSList *selection = selection_get_ranges (sv, FALSE);
GnmParsePos pp;
GnmExprTop const *texpr = NULL;
parse_pos_init_editpos (&pp, sv);
/* Array only works on single range. */
if (result == WBC_EDIT_ACCEPT_ARRAY &&
(selection == NULL || selection->next != NULL))
result = WBC_EDIT_ACCEPT_RANGE;
/******* Check whether we would split a range ********/
switch (result) {
case (WBC_EDIT_ACCEPT_RANGE):
case (WBC_EDIT_ACCEPT_ARRAY): {
if (sheet_ranges_split_region (sheet, selection,
GO_CMD_CONTEXT (wbc), _("Set Text"))) {
range_fragment_free (selection);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
return FALSE;
}
if (result == WBC_EDIT_ACCEPT_ARRAY &&
sheet_range_contains_merges_or_arrays
(sheet, selection->data,
GO_CMD_CONTEXT (wbc), _("Set Text"),
TRUE, FALSE)) {
range_fragment_free (selection);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
return FALSE;
}
break;
}
case (WBC_EDIT_ACCEPT_WO_AC):
case (WBC_EDIT_ACCEPT): {
GnmCell const *cell = sheet_cell_get
(sheet, sv->edit_pos.col, sv->edit_pos.row);
if (gnm_cell_is_nonsingleton_array (cell)) {
gnm_cmd_context_error_splits_array (GO_CMD_CONTEXT (wbc),
_("Set Text"), NULL);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
range_fragment_free (selection);
return FALSE;
}
break;
}
case (WBC_EDIT_REJECT):
default:
/* We should not be able to get here! */
break;
}
/******* Check whether the range is locked ********/
switch (result) {
case (WBC_EDIT_ACCEPT_RANGE):
case (WBC_EDIT_ACCEPT_ARRAY): {
if (cmd_selection_is_locked_effective (sheet, selection, wbc,
_("Set Text"))) {
range_fragment_free (selection);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
return FALSE;
}
break;
}
case (WBC_EDIT_ACCEPT_WO_AC):
case (WBC_EDIT_ACCEPT): {
GnmRange r;
r.end = r.start = pp.eval;
if (cmd_cell_range_is_locked_effective (sheet, &r, wbc,
_("Set Text"))) {
range_fragment_free (selection);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
return FALSE;
}
break;
}
case (WBC_EDIT_REJECT):
default:
/* We should not be able to get here! */
break;
}
/*****************************************************/
txt = wbcg_edit_get_display_text (wbcg);
mstyle = sheet_style_get (sheet, sv->edit_pos.col, sv->edit_pos.row);
fmt = gnm_cell_get_format (sheet_cell_fetch (sheet, sv->edit_pos.col,
sv->edit_pos.row));
value = format_match (txt, fmt,
workbook_date_conv (sheet->workbook));
if (value == NULL)
expr_txt = gnm_expr_char_start_p (txt);
else
value_release (value);
/* NOTE : do not modify gnm_expr_char_start_p to exclude "-"
* it _can_ start an expression, which is required for rangesel
* it just isn't an expression. */
if (expr_txt != NULL && *expr_txt != '\0' && strcmp (expr_txt, "-")) {
GnmExprTop const *texpr_test = NULL;
GnmParseError perr;
parse_error_init (&perr);
texpr_test = gnm_expr_parse_str (expr_txt,
&pp, GNM_EXPR_PARSE_DEFAULT, NULL, &perr);
/* Try adding a single extra closing paren to see if it helps */
if (texpr_test == NULL && perr.err != NULL &&
perr.err->code == PERR_MISSING_PAREN_CLOSE) {
GnmParseError tmp_err;
char *tmp = g_strconcat (txt, ")", NULL);
parse_error_init (&tmp_err);
texpr_test = gnm_expr_parse_str (gnm_expr_char_start_p (tmp),
&pp, GNM_EXPR_PARSE_DEFAULT,
NULL, &tmp_err);
parse_error_free (&tmp_err);
if (texpr_test != NULL) {
txt = free_txt = tmp;
expr_txt = gnm_expr_char_start_p (txt);
} else
g_free (tmp);
}
if (texpr_test == NULL && perr.err != NULL) {
ValidationStatus reedit;
/* set focus _before_ selection. gtk2 seems to
* screw with selection in gtk_entry_grab_focus
* (no longer required now that we clear
* gtk-entry-select-on-focus) */
gtk_window_set_focus (wbcg_toplevel (wbcg),
(GtkWidget *) wbcg_get_entry (wbcg));
if (perr.begin_char != 0 || perr.end_char != 0) {
int offset = expr_txt - txt;
gtk_editable_select_region (GTK_EDITABLE (wbcg_get_entry (wbcg)),
offset + perr.begin_char,
offset + perr.end_char);
} else
gtk_editable_set_position (
GTK_EDITABLE (wbcg_get_entry (wbcg)), -1);
reedit = wb_control_validation_msg (GNM_WBC (wbcg),
GNM_VALIDATION_STYLE_PARSE_ERROR, NULL,
perr.err->message);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
parse_error_free (&perr);
if (reedit == GNM_VALIDATION_STATUS_INVALID_EDIT) {
range_fragment_free (selection);
return FALSE;
}
/* restore focus to sheet , or we'll leave edit
* mode only to jump right back in the new
* cell because it looks like someone just
* focused on the edit line (eg hit F2) */
wbcg_focus_cur_scg (wbcg);
}
if (texpr_test != NULL)
gnm_expr_top_unref (texpr_test);
}
/* We only enter an array formula if the text is a formula */
if (result == WBC_EDIT_ACCEPT_ARRAY && !expr_txt)
result = WBC_EDIT_ACCEPT_RANGE;
if (result == WBC_EDIT_ACCEPT_ARRAY) {
GnmParsePos pp_array;
GnmRange *r = selection->data;
parse_pos_init (&pp_array, sheet->workbook, sheet, r->start.col, r->start.row);
if ((texpr = gnm_expr_parse_str
(expr_txt, &pp_array, GNM_EXPR_PARSE_DEFAULT,
sheet_get_conventions (sheet), NULL)) == NULL)
result = WBC_EDIT_ACCEPT_RANGE;
}
/* We need to save the information that we will temporarily overwrite */
/* We then assign the information. No need to worry about formatting */
/* Finally we can check the validation! */
switch (result) {
case (WBC_EDIT_ACCEPT_RANGE): {
GSList *l;
for (l = selection; l != NULL; l = l->next) {
GnmRange *r = l->data;
u = go_undo_combine (u, clipboard_copy_range_undo (sheet, r));
}
for (l = selection; l != NULL; l = l->next) {
GnmRange *r = l->data;
/* We do this separately since there may be overlap between ranges */
sheet_range_set_text (&pp, r, txt);
valid = gnm_validation_eval_range (wbc, sheet, &sv->edit_pos, r,
showed_dialog);
if (valid != GNM_VALIDATION_STATUS_VALID)
break;
}
break;
}
case (WBC_EDIT_ACCEPT_ARRAY): {
GnmRange *r = selection->data;
u = go_undo_combine (u, clipboard_copy_range_undo (sheet, r));
if (texpr) {
gnm_expr_top_ref (texpr);
gnm_cell_set_array_formula (sheet,
r->start.col, r->start.row,
r->end.col, r->end.row,
texpr);
sheet_region_queue_recalc (sheet, r);
}
valid = gnm_validation_eval_range (wbc, sheet, &sv->edit_pos, r,
showed_dialog);
break;
}
case (WBC_EDIT_ACCEPT_WO_AC):
case (WBC_EDIT_ACCEPT): {
GnmRange r;
GnmCell *cell;
range_init_cellpos (&r, &sv->edit_pos);
u = clipboard_copy_range_undo (sheet, &r);
cell = sheet_cell_fetch (sheet,
sv->edit_pos.col,
sv->edit_pos.row);
sheet_cell_set_text (cell, txt, wbcg->edit_line.markup);
valid = gnm_validation_eval (wbc, mstyle, sheet, &sv->edit_pos, showed_dialog);
break;
}
case (WBC_EDIT_REJECT):
default:
/* We should not be able to get here! */
break;
}
range_fragment_free (selection);
/* We need to rebuild the original info first. */
go_undo_undo (u);
g_object_unref (u);
/* Now we can respond to our validation information */
if (valid != GNM_VALIDATION_STATUS_VALID) {
result = WBC_EDIT_REJECT;
if (valid == GNM_VALIDATION_STATUS_INVALID_EDIT) {
gtk_window_set_focus (wbcg_toplevel (wbcg),
(GtkWidget *) wbcg_get_entry (wbcg));
g_free (free_txt);
if (texpr != NULL)
gnm_expr_top_unref (texpr);
return FALSE;
}
} else {
if (result == WBC_EDIT_ACCEPT_ARRAY) {
cmd_area_set_array_expr (wbc, sv, texpr);
} else {
PangoAttrList *res_markup = wbcg->edit_line.markup
? pango_attr_list_copy (wbcg->edit_line.markup)
: NULL;
if (result == WBC_EDIT_ACCEPT)
cmd_set_text (wbc, sheet, &sv->edit_pos, txt, res_markup, TRUE);
else if (result == WBC_EDIT_ACCEPT_WO_AC)
cmd_set_text (wbc, sheet, &sv->edit_pos, txt, res_markup, FALSE);
else
cmd_area_set_text (wbc, sv, txt, res_markup);
if (res_markup)
pango_attr_list_unref (res_markup);
}
}
if (texpr != NULL)
gnm_expr_top_unref (texpr);
g_free (free_txt);
} else {
if (sv == wb_control_cur_sheet_view (wbc)) {
/* Redraw the cell contents in case there was a span */
GnmRange tmp; tmp.start = tmp.end = sv->edit_pos;
sheet_range_bounding_box (sv->sheet, &tmp);
sv_redraw_range (wb_control_cur_sheet_view (wbc), &tmp);
}
/* Reload the entry widget with the original contents */
wb_view_edit_line_set (wbv, wbc);
}
/* Stop editing */
wbcg->editing = FALSE;
wbcg->editing_sheet = NULL;
wbcg->editing_cell = NULL;
if (wbcg->edit_line.guru != NULL) {
GtkWidget *w = wbcg->edit_line.guru;
wbc_gtk_detach_guru (wbcg);
gtk_widget_destroy (w);
}
if (wbcg->edit_line.signal_insert) {
g_signal_handler_disconnect (wbcg_get_entry (wbcg),
wbcg->edit_line.signal_insert);
wbcg->edit_line.signal_insert = 0;
}
if (wbcg->edit_line.signal_delete) {
g_signal_handler_disconnect (wbcg_get_entry (wbcg),
wbcg->edit_line.signal_delete);
wbcg->edit_line.signal_delete = 0;
}
if (wbcg->edit_line.signal_cursor_pos) {
g_signal_handler_disconnect (wbcg_get_entry (wbcg),
wbcg->edit_line.signal_cursor_pos);
wbcg->edit_line.signal_cursor_pos = 0;
}
if (wbcg->edit_line.signal_selection_bound) {
g_signal_handler_disconnect (wbcg_get_entry (wbcg),
wbcg->edit_line.signal_selection_bound);
wbcg->edit_line.signal_selection_bound = 0;
}
if (wbcg->edit_line.cell_attrs != NULL) {
pango_attr_list_unref (wbcg->edit_line.cell_attrs);
wbcg->edit_line.cell_attrs = NULL;
}
if (wbcg->edit_line.markup) {
pango_attr_list_unref (wbcg->edit_line.markup);
wbcg->edit_line.markup = NULL;
}
if (wbcg->edit_line.full_content != NULL) {
pango_attr_list_unref (wbcg->edit_line.full_content);
wbcg->edit_line.full_content = NULL;
}
if (wbcg->edit_line.cur_fmt) {
pango_attr_list_unref (wbcg->edit_line.cur_fmt);
wbcg->edit_line.cur_fmt = NULL;
}
/* set pos to 0, to ensure that if we start editing by clicking on the
* editline at the last position, we'll get the right style feedback */
gtk_editable_set_position ((GtkEditable *) wbcg_get_entry (wbcg), 0);
wb_control_update_action_sensitivity (wbc);
if (!sheet->workbook->during_destruction) {
/* restore focus to original sheet in case things were being selected
* on a different page. Do no go through the view, rangesel is
* specific to the control. */
wb_control_sheet_focus (wbc, sheet);
/* Only the edit sheet has an edit cursor */
scg_edit_stop (wbcg_cur_scg (wbcg));
}
wbcg_auto_complete_destroy (wbcg);
wb_control_style_feedback (wbc, NULL); /* in case markup messed with things */
return TRUE;
}
/**
* wbcg_edit_start:
* @wbcg: The workbook to be edited.
* @blankp: If true, erase current cell contents first. If false, leave the
* contents alone.
* @cursorp: If true, create an editing cursor in the current sheet. (If
* false, the text will be editing in the edit box above the sheet,
* but this is not handled by this function.)
*
* Initiate editing of a cell in the sheet. Note that we have two modes of
* editing:
* 1) in-cell editing when you just start typing, and
* 2) above sheet editing when you hit F2.
*
* Returns TRUE if we did indeed start editing. Returns FALSE if the
* cell-to-be-edited was locked.
*/
gboolean
wbcg_edit_start (WBCGtk *wbcg,
gboolean blankp, gboolean cursorp)
{
/* We could save this, but the situation is rare, if confusing. */
static gboolean warn_on_text_format = TRUE;
SheetView *sv;
SheetControlGUI *scg;
GnmCell *cell;
char *text = NULL;
int col, row;
WorkbookView *wbv;
int cursor_pos = -1;
g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
if (wbcg_is_editing (wbcg))
return TRUE;
/* Avoid recursion, and do not begin editing if a guru is up */
if (wbcg->inside_editing || wbc_gtk_get_guru (wbcg) != NULL)
return TRUE;
wbcg->inside_editing = TRUE;
wbv = wb_control_view (GNM_WBC (wbcg));
sv = wb_control_cur_sheet_view (GNM_WBC (wbcg));
scg = wbcg_cur_scg (wbcg);
col = sv->edit_pos.col;
row = sv->edit_pos.row;
/* don't edit a locked cell */
/* TODO : extend this to disable edits that cannot succeed
* like editing a single cell of an array. I think we have enough
* information if we look at the selection.
*/
if (wb_view_is_protected (wbv, TRUE) &&
gnm_style_get_contents_locked (sheet_style_get (sv->sheet, col, row))) {
char *pos = g_strdup_printf ( _("%s!%s is locked"),
sv->sheet->name_quoted, cell_coord_name (col, row));
go_cmd_context_error_invalid (GO_CMD_CONTEXT (wbcg), pos,
wb_view_is_protected (wbv, FALSE)
? _("Unprotect the workbook to enable editing.")
: _("Unprotect the sheet to enable editing."));
wbcg->inside_editing = FALSE;
g_free (pos);
return FALSE;
}
cell = sheet_cell_get (sv->sheet, col, row);
if (cell &&
warn_on_text_format &&
go_format_is_text (gnm_cell_get_format (cell)) &&
(gnm_cell_has_expr (cell) || !VALUE_IS_STRING (cell->value))) {
gint res; /* Using GtkResponseType would yield a warning on the switch */
GtkWidget *check;
GtkWidget *align;
GtkWidget *d = gnm_message_dialog_create
(wbcg_toplevel (wbcg),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING,
_("You are about to edit a cell with \"text\" format."),
_("The cell does not currently contain text, though, so if "
"you go on editing then the contents will be turned into "
"text."));
gtk_dialog_add_button (GTK_DIALOG (d), GTK_STOCK_EDIT, GTK_RESPONSE_OK);
go_gtk_dialog_add_button
(GTK_DIALOG (d), _("Remove format"), GTK_STOCK_REMOVE,
GNM_RESPONSE_REMOVE);
gtk_dialog_add_button (GTK_DIALOG (d), GNM_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_CANCEL);
check = gtk_check_button_new_with_label (_("Show this dialog next time."));
g_signal_connect (check, "toggled", G_CALLBACK (cb_warn_toggled), &warn_on_text_format);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
align = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_container_add (GTK_CONTAINER (align), check);
gtk_widget_show_all (align);
gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (d))), align, TRUE, TRUE, 0);
res = go_gtk_dialog_run (GTK_DIALOG (d), wbcg_toplevel (wbcg));
switch (res) {
case GNM_RESPONSE_REMOVE: {
GnmStyle *style = gnm_style_new ();
gnm_style_set_format (style, go_format_general ());
if (!cmd_selection_format (GNM_WBC (wbcg),
style, NULL, NULL))
break;
/* Fall through. */
}
default:
case GTK_RESPONSE_CANCEL:
wbcg->inside_editing = FALSE;
return FALSE;
case GTK_RESPONSE_OK:
break;
}
}
gnm_app_clipboard_unant ();
if (blankp)
gtk_entry_set_text (wbcg_get_entry (wbcg), "");
else if (cell != NULL) {
gboolean quoted = FALSE;
text = gnm_cell_get_text_for_editing (cell, sv->sheet, "ed, &cursor_pos);
if (text)
gtk_entry_set_text (wbcg_get_entry (wbcg), text);
if (cell->value != NULL) {
GOFormat const *fmt = VALUE_FMT (cell->value);
if (fmt != NULL && go_format_is_markup (fmt)) {
PangoAttrList *markup =
pango_attr_list_copy ((PangoAttrList *)go_format_get_markup (fmt));
if (quoted)
go_pango_attr_list_open_hole (markup, 0, 1);
wbcg_edit_init_markup (wbcg, markup);
}
}
}
gnm_expr_entry_set_scg (wbcg->edit_line.entry, scg);
gnm_expr_entry_set_flags (wbcg->edit_line.entry,
GNM_EE_SHEET_OPTIONAL | GNM_EE_FORMULA_ONLY,
GNM_EE_SINGLE_RANGE | GNM_EE_SHEET_OPTIONAL | GNM_EE_FORMULA_ONLY | GNM_EE_FORCE_REL_REF | GNM_EE_FORCE_ABS_REF);
scg_edit_start (scg);
/* Redraw the cell contents in case there was a span */
sheet_redraw_region (sv->sheet, col, row, col, row);
if (cursorp && /* autocompletion code will not work in the edit line */
wbv->do_auto_completion &&
(text == NULL || g_unichar_isalpha (g_utf8_get_char (text)))) {
wbcg->auto_complete = gnm_complete_sheet_new (
sv->sheet, col, row,
workbook_edit_complete_notify, wbcg);
wbcg->auto_completing = TRUE;
wbcg->auto_max_size = 0;
} else
wbcg->auto_complete = NULL;
/* Give the focus to the edit line */
if (!cursorp)
gtk_window_set_focus (wbcg_toplevel (wbcg),
(GtkWidget *) wbcg_get_entry (wbcg));
wbcg->editing = TRUE;
wbcg->editing_sheet = sv->sheet;
wbcg->editing_cell = cell;
/* If this assert fails, it means editing was not shut down
* properly before
*/
g_return_val_if_fail (wbcg->edit_line.signal_changed == 0, TRUE);
wbcg->edit_line.signal_changed = g_signal_connect (
G_OBJECT (wbcg_get_entry (wbcg)),
"changed",
G_CALLBACK (cb_entry_changed), wbcg);
wbcg->edit_line.signal_insert = g_signal_connect (
G_OBJECT (wbcg_get_entry (wbcg)),
"insert-text",
G_CALLBACK (cb_entry_insert_text), wbcg);
wbcg->edit_line.signal_delete = g_signal_connect (
G_OBJECT (wbcg_get_entry (wbcg)),
"delete-text",
G_CALLBACK (cb_entry_delete_text), wbcg);
wbcg->edit_line.signal_cursor_pos = g_signal_connect_swapped (
G_OBJECT (wbcg_get_entry (wbcg)),
"notify::cursor-position",
G_CALLBACK (cb_entry_cursor_pos), wbcg);
wbcg->edit_line.signal_selection_bound = g_signal_connect_swapped (
G_OBJECT (wbcg_get_entry (wbcg)),
"notify::selection-bound",
G_CALLBACK (cb_entry_cursor_pos), wbcg);
g_free (text);
wb_control_update_action_sensitivity (GNM_WBC (wbcg));
wbcg->inside_editing = FALSE;
gtk_editable_set_position (GTK_EDITABLE (wbcg_get_entry (wbcg)), cursor_pos);
return TRUE;
}
static void
gutter_renderer_text_draw (GtkSourceGutterRenderer *renderer,
cairo_t *cr,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkTextIter *start,
GtkTextIter *end,
GtkSourceGutterRendererState state)
{
GtkSourceGutterRendererText *text = GTK_SOURCE_GUTTER_RENDERER_TEXT (renderer);
gint width;
gint height;
PangoAttrList *attr_list;
gfloat xalign;
gfloat yalign;
GtkSourceGutterRendererAlignmentMode mode;
GtkTextView *view;
gint x = 0;
gint y = 0;
GtkStyleContext *context;
/* Chain up to draw background */
if (GTK_SOURCE_GUTTER_RENDERER_CLASS (gtk_source_gutter_renderer_text_parent_class)->draw != NULL)
{
GTK_SOURCE_GUTTER_RENDERER_CLASS (gtk_source_gutter_renderer_text_parent_class)->draw (renderer,
cr,
background_area,
cell_area,
start,
end,
state);
}
view = gtk_source_gutter_renderer_get_view (renderer);
if (text->priv->is_markup)
{
pango_layout_set_markup (text->priv->cached_layout,
text->priv->text,
-1);
}
else
{
pango_layout_set_text (text->priv->cached_layout,
text->priv->text,
-1);
}
attr_list = pango_layout_get_attributes (text->priv->cached_layout);
if (!attr_list)
{
pango_layout_set_attributes (text->priv->cached_layout,
pango_attr_list_copy (text->priv->cached_attr_list));
}
else
{
pango_attr_list_insert (attr_list,
pango_attribute_copy (text->priv->fg_attr));
}
pango_layout_get_pixel_size (text->priv->cached_layout, &width, &height);
gtk_source_gutter_renderer_get_alignment (renderer,
&xalign,
&yalign);
mode = gtk_source_gutter_renderer_get_alignment_mode (renderer);
switch (mode)
{
case GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL:
x = cell_area->x + (cell_area->width - width) * xalign;
y = cell_area->y + (cell_area->height - height) * yalign;
break;
case GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST:
center_on (renderer,
cell_area,
start,
width,
height,
xalign,
yalign,
&x,
&y);
break;
case GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_LAST:
center_on (renderer,
cell_area,
end,
width,
height,
xalign,
yalign,
&x,
&y);
break;
}
context = gtk_widget_get_style_context (GTK_WIDGET (view));
gtk_render_layout (context, cr, x, y, text->priv->cached_layout);
}
static gboolean
do_tests (CallbackData *data)
{
PangoFontDescription *fd;
static const ClutterColor red = { 0xff, 0x00, 0x00, 0xff };
PangoAttrList *attr_list, *attr_list_copy;
PangoAttribute *attr;
/* TEST 1: change the text */
clutter_text_set_text (CLUTTER_TEXT (data->label), "Counter 0");
pango_layout_set_text (data->test_layout, "Counter 0", -1);
g_assert (check_result (data, "Change text", TRUE) == FALSE);
/* TEST 2: change a single character */
clutter_text_set_text (CLUTTER_TEXT (data->label), "Counter 1");
pango_layout_set_text (data->test_layout, "Counter 1", -1);
g_assert (check_result (data, "Change a single character", TRUE) == FALSE);
/* TEST 3: move the label */
clutter_actor_set_position (data->label, 10, 0);
g_assert (check_result (data, "Move the label", FALSE) == FALSE);
/* TEST 4: change the font */
clutter_text_set_font_name (CLUTTER_TEXT (data->label), "Serif 15");
fd = pango_font_description_from_string ("Serif 15");
pango_layout_set_font_description (data->test_layout, fd);
pango_font_description_free (fd);
g_assert (check_result (data, "Change the font", TRUE) == FALSE);
/* TEST 5: change the color */
clutter_text_set_color (CLUTTER_TEXT (data->label), &red);
g_assert (check_result (data, "Change the color", FALSE) == FALSE);
/* TEST 6: change the attributes */
attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
attr->start_index = 0;
attr->end_index = 2;
attr_list = pango_attr_list_new ();
pango_attr_list_insert (attr_list, attr);
attr_list_copy = pango_attr_list_copy (attr_list);
clutter_text_set_attributes (CLUTTER_TEXT (data->label), attr_list);
pango_layout_set_attributes (data->test_layout, attr_list_copy);
pango_attr_list_unref (attr_list_copy);
pango_attr_list_unref (attr_list);
g_assert (check_result (data, "Change the attributes", TRUE) == FALSE);
/* TEST 7: change the text again */
clutter_text_set_attributes (CLUTTER_TEXT (data->label), NULL);
clutter_text_set_text (CLUTTER_TEXT (data->label), long_text);
pango_layout_set_attributes (data->test_layout, NULL);
pango_layout_set_text (data->test_layout, long_text, -1);
g_assert (check_result (data, "Change the text again", TRUE) == FALSE);
/* TEST 8: enable markup */
clutter_text_set_use_markup (CLUTTER_TEXT (data->label), TRUE);
pango_layout_set_markup (data->test_layout, long_text, -1);
g_assert (check_result (data, "Enable markup", TRUE) == FALSE);
/* This part can't be a test because Clutter won't restrict the
width if wrapping and ellipsizing is disabled so the extents will
be different, but we still want to do it for the later tests */
clutter_actor_set_width (data->label, 200);
pango_layout_set_width (data->test_layout, 200 * PANGO_SCALE);
/* Force a redraw so that changing the width won't affect the
results */
force_redraw (data);
/* TEST 9: enable ellipsize */
clutter_text_set_ellipsize (CLUTTER_TEXT (data->label),
PANGO_ELLIPSIZE_END);
pango_layout_set_ellipsize (data->test_layout, PANGO_ELLIPSIZE_END);
g_assert (check_result (data, "Enable ellipsize", TRUE) == FALSE);
clutter_text_set_ellipsize (CLUTTER_TEXT (data->label),
PANGO_ELLIPSIZE_NONE);
pango_layout_set_ellipsize (data->test_layout, PANGO_ELLIPSIZE_NONE);
force_redraw (data);
/* TEST 10: enable line wrap */
clutter_text_set_line_wrap (CLUTTER_TEXT (data->label), TRUE);
pango_layout_set_wrap (data->test_layout, PANGO_WRAP_WORD);
g_assert (check_result (data, "Enable line wrap", TRUE) == FALSE);
/* TEST 11: change wrap mode
* FIXME - broken
*/
clutter_text_set_line_wrap_mode (CLUTTER_TEXT (data->label),
PANGO_WRAP_CHAR);
pango_layout_set_wrap (data->test_layout, PANGO_WRAP_CHAR);
g_assert (check_result (data, "Change wrap mode", TRUE) == FALSE);
/* TEST 12: enable justify */
clutter_text_set_justify (CLUTTER_TEXT (data->label), TRUE);
pango_layout_set_justify (data->test_layout, TRUE);
/* Pango appears to have a bug which means that you can't change the
justification after setting the text but this fixes it.
See http://bugzilla.gnome.org/show_bug.cgi?id=551865 */
pango_layout_context_changed (data->test_layout);
g_assert (check_result (data, "Enable justify", TRUE) == FALSE);
/* TEST 13: change alignment */
clutter_text_set_line_alignment (CLUTTER_TEXT (data->label),
PANGO_ALIGN_RIGHT);
pango_layout_set_alignment (data->test_layout, PANGO_ALIGN_RIGHT);
g_assert (check_result (data, "Change alignment", TRUE) == FALSE);
clutter_main_quit ();
return FALSE;
}
/**
* gtk_ellipsis_set_label_widget:
* @ellipsis: a #GtkEllipsis
* @label: the new label widget
*
* Set the label widget for the ellipsis. This is the widget
* that will appear embedded alongside the ellipsis arrow.
*
* Since: 2.4
**/
void
gtk_ellipsis_set_label_widget (GtkEllipsis *ellipsis,
GtkWidget *label)
{
GtkEllipsisPrivate *priv;
g_return_if_fail (GTK_IS_ELLIPSIS (ellipsis));
g_return_if_fail (label == NULL || GTK_IS_WIDGET (label));
g_return_if_fail (label == NULL || label->parent == NULL);
priv = ellipsis->priv;
if (priv->label == label)
return;
if (priv->label)
{
gtk_widget_set_state (priv->label, GTK_STATE_NORMAL);
gtk_widget_unparent (priv->label);
}
priv->label = label;
if (label)
{
gfloat xalign, yalign;
gtk_misc_get_alignment (>K_LABEL (label)->misc, &xalign, &yalign);
gtk_misc_set_alignment (>K_LABEL (label)->misc, 0.0, yalign);
gtk_widget_set_parent (label, GTK_WIDGET (ellipsis));
if (!priv->ellipsis_label)
{
GdkColor *link_color, active_bg_color;
GtkWidget *child;
PangoAttrList *attrs;
PangoAttribute *uline;
child = gtk_label_new ("...");
/* Change the foreground color for all states but selected. */
gtk_widget_style_get (GTK_WIDGET (child),
"link-color", &link_color, NULL);
if (!link_color)
{
GtkStyle *style = gtk_widget_get_style (child);
active_bg_color = style->bg[GTK_STATE_SELECTED];
link_color = &active_bg_color;
}
gtk_widget_modify_fg (child, GTK_STATE_NORMAL, link_color);
gtk_widget_modify_fg (child, GTK_STATE_ACTIVE, link_color);
gtk_widget_modify_fg (child, GTK_STATE_PRELIGHT, link_color);
if (link_color != &active_bg_color)
gdk_color_free (link_color);
/* Add an underline. */
attrs = gtk_label_get_attributes (GTK_LABEL (label));
attrs = attrs ? pango_attr_list_copy (attrs) : pango_attr_list_new ();
uline = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
uline->start_index = 0;
uline->end_index = G_MAXUINT;
pango_attr_list_insert (attrs, uline);
gtk_label_set_attributes (GTK_LABEL (child), attrs);
pango_attr_list_unref (attrs);
gtk_widget_show (child);
gtk_widget_set_parent (child, GTK_WIDGET (ellipsis));
priv->ellipsis_label = child;
}
if (priv->prelight)
{
gtk_widget_set_state (label, GTK_STATE_PRELIGHT);
gtk_widget_set_state (priv->ellipsis_label, GTK_STATE_PRELIGHT);
}
}
else
{
if (priv->ellipsis_label)
{
gtk_widget_destroy (priv->ellipsis_label);
priv->ellipsis_label = NULL;
}
}
if (GTK_WIDGET_VISIBLE (ellipsis))
gtk_widget_queue_resize (GTK_WIDGET (ellipsis));
g_object_freeze_notify (G_OBJECT (ellipsis));
g_object_notify (G_OBJECT (ellipsis), "label-widget");
g_object_notify (G_OBJECT (ellipsis), "label");
g_object_thaw_notify (G_OBJECT (ellipsis));
}