webkit2gtk+ draw

#include <gtk/gtk.h>
#include <stdlib.h>
#include <stdlib.h>
#include <webkit2/webkit2.h>
#include <JavaScriptCore/JSContextRef.h>
#include <JavaScriptCore/JSStringRef.h>
#include <webkit2/webkit-web-extension.h>

    GtkWidget *window;
    GtkWidget *controll_window;
    GtkWidget *web_view;
/*
static JSValueRef echoCallback(JSContextRef jsContext, JSObjectRef obj1, JSObjectRef obj2, size_t argumentCount, const JSValueRef arguments[], JSValueRef* jsvalref)
{
    printf("JS callback\n");
    if (argumentCount <= 0)
        return JSValueMakeUndefined(jsContext);

    JSStringRef jstr= JSValueToStringCopy(jsContext, arguments[0], 0);
    return JSValueMakeString(jsContext, jstr);
}
*/
static void
window_object_cleared_callback (WebKitScriptWorld *world,
                                WebKitWebPage     *web_page,
                                WebKitFrame       *frame,
                                gpointer           user_data)
{
    /*JSGlobalContextRef jsContext;
    JSObjectRef        globalObject;*/

    /*jsContext = webkit_frame_get_javascript_context_for_script_world (frame, world);
    globalObject = JSContextGetGlobalObject (jsContext);*/
    printf("%s callback in UI process\n", __func__);


    /* Use JSC API to add the JavaScript code you want */
    /*g_assert(jsContext);
    g_assert(globalObject);

    JSStringRef functionName = JSStringCreateWithUTF8CString("MyEcho");
    JSObjectRef function = JSObjectMakeFunctionWithCallback(jsContext, functionName, echoCallback);
    JSObjectSetProperty(jsContext, globalObject, functionName, function, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly, 0);
    */
}

void handle_load_change() {
    printf("load-changed\n");
}

gboolean damage_event_handler(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
    GTimeVal current_time;
    gchar* time_str;

    g_get_current_time(&current_time);
    time_str = g_time_val_to_iso8601(&current_time);
    printf("%s %s damage-event ", time_str, (char*)user_data);
    g_free(time_str);
    if(event->type == GDK_EXPOSE || event->type == GDK_DAMAGE) { // all or part of the window has become visible and needs to be redrawn.
            GdkEventExpose expose = event->expose;
        GdkRectangle rect = expose.area;

        if(event->type == GDK_EXPOSE) {
            printf("GDK_EXPOSE ");
        } else if(event->type == GDK_DAMAGE) {
            printf("GDK_DAMAGE ");
        }
            if (expose.type == GDK_EXPOSE) {
            printf("GDK_EXPOSE ");
            } else if (expose.type == GDK_DAMAGE) {
            printf("GDK_DAMAGE ");
            }
        printf("{{X: %d, Y: %d, W: %d, H: %d}, count: %d}", rect.x, rect.y, rect.width, rect.height, expose.count);
    } else {
        printf("event->type = %d)", event->type);
    }
    printf("\n");
    return FALSE;
}

/*
 * This signal is emitted when a widget is supposed to render itself. The widget 's top left corner must be painted at the origin of the passed in context and be sized to the values returned by gtk_widget_get_allocated_width() and gtk_widget_get_allocated_height().
 *
 * Signal handlers connected to this signal can modify the cairo context passed as cr in any way they like and don't need to restore it. The signal emission takes care of calling cairo_save() before and cairo_restore() after invoking the handler.
 *
 * The signal handler will get a cr with a clip region already set to the widget's dirty region, i.e. to the area that needs repainting. Complicated widgets that want to avoid redrawing themselves completely can get the full extents of the clip region with gdk_cairo_get_clip_rectangle(), or they can get a finer-grained representation of the dirty region with cairo_copy_clip_rectangle_list().
 */
gboolean draw_event_handler(GtkWidget *widget, cairo_t *cr, gpointer user_data)
{
    cairo_rectangle_list_t *rect_list;
    cairo_rectangle_t *rect;
    int i;
    GTimeVal current_time;
    gchar* time_str;
    cairo_surface_t *surface;


    rect_list= cairo_copy_clip_rectangle_list(cr);
    g_get_current_time(&current_time);
    time_str = g_time_val_to_iso8601(&current_time);
    printf("%s %s draw ", time_str, (char*)user_data);
    g_free(time_str);
    if(rect_list->status == CAIRO_STATUS_SUCCESS) {
        printf("%d ", rect_list->num_rectangles);

        surface = cairo_get_group_target(cr);
        for(i=0; i < rect_list->num_rectangles; i++) {
            rect = rect_list->rectangles + i;
            printf("{X: %f, Y: %f, W: %f, H:%f} ", rect->x, rect->y, rect->width, rect->height);
            if(cairo_surface_status(surface) == CAIRO_STATUS_SUCCESS) {
                cairo_surface_t *surface_rect;
                unsigned char* data;
                int width, height, stride;
            gchar *checksum;

                surface_rect = cairo_surface_create_for_rectangle(surface, rect->x, rect->y, rect->width, rect->height);
            if(surface_rect != NULL) {
                data = cairo_image_surface_get_data (surface_rect);
                width = cairo_image_surface_get_width (surface_rect);
                height = cairo_image_surface_get_height (surface_rect);
                stride = cairo_image_surface_get_stride (surface_rect);
                /*width = rect->width;
                height = rect->height;
                stride = 4*width;*/

                checksum = g_compute_checksum_for_data(G_CHECKSUM_MD5, data, (gsize)(height*stride));
                printf("%dx%d-%s ", width, height, checksum);
                cairo_surface_destroy (surface_rect);
                g_free(checksum);
            }
            }
            /*draw something*/
               /* GdkRGBA color;
                cairo_arc (cr, rect->x + rect->width / 2.0, rect->y + rect->height / 2.0, MIN (rect->width, rect->height) / 2.0, 0, 2 * G_PI);
                gtk_style_context_get_color (gtk_widget_get_style_context (widget), 0, &color);
                gdk_cairo_set_source_rgba (cr, &color);
            cairo_fill (cr);*/
        }
    } else {
        printf("rect_list->status = %d ", rect_list->status);
    }
    printf("\n");
    cairo_rectangle_list_destroy(rect_list);
    return FALSE;
}

void init_signals() {
    g_signal_connect (webkit_script_world_get_default (),
                      "window-object-cleared",
                      G_CALLBACK (window_object_cleared_callback),
                      NULL);
    g_signal_connect (web_view,
                      "load-changed",
                      G_CALLBACK (handle_load_change),
                      NULL);

    g_signal_connect_after (window, "damage-event", G_CALLBACK(damage_event_handler), "window");
    g_signal_connect_after (window, "draw", G_CALLBACK(draw_event_handler), "window");

    g_signal_connect_after (web_view, "damage-event", G_CALLBACK(damage_event_handler), "web_view");
    g_signal_connect_after (web_view, "draw", G_CALLBACK(draw_event_handler), "web_view");

}

void load_web_process_extensions() {
    printf("%s\n", __func__);
     webkit_web_context_set_web_extensions_directory(webkit_web_context_get_default(),"./extension");
}

static void
web_view_javascript_finished (GObject      *object,
                              GAsyncResult *result,
                              gpointer      user_data)
{
    WebKitJavascriptResult *js_result;
    JSValueRef              value;
    JSGlobalContextRef      context;
    GError                 *error = NULL;

    js_result = webkit_web_view_run_javascript_finish (WEBKIT_WEB_VIEW (object), result, &error);
    if (!js_result) {
        g_warning ("Error running javascript: %s", error->message);
        g_error_free (error);
        return;
    }

    context = webkit_javascript_result_get_global_context (js_result);
    value = webkit_javascript_result_get_value (js_result);
    if (JSValueIsString (context, value)) {
        JSStringRef js_str_value;
        gchar      *str_value;
        gsize       str_length;

        js_str_value = JSValueToStringCopy (context, value, NULL);
        str_length = JSStringGetMaximumUTF8CStringSize (js_str_value);
        str_value = (gchar *)g_malloc (str_length);
        JSStringGetUTF8CString (js_str_value, str_value, str_length);
        JSStringRelease (js_str_value);
        g_print ("Script result: %s\n", str_value);
        g_free (str_value);
    } else {
        g_warning ("Javascript: Non string return value");
        JSStringRef js_str_value;
        gchar      *str_value;
        gsize       str_length;

        js_str_value = JSValueToStringCopy (context, value, NULL);
        str_length = JSStringGetMaximumUTF8CStringSize (js_str_value);
        str_value = (gchar *)g_malloc (str_length);
        JSStringGetUTF8CString (js_str_value, str_value, str_length);
        JSStringRelease (js_str_value);
        g_print ("Script result: %s\n", str_value);
        g_free (str_value);
    }
    webkit_javascript_result_unref (js_result);
}


void run_java_script(GtkWidget *web_view, gchar *js_script_text) {
    GAsyncReadyCallback cCallback = web_view_javascript_finished;
    gpointer userData = NULL;

    printf("%s: %s\n", __func__, js_script_text);
    webkit_web_view_run_javascript(WEBKIT_WEB_VIEW(web_view), js_script_text, NULL, cCallback, userData);
}

void click(GtkWidget *web_view, short x, short y) {
    gchar* click_js = g_strdup_printf("document.elementFromPoint(%d, %d).click();", x, y);
    run_java_script(web_view, click_js);
    g_free(click_js);
}

gboolean fake_click() {
    printf("fake click\n");
    click(web_view, 100, 100);
    return TRUE;
}

void real_click_button(GtkWidget *clck_button, gpointer data) {
    int x = 0, y = 0;
    const char *text = gtk_entry_get_text(GTK_ENTRY(data));
    sscanf(text, "%d,%d", &x, &y);
    printf("real_click %d, %d\n", x ,y);
    click(web_view, x, y);
}

void follow_uri_button(GtkWidget *uri_button, gpointer data) {
    const char *uri = gtk_entry_get_text(GTK_ENTRY(data));
    webkit_web_view_load_uri(WEBKIT_WEB_VIEW(web_view), uri);
}

void javascript_button_execute(GtkWidget *js_button, gpointer data) {
    gchar *js = (gchar*)gtk_entry_get_text(GTK_ENTRY(data));
    run_java_script(web_view, js);
}



void application_quit() {
    printf("bye\n");
    exit(0);
}
void make_controll_window() {
      /*buttons*/
      GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
      GtkWidget *entry_click = gtk_entry_new();
      GtkWidget *button_click = gtk_button_new_with_label("Generate click");
      GtkWidget *entry_uri = gtk_entry_new();
      GtkWidget *button_uri = gtk_button_new_with_label("Go");
      GtkWidget *entry_js = gtk_entry_new();
      GtkWidget *button_js = gtk_button_new_with_label("execute script");
      controll_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
      g_signal_connect(G_OBJECT(controll_window), "destroy", G_CALLBACK(application_quit), NULL);
      gtk_window_set_title(GTK_WINDOW(controll_window), "controlls");
      //gtk_window_set_default_size(GTK_WINDOW(controll_window), 60, 60);
      gtk_window_set_resizable(GTK_WINDOW(controll_window), FALSE);
      gtk_window_set_position(GTK_WINDOW(controll_window), GTK_WIN_POS_CENTER);
      g_signal_connect(G_OBJECT(button_click), "clicked", G_CALLBACK(real_click_button), entry_click);
      g_signal_connect(G_OBJECT(button_uri), "clicked", G_CALLBACK(follow_uri_button), entry_uri);
      g_signal_connect(G_OBJECT(button_js), "clicked", G_CALLBACK(javascript_button_execute), entry_js);

      gtk_box_pack_start(GTK_BOX(box), entry_click, FALSE, FALSE, 2);
      gtk_box_pack_start(GTK_BOX(box), button_click, FALSE, FALSE, 2);
      gtk_box_pack_start(GTK_BOX(box), entry_uri, FALSE, FALSE, 2);
      gtk_box_pack_start(GTK_BOX(box), button_uri, FALSE, FALSE, 2);
      gtk_box_pack_start(GTK_BOX(box), entry_js, FALSE, FALSE, 2);
      gtk_box_pack_start(GTK_BOX(box), button_js, FALSE, FALSE, 2);
      gtk_container_add(GTK_CONTAINER(controll_window), box);
      gtk_widget_show_all(controll_window);
}

int main(int argc, char **argv)
{
    //load_web_process_extensions();
    gdk_threads_enter();
    gtk_init(&argc, &argv);

     //GtkWidget *window = gtk_offscreen_window_new();
     //https://developer.gnome.org/gtk2/2.24/GtkWindow.html#gtk-window-new
     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
     web_view = webkit_web_view_new();

     //do not duble buffer
     gtk_widget_set_double_buffered(web_view, FALSE);

     g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(application_quit), NULL);
     init_signals();

     gtk_window_set_title(GTK_WINDOW(window), "Test");
      gtk_window_set_default_size(GTK_WINDOW(window), 600, 800);
      gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
      gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

      //add web-view
      gtk_container_add(GTK_CONTAINER(window), web_view);
      gtk_widget_set_double_buffered(GTK_WIDGET(web_view), FALSE);

      gtk_widget_show_all(window);

       //settings are set. Load url.
       webkit_web_view_load_uri(WEBKIT_WEB_VIEW(web_view), "http://wemar:8000/ui_new/113/menu");

       make_controll_window();


       // fake click every 2 secs
       //g_timeout_add(2000, fake_click, NULL);
       //

    gtk_main();
    gdk_threads_leave();
    return 0;
}