static PangoAttrList*
gdip_get_layout_attributes (PangoLayout *layout)
{
PangoAttrList *list = pango_layout_get_attributes (layout);
if (!list)
list = pango_attr_list_new ();
else
pango_attr_list_ref (list);
return list;
}
void rc_ui_scrollable_label_set_attributes(RCUiScrollableLabel *widget,
PangoAttrList *attrs)
{
RCUiScrollableLabelPrivate *priv;
if(widget==NULL) return;
priv = RC_UI_SCROLLABLE_LABEL(widget)->priv;
if(priv==NULL) return;
if(priv->attrs!=NULL)
pango_attr_list_unref(priv->attrs);
priv->attrs = NULL;
if(attrs!=NULL)
{
priv->attrs = attrs;
pango_attr_list_ref(priv->attrs);
}
pango_layout_set_attributes(priv->layout, attrs);
gtk_widget_queue_draw(GTK_WIDGET(widget));
}
JNIEXPORT void JNICALL
Java_org_gnome_pango_PangoAttrList_pango_1attr_1list_1ref
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
PangoAttrList* self;
// convert parameter self
self = (PangoAttrList*) _self;
// call function
pango_attr_list_ref(self);
// cleanup parameter self
}
static void _mt_draw_string(MT_WINDOW *win, MT_STRING *str, int x_offset, int y_offset, MT_COLOR *color)
{
MT_GTK_STRING *s = str;
PangoLayout *layout = s->layout;
int state_type = s->state_type;
if (!color && s->color) color = s->color;
if (color && !pango_layout_get_text(layout)) color = NULL;
if (color) {
PangoAttrList *attrlist;
PangoAttribute *attr;
layout = pango_layout_copy(layout);
attrlist = pango_layout_get_attributes(layout);
if (attrlist) {
pango_attr_list_ref(attrlist);
}
else {
attrlist = pango_attr_list_new();
}
if (color) {
attr = pango_attr_foreground_new(color->r << 8, color->g << 8, color->b << 8);
attr->start_index = 0;
attr->end_index = strlen(pango_layout_get_text(layout));
pango_attr_list_insert_before(attrlist, attr);
}
pango_layout_set_attributes(layout, attrlist);
pango_attr_list_unref(attrlist);
state_type = GTK_STATE_NORMAL;
}
s->parent_class->draw_layout(s->style, (GdkWindow *)win, state_type, s->use_text,
s->area, s->widget, s->detail, s->x + x_offset, s->y + y_offset, layout);
if (color) {
g_object_unref(layout);
}
}
static void
cv_tabs_rename (chan *ch, char *name)
{
PangoAttrList *attr;
GtkWidget *tab = ch->impl;
attr = gtk_label_get_attributes (GTK_LABEL (gtk_bin_get_child (GTK_BIN (tab))));
if (attr)
pango_attr_list_ref (attr);
gtk_button_set_label (GTK_BUTTON (tab), name);
gtk_widget_queue_resize (gtk_widget_get_parent(gtk_widget_get_parent(gtk_widget_get_parent(tab))));
if (attr)
{
gtk_label_set_attributes (GTK_LABEL (gtk_bin_get_child (GTK_BIN (tab))), attr);
pango_attr_list_unref (attr);
}
}
void scim_bridge_client_imcontext_get_preedit_string (GtkIMContext *context, gchar **str, PangoAttrList **pango_attrs, gint *cursor_pos)
{
scim_bridge_pdebugln (4, "scim_bridge_client_imcontext_get_preedit_string ()");
ScimBridgeClientIMContext *imcontext = SCIM_BRIDGE_CLIENT_IMCONTEXT (context);
if (imcontext->slave_preedit) {
gtk_im_context_get_preedit_string (imcontext->slave, str, pango_attrs, cursor_pos);
return;
}
if (scim_bridge_client_is_messenger_opened () && imcontext != NULL && imcontext->preedit_shown) {
const size_t preedit_string_length = strlen (imcontext->preedit_string);
const size_t preedit_wstring_length = g_utf8_strlen (imcontext->preedit_string, -1);
if (str) {
if (preedit_string_length > 0) {
*str = g_strdup (imcontext->preedit_string);
} else {
*str = g_strdup ("");
}
}
if (cursor_pos) {
if (imcontext->preedit_cursor_position > preedit_wstring_length) {
*cursor_pos = preedit_wstring_length;
} else {
*cursor_pos = imcontext->preedit_cursor_position;
}
}
if (pango_attrs) {
*pango_attrs = imcontext->preedit_attributes;
pango_attr_list_ref (imcontext->preedit_attributes);
}
} else {
if (str) *str = g_strdup ("");
if (cursor_pos) *cursor_pos = 0;
if (pango_attrs) *pango_attrs = pango_attr_list_new ();
}
}
static void
text_input_preedit_string(void *data,
struct wl_text_input *text_input,
uint32_t serial,
const char *text,
const char *commit)
{
struct text_entry *entry = data;
if ((entry->serial - serial) > (entry->serial - entry->reset_serial)) {
fprintf(stderr, "Ignore preedit_string. Serial: %u, Current: %u, Reset: %u\n",
serial, entry->serial, entry->reset_serial);
clear_pending_preedit(entry);
return;
}
if (entry->pending_commit.invalid_delete) {
fprintf(stderr, "Ignore preedit_string. Invalid previous delete_surrounding event.\n");
clear_pending_preedit(entry);
return;
}
if (entry->pending_commit.delete_length) {
text_entry_delete_text(entry,
entry->pending_commit.delete_index,
entry->pending_commit.delete_length);
} else {
text_entry_delete_selected_text(entry);
}
text_entry_set_preedit(entry, text, entry->preedit_info.cursor);
entry->preedit.commit = strdup(commit);
entry->preedit.attr_list = pango_attr_list_ref(entry->preedit_info.attr_list);
clear_pending_preedit(entry);
text_entry_update(entry);
widget_schedule_redraw(entry->widget);
}
static void
fcitx_im_context_get_preedit_string(GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
gint *cursor_pos)
{
FcitxLog(LOG_LEVEL, "fcitx_im_context_get_preedit_string");
FcitxIMContext *fcitxcontext = FCITX_IM_CONTEXT(context);
if (fcitx_client_is_valid(fcitxcontext->client)) {
if (str) {
if (fcitxcontext->preedit_string)
*str = strdup(fcitxcontext->preedit_string);
else
*str = strdup("");
}
if (attrs) {
if (fcitxcontext->attrlist == NULL) {
*attrs = pango_attr_list_new();
if (str) {
PangoAttribute *pango_attr;
pango_attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
pango_attr->start_index = 0;
pango_attr->end_index = strlen(*str);
pango_attr_list_insert(*attrs, pango_attr);
}
}
else {
*attrs = pango_attr_list_ref (fcitxcontext->attrlist);
}
}
if (cursor_pos)
*cursor_pos = fcitxcontext->cursor_pos;
} else
gtk_im_context_get_preedit_string(fcitxcontext->slave, str, attrs, cursor_pos);
return ;
}
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 void
hippo_canvas_text_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
HippoCanvasText *text;
text = HIPPO_CANVAS_TEXT(object);
switch (prop_id) {
case PROP_TEXT:
{
const char *new_text;
new_text = g_value_get_string(value);
if (!(new_text == text->text ||
(new_text && text->text && strcmp(new_text, text->text) == 0))) {
g_free(text->text);
text->text = g_strdup(new_text);
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(text));
hippo_canvas_item_emit_paint_needed(HIPPO_CANVAS_ITEM(text), 0, 0, -1, -1);
}
}
break;
case PROP_ATTRIBUTES:
{
PangoAttrList *attrs = g_value_get_boxed(value);
if (attrs)
pango_attr_list_ref(attrs);
if (text->attributes)
pango_attr_list_unref(text->attributes);
text->attributes = attrs;
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(text));
hippo_canvas_item_emit_paint_needed(HIPPO_CANVAS_ITEM(text), 0, 0, -1, -1);
}
break;
case PROP_MARKUP:
{
char *text;
PangoAttrList *attrs;
GError *error = NULL;
if (!pango_parse_markup(g_value_get_string(value),
-1,
0,
&attrs,
&text,
NULL,
&error)) {
g_error("Failed to set markup: %s", error->message);
return;
}
g_object_set(object, "text", text, "attributes", attrs, NULL);
pango_attr_list_unref(attrs);
g_free(text);
}
break;
case PROP_FONT_SCALE:
text->font_scale = g_value_get_double(value);
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(text));
hippo_canvas_item_emit_paint_needed(HIPPO_CANVAS_ITEM(text), 0, 0, -1, -1);
break;
case PROP_SIZE_MODE:
text->size_mode = g_value_get_enum(value);
hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(text));
hippo_canvas_item_emit_paint_needed(HIPPO_CANVAS_ITEM(text), 0, 0, -1, -1);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
gnm_so_path_set_property (GObject *obj, guint param_id,
GValue const *value, GParamSpec *pspec)
{
GnmSOPath *sop = GNM_SO_PATH (obj);
switch (param_id) {
case SOP_PROP_STYLE: {
GOStyle *style = go_style_dup (g_value_get_object (value));
style->interesting_fields = GO_STYLE_OUTLINE | GO_STYLE_FILL;
g_object_unref (sop->style);
sop->style = style;
break;
}
case SOP_PROP_PATH: {
GOPath *path = g_value_get_boxed (value);
if (sop->path)
go_path_free (sop->path);
else if (sop->paths)
g_ptr_array_unref (sop->paths);
sop->path = NULL;
sop->paths = NULL;
if (path) {
cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1);
cairo_t *cr = cairo_create (surface);
sop->path = go_path_ref (path);
/* evaluates the bounding rectangle */
go_path_to_cairo (path, GO_PATH_DIRECTION_FORWARD, cr);
cairo_fill_extents (cr,
&sop->x_offset, &sop->y_offset,
&sop->width, &sop->height);
sop->width -= sop->x_offset;
sop->height -= sop->y_offset;
cairo_destroy (cr);
cairo_surface_destroy (surface);
}
break;
}
case SOP_PROP_PATHS: {
GPtrArray *paths = g_value_get_boxed (value);
unsigned i;
for (i = 0; i < paths->len; i++)
/* we can only check that the path is not NULL */
g_return_if_fail (g_ptr_array_index (paths, i) != NULL);
if (sop->path)
go_path_free (sop->path);
else if (sop->paths)
g_ptr_array_unref (sop->paths);
sop->path = NULL;
sop->paths = NULL;
if (paths) {
cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1);
cairo_t *cr = cairo_create (surface);
sop->paths = g_ptr_array_ref (paths);
/* evaluates the bounding rectangle */
for (i = 0; i < paths->len; i++)
go_path_to_cairo ((GOPath *) g_ptr_array_index (paths, i),
GO_PATH_DIRECTION_FORWARD, cr);
cairo_fill_extents (cr,
&sop->x_offset, &sop->y_offset,
&sop->width, &sop->height);
sop->width -= sop->x_offset;
sop->height -= sop->y_offset;
cairo_destroy (cr);
cairo_surface_destroy (surface);
}
break;
}
case SOP_PROP_TEXT: {
char const *str = g_value_get_string (value);
g_free (sop->text);
sop->text = g_strdup (str == NULL ? "" : str);
break;
}
case SOP_PROP_MARKUP:
if (sop->markup != NULL)
pango_attr_list_unref (sop->markup);
sop->markup = g_value_peek_pointer (value);
if (sop->markup != NULL)
pango_attr_list_ref (sop->markup);
break;
case SOP_PROP_VIEWBOX:
/* not settable */
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, param_id, pspec);
return;
}
}
void RrFontDraw(XftDraw *d, RrTextureText *t, RrRect *area)
{
gint x,y,w;
XftColor c;
gint mw;
PangoRectangle rect;
PangoAttrList *attrlist;
PangoEllipsizeMode ell;
g_assert(!t->flow || t->maxwidth > 0);
y = area->y;
if (!t->flow)
/* center the text vertically
We do this centering based on the 'baseline' since different fonts
have different top edges. It looks bad when the whole string is
moved when 1 character from a non-default language is included in
the string */
y += font_calculate_baseline(t->font, area->height);
/* the +2 and -4 leave a small blank edge on the sides */
x = area->x + 2;
w = area->width;
if (t->flow) w = MAX(w, t->maxwidth);
w -= 4;
/* h = area->height; */
if (t->flow)
ell = PANGO_ELLIPSIZE_NONE;
else {
switch (t->ellipsize) {
case RR_ELLIPSIZE_NONE:
ell = PANGO_ELLIPSIZE_NONE;
break;
case RR_ELLIPSIZE_START:
ell = PANGO_ELLIPSIZE_START;
break;
case RR_ELLIPSIZE_MIDDLE:
ell = PANGO_ELLIPSIZE_MIDDLE;
break;
case RR_ELLIPSIZE_END:
ell = PANGO_ELLIPSIZE_END;
break;
default:
g_assert_not_reached();
}
}
pango_layout_set_text(t->font->layout, t->string, -1);
pango_layout_set_width(t->font->layout, w * PANGO_SCALE);
pango_layout_set_ellipsize(t->font->layout, ell);
pango_layout_set_single_paragraph_mode(t->font->layout, !t->flow);
/* * * end of setting up the layout * * */
pango_layout_get_pixel_extents(t->font->layout, NULL, &rect);
mw = rect.width;
/* pango_layout_set_alignment doesn't work with
pango_xft_render_layout_line */
switch (t->justify) {
case RR_JUSTIFY_LEFT:
break;
case RR_JUSTIFY_RIGHT:
x += (w - mw);
break;
case RR_JUSTIFY_CENTER:
x += (w - mw) / 2;
break;
case RR_JUSTIFY_NUM_TYPES:
g_assert_not_reached();
}
if (t->shadow_offset_x || t->shadow_offset_y) {
/* From nvidia's readme (chapter 23):
When rendering to a 32-bit window, keep in mind that the X RENDER
extension, used by most composite managers, expects "premultiplied
alpha" colors. This means that if your color has components (r,g,b)
and alpha value a, then you must render (a*r, a*g, a*b, a) into the
target window.
*/
c.color.red = (t->shadow_color->r | t->shadow_color->r << 8) *
t->shadow_alpha / 255;
c.color.green = (t->shadow_color->g | t->shadow_color->g << 8) *
t->shadow_alpha / 255;
c.color.blue = (t->shadow_color->b | t->shadow_color->b << 8) *
t->shadow_alpha / 255;
c.color.alpha = 0xffff * t->shadow_alpha / 255;
c.pixel = t->shadow_color->pixel;
/* see below... */
if (!t->flow) {
pango_xft_render_layout_line
(d, &c,
#if PANGO_VERSION_MAJOR > 1 || \
(PANGO_VERSION_MAJOR == 1 && PANGO_VERSION_MINOR >= 16)
pango_layout_get_line_readonly(t->font->layout, 0),
#else
pango_layout_get_line(t->font->layout, 0),
#endif
(x + t->shadow_offset_x) * PANGO_SCALE,
(y + t->shadow_offset_y) * PANGO_SCALE);
}
else {
pango_xft_render_layout(d, &c, t->font->layout,
(x + t->shadow_offset_x) * PANGO_SCALE,
(y + t->shadow_offset_y) * PANGO_SCALE);
}
}
c.color.red = t->color->r | t->color->r << 8;
c.color.green = t->color->g | t->color->g << 8;
c.color.blue = t->color->b | t->color->b << 8;
c.color.alpha = 0xff | 0xff << 8; /* fully opaque text */
c.pixel = t->color->pixel;
if (t->shortcut) {
const gchar *s = t->string + t->shortcut_pos;
t->font->shortcut_underline->start_index = t->shortcut_pos;
t->font->shortcut_underline->end_index = t->shortcut_pos +
(g_utf8_next_char(s) - s);
/* the attributes are owned by the layout.
re-add the attributes to the layout after changing the
start and end index */
attrlist = pango_layout_get_attributes(t->font->layout);
pango_attr_list_ref(attrlist);
pango_layout_set_attributes(t->font->layout, attrlist);
pango_attr_list_unref(attrlist);
}
/* layout_line() uses y to specify the baseline
The line doesn't need to be freed, it's a part of the layout */
if (!t->flow) {
pango_xft_render_layout_line
(d, &c,
#if PANGO_VERSION_MAJOR > 1 || \
(PANGO_VERSION_MAJOR == 1 && PANGO_VERSION_MINOR >= 16)
pango_layout_get_line_readonly(t->font->layout, 0),
#else
pango_layout_get_line(t->font->layout, 0),
#endif
x * PANGO_SCALE,
y * PANGO_SCALE);
}
else {
pango_xft_render_layout(d, &c, t->font->layout,
x * PANGO_SCALE,
y * PANGO_SCALE);
}
if (t->shortcut) {
t->font->shortcut_underline->start_index = 0;
t->font->shortcut_underline->end_index = 0;
/* the attributes are owned by the layout.
re-add the attributes to the layout after changing the
start and end index */
attrlist = pango_layout_get_attributes(t->font->layout);
pango_attr_list_ref(attrlist);
pango_layout_set_attributes(t->font->layout, attrlist);
pango_attr_list_unref(attrlist);
}
}
