Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
RPN Calculat.py for Pythonista
#version 1.2 8 dec. 2012 PKHG
#---------
#inverse sin etc. deg <-> rad
#4 12 2012 prgramming preparations
#UNDO partly done
from scene import *
from random import random
from string import ascii_lowercase
from math import *
from random import random
########## some globals easier typing
memories = {}
l_n = {}
l_red_n ={}
mesg = None
info = None
rad_set = True
#hyp_setting = ''
last_x = 'TODO'
hyp_set = False
#???done_18_red = False
pgrm_mode = 0
pgrm_data ={}
pdata_length = 0
copy_xyzw_data = []
copy_xyzw_pgrm = ['','','','']
infos = ['DEG', 'RAD', 'DEG HYP', 'RAD HYP', 'pgrm mode'] # others append!
infos.append('Clear tap: 0 >X, 1 ->MEMs 2 ->Pgrm, 3 ->sum, 4 ->cancel') #nr. 5
infos.append('MEMs set to 0')
info_mode = 1
input_action = False
clear_info_shown = False
confirmed = False
ch_ob = {'data':['0','1','2','3','4','UNDO'],'active':False, 'but':{}}
save_state = {'memories':[ii for ii in range(41)],'pressed_but':-1,'info_mode':-1}
class MyButton (Scene):
def __init__(self, x=10, y=10, w=1, h=1, txt=' '):
self.x, self.y = x, y
self.txt = txt
self.w, self.h = w, h
self.b_red = False
self.red, self.green, self.blue = Color(1,0,0), Color(0,1,0), Color(0,0,1)
self.l_buf_normal =[]
self.alphabet = []
self.a_places = [ el for el in range(31,37)]
tmp = [el for el in range(25,31)]
self.a_places.extend(tmp)
tmp = [el for el in range(20,24)]
self.a_places.extend(tmp)
tmp = [el for el in range(16,19)]
self.a_places.extend(tmp)
tmp = [el for el in range(11,14)]
self.a_places.extend(tmp)
tmp = [el for el in range(6,9)]
tmp.append(1)
self.a_places.extend(tmp)
#self.memories = {}
for el in self.a_places:
memories[el] = str(el)
#print(self.a_places)
#print memories
memories[37]=' 0'
for el in range(38,41):
memories[el] = ' 0 '
self.action = -1
self.digit_places = [1,6,7,8,11,12,13,16,17,18]
self.digit_found = -1
self.rad_deg, size = render_text('rad -> deg')
self.deg_rad,size = render_text('deg -> rad')
self.names = None
def add_pgrm_data(self,but):
global pgrm_data,pdata_length, info_modey, pgrm_mode, copy_xyzw_data, copy_xyzw_pgrm
if but == 5 and pdata_length == 0:
pgrm_mode = 2
return #back from Pgrm and Red
if self.b_red:
#print 'add_prgm L 74',but
if but == 3: #Pgrm ends this Pgrm-mode RESTORE!
self.b_red = False
pgrm_mode = 0
#print 'DBG L81',copy_xyzw_data[:]
for el in range(4):
memories[37+el] = copy_xyzw_data[el]
txt = self.adjust_txt(copy_xyzw_data[el])
img , size = render_text(txt)
self.root_layer.sublayers[37+el].image = img
copy_xyzw_data =[]
self.root_layer.sublayers[3].background = self.blue
self.root_layer.sublayers[5].background = self.blue
self.change_info(1,col=Color(0,1,0))
self.set_normal()
return #FINISHED
#PKHG.TODO ?? next line ??!!
but = 38 + but
#print 'dbg L92',but
s = 0 #to simplify adding an integer
if but in self.digit_places:
tmp = self.digit_places.index(but)
if self.digit_found == -1:
self.digit_found = 1
pgrm_data[pdata_length] = tmp
s = tmp
else:
try:
pdata_length -= 1
s = tmp + 10 * pgrm_data[pdata_length]
pgrm_data[pdata_length] = s
self.digit_found += 1
except:
print '***ERROR INPUT OF INT TOO LONG'
pdata_length += 1
self.digit_found = -1
#print ' digit found ',tmp
else:
pgrm_data[pdata_length] = [but, info_mode]
self.digit_found = -1
######## hier
for el in range(3,0,-1):
copy_xyzw_pgrm[el] = copy_xyzw_pgrm[el-1]
if self.digit_found > 0:
#print s
copy_xyzw_pgrm[0] = 'adr ' + str(pdata_length) + ' ' + str(s)
else:
copy_xyzw_pgrm[0] = 'adr ' + str(pdata_length) + ' ' + self.names[but]
pdata_length += 1
for el in range(4):
txt = self.adjust_txt(copy_xyzw_pgrm[el])
img , size = render_text(txt)
self.root_layer.sublayers[37+el].image = img
def m_one_txt_layer(self, txt, x, y, col=Color(0,0,0), extra = 0):
#img, size = render_text(txt, font_size=30)
img, size = render_text('Peter')
#print(img,size)
lay = Layer(Rect(x, y, size.w, size.h + 10 + extra))
#lay.image ='Baby_Chick_1'
lay.image = img
lay.background = col
return lay
def adjust_txt(self,txt,width=30):
lt = len(txt)
vo = int((width-lt)/2)
na = width - vo - lt
txt = ' '*vo + txt + ' '*na
return txt
def adjust_display(self, txt, col=Color(0,0,1)):
txt = self.adjust_txt(txt)
img , size = render_text(txt)
self.root_layer.sublayers[37].image = img
self.root_layer.sublayers[37].background = col
def change_mesg(self, message, col=Color(1,0,0)):
global mesg
img,size = render_text(str(message))
mesg.background = col
mesg.image = img
def change_info(self,infos_index,col=Color(0,0,0)):
global infos, info
tmp = self.adjust_txt(infos[infos_index],width=50)
img,size = render_text(tmp)
info.background = col
info.image = img
def m_layer(self,txt,col,row,width_1,width_2,extra=0,backgr = Color(0,0,1),w_stroke=True):
img, size = render_text(txt, font_size = 30)
layer = Layer(Rect(self.x + col * (width_1+extra), self.y + 45 * row, width_2, self.h + size.h))
layer.stroke_weight = 1
if w_stroke:
layer.stroke = Color(0,1,0)
layer.background = backgr
layer.image = img
self.root_layer.add_layer(layer)
self.all_layers.append(layer)
return layer
def setup(self):
global mesg, info, ch_ob
# This will be called before the first frame is drawn.
# Set up the root layer and one other layer:
self.root_layer = Layer(self.bounds)
#center = self.bounds.center()
self.l_n, l_but_info, maks = self.make_l_n()
self.l_buf_normal = l_but_info
self.all_layers =[]
for row in range(4):
for col in range(5):
wi = col + 5 * row + self.b_red * 38
self.m_layer(l_n[wi],col,row,maks,maks,50)
self.m_layer(l_n[20+self.b_red*38],0,4,maks,maks)
for ii in range(21,25):
self.m_layer(l_n[(ii+self.b_red*38)], ii % 20, 4, maks,maks,50)
for ii in range(25,31):
self.m_layer(l_n[(ii+self.b_red*38)], ii % 25, 5, maks,maks,25)
for ii in range(31,37):
self.m_layer(l_n[(ii+self.b_red*38)], ii % 31, 6, maks,maks,25)
#l_n[37] = memories[37]
memories[37] = l_n[37+self.b_red*38]
for ii in range(4):
memories[37+ii] = self.adjust_txt(memories[37+ii])
self.m_layer(memories[37+ii],0, 7.5 + ii, 200, 300)
n_xyzw = ['x','y','z','w']
for ii in range(4):
#print self.root_layer.sublayers[37].frame #==> Rect(x=10, y=347.5, w=300, h=36.0)
self.m_layer(n_xyzw[ii],10.2, 7.5 +ii,30,36,backgr=Color(0,0,0),w_stroke=False )
#print self.root_layer.sublayers[-1].frame
self.m_layer('messages:',1, 7.5 + 5,0,100,backgr=Color(0,0,0),w_stroke=False )
#print self.root_layer.sublayers[-1].frame #Rect(x=10, y=572.5, w=100, h=36.0)
self.m_layer(self.adjust_txt('OK',width=50),10, 7.5 + 5,12,500,backgr=Color(0,1,0))
mesg = self.root_layer.sublayers[-1] #mesg is global
self.m_layer('info:',1, 7.5 + 6,0,100,backgr=Color(0,0,0),w_stroke=False )
#print self.root_layer.sublayers[-1].frame #Rect(x=10, y=572.5, w=100, h=36.0)
self.m_layer(self.adjust_txt('Rad',width=50),10, 7.5 + 6,12,500,backgr=Color(0,1,0))
info = self.root_layer.sublayers[-1] #info is global
#print 'info',type(info),info
self.m_layer('choices:',1, 7.5 + 7,0,100,backgr=Color(0,0,0),w_stroke=False )
self.m_layer('extra:',1, 7.5 + 8,0,100,backgr=Color(0,0,0),w_stroke=False )
#ch_ob = {'data':['0','1','2','3','4','cancel'],'active':False, 'but':{}}
#def m_layer(self,txt,col,row,width_1,width_2,extra=0,backgr = Color(0,0,1),w_stroke=True):
for ii in range(5):
ch_ob['but'][ii] = self.m_layer(ch_ob['data'][ii],1.65+ii,14.5,maks*0.5,maks,50)
ch_ob['but'][5] = self.m_layer(ch_ob['data'][5],1.65,15.5,maks*0.5,maks,50,backgr=Color(1,.3,1))
def set_normal(self):
#for ii, w in enumerate(self.a_places):
for w in range(37):
img,size = render_text( self.l_n[w +38 *self.b_red])
self.root_layer.sublayers[w].image = img
def draw(self):
# Update and draw our root layer. For a layer-based scene, this
# is usually all you have to do in the draw method.
background(0, 0, 0)
self.root_layer.update(self.dt)
self.root_layer.draw()
def touch_began(self, touch):
global input_action, save_state, info_mode, clear_info_shown, pgrm_data, confirmed
def prepare_undo(but):
print('*********** prepare_undo called')
#save_state = {'memories':[],'pressed_but':-1,'info_mode':-1}
save_state['info_mode'] = info_mode
for el in memories:
save_state['memories'][el] = memories[el]
save_state['pressed_but'] = but
#check, which button is touched
t_button = -1
for i, el in enumerate(self.all_layers):
if touch.location in el.frame:
t_button = i
break
#for touched_button
def do_UNDO():
global clear_info_shown
#print('DBG L 262 UNDO',clear_info_shown)
if clear_info_shown: # clear what?!
clear_info_shown = False
self.change_info(1, col=Color(0,0,1))
else:
for ii, el in enumerate(save_state['memories']):
memories[ii] = el
info_mode = save_state['info_mode']
self.change_info(info_mode, self.green)
for el in range(37,41):
img, size = render_text(self.adjust_txt(memories[el]))
self.root_layer.sublayers[el].image = img
##### real begin of touch_begin **********************************
print 'dbg touch black?',i,t_button
#print self.root_layer.sublayers[i].frame
#t_button == -1 => no button touched!!
if t_button == 56: #UNDO
print '********** undo called'
do_UNDO()
return
if clear_info_shown and t_button in [51, 52, 53, 54, 55]:
clear_info_shown = False
self.change_info(info_mode, col=Color(0,0,1))
if confirmed and (t_button <> 53):
confirmed = False
self.change_mesg('OK',Color(0,1,0))
if t_button == 55: #but 4 = cancel?!
return
if t_button == 51: #X reg
memories[37] = ''
self.adjust_display(' ')
return
if t_button == 52:
clear_memories()
self.change_info(6)
return
if t_button == 53:
if confirmed:
pgrm_data ={}
print('*** INFO PGRM CLEARED')
confirmed = False
self.change_mesg('Pgrm CLEARED',Color(0,1,1))
else:
self.change_mesg('REALLY? confirm: tap me again!',Color(1,0,0))
clear_info_shown = True
confirmed =True
return
if t_button == 54:
print('*** INFO CLEAR SUM NOT YET IMPLEMENTED')
return
return # canceled nothing to do ;-)
if t_button < 0 or t_button > 36: #not handled but? Yes, return!
return
####normal commands
prepare_undo(t_button)
#print save_state
self.exe_commands(t_button)
def exe_commands(self,t_button):
global mesg, last_x, hyp_set, pgrm_mode, save_state
error =''
def set_alphabet():
for ii, w in enumerate(self.a_places):
img , size = render_text(' '+ascii_lowercase[ii] + ' ')
self.root_layer.sublayers[w].image = img
def mem_up():
for el in range(39,36,-1):
memories[el+1] = memories[el]
for el in range(37,41):
img, size = render_text(self.adjust_txt(memories[el]))
self.root_layer.sublayers[el].image = img
def mem_down():
for el in [39,40]:
memories[el-1] = memories[el]
#memories[40] = '0'
for el in range(37,41):
img, size = render_text(self.adjust_txt(memories[el]))
self.root_layer.sublayers[el].image = img
def rotate_down():
tmp = memories[37]
for el in [38,39,40]:
memories[el-1] = memories[el]
memories[40] = tmp
for el in range(37,41):
img, size = render_text(self.adjust_txt(memories[el]))
self.root_layer.sublayers[el].image = img
def red_actions(but):
global hyp_set, rad_set, pgrm_mode, info_mode #???done_18_red
global clear_info_shown, input_action
error = 'not yet impemented '
if but == 31: #X^2
try:
tmp = float(memories[37])**2
memories[37]=str(tmp)
error =''
except:
error = '***ERROR X^2 X=' #+ memories[37]
elif but == 32: #10^X
try:
tmp = 10**float(memories[37])
memories[37] = str(tmp)
error = ''
except :
error = '***ERROR 10^X X='
elif but == 33: #LOG(X)
try:
tmp = log10(float(memories[37]))
memories[37] = str(tmp)
error = ''
except :
'***ERROR LOG(X) X='
elif but == 22:
# print '22 tapped',rad_set
error = ''
rad_set = not rad_set
if rad_set:
self.root_layer.sublayers[22].background = self.blue
self.root_layer.sublayers[18].image = self.deg_rad
else:
self.root_layer.sublayers[22].background = self.red
self.root_layer.sublayers[18].image = self.rad_deg
info_mode = 1*rad_set+2*hyp_set
self.change_info(info_mode,col=Color(random(),random(),1))
elif but == 25:
error = 'COMPLX TAPPED, not yet implemented'
elif but == 24: #CLEAR
clear_info_shown = True
input_action = True
self.change_info(5)
error = ''
#CLEAR X VARS PROG SUM
elif but == 26: #pi
error = ''
memories[37] = str(pi)
elif but == 27: #SET HYP
hyp_set = not hyp_set
if hyp_set:
self.root_layer.sublayers[27].background = self.red
else:
self.root_layer.sublayers[27].background = self.blue
#TODO needs indicator
info_mode = 1*rad_set+2*hyp_set
self.change_info(info_mode,col=Color(random(),random(),1))
#self.adjust_display('HYP set')
error = ''
elif but == 20: #LAST_X
error = ''
memories[37] = last_x
#print '*RED 20****DBG', type(last_x), last_x
elif but == 18: #DEG <=> RAD
try:
arg = float(memories[37])
if rad_set:
memories[37] = str(radians(arg))
#self.root_layer.sublayers[18].image = self.deg_rad
else:
memories[37] = str(degrees(arg))
#self.root_layer.sublayers[18].image = self.rad_deg
error = ''
except:
error = '***ERROR DEG <=> RAD'
elif but == 28: #ASIN
try:
arg =float(memories[37])
memories[37] = str(asin(arg))
error = ''
except :
error = '***ERROR asin'
elif but == 29: #ACOS
try:
arg =float(memories[37])
memories[37] = str(acos(arg))
error = ''
except :
error = '***ERROR acos'
elif but == 30: #ATAN
try:
arg =float(memories[37])
memories[37] = str(atan(arg))
error = ''
except :
error = '***ERROR atan'
elif but == 3: #PGRM
col = self.red
error = ''
#print('Pgrm tap ', pgrm_mode,' data =',pgrm_data.values())
if pgrm_mode == 0:
for el in range(37,41):
copy_xyzw_data.append(memories[el])
#print 'xyzw saved in copy_xyzw_data'
pgrm_mode = 1 # first time not in Pgrm!
self.change_info(4, col=Color(0,0,1))
elif pgrm_mode == 2:
pgrm_mode = 0
col = self.blue
else:
prgm_mode = 0 # disable Pgrm mode
self.change_info(info_mode, col=Color(0,0,1))
col = self.blue
self.root_layer.sublayers[3].background = col
elif but == 0: #OFF
#from sys import exit
#exit(0)
print 'saved commands'
for el in pgrm_data.values():
print el
error = 'tap x to real exit'
#self.change_mesg(self.adjust_txt('tap x to real exit', width=50),col=Color(1,1,0))
if not error and pgrm_mode == 0:
self.adjust_display(memories[37])
return error
if t_button == 5: #RED is a toggle
if self.b_red:
self.b_red = False
self.root_layer.sublayers[t_button].background = self.blue
self.change_mesg(self.adjust_txt('OK', width=50),col=Color(0,1,0))
self.root_layer.sublayers[27].background = self.blue
self.root_layer.sublayers[22].background = self.blue
col = self.blue
if hyp_set:
col = self.red
for bu in range(28,31):
self.root_layer.sublayers[bu].background = col
#if prgm_mode == 'active': #PKHG if really needed?
#self.root_layer.sublayers[3].background = self.blue
else:
self.b_red = True
self.root_layer.sublayers[t_button].background = self.red
for bu in range(28,31):
self.root_layer.sublayers[bu].background = self.blue
if hyp_set:
self.root_layer.sublayers[27].background = self.red
else:
self.root_layer.sublayers[27].background = self.blue
#TODO needs indicator
self.set_normal()
#### already a return for new touch, RED changes layout with corresponing actions
if pgrm_mode > 0:
if pgrm_mode > 1:
self.add_pgrm_data(5)
else:
pgrm_mode = 2
return
if pgrm_mode:
self.add_pgrm_data(t_button)
elif self.b_red:
error = red_actions(t_button)
elif self.action == 25: #STO
#print 'nu sto checken'
if t_button in self.a_places:
tmp = memories[37]
#print 'wat=',tmp, 'where',t_button
if tmp.find('***') < 0:
memories[37] = '0'
memories[t_button] = tmp #WHY NOT MEMORIES[37] POSSIBLE.
#print 'stored',memories[t_button]
self.action = -1
memories[37] = tmp
#self.setup()
self.set_normal()
self.adjust_display(memories[37])
elif self.action == 26: # RCL
#print 'nu rcl check'
#print memories
#print 'de t_button', t_button
if t_button in self.a_places:
#print 'value to set',memories[t_button]
self.action = -1
memories[37]= memories[t_button]
self.set_normal()
self.adjust_display(memories[37])
elif t_button in self.digit_places:
#print 'digit place',t_button
print '>',memories[37],'<'
if memories[37].strip() == '0':
memories[37] = ''
if self.action == -1:
self.action = -2
#mem_up()+
w = self.digit_places.index(t_button)
memories[37] = str(w)
self.adjust_display(memories[37])
elif self.action == -2:
#max check!! digit . check
w = self.digit_places.index(t_button)
memories[37] += str(w)
self.adjust_display(memories[37])
elif t_button in [4,9,14,19]: # + - * /
self.action = -1
try:
arg1 = float(memories[38])
except:
error = "***ERROR arg1, zero used"
arg1 = 0
try:
arg2 = float(memories[37])
except:
error += " ***ERROR arg2, zero used"
arg2 = 0
if t_button == 4: #add
memories[37] = str(arg1 + arg2)
elif t_button == 9:
memories[37] = str(arg1 - arg2)
elif t_button == 14:
memories[37] = str(arg1 * arg2)
elif t_button == 19:
try:
memories[37] = str(arg1 / arg2) #no division by zero!
except:
memories[37] = str(arg1) +'x / 0 ***Clear me!'
mem_down()
elif t_button == 25: #STO prepare
self.action = 25
set_alphabet()
elif t_button == 26: #RCL prepare
self.action = 26
set_alphabet()
elif t_button == 27: #ROTATE DOWN
rotate_down()
elif t_button == 0: #CLEAR
memories[37] = ''
self.adjust_display('')
elif t_button == 2:
#print '. touched'
#print('www',memories[37].find('.'))
if memories[37].find('.') < 0:
memories[37] = memories[37].strip() + '.'
self.adjust_display(memories[37])
elif (self.action == -1 or self.action ==-2) and t_button == 20: # ENTER CASE
last_x = memories[37]
#print 'but' + str(t_button) + ' pressed', type(last_x), last_x
mem_up()
self.action =-1
self.adjust_display(memories[37])
elif t_button == 24:
tmp = memories[37].strip()
if len(tmp) > 0:
memories[37] = tmp[:-1]
self.adjust_display(memories[37])
elif t_button == 21: # x<>y
tmp = memories[38]
memories[38] = memories[37]
img, size = render_text(self.adjust_txt(memories[38]))
#img, size = render_text(memories[38])
self.root_layer.sublayers[38].image = img
memories[37] = tmp
self.adjust_display(memories[37])
elif t_button == 22: # +- button
if self.action == -2:
tmp = memories[37]
tep = tmp.find('e')
if tep > -1:
mant = tmp[:tep+1]
expd = tmp[(tep+2):]
#print 'expd',len(expd),expd
len_expd = len(expd)
try:
expd = str(-int(float(expd)))
except:
expd = '-'
#print 'expd',len(expd),expd
memories[37] = mant + expd
else:
try:
tmp = -float(memories[37])
memories[37] = str(tmp)
except:
memories[37] = '-'
self.adjust_display(memories[37])
elif t_button == 23: #E case
tmp = memories[37].find('e')
if tmp < 0:
self.action = -2
memories[37] += 'e'
self.adjust_display(memories[37])
else:
self.action = -2
elif t_button == 35: # 1/x
try:
tmp = 1.0 / float(memories[37])
memories[37] = str(tmp)
self.adjust_display(memories[37])
except:
error = '1/x ***ERROR.?? with '
elif t_button == 31: #SQRT
try:
tmp = sqrt(float(memories[37]))
memories[37] = str(tmp)
self.adjust_display(memories[37])
except :
error = '*** SQRT ERROR WITH'
elif t_button == 32: #EXP
try:
tmp = exp(float(memories[37]))
memories[37] = str(tmp)
self.adjust_display(memories[37])
except :
error = '*** EXP ERROR WITH '
elif t_button == 33: #LOG
try:
tmp = log(float(memories[37]))
memories[37] = str(tmp)
self.adjust_display(memories[37])
except :
error = '*** LOG ERROR WITH '
elif t_button == 34: #Y^X
try:
tmp = float(memories[38])**float(memories[37])
memories[37] = str(tmp)
self.adjust_display(memories[37])
except :
error = '*** Y^X ERROR WITH '
elif t_button == 28: #SIN
try:
arg = float(memories[37])
if hyp_set:
tmp = sinh(arg)
else:
if not rad_set:
arg = radians(arg)
tmp = sin(arg)
memories[37] = str(tmp)
self.adjust_display(memories[37])
except :
error = '*** SIN(H) ERROR WITH '
elif t_button == 29: #COS
try:
arg = float(memories[37])
if hyp_set:
tmp = cosh(arg)
else:
if not rad_set:
arg = radians(arg)
tmp = cos(arg)
memories[37] = str(tmp)
self.adjust_display(memories[37])
except :
error = '*** COS(H) ERROR WITH '
elif t_button == 30: #TAN TANH
try:
arg = float(memories[37])
if hyp_set:
tmp = tanh(arg)
else:
if not radians(arg):
arg = radians(arg)
tmp = tan(arg)
memories[37] = str(tmp)
self.adjust_display(memories[37])
except :
error = '*** TAN(H) ERROR WITH '
elif t_button == 3: #R/S
print pgrm_data
ueerror = 'R/S not yet'
if error:
tmp = error + '"' + memories[37] + '"'
self.change_mesg(tmp)
#print tmp
else:
self.change_mesg(self.adjust_txt('OK', width=50),col=Color(0,1,0))
def touch_moved(self, touch):
pass
def touch_ended(self, touch):
pass
def make_l_n(self):
"""make names for lower part of calculator"""
# l_n = {}
l_n[0] = " C "
l_n[1] = " 0 "
l_n[2] = " . "
l_n[3] = " R/S "
l_n[4] = " + "
l_n[5] = " RED "
l_n[6] = " 1 "
l_n[7] = " 2 "
l_n[8] = " 3 "
l_n[9] = " - "
l_n[10] = "down"
l_n[11] = " 4 "
l_n[12] = " 5 "
l_n[13] = " 6 "
l_n[14] = " * "
l_n[15] = " XEQ "
l_n[16] = " 7 "
l_n[17] = " 8 "
l_n[18] = " 9 "
l_n[19] = " / "
l_n[20] = 'ENTER'
l_n[21] = 'x<>y'
l_n[22] = '+/-'
l_n[23] = ' E '
l_n[24] = ' <== '
l_n[25] = ' sto '
l_n[26] = ' rcl '
l_n[27] = 'rot dn'
l_n[28] = ' SIN '
l_n[29] = ' COS '
l_n[30] = 'TAN'
l_n[31] = 'SQRT'
l_n[32] = 'EXP'
l_n[33] = 'LN'
l_n[34] = 'Y^X'
l_n[35] = '1/X'
l_n[36] = 'sum +'
l_n[37] = self.adjust_txt('0')
######red ones
l_n[38+0] = " OFF "
l_n[38+1] = " input "
l_n[38+2] = " show "
l_n[38+3] = " Pgrm "
l_n[38+4] = " View "
l_n[38+5] = " RED "
l_n[38+6] = " save/restore "
l_n[38+7] = " stat "
l_n[38+8] = " prob "
l_n[38+9] = " mem "
l_n[38+10] = " ^ "
l_n[38+11] = " lbl/rtn "
l_n[38+12] = " loop "
l_n[38+13] = " flags "
l_n[38+14] = " tests "
l_n[38+15] = " gto "
l_n[38+16] = "P<>R"
l_n[38+17] = "H<>HMS"
l_n[38+18] = "deg -> rad"
l_n[38+19] = "Base"
l_n[38+20] = 'Last X'
l_n[38+21] = 'parts'
l_n[38+22] = 'rad/deg'
l_n[38+23] = 'disp'
l_n[38+24] = 'clear'
l_n[38+25] = 'complx'
l_n[38+26] = ' pi '
l_n[38+27] = 'HYP'
l_n[38+28] = 'ASIN'
l_n[38+29] = 'ACOS'
l_n[38+30] = 'ATAN'
l_n[38+31] = 'x^2'
l_n[38+32] = '10^x'
l_n[38+33] = 'LOG'
l_n[38+34] = '%'
l_n[38+35] = '%CHG'
l_n[38+36] = 'sum -'
l_n[38+37] = self.adjust_txt('0')
self.names = l_n
l_but_inf = {}
for i, el in enumerate(l_n.values()):
#print el
l_but_inf[i] = render_text(l_n[i], font_size = 30)
#print(l_but_inf[0])
tmp = [l_but_inf[i][1].w for i in range(20)]
#print tmp
#print max(tmp)
return (l_n, l_but_inf, max(tmp))
def clear_memories():
for ii in range(41):
memories[ii] = '0'
print '*** INFO: memories set to "0"'
run(MyButton())
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment