# -*- coding: utf_8 -*-

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import GLib
from gi.repository import GObject
import cairo
import threading
import time

class Window01(Gtk.Window):
    def __init__(self):
        self.bitmap_width = 300
        self.bitmap_height = 300
        self.textview_height = 150
        self.window_width = 300
        self.window_height = self.bitmap_width + 30 + self.textview_height


        Gtk.Window.__init__(self)
        self.set_title('Mandelbrot Test')
        self.set_position(Gtk.WindowPosition.CENTER)
        self.set_property("width-request", self.bitmap_width)
        self.set_property("height-request", self.bitmap_height + 30)

        self.stopflag01 = 0
        self.execflag01 = 0

        self.load_image()
        self.vbox = Gtk.Box()
        self.vbox.set_orientation(Gtk.Orientation.VERTICAL)
        self.add(self.vbox)

        self.darea = Gtk.DrawingArea()
        self.darea.set_property("width-request", self.bitmap_width)
        self.darea.set_property("height-request", self.bitmap_height)
        self.vbox.pack_start(self.darea, False, False, 0)

        self.hbox = Gtk.Box()
        self.hbox.set_orientation(Gtk.Orientation.HORIZONTAL)
        self.vbox.pack_start(self.hbox, False, False, 0)

        self.button03 = Gtk.Button(Gtk.STOCK_QUIT)
        self.button03.set_label('終了')
        self.hbox.pack_end(self.button03, False, False, 0)
        self.button03.connect('clicked', self.button03_clicked)

        self.button01 = Gtk.Button()
        self.button01.set_label('開始')
        self.hbox.pack_end(self.button01, False, False, 0)
        self.button01.connect('clicked', self.button01_clicked)

        self.button02 = Gtk.Button()
        self.button02.set_label('中断')
        self.hbox.pack_end(self.button02, False, False, 0)
        self.button02.connect('clicked', self.button02_clicked)

        self.vbox02 = Gtk.Box()
        self.vbox02.set_orientation(Gtk.Orientation.VERTICAL)
        self.vbox.pack_start(self.vbox02, False, False, 0)

        self.scrolled_window01 = Gtk.ScrolledWindow()
        self.scrolled_window01.set_shadow_type(Gtk.ShadowType.ETCHED_OUT)
        self.scrolled_window01.set_policy(Gtk.PolicyType.ALWAYS, Gtk.PolicyType.ALWAYS)
        self.scrolled_window01.set_property("width-request", self.window_width)
        self.scrolled_window01.set_property("height-request", self.textview_height)
        self.vbox02.pack_start(self.scrolled_window01, False, False, 0)

        self.textview01 = Gtk.TextView()
        self.scrolled_window01.add(self.textview01)
        self.set_text(self.textview01, "")

        self.darea.connect('draw', self.on_draw_event)
        self.connect('delete-event', Gtk.main_quit)

    def delete_text(self, textview):
        buffer = textview.get_buffer()
        start = buffer.get_start_iter()
        end = buffer.get_end_iter()
        buffer.delete(start, end)

    def set_text(self, textview, text):
        buffer = textview.get_buffer()
        buffer.set_text(text)

    def append_text(self, textview, text):
        buffer = textview.get_buffer()
        iter = buffer.get_end_iter()
        buffer.insert(iter, text)

    def scroll_to_bottom(self, scrolled_window):
        vadj = scrolled_window.get_vadjustment()
        size = vadj.get_upper() - vadj.get_page_size()
        if size < 0:
            size = 0
        vadj.set_value(size)


    def on_draw_event(self, drawingarea, cr):
        self.do_drawing(drawingarea, cr)

    def do_drawing(self, drawingarea, cr):
        screen_width = Gdk.Screen.get_width(Gdk.Screen.get_default())
        screen_height = Gdk.Screen.get_height(Gdk.Screen.get_default())
        image_width = self.image.get_width()
        image_height = self.image.get_height()
        x_scaling = 1.0;
        y_scaling = 1.0;
        cr.scale(x_scaling, y_scaling);
        cr.set_source_surface (self.image, 0, 0);
        cr.paint ();

    def load_image(self):
        self.image = cairo.ImageSurface(cairo.FORMAT_ARGB32, self.bitmap_width, self.bitmap_height)
        ic = cairo.Context(self.image)

        #色の指定(外枠：Red,Green,Blue)
        ic.set_source_rgb(0.0, 0.0, 1.0)
        #長方形（x,y,width,height）を描画
        ic.rectangle(0.0, 0.0, self.image.get_width(), self.image.get_height())
        #長方形の外枠を作る
        ic.stroke_preserve()
        #色を指定(塗りつぶし：Red,Green,Blue)
        ic.set_source_rgb(0.0, 0.0, 1.0)
        #長方形を塗りつぶす
        ic.fill()
        ic.stroke()

    def button01_clicked(self, button01):
        if self.execflag01 == 0:
            self.execflag01 = 1
            self.stopflag01 = 0
            self.thread = threading.Thread(target=self.thread_func)
            self.thread.start()

    def button02_clicked(self, button02):
        self.stopflag01 = 1

    def button03_clicked(self, button01):
        self.stopflag01 = 1
        Gtk.main_quit()

    def thread_func(self):
        param_xcorner = []
        param_ycorner = []
        param_length = []

        param_xcorner.append(-1.785666666666666e+000)
        param_ycorner.append(-2.508333333333312e-002)
        param_length.append(5.000000000000000e-002)

        param_xcorner.append(-1.759984700520832e+000)
        param_ycorner.append(-1.518603515624978e-002)
        param_length.append(9.765625000000001e-005)

        param_xcorner.append(-1.759906697591145e+000)
        param_ycorner.append(-1.515360514322895e-002)
        param_length.append(6.103515625000000e-006)

        param_xcorner.append(-1.759901244004566e+000)
        param_ycorner.append(-1.515219028790770e-002)
        param_length.append(4.768371582031250e-008)

        param_xcorner.append(-1.759901209723814e+000)
        param_ycorner.append(-1.515217680089193e-002)
        param_length.append(5.820766091346741e-012)

        param_xcorner.append(-2.112213541666665e-001)
        param_ycorner.append(-7.939140624999994e-001)
        param_length.append(1.562500000000000e-003)

        param_xcorner.append(-2.238124999999996e-001)
        param_ycorner.append(-6.581041666666665e-001)
        param_length.append(1.250000000000000e-002)

        param_xcorner.append(-2.137343749999995e-001)
        param_ycorner.append(-6.554270833333333e-001)
        param_length.append(3.906250000000000e-004)

        self.start_time = time.time()

        ic = cairo.Context(self.image)
        for count01 in range(0, len(param_xcorner)):
           ic.set_source_rgb(0.0, 0.0, 1.0)
           ic.rectangle(0.0, 0.0, self.image.get_width(), self.image.get_height())
           ic.stroke_preserve()
           ic.set_source_rgb(0.0, 0.0, 1.0)
           ic.fill()
           ic.stroke()

           xcorner = param_xcorner[count01]
           ycorner = param_ycorner[count01]
           length = param_length[count01]
           depth = 1000;

           xgap = length / self.bitmap_width
           ygap = length / self.bitmap_height
           xx = xcorner
           yy = ycorner

           Gdk.threads_enter()
           self.append_text(self.textview01, "xcorner = {0:.15e}\n".format(xcorner))
           self.append_text(self.textview01, "ycorner = {0:.15e}\n".format(ycorner))
           self.append_text(self.textview01, "length = {0:.15e}\n".format(length))
           self.append_text(self.textview01, "depth = {0:d}\n".format(depth))
           self.append_text(self.textview01, "\n")
           Gdk.threads_leave()
           time.sleep(0.005)
           Gdk.threads_enter()
           self.scroll_to_bottom(self.scrolled_window01)
           Gdk.threads_leave()
           for j in range(0, self.bitmap_height):
               for i in range(0, self.bitmap_width):
                   a1 = xx
                   b1 = yy
                   i1 = 0
                   x1 = 0
                   y1 = 0
                   x2 = x1 * x1
                   y2 = y1 * y1
                   while (i1 < depth) and (x2 + y2 <= 4.0):
                       if self.stopflag01 == 1:
                           self.execflag01 = 0
                           return
                       tmp1 = x2 - y2 + a1
                       y1 = 2 * x1 * y1 + b1
                       x1 = tmp1
                       x2 = x1 * x1
                       y2 = y1 * y1
                       i1 = i1 + 1
                   if i1 == depth:
                       i1 = 0
                   else:
                       i1 = i1 + 1
                   col = i1

                   Gdk.threads_enter()
                   ic.set_source_rgb((col % 256) / 256.0, 0.0, 0.0)
                   ic.rectangle(i, j, 1.0, 1.0)
                   ic.stroke()
                   Gdk.threads_leave()
                   xx = xx + xgap
               yy = yy + xgap
               xx = xcorner
               if j % 5 == 0:
                   Gdk.threads_enter()
                   self.darea.queue_draw()
                   Gdk.threads_leave()
               time.sleep(0.001)
           Gdk.threads_enter()
           self.darea.queue_draw()
           Gdk.threads_leave()
           time.sleep(0.05)
        self.end_time = time.time()
        Gdk.threads_enter()
        self.append_text(self.textview01, "実行時間 : {0:.4f}秒\n".format(self.end_time - self.start_time))
        self.scroll_to_bottom(self.scrolled_window01)
        Gdk.threads_leave()

        self.execflag01 = 0

GObject.threads_init()
Gdk.threads_init()
Gdk.threads_enter()
window = Window01()
window.show_all()
Gtk.main()
Gdk.threads_leave()