void ygtk_html_wrap_set_text (GtkWidget *widget, const gchar* text, gboolean plain_mode)
{
// TODO: implement plain_mode
GtkHTMLStream *stream = gtk_html_begin (GTK_HTML (widget));
gtk_html_write (GTK_HTML (widget), stream, text, strlen (text));
gtk_html_end (GTK_HTML (widget), stream, GTK_HTML_STREAM_OK);
}
static HTMLAnchor *
find_anchor (HTMLObject *self,
const gchar *name,
gint *x,
gint *y)
{
HTMLFrame *frame;
HTMLAnchor *anchor;
g_return_val_if_fail (HTML_IS_FRAME (self), NULL);
frame = HTML_FRAME (self);
if (!frame || !frame->html || !GTK_IS_HTML (frame->html) || !GTK_HTML (frame->html)->engine || !GTK_HTML (frame->html)->engine->clue)
return NULL;
anchor = html_object_find_anchor (GTK_HTML (frame->html)->engine->clue, name, x, y);
if (anchor) {
*x += self->x;
*y += self->y - self->ascent;
}
return anchor;
}
static gboolean
search (HTMLObject *self,
HTMLSearch *info)
{
HTMLEngine *e = GTK_HTML (HTML_FRAME (self)->html)->engine;
/* printf ("search\n"); */
/* search_next? */
if (info->stack && HTML_OBJECT (info->stack->data) == e->clue) {
/* printf ("next\n"); */
info->engine = GTK_HTML (GTK_HTML (HTML_FRAME (self)->html)->iframe_parent)->engine;
html_search_pop (info);
html_engine_unselect_all (e);
return html_search_next_parent (info);
}
info->engine = e;
html_search_push (info, e->clue);
if (html_object_search (e->clue, info))
return TRUE;
html_search_pop (info);
info->engine = GTK_HTML (GTK_HTML (HTML_FRAME (self)->html)->iframe_parent)->engine;
/* printf ("FALSE\n"); */
return FALSE;
}
static gboolean
select_range (HTMLObject *self,
HTMLEngine *engine,
guint start,
gint length,
gboolean queue_draw)
{
return html_object_select_range (GTK_HTML (HTML_FRAME (self)->html)->engine->clue,
GTK_HTML (HTML_FRAME (self)->html)->engine,
start, length, queue_draw);
}
static void
reparent (HTMLEmbedded *emb,
GtkWidget *html)
{
HTMLFrame *frame = HTML_FRAME (emb);
gtk_html_set_iframe_parent (GTK_HTML (frame->html),
html,
GTK_HTML (frame->html)->frame);
(* HTML_EMBEDDED_CLASS (parent_class)->reparent) (emb, html);
}
static void
set_painter (HTMLObject *o,
HTMLPainter *painter)
{
HTMLFrame *frame;
frame = HTML_FRAME (o);
if (G_OBJECT_TYPE (GTK_HTML (frame->html)->engine->painter) != HTML_TYPE_PRINTER) {
frame_set_gdk_painter (frame, GTK_HTML (frame->html)->engine->painter);
}
html_engine_set_painter (GTK_HTML (frame->html)->engine,
G_OBJECT_TYPE (painter) != HTML_TYPE_PRINTER ? frame->gdk_painter : painter);
}
static HTMLObject *
check_point (HTMLObject *self,
HTMLPainter *painter,
gint x,
gint y,
guint *offset_return,
gboolean for_cursor)
{
HTMLEngine *e = GTK_HTML (HTML_FRAME (self)->html)->engine;
if (x < self->x || x >= self->x + self->width
|| y >= self->y + self->descent || y < self->y - self->ascent)
return NULL;
x -= self->x + html_engine_get_left_border (e) - e->x_offset;
y -= self->y - self->ascent + html_engine_get_top_border (e) - e->y_offset;
if (for_cursor && (x < 0 || y < e->clue->y - e->clue->ascent))
return html_object_check_point (e->clue, e->painter, 0, e->clue->y - e->clue->ascent,
offset_return, for_cursor);
if (for_cursor && (x > e->clue->width - 1 || y > e->clue->y + e->clue->descent - 1))
return html_object_check_point (e->clue, e->painter, e->clue->width - 1, e->clue->y + e->clue->descent - 1,
offset_return, for_cursor);
return html_object_check_point (e->clue, e->painter, x, y, offset_return, for_cursor);
}
static void
draw (HTMLObject *o,
HTMLPainter *p,
gint x,
gint y,
gint width,
gint height,
gint tx,
gint ty)
{
HTMLFrame *frame = HTML_FRAME (o);
HTMLEngine *e = GTK_HTML (frame->html)->engine;
GdkRectangle paint;
if (G_OBJECT_TYPE (e->painter) == HTML_TYPE_PRINTER) {
gint pixel_size = html_painter_get_pixel_size (e->painter);
if (!html_object_intersect (o, &paint, x, y, width, height))
return;
html_object_draw (e->clue, e->painter,
x, y,
width - pixel_size * (html_engine_get_left_border (e) + html_engine_get_right_border (e)),
height - pixel_size * (html_engine_get_top_border (e) + html_engine_get_bottom_border (e)),
tx + pixel_size * html_engine_get_left_border (e), ty + pixel_size * html_engine_get_top_border (e));
} else
(*HTML_OBJECT_CLASS (parent_class)->draw) (o, p, x, y, width, height, tx, ty);
}
static GtkPrintOperationResult
_do_print(EDITOR * e, GtkPrintOperationAction action)
{
GtkPrintOperation *operation;
GtkPrintSettings *psettings;
GtkPageSetup *setup;
GtkPrintOperationResult result;
GError *error = NULL;
operation = gtk_print_operation_new();
psettings = gtk_print_settings_new();
psettings = gtk_print_operation_get_print_settings(operation);
setup = gtk_page_setup_new();
gtk_page_setup_set_top_margin(setup, 30, GTK_UNIT_PIXEL);
gtk_page_setup_set_left_margin(setup, 50, GTK_UNIT_PIXEL);
#ifdef WIN32
gtk_print_operation_set_unit(operation, GTK_UNIT_POINTS);
#endif
gtk_print_operation_set_default_page_setup(operation, setup);
result = gtk_html_print_operation_run(GTK_HTML(e->html_widget), operation, action, GTK_WINDOW(e->window), (GtkHTMLPrintCalcHeight) _calc_header_height, /* GtkHTMLPrintCalcHeight calc_header_height */
(GtkHTMLPrintCalcHeight) _calc_footer_height, /* GtkHTMLPrintCalcHeight calc_footer_height */
(GtkHTMLPrintDrawFunc) _draw_header, /* GtkHTMLPrintDrawFunc draw_header */
(GtkHTMLPrintDrawFunc) _draw_footer, /* GtkHTMLPrintDrawFunc draw_footer */
e, /* gpointer user_data */
&error);
g_object_unref(operation);
handle_error(&error);
return result;
}
static gint
check_page_split (HTMLObject *self,
HTMLPainter *p,
gint y)
{
return html_object_check_page_split (GTK_HTML (HTML_FRAME (self)->html)->engine->clue, p, y);
}
GtkWidget *glen_html_new()
{
GtkWidget *ret;
ret = gtk_html_new();
g_assert(ret != NULL);
g_signal_connect(G_OBJECT(ret), "url_requested",
G_CALLBACK(url_requested_cb), NULL);
g_signal_connect(G_OBJECT(ret), "link_clicked",
G_CALLBACK(link_clicked_cb), NULL);
gtk_html_set_animate(GTK_HTML(ret), TRUE);
gtk_html_set_images_blocking(GTK_HTML(ret), FALSE);
return ret;
}
static void
frame_size_changed (GtkHTML *html,
gpointer data)
{
HTMLFrame *frame = HTML_FRAME (data);
GtkHTML *parent = GTK_HTML (HTML_EMBEDDED (frame)->parent);
html_engine_schedule_update (parent->engine);
}
static void
set_max_width (HTMLObject *o,
HTMLPainter *painter,
gint max_width)
{
HTMLEngine *e = GTK_HTML (HTML_FRAME (o)->html)->engine;
o->max_width = max_width;
html_object_set_max_width (e->clue, e->painter, max_width - (html_engine_get_left_border (e) + html_engine_get_right_border (e)));
}
static void
tny_gtk_html_mime_part_view_instance_init (GTypeInstance *instance, gpointer g_class)
{
TnyGtkHtmlMimePartView *self = (TnyGtkHtmlMimePartView*) instance;
TnyGtkHtmlMimePartViewPriv *priv = TNY_GTK_HTML_MIME_PART_VIEW_GET_PRIVATE (self);
gtk_html_set_editable (GTK_HTML(self), FALSE);
gtk_html_allow_selection (GTK_HTML(self), TRUE);
gtk_html_set_caret_mode (GTK_HTML(self), FALSE);
gtk_html_set_blocking (GTK_HTML(self), FALSE);
gtk_html_set_images_blocking (GTK_HTML(self), FALSE);
g_signal_connect (G_OBJECT(self), "url_requested",
G_CALLBACK(on_url_requested), self);
priv->part = NULL;
return;
}
void
html_frame_set_margin_height (HTMLFrame *frame,
gint margin_height)
{
HTMLEngine *e;
e = GTK_HTML (frame->html)->engine;
e->bottomBorder = e->topBorder = margin_height;
html_engine_schedule_redraw (e);
}
void
html_frame_set_margin_width (HTMLFrame *frame,
gint margin_width)
{
HTMLEngine *e;
e = GTK_HTML (frame->html)->engine;
e->leftBorder = e->rightBorder = margin_width;
html_engine_schedule_redraw (e);
}
static void
forall (HTMLObject *self,
HTMLEngine *e,
HTMLObjectForallFunc func,
gpointer data)
{
HTMLFrame *frame;
frame = HTML_FRAME (self);
(* func) (self, html_object_get_engine (self, e), data);
html_object_forall (GTK_HTML (frame->html)->engine->clue, html_object_get_engine (self, e), func, data);
}
static void
frame_submit (GtkHTML *html,
const gchar *method,
const gchar *action,
const gchar *encoding,
gpointer data)
{
HTMLFrame *frame = HTML_FRAME (data);
GtkHTML *parent = GTK_HTML (HTML_EMBEDDED (frame)->parent);
g_signal_emit_by_name (parent, "submit", method, action, encoding);
}
static void
frame_url_requested (GtkHTML *html,
const gchar *url,
GtkHTMLStream *handle,
gpointer data)
{
HTMLFrame *frame = HTML_FRAME (data);
GtkHTML *parent = GTK_HTML (HTML_EMBEDDED (frame)->parent);
if (!html->engine->stopped)
g_signal_emit_by_name (parent->engine, "url_requested", url, handle);
}
gint main (gint argc, gchar *argv[])
{
GtkWidget *win, *html_widget, *sw;
GtkHTML *html;
gint i = 0, n_all, n_successful;
if (argc > 1)
return 0;
gtk_init (&argc, &argv);
html_widget = gtk_html_new ();
html = GTK_HTML (html_widget);
gtk_html_load_empty (html);
gtk_html_set_editable (html, TRUE);
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (win, 600, 400);
gtk_container_add (GTK_CONTAINER (sw), html_widget);
gtk_container_add (GTK_CONTAINER (win), sw);
gtk_widget_show_all (win);
gtk_widget_show_now (win);
n_all = n_successful = 0;
fprintf (stderr, "\nGtkHTML test suite\n");
fprintf (stderr, "--------------------------------------------------------------------------------\n");
for (i = 0; tests [i].name; i ++) {
gint j, result;
if (tests [i].test_function) {
fprintf (stderr, " %s ", tests [i].name);
for (j = strlen (tests [i].name); j < 69; j ++)
fputc ('.', stderr);
result = (*tests [i].test_function) (html);
fprintf (stderr, " %s\n", result ? "passed" : "failed");
n_all ++;
if (result)
n_successful ++;
} else {
fprintf (stderr, "* %s\n", tests [i].name);
}
}
fprintf (stderr, "--------------------------------------------------------------------------------\n");
fprintf (stderr, "%d tests failed %d tests passed (of %d tests)\n\n", n_all - n_successful, n_successful, n_all);
gtk_main ();
return n_all != n_successful;
}
static gint
calc_min_width (HTMLObject *o,
HTMLPainter *painter)
{
gint min_width;
if (HTML_FRAME (o)->width < 0)
min_width = html_engine_calc_min_width (GTK_HTML (HTML_FRAME (o)->html)->engine);
else
min_width = HTML_FRAME (o)->width;
return min_width;
}
static void
on_html_http_link_clicked_disconnect (C2Request *request, gboolean success, C2Pthread3 *data)
{
GtkHTML *html = GTK_HTML (data->v1);
GtkHTMLStream *stream = data->v3;
const gchar *ptr;
gint length = request->got_size;
ptr = (request->source+request->got_size)-length;
gtk_html_stream_write (stream, request->source, request->got_size);
gtk_html_end (html, stream, success ? GTK_HTML_STREAM_OK : GTK_HTML_STREAM_ERROR);
}
static gboolean
frame_object_requested (GtkHTML *html,
GtkHTMLEmbedded *eb,
gpointer data)
{
HTMLFrame *frame = HTML_FRAME (data);
GtkHTML *parent = GTK_HTML (HTML_EMBEDDED (frame)->parent);
gboolean ret_val;
ret_val = FALSE;
g_signal_emit_by_name (parent, "object_requested", eb, &ret_val);
return ret_val;
}
static void
set_html_part (TnyGtkHtmlMimePartView *self, TnyMimePart *part)
{
SomeData *info = g_slice_new (SomeData);
info->self = (TnyGtkHtmlMimePartView *) g_object_ref (self);
info->gtkhtml_stream = gtk_html_begin(GTK_HTML(self));
info->tny_stream = TNY_STREAM (tny_gtk_html_stream_new (info->gtkhtml_stream));
tny_stream_reset (info->tny_stream);
tny_mime_part_decode_to_stream_async ((TnyMimePart*)part, info->tny_stream,
on_set_stream_finished, on_status, info);
return;
}
static void
gtk_html_a11y_initialize (AtkObject *obj,
gpointer data)
{
GtkWidget *widget;
GtkHTML *html;
AtkObject *accessible;
AtkObject *focus_object = NULL;
/* printf ("gtk_html_a11y_initialize\n"); */
if (ATK_OBJECT_CLASS (parent_class)->initialize)
ATK_OBJECT_CLASS (parent_class)->initialize (obj, data);
g_object_set_data (G_OBJECT (obj), GTK_HTML_ID, data);
obj->role = ATK_ROLE_PANEL;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
accessible = ATK_OBJECT (obj);
g_signal_connect (widget, "grab_focus",
G_CALLBACK (gtk_html_a11y_grab_focus_cb),
NULL);
g_signal_connect (widget, "cursor_changed",
G_CALLBACK (gtk_html_a11y_cursor_changed_cb),
NULL);
g_signal_connect_after (widget, "object_inserted",
G_CALLBACK (gtk_html_a11y_insert_object_cb),
NULL);
g_signal_connect_after (widget, "object_delete",
G_CALLBACK (gtk_html_a11y_delete_object_cb),
NULL);
html = GTK_HTML (widget);
if (html->engine != NULL && html->engine->clue != NULL) {
html_utils_get_accessible (html->engine->clue, accessible);
focus_object = gtk_html_a11y_get_focus_object (widget);
}
if (focus_object && gtk_html_a11y_focus_object != focus_object) {
gtk_html_a11y_focus_object = focus_object;
atk_focus_tracker_notify (focus_object);
}
}
static void
gtk_html_a11y_grab_focus_cb (GtkWidget *widget)
{
AtkObject *focus_object, *obj, *clue;
focus_object = gtk_html_a11y_get_focus_object (widget);
if (focus_object == NULL)
return;
obj = gtk_widget_get_accessible (widget);
clue = html_utils_get_accessible (GTK_HTML (widget)->engine->clue, obj);
atk_object_set_parent (clue, obj);
gtk_html_a11y_focus_object = focus_object;
atk_focus_tracker_notify (focus_object);
}
static void
on_html_http_link_clicked (C2Pthread3 *data)
{
C2Request *request;
const gchar *url = data->v2;
GtkHTML *html = GTK_HTML (data->v1);
GtkHTMLStream *stream;
stream = gtk_html_begin (html);
data->v3 = (gpointer) stream;
request = c2_request_new (url);
gtk_signal_connect (GTK_OBJECT (request), "exchange",
GTK_SIGNAL_FUNC (on_html_http_link_clicked_exchange), data);
gtk_signal_connect (GTK_OBJECT (request), "disconnect",
GTK_SIGNAL_FUNC (on_html_http_link_clicked_disconnect), data);
c2_request_run (request);
}
static void
draw (HTMLObject *o,
HTMLPainter *p,
gint x,
gint y,
gint width,
gint height,
gint tx,
gint ty)
{
HTMLEmbedded *element = HTML_EMBEDDED (o);
gint new_x, new_y;
d (printf ("draw embedded %p\n", element));
if (!element->widget)
return;
if (element->parent) {
GtkWidget *parent;
new_x = o->x + tx;
new_y = o->y + ty - o->ascent;
if ((parent = gtk_widget_get_parent (element->widget))) {
if (new_x != element->abs_x || new_y != element->abs_y) {
d (printf ("element: %p moveto: %d,%d shown: %d\n", element, new_x, new_y, GTK_WIDGET_VISIBLE (element->widget)));
gtk_layout_move (GTK_LAYOUT (parent), element->widget, new_x, new_y);
} else if (!GTK_HTML (parent)->engine->expose)
gtk_widget_queue_draw (element->widget);
}
element->abs_x = new_x;
element->abs_y = new_y;
if (!parent) {
d (printf ("element: %p put: %d,%d shown: %d\n", element, new_x, new_y, GTK_WIDGET_VISIBLE (element->widget)));
gtk_layout_put (GTK_LAYOUT (element->parent), element->widget, new_x, new_y);
}
}
d (printf ("draw embedded %p - call painter tx %d ty %d\n", element, tx, ty));
html_painter_draw_embedded (p, element, tx, ty);
}
static void
gtk_html_a11y_cursor_changed_cb (GtkWidget *widget)
{
AtkObject *focus_object;
focus_object = gtk_html_a11y_get_focus_object (widget);
g_return_if_fail (focus_object != NULL);
if (gtk_html_a11y_focus_object != focus_object) {
gtk_html_a11y_focus_object = focus_object;
atk_focus_tracker_notify (focus_object);
} else {
if (G_IS_HTML_A11Y_TEXT (focus_object)) {
gint offset;
offset = (GTK_HTML (widget))->engine->cursor->offset;
g_signal_emit_by_name (focus_object, "text_caret_moved",offset);
}
}
}
static void
html_embedded_allocate (GtkWidget *w,
GtkAllocation *allocation,
HTMLEmbedded *e)
{
GtkWidget *parent;
parent = gtk_widget_get_parent (w);
if (e->width != allocation->width || e->height != allocation->height) {
if (e->width != allocation->width) {
html_object_change_set (HTML_OBJECT (e), HTML_CHANGE_ALL_CALC);
e->width = allocation->width;
}
e->height = allocation->height;
if (GTK_IS_HTML (parent))
html_engine_schedule_update (GTK_HTML (parent)->engine);
}
}
