path: root/ka_controller.py

# coding: UTF8
# Copyright 2009 Thomas Jourdan
#
# This program 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; either version 3 of the License, or
# (at your option) any later version.
#
# This program 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, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

import hashlib 
import gtk
import gtk.glade
import cairo
import ka_debug
import model_population
import ka_incoming
import kandidtube
import ka_random
import ka_task

class KandidController(object):
    """
    inv: self.model is not None
    inv: self._canvas is not None
    """

    def __init__(self, init_canvas):
        """
        pre: init_canvas is not None
        """
        self._canvas = init_canvas
        self._tube = None

        # create to data model
        self.model = model_population.KandidModel(12)
        self.model.randomize()
        self.incoming = ka_incoming.KandidIncoming(3)
        
        self.surface_cache = {}
        
        #Create a dictionary to connect events
        events = {
                'on_breed_generation' : self.on_breed_generation,
                'on_random_generation' : self.on_random_generation,
                'on_flurry_value_changed' : self.on_flurry_value_changed,
                'on_decline_incoming' : self.on_decline_incoming,
                'on_accept_incoming' : self.on_accept_incoming,
                'delete_event' : gtk.main_quit }
        for cell_index in range(self.model.size):
            strix = str(cell_index)
            key = 'on_drawingarea_#_expose'.replace('#', strix)
            events[key] = self.on_drawingarea_expose
            key = 'on_drawingarea_#_size_allocate'.replace('#', strix)
            events[key] = self.on_drawingarea_size_allocate
            key = 'on_fitness_#_value_changed'.replace('#', strix)
            events[key] = self.on_fitness_value_changed
            key = 'on_protozoon_popup_#'.replace('#', strix)
            events[key] = self.on_protozoon_popup
            key = 'on_publishprotozoon_activate_#'.replace('#', strix)
            events[key] = self.on_publishprotozoon_activate
            events['on_favorite_activate_' + strix] = self.on_favorite_activate
            events['on_awfull_activate_' + strix] = self.on_awfull_activate
        for cell_index in range(3):
            strix = str(cell_index)
            key = 'on_incomingarea_#_expose'.replace('#', strix)
            events[key] = self.on_incomingarea_expose
            key = 'on_incoming_#_popup'.replace('#', strix)
            events[key] = self.on_incoming_popup
        self._canvas.widgetTree.signal_autoconnect(events)
        self._update_gui()

    def _update_model(self, in_model):
        if in_model:
            self.model = in_model
            self.model._state = model_population.STATE_EVOLVED
        self._update_gui()

    def _update_gui(self):
        for cell_index in range(self.model.size):
            strix = str(cell_index)
            key = 'fitness_#'.replace('#', strix)
            self._canvas.widgetTree.get_widget(key). \
                set_value(self.model.fitness[cell_index])
        self._canvas.widgetTree.get_widget('flurrySpinButton'). \
            set_value(self.model.flurry_rate)

    def _draw_from_cache(self, widget, cell_index):
        if self.surface_cache.has_key(cell_index):
            ka_debug.info('_draw_from_cache: ' + widget.name + ' ' + str(cell_index))
            ctx = self._create_context(widget)
            ctx.set_operator(cairo.OPERATOR_SOURCE)
            ctx.set_source_surface(self.surface_cache[cell_index])
            ctx.paint()

    def on_drawingarea_expose(self, widget, event):
        """ Repaint image of a single protozoon inside population area.
        pre: widget is not None
        """
        # draw precalculated protozoon stored in the surface cache. 
        ka_debug.info('on_drawingarea_expose: ' + widget.name + ' ' 
                      + str(widget.allocation.width) 
                      + 'x' + str(widget.allocation.height))
        self._draw_from_cache(widget, _name_to_index(widget.name))

    def on_drawingarea_size_allocate(self, widget, event):
        """ New size for drawing area available.
        pre: widget is not None
        """
        ka_debug.info('on_drawingarea_size_allocate: ' + widget.name + ' ' 
                      + str(widget.allocation.width) 
                      + 'x' + str(widget.allocation.height))
        self._start_calculation([_name_to_index(widget.name)])

    def _create_context(self, widget):
        """ Create cairo context.
        pre: widget is not None
        """
        ctx = widget.window.cairo_create()
        ctx.rectangle(0, 0, \
                      widget.allocation.width, widget.allocation.height)
        ctx.clip()
        return ctx

    def on_fitness_value_changed(self, *args):
        """
        pre: len(args) >= 1
        """
        ka_debug.info('on_fitness_value_changed %f [%s]' % 
                   (args[0].get_value(), args[0].get_name()))
        self.model.fitness[_name_to_index(args[0].get_name())] \
            = args[0].get_value()

    def on_breed_generation(self, *args):
        if ka_task.is_completed():
            ka_debug.info('on_breed_generation entry')
            ka_task.GeneratorTask(self.task_breed_generation, 
                                  self.on_model_completed).start()
            ka_debug.info('on_breed_generation exit')
        else:
            ka_debug.info('on_breed_generation ignored')
    
    def on_random_generation(self, *args):
        if ka_task.is_completed():
            ka_debug.info('on_random_generation entry')
            ka_task.GeneratorTask(self.task_random_generation, 
                                  self.on_model_completed).start()
            ka_debug.info('on_random_generation exit')
        else:
            ka_debug.info('on_random_generation ignored')
    
    def on_model_completed(self, *args):
        """
        pre: len(args) == 1
        """
        ka_debug.info('on_model_completed entry')
        for cell_index in args[0]:
            self._canvas.widgetTree.get_widget('vbox_' + str(cell_index)). \
                                                          set_sensitive(False)
        self._start_calculation(args[0])
        ka_debug.info('on_model_completed exit')

    def _start_calculation(self, concerned):
        """
        pre: len(concerned) > 0
        pre: forall(concerned, lambda x: 0 <= x <= self.model.size)
        """
        for cell_index in concerned:
            widget = self._canvas.widgetTree.get_widget('drawingarea_'
                                                        + str(cell_index))
            task = ka_task.GeneratorTask(self.task_draw,
                                         self.on_image_completed)
            task.start(self.model.protozoans[cell_index], cell_index,
                       widget.allocation.width, widget.allocation.height)

    def task_breed_generation(self, *args, **kwargs):
        """
        pre: len(args) == 0
        """
        ka_debug.info('task_breed_generation entry')
        new_indices = self.model.breed()
        ka_debug.info('task_breed_generation exit')
        return new_indices

    def task_random_generation(self, *args, **kwargs):
        """
        pre: len(args) == 0
        """
        ka_debug.info('task_random_generation entry')
        new_indices = self.model.random()
        ka_debug.info('task_random_generation exit')
        return new_indices

    def task_draw(self, *args, **kwargs):
        """
        pre: len(args) == 4
        """
        protozoon, cell_index, width, height = args[0], args[1], args[2], args[3]
        ka_debug.info('task_draw entry: ' + str(cell_index))
        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
        ctx = cairo.Context(surface)
        protozoon.draw(ctx, width, height)
        self.surface_cache[cell_index] = surface
        ka_debug.info('task_draw exit: ' + str(cell_index))
        return cell_index

    def on_image_completed(self, *args):
        ka_debug.info('on_image_completed: ' + str(args[0]))
        cell_index = args[0]
        widget = self._canvas.widgetTree.get_widget('drawingarea_'
                                                    + str(cell_index))
        self._draw_from_cache(widget, cell_index)
        self._canvas.widgetTree.get_widget('vbox_' + str(cell_index)). \
                                                            set_sensitive(True)
        self._canvas.widgetTree.get_widget('fitness_' + str(cell_index)). \
                                      set_value(self.model.fitness[cell_index])    

    def on_flurry_value_changed(self, *args):
        """
        pre: len(args) >= 1
        pre: 0 <= args[0].get_value() <= 9
        """
        ka_debug.info('on_flurry_value_changed [%s]' % args[0].get_value())
        ka_random.set_flurry(args[0].get_value())

    def on_protozoon_popup(self, widget, event):
        ka_debug.info('on_protozoon_popup: ' + widget.name)
        self._show_popup(widget, event, \
                         'protozoon_menu_%u' % _name_to_index(widget.name))

    def on_publishprotozoon_activate(self, *args):
        """Publish single protozoon to all other buddies.
        pre: len(args) >= 1
        """
        ka_debug.info('on_publishprotozoon_activate [%s]' % args[0].get_name())
        if self._tube:
            proto = self.model.protozoans[_name_to_index(args[0].get_name())]
            self._tube.publish_protozoon(model_population.to_buffer(proto))

    def on_favorite_activate(self, *args):
        """Set best ranking for this protozoon.
        pre: len(args) >= 1
        """
        ka_debug.info('on_favorite_activate [%s]' % args[0].get_name())
        self.model.raise_fitness(_name_to_index(args[0].get_name()))
        self._update_gui()

    def on_awfull_activate(self, *args):
        """Set last ranking for this protozoon.
        pre: len(args) >= 1
        """
        ka_debug.info('on_awfull_activate [%s]' % args[0].get_name())
        self.model.reduce_fitness(_name_to_index(args[0].get_name()))
        self._update_gui()

    def on_received(self, code_type, code_element, code_md5):
        """Update population or protozoon preview when received from others."""
        ka_debug.info('on_received: Received %u bytes, type: [%s] md5: [%s]' % \
                   (len(code_element), code_type, code_md5))
        if hashlib.md5(code_element).hexdigest() == code_md5:
            inbox_widget = self._canvas.widgetTree.get_widget('incomingBox')
            if code_type == kandidtube.SEND_POPULATION:
                if self.is_overwrite_allowed:
                    self._update_model(model_population.from_buffer(code_element))
                    self.model._state = model_population.STATE_EVOLVED
                    inbox_widget.queue_draw()
                else:
                    ka_debug.info("I've already an evolved population, doing nothing")
            elif code_type == kandidtube.SEND_PROTOZOON:
                self.incoming.append_protozoon(model_population.from_buffer(code_element))
                inbox_widget.queue_draw()
            else:
                ka_debug.info('Somebody called me using an illegal type [%s]' \
                           % code_type)
        else:
            ka_debug.info('Somebody called me with an corrupt data model')

    def on_new_tube(self, tube, is_initiator, get_buddy):
        """Creates communication object and sends population
        pre: tube > 0
        pre: get_buddy is not None
        """
        self._tube = kandidtube.KandidTube(self,
                                           tube,
                                           is_initiator,
                                           get_buddy)

# Event handling for incoming protozoans
    def on_incoming_popup(self, widget, event):
        ka_debug.info('on_incoming_popup: ' + widget.name)
        index = _name_to_index(widget.name)
        self._show_popup(widget, event, 'incoming_menu_'+ str(index))

    def _show_popup(self, widget, event, menu):
        ka_debug.info('%s [%s]' % (menu, widget.name))
        popup_menu = self._canvas.widgetTree.get_widget(menu)
        popup_menu.popup(None, None, None, event.button, event.time)

    def on_accept_incoming(self, menu_item):
        ka_debug.info('on_accept_incoming [%s]' % menu_item.parent.name)
        new_at = self.incoming.accept_protozoon(self.model, \
                                       _name_to_index(menu_item.parent.name))
        self._start_calculation([new_at])
#        self._update_gui()
        inbox_widget = self._canvas.widgetTree.get_widget('incomingBox')
        inbox_widget.queue_draw()

    def on_decline_incoming(self, menu_item):
        ka_debug.info('on_decline_incoming [%s]' % menu_item.parent.name)
        self.incoming.decline_protozoon(_name_to_index(menu_item.parent.name))
        inbox_widget = self._canvas.widgetTree.get_widget('incomingBox')
        inbox_widget.queue_draw()

    def on_incomingarea_expose(self, widget, event):
        """ Repaint image of a single protozoon inside incoming area.
        pre: widget is not None
        """
        ka_debug.info('on_incomingarea_expose: ' + widget.name)
        self.incoming.draw(_name_to_index(widget.name), \
                           self._create_context(widget), \
                           widget.allocation.width, widget.allocation.height)

# data model and persistence
    def is_overwrite_allowed(self):
        """Preserve an already evolved population from over writing."""
        return self.model.is_overwrite_allowed()

    def serialize_model(self):
        """Serialize population to a string buffer."""
        return model_population.to_buffer(self.model)

    def read_file(self, file_path):
        """Delegate reading from journal to data model
        pre: (file_path is not None) and (len(file_path) >= 1)
        """
        self._update_model(model_population.read_file(file_path))
    
    def write_file(self, file_path):
        """Delegate writing data model to journal
        pre: (file_path is not None) and (len(file_path) >= 1)
        """
        model_population.write_file(file_path, self.model)

def _name_to_index(name):
    """Extract index from last part of a name.
    Parts are separated by _.
    pre: name[-1].isdigit()
    post: __return__ >= 0
    """
    return int(name.rsplit('_')[-1])