You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
659 lines
16 KiB
659 lines
16 KiB
/*
|
|
* Copyright 2006 Rob Kendrick <rjek@rjek.com>
|
|
* Copyright 2005 James Bursa <bursa@users.sourceforge.net>
|
|
*
|
|
* This file is part of NetSurf, http://www.netsurf-browser.org/
|
|
*
|
|
* NetSurf is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; version 2 of the License.
|
|
*
|
|
* NetSurf is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/**
|
|
* \file
|
|
* GTK and Cairo plotter implementations.
|
|
*
|
|
* Uses Cairo drawing primitives to render browser output.
|
|
* \todo remove the use of the gdk structure for clipping
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include <assert.h>
|
|
#include <gdk/gdk.h>
|
|
#include <gtk/gtk.h>
|
|
|
|
#include "utils/log.h"
|
|
#include "netsurf/plotters.h"
|
|
#include "utils/nsoption.h"
|
|
|
|
#include "gtk/layout_pango.h"
|
|
#include "gtk/plotters.h"
|
|
#include "gtk/scaffolding.h"
|
|
#include "gtk/bitmap.h"
|
|
|
|
cairo_t *current_cr;
|
|
|
|
static GdkRectangle cliprect;
|
|
|
|
/**
|
|
* Set cairo context colour to nsgtk colour.
|
|
*
|
|
* \param c the netsurf colour to set in cairo
|
|
*/
|
|
void nsgtk_set_colour(colour c)
|
|
{
|
|
cairo_set_source_rgba(current_cr,
|
|
(c & 0xff) / 255.0,
|
|
((c & 0xff00) >> 8) / 255.0,
|
|
((c & 0xff0000) >> 16) / 255.0,
|
|
1.0);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set cairo context to solid plot operation.
|
|
*/
|
|
static inline void nsgtk_set_solid(void)
|
|
{
|
|
double dashes = 0;
|
|
cairo_set_dash(current_cr, &dashes, 0, 0);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set cairo context to dotted plot operation.
|
|
*/
|
|
static inline void nsgtk_set_dotted(void)
|
|
{
|
|
double cdashes[] = { 1.0, 2.0 };
|
|
cairo_set_dash(current_cr, cdashes, 2, 0);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set cairo context to dashed plot operation.
|
|
*/
|
|
static inline void nsgtk_set_dashed(void)
|
|
{
|
|
double cdashes[] = { 8.0, 2.0 };
|
|
cairo_set_dash(current_cr, cdashes, 2, 0);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set cairo context line width.
|
|
*/
|
|
static inline void nsgtk_set_line_width(plot_style_fixed width)
|
|
{
|
|
if (width == 0) {
|
|
cairo_set_line_width(current_cr, 1);
|
|
} else {
|
|
cairo_set_line_width(current_cr,
|
|
plot_style_fixed_to_double(width));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* \brief Sets a clip rectangle for subsequent plot operations.
|
|
*
|
|
* \param ctx The current redraw context.
|
|
* \param clip The rectangle to limit all subsequent plot
|
|
* operations within.
|
|
* \return NSERROR_OK on success else error code.
|
|
*/
|
|
static nserror
|
|
nsgtk_plot_clip(const struct redraw_context *ctx, const struct rect *clip)
|
|
{
|
|
cairo_reset_clip(current_cr);
|
|
cairo_rectangle(current_cr, clip->x0, clip->y0,
|
|
clip->x1 - clip->x0, clip->y1 - clip->y0);
|
|
cairo_clip(current_cr);
|
|
|
|
cliprect.x = clip->x0;
|
|
cliprect.y = clip->y0;
|
|
cliprect.width = clip->x1 - clip->x0;
|
|
cliprect.height = clip->y1 - clip->y0;
|
|
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Plots an arc
|
|
*
|
|
* plot an arc segment around (x,y), anticlockwise from angle1
|
|
* to angle2. Angles are measured anticlockwise from
|
|
* horizontal, in degrees.
|
|
*
|
|
* \param ctx The current redraw context.
|
|
* \param style Style controlling the arc plot.
|
|
* \param x The x coordinate of the arc.
|
|
* \param y The y coordinate of the arc.
|
|
* \param radius The radius of the arc.
|
|
* \param angle1 The start angle of the arc.
|
|
* \param angle2 The finish angle of the arc.
|
|
* \return NSERROR_OK on success else error code.
|
|
*/
|
|
static nserror
|
|
nsgtk_plot_arc(const struct redraw_context *ctx,
|
|
const plot_style_t *style,
|
|
int x, int y, int radius, int angle1, int angle2)
|
|
{
|
|
nsgtk_set_colour(style->fill_colour);
|
|
nsgtk_set_solid();
|
|
|
|
cairo_set_line_width(current_cr, 1);
|
|
cairo_arc(current_cr, x, y, radius,
|
|
(angle1 + 90) * (M_PI / 180),
|
|
(angle2 + 90) * (M_PI / 180));
|
|
cairo_stroke(current_cr);
|
|
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Plots a circle
|
|
*
|
|
* Plot a circle centered on (x,y), which is optionally filled.
|
|
*
|
|
* \param ctx The current redraw context.
|
|
* \param style Style controlling the circle plot.
|
|
* \param x x coordinate of circle centre.
|
|
* \param y y coordinate of circle centre.
|
|
* \param radius circle radius.
|
|
* \return NSERROR_OK on success else error code.
|
|
*/
|
|
static nserror
|
|
nsgtk_plot_disc(const struct redraw_context *ctx,
|
|
const plot_style_t *style,
|
|
int x, int y, int radius)
|
|
{
|
|
if (style->fill_type != PLOT_OP_TYPE_NONE) {
|
|
nsgtk_set_colour(style->fill_colour);
|
|
nsgtk_set_solid();
|
|
cairo_set_line_width(current_cr, 0);
|
|
cairo_arc(current_cr, x, y, radius, 0, M_PI * 2);
|
|
cairo_fill(current_cr);
|
|
cairo_stroke(current_cr);
|
|
}
|
|
|
|
if (style->stroke_type != PLOT_OP_TYPE_NONE) {
|
|
nsgtk_set_colour(style->stroke_colour);
|
|
|
|
switch (style->stroke_type) {
|
|
case PLOT_OP_TYPE_SOLID: /* Solid colour */
|
|
default:
|
|
nsgtk_set_solid();
|
|
break;
|
|
|
|
case PLOT_OP_TYPE_DOT: /* Doted plot */
|
|
nsgtk_set_dotted();
|
|
break;
|
|
|
|
case PLOT_OP_TYPE_DASH: /* dashed plot */
|
|
nsgtk_set_dashed();
|
|
break;
|
|
}
|
|
|
|
nsgtk_set_line_width(style->stroke_width);
|
|
|
|
cairo_arc(current_cr, x, y, radius, 0, M_PI * 2);
|
|
|
|
cairo_stroke(current_cr);
|
|
}
|
|
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Plots a line
|
|
*
|
|
* plot a line from (x0,y0) to (x1,y1). Coordinates are at
|
|
* centre of line width/thickness.
|
|
*
|
|
* \param ctx The current redraw context.
|
|
* \param style Style controlling the line plot.
|
|
* \param line A rectangle defining the line to be drawn
|
|
* \return NSERROR_OK on success else error code.
|
|
*/
|
|
static nserror
|
|
nsgtk_plot_line(const struct redraw_context *ctx,
|
|
const plot_style_t *style,
|
|
const struct rect *line)
|
|
{
|
|
nsgtk_set_colour(style->stroke_colour);
|
|
|
|
switch (style->stroke_type) {
|
|
case PLOT_OP_TYPE_SOLID: /* Solid colour */
|
|
default:
|
|
nsgtk_set_solid();
|
|
break;
|
|
|
|
case PLOT_OP_TYPE_DOT: /* Doted plot */
|
|
nsgtk_set_dotted();
|
|
break;
|
|
|
|
case PLOT_OP_TYPE_DASH: /* dashed plot */
|
|
nsgtk_set_dashed();
|
|
break;
|
|
}
|
|
|
|
if (style->stroke_type != PLOT_OP_TYPE_NONE) {
|
|
nsgtk_set_colour(style->stroke_colour);
|
|
}
|
|
|
|
nsgtk_set_line_width(style->stroke_width);
|
|
|
|
/* core expects horizontal and vertical lines to be on pixels, not
|
|
* between pixels
|
|
*/
|
|
cairo_move_to(current_cr,
|
|
(line->x0 == line->x1) ? line->x0 + 0.5 : line->x0,
|
|
(line->y0 == line->y1) ? line->y0 + 0.5 : line->y0);
|
|
cairo_line_to(current_cr,
|
|
(line->x0 == line->x1) ? line->x1 + 0.5 : line->x1,
|
|
(line->y0 == line->y1) ? line->y1 + 0.5 : line->y1);
|
|
cairo_stroke(current_cr);
|
|
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Plot a caret.
|
|
*
|
|
* @note It is assumed that the plotters have been set up.
|
|
*/
|
|
void nsgtk_plot_caret(int x, int y, int h)
|
|
{
|
|
nsgtk_set_solid(); /* solid line */
|
|
nsgtk_set_colour(0); /* black */
|
|
cairo_set_line_width(current_cr, 1); /* thin line */
|
|
|
|
/* core expects horizontal and vertical lines to be on pixels, not
|
|
* between pixels */
|
|
cairo_move_to(current_cr, x + 0.5, y);
|
|
cairo_line_to(current_cr, x + 0.5, y + h - 1);
|
|
cairo_stroke(current_cr);
|
|
}
|
|
|
|
|
|
/**
|
|
* Plots a rectangle.
|
|
*
|
|
* The rectangle can be filled an outline or both controlled
|
|
* by the plot style The line can be solid, dotted or
|
|
* dashed. Top left corner at (x0,y0) and rectangle has given
|
|
* width and height.
|
|
*
|
|
* \param ctx The current redraw context.
|
|
* \param style Style controlling the rectangle plot.
|
|
* \param rect A rectangle defining the line to be drawn
|
|
* \return NSERROR_OK on success else error code.
|
|
*/
|
|
static nserror
|
|
nsgtk_plot_rectangle(const struct redraw_context *ctx,
|
|
const plot_style_t *style,
|
|
const struct rect *rect)
|
|
{
|
|
if (style->fill_type != PLOT_OP_TYPE_NONE) {
|
|
nsgtk_set_colour(style->fill_colour);
|
|
nsgtk_set_solid();
|
|
|
|
cairo_set_line_width(current_cr, 0);
|
|
cairo_rectangle(current_cr,
|
|
rect->x0,
|
|
rect->y0,
|
|
rect->x1 - rect->x0,
|
|
rect->y1 - rect->y0);
|
|
cairo_fill(current_cr);
|
|
cairo_stroke(current_cr);
|
|
}
|
|
|
|
if (style->stroke_type != PLOT_OP_TYPE_NONE) {
|
|
nsgtk_set_colour(style->stroke_colour);
|
|
|
|
switch (style->stroke_type) {
|
|
case PLOT_OP_TYPE_SOLID: /* Solid colour */
|
|
default:
|
|
nsgtk_set_solid();
|
|
break;
|
|
|
|
case PLOT_OP_TYPE_DOT: /* Doted plot */
|
|
nsgtk_set_dotted();
|
|
break;
|
|
|
|
case PLOT_OP_TYPE_DASH: /* dashed plot */
|
|
nsgtk_set_dashed();
|
|
break;
|
|
}
|
|
|
|
nsgtk_set_line_width(style->stroke_width);
|
|
|
|
cairo_rectangle(current_cr,
|
|
rect->x0 + 0.5,
|
|
rect->y0 + 0.5,
|
|
rect->x1 - rect->x0,
|
|
rect->y1 - rect->y0);
|
|
cairo_stroke(current_cr);
|
|
}
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Plot a polygon
|
|
*
|
|
* Plots a filled polygon with straight lines between
|
|
* points. The lines around the edge of the ploygon are not
|
|
* plotted. The polygon is filled with the non-zero winding
|
|
* rule.
|
|
*
|
|
* \param ctx The current redraw context.
|
|
* \param style Style controlling the polygon plot.
|
|
* \param p verticies of polygon
|
|
* \param n number of verticies.
|
|
* \return NSERROR_OK on success else error code.
|
|
*/
|
|
static nserror
|
|
nsgtk_plot_polygon(const struct redraw_context *ctx,
|
|
const plot_style_t *style,
|
|
const int *p,
|
|
unsigned int n)
|
|
{
|
|
unsigned int i;
|
|
|
|
nsgtk_set_colour(style->fill_colour);
|
|
nsgtk_set_solid();
|
|
|
|
cairo_set_line_width(current_cr, 0);
|
|
cairo_move_to(current_cr, p[0], p[1]);
|
|
for (i = 1; i != n; i++) {
|
|
cairo_line_to(current_cr, p[i * 2], p[i * 2 + 1]);
|
|
}
|
|
cairo_fill(current_cr);
|
|
cairo_stroke(current_cr);
|
|
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Plots a path.
|
|
*
|
|
* Path plot consisting of cubic Bezier curves. Line and fill colour is
|
|
* controlled by the plot style.
|
|
*
|
|
* \param ctx The current redraw context.
|
|
* \param pstyle Style controlling the path plot.
|
|
* \param p elements of path
|
|
* \param n nunber of elements on path
|
|
* \param transform A transform to apply to the path.
|
|
* \return NSERROR_OK on success else error code.
|
|
*/
|
|
static nserror
|
|
nsgtk_plot_path(const struct redraw_context *ctx,
|
|
const plot_style_t *pstyle,
|
|
const float *p,
|
|
unsigned int n,
|
|
const float transform[6])
|
|
{
|
|
unsigned int i;
|
|
cairo_matrix_t old_ctm, n_ctm;
|
|
|
|
if (n == 0)
|
|
return NSERROR_OK;
|
|
|
|
if (p[0] != PLOTTER_PATH_MOVE) {
|
|
NSLOG(netsurf, INFO, "Path does not start with move");
|
|
return NSERROR_INVALID;
|
|
}
|
|
|
|
/* Save CTM */
|
|
cairo_get_matrix(current_cr, &old_ctm);
|
|
|
|
/* Set up line style and width */
|
|
nsgtk_set_line_width(pstyle->stroke_width);
|
|
nsgtk_set_solid();
|
|
|
|
/* Load new CTM */
|
|
n_ctm.xx = transform[0];
|
|
n_ctm.yx = transform[1];
|
|
n_ctm.xy = transform[2];
|
|
n_ctm.yy = transform[3];
|
|
n_ctm.x0 = transform[4] + old_ctm.x0;
|
|
n_ctm.y0 = transform[5] + old_ctm.y0;
|
|
|
|
cairo_set_matrix(current_cr, &n_ctm);
|
|
|
|
/* Construct path */
|
|
for (i = 0; i < n; ) {
|
|
if (p[i] == PLOTTER_PATH_MOVE) {
|
|
cairo_move_to(current_cr, p[i+1], p[i+2]);
|
|
i += 3;
|
|
} else if (p[i] == PLOTTER_PATH_CLOSE) {
|
|
cairo_close_path(current_cr);
|
|
i++;
|
|
} else if (p[i] == PLOTTER_PATH_LINE) {
|
|
cairo_line_to(current_cr, p[i+1], p[i+2]);
|
|
i += 3;
|
|
} else if (p[i] == PLOTTER_PATH_BEZIER) {
|
|
cairo_curve_to(current_cr, p[i+1], p[i+2],
|
|
p[i+3], p[i+4],
|
|
p[i+5], p[i+6]);
|
|
i += 7;
|
|
} else {
|
|
NSLOG(netsurf, INFO, "bad path command %f", p[i]);
|
|
/* Reset matrix for safety */
|
|
cairo_set_matrix(current_cr, &old_ctm);
|
|
return NSERROR_INVALID;
|
|
}
|
|
}
|
|
|
|
/* Restore original CTM */
|
|
cairo_set_matrix(current_cr, &old_ctm);
|
|
|
|
/* Now draw path */
|
|
if (pstyle->fill_colour != NS_TRANSPARENT) {
|
|
nsgtk_set_colour(pstyle->fill_colour);
|
|
|
|
if (pstyle->stroke_colour != NS_TRANSPARENT) {
|
|
/* Fill & Stroke */
|
|
cairo_fill_preserve(current_cr);
|
|
nsgtk_set_colour(pstyle->stroke_colour);
|
|
cairo_stroke(current_cr);
|
|
} else {
|
|
/* Fill only */
|
|
cairo_fill(current_cr);
|
|
}
|
|
} else if (pstyle->stroke_colour != NS_TRANSPARENT) {
|
|
/* Stroke only */
|
|
nsgtk_set_colour(pstyle->stroke_colour);
|
|
cairo_stroke(current_cr);
|
|
}
|
|
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Plot a bitmap
|
|
*
|
|
* Tiled plot of a bitmap image. (x,y) gives the top left
|
|
* coordinate of an explicitly placed tile. From this tile the
|
|
* image can repeat in all four directions -- up, down, left
|
|
* and right -- to the extents given by the current clip
|
|
* rectangle.
|
|
*
|
|
* The bitmap_flags say whether to tile in the x and y
|
|
* directions. If not tiling in x or y directions, the single
|
|
* image is plotted. The width and height give the dimensions
|
|
* the image is to be scaled to.
|
|
*
|
|
* \param ctx The current redraw context.
|
|
* \param bitmap The bitmap to plot
|
|
* \param x The x coordinate to plot the bitmap
|
|
* \param y The y coordiante to plot the bitmap
|
|
* \param width The width of area to plot the bitmap into
|
|
* \param height The height of area to plot the bitmap into
|
|
* \param bg the background colour to alpha blend into
|
|
* \param flags the flags controlling the type of plot operation
|
|
* \return NSERROR_OK on success else error code.
|
|
*/
|
|
static nserror
|
|
nsgtk_plot_bitmap(const struct redraw_context *ctx,
|
|
struct bitmap *bitmap,
|
|
int x, int y,
|
|
int width,
|
|
int height,
|
|
colour bg,
|
|
bitmap_flags_t flags)
|
|
{
|
|
bool repeat_x = (flags & BITMAPF_REPEAT_X);
|
|
bool repeat_y = (flags & BITMAPF_REPEAT_Y);
|
|
GdkRectangle cliprect_bitmap;
|
|
cairo_surface_t *img_surface;
|
|
int img_width, img_height;
|
|
|
|
/* Bail early if we can */
|
|
if (width <= 0 || height <= 0) {
|
|
/* Nothing to plot */
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
/* Copy the clip rectangle into bitmap plot clip rectangle */
|
|
cliprect_bitmap = cliprect;
|
|
|
|
/* Constrain bitmap plot rectangle for any lack of tiling */
|
|
if (!repeat_x) {
|
|
if (cliprect_bitmap.width > width) {
|
|
cliprect_bitmap.width = width;
|
|
}
|
|
if (cliprect_bitmap.x < x) {
|
|
cliprect_bitmap.x = x;
|
|
cliprect_bitmap.width -= x - cliprect_bitmap.x;
|
|
}
|
|
}
|
|
if (!repeat_y) {
|
|
if (cliprect_bitmap.height > height) {
|
|
cliprect_bitmap.height = height;
|
|
}
|
|
if (cliprect_bitmap.y < y) {
|
|
cliprect_bitmap.y = y;
|
|
cliprect_bitmap.height -= y - cliprect_bitmap.y;
|
|
}
|
|
}
|
|
|
|
/* Bail early if we can */
|
|
if (cliprect_bitmap.width <= 0 || cliprect_bitmap.height <= 0) {
|
|
/* Nothing to plot */
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
/* Get the image's surface and intrinsic dimensions */
|
|
img_surface = bitmap->surface;
|
|
img_width = cairo_image_surface_get_width(img_surface);
|
|
img_height = cairo_image_surface_get_height(img_surface);
|
|
|
|
/* Set the source surface */
|
|
if ((img_width == width) && (img_height == height)) {
|
|
/* Non-scaled rendering */
|
|
cairo_set_source_surface(current_cr, img_surface, x, y);
|
|
|
|
/* Enable tiling if we're repeating */
|
|
if (repeat_x || repeat_y) {
|
|
cairo_pattern_set_extend(
|
|
cairo_get_source(current_cr),
|
|
CAIRO_EXTEND_REPEAT);
|
|
}
|
|
|
|
/* Render the bitmap */
|
|
cairo_rectangle(current_cr,
|
|
cliprect_bitmap.x,
|
|
cliprect_bitmap.y,
|
|
cliprect_bitmap.width,
|
|
cliprect_bitmap.height);
|
|
cairo_fill(current_cr);
|
|
} else {
|
|
/* Scaled rendering */
|
|
double scale_x = (double)width / img_width;
|
|
double scale_y = (double)height / img_height;
|
|
|
|
/* Save cairo rendering context state before scaling */
|
|
cairo_save(current_cr);
|
|
cairo_scale(current_cr, scale_x, scale_y);
|
|
|
|
cairo_set_source_surface(current_cr, img_surface,
|
|
x / scale_x, y / scale_y);
|
|
|
|
/* Enable tiling if we're repeating */
|
|
if (repeat_x || repeat_y) {
|
|
cairo_pattern_set_extend(
|
|
cairo_get_source(current_cr),
|
|
CAIRO_EXTEND_REPEAT);
|
|
}
|
|
|
|
/* Render the bitmap */
|
|
cairo_rectangle(current_cr,
|
|
cliprect_bitmap.x / scale_x,
|
|
cliprect_bitmap.y / scale_y,
|
|
cliprect_bitmap.width / scale_x,
|
|
cliprect_bitmap.height / scale_y);
|
|
cairo_fill(current_cr);
|
|
|
|
/* Restore pre-scaling cairo rendering state */
|
|
cairo_restore(current_cr);
|
|
}
|
|
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Text plotting.
|
|
*
|
|
* \param ctx The current redraw context.
|
|
* \param fstyle plot style for this text
|
|
* \param x x coordinate
|
|
* \param y y coordinate
|
|
* \param text UTF-8 string to plot
|
|
* \param length length of string, in bytes
|
|
* \return NSERROR_OK on success else error code.
|
|
*/
|
|
static nserror
|
|
nsgtk_plot_text(const struct redraw_context *ctx,
|
|
const struct plot_font_style *fstyle,
|
|
int x,
|
|
int y,
|
|
const char *text,
|
|
size_t length)
|
|
{
|
|
return nsfont_paint(x, y, text, length, fstyle);
|
|
}
|
|
|
|
|
|
/** GTK plotter table */
|
|
const struct plotter_table nsgtk_plotters = {
|
|
.clip = nsgtk_plot_clip,
|
|
.arc = nsgtk_plot_arc,
|
|
.disc = nsgtk_plot_disc,
|
|
.line = nsgtk_plot_line,
|
|
.rectangle = nsgtk_plot_rectangle,
|
|
.polygon = nsgtk_plot_polygon,
|
|
.path = nsgtk_plot_path,
|
|
.bitmap = nsgtk_plot_bitmap,
|
|
.text = nsgtk_plot_text,
|
|
.option_knockout = true
|
|
};
|