ptk-text-renderer.c

台湾人开发的Linux下的文件管理器

    case PROP_ELLIPSIZE:
        celltext->ellipsize = g_value_get_enum ( value );
        celltext->ellipsize_set = TRUE;
        g_object_notify ( object, "ellipsize-set" );
        break;

    case PROP_WRAP_MODE:
        celltext->wrap_mode = g_value_get_enum ( value );
        break;

    case PROP_WRAP_WIDTH:
        celltext->wrap_width = g_value_get_int ( value );
        break;

    case PROP_BACKGROUND_SET:
        celltext->background_set = g_value_get_boolean ( value );
        break;

    case PROP_FOREGROUND_SET:
        celltext->foreground_set = g_value_get_boolean ( value );
        break;

    case PROP_UNDERLINE_SET:
        celltext->underline_set = g_value_get_boolean ( value );
        break;

    case PROP_ELLIPSIZE_SET:
        celltext->ellipsize_set = g_value_get_boolean ( value );
        break;

    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID ( object, param_id, pspec );
        break;
    }
}

/**
 * ptk_text_renderer_new:
 *
 * Creates a new #PtkTextRenderer. Adjust how text is drawn using
 * object properties. Object properties can be
 * set globally (with g_object_set()). Also, with #GtkTreeViewColumn,
 * you can bind a property to a value in a #GtkTreeModel. For example,
 * you can bind the "text" property on the cell renderer to a string
 * value in the model, thus rendering a different string in each row
 * of the #GtkTreeView
 *
 * Return value: the new cell renderer
 **/
GtkCellRenderer *
ptk_text_renderer_new ( void )
{
    return g_object_new ( PTK_TYPE_TEXT_RENDERER, NULL );
}

static void
add_attr ( PangoAttrList *attr_list,
           PangoAttribute *attr )
{
    attr->start_index = 0;
    attr->end_index = G_MAXINT;

    pango_attr_list_insert ( attr_list, attr );
}

static PangoLayout*
get_layout ( PtkTextRenderer *celltext,
             GtkWidget *widget,
             gboolean will_render,
             GtkCellRendererState flags )
{
    PangoAttrList * attr_list;
    PangoLayout *layout;
    PangoUnderline uline;

    layout = gtk_widget_create_pango_layout ( widget, celltext->text );
    pango_layout_set_alignment( layout, PANGO_ALIGN_CENTER );

    attr_list = pango_attr_list_new ();

    if ( will_render )
    {
        /* Add options that affect appearance but not size */

        /* note that background doesn't go here, since it affects
          * background_area not the PangoLayout area
        */

        if ( celltext->foreground_set
                && ( flags & GTK_CELL_RENDERER_SELECTED ) == 0 )
        {
            PangoColor color;

            color = celltext->foreground;

            add_attr ( attr_list,
                       pango_attr_foreground_new ( color.red, color.green, color.blue ) );
        }

    }

    add_attr ( attr_list, pango_attr_font_desc_new ( celltext->font ) );

    if ( celltext->underline_set )
        uline = celltext->underline_style;
    else
        uline = PANGO_UNDERLINE_NONE;

    if ( ( flags & GTK_CELL_RENDERER_PRELIT ) == GTK_CELL_RENDERER_PRELIT )
    {
        switch ( uline )
        {
        case PANGO_UNDERLINE_NONE:
            uline = PANGO_UNDERLINE_SINGLE;
            break;

        case PANGO_UNDERLINE_SINGLE:
            uline = PANGO_UNDERLINE_DOUBLE;
            break;

        default:
            break;
        }
    }

    if ( uline != PANGO_UNDERLINE_NONE )
        add_attr ( attr_list, pango_attr_underline_new ( celltext->underline_style ) );

    if ( celltext->ellipsize_set )
        pango_layout_set_ellipsize ( layout, celltext->ellipsize );
    else
        pango_layout_set_ellipsize ( layout, PANGO_ELLIPSIZE_NONE );

    if ( celltext->wrap_width != -1 )
    {
        pango_layout_set_width ( layout, celltext->wrap_width * PANGO_SCALE );
        pango_layout_set_wrap ( layout, celltext->wrap_mode );

        if ( pango_layout_get_line_count ( layout ) == 1 )
        {
            pango_layout_set_width ( layout, -1 );
            pango_layout_set_wrap ( layout, PANGO_WRAP_CHAR );
        }
    }
    else
    {
        pango_layout_set_width ( layout, -1 );
        pango_layout_set_wrap ( layout, PANGO_WRAP_CHAR );
    }

    pango_layout_set_attributes ( layout, attr_list );

    pango_attr_list_unref ( attr_list );

    return layout;
}

static void
get_size ( GtkCellRenderer *cell,
           GtkWidget *widget,
           GdkRectangle *cell_area,
           PangoLayout *layout,
           gint *x_offset,
           gint *y_offset,
           gint *width,
           gint *height )
{
    PtkTextRenderer * celltext = ( PtkTextRenderer * ) cell;
    PangoRectangle rect;

    if ( layout )
    {
        g_object_ref ( layout );
        pango_layout_set_alignment( layout, PANGO_ALIGN_CENTER );
    }
    else
        layout = get_layout ( celltext, widget, FALSE, 0 );

    pango_layout_get_pixel_extents ( layout, NULL, &rect );

    if ( height )
        * height = cell->ypad * 2 + rect.height;

    /* The minimum size for ellipsized labels is ~ 3 chars */
    if ( width )
    {
        if ( celltext->ellipsize )
        {
            PangoContext * context;
            PangoFontMetrics *metrics;
            gint char_width;

            context = pango_layout_get_context ( layout );
            metrics = pango_context_get_metrics ( context, widget->style->font_desc, pango_context_get_language ( context ) );

            char_width = pango_font_metrics_get_approximate_char_width ( metrics );
            pango_font_metrics_unref ( metrics );

            *width = cell->xpad * 2 + ( PANGO_PIXELS ( char_width ) * 3 );
        }
        else
        {
            *width = cell->xpad * 2 + rect.x + rect.width;
        }
    }

    if ( cell_area )
    {
        if ( x_offset )
        {
            if ( gtk_widget_get_direction ( widget ) == GTK_TEXT_DIR_RTL )
                * x_offset = ( 1.0 - cell->xalign ) * ( cell_area->width - ( rect.x + rect.width + ( 2 * cell->xpad ) ) );
            else
                *x_offset = cell->xalign * ( cell_area->width - ( rect.x + rect.width + ( 2 * cell->xpad ) ) );

            if ( celltext->ellipsize_set || celltext->wrap_width != -1 )
                * x_offset = MAX( *x_offset, 0 );
        }
        if ( y_offset )
        {
            *y_offset = cell->yalign * ( cell_area->height - ( rect.height + ( 2 * cell->ypad ) ) );
            *y_offset = MAX ( *y_offset, 0 );
        }
    }

    g_object_unref ( layout );
}


static void
ptk_text_renderer_get_size ( GtkCellRenderer *cell,
                             GtkWidget *widget,
                             GdkRectangle *cell_area,
                             gint *x_offset,
                             gint *y_offset,
                             gint *width,
                             gint *height )
{
    get_size ( cell, widget, cell_area, NULL,
               x_offset, y_offset, width, height );
}

static void
ptk_text_renderer_render ( GtkCellRenderer *cell,
                           GdkDrawable *window,
                           GtkWidget *widget,
                           GdkRectangle *background_area,
                           GdkRectangle *cell_area,
                           GdkRectangle *expose_area,
                           GtkCellRendererState flags )

{
    PtkTextRenderer * celltext = ( PtkTextRenderer * ) cell;
    PangoLayout *layout;
    GtkStateType state;
    gint x_offset;
    gint y_offset;

    layout = get_layout ( celltext, widget, TRUE, flags );
    get_size ( cell, widget, cell_area, layout, &x_offset, &y_offset, NULL, NULL );

    if ( !cell->sensitive )
    {
        state = GTK_STATE_INSENSITIVE;
    }
    else if ( ( flags & GTK_CELL_RENDERER_SELECTED ) == GTK_CELL_RENDERER_SELECTED )
    {
        if ( GTK_WIDGET_HAS_FOCUS ( widget ) )
            state = GTK_STATE_SELECTED;
        else
            state = GTK_STATE_ACTIVE;
    }
    else if ( ( flags & GTK_CELL_RENDERER_PRELIT ) == GTK_CELL_RENDERER_PRELIT &&
              GTK_WIDGET_STATE ( widget ) == GTK_STATE_PRELIGHT )
    {
        state = GTK_STATE_PRELIGHT;
    }
    else
    {
        if ( GTK_WIDGET_STATE ( widget ) == GTK_STATE_INSENSITIVE )
            state = GTK_STATE_INSENSITIVE;
        else
            state = GTK_STATE_NORMAL;
    }

#if 0
    if ( celltext->background_set &&
            ( flags & GTK_CELL_RENDERER_SELECTED ) == 0 )
    {
        cairo_t * cr = gdk_cairo_create ( window );

        if ( expose_area )
        {
            gdk_cairo_rectangle ( cr, expose_area );
            cairo_clip ( cr );
        }

        gdk_cairo_rectangle ( cr, background_area );
        cairo_set_source_rgb ( cr,
                               celltext->background.red / 65535.,
                               celltext->background.green / 65535.,
                               celltext->background.blue / 65535. );
        cairo_fill ( cr );

        cairo_destroy ( cr );
    }
#endif

    if ( celltext->ellipsize_set )
        pango_layout_set_width ( layout,
                                 ( cell_area->width - x_offset - 2 * cell->xpad ) * PANGO_SCALE );
    else if ( celltext->wrap_width == -1 )
        pango_layout_set_width ( layout, -1 );

    gtk_paint_layout ( widget->style,
                       window,
                       state,
                       TRUE,
                       expose_area,
                       widget,
                       "cellrenderertext",
                       cell_area->x + x_offset + cell->xpad,
                       cell_area->y + y_offset + cell->ypad,
                       layout );

    g_object_unref ( layout );
}