# -*- coding: utf-8 -*-
#Copyright (c) 2007-8, Playful Invention Company.
#Copyright (c) 2008-10, Walter Bender
#Copyright (c) 2008-10, Raúl Gutiérrez Segalés

#Permission is hereby granted, free of charge, to any person obtaining a copy
#of this software and associated documentation files (the "Software"), to deal
#in the Software without restriction, including without limitation the rights
#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
#copies of the Software, and to permit persons to whom the Software is
#furnished to do so, subject to the following conditions:

#The above copyright notice and this permission notice shall be included in
#all copies or substantial portions of the Software.

#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
#THE SOFTWARE.

import gtk
import gobject
from time import clock
from math import sqrt
from random import uniform
from operator import isNumberType
import audioop
import subprocess
from UserDict import UserDict
try:
    from sugar.datastore import datastore
except:
    pass

from taconstants import PRIMITIVES, PALETTES, PALETTE_NAMES, STATUS_LAYER,\
                        TEMPLATES, BOX_STYLE
from tagplay import play_audio, play_movie_from_file, stop_media
from tajail import myfunc, myfunc_import
from tautils import get_pixbuf_from_journal, movie_media_type,\
                    audio_media_type, round_int
from gettext import gettext as _

procstop = False

class noKeyError(UserDict):
    __missing__=lambda x,y: 0

class symbol:
    def __init__(self, name):
        self.name = name
        self.nargs = None
        self.fcn = None

    def __str__(self):
        return self.name
    def __repr__(self):
        return '#'+self.name

class logoerror(Exception):
    def __init__(self, value):
        self.value = value
    def __str__(self):
        return repr(self.value)

"""
Utility functions
"""

def careful_divide(x,y):
    try:
        if y==0:
            return 0
        return x/y
    except:
        return 0

def taequal(x,y):
    try:
        return float(x)==float(y)
    except:
        if type(x) == str or type(x) == unicode:
            xx = ord(x[0])
        else:
            xx = x
        if type(y) == str or type(y) == unicode:
            yy = ord(y[0])
        else:
            yy = y
        return xx==yy
    
def taless(x, y):
    try:
        return float(x)<float(y)
    except:
        if type(x) == str or type(x) == unicode:
            xx = ord(x[0])
        else:
            xx = x
        if type(y) == str or type(y) == unicode:
            yy = ord(y[0])
        else:
            yy = y
        return xx<yy
    
def tamore(x, y):
    return taless(y, x)

def taminus(x, y):
    try:
        return(x-y)
    except:
        raise logoerror("#syntaxerror")
    
def taproduct(x, y):
    try:
        return(x*y)
    except:
        raise logoerror("#syntaxerror")
    
def tamod(x, y):
    try:
        return(x%y)
    except:
        raise logoerror("#syntaxerror")
    
def tasqrt(x):
    try:
        return sqrt(x)
    except:
        raise logoerror("#syntaxerror")
    
def identity(x):
    return(x)

def calc_position(tw, t):
    w,h,x,y,dx,dy = TEMPLATES[t]
    x *= tw.canvas.width
    y *= tw.canvas.height
    w *= (tw.canvas.width-x)
    h *= (tw.canvas.height-y)
    dx *= w
    dy *= h
    return(w,h,x,y,dx,dy)
    
"""
Stop_logo is called from the Stop button on the toolbar
"""
def stop_logo(tw):
    tw.step_time = 0
    tw.lc.step = just_stop()
    tw.turtles.show_all()

def just_stop():
    yield False

def millis():
    return int(clock()*1000)

"""
A class for parsing Logo Code
"""
class LogoCode:
    def __init__(self, tw):

        self.tw = tw
        self.oblist = {}

        DEFPRIM = {
        '(':[1, lambda self, x: self.prim_opar(x)],
        '/':[None, lambda self,x,y: careful_divide(x,y)],
        '-':[None, lambda self,x,y: x-y],
        '*':[None, lambda self,x,y: x*y],
        '%':[None, lambda self,x,y: x%y],
        '+':[None, lambda self,x,y: x+y],
        'and':[2, lambda self,x,y: x&y],
        'arc':[2, lambda self, x, y: self.prim_arc(x, y)],
        'back':[1, lambda self,x: self.prim_forward(-x)],
        'blue':[0, lambda self: 70],
        'bpos':[0, lambda self: -self.tw.canvas.height/(self.tw.coord_scale*2)],
        'box1':[0, lambda self: self.boxes['box1']],
        'box':[1, lambda self,x: self.box(x)],
        'box2':[0, lambda self: self.boxes['box2']],
        'bullet':[2, self.prim_bullet, True],
        'clean':[0, lambda self: self.prim_clear()],
        'clearheap':[0, lambda self: self.empty_heap()],
        'color':[0, lambda self: self.tw.canvas.color],
        'container':[1, lambda self,x: x],
        'cyan':[0, lambda self: 50],
        'define':[2, self.prim_define],
        'division':[2, lambda self,x,y: careful_divide(x,y)],
        'equal?':[2, lambda self,x,y: taequal(x,y)],
        'fillscreen':[2, lambda self, x, y: self.prim_fillscreen(x, y)],
        'forever':[1, self.prim_forever, True],
        'forward':[1, lambda self, x: self.prim_forward(x)],
        'greater?':[2, lambda self,x,y: tamore(x,y)],
        'green':[0, lambda self: 30],
        'heading':[0, lambda self: self.tw.canvas.heading],
        'hideblocks':[0, lambda self: self.tw.hideblocks()],
        'hres':[0, lambda self: self.tw.canvas.width/self.tw.coord_scale],
        'id':[1, lambda self,x: identity(x)],
        'if':[2, self.prim_if, True],
        'ifelse':[3, self.prim_ifelse, True],
        'insertimage':[1, lambda self,x: self.insert_image(x, False)],
        'kbinput':[0, lambda self: self.kbinput()],
        'keyboard':[0, lambda self: self.keyboard],
        'left':[1, lambda self,x: self.prim_right(-x)],
        'lpos':[0, lambda self: -self.tw.canvas.width/(self.tw.coord_scale*2)],
        'less?':[2, lambda self,x,y: taless(x,y)],
        'minus':[2, lambda self,x,y: taminus(x,y)],
        'mod':[2, lambda self,x,y: tamod(x,y)],
        'myfunc':[2, lambda self,f,x: self.prim_myfunc(f, x)],
        'nop':[0, lambda self: self.prim_none()],
        'nop1':[0, lambda self: self.prim_none(1)],
        'nop2':[0, lambda self: self.prim_none(2)],
        'nop3':[1, lambda self,x: self.prim_none(x)],
        'not':[1, lambda self,x:not x],
        'orange':[0, lambda self: 10],
        'or':[2, lambda self,x,y: x|y],
        'pendown':[0, lambda self: self.prim_setpen(True)],
        'pensize':[0, lambda self: self.tw.canvas.pensize],
        'penup':[0, lambda self:  self.prim_setpen(False)],
        'plus':[2, lambda self,x,y: self.prim_plus(x,y)],
        'pop':[0, lambda self: self.prim_pop()],
        'print':[1, lambda self,x: self.prim_print(x)],
        'printheap':[0, lambda self: self.prim_print_heap()],
        'product':[2, lambda self,x,y: taproduct(x,y)],
        'purple':[0, lambda self: 90],
        'push':[1, lambda self,x: self.prim_push(x)],
        'random':[2, lambda self,x,y: int(uniform(x,y))],
        'red':[0, lambda self: 0],
        'repeat':[2, self.prim_repeat, True],
        'right':[1, lambda self, x: self.prim_right(x)],
        'rpos':[0, lambda self: self.tw.canvas.width/(self.tw.coord_scale*2)],
        'scale':[0, lambda self: self.scale],
        'setcolor':[1, lambda self, x: self.prim_setcolor(x)],
        'seth':[1, lambda self, x: self.prim_setheading(x)],
        'setpensize':[1, lambda self, x: self.prim_setpensize(x)],
        'setscale':[1, lambda self,x: self.set_scale(x)],
        'setshade':[1, lambda self, x: self.tw.canvas.setshade(x)],
        'settextcolor':[1, lambda self, x: self.tw.canvas.settextcolor(x)],
        'settextsize':[1, lambda self, x: self.tw.canvas.settextsize(x)],
        'setxy':[2, lambda self, x, y: self.prim_setxy(x, y)],
        'shade':[0, lambda self: self.tw.canvas.shade],
        'show':[1,lambda self, x: self.prim_show(x, True)],
        'showblocks':[0, lambda self: self.tw.showblocks()],
        'sound':[1, lambda self,x: self.play_sound(x)],
        'sqrt':[1, lambda self,x: sqrt(x)],
        'stack1':[0, self.prim_stack1, True],
        'stack':[1, self.prim_stack, True],
        'stack2':[0, self.prim_stack2, True],
        'start':[0, lambda self: self.prim_start()],
        'stopstack':[0, self.prim_stopstack],
        'storeinbox1':[1, lambda self,x: self.prim_setbox('box1',x)],
        'storeinbox2':[1, lambda self,x: self.prim_setbox('box2',x)],
        'storeinbox':[2, lambda self,x,y: self.prim_setbox('box3'+str(x),y)],
        't1x1':[2, lambda self,x,y: self.show_template1x1(x, y)],
        't1x1a':[2, lambda self,x,y: self.show_template1x1a(x, y)],
        't1x2':[3, lambda self,x,y,z: self.show_template1x2(x, y, z)],
        't2x1':[3, lambda self,x,y,z: self.show_template2x1(x, y, z)],
        't2x2':[5, lambda self,x,y,z,a,b: self.show_template2x2(x, y, z, a, b)],
        'textcolor':[0, lambda self: self.tw.canvas.textcolor],
        'textsize':[0, lambda self: self.tw.textsize],
        'tpos':[0, lambda self: self.tw.canvas.height/(self.tw.coord_scale*2)],
        'turtle':[1, lambda self, x: self.tw.canvas.set_turtle(x)],
        'userdefined':[1, lambda self,x: self.prim_myblock(x)],
        'video':[1, lambda self,x: self.play_movie(x)],
        'vres':[0, lambda self: self.tw.canvas.height/self.tw.coord_scale],
        'wait':[1, self.prim_wait, True],
        'write':[2, lambda self, x,y: self.write(self, x,y)],
        'xcor':[0, lambda self: self.tw.canvas.xcor/self.tw.coord_scale],
        'ycor':[0, lambda self: self.tw.canvas.ycor/self.tw.coord_scale],
        'yellow':[0, lambda self: 20]}

        for p in iter(DEFPRIM):
            if len(DEFPRIM[p]) == 2:
                self.defprim(p, DEFPRIM[p][0], DEFPRIM[p][1])
            else:
                self.defprim(p, DEFPRIM[p][0], DEFPRIM[p][1], DEFPRIM[p][2])
    
        self.symtype = type(self.intern('print'))
        self.listtype = type([])
        self.symnothing = self.intern('%nothing%')
        self.symopar = self.intern('(')
        self.iline = None
        self.cfun = None
        self.arglist = None
        self.ufun = None
    
        self.istack = []
        self.stacks = {}
        self.boxes = {'box1': 0, 'box2': 0}
        self.heap = []

        self.keyboard = 0
        self.trace = 0
        self.gplay = None
        self.ag = None
        self.nobox = ""
        self.title_height = int((self.tw.canvas.height/20)*self.tw.scale)
        self.body_height = int((self.tw.canvas.height/40)*self.tw.scale)
        self.bullet_height = int((self.tw.canvas.height/30)*self.tw.scale)
    
        self.scale = 33

    """
    Define the primitives associated with the blocks
    """
    def defprim(self, name, args, fcn, rprim=False):
        sym = self.intern(name)
        sym.nargs, sym.fcn = args, fcn
        sym.rprim = rprim    

    """
    Add any new objects to the symbol list.
    """
    def intern(self, str):
        if str in self.oblist:
            return self.oblist[str]
        sym = symbol(str)
        self.oblist[str] = sym
        return sym
    
    """
    Given a block to run...
    """
    def run_blocks(self, blk, blocks, run_flag):
        self.blk_index = [] # Maintain a correlation between blocks and code
        self.bi = 0 # and a counter as you walk through the code
        self.bis = {'stack1':0, 'stack2':0}
        for k in self.stacks.keys():
            self.stacks[k] = None
        self.stacks['stack1'] = None
        self.stacks['stack2'] = None
        for b in blocks:
            if b.name == 'hat1':
                self.bis['stack1'] = len(self.blk_index)
                self.stacks['stack1'] = self.readline(self.blocks_to_code(b))
            if b.name=='hat2':
                self.bis['stack2'] = len(self.blk_index)
                self.stacks['stack2'] = self.readline(self.blocks_to_code(b))
            if b.name == 'hat':
                self.bis['stack3'+b.connections[1].values[0]] =\
                    len(self.blk_index)
                if b.connections[1] is not None:
                    self.stacks['stack3'+b.connections[1].values[0]] =\
                        self.readline(self.blocks_to_code(b))
        self.bi = len(self.blk_index)
        code = self.blocks_to_code(blk)
        if run_flag is True:
            print "running code: %s" % (code)
            print "block index is: %s" % (self.blk_index)
            print "step time is: %d" % (self.tw.step_time)
            self.setup_cmd(code)
        else:
            return code

    """
    Convert a stack of blocks to pseudocode.
    """
    def blocks_to_code(self, blk):
        if blk is None:
            return ['%nothing%']
        code = []
        dock = blk.docks[0]
        if len(dock)>4: # There could be a '(', ')', '[' or ']'.
            code.append(dock[4])
        if blk.primitive is not None:
            code.append(blk.primitive)
            if blk.name not in BOX_STYLE:
                self.blk_index.append(self.tw.block_list.list.index(blk))
        elif len(blk.values)>0:  # Extract the value from content blocks.
            if blk.name=='number':
                try:
                    code.append(float(blk.values[0]))
                except ValueError:
                    code.append(float(ord(blk.values[0][0])))
            elif blk.name=='string' or blk.name=='title':
                if type(blk.values[0]) == float or type(blk.values[0]) == int:
                    if int(blk.values[0]) == blk.values[0]:
                        blk.values[0] = int(blk.values[0])
                    code.append('#s'+str(blk.values[0]))
                else:
                    code.append('#s'+blk.values[0])
            elif blk.name=='journal':
                if blk.values[0] is not None:
                    code.append('#smedia_'+str(blk.values[0]))
                else:
                    code.append('#smedia_None')
            elif blk.name=='description':
                if blk.values[0] is not None:
                    code.append('#sdescr_'+str(blk.values[0]))
                else:
                    code.append('#sdescr_None')
            elif blk.name=='audio':
                if blk.values[0] is not None:
                    code.append('#saudio_'+str(blk.values[0]))
                else:
                    code.append('#saudio_None')
            else:
                print "%s had no primitive." % (blk.name)
                return ['%nothing%']
        else:
            print "%s had no value." % (blk.name)
            return ['%nothing%']
        for i in range(1, len(blk.connections)):
            b = blk.connections[i]        
            dock = blk.docks[i]
            if len(dock)>4: # There could be a '(', ')', '[' or ']'.
                for c in dock[4]:
                    code.append(c)
            if b is not None:
                code.extend(self.blocks_to_code(b))
            elif blk.docks[i][0] not in ['flow', 'unavailable']:
                code.append('%nothing%')
        return code
    
    """
    Execute the psuedocode.
    """
    def setup_cmd(self, str):
        self.tw.active_turtle.hide() # Hide the turtle while we are running.
        self.procstop = False
        list = self.readline(str)
        self.step = self.start_eval(list)

    """
    Convert the pseudocode into a list of commands.
    """
    def readline(self, line):
        res = []
        while line:
            token = line.pop(0)
            if isNumberType(token):
                res.append(token)
            elif token.isdigit():
                res.append(float(token))
            elif token[0]=='-' and token[1:].isdigit():
                res.append(-float(token[1:]))
            elif token[0] == '"':
                res.append(token[1:])
            elif token[0:2] == "#s":
                res.append(token[2:])
            elif token == '[':
                res.append(self.readline(line))
            elif token == ']':
                return res
            else:
                res.append(self.intern(token))
        return res

    """
    Step through the list.
    """
    def start_eval(self, list):
        self.icall(self.evline, list)
        yield True
        if self.tw.running_sugar:
            self.tw.activity.stop_button.set_icon("stopitoff")
        yield False

    """
    Add a function and its arguments to the program stack.
    """
    def icall(self, fcn, *args):
        self.istack.append(self.step)
        self.step = fcn(*(args))

    """
    Evaluate a line of code from the list.
    """
    def evline(self, list):
        oldiline = self.iline
        self.iline = list[:]
        self.arglist = None
        while self.iline:

            if self.tw.step_time > 0:
                b = self.tw.block_list.list[self.blk_index[self.bi]]
                b.highlight()
                self.tw.active_turtle.show()
                endtime = millis()+self.an_int(self.tw.step_time)*100
                while millis()<endtime:
                    yield True
                self.tw.active_turtle.hide()
                self.bi += 1

            token = self.iline[0]
            if token == self.symopar:
                token = self.iline[1]
            self.icall(self.eval)
            yield True
            if self.procstop:
                break
            if self.iresult == None:
                continue
            raise logoerror(str(self.iresult))
        self.iline = oldiline
        self.ireturn()
        self.tw.display_coordinates()
        yield True
    
    """
    Evaluate the next token on the line.
    """
    def eval(self, infixarg=False):
        token = self.iline.pop(0)
        if type(token) == self.symtype:
            self.icall(self.evalsym, token)
            yield True
            res = self.iresult
        else:
            res = token
        if not infixarg:
            while self.infixnext():
                self.icall(self.evalinfix, res)
                yield True
                res = self.iresult
        self.ireturn(res)
        yield True

    """
    Processing flow (vertical)
    """
    def evalsym(self, token):
        self.debug_trace(token)
        self.undefined_check(token)
        oldcfun, oldarglist = self.cfun, self.arglist
        self.cfun, self.arglist = token, []
        if token.nargs == None:
            raise logoerror("#noinput")
        for i in range(token.nargs):
            self.no_args_check()
            self.icall(self.eval)
            yield True
            self.arglist.append(self.iresult)
        if self.cfun.rprim:
            if type(self.cfun.fcn) == self.listtype:
                self.icall(self.ufuncall, self.cfun.fcn)
                yield True
            else:
                self.icall(self.cfun.fcn, *self.arglist)
                yield True
            result = None
        else:
            # TODO: find out why stopstack args are mismatched
            if token.name == 'stopstack':
                result = self.cfun.fcn()
            else:
                result = self.cfun.fcn(self, *self.arglist)
        self.cfun, self.arglist = oldcfun, oldarglist
        if self.arglist is not None and result == None:
            raise logoerror("%s didn't output to %s (arglist %s, result %s)" % \
                (oldcfun.name, self.cfun.name, str(self.arglist), str(result)))
        self.ireturn(result)
        yield True

    #
    # Processing assignments (horizontal)
    #
    def evalinfix(self, firstarg):
        token = self.iline.pop(0)
        oldcfun, oldarglist = self.cfun, self.arglist
        self.cfun, self.arglist = token, [firstarg]
        no_args_check(self)
        self.icall(self.eval, True)
        yield True
        self.arglist.append(self.iresult)
        result = self.cfun.fcn(self, *self.arglist)
        self.cfun, self.arglist = oldcfun, oldarglist
        self.ireturn(result)
        yield True
    
    def infixnext(self):
        if len(self.iline)==0:
            return False
        if type(self.iline[0]) is not self.symtype:
            return False
        return self.iline[0].name in ['+', '-', '*', '/','%','and','or']

    def ufuncall(self, body):
        ijmp(self.evline, body)
        yield True
    
    def doevalstep(self):
        starttime = millis()
        try:
            while (millis()-starttime)<120:
                try:
                    if self.step is not None:
                        self.step.next()
                    else:
                        print "step is None"
                        return False
                except StopIteration:
                    self.tw.turtles.show_all()
                    return False
        except logoerror, e:
            self.showlabel(str(e)[1:-1])
            self.tw.turtles.show_all()
            return False
        return True

    def ireturn(self, res=None):
        self.step = self.istack.pop()
        self.iresult = res

    def ijmp(self, fcn, *args):
        self.step = fcn(*(args))

    def debug_trace(self, token):
        if self.trace:
            if token.name in PALETTES[PALETTE_NAMES.index('turtle')]:
                my_string = "%s\n%s=%d\n%s=%d\n%s=%d\n%s=%d" %\
                    (token.name, _('xcor'), int(self.tw.canvas.xcor),
                     _('ycor'), int(self.tw.canvas.ycor), _('heading'),
                     int(self.tw.canvas.heading), _('scale'), int(self.scale))
            elif token.name in PALETTES[PALETTE_NAMES.index('pen')]:
                if self.tw.canvas.pendown:
                    penstatus = _('pen down')
                else:
                    penstatus = _('pen up')
                my_string = "%s\n%s\n%s=%d\n%s=%d\n%s=%.1f" %\
                    (token.name, penstatus, _('color'),
                     int(self.tw.canvas.color), _('shade'),
                     int(self.tw.canvas.shade), _('pen size'),
                     self.tw.canvas.pensize)
            else:
                my_string = "%s\n%s:\n" % (token.name, _('box'))
                for k, v in self.boxes.iteritems():
                    tmp = k +":" + str(v) + "\n"
                    my_string += tmp
            shp = 'info'
            self.tw.status_spr.set_shape(self.tw.status_shapes[shp])
            self.tw.status_spr.set_label(_(my_string))
            self.tw.status_spr.set_layer(STATUS_LAYER)
        return
    
    def undefined_check(self, token):
        if token.fcn is not None:
            return False
        raise logoerror("%s %s" % (_("I don't know how to"), token.name))
    
    def no_args_check(self):
        if self.iline and self.iline[0] is not self.symnothing:
            return
        raise logoerror("#noinput")
    
    #
    # Primitives
    #

    def prim_none(self, x=None):
        self.highlighter("nop"+str(x))
        self.unhighlight("nop"+str(x))
        return None

    def prim_plus(self, x, y):
        self.highlighter("plus")
        self.unhighlight("plus")
        if (type(x) == int or type(x) == float) and \
            (type(y) == int or type(y) == float):
            return(x+y)
        else:
            return(str(x) + str(y))
    
    def prim_clear(self):
        print ">>>>>>>>>>>>>>>>>>>>> in the clear"
        self.highlighter("clear")
        print "after call to highlight"
        stop_media(self)
        self.tw.canvas.clearscreen()
        print "unhighlighting"
        self.unhighlight("plus")

    def prim_fillscreen(self):
        self.highlighter("clear")
        self.tw.canvas.fillscreen(x, y)
        self.unhighlight("clear")

    def prim_right(self, x):
        self.highlighter("left/right")
        self.tw.canvas.right(x)
        self.unhighlight("left/right")

    def prim_forward(self, x):
        self.highlighter("back/forward")
        self.tw.canvas.forward(x)
        self.unhighlight("back/forward")

    def prim_setheading(self, x):
        self.highlighter("seth")
        self.tw.canvas.seth(x)
        self.unhighlight("seth")

    def prim_arc(self, x, y):
        self.highlighter("arc")
        self.tw.canvas.arc(x, y)
        self.unhighlight("arc")

    def prim_setxy(self, x, y):
        self.highlighter("setxy")
        self.tw.canvas.setxy(x, y)
        self.unhighlight("setxy")

    def prim_show(self, x, y):
        self.highlighter("show")
        self.show(x, True)
        self.unhighlight("show")

    def prim_setpen(self, x):
        self.highlighter("pendown/up")
        self.tw.canvas.setpen(x)
        self.unhighlight("pendown/up")

    def prim_setpensize(self, x): 
        self.highlighter("setpensize")
        self.tw.canvas.setpensize(x)
        self.unhighlight("setpensize")

    def prim_setcolor(self, x):
        self.highlighter("setcolor")
        self.tw.canvas.setcolor(x)
        self.unhighlight("setcolor")

    def prim_setshade(self, x):
        self.highlighter("setcolor")
        self.tw.canvas.setshade(x)
        self.unhighlight("setcolor")

    def prim_start(self):
        self.highlighter("start")
        if self.tw.running_sugar:
            self.tw.activity.recenter()
        self.unhighlight("start")

    def prim_wait(self, time):
        self.highlighter("wait")
        self.tw.active_turtle.show()
        endtime = millis()+self.an_int(time*1000)
        while millis()<endtime:
            yield True
        self.tw.active_turtle.hide()
        self.unhighlight("wait")
        self.ireturn()
        yield True
    
    def prim_repeat(self, num, list):
        num = self.an_int(num)
        self.highlighter("repeat")
        bi = self.bi
        for i in range(num):
            self.bi = bi
            self.icall(self.evline, list[:])
            yield True
            if self.procstop:
                break
        self.bi = bi
        self.unhighlight("repeat")
        self.ireturn()
        yield True

    def prim_bullet(self, title, list):
        self.highlighter("bullet")
        self.show_bullets(title, list)
        self.unhighlight("bullet")
        self.ireturn()
        yield True

    def prim_forever(self, list):
        self.highlighter("forever")
        bi = self.bi
        while True:
            self.bi = bi
            self.icall(self.evline, list[:])
            yield True
            if self.procstop:
                break
        self.bi = bi
        self.unhighlight("forever")
        self.ireturn()
        yield True

    def prim_if(self, bool, list):
        self.highlighter("if")
        bi = self.bi
        if bool:
            self.icall(self.evline, list[:])
            yield True
        self.bi = bi
        self.unhighlight("if")
        self.ireturn()
        yield True

    def prim_ifelse(self, bool, list1, list2):
        self.highlighter("ifelse")
        bi = self.bi
        if bool:
            self.ijmp(self.evline, list1[:])
            yield True
        else:
            self.ijmp(self.evline, list2[:])
            yield True
        self.bi = bi
        self.unhighlight("ifelse")

    def prim_opar(self, val):
        self.iline.pop(0)
        return val

    def prim_define(self, name, body):
        if type(name) is not symtype:
            name = self.intern(name)
        name.nargs, name.fcn = 0, body
        name.rprim = True
    
    def prim_stack(self, str):
        self.highlighter("stack")
        self.bi = self.bis['stack3'+str]
        if (not self.stacks.has_key('stack3'+str)) or\
           self.stacks['stack3'+str] is None:
            raise logoerror("#nostack")
        self.icall(self.evline, self.stacks['stack3'+str][:])
        yield True
        self.procstop = False
        self.ireturn()
        yield True

    def prim_stack1(self):
        self.highlighter("stack1")
        bi = self.bi
        self.bi = self.bis['stack1']
        if self.stacks['stack1'] is None:
            raise logoerror("#nostack")
        self.icall(self.evline, self.stacks['stack1'][:])
        yield True
        self.procstop = False
        self.unhighlight("stack1")
        self.ireturn()
        yield True
    
    def prim_stack2(self):
        self.highlighter("stack2")
        bi = self.bi
        self.bi = self.bis['stack2']
        if self.stacks['stack2'] is None:
            raise logoerror("#nostack")
        self.icall(self.evline, self.stacks['stack2'][:])
        yield True
        self.procstop = False
        self.unhighlight("stack2")
        self.ireturn()
        yield True

    def prim_stopstack(self):
        self.highlighter("stopstack")
        self.procstop = True
        self.unhighlight("stopstack")
    
    def prim_print_heap(self):
        self.highlighter("heap")
        self.showlabel(self.heap)
        self.unhighlight("heap")

    def an_int(self, n):
        if type(n) == int:
            return n
        elif type(n) == float:
            return int(n)
        elif type(n) == str:
            return int(ord(n[0]))
        else:
            raise logoerror("%s doesn't like %s as input" \
                % (self.cfun.name, str(n)))

    def box(self, x):
        self.highlighter("box")
        self.unhighlight("box")
        try:
            return self.boxes['box3'+str(x)]
        except:
            self.nobox = str(x)
            raise logoerror("#emptybox")
    
    def prim_myblock(self, x):
        self.highlighter("myblock")
        if self.tw.myblock is not None:
            y = myfunc_import(self, self.tw.myblock, x)
        else:
            raise logoerror("#nocode")
        self.unhighlight("myblock")
        return
    
    def prim_myfunc(self, f, x):
        self.highlighter("myfunc")
        y = myfunc(self, f, x)
        self.unhighlight("myfunc")
        if y == None:
            raise logoerror("#syntaxerror")
            stop_logo(self.tw)
        else:
            return y
    
    def prim_print(self, n):
        self.highlighter("print")
        if type(n) == str or type(n) == unicode:
            if n[0:6] == 'media_':
                try:
                    dsobject = datastore.get(n[6:])
                    self.showlabel(dsobject.metadata['title'])
                    dsobject.destroy()
                except:
                    self.showlabel(n)
            else:
                self.showlabel(n)
        elif type(n) == int:
            self.showlabel(n)
        else:
            self.showlabel(round_int(n))
        self.unhighlight("print")
    
    def kbinput(self):
        self.highlighter("kbinput")
        self.bi += 1
        if len(self.tw.keypress) == 1:
            self.keyboard = ord(self.tw.keypress[0])
        else:
            try:
                self.keyboard = {'Escape': 27, 'space': 32, ' ': 32,
                                 'Return': 13, \
                                 'KP_Up': 2, 'KP_Down': 4, 'KP_Left': 1, \
                                 'KP_Right': 3,}[self.tw.keypress]
            except:
                self.keyboard = 0
        self.tw.keypress = ""
        self.unhighlight("kbinput")

    def showlabel(self, label):
        if label=='#nostack':
            shp = 'nostack'
            label=''
        elif label=='#noinput':
            shp = 'noinput'
            label=''
        elif label=='#emptyheap':
            shp = 'emptyheap'
            label=''
        elif label=='#emptybox':
            shp = 'emptybox'
            label='                    '+self.nobox
        elif label=='#nomedia':
            shp = 'nomedia'
            label=''
        elif label=='#nocode':
            shp = 'nocode'
            label=''
        elif label=='#syntaxerror':
            shp = 'syntaxerror'
            label=''
        elif label=='#overflowerror':
            shp = 'overflowerror'
            label=''
        elif label=='#notanumber':
            shp = 'overflowerror'
            label=''
        else:
            shp = 'status'
        self.tw.status_spr.set_shape(self.tw.status_shapes[shp])
        self.tw.status_spr.set_label(label)
        self.tw.status_spr.set_layer(STATUS_LAYER)

    def prim_setbox(self, name, val):
        self.highlighter("setbox"+name)
        self.boxes[name]=val
        self.unhighlight("setbox"+name)

    def prim_push(self, val):
        self.highlighter("push")
        self.heap.append(val)
        self.unhighlight("push")

    def prim_pop(self):
        self.highlighter("pop")
        self.unhighlight("pop")
        try:
            return self.heap.pop(-1)
        except:
            raise logoerror ("#emptyheap")

    def empty_heap(self):
        self.highlighter("empty")
        self.heap = []
        self.unhighlight("empty")

    def highlighter(self, name):
        b = self.tw.block_list.list[self.blk_index[self.bi-1]]
        print "entering block %s: (%d: %s)" % (name, self.bi, b.name)
        return

    def unhighlight(self, name):
        print "in unhighlight"
        if self.tw.step_time == 0:
            return
        if self.bi > 0:
            b = self.tw.block_list.list[self.blk_index[self.bi-1]]
            b.unhighlight()
            print "exiting block %s: (%d: %s)" % (name, self.bi, b.name)

    """
    Everything below is related to multimedia commands
    """

    def show_picture(self, media, x, y, w, h):
        if media == "" or media[6:] == "":
            pass
        elif media[6:] is not "None":
            pixbuf = None
            if self.tw.running_sugar:
                try:
                    dsobject = datastore.get(media[6:])
                except:
                    print "Couldn't open Journal object %s" % (media[6:])
                if movie_media_type(dsobject.file_path[-4:]):
                    play_movie_from_file(self,
                        dsobject.file_path, int(x), int(y), int(w), int(h))
                else:
                    pixbuf = get_pixbuf_from_journal(dsobject, int(w), int(h))
                dsobject.destroy()
            else:
                try:
                    if movie_media_type(media[-4:]):
                        play_movie_from_file(self, media[6:], int(x), int(y),
                                                              int(w), int(h))
                    else:
                        pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
                                     media[6:], int(w), int(h))
                except:
                    print "Couldn't open media object %s" % (media[6:])
            if pixbuf is not None:
                self.tw.canvas.draw_pixbuf(pixbuf, 0, 0, int(x), int(y),
                                                         int(w), int(h))

    def show_description(self, media, x, y, w, h):
        if media == "" or media[6:] == "":
            pass
        elif media[6:] is not "None":
            text = None
            if self.tw.running_sugar:
                try:
                    dsobject = datastore.get(media[6:])
                    text = str(dsobject.metadata['description'])
                    dsobject.destroy()
                except:
                    print "no description in %s" % (media[6:])
            else:
                try:
                    f = open(media[6:], 'r')
                    text = f.read()
                    f.close()
                except:
                    print "no text in %s?" % (media[6:])
            if text is not None:
                print "text: %s" % (text)
                self.tw.canvas.draw_text(text, int(x), int(y),
                                         self.body_height, int(w))
    
    def draw_title(self, title, x, y):
        self.tw.canvas.draw_text(title,int(x),int(y),self.title_height,
                                                     self.tw.canvas.width-x)

    # title, one image, and description
    def show_template1x1(self, title, media):
        print "entering tp1x1 %d" % (self.bi)
        self.bi += 1
        w,h,xo,yo,dx,dy = calc_position(self.tw, 't1x1')
        x = -(self.tw.canvas.width/2)+xo
        y = self.tw.canvas.height/2
        self.tw.canvas.setxy(x, y)
        # save the text size so we can restore it later
        save_text_size = self.tw.textsize
        # set title text
        self.tw.canvas.settextsize(self.title_height)
        self.show(title)
        # calculate and set scale for media blocks
        myscale = 45 * (self.tw.canvas.height - self.title_height*2) \
                      / self.tw.canvas.height
        self.set_scale(myscale)
        # set body text size
        self.tw.canvas.settextsize(self.body_height)
        # render media object
        # leave some space below the title
        y -= int(self.title_height*2*self.tw.lead)
        self.tw.canvas.setxy(x, y)
        self.show(media)
        if self.tw.running_sugar:
            x = 0
            self.tw.canvas.setxy(x, y)
            self.show(media.replace("media_","descr_"))
        # restore text size
        self.tw.canvas.settextsize(save_text_size)
    
    # title, two images (horizontal), two descriptions
    def show_template2x1(self, title, media1, media2):
        print "entering tp2x1 %d" % (self.bi)
        self.bi += 1
        w,h,xo,yo,dx,dy = calc_position(self.tw, 't2x1')
        x = -(self.tw.canvas.width/2)+xo
        y = self.tw.canvas.height/2
        self.tw.canvas.setxy(x, y)
        # save the text size so we can restore it later
        save_text_size = self.tw.textsize
        # set title text
        self.tw.canvas.settextsize(self.title_height)
        self.show(title)
        # calculate and set scale for media blocks
        myscale = 45 * (self.tw.canvas.height - self.title_height*2)/\
                  self.tw.canvas.height
        self.set_scale(myscale)
        # set body text size
        self.tw.canvas.settextsize(self.body_height)
        # render four quadrents
        # leave some space below the title
        y -= int(self.title_height*2*self.tw.lead)
        self.tw.canvas.setxy(x, y)
        self.show(media1)
        x = 0
        self.tw.canvas.setxy(x, y)
        self.show(media2)
        y = -self.title_height
        if self.tw.running_sugar:
            self.tw.canvas.setxy(x, y)
            self.show(media2.replace("media_","descr_"))
            x = -(self.tw.canvas.width/2)+xo
            self.tw.canvas.setxy(x, y)
            self.show(media1.replace("media_","descr_"))
        # restore text size
        self.tw.canvas.settextsize(save_text_size)

    # title and varible number of  bullets
    def show_bullets(self, title, sarray):
        w,h,xo,yo,dx,dy = calc_position(self.tw, 'bullet')
        x = -(self.tw.canvas.width/2)+xo
        y = self.tw.canvas.height/2
        self.tw.canvas.setxy(x, y)
        # save the text size so we can restore it later
        save_text_size = self.tw.textsize
        # set title text
        self.tw.canvas.settextsize(self.title_height)
        self.show(title)
        # set body text size
        self.tw.canvas.settextsize(self.bullet_height)
        # leave some space below the title
        y -= int(self.title_height*2*self.tw.lead)
        for s in sarray:
            self.tw.canvas.setxy(x, y)
            self.show(s)
            y -= int(self.bullet_height*2*self.tw.lead)
        # restore text size
        self.tw.canvas.settextsize(save_text_size)
    
    # title, two images (vertical), two desciptions
    def show_template1x2(self, title, media1, media2):
        print "entering tp1x2 %d" % (self.bi)
        self.bi += 1
        w,h,xo,yo,dx,dy = calc_position(self.tw, 't1x2')
        x = -(self.tw.canvas.width/2)+xo
        y = self.tw.canvas.height/2
        self.tw.canvas.setxy(x, y)
        # save the text size so we can restore it later
        save_text_size = self.tw.textsize
        # set title text
        self.tw.canvas.settextsize(self.title_height)
        self.show(title)
        # calculate and set scale for media blocks
        myscale = 45 * (self.tw.canvas.height - self.title_height*2)/\
                 self.tw.canvas.height
        self.set_scale(myscale)
        # set body text size
        self.tw.canvas.settextsize(self.body_height)
        # render four quadrents
        # leave some space below the title
        y -= int(self.title_height*2*self.tw.lead)
        self.tw.canvas.setxy(x, y)
        self.show(media1)
        if self.tw.running_sugar:
            x = 0
            self.tw.canvas.setxy(x, y)
            self.show(media1.replace("media_","descr_"))
            y = -self.title_height
            self.tw.canvas.setxy(x, y)
            self.show(media2.replace("media_","descr_"))
            x = -(self.tw.canvas.width/2)+xo
            self.tw.canvas.setxy(x, y)
            self.show(media2)
        # restore text size
        self.tw.canvas.settextsize(save_text_size)

    # title and four images
    def show_template2x2(self, title, media1, media2, media3, media4):
        print "entering tp2x2 %d" % (self.bi)
        self.bi += 1
        w,h,xo,yo,dx,dy = calc_position(self.tw, 't2x2')
        x = -(self.tw.canvas.width/2)+xo
        y = self.tw.canvas.height/2
        self.tw.canvas.setxy(x, y)
        # save the text size so we can restore it later
        save_text_size = self.tw.textsize
        # set title text
        self.tw.canvas.settextsize(self.title_height)
        self.show(title)
        # calculate and set scale for media blocks
        myscale = 45 * (self.tw.canvas.height - self.title_height*2)/\
                  self.tw.canvas.height
        self.set_scale(myscale)
        # set body text size
        self.tw.canvas.settextsize(self.body_height)
        # render four quadrents
        # leave some space below the title
        y -= int(self.title_height*2*self.tw.lead)
        self.tw.canvas.setxy(x, y)
        self.show(media1)
        x = 0
        self.tw.canvas.setxy(x, y)
        self.show(media2)
        y = -self.title_height
        self.tw.canvas.setxy(x, y)
        self.show(media4)
        x = -(self.tw.canvas.width/2)+xo
        self.tw.canvas.setxy(x, y)
        self.show(media3)
        # restore text size
        self.tw.canvas.settextsize(save_text_size)

    # title, one media object
    def show_template1x1a(self, title, media1):
        print "entering tp1x1a %d" % (self.bi)
        self.bi += 1
        w,h,xo,yo,dx,dy = calc_position(self.tw, 't1x1a')
        x = -(self.tw.canvas.width/2)+xo
        y = self.tw.canvas.height/2
        self.tw.canvas.setxy(x, y)
        # save the text size so we can restore it later
        save_text_size = self.tw.textsize
        # set title text
        self.tw.canvas.settextsize(self.title_height)
        self.show(title)
        # calculate and set scale for media blocks
        myscale = 90 * (self.tw.canvas.height - self.title_height*2) /\
                       self.tw.canvas.height
        self.set_scale(myscale)
        # set body text size
        self.tw.canvas.settextsize(self.body_height)
        # render media object
        # leave some space below the title
        y -= int(self.title_height*2*self.tw.lead)
        self.tw.canvas.setxy(x, y)
        self.show(media1)
        # restore text size
        self.tw.canvas.settextsize(save_text_size)

    # image only (at current x,y)
    def insert_image(self, media, center):
        w = (self.tw.canvas.width * self.scale)/100
        h = (self.tw.canvas.height * self.scale)/100
        # convert from Turtle coordinates to screen coordinates
        x = self.tw.canvas.width/2+int(self.tw.canvas.xcor)
        y = self.tw.canvas.height/2-int(self.tw.canvas.ycor)
        if center is True:
            x -= w/2
            y -= h/2
        if media[0:5] == 'media':
            self.show_picture(media, x, y, w, h)
    
    # description text only (at current x,y)
    def insert_desc(self, media):
        w = (self.tw.canvas.width * self.scale)/100
        h = (self.tw.canvas.height * self.scale)/100
        # convert from Turtle coordinates to screen coordinates
        x = self.tw.canvas.width/2+int(self.tw.canvas.xcor)
        y = self.tw.canvas.height/2-int(self.tw.canvas.ycor)
        if media[0:5] == 'descr':
            self.show_description(media, x, y, w, h)
    
    def set_scale(self, x):
        self.highlighter("set")
        self.bi += 1
        self.scale = x

    # need to fix export logo to map show to write
    def show(self, string, center=False):
        # convert from Turtle coordinates to screen coordinates
        x = self.tw.canvas.width/2+int(self.tw.canvas.xcor)
        y = self.tw.canvas.height/2-int(self.tw.canvas.ycor)
        if type(string) == str or type(string) == unicode:
            if string == "media_None":
                pass
            elif string[0:6] == 'media_':
                self.insert_image(string, center)
            elif string[0:6] == 'descr_':
                self.insert_desc(string)
            elif string[0:6] == 'audio_':
                self.play_sound(string)
            else:
                if center is True:
                    y -= self.tw.textsize
                self.tw.canvas.draw_text(string,x,y,self.tw.textsize,
                          self.tw.canvas.width-x)
        elif type(string) == float or type(string) == int:
            string = round_int(string)
            if center is True:
                y -= self.tw.textsize
            self.tw.canvas.draw_text(string, x, y, self.tw.textsize,
                                     self.tw.canvas.width-x)
    
    def play_sound(self, audio):
        if audio == "" or audio[6:] == "":
            raise logoerror("#nomedia")
        if self.tw.running_sugar:
            if audio[6:] != "None":
                try:
                    dsobject = datastore.get(audio[6:])
                    play_audio(self, dsobject.file_path)
                except:
                    print "Couldn't open id: " + str(audio[6:])
        else:
            play_audio(self, audio[6:])

    def write(self, string, fsize):
        self.highlighter("write")
        # convert from Turtle coordinates to screen coordinates
        x = self.tw.canvas.width/2+int(self.tw.canvas.xcor)
        y = self.tw.canvas.height/2-int(self.tw.canvas.ycor)
        self.tw.canvas.draw_text(string,x,y-15,int(fsize),self.tw.canvas.width)
        self.unhighlight("write")