path: root/ReckonPrimer.activity/display.py

#! -*- coding: utf-8 -*-
#(c) Stefan Heher 2009
#1234567890123456789012345678901234567890123456789012345678901234567890123456789
import gtk
import pygtk
import pango
import time
import gobject
from timer import Timer
from collection import Collection
from exstore import ExStore
from sugar import profile
from sugar.graphics import style
from sugar.activity import activity

class Display:
    """print "root: ", self._root
    Definition and manipulation of all GUI-elemts.
    Exception (redesign?): def define_buttons in classes derived from Exercise.
    """
    #print("in display, class definition")
    #DnD: Allowed targets
    TARGETS = [
        ('pixbuf', gtk.TARGET_SAME_WIDGET, 0),
        ('text', gtk.TARGET_SAME_WIDGET, 1)
        ]

    def __init__(self, window):
        self._drag_and_drop = False # set true to enable drag and drop
        self._coll = None # object holding current data from ExStore
        self._root = None # relates _data to _coll
        self._data = None # list of current data from ExStore
        self._selected = None #Tuple containing position of selected object
        self._from = None # dragposition on treeview
        self._to = None   # dropposition on treeview
        self._to_spec = None   # specific for dropposition
        self._permanent_gui_elements(window)
        self.total_calcs = 0   #number of calculations in one exercise
        self.errors = 0
                               # TODO: imprive information hiding
        self._sett = None      # setting updated by callbacks during input
        self.running = False   # switch settings_/feedback_table TODO rename
        self._coll_key = None  # semaphore for self.finish_collect_callback
                               # and Collection.select_exerc_callback
        self._testvar = 'FOUND'


    def register(self, sess, co, learner, exstore):
        """register _after_ Session and Coach have been instantiated"""
        self._sess = sess
        self._co = co
        self._learner = learner
        self.current_exercisestore = exstore

    def _permanent_gui_elements(self, window):
        # The display is partitioned as follows
        #
        # table:
        # 0                         1                        2
        #0+-------------------------+------------------------+
        # |                         |                        |
        #1|                         |  OVERLAYS OF           |
        # |  scrolled_window        |    exstore_table       |
        #2|                         |  OR                    |
        # |                         |    settings_table      |
        #3+-------------------------+  OR                    |
        # |                         |    exercise_table      |
        #4|  calcs,                 |    (incliding feedback |
        # |  info_table, etc        |     _table             |
        #5+-------------------------+------------------------+

        self.main_window = window            # Save the sugar main window

        # whole window with 5 lines and 2 columns
        #self.table = gtk.Table(5, 2, True)
        self.table = gtk.Table(10, 2, True)
        self.table.set_row_spacings(2)
        self.table.set_col_spacings(2)
        self.main_window.set_canvas(self.table)

        self.log_buffer = gtk.TextBuffer()
        self.tag_table = self.log_buffer.get_tag_table()

        self.error_tag = gtk.TextTag("error")    # tag for errors
        self.error_tag.set_property("foreground", "blue")
        self.tag_table.add(self.error_tag)
        self.correct_tag = gtk.TextTag("correct")# tag for correct calcs
        self.correct_tag.set_property("foreground", "green")
        self.tag_table.add(self.correct_tag)

        # Create a log_view with the previously created log_buffer
        self.log_view = gtk.TextView(self.log_buffer)
        # Set the font size for the log_view
        self.log_view.modify_font(pango.FontDescription('sans bold 14'))
        self.log_view.set_editable(False)
        self.log_view.set_cursor_visible(False)
        self.log_view.set_justification(gtk.JUSTIFY_CENTER)

        self.scrolled_window = gtk.ScrolledWindow() # for the log_view
        self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
                                        gtk.POLICY_AUTOMATIC)

        # Connect log_view and scrolled window
        self.scrolled_window.add(self.log_view)
        # Insert the log_view into the upper half on left side
        # TODO make bottom depend on exercise._sett['calclines']
        #self.table.attach(self.scrolled_window, 0, 1, 0, 3)
        self.table.attach(self.scrolled_window, 0, 1, 0, 5)
        self.log_view.show()
        self.scrolled_window.show()
        # make empty lines such that all calcs are entered at bottom
        for i in range(1,21):
            end_iterator = self.log_buffer.get_end_iter()
            self.log_buffer.insert(end_iterator, "\n")
            self.log_view.scroll_mark_onscreen(self.log_buffer.get_insert())

        # 3 tables as overlays with same 15 lines and 6 columns
        self.exercise_table = gtk.Table(14, 9, True)
        self.exercise_table.set_row_spacings(2)
        self.exercise_table.set_col_spacings(2)
        self.exstore_table = gtk.Table(14, 9, True)
        self.exstore_table.set_row_spacings(2)
        self.exstore_table.set_col_spacings(2)
        self.settings_table = gtk.Table(14, 9, True)
        self.settings_table.set_row_spacings(2)
        self.settings_table.set_col_spacings(2)
        #feedback_table
        self.feedback_table = gtk.Table  (3, 12, True)
        self.feedback_table.set_row_spacings(2)
        self.feedback_table.set_col_spacings(2)
        # info_table is showen in the left_bottom area
        self.info_table = gtk.Table(7, 20, True)
        #title
        self.label0 = gtk.Label("Title: ")
        self.label0.modify_font(pango.FontDescription("sans bold 12"))
        self.label0.set_alignment(0, 0.5)
        self.info_table.attach(self.label0, 1, 10, 0, 1)
        self.label0.show()
        self._title_buffer = gtk.TextBuffer()
        self._title = gtk.TextView(self._title_buffer)
        self._title.modify_font(pango.FontDescription('sans 12'))
        self._title.set_editable(False)
        self._title.set_cursor_visible(False)
        self.info_table.attach(self._title, 1, 19, 1, 2)
        self._title.show()
        #description
        self.label1 = gtk.Label("Description: ")
        self.label1.modify_font(pango.FontDescription("sans bold 12"))
        self.label1.set_alignment(0, 0.5)
        self.info_table.attach(self.label1, 1, 10, 2, 3)
        self.label1.show()
        self._desc_buffer = gtk.TextBuffer()
        self._desc = gtk.TextView(self._desc_buffer)
        self._desc.modify_font(pango.FontDescription('sans 12'))
        self._desc.set_editable(False)
        self._desc.set_cursor_visible(False)
        self.desc_scrolled_window = gtk.ScrolledWindow()
        self.desc_scrolled_window.set_policy(gtk.POLICY_NEVER,
                                        gtk.POLICY_ALWAYS)
        self.info_table.attach(self.desc_scrolled_window, 1, 19, 3, 6)
        self.desc_scrolled_window.add(self._desc)
        self._desc.set_wrap_mode(gtk.WRAP_WORD)
        self._desc.show()
        self.desc_scrolled_window.show()
        #calculations
        self.ex_name_label = gtk.Label("Calculations: ")
        self.ex_name_label.modify_font(pango.FontDescription("sans bold 12"))
        self.ex_name_label.set_alignment(0, 0.5)
        self.info_table.attach(self.ex_name_label, 1, 7, 6, 7)
        #self.ex_name_label.show()
        self.ex_num_label = gtk.Label("")
        self.ex_num_label.modify_font(pango.FontDescription("sans 12"))
        self.info_table.attach(self.ex_num_label, 7, 9, 6, 7)
        self.ex_num_label.show()
        # Insert the 3 tables into the right half of the screen
        #self.table.attach(self.exercise_table,   1, 2, 0, 5)
        self.table.attach(self.exercise_table,   1, 2, 0, 10)
        #self.table.attach(self.exstore_table,   1, 2, 0, 5)
        self.table.attach(self.exstore_table,   1, 2, 0, 10)
        #self.table.attach(self.settings_table,  1, 2, 0, 5)
        self.table.attach(self.settings_table,  1, 2, 0, 10)
        #self.table.attach(self.info_table,  0, 1, 3, 5)
        self.table.attach(self.info_table,  0, 1, 7, 10)

        self.exercise_table.attach(self.feedback_table,  0, 9, 11, 13)
        # show all tables, scrolled_window already shown above
        self.exstore_table.show() # treat uniformly !
        self.settings_table_show()   # treat uniformly <>!
        self.info_table.show()
        self.feedback_table_init()
        self.table.show() # since all other tables have been inserted

    def update_time(self):
        minutes, seconds = divmod(self.stopwatch.elapsed, 60)
        if(minutes < 10 and seconds < 10):
            time = "0" + str(int(minutes)) + ":" + "0" + str(int(seconds))
        if(minutes > 9 and seconds > 9):
            time = str(int(minutes)) + ":" + str(int(seconds))
        if(minutes > 9 and seconds < 10):
            time = str(int(minutes)) + ":" + "0" + str(int(seconds))
        if(minutes < 10 and seconds > 10):
            time = "0" + str(int(minutes)) + ":" + str(int(seconds))
        self.stopwatch_label.set_label(time)
        self.stopwatch_label.queue_draw()
        return True

    def settings_table_show(self): # rename to .._permanent
        """ Initialize all permanent gui-elements in settings_table. """
        #finish/exit button
        self.sfb2_butt = gtk.Button(None, gtk.STOCK_STOP)
        self.sfb2_butt.connect("clicked", self.release_feedb_to_sett_callback)
        self.exercise_table.attach(self.sfb2_butt, 0, 9, 14, 15)
        self.sfb2_alignment = self.sfb2_butt.get_children()[0]
        self.sfb2_hbox = self.sfb2_alignment.get_children()[0]
        self.sfb2_image, self.sfb2_label = self.sfb2_hbox.get_children()
        self.sfb2_label.set_label("Back")
        self.sfb2_butt.hide()    # only show() if running calcs
        # button releasing settings_table and coach.notify('setting-done',..)
        self.see_butt = gtk.Button(None, gtk.STOCK_APPLY)   #GO_FORWARD
        self.see_butt.connect("clicked", self.release_sett_callback)
        #self.settings_table.attach(self.see_butt, 0, 5, 14, 15)
        self.settings_table.attach(self.see_butt, 0, 7, 14, 15)
        self.see_alignment = self.see_butt.get_children()[0]
        self.see_hbox = self.see_alignment.get_children()[0]
        self.see_image, self.see_label = self.see_hbox.get_children()
        self.see_label.set_label("Start")
        self.see_butt.show()
        # button switching from settings_table to collect_table
        self.sec_butt = gtk.Button()
        self.sec_butt = gtk.Button(None, gtk.STOCK_CANCEL)  #GO_BACK
        self.sec_butt.connect("clicked", self.switch_setts_to_coll_callback)
        self.settings_table.attach(self.sec_butt, 7, 9, 14, 15)
        self.sec_alignment = self.sec_butt.get_children()[0]
        self.sec_hbox = self.sec_alignment.get_children()[0]
        self.sec_image, self.sec_label = self.sec_hbox.get_children()
        self.sec_label.set_label("")
        self.sec_butt.show()

    def switch_setts_to_coll_callback(self, widget):
        """ Switch from settings_table to exstore_table. """
        #trigger update from pickle to show the correct number of calcs
        self._co._exstore.reload()
        # Rebuild settings_table to get rid of the buttons
        self.settings_table.destroy()
        self.settings_table = gtk.Table(14, 9, True)
        self.settings_table.set_row_spacings(2)
        self.settings_table.set_col_spacings(2)
        #self.table.attach(self.settings_table, 1, 2, 0, 5)
        self.table.attach(self.settings_table, 1, 2, 0, 10)
        self.settings_table_show()
        self.exstore_table.show()
        self.info_table.show()

    def feedback_table_init(self):
        """RENAME to draw_feedback_screen"""
        # Section for stopwatch
        self.stopwatch = Timer()
        self.stopwatch_label = gtk.Label()#"00:00")
        self.stopwatch_label.modify_font(pango.FontDescription("sans 16"))
        #self.feedback_table.attach(self.stopwatch_label, 5, 6, 12, 13)
        self.feedback_table.attach(self.stopwatch_label, 10, 12, 2, 3)

        # Section for nickname
        #self.name = profile.get_nick_name()
        #self.name_label = gtk.Label(self.name)
        #self.name_label.modify_font(pango.FontDescription("sans 16"))
        #self.feedback_table.attach(self.name_label, 0, 6, 13, 14)
        #self.feedback_table.attach(self.name_label, 0, 9, 13, 14)

        # Section for progress bar
        self.progressbar = gtk.ProgressBar(adjustment=None)

        # Color for progress bar
        style = self.progressbar.get_style()
        style.bg[gtk.STATE_PRELIGHT] = gtk.gdk.color_parse("green")
        self.progressbar.set_style (style)
        self.progressbar.set_fraction(0)
        self.feedback_table.attach(self.progressbar, 0, 12, 0, 1)

        # Labels for progress bar
        self.progress0 = gtk.Label("0")
        self.progress0.modify_font(pango.FontDescription("sans 16"))
        self.feedback_table.attach(self.progress0, 0, 1, 1, 2)

        # Labels for status update
        self.correct_count = 0
        self.correct_counter = gtk.Label(str(self.correct_count))
        self.correct_counter.modify_font(pango.FontDescription("sans 16"))

        # Ugly code for label color
        attr = pango.AttrList()
        fg_color = pango.AttrForeground(0, 65535, 0, 0, 6)
        attr.insert(fg_color)
        self.correct_counter.set_attributes(attr)

        #self.feedback_table.attach(self.correct_counter, 2, 4, 9, 10 )
        self.feedback_table.attach(self.correct_counter, 6, 7, 1, 2)

        self.false_count = 0
        self.false_counter = gtk.Label(str(self.false_count))
        self.false_counter.modify_font(pango.FontDescription("sans 16"))

        # Ugly code for label color
        attr = pango.AttrList()
        fg_color = pango.AttrForeground(0, 0, 65535, 0, 6)
        attr.insert(fg_color)
        self.false_counter.set_attributes(attr)

        #self.feedback_table.attach(self.false_counter, 2, 4, 10, 11 )
        self.feedback_table.attach(self.false_counter, 6, 7, 2, 3)

        self.stopwatch_label.show()
        gobject.timeout_add(1000, self.update_time)
        #self.name_label.show()
        self.progressbar.show()
        self.progress0.show()
        self.correct_counter.show()
        self.false_counter.show()

        self.progress_total = gtk.Label('')
        self.progress_total.modify_font(pango.FontDescription("sans 16"))
        self.feedback_table.attach(self.progress_total, 10, 12, 1, 2)
        self.progress_total.show()

    def feedback_table_show(self):
        #reset running feedback
        self.correct_count = 0
        self.correct_counter.set_label('0')
        self.false_count = 0
        self.false_counter.set_label('0')
        #reset timer
        self.stopwatch_label.set_label('00:00')
        self.stopwatch.reset()
        #load current feedback to ui
        self.total_calcs = self._co._current_exercise.count()+1
        self.progress_total.set_label(str(self.total_calcs))
        self.feedback_table.show()

    def feedback_table_hide(self):
        self.progressbar.set_fraction(0)
        self.feedback_table.hide()

    def offer_setting(self, ex):
        """ Prepare display for update of settings. """
        ex.define_buttons()
        ex.set_buttons(ex.get_setting())

    def release_feedb_callback(self, widget):
        """ Exit calcs to main menu = exstore """
        self.protocol('----------------------------------------', 0, 'OK')
        #print('in display.release_feedb_callback')
        self.calc_table.destroy()
        self.feedback_table_hide()
        self.info_table.show()
        self.exercise_table.hide()
        self.exstore_table.show()

    def release_feedb_to_sett_callback(self, widget):
        """ Exit calcs to settings """
        self.protocol('----------------------------------------', 0, 'OK')
        #print('in display.release_feedb_callback')
        self.calc_table.destroy()
        self.feedback_table_hide()
        self.exercise_table.hide()
        self.settings_table.show()

    def release_sett_callback(self, widget):
        """ Start calcs with these settings (probably updated). """
        #print('display: release_sett_callback: start from settings screen')
        self._co.settings_done(self._co._current_exercise.get_setting())
        self.settings_table.hide()
        self.exercise_table.show()
        self.feedback_table_show()
        self.sfb2_butt.show()
        self.sfb_butt.hide()
        self.info_table.hide()

    '''def init_calc(self):
        """
        prepares for calculations from 1 setting.
        for instance, a calculation might be on 1 ore more lines.
        """
        print("display: init_calc: onBtnClick")
        # make empty lines such that all calcs are entered at bottom
        for i in range(1,21):
            end_iterator = self.log_buffer.get_end_iter()
            self.log_buffer.insert(end_iterator, "\n")
            self.log_view.scroll_mark_onscreen(self.log_buffer.get_insert())
    '''
    def destroy_box(self):
        self.calculation_box.destroy()

    def protocol(self, full_line, errors, feedback):
        end_iterator = self.log_buffer.get_end_iter()

        if( feedback == 'OK' ):
            self.log_buffer.insert_with_tags_by_name(end_iterator, "\n" + full_line, "correct" )
        elif ( feedback == 'XXX' ):
            self.log_buffer.insert_with_tags_by_name(end_iterator, "\n" + full_line, "error" )
        end_iterator = self.log_buffer.get_end_iter()
        mark = self.log_buffer.create_mark(None, end_iterator, True)
        self.log_view.scroll_mark_onscreen(mark)

    def protocol_generated_calcs(self, calculations, change):
        #print("DEBUG: in display.protocol_generated_calcs")
        end_iterator = self.log_buffer.get_end_iter()
        self.log_buffer.insert_with_tags_by_name(end_iterator, "\n---------- " + change + " ----------" , "fixxxme!" )
        for c in calculations:
            end_iterator = self.log_buffer.get_end_iter()

            #['1', '-', '1', '=', '0']
            to_format = c[0]
            printable_calc =    to_format[0] + " " + \
                                to_format[1] + " " + \
                                to_format[2] + " " + \
                                to_format[3] + " " + \
                                to_format[4]
            self.log_buffer.insert_with_tags_by_name(end_iterator, "\n" + printable_calc, "fixxxme!" )

        mark = self.log_buffer.create_mark(None, end_iterator, True)
        self.log_view.scroll_mark_onscreen(mark)

    def input_digit(self, widget, dig, proterr, protok):
        """callback: input a digit and give feedback.
        The _only_ other active widget is the <stop>-button on the right"""
        entry_text = widget.get_text()
        ### bitte anzeigen !???????
        if(entry_text == dig):

            self.errors = 0 #WN090518 ???
            self.protocol(protok, self.errors, 'OK')
            self.destroy_box()
            self._learner.digit_done()
        elif(entry_text == ""):
            pass #otherwise feedback in protocol written twice: see entry.set_text("") below
        else:
            self.false_count = self.false_count + 1
            self.false_counter.set_text(str(self.false_count))
            self.errors = self.errors + 1
            widget.set_text("")
            self.protocol(proterr, self.errors, 'XXX')


    #WN090518
    def display_calc(self, lines):

        self.calc_table = gtk.Table(5, 1, True)
        self.calc_table.set_row_spacings(2)
        self.calc_table.set_col_spacings(2)
        #self.table.attach(self.calc_table, 0, 1, 0, 5)
        self.table.attach(self.calc_table, 0, 1, 6, 10)
        self.calc_table.show()

        """display the lines of a calc with _ at all input positions"""
        lino = 0
        for li in lines:
            #print('in Display.display_calc, line=', li)
            self.create_entryline((lino, -1, 'dummy-dig', 'dummy-proterr', 'dummy-protok', li))
            lino = lino + 1


    def create_entryline(self, (lineno, linepos, dig, proterr, protok, line)):
        """create gtk.Entry in line at linepos and set callback_input_digit"""
        #print('in Display.create_entryline: lineno=', lineno, ', linepos=',
        #      linepos, ', line=', line)
        calculation, cursor = line, linepos
        self.calculation_box = gtk.HBox(True, 0)
        calc_pos = 0
        #self.calc_table.attach(self.calculation_box, 0, 1, 3 + lineno, 4 + lineno)
        self.calc_table.attach(self.calculation_box, 0, 1, 0 + lineno, 1 + lineno)
        for i in calculation:
            if (calc_pos != cursor):
                self.label = gtk.Label(i)
                self.label.modify_font(pango.FontDescription("sans 24"))
                self.calculation_box.pack_start(self.label)
                self.label.show()
            else: # prepare for input
                self.text_entry = gtk.Entry(max = 1)
                self.text_entry.modify_font(pango.FontDescription("sans 24"))
                self.text_entry.connect("changed", self.input_digit, dig, proterr, protok)
                self.calculation_box.pack_start(self.text_entry)
                self.text_entry.show()
            calc_pos = calc_pos + 1
        #?kann m.die calculation_box ZUERST aufbauen und DANN self.table.attach
        self.calculation_box.show()

        if(cursor != -1):
            self.text_entry.grab_focus()
        #just add lineno to table.attach
        #TODO rename calculation, cursor below ...
        #TODO remove hack on callback:
        #self.input_digit('widget', dig, protline)


    def finish_calc(self):
        self.stopwatch.stop()

    def show_progress(self):
        progress = self.progressbar.get_fraction()+(float(1)/float(self.total_calcs))
        #avoid error due to set_fraction(>1.0)
        if(progress > float(1.0)):
            progress = float(1.0)
        self.progressbar.set_fraction(progress)
        self.correct_count = self.correct_count + 1
        self.correct_counter.set_text(str(self.correct_count))
        self.calc_table.destroy()

    def show_selection_properties(self, obj):
        ''' Shows the task/collection information in the info_table'''
        self._title_buffer.set_text(obj.get_title())
        self._desc_buffer.set_text(obj.get_description())
        if isinstance(obj, Collection):
            self.ex_name_label.hide()
            self.ex_num_label.set_label("")
        else:
            self.ex_name_label.show()
            temp = self._co._exstore.get_exercise(obj)
            self.ex_num_label.set_label(str(temp.count()))

    '''
    def hide_selection_properties(self):
        return
    '''

    def offer_coll_to_learner(self, data):
        """Show the exstore to the learner"""
        self.gtk_tree(data) #-->self.treeview
        #self.exstore_table.attach(self.treeview, 0, 9, 0, 13)

        self.exstore_table.attach(self.tree_scrolled_window, 0, 9, 0, 13)
        self.tree_scrolled_window.add(self.treeview)

        self.treeview.show() ### see finish_learner_coll_callback
        self.tree_scrolled_window.show()
        self.set_coll_to_learner() # set finish_learner_coll_butt + callback

    def set_select_exerc_semaphore(self, coll_key):
        """ Sets a semaphore for finish_collect_callback. """
        #print('in display.set_select_exerc_semaphore, coll_key', self._coll_key)
        self._coll_key = coll_key

    def set_coll_to_learner(self):
        """ Set the permanent gui-elements for exstore_table. """
        #print('in display.set_coll_to_learner')
        # button to go back to the mein menu ->exstore_table
        self.sfb_butt = gtk.Button(None, gtk.STOCK_STOP)
        self.sfb_butt.connect("clicked", self.release_feedb_callback)
        self.exercise_table.attach(self.sfb_butt, 0, 9, 14, 15)
        self.sfb_alignment = self.sfb_butt.get_children()[0]
        self.sfb_hbox = self.sfb_alignment.get_children()[0]
        self.sfb_image, self.sfb_label = self.sfb_hbox.get_children()
        self.sfb_label.set_label("Back")
        self.sfb_butt.hide()    # only show() if running calcs
        # button switching from collect_table to calcs
        self.flc_butt = gtk.Button(None, gtk.STOCK_GO_FORWARD)
        self.flc_butt.connect("clicked", self.finish_learner_coll_callback)
        self.exstore_table.attach(self.flc_butt, 0, 7, 13, 14)
        self.flc_alignment = self.flc_butt.get_children()[0]
        self.flc_hbox = self.flc_alignment.get_children()[0]
        self.flc_image, self.flc_label = self.flc_hbox.get_children()
        self.flc_label.set_label("Start")
        self.flc_butt.show()
        #disabled by default: waiting for a task to be selected
        self.flc_butt.set_sensitive(False)
        # button switching from collect_table to settings_table
        self.sts_butt = gtk.Button(None, gtk.STOCK_PROPERTIES) #STOCK_EXECUTE, REFERENCES
        self.sts_alignment = self.sts_butt.get_children()[0]
        self.sts_hbox = self.sts_alignment.get_children()[0]
        self.sts_image, self.sts_label = self.sts_hbox.get_children()
        self.sts_label.set_label("")
        self.sts_butt.connect("clicked", self.switch_learner_to_setts)
        self.exstore_table.attach(self.sts_butt, 7, 9, 13, 14)
        self.sts_alignment = self.sts_butt.get_children()[0]
        self.sts_butt.show()
        #disabled by default
        self.sts_butt.set_sensitive(False)

    def finish_learner_coll_callback(self, widget):
        """ Callback on flc_butt; uses self._coll_key as semaphore
        from Collection.select_exerc_callback. """
        #print('display: finish_learner_coll_callback: btn start auf startseite')
        self._co.exercise_selected() #self._selected)
        self.exstore_table.hide()
        self.exercise_table.show()
        self.sfb_butt.show()
        self.sfb2_butt.hide()
        self.info_table.hide()
        self.feedback_table_show()

    def switch_learner_to_setts(self, widget):
        """ Callback on sts_butt. asks the Coach if allowed. """
        #print('display: switch_learner_to_setts: triggered, '+self._coll_key+', ')
        self._co.switch_to_settings() #->  calls: self.offer_setting(exercise)
        #self.exercise_table.hide()
        self.exstore_table.hide()
        self.settings_table.show()
        self.info_table.hide()

    '''def set_curr_exerc(self, exerc):
        """ self.current_exercise is needed for feedback_table etc. """
        if(self.current_exercise == exerc):
            print('eh schon gleich')
        self.current_exercise = exerc
    '''
    def gtk_tree(self, data):
        # treeView scroll container
        self.tree_scrolled_window = gtk.ScrolledWindow()
        self.tree_scrolled_window.set_policy(gtk.POLICY_NEVER,
                                        gtk.POLICY_ALWAYS)

        """ Define TreeStore and TreeView """
        self.treestore = gtk.TreeStore(gtk.gdk.Pixbuf, str)
        self.treestore.clear()

        #fill the TreeStore with data from Collection
        self.fill_store(self.treestore, None, data)
        self.treeview = gtk.TreeView(self.treestore)

        #create the TreeViewColumn to display the data
        self.tvcolumn = gtk.TreeViewColumn('Exercises')
        self.cellpb = gtk.CellRendererPixbuf()
        self.tvcolumn.pack_start(self.cellpb, True)
        self.tvcolumn.add_attribute(self.cellpb, 'pixbuf', 0)

        #create a CellRendererText to render the data
        self.cell = gtk.CellRendererText()

        #add the cell to the tvcolumn and allow it to expand
        self.tvcolumn.pack_start(self.cell, True)

        #set the cell "text" attribute to column 0 - retrieve text
        #from that column in treestore
        self.tvcolumn.add_attribute(self.cell, 'text', 1)

        #add tvcolumn to treeview
        self.treeview.append_column(self.tvcolumn)

        #make it searchable
        self.treeview.set_search_column(0)

        #Allow sorting on the column
        self.tvcolumn.set_sort_column_id(-1)

        #Callback for selection
        self.treeselection = self.treeview.get_selection()
        self.treeselection.connect("changed", self.treeselection_callback)

        if(self._drag_and_drop == True):
            #Drag and Drop callbacks
            #TODO: fix bug when dropping Collection into itself -> don't
            #      allow dropping into itself!
            self.treeview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
                                                   self.TARGETS,
                                                   gtk.gdk.ACTION_MOVE)
            self.treeview.enable_model_drag_dest(self.TARGETS,
                                                 gtk.gdk.ACTION_MOVE)
            self.treeview.connect("drag_data_get", self.drag_data_get_data)
            self.treeview.connect("drag_data_received",
                                  self.drag_data_received_data)

        self.treeview.expand_all()

    def fill_store(self, ts, parent, list):
        """ Fill the TreeStore with data """
        #add data from file
        if list == None:
            print "Can't open list! - Reason: ", list

        for i in range(len(list)):
            if isinstance(list[i], Collection):
                olditer = ts.append(parent, [gtk.gdk.pixbuf_new_from_file("./img/collection.png"), list[i].get_title()])
                c_list = list[i].get_data()
                self.fill_store(ts, olditer, c_list)
            else:
                text = list[i].get_title() # + ": " + list[i].get_description()
                iter = ts.append(parent, [gtk.gdk.pixbuf_new_from_file("./img/exercise.png"), text])

    def drag_data_get_data(self, treeview, context,
                           selection, target_id, etime):
        """ Handles the drag of an item. The left-mouse has been klicked.
        Stores position in self._from. """
        # get iter pointing on selected item in tree
        treeselection = treeview.get_selection()
        model, iter = treeselection.get_selected()
        # tupel that shows the drag-position
        self._from = self.treestore.get_path(iter)
        return

    def drag_data_received_data(self, treeview, context, x, y,
                                selection, info, etime):
        """ Handles the drop of an item """
        obj = self._coll.get_object(self._from)
        # get the drop information - tupel containing another tupel with drop
        # position and a pointer containing information on drop (before, into,
        # after - an item)
        drop_info = treeview.get_dest_row_at_pos(x, y)
        self._to = None
        self._to_spec = None
        if drop_info:
            self._to = drop_info[0]
            self._to_spec = drop_info[1]

        self._coll.insert_object(obj, self._to, self._to_spec)
        self.treestore.clear()
        self._root = self._coll.get_data_from_pickle()
        list = self._root.get_data()
        self.fill_store(self.treestore, None, list)
        self.treeview.expand_all()

        if context.action == gtk.gdk.ACTION_MOVE:
            context.finish(True, True, etime)
        return

    def treeselection_callback(self, treeselection):
        """ sets _from to the current selected item """
        if(treeselection.get_mode() == gtk.SELECTION_SINGLE):
            model, iter = treeselection.get_selected()
            self._selected = self.treestore.get_path(iter)
            #get selected object from coach
            obj = self._co.get_selected_object(self._selected)
            if isinstance(obj, Collection):
                self.show_selection_properties(obj)
                self.flc_butt.set_sensitive(False)
                self.sts_butt.set_sensitive(False)
            else:
                self.show_selection_properties(obj)
                self.flc_butt.set_sensitive(True)
                self.sts_butt.set_sensitive(True)
        return