#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <cairo.h>

#define BITMAP_WIDTH (500)
#define BITMAP_HEIGHT (500)
#define TEXTVIEW_HEIGHT (100)

GtkWidget *window;
GtkWidget *darea;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *hbox01;
GtkWidget *button01;
GtkWidget *button02;
GtkWidget *vbox02;
GtkWidget *scrolledwindow;
GtkWidget *textview;
GThread* thread;
volatile int execflag01;
int count;
int time_count;
char buf[1024];
double start_time, end_time;


double seconds();
void delete_text(GtkTextView *textview);
void set_text(GtkTextView *textview, const gchar *text);
void append_text(GtkTextView *textview , const gchar *text);
void scroll_to_bottom(GtkScrolledWindow *scrolled_window);

static void do_drawing (cairo_t *, GtkWidget * widget);

struct {
    cairo_surface_t *image;
} glob;

static gboolean on_draw_event (GtkWidget * widget, cairo_t * cr, gpointer user_data)
{
    cr = gdk_cairo_create (gtk_widget_get_window (widget));
    do_drawing (cr, widget);
    cairo_destroy (cr);

    return FALSE;
}


static void do_drawing (cairo_t * cr, GtkWidget * widget)
{
    gfloat screen_width;
    gfloat screen_height;
    gfloat image_width;
    gfloat image_height;
    gfloat x_scaling;
    gfloat y_scaling;

    /* ディスプレイの全画面の大きさを取得 */
    screen_width = gdk_screen_get_width (gdk_screen_get_default ());
    screen_height = gdk_screen_get_height (gdk_screen_get_default ());

    /* イメージの大きさを取得 */
    image_width = cairo_image_surface_get_width (glob.image);
    image_height = cairo_image_surface_get_height (glob.image);

    x_scaling = 1.0;
    y_scaling = 1.0;

    cairo_scale (cr, x_scaling, y_scaling);
    cairo_set_source_surface (cr, glob.image, 0, 0);
    cairo_paint (cr);
}


static void load_image ()
{
    cairo_t *ic;
    glob.image = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, BITMAP_WIDTH, BITMAP_HEIGHT);
    ic = cairo_create (glob.image);

    //長方形の描画
    {
        //色の指定(外枠：Red,Green,Blue)
        cairo_set_source_rgb(ic, 0.0, 0.0, 1.0);
        //長方形（x,y,width,height）を描画
        cairo_rectangle(ic, 0.0, 0.0, BITMAP_WIDTH, BITMAP_HEIGHT);
        //長方形の外枠を作る
        cairo_stroke_preserve(ic);
        //色を指定(塗りつぶし：Red,Green,Blue)
        cairo_set_source_rgb(ic, 0.0, 0.0, 1.0);
        //長方形を塗りつぶす
        cairo_fill(ic);
        cairo_stroke (ic);
    }
    cairo_destroy (ic);
}


static gpointer thread_func( gpointer data){
    int i, j, col, i1, depth;
    double xgap, ygap, xx, yy, a1, b1, x1, y1, tmp1, x2, y2;
    double xcorner, ycorner, length;

    cairo_t *ic;
    int count01;

    struct {
        double xcorner;
        double ycorner;
        double length;
    } param[8];

    param[0].xcorner = -1.785666666666666e+000; param[0].ycorner = -2.508333333333312e-002;
    param[0].length = 5.000000000000000e-002;

    param[1].xcorner = -1.759984700520832e+000; param[1].ycorner = -1.518603515624978e-002;
    param[1].length = 9.765625000000001e-005;

    param[2].xcorner = -1.759906697591145e+000; param[2].ycorner = -1.515360514322895e-002;
    param[2].length = 6.103515625000000e-006;

    param[3].xcorner = -1.759901244004566e+000; param[3].ycorner = -1.515219028790770e-002;
    param[3].length = 4.768371582031250e-008;

    param[4].xcorner = -1.759901209723814e+000; param[4].ycorner = -1.515217680089193e-002;
    param[4].length = 5.820766091346741e-012;

    param[5].xcorner = -2.112213541666665e-001; param[5].ycorner = -7.939140624999994e-001;
    param[5].length = 1.562500000000000e-003;

    param[6].xcorner = -2.238124999999996e-001; param[6].ycorner = -6.581041666666665e-001;
    param[6].length = 1.250000000000000e-002;

    param[7].xcorner = -2.137343749999995e-001; param[7].ycorner = -6.554270833333333e-001;
    param[7].length = 3.906250000000000e-004;

    ic = cairo_create (glob.image);

    start_time = seconds();

    for (count01 = 0; count01 < 8; count01++) {
        cairo_set_source_rgb(ic, 0.0, 0.0, 1.0);
        cairo_rectangle(ic, 0.0, 0.0, BITMAP_WIDTH, BITMAP_HEIGHT);
        cairo_stroke_preserve(ic);
        cairo_set_source_rgb(ic, 0.0, 0.0, 1.0);
        cairo_fill(ic);

        xcorner = param[count01].xcorner;
        ycorner = param[count01].ycorner;
        length  = param[count01].length;
        depth   = 1000;

        xgap = length / BITMAP_WIDTH;
        ygap = length / BITMAP_HEIGHT;

        gdk_threads_enter();
        sprintf(buf, "xcorner = %.15e, ycorner = %.15e\n", xcorner, ycorner);
        append_text(GTK_TEXT_VIEW(textview), buf);
        sprintf(buf, "length = %.15e\n", length);
        append_text(GTK_TEXT_VIEW(textview), buf);
        sprintf(buf, "depth = %d\n\n", depth);
        append_text(GTK_TEXT_VIEW(textview), buf);
        gdk_threads_leave();
        usleep(10000);
        gdk_threads_enter();
        scroll_to_bottom(scrolledwindow);
        gdk_threads_leave();

        xx = xcorner;
        yy = ycorner;
        for(j = 0; j < BITMAP_HEIGHT; j++) {
            ic = cairo_create (glob.image);
            for(i = 0; i < BITMAP_WIDTH; i++) {
                a1 = xx;     b1 = yy;
                i1 = 0;
                x1 = 0;      y1 = 0;
                x2 = x1 * x1;
                y2 = y1 * y1;
                while ((i1 < depth) && (x2+y2 <=4)) {
                    tmp1 = x2 - y2 + a1;
                    y1 = 2 * x1 * y1 + b1;
                    x1 = tmp1;
                    x2 = x1 * x1;
                    y2 = y1 * y1;
                    i1++;
                }
                if (i1 == depth) i1 = 0;
                else i1++;

                col = i1;
                gdk_threads_enter();
                cairo_set_source_rgb(ic, (col % 256) / 256.0, 0.0, 0.0);
                cairo_rectangle(ic, (double)i, (double)j, 1.0, 1.0);
                cairo_stroke(ic);
                gdk_threads_leave();

                xx = xx + xgap;
            }
            yy = yy + ygap;
            xx = xcorner;

            if (j % 5 == 0) {
                gdk_threads_enter();
                gtk_widget_queue_draw(darea);
                gdk_threads_leave();
            }
            usleep(1000);
        }
        gdk_threads_enter();
        gtk_widget_queue_draw(darea);
        gdk_threads_leave();
        usleep(50000);
    }
    end_time = seconds();

    gdk_threads_enter();
    sprintf(buf, "実行時間：  %f秒", end_time - start_time);
    append_text(GTK_TEXT_VIEW(textview), buf);
    gdk_threads_leave();
    usleep(50000);
    gdk_threads_enter();
    scroll_to_bottom(scrolledwindow);
    gdk_threads_leave();


    cairo_destroy (ic);
    execflag01 = 0;
}


static void on_button01_clicked(GtkWidget *button, gpointer user_data){
    GError *error;
    if (execflag01 == 0) {
        execflag01 = 1;
        count = BITMAP_HEIGHT;
        time_count = 1000;
        thread = g_thread_create( thread_func, (gpointer)darea, FALSE, &error);
    }
}

void delete_text(GtkTextView *textview){
    GtkTextBuffer *buffer;
    GtkTextIter start, end;
    buffer = gtk_text_view_get_buffer(textview);
    gtk_text_buffer_get_start_iter (buffer , &start);
    gtk_text_buffer_get_end_iter (buffer , &end);
    gtk_text_buffer_delete(buffer, &start, &end);
}

void set_text(GtkTextView *textview, const gchar *text)
{
    GtkTextBuffer *buffer;
    buffer = gtk_text_view_get_buffer(textview);
    gtk_text_buffer_set_text(buffer, text, -1);
}

void append_text(GtkTextView *textview , const gchar *text)
{
    GtkTextBuffer *buffer;
    GtkTextIter iter;
    buffer = gtk_text_view_get_buffer (textview);
    gtk_text_buffer_get_end_iter(buffer, &iter);
    gtk_text_buffer_insert(buffer, &iter, text, -1);
}

void scroll_to_bottom(GtkScrolledWindow *scrolled_window)
{
    GtkAdjustment *vadj;
    gdouble size;
    vadj = gtk_scrolled_window_get_vadjustment(scrolled_window);
    size = gtk_adjustment_get_upper(vadj) - gtk_adjustment_get_page_size(vadj);
    if (size < 0) size = 0.0;
    gtk_adjustment_set_value(vadj, size);
}

double seconds() {
    struct timeval tm;
    double t ;
    static int base_sec = 0,base_usec = 0;
    gettimeofday(&tm, NULL);
    if(base_sec == 0 && base_usec == 0)
    {
        base_sec = tm.tv_sec; base_usec = tm.tv_usec; t = 0.0;
    } else {
        t = (double) (tm.tv_sec-base_sec) + ((double) (tm.tv_usec-base_usec))/1.0e6 ;
    }
    return t;
}


int main (int argc, char *argv[])
{
    load_image ();
    execflag01 = 0;
    gtk_init (&argc, &argv);
    gdk_threads_init();

    gdk_threads_enter();

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_container_set_border_width(GTK_CONTAINER(window), 5);

    vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
    gtk_container_add(GTK_CONTAINER(window), vbox);

    darea = gtk_drawing_area_new ();
    gtk_box_pack_start(GTK_BOX(vbox), darea, FALSE, FALSE, 0);
    gtk_widget_set_size_request(darea, BITMAP_WIDTH, BITMAP_HEIGHT);

    hbox01 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
    button02 = gtk_button_new_from_stock(GTK_STOCK_QUIT);
    gtk_box_pack_end(GTK_BOX(hbox01), button02, FALSE, FALSE, 0);

    button01 = gtk_button_new_with_label("開始");
    gtk_box_pack_end(GTK_BOX(hbox01), button01, FALSE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(vbox), hbox01, FALSE, FALSE, 0);

    vbox02 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
    scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_SHADOW_ETCHED_OUT);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_widget_set_size_request(GTK_SCROLLED_WINDOW(scrolledwindow), BITMAP_HEIGHT, TEXTVIEW_HEIGHT);
    gtk_box_pack_start(GTK_BOX(vbox02), scrolledwindow, TRUE, TRUE, 0);

    textview = gtk_text_view_new();
    gtk_container_add(GTK_CONTAINER(scrolledwindow), textview);
    set_text(GTK_TEXT_VIEW(textview), "");

    gtk_box_pack_start(GTK_BOX(vbox), vbox02, FALSE, FALSE, 0);

    g_signal_connect(G_OBJECT(button01), "clicked", G_CALLBACK(on_button01_clicked), NULL);
    g_signal_connect (G_OBJECT (darea), "draw", G_CALLBACK (on_draw_event), NULL);
    g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(button02), "clicked", G_CALLBACK(gtk_main_quit), NULL);

    gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
    gtk_window_set_title (GTK_WINDOW (window), "Cairo Test");
    gtk_window_set_decorated (GTK_WINDOW (window), TRUE);
    gtk_widget_set_size_request(window, BITMAP_WIDTH, BITMAP_HEIGHT + 30 + TEXTVIEW_HEIGHT);

    gtk_widget_show_all (window);
    gtk_main ();

    gdk_threads_leave();

    cairo_surface_destroy (glob.image);
    return 0;
}