summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/asymptote/GUI
diff options
context:
space:
mode:
authorKarl Berry <karl@freefriends.org>2013-04-07 18:19:31 +0000
committerKarl Berry <karl@freefriends.org>2013-04-07 18:19:31 +0000
commit752012c605d34cd943795527a9738475a6958fcc (patch)
tree4ee06acdd8333a662c2d6f6ef716235053468f55 /Master/texmf-dist/asymptote/GUI
parent9789d09132f18a838e84f041b4b3aff28d3426ec (diff)
texmf -> texmf-dist: start with unique dirs from texmf
git-svn-id: svn://tug.org/texlive/trunk@29712 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Master/texmf-dist/asymptote/GUI')
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/CubicBezier.py101
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/UndoRedoStack.py117
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasy.py35
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasy2asy.py767
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasyActions.py387
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasyBezierEditor.py208
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasyCodeEditor.py37
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasyColorPicker.py248
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasyFile.py315
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasyGUIIcons.py92
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasyMainWin.py1741
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasyOptions.py126
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasyOptionsDialog.py228
-rwxr-xr-xMaster/texmf-dist/asymptote/GUI/xasyVersion.py2
14 files changed, 4404 insertions, 0 deletions
diff --git a/Master/texmf-dist/asymptote/GUI/CubicBezier.py b/Master/texmf-dist/asymptote/GUI/CubicBezier.py
new file mode 100755
index 00000000000..6455b700a79
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/CubicBezier.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# Convert a Bezier curve to a polyline
+#
+# Once Tk supports "RawCurves" this will not be needed.
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+###########################################################################
+import math
+
+def norm(vector):
+ """Return the norm of a vector"""
+ return math.sqrt(vector[0]**2+vector[1]**2)
+
+def splitLine(end0,end1,t):
+ """Split a line at the distance t, with t in (0,1)"""
+ return (end0[0]+t*(end1[0]-end0[0]),end0[1]+t*(end1[1]-end0[1]))
+
+def splitBezier(node0,control0,control1,node1,t):
+ """Find the nodes and control points for the segments of a Bezier curve split at t"""
+ a = splitLine(node0,control0,t)
+ b = splitLine(control0,control1,t)
+ c = splitLine(control1,node1,t)
+ d = splitLine(a,b,t)
+ e = splitLine(b,c,t)
+ f = splitLine(d,e,t)#this is the point on the curve at t
+ return ([node0,a,d,f],[f,e,c,node1])
+
+def BezierWidth(node0,control0,control1,node1):
+ """Compute the distance of the control points from the node-node axis"""
+ deltax = node1[0] - node0[0]
+ deltay = node1[1] - node0[1]
+ length = norm((deltax,deltay))
+ if length == 0:
+ y1 = control0[1]-node0[1]
+ y2 = control1[1]-node0[1]
+ else:
+ cosine = deltax/length
+ sine = deltay/length
+ y1 = cosine*(control0[1]-node0[1])-sine*(control0[0]-node0[0])
+ y2 = cosine*(control1[1]-node0[1])-sine*(control1[0]-node0[0])
+ if y1*y2 >= 0:
+ #same sign
+ return max(abs(y1),abs(y2))
+ else:
+ #opposite sign
+ return abs(y1)+abs(y2)
+
+#If the above algorithm fails, this one will work, but it is far from elegant
+#def computeIntermediates(steps,node0,control0,control1,node1):
+ #pointList = []
+ #for a in range(0,100,100/steps)+[100]:
+ #t = a/100.0
+ #t1 = 1-t
+ #x = node0[0]*t1**3+3*control0[0]*t*t1**2+3*control1[0]*t**2*t1+node1[0]*t**3
+ #y = node0[1]*t1**3+3*control0[1]*t*t1**2+3*control1[1]*t**2*t1+node1[1]*t**3
+ #pointList.append((x,y))
+ #return pointList
+#def makeBezier(steps,node0,control0,control1,node1):
+ #if len(node0)!=2 or len(control0)!=2 or len(control1)!=2 or len(node1)!=2:
+ #return -1
+ #else:
+ #return [node0]+computeIntermediates(steps,node0,control0,control1,node1)+[node1]
+
+def makeBezierIntermediates(node0,control0,control1,node1,epsilon):
+ """Find the points, excluding node0, to be used as the line segment endpoints"""
+ if(BezierWidth(node0,control0,control1,node1) <= epsilon):
+ return [node1]
+ else:
+ splitUp = splitBezier(node0,control0,control1,node1,0.5)
+ return makeBezierIntermediates(*splitUp[0]+[epsilon])+makeBezierIntermediates(*splitUp[1]+[epsilon])
+
+def makeBezier(node0,control0,control1,node1,epsilon=1):
+ """Return the vertices to be used in the polyline representation of a Bezier curve"""
+ return [node0]+makeBezierIntermediates(node0,control0,control1,node1,epsilon)
+
+if __name__ == '__main__':
+ pointList = makeBezier((-80,0),(-150,40),(150,120),(80,0),0.5)
+ from timeit import Timer
+ t = Timer('makeBezier((-80,0),(-40,-40),(40,120),(80,0),1)','from __main__ import makeBezier')
+ print pointList
+ print len(pointList)
+ iterations = 1000
+ time = t.timeit(iterations)
+ print "%d iterations took %f seconds (%f ms for each)."%(iterations,time,1000.0*time/iterations)
+ points = []
+ for point in pointList:
+ points.append(point[0])
+ points.append(-point[1])
+ from Tkinter import *
+ root = Tk()
+ canv = Canvas(root,scrollregion=(-100,-100,100,100))
+ canv.pack()
+ canv.create_line(points)
+ for point in pointList:
+ canv.create_oval(point[0],-point[1],point[0],-point[1],fill='red',outline='red')
+ root.mainloop()
diff --git a/Master/texmf-dist/asymptote/GUI/UndoRedoStack.py b/Master/texmf-dist/asymptote/GUI/UndoRedoStack.py
new file mode 100755
index 00000000000..f4a247a411d
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/UndoRedoStack.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# UndoRedoStack implements the usual undo/redo capabilities of a GUI
+#
+# Author: Orest Shardt
+# Created: July 23, 2007
+#
+###########################################################################
+
+class action:
+ def __init__(self,act,inv):
+ self.act = act
+ self.inv = inv
+ def undo(self):
+ #print "Undo:",self
+ self.inv()
+ def redo(self):
+ #print "Redo:",self
+ self.act()
+ def __str__(self):
+ return "A generic action"
+
+class beginActionGroup:
+ pass
+
+class endActionGroup:
+ pass
+
+class actionStack:
+ def __init__(self):
+ self.clear()
+
+ def add(self,action):
+ self.undoStack.append(action)
+ #print "Added",action
+ self.redoStack = []
+
+ def undo(self):
+ if len(self.undoStack) > 0:
+ op = self.undoStack.pop()
+ if op is beginActionGroup:
+ level = 1
+ self.redoStack.append(endActionGroup)
+ while level > 0:
+ op=self.undoStack.pop()
+ if op is endActionGroup:
+ level -= 1
+ self.redoStack.append(beginActionGroup)
+ elif op is beginActionGroup:
+ level += 1
+ self.redoStack.append(endActionGroup)
+ else:
+ op.undo()
+ self.redoStack.append(op)
+ elif op is endActionGroup:
+ raise Exception,"endActionGroup without previous beginActionGroup"
+ else:
+ self.redoStack.append(op)
+ op.undo()
+ #print "undid",op
+ else:
+ pass #print "nothing to undo"
+
+ def redo(self):
+ if len(self.redoStack) > 0:
+ op = self.redoStack.pop()
+ if op is beginActionGroup:
+ level = 1
+ self.undoStack.append(endActionGroup)
+ while level > 0:
+ op = self.redoStack.pop()
+ if op is endActionGroup:
+ level -= 1
+ self.undoStack.append(beginActionGroup)
+ elif op is beginActionGroup:
+ level += 1
+ self.undoStack.append(endActionGroup)
+ else:
+ op.redo()
+ self.undoStack.append(op)
+ elif op is endActionGroup:
+ raise Exception,"endActionGroup without previous beginActionGroup"
+ else:
+ self.undoStack.append(op)
+ op.redo()
+ #print "redid",op
+ else:
+ pass #print "nothing to redo"
+
+ def setCommitLevel(self):
+ self.commitLevel = len(self.undoStack)
+
+ def changesMade(self):
+ if len(self.undoStack) != self.commitLevel:
+ return True
+ else:
+ return False
+
+ def clear(self):
+ self.redoStack = []
+ self.undoStack = []
+ self.commitLevel = 0
+
+if __name__=='__main__':
+ import sys
+ def opq():
+ print "action1"
+ def unopq():
+ print "inverse1"
+ q = action(opq,unopq)
+ w = action(lambda:sys.stdout.write("action2\n"),lambda:sys.stdout.write("inverse2\n"))
+ e = action(lambda:sys.stdout.write("action3\n"),lambda:sys.stdout.write("inverse3\n"))
+ s = actionStack()
+ s.add(q)
+ s.add(w)
+ s.add(e)
diff --git a/Master/texmf-dist/asymptote/GUI/xasy.py b/Master/texmf-dist/asymptote/GUI/xasy.py
new file mode 100755
index 00000000000..ffca16a1e2d
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasy.py
@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# xasy implements a graphical interface for Asymptote.
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+############################################################################
+
+import getopt,sys,signal
+from Tkinter import *
+import xasyMainWin
+
+signal.signal(signal.SIGINT,signal.SIG_IGN)
+
+root = Tk()
+mag = 1.0
+try:
+ opts,args = getopt.getopt(sys.argv[1:],"x:")
+ if(len(opts)>=1):
+ mag = float(opts[0][1])
+except:
+ print "Invalid arguments."
+ print "Usage: xasy.py [-x magnification] [filename]"
+ sys.exit(1)
+if(mag <= 0.0):
+ print "Magnification must be positive."
+ sys.exit(1)
+if(len(args)>=1):
+ app = xasyMainWin.xasyMainWin(root,args[0],mag)
+else:
+ app = xasyMainWin.xasyMainWin(root,magnification=mag)
+root.mainloop()
diff --git a/Master/texmf-dist/asymptote/GUI/xasy2asy.py b/Master/texmf-dist/asymptote/GUI/xasy2asy.py
new file mode 100755
index 00000000000..7779e073f81
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasy2asy.py
@@ -0,0 +1,767 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# xasy2asy provides a Python interface to Asymptote
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+###########################################################################
+import sys,os,signal,threading
+from subprocess import *
+from string import *
+import xasyOptions
+import Queue
+from Tkinter import *
+from tempfile import mkdtemp
+
+# PIL support is now mandatory due to rotations
+try:
+ import ImageTk
+ import Image
+except:
+ pass
+
+import CubicBezier
+
+quickAsyFailed = True
+global AsyTempDir
+
+console=None
+
+def startQuickAsy():
+ global quickAsy
+ global quickAsyFailed
+ global AsyTempDir
+ global fout,fin
+ if quickAsyRunning():
+ return
+ try:
+ fout.close()
+ quickAsy.wait()
+ except:
+ pass
+ try:
+ quickAsyFailed = False
+ if os.name == "nt":
+ AsyTempDir=mkdtemp(prefix="asy_", dir="./")
+ else:
+ AsyTempDir=mkdtemp(prefix="asy_")+os.sep
+ if sys.platform[:3] == 'win':
+ quickAsy=Popen([xasyOptions.options['asyPath'],"-noV","-multiline","-q",
+ "-o"+AsyTempDir,"-inpipe=0","-outpipe=2"],stdin=PIPE,stderr=PIPE)
+ fout=quickAsy.stdin
+ fin=quickAsy.stderr
+ else:
+ (rx,wx) = os.pipe()
+ (ra,wa) = os.pipe()
+ quickAsy=Popen([xasyOptions.options['asyPath'],"-noV","-multiline","-q",
+ "-o"+AsyTempDir,"-inpipe="+str(rx),"-outpipe="+str(wa)])
+ fout=os.fdopen(wx,'w')
+ fin=os.fdopen(ra,'r')
+ if quickAsy.returncode != None:
+ quickAsyFailed = True
+ except:
+ quickAsyFailed = True
+
+def getAsyTempDir():
+ return AsyTempDir
+
+def quickAsyRunning():
+ if quickAsyFailed or quickAsy.returncode != None:
+ return False
+ else:
+ return True
+
+def asyExecute(command):
+ if not quickAsyRunning():
+ startQuickAsy()
+ fout.write(command)
+
+def closeConsole(event):
+ global console
+ console = None
+
+def consoleOutput(line):
+ global console
+ global ctl
+ if console == None:
+ ctl=Toplevel()
+ ctl.title("Asymptote Console")
+ ctl.bind("<Destroy>",closeConsole)
+ yscrollbar=Scrollbar(ctl)
+ yscrollbar.pack(side=RIGHT,fill=Y)
+ console=Text(ctl,yscrollcommand=yscrollbar.set)
+ console.pack()
+ yscrollbar.config(command=console.yview)
+ console.insert(END,line)
+ ctl.lift()
+
+class asyTransform:
+ """A python implementation of an asy transform"""
+ def __init__(self,initTuple,delete=False):
+ """Initialize the transform with a 6 entry tuple"""
+ if type(initTuple) == type((0,)) and len(initTuple) == 6:
+ self.t = initTuple
+ self.x,self.y,self.xx,self.xy,self.yx,self.yy = initTuple
+ self.deleted = delete
+ else:
+ raise Exception,"Illegal initializer for asyTransform"
+
+ def getCode(self):
+ """Obtain the asy code that represents this transform"""
+ if self.deleted:
+ return str(self.t) + ", false"
+ else:
+ return str(self.t)
+
+ def scale(self,s):
+ return asyTransform((0,0,s,0,0,s))*self
+
+ def __str__(self):
+ """Equivalent functionality to getCode(). It allows the expression str(asyTransform) to be meaningful."""
+ return self.getCode()
+
+ def __mul__(self,other):
+ """Define multiplication of transforms as composition."""
+ if type(other)==type((0,)):
+ if len(other) == 6:
+ return self*asyTransform(other)
+ elif len(other) == 2:
+ return ((self.t[0]+self.t[2]*other[0]+self.t[3]*other[1]),(self.t[1]+self.t[4]*other[0]+self.t[5]*other[1]))
+ else:
+ raise Exception, "Illegal multiplier of %s"%str(type(other))
+ elif isinstance(other,asyTransform):
+ result = asyTransform((0,0,0,0,0,0))
+ result.x = self.x+self.xx*other.x+self.xy*other.y
+ result.y = self.y+self.yx*other.x+self.yy*other.y
+ result.xx = self.xx*other.xx+self.xy*other.yx
+ result.xy = self.xx*other.xy+self.xy*other.yy
+ result.yx = self.yx*other.xx+self.yy*other.yx
+ result.yy = self.yx*other.xy+self.yy*other.yy
+ result.t = (result.x,result.y,result.xx,result.xy,result.yx,result.yy)
+ return result
+ else:
+ raise Exception, "Illegal multiplier of %s"%str(type(other))
+
+def identity():
+ return asyTransform((0,0,1,0,0,1))
+
+class asyObj:
+ """A base class for asy objects: an item represented by asymptote code."""
+ def __init__(self):
+ """Initialize the object"""
+ self.asyCode = ""
+
+ def updateCode(self,mag=1.0):
+ """Update the object's code: should be overriden."""
+ pass
+
+ def getCode(self):
+ """Return the code describing the object"""
+ self.updateCode()
+ return self.asyCode
+
+class asyPen(asyObj):
+ """A python wrapper for an asymptote pen"""
+ def __init__(self,color=(0,0,0),width=0.5,options=""):
+ """Initialize the pen"""
+ asyObj.__init__(self)
+ self.options=options
+ self.width=width
+ self.setColor(color)
+ self.updateCode()
+ if options != "":
+ self.computeColor()
+
+ def updateCode(self,mag=1.0):
+ """Generate the pen's code"""
+ self.asyCode = "rgb(%g,%g,%g)"%self.color+"+"+str(self.width)
+ if len(self.options) > 0:
+ self.asyCode += "+"+self.options
+
+ def setWidth(self,newWidth):
+ """Set the pen's width"""
+ self.width=newWidth
+ self.updateCode()
+
+ def setColor(self,color):
+ """Set the pen's color"""
+ if type(color) == type((1,)) and len(color) == 3:
+ self.color = color
+ else:
+ self.color = "(0,0,0)"
+ self.updateCode()
+
+ def computeColor(self):
+ """Find out the color of an arbitrary asymptote pen."""
+ fout.write("pen p="+self.getCode()+';\n')
+ fout.write("file fout=output(mode='pipe');\n")
+ fout.write("write(fout,colorspace(p),newl);\n")
+ fout.write("write(fout,colors(p));\n")
+ fout.write("flush(fout);\n")
+ fout.flush()
+ colorspace = fin.readline()
+ if colorspace.find("cmyk") != -1:
+ lines = fin.readline()+fin.readline()+fin.readline()+fin.readline()
+ parts = lines.split()
+ c,m,y,k = eval(parts[0]),eval(parts[1]),eval(parts[2]),eval(parts[3])
+ k = 1-k
+ r,g,b = ((1-c)*k,(1-m)*k,(1-y)*k)
+ elif colorspace.find("rgb") != -1:
+ lines = fin.readline()+fin.readline()+fin.readline()
+ parts = lines.split()
+ r,g,b = eval(parts[0]),eval(parts[1]),eval(parts[2])
+ elif colorspace.find("gray") != -1:
+ lines = fin.readline()
+ parts = lines.split()
+ r = g = b = eval(parts[0])
+ self.color = (r,g,b)
+
+ def tkColor(self):
+ """Return the tk version of the pen's color"""
+ self.computeColor()
+ r,g,b = self.color
+ r,g,b = int(256*r),int(256*g),int(256*b)
+ if r == 256:
+ r = 255
+ if g == 256:
+ g = 255
+ if b == 256:
+ b = 255
+ r,g,b = map(hex,(r,g,b))
+ r,g,b = r[2:],g[2:],b[2:]
+ if len(r) < 2:
+ r += '0'
+ if len(g) < 2:
+ g += '0'
+ if len(b) < 2:
+ b += '0'
+ return'#'+r+g+b
+
+class asyPath(asyObj):
+ """A python wrapper for an asymptote path"""
+ def __init__(self):
+ """Initialize the path to be an empty path: a path with no nodes, control points, or links."""
+ asyObj.__init__(self)
+ self.nodeSet = []
+ self.linkSet = []
+ self.controlSet = []
+ self.computed = False
+
+ def initFromNodeList(self,nodeSet,linkSet):
+ """Initialize the path from a set of nodes and link types, "--", "..", or "::" """
+ if len(nodeSet)>0:
+ self.nodeSet = nodeSet[:]
+ self.linkSet = linkSet[:]
+ self.computed = False
+
+ def initFromControls(self,nodeSet,controlSet):
+ """Initialize the path from nodes and control points"""
+ self.controlSet = controlSet[:]
+ self.nodeSet = nodeSet[:]
+ self.computed = True
+
+ def makeNodeStr(self,node):
+ """Represent a node as a string"""
+ if node == 'cycle':
+ return node
+ else:
+ return "("+str(node[0])+","+str(node[1])+")"
+
+ def updateCode(self,mag=1.0):
+ """Generate the code describing the path"""
+ if not self.computed:
+ count = 0
+ #this string concatenation could be optimised
+ self.asyCode = self.makeNodeStr(self.nodeSet[0])
+ for node in self.nodeSet[1:]:
+ self.asyCode += self.linkSet[count]+self.makeNodeStr(node)
+ count += 1
+ else:
+ count = 0
+ #this string concatenation could be optimised
+ self.asyCode = self.makeNodeStr(self.nodeSet[0])
+ for node in self.nodeSet[1:]:
+ self.asyCode += "..controls"
+ self.asyCode += self.makeNodeStr(self.controlSet[count][0])
+ self.asyCode += "and"
+ self.asyCode += self.makeNodeStr(self.controlSet[count][1])
+ self.asyCode += ".." + self.makeNodeStr(node) + "\n"
+ count += 1
+
+ def getNode(self,index):
+ """Return the requested node"""
+ return self.nodeSet[index]
+
+ def getLink(self,index):
+ """Return the requested link"""
+ return self.linkSet[index]
+
+ def setNode(self,index,newNode):
+ """Set a node to a new position"""
+ self.nodeSet[index] = newNode
+
+ def moveNode(self,index,offset):
+ """Translate a node"""
+ if self.nodeSet[index] != "cycle":
+ self.nodeSet[index] = (self.nodeSet[index][0]+offset[0],self.nodeSet[1]+offset[1])
+
+ def setLink(self,index,ltype):
+ """Change the specified link"""
+ self.linkSet[index] = ltype
+
+ def addNode(self,point,ltype):
+ """Add a node to the end of a path"""
+ self.nodeSet.append(point)
+ if len(self.nodeSet) != 1:
+ self.linkSet.append(ltype)
+ if self.computed:
+ self.computeControls()
+
+ def insertNode(self,index,point,ltype=".."):
+ """Insert a node, and its corresponding link, at the given index"""
+ self.nodeSet.insert(index,point)
+ self.linkSet.insert(index,ltype)
+ if self.computed:
+ self.computeControls()
+
+ def setControl(self,index,position):
+ """Set a control point to a new position"""
+ self.controlSet[index] = position
+
+ def moveControl(self,index,offset):
+ """Translate a control point"""
+ self.controlSet[index] = (self.controlSet[index][0]+offset[0],self.controlSet[index][1]+offset[1])
+
+ def computeControls(self):
+ """Evaluate the code of the path to obtain its control points"""
+ fout.write("file fout=output(mode='pipe');\n")
+ fout.write("path p="+self.getCode()+';\n')
+ fout.write("write(fout,length(p),newl);\n")
+ fout.write("write(fout,unstraighten(p),endl);\n")
+ fout.flush()
+ lengthStr = fin.readline()
+ pathSegments = eval(lengthStr.split()[-1])
+ pathStrLines = []
+ for i in range(pathSegments+1):
+ line=fin.readline()
+ line=line.replace("\n","")
+ pathStrLines.append(line)
+ oneLiner = "".join(split(join(pathStrLines)))
+ splitList = oneLiner.split("..")
+ nodes = [a for a in splitList if a.find("controls")==-1]
+ self.nodeSet = []
+ for a in nodes:
+ if a == 'cycle':
+ self.nodeSet.append(a)
+ else:
+ self.nodeSet.append(eval(a))
+ controls = [a.replace("controls","").split("and") for a in splitList if a.find("controls") != -1]
+ self.controlSet = [[eval(a[0]),eval(a[1])] for a in controls]
+ self.computed = True
+
+class asyLabel(asyObj):
+ """A python wrapper for an asy label"""
+ def __init__(self,text="",location=(0,0),pen=asyPen()):
+ """Initialize the label with the given test, location, and pen"""
+ asyObj.__init__(self)
+ self.text = text
+ self.location = location
+ self.pen = pen
+
+ def updateCode(self,mag=1.0):
+ """Generate the code describing the label"""
+ self.asyCode = "Label(\""+self.text+"\","+str((self.location[0],self.location[1]))+","+self.pen.getCode()+",align=SE)"
+
+ def setText(self,text):
+ """Set the label's text"""
+ self.text = text
+ self.updateCode()
+
+ def setPen(self,pen):
+ """Set the label's pen"""
+ self.pen = pen
+ self.updateCode()
+
+ def moveTo(self,newl):
+ """Translate the label's location"""
+ self.location = newl
+
+class asyImage:
+ """A structure containing an image and its format, bbox, and IDTag"""
+ def __init__(self,image,format,bbox):
+ self.image = image
+ self.format = format
+ self.bbox = bbox
+ self.IDTag = None
+
+class xasyItem:
+ """A base class for items in the xasy GUI"""
+ def __init__(self,canvas=None):
+ """Initialize the item to an empty item"""
+ self.transform = [identity()]
+ self.asyCode = ""
+ self.imageList = []
+ self.IDTag = None
+ self.asyfied = False
+ self.onCanvas = canvas
+
+ def updateCode(self,mag=1.0):
+ """Update the item's code: to be overriden"""
+ pass
+
+ def getCode(self):
+ """Return the code describing the item"""
+ self.updateCode()
+ return self.asyCode
+
+ def handleImageReception(self,file,format,bbox,count):
+ """Receive an image from an asy deconstruction. It replaces the default in asyProcess."""
+ image = Image.open(file)
+ self.imageList.append(asyImage(image,format,bbox))
+ if self.onCanvas != None:
+ self.imageList[-1].itk = ImageTk.PhotoImage(image)
+ self.imageList[-1].originalImage = image.copy()
+ self.imageList[-1].originalImage.theta = 0.0
+ self.imageList[-1].originalImage.bbox = bbox
+ if count >= len(self.transform) or self.transform[count].deleted == False:
+ self.imageList[-1].IDTag = self.onCanvas.create_image(bbox[0],-bbox[3],anchor=NW,tags=("image"),image=self.imageList[-1].itk)
+ self.onCanvas.update()
+
+ def asyfy(self,mag=1.0):
+ self.removeFromCanvas()
+ self.imageList = []
+ self.imageHandleQueue = Queue.Queue()
+ worker = threading.Thread(target=self.asyfyThread,args=(mag,))
+ worker.start()
+ item = self.imageHandleQueue.get()
+ if console != None:
+ console.delete(1.0,END)
+ while item != (None,) and item[0] != "ERROR":
+ if(item[0] == "OUTPUT"):
+ consoleOutput(item[1])
+ else:
+ self.handleImageReception(*item)
+ try:
+ os.remove(item[0])
+ except:
+ pass
+ item = self.imageHandleQueue.get()
+ #self.imageHandleQueue.task_done()
+ worker.join()
+
+ def asyfyThread(self,mag=1.0):
+ """Convert the item to a list of images by deconstructing this item's code"""
+ fout.write("reset;\n")
+ fout.write("initXasyMode();\n")
+ fout.write("atexit(null);\n")
+ global console
+ for line in self.getCode().splitlines():
+ fout.write(line+"\n");
+ fout.write("deconstruct(%f);\n"%mag)
+ fout.flush()
+ format = "png"
+ maxargs = int(split(fin.readline())[0])
+ boxes=[]
+ batch=0
+ n=0
+ text = fin.readline()
+ template=AsyTempDir+"%d_%d.%s"
+ def render():
+ for i in range(len(boxes)):
+ l,b,r,t = [float(a) for a in split(boxes[i])]
+ name=template%(batch,i+1,format)
+ self.imageHandleQueue.put((name,format,(l,b,r,t),i))
+ while text != "Done\n" and text != "Error\n":
+ boxes.append(text)
+ text = fin.readline()
+ n += 1
+ if n >= maxargs:
+ render()
+ boxes=[]
+ batch += 1
+ n=0
+ if text == "Error\n":
+ self.imageHandleQueue.put(("ERROR",fin.readline()))
+ else:
+ render()
+ self.imageHandleQueue.put((None,))
+ self.asyfied = True
+
+ def drawOnCanvas(self,canvas,mag,forceAddition=False):
+ pass
+ def removeFromCanvas(self):
+ pass
+
+class xasyDrawnItem(xasyItem):
+ """A base class for GUI items was drawn by the user. It combines a path, a pen, and a transform."""
+ def __init__(self,path,pen = asyPen(),transform = identity()):
+ """Initialize the item with a path, pen, and transform"""
+ xasyItem.__init__(self)
+ self.path = path
+ self.pen = pen
+ self.transform = [transform]
+
+ def appendPoint(self,point,link=None):
+ """Append a point to the path. If the path is cyclic, add this point before the 'cycle' node."""
+ if self.path.nodeSet[-1] == 'cycle':
+ self.path.nodeSet[-1] = point
+ self.path.nodeSet.append('cycle')
+ else:
+ self.path.nodeSet.append(point)
+ self.path.computed = False
+ if len(self.path.nodeSet) > 1 and link != None:
+ self.path.linkSet.append(link)
+
+ def clearTransform(self):
+ """Reset the item's transform"""
+ self.transform = [identity()]
+
+ def removeLastPoint(self):
+ """Remove the last point in the path. If the path is cyclic, remove the node before the 'cycle' node."""
+ if self.path.nodeSet[-1] == 'cycle':
+ del self.path.nodeSet[-2]
+ else:
+ del self.path.nodeSet[-1]
+ del self.path.linkSet[-1]
+ self.path.computed = False
+
+ def setLastPoint(self,point):
+ """Modify the last point in the path. If the path is cyclic, modify the node before the 'cycle' node."""
+ if self.path.nodeSet[-1] == 'cycle':
+ self.path.nodeSet[-2] = point
+ else:
+ self.path.nodeSet[-1] = point
+ self.path.computed = False
+
+class xasyShape(xasyDrawnItem):
+ """An outlined shape drawn on the GUI"""
+ def __init__(self,path,pen=asyPen(),transform=identity()):
+ """Initialize the shape with a path, pen, and transform"""
+ xasyDrawnItem.__init__(self,path,pen,transform)
+
+ def updateCode(self,mag=1.0):
+ """Generate the code to describe this shape"""
+ self.asyCode = "xformStack.push("+self.transform[0].getCode()+");\n"
+ self.asyCode += "draw("+self.path.getCode()+","+self.pen.getCode()+");"
+
+ def removeFromCanvas(self,canvas):
+ """Remove the shape's depiction from a tk canvas"""
+ if self.IDTag != None:
+ canvas.delete(self.IDTag)
+
+ def drawOnCanvas(self,canvas,mag,asyFy=False,forceAddition=False):
+ """Add this shape to a tk canvas"""
+ if not asyFy:
+ if self.IDTag == None or forceAddition:
+ #add ourselves to the canvas
+ self.path.computeControls()
+ self.IDTag = canvas.create_line(0,0,0,0,tags=("drawn","xasyShape"),fill=self.pen.tkColor(),width=self.pen.width*mag)
+ self.drawOnCanvas(canvas,mag)
+ else:
+ self.path.computeControls()
+ pointSet = []
+ previousNode = self.path.nodeSet[0]
+ nodeCount = 0
+ if len(self.path.nodeSet) == 0:
+ pointSet = [0,0,0,0]
+ elif len(self.path.nodeSet) == 1:
+ if self.path.nodeSet[-1] != 'cycle':
+ p = self.transform[0]*(self.path.nodeSet[0][0],self.path.nodeSet[0][1])
+ pointSet = [p[0],-p[1],p[0],-p[1],p[0],-p[1]]
+ else:
+ pointSet = [0,0,0,0]
+ else:
+ for node in self.path.nodeSet[1:]:
+ if node == 'cycle':
+ node = self.path.nodeSet[0]
+ transform = self.transform[0].scale(mag)
+ points = CubicBezier.makeBezier(transform*previousNode,transform*self.path.controlSet[nodeCount][0],transform*self.path.controlSet[nodeCount][1],transform*node)
+ for point in points:
+ pointSet += [point[0],-point[1]]
+ nodeCount += 1
+ previousNode = node
+ canvas.coords(self.IDTag,*pointSet)
+ canvas.itemconfigure(self.IDTag,fill=self.pen.tkColor(),width=self.pen.width*mag)
+ else:
+ #first asyfy then add an image list
+ pass
+
+ def __str__(self):
+ """Create a string describing this shape"""
+ return "xasyShape code:%s"%("\n\t".join(self.getCode().splitlines()))
+
+class xasyFilledShape(xasyShape):
+ """A filled shape drawn on the GUI"""
+ def __init__(self,path,pen=asyPen(),transform=identity()):
+ """Initialize this shape with a path, pen, and transform"""
+ if path.nodeSet[-1] != 'cycle':
+ raise Exception,"Filled paths must be cyclic"
+ xasyShape.__init__(self,path,pen,transform)
+
+ def updateCode(self,mag=1.0):
+ """Generate the code describing this shape"""
+ self.asyCode = "xformStack.push("+self.transform[0].getCode()+");\n"
+ self.asyCode += "fill("+self.path.getCode()+","+self.pen.getCode()+");"
+
+ def removeFromCanvas(self,canvas):
+ """Remove this shape's depiction from a tk canvas"""
+ if self.IDTag != None:
+ canvas.delete(self.IDTag)
+
+ def drawOnCanvas(self,canvas,mag,asyFy=False,forceAddition=False):
+ """Add this shape to a tk canvas"""
+ if not asyFy:
+ if self.IDTag == None or forceAddition:
+ #add ourselves to the canvas
+ self.path.computeControls()
+ self.IDTag = canvas.create_polygon(0,0,0,0,0,0,tags=("drawn","xasyFilledShape"),fill=self.pen.tkColor(),outline=self.pen.tkColor(),width=1*mag)
+ self.drawOnCanvas(canvas,mag)
+ else:
+ self.path.computeControls()
+ pointSet = []
+ previousNode = self.path.nodeSet[0]
+ nodeCount = 0
+ if len(self.path.nodeSet) == 0:
+ pointSet = [0,0,0,0,0,0]
+ elif len(self.path.nodeSet) == 1:
+ if self.path.nodeSet[-1] != 'cycle':
+ p = self.transform[0]*(self.path.nodeSet[0][0],self.path.nodeSet[0][1])
+ pointSet = [p[0],-p[1],p[0],-p[1],p[0],-p[1]]
+ else:
+ pointSet = [0,0,0,0,0,0]
+ elif len(self.path.nodeSet) == 2:
+ if self.path.nodeSet[-1] != 'cycle':
+ p = self.transform[0].scale(mag)*(self.path.nodeSet[0][0],self.path.nodeSet[0][1])
+ p2 = self.transform[0].scale(mag)*(self.path.nodeSet[1][0],self.path.nodeSet[1][1])
+ pointSet = [p[0],-p[1],p2[0],-p2[1],p[0],-p[1]]
+ else:
+ pointSet = [0,0,0,0,0,0]
+ else:
+ for node in self.path.nodeSet[1:]:
+ if node == 'cycle':
+ node = self.path.nodeSet[0]
+ transform = self.transform[0].scale(mag)
+ points = CubicBezier.makeBezier(transform*previousNode,transform*self.path.controlSet[nodeCount][0],transform*self.path.controlSet[nodeCount][1],transform*node)
+ for point in points:
+ pointSet += [point[0],-point[1]]
+ nodeCount += 1
+ previousNode = node
+ canvas.coords(self.IDTag,*pointSet)
+ canvas.itemconfigure(self.IDTag,fill=self.pen.tkColor(),outline=self.pen.tkColor(),width=1*mag)
+ else:
+ #first asyfy then add an image list
+ pass
+
+ def __str__(self):
+ """Return a string describing this shape"""
+ return "xasyFilledShape code:%s"%("\n\t".join(self.getCode().splitlines()))
+
+class xasyText(xasyItem):
+ """Text created by the GUI"""
+ def __init__(self,text,location,pen=asyPen(),transform=identity()):
+ """Initialize this item with text, a location, pen, and transform"""
+ xasyItem.__init__(self)
+ self.label=asyLabel(text,location,pen)
+ self.transform = [transform]
+ self.onCanvas = None
+
+ def updateCode(self,mag=1.0):
+ """Generate the code describing this object"""
+ self.asyCode = "xformStack.push("+self.transform[0].getCode()+");\n"
+ self.asyCode += "label("+self.label.getCode()+");"
+
+ def removeFromCanvas(self):
+ """Removes the label's images from a tk canvas"""
+ if self.onCanvas == None:
+ return
+ for image in self.imageList:
+ if image.IDTag != None:
+ self.onCanvas.delete(image.IDTag)
+
+ def drawOnCanvas(self,canvas,mag,asyFy=True,forceAddition=False):
+ """Adds the label's images to a tk canvas"""
+ if self.onCanvas == None:
+ self.onCanvas = canvas
+ elif self.onCanvas != canvas:
+ raise Exception,"Error: item cannot be added to more than one canvas"
+ self.asyfy(mag)
+
+ def __str__(self):
+ return "xasyText code:%s"%("\n\t".join(self.getCode().splitlines()))
+
+class xasyScript(xasyItem):
+ """A set of images create from asymptote code. It is always deconstructed."""
+ def __init__(self,canvas,script="",transforms=[]):
+ """Initialize this script item"""
+ xasyItem.__init__(self,canvas)
+ self.transform = transforms[:]
+ self.script = script
+
+ def clearTransform(self):
+ """Reset the transforms for each of the deconstructed images"""
+ self.transform = [identity() for im in self.imageList]
+
+ def updateCode(self,mag=1.0):
+ """Generate the code describing this script"""
+ self.asyCode = "";
+ if len(self.transform) > 0:
+ self.asyCode = "xformStack.add("
+ isFirst = True
+ count = 0
+ for xform in self.transform:
+ if not isFirst:
+ self.asyCode+=",\n"
+ self.asyCode += "indexedTransform(%d,%s)"%(count,str(xform))
+ isFirst = False
+ count += 1
+ self.asyCode += ");\n"
+ self.asyCode += "startScript(); {\n"
+ self.asyCode += self.script.replace("\t"," ")
+ self.asyCode = self.asyCode.rstrip()
+ self.asyCode += "\n} endScript();\n"
+
+ def setScript(self,script):
+ """Sets the content of the script item."""
+ self.script = script
+ self.updateCode()
+
+ def removeFromCanvas(self):
+ """Removes the script's images from a tk canvas"""
+ if self.onCanvas == None:
+ return
+ for image in self.imageList:
+ if image.IDTag != None:
+ self.onCanvas.delete(image.IDTag)
+
+ def asyfy(self,mag):
+ """Generate the list of images described by this object and adjust the length of the transform list."""
+ xasyItem.asyfy(self,mag)
+ while len(self.imageList) > len(self.transform):
+ self.transform.append(identity())
+ while len(self.imageList) < len(self.transform):
+ self.transform.pop()
+ self.updateCode()
+
+ def drawOnCanvas(self,canvas,mag,asyFy=True,forceAddition=False):
+ """Adds the script's images to a tk canvas"""
+ if self.onCanvas == None:
+ self.onCanvas = canvas
+ elif self.onCanvas != canvas:
+ raise Exception,"Error: item cannot be added to more than one canvas"
+ self.asyfy(mag)
+
+ def __str__(self):
+ """Return a string describing this script"""
+ retVal = "xasyScript\n\tTransforms:\n"
+ for xform in self.transform:
+ retVal += "\t"+str(xform)+"\n"
+ retVal += "\tCode Ommitted"
+ return retVal
+
+if __name__=='__main__':
+ root = Tk()
+ t=xasyText("test",(0,0))
+ t.asyfy()
diff --git a/Master/texmf-dist/asymptote/GUI/xasyActions.py b/Master/texmf-dist/asymptote/GUI/xasyActions.py
new file mode 100755
index 00000000000..38aae1d5c7e
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasyActions.py
@@ -0,0 +1,387 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# xasyActions implements the possible actions and their inverses
+# for the undo/redo stack in xasy
+#
+# Author: Orest Shardt
+# Created: July 23, 2007
+#
+###########################################################################
+import math
+import UndoRedoStack
+import xasy2asy
+from Tkinter import *
+
+class translationAction(UndoRedoStack.action):
+ def __init__(self,owner,itemList,indexList,translation):
+ self.translation = translation
+ self.owner = owner
+ self.itemList = itemList
+ self.indexList = indexList
+ UndoRedoStack.action.__init__(self,self.transF,self.unTransF)
+
+ def transF(self):
+ mag = self.owner.magnification
+ for i in range(len(self.itemList)):
+ for index in self.indexList[i]:
+ self.owner.translateSomething(-1,(self.translation[0]/mag,self.translation[1]/mag),self.itemList[i],index)
+ if index==None:
+ index = 0
+ try:
+ self.owner.mainCanvas.move(self.itemList[i].imageList[index].IDTag,self.translation[0]*mag,-self.translation[1]*mag)
+ except:
+ self.owner.mainCanvas.move(self.itemList[i].IDTag,self.translation[0]*mag,-self.translation[1]*mag)
+ self.owner.updateSelection()
+ self.owner.updateCanvasSize()
+
+ def unTransF(self):
+ mag = self.owner.magnification
+ for i in range(len(self.itemList)):
+ for index in self.indexList[i]:
+ self.owner.translateSomething(-1,(-self.translation[0]/mag,-self.translation[1]/mag),self.itemList[i],index)
+ try:
+ self.owner.mainCanvas.move(self.itemList[i].imageList[index].IDTag,-self.translation[0]*mag,self.translation[1]*mag)
+ except:
+ self.owner.mainCanvas.move(self.itemList[i].IDTag,-self.translation[0]*mag,self.translation[1]*mag)
+ self.owner.updateSelection()
+ self.owner.updateCanvasSize()
+
+ def __str__(self):
+ return "Translation of "+str(self.itemList)+str(self.indexList)+" by "+str(self.translation)
+
+class rotationAction(UndoRedoStack.action):
+ def __init__(self,owner,itemList,indexList,angle,origin):
+ self.owner = owner
+ self.itemList = itemList
+ self.indexList = indexList
+ self.angle = angle
+ self.origin = origin
+ UndoRedoStack.action.__init__(self,self.rotF,self.unRotF)
+
+ def rotF(self):
+ for i in range(len(self.itemList)):
+ for index in self.indexList[i]:
+ self.owner.rotateSomething(-1,self.angle,self.origin,self.itemList[i],index)
+ for item in self.itemList:
+ item.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.bindItemEvents(item)
+ self.owner.updateSelection()
+ self.owner.updateCanvasSize()
+
+ def unRotF(self):
+ for i in range(len(self.itemList)):
+ for index in self.indexList[i]:
+ self.owner.rotateSomething(-1,-self.angle,self.origin,self.itemList[i],index)
+ for item in self.itemList:
+ item.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.bindItemEvents(item)
+ self.owner.updateSelection()
+ self.owner.updateCanvasSize()
+
+ def __str__(self):
+ return "Rotation of "+str(self.itemList)+str(self.indexList)+" by "+"%.3f"%(self.angle*180.0/math.pi)+" about "+str(self.origin)
+
+class addLabelAction(UndoRedoStack.action):
+ def __init__(self,owner,label):
+ self.owner = owner
+ self.label = label
+ UndoRedoStack.action.__init__(self,self.addF,self.unAddF)
+
+ def addF(self):
+ self.owner.addItemToFile(self.label)
+ self.label.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.bindItemEvents(self.label)
+
+ def unAddF(self):
+ self.label.removeFromCanvas()
+ del self.owner.fileItems[-1]
+ self.owner.propList.delete(0)
+ self.owner.clearSelection()
+
+ def __str__(self):
+ return "Addition of a label"
+
+class deleteLabelAction(UndoRedoStack.action):
+ def __init__(self,owner,label,index):
+ self.owner = owner
+ self.label = label
+ self.index = index
+ UndoRedoStack.action.__init__(self,self.delF,self.unDelF)
+
+ def delF(self):
+ self.owner.fileItems[self.index].removeFromCanvas()
+ self.owner.propList.delete(len(self.owner.fileItems)-self.index-1)
+ del self.owner.fileItems[self.index]
+
+ def unDelF(self):
+ self.owner.fileItems.insert(self.index,self.label)
+ self.owner.fileItems[self.index].drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.propList.insert(len(self.owner.fileItems)-self.index-1,self.owner.describeItem(self.label))
+ self.owner.bindItemEvents(self.label)
+
+ def __str__(self):
+ return "Deletion of a label"
+
+class editLabelTextAction(UndoRedoStack.action):
+ def __init__(self,owner,label,newText,oldText):
+ self.owner = owner
+ self.label = label
+ self.newText = newText
+ self.oldText = oldText
+ UndoRedoStack.action.__init__(self,self.modT,self.unModT)
+
+ def modT(self):
+ self.label.label.setText(self.newText)
+ self.label.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.bindItemEvents(self.label)
+
+ def unModT(self):
+ self.label.label.setText(self.oldText)
+ self.label.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.bindItemEvents(self.label)
+
+ def __str__(self):
+ return "Editing a label's text"
+
+class editLabelPenAction(UndoRedoStack.action):
+ def __init__(self,owner,oldPen,newPen,index):
+ self.owner = owner
+ self.newPen = newPen
+ self.oldPen = oldPen
+ self.index = index
+ UndoRedoStack.action.__init__(self,self.editF,self.unEditF)
+
+ def editF(self):
+ self.owner.fileItems[self.index].removeFromCanvas()
+ self.owner.fileItems[self.index].label.pen = self.newPen
+ self.owner.fileItems[self.index].drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.bindItemEvents(self.owner.fileItems[self.index])
+
+ def unEditF(self):
+ self.owner.fileItems[self.index].removeFromCanvas()
+ self.owner.fileItems[self.index].label.pen = self.oldPen
+ self.owner.fileItems[self.index].drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.bindItemEvents(self.owner.fileItems[self.index])
+
+ def __str__(self):
+ return "Changing a label's pen"
+
+class addScriptAction(UndoRedoStack.action):
+ def __init__(self,owner,script):
+ self.owner = owner
+ self.script = script
+ UndoRedoStack.action.__init__(self,self.addF,self.unAddF)
+
+ def addF(self):
+ self.owner.addItemToFile(self.script)
+ self.script.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.bindItemEvents(self.script)
+
+ def unAddF(self):
+ self.script.removeFromCanvas()
+ del self.owner.fileItems[-1]
+ self.owner.propList.delete(0)
+ self.owner.clearSelection()
+
+ def __str__(self):
+ return "Addition of a script"
+
+class deleteScriptAction(UndoRedoStack.action):
+ def __init__(self,owner,script,index):
+ self.owner = owner
+ self.script = script
+ self.index = index
+ UndoRedoStack.action.__init__(self,self.delF,self.unDelF)
+
+ def delF(self):
+ self.owner.fileItems[self.index].removeFromCanvas()
+ self.owner.propList.delete(len(self.owner.fileItems)-self.index-1)
+ del self.owner.fileItems[self.index]
+
+ def unDelF(self):
+ self.owner.fileItems.insert(self.index,self.script)
+ self.owner.fileItems[self.index].drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.propList.insert(len(self.owner.fileItems)-self.index-1,self.owner.describeItem(self.script))
+ self.owner.bindItemEvents(self.script)
+
+ def __str__(self):
+ return "Deletion of a script"
+
+class deleteScriptItemAction(UndoRedoStack.action):
+ def __init__(self,owner,script,indices,oldTransforms):
+ self.owner = owner
+ self.script = script
+ self.indices = indices[:]
+ UndoRedoStack.action.__init__(self,self.delI,self.unDelI)
+ def delI(self):
+ for index in self.indices:
+ self.script.transform[index].deleted = True
+ self.owner.mainCanvas.delete(self.script.imageList[index].IDTag)
+
+ def unDelI(self):
+ for i in range(len(self.indices)):
+ index = self.indices[i]
+ self.script.transform[index].deleted = False
+ bbox = self.script.imageList[index].originalImage.bbox
+ self.script.imageList[index].IDTag = self.owner.mainCanvas.create_image(bbox[0],-bbox[3],anchor=NW,tags=("image"),image=self.script.imageList[index].itk)
+ self.owner.bindEvents(self.script.imageList[index].IDTag)
+ self.owner.resetStacking()
+
+ def __str__(self):
+ return "Deletion of item "+str(self.indices)+" in "+str(self.script)
+
+class editScriptAction(UndoRedoStack.action):
+ def __init__(self,owner,script,newText,oldText):
+ self.owner = owner
+ self.script = script
+ self.newText = newText
+ self.oldText = oldText
+ UndoRedoStack.action.__init__(self,self.modS,self.unModS)
+
+ def modS(self):
+ self.script.setScript(self.newText)
+ self.script.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.bindItemEvents(self.script)
+
+ def unModS(self):
+ self.script.setScript(self.oldText)
+ self.script.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+ self.owner.bindItemEvents(self.script)
+
+ def __str__(self):
+ return "Modification of a script"
+
+class clearItemTransformsAction(UndoRedoStack.action):
+ def __init__(self,owner,item,oldTransforms):
+ self.owner = owner
+ self.item = item
+ self.oldTransforms = oldTransforms
+ UndoRedoStack.action.__init__(self,self.clearF,self.unClearF)
+
+ def clearF(self):
+ for i in range(len(self.oldTransforms)):
+ self.item.transform[i] = xasy2asy.identity()
+ self.item.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+
+ def unClearF(self):
+ for i in range(len(self.oldTransforms)):
+ self.item.transform[i] = self.oldTransforms[i]
+ self.item.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification)
+
+ def __str__(self):
+ return "Clear the transforms of "+str(self.item)+" from "+str(self.oldTransforms)
+
+class itemRaiseAction(UndoRedoStack.action):
+ def __init__(self,owner,items,oldPositions):
+ self.owner = owner
+ self.items = items[:]
+ self.oldPositions = oldPositions[:]
+ UndoRedoStack.action.__init__(self,self.raiseI,self.unRaiseI)
+
+ def raiseI(self):
+ for item in self.items:
+ self.owner.raiseSomething(item)
+
+ def unRaiseI(self):
+ length = len(self.owner.fileItems)
+ indices = self.oldPositions[:]
+ indices = [length-i-1 for i in indices]
+ indices.reverse()
+ for index in indices:
+ for i in range(index):
+ self.owner.raiseSomething(self.owner.fileItems[length-index-1])
+
+ def __str__(self):
+ return "Raise items "+str(self.items)+" from positions "+str(self.oldPositions)
+
+class itemLowerAction(UndoRedoStack.action):
+ def __init__(self,owner,items,oldPositions):
+ self.owner = owner
+ self.items = items[:]
+ self.oldPositions = oldPositions[:]
+ UndoRedoStack.action.__init__(self,self.lowerI,self.unLowerI)
+
+ def lowerI(self):
+ for item in self.items:
+ self.owner.lowerSomething(item)
+
+ def unLowerI(self):
+ indices = self.oldPositions[:]
+ indices.reverse()
+ for index in indices:
+ for i in range(index):
+ self.owner.lowerSomething(self.owner.fileItems[index])
+
+ def __str__(self):
+ return "Lower items "+str(self.items)+" from positions "+str(self.oldPositions)
+
+class addDrawnItemAction(UndoRedoStack.action):
+ def __init__(self,owner,item):
+ self.owner = owner
+ self.item = item
+ UndoRedoStack.action.__init__(self,self.drawF,self.unDrawF)
+
+ def drawF(self):
+ self.owner.addItemToFile(self.item)
+ self.item.drawOnCanvas(self.owner.mainCanvas,self.owner.magnification,forceAddition=True)
+ self.owner.bindItemEvents(self.item)
+
+ def unDrawF(self):
+ self.item.removeFromCanvas(self.owner.mainCanvas)
+ del self.owner.fileItems[-1]
+ self.owner.propList.delete(0)
+ self.owner.clearSelection()
+
+ def __str__(self):
+ return "Drawing of an item"
+
+class deleteDrawnItemAction(UndoRedoStack.action):
+ def __init__(self,owner,item,index):
+ self.owner = owner
+ self.item = item
+ self.index = index
+ UndoRedoStack.action.__init__(self,self.delF,self.unDelF)
+
+ def delF(self):
+ self.owner.fileItems[self.index].removeFromCanvas(self.owner.mainCanvas)
+ self.owner.propList.delete(len(self.owner.fileItems)-self.index-1)
+ del self.owner.fileItems[self.index]
+
+ def unDelF(self):
+ self.owner.fileItems.insert(self.index,self.item)
+ self.owner.fileItems[self.index].drawOnCanvas(self.owner.mainCanvas,self.owner.magnification,forceAddition=True)
+ self.owner.propList.insert(len(self.owner.fileItems)-self.index-1,self.owner.describeItem(self.item))
+ self.owner.bindItemEvents(self.item)
+
+ def __str__(self):
+ return "Deletion of a drawn item"
+
+class editDrawnItemAction(UndoRedoStack.action):
+ def __init__(self,owner,oldItem,newItem,index):
+ self.owner = owner
+ self.oldItem = oldItem
+ self.newItem = newItem
+ self.index = index
+ UndoRedoStack.action.__init__(self,self.editF,self.unEditF)
+
+ def editF(self):
+ self.owner.fileItems[self.index].removeFromCanvas(self.owner.mainCanvas)
+ self.owner.fileItems[self.index].path = self.newItem.path
+ self.owner.fileItems[self.index].pen = self.newItem.pen
+ self.owner.fileItems[self.index].transform = self.newItem.transform
+ self.owner.fileItems[self.index].IDTag = self.newItem.IDTag
+ self.owner.fileItems[self.index].drawOnCanvas(self.owner.mainCanvas,self.owner.magnification,forceAddition=True)
+ self.owner.bindItemEvents(self.owner.fileItems[self.index])
+
+ def unEditF(self):
+ self.owner.fileItems[self.index].removeFromCanvas(self.owner.mainCanvas)
+ self.owner.fileItems[self.index].path = self.oldItem.path
+ self.owner.fileItems[self.index].pen = self.oldItem.pen
+ self.owner.fileItems[self.index].transform = self.oldItem.transform
+ self.owner.fileItems[self.index].IDTag = self.oldItem.IDTag
+ self.owner.fileItems[self.index].drawOnCanvas(self.owner.mainCanvas,self.owner.magnification,forceAddition=True)
+ self.owner.bindItemEvents(self.owner.fileItems[self.index])
+
+ def __str__(self):
+ return "Modification of a drawn item"
diff --git a/Master/texmf-dist/asymptote/GUI/xasyBezierEditor.py b/Master/texmf-dist/asymptote/GUI/xasyBezierEditor.py
new file mode 100755
index 00000000000..998ee4c7c25
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasyBezierEditor.py
@@ -0,0 +1,208 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# xasyBezierEditor implements the ability to graphically edit the location
+# of the nodes and control points of a bezier curve.
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+###########################################################################
+
+from Tkinter import *
+import math
+from CubicBezier import *
+import xasy2asy
+
+class node:
+ def __init__(self,precontrol,node,postcontrol,uid,isTied = True):
+ self.node = node
+ self.precontrol = precontrol
+ self.postcontrol = postcontrol
+ self.isTied = isTied
+ self.uid = uid
+ self.nodeID = self.precontrolID = self.prelineID = self.postcontrolID = self.postlineID = None
+
+ def shiftNode(self,delta):
+ self.node = (self.node[0]+delta[0],self.node[1]+delta[1])
+ if self.precontrol != None:
+ self.precontrol = (self.precontrol[0]+delta[0],self.precontrol[1]+delta[1])
+ if self.postcontrol != None:
+ self.postcontrol = (self.postcontrol[0]+delta[0],self.postcontrol[1]+delta[1])
+
+ def shiftPrecontrol(self,delta):
+ self.precontrol = (self.precontrol[0]+delta[0],self.precontrol[1]+delta[1])
+ if self.isTied and self.postcontrol != None:
+ self.rotatePostControl(self.precontrol)
+
+ def shiftPostcontrol(self,delta):
+ self.postcontrol = (self.postcontrol[0]+delta[0],self.postcontrol[1]+delta[1])
+ if self.isTied and self.precontrol != None:
+ self.rotatePrecontrol(self.postcontrol)
+
+ def rotatePrecontrol(self,after):
+ vx,vy = after[0]-self.node[0],after[1]-self.node[1]
+ l = norm((vx,vy))
+ if l == 0:
+ return
+ m = norm((self.precontrol[0]-self.node[0],self.precontrol[1]-self.node[1]))
+ vx = -m*vx/l
+ vy = -m*vy/l
+ self.precontrol = self.node[0]+vx,self.node[1]+vy
+
+ def rotatePostControl(self,after):
+ vx,vy = after[0]-self.node[0],after[1]-self.node[1]
+ l = norm((vx,vy))
+ if l == 0:
+ return
+ m = norm((self.postcontrol[0]-self.node[0],self.postcontrol[1]-self.node[1]))
+ vx = -m*vx/l
+ vy = -m*vy/l
+ self.postcontrol = self.node[0]+vx,self.node[1]+vy
+
+ def draw(self,canvas):
+ width = 3
+ if self.precontrol != None:
+ if self.prelineID == None:
+ self.prelineID = canvas.create_line(self.precontrol[0],-self.precontrol[1],self.node[0],-self.node[1],tags=("preline",self.uid))
+ else:
+ canvas.coords(self.prelineID,self.precontrol[0],-self.precontrol[1],self.node[0],-self.node[1])
+ if self.precontrolID == None:
+ self.precontrolID = canvas.create_oval(self.precontrol[0]-width,-self.precontrol[1]-width,self.precontrol[0]+width,-self.precontrol[1]+width,
+ fill="red",outline="black",tags=("precontrol",self.uid))
+ else:
+ canvas.coords(self.precontrolID,self.precontrol[0]-width,-self.precontrol[1]-width,self.precontrol[0]+width,-self.precontrol[1]+width)
+ if self.postcontrol != None:
+ if self.postlineID == None:
+ self.postlineID = canvas.create_line(self.postcontrol[0],-self.postcontrol[1],self.node[0],-self.node[1],tags=("postline",self.uid))
+ else:
+ canvas.coords(self.postlineID,self.postcontrol[0],-self.postcontrol[1],self.node[0],-self.node[1])
+ if self.postcontrolID == None:
+ self.postcontrolID = canvas.create_oval(self.postcontrol[0]-width,-self.postcontrol[1]-width,self.postcontrol[0]+width,-self.postcontrol[1]+width,
+ fill="red",outline="black",tags=("postcontrol",self.uid))
+ else:
+ canvas.coords(self.postcontrolID,self.postcontrol[0]-width,-self.postcontrol[1]-width,self.postcontrol[0]+width,-self.postcontrol[1]+width)
+ if self.isTied:
+ color = "blue"
+ else:
+ color = "green"
+ if self.nodeID == None:
+ self.nodeID = canvas.create_oval(self.node[0]-width,-self.node[1]-width,self.node[0]+width,-self.node[1]+width,
+ fill=color,outline="black",tags=("node",self.uid))
+ else:
+ canvas.coords(self.nodeID,self.node[0]-width,-self.node[1]-width,self.node[0]+width,-self.node[1]+width)
+ canvas.itemconfigure(self.nodeID,fill=color)
+
+class xasyBezierEditor:
+ def __init__(self,parent,shape,canvas):
+ self.parent = parent
+ self.shape = shape
+ self.transform = self.shape.transform[0]
+ self.path = self.shape.path
+ self.canvas = canvas
+ self.modified = False
+ self.path.computeControls()
+ isCyclic = self.path.nodeSet[-1] == 'cycle'
+ segments = len(self.path.controlSet)
+ self.nodeList = []
+ for i in range(segments):
+ if i == 0:
+ node0 = self.transform*self.path.nodeSet[i]
+ control = self.transform*self.path.controlSet[i][0]
+ self.nodeList.append(node(None,node0,control,len(self.nodeList)))
+ else:
+ node0 = self.transform*self.path.nodeSet[i]
+ precontrol = self.transform*self.path.controlSet[i-1][1]
+ postcontrol = self.transform*self.path.controlSet[i][0]
+ self.nodeList.append(node(precontrol,node0,postcontrol,len(self.nodeList)))
+ if not isCyclic:
+ node0 = self.transform*self.path.nodeSet[-1]
+ precontrol = self.transform*self.path.controlSet[-1][1]
+ self.nodeList.append(node(precontrol,node0,None,len(self.nodeList)))
+ else:
+ self.nodeList[0].precontrol = self.transform*self.path.controlSet[-1][1]
+ self.showControls()
+ self.bindNodeEvents()
+ self.bindControlEvents()
+
+ def showControls(self):
+ for n in self.nodeList:
+ n.draw(self.canvas)
+ self.bindNodeEvents()
+ self.bindControlEvents()
+ self.parent.updateCanvasSize()
+
+ def bindNodeEvents(self):
+ self.canvas.tag_bind("node","<B1-Motion>",self.nodeDrag)
+ self.canvas.tag_bind("node","<Button-1>",self.buttonDown)
+ self.canvas.tag_bind("node","<Double-Button-1>",self.toggleNode)
+
+ def unbindNodeEvents(self):
+ self.canvas.tag_unbind("node","<B1-Motion>")
+ self.canvas.tag_unbind("node","<Button-1>")
+ self.canvas.tag_unbind("node","<Double-Button-1>")
+
+ def bindControlEvents(self):
+ self.canvas.tag_bind("precontrol || postcontrol","<B1-Motion>",self.controlDrag)
+ self.canvas.tag_bind("precontrol || postcontrol","<Button-1>",self.buttonDown)
+
+ def unbindControlEvents(self):
+ self.canvas.tag_unbind("precontrol || postcontrol","<B1-Motion>")
+ self.canvas.tag_unbind("precontrol || postcontrol","<Button-1>")
+
+ def buttonDown(self,event):
+ self.parent.freeMouseDown = False
+ self.startx,self.starty = event.x,event.y
+
+ def toggleNode(self,event):
+ self.parent.freeMouseDown = False
+ tags = self.canvas.gettags(CURRENT)
+ obj = tags[0]
+ uid = int(tags[1])
+ self.nodeList[uid].isTied = not self.nodeList[uid].isTied
+ self.showControls()
+
+ def nodeDrag(self,event):
+ self.parent.freeMouseDown = False
+ deltax = event.x-self.startx
+ deltay = event.y-self.starty
+ tags = self.canvas.gettags(CURRENT)
+ obj = tags[0]
+ uid = int(tags[1])
+ self.nodeList[uid].shiftNode((deltax,-deltay))
+ self.startx,self.starty = event.x,event.y
+ self.applyChanges()
+ self.showControls()
+ self.shape.drawOnCanvas(self.canvas,self.parent.magnification)
+
+ def controlDrag(self,event):
+ self.parent.freeMouseDown = False
+ deltax = event.x-self.startx
+ deltay = event.y-self.starty
+ tags = self.canvas.gettags(CURRENT)
+ obj = tags[0]
+ uid = int(tags[1])
+ if obj == "precontrol":
+ self.nodeList[uid].shiftPrecontrol((deltax,-deltay))
+ elif obj == "postcontrol":
+ self.nodeList[uid].shiftPostcontrol((deltax,-deltay))
+ self.startx,self.starty = event.x,event.y
+ self.applyChanges()
+ self.showControls()
+ self.shape.drawOnCanvas(self.canvas,self.parent.magnification)
+
+ def applyChanges(self):
+ self.modified = True
+ self.shape.transform[0] = xasy2asy.asyTransform((0,0,1,0,0,1))
+ for i in range(len(self.nodeList)):
+ self.path.nodeSet[i] = self.nodeList[i].node
+ if self.nodeList[i].postcontrol != None:
+ self.path.controlSet[i][0] = self.nodeList[i].postcontrol
+ if self.nodeList[i].precontrol != None:
+ self.path.controlSet[i-1][1] = self.nodeList[i].precontrol
+
+ def endEdit(self):
+ self.unbindNodeEvents()
+ self.unbindControlEvents()
+ self.canvas.delete("node || precontrol || postcontrol || preline || postline")
diff --git a/Master/texmf-dist/asymptote/GUI/xasyCodeEditor.py b/Master/texmf-dist/asymptote/GUI/xasyCodeEditor.py
new file mode 100755
index 00000000000..93e06e447ee
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasyCodeEditor.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# xasyCodeEditor implements a simple text editor for Asymptote scripts in
+# xasy.
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+############################################################################
+
+from subprocess import call
+from tempfile import mkstemp
+from os import remove
+from os import fdopen
+from string import split
+import xasyOptions
+
+def getText(text=""):
+ """Launch the external editor"""
+ temp = mkstemp()
+ tempf = fdopen(temp[0],"r+w")
+ tempf.write(text)
+ tempf.flush()
+ try:
+ call(split(xasyOptions.options['externalEditor'])+[temp[1]])
+ except:
+ raise Exception('Error launching external editor.')
+ tempf.seek(0)
+ text = tempf.read()
+ remove(temp[1])
+ return text
+
+if __name__ == '__main__':
+ #run a test
+ print getText("Here is some text to edit")
diff --git a/Master/texmf-dist/asymptote/GUI/xasyColorPicker.py b/Master/texmf-dist/asymptote/GUI/xasyColorPicker.py
new file mode 100755
index 00000000000..7415be205c4
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasyColorPicker.py
@@ -0,0 +1,248 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# xasyColorPicker implements a dialog that allows a user to choose a color
+# from those already defined in Asymptote or a custom RGB color.
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+############################################################################
+
+from Tkinter import *
+import tkColorChooser
+asyColors = { "black":(0,0,0),
+ "white":(1,1,1),
+ "gray":(0.5,0.5,0.5),
+ "red":(1,0,0),
+ "green":(0,1,0),
+ "blue":(0,0,1),
+ "cmyk":(1,1,1),
+ "Cyan":(0,1,1),
+ "Magenta":(1,0,1),
+ "Yellow":(1,1,0),
+ "Black":(0,0,0),
+ "cyan":(0,1,1),
+ "magenta":(1,0,1),
+ "yellow":(1,1,0),
+ "palered":(1,0.75,0.75),
+ "palegreen":(0.75,1,0.75),
+ "paleblue":(0.75,0.75,1),
+ "palecyan":(0.75,1,1),
+ "palemagenta":(1,0.75,1),
+ "paleyellow":(1,1,0.75),
+ "palegray":(0.95,0.95,0.95),
+ "lightred":(1,0.5,0.5),
+ "lightgreen":(0.5,1,0.5),
+ "lightblue":(0.5,0.5,1),
+ "lightcyan":(0.5,1,1),
+ "lightmagenta":(1,0.5,1),
+ "lightyellow":(1,1,0.5),
+ "lightgray":(0.9,0.9,0.9),
+ "mediumred":(1,0.25,0.25),
+ "mediumgreen":(0.25,1,0.25),
+ "mediumblue":(0.25,0.25,1),
+ "mediumcyan":(0.25,1,1),
+ "mediummagenta":(1,0.25,1),
+ "mediumyellow":(1,1,0.25),
+ "mediumgray":(0.75,0.75,0.75),
+ "heavyred":(0.75,0,0),
+ "heavygreen":(0,0.75,0),
+ "heavyblue":(0,0,0.75),
+ "heavycyan":(0,0.75,0.75),
+ "heavymagenta":(0.75,0,0.75),
+ "lightolive":(0.75,0.75,0),
+ "heavygray":(0.25,0.25,0.25),
+ "deepred":(0.5,0,0),
+ "deepgreen":(0,0.5,0),
+ "deepblue":(0,0,0.5),
+ "deepcyan":(0,0.5,0.5),
+ "deepmagenta":(0.5,0,0.5),
+ "olive":(0.5,0.5,0),
+ "deepgray":(0.1,0.1,0.1),
+ "darkred":(0.25,0,0),
+ "darkgreen":(0,0.25,0),
+ "darkblue":(0,0,0.25),
+ "darkcyan":(0,0.25,0.25),
+ "darkmagenta":(0.25,0,0.25),
+ "darkolive":(0.25,0.25,0),
+ "darkgray":(0.05,0.05,0.05),
+ "orange":(1,0.5,0),
+ "fuchsia":(1,0,0.5),
+ "chartreuse":(0.5,1,0),
+ "springgreen":(0,1,0.5),
+ "purple":(0.5,0,1),
+ "royalblue":(0,0.5,1)
+ }
+colorLayout = [['palered',
+ 'lightred',
+ 'mediumred',
+ 'red',
+ 'heavyred',
+ 'deepred',
+ 'darkred',
+ 'palegreen',
+ 'lightgreen',
+ 'mediumgreen',
+ 'green',
+ 'heavygreen',
+ 'deepgreen',
+ 'darkgreen',
+ 'paleblue',
+ 'lightblue',
+ 'mediumblue',
+ 'blue',
+ 'heavyblue',
+ 'deepblue',
+ 'darkblue'],
+ ['palecyan',
+ 'lightcyan',
+ 'heavycyan',
+ 'deepcyan',
+ 'darkcyan',
+ 'palemagenta',
+ 'lightmagenta',
+ 'mediummagenta',
+ 'magenta',
+ 'heavymagenta',
+ 'deepmagenta',
+ 'darkmagenta',
+ 'yellow',
+ 'lightyellow',
+ 'mediumyellow',
+ 'yellow',
+ 'lightolive',
+ 'olive',
+ 'darkolive',
+ 'palegray',
+ 'lightgray',
+ 'mediumgray',
+ 'gray',
+ 'heavygray',
+ 'deepgray',
+ 'darkgray'],
+ ['black',
+ 'white',
+ 'orange',
+ 'fuchsia',
+ 'chartreuse',
+ 'springgreen',
+ 'purple',
+ 'royalblue',
+ 'Cyan',
+ 'Magenta',
+ 'Yellow',
+ 'Black']]
+
+def makeRGBfromTkColor(tkColor):
+ """Convert a Tk color of the form #rrggbb to an asy rgb color"""
+ r = int('0x'+tkColor[1:3],16)
+ g = int('0x'+tkColor[3:5],16)
+ b = int('0x'+tkColor[5:7],16)
+ r /= 255.0
+ g /= 255.0
+ b /= 255.0
+ return (r,g,b)
+
+def RGBreal255((r,g,b)):
+ """Convert an RGB color from 0-1 to 0-255"""
+ a,b,c = (256*r,256*g,256*b)
+ if a == 256:
+ a = 255
+ if b == 256:
+ b = 255
+ if c == 256:
+ c = 255
+ return map(int,(a,b,c))
+
+def RGB255hex((r,g,b)):
+ """Make a color in the form #rrggbb in hex from r,g,b in 0-255"""
+ rs,gs,bs = map(hex,(r,g,b))
+ rs,gs,bs = rs[2:],gs[2:],bs[2:]
+ if len(rs) < 2:
+ rs += '0'
+ if len(gs) < 2:
+ gs += '0'
+ if len(bs) < 2:
+ bs += '0'
+ return '#'+rs+gs+bs
+
+class xasyColorDlg(Toplevel):
+ """A dialog for choosing an asymptote color. It displays the usual asy presets and allows custom rgb colors"""
+ def __init__(self,master=None,color=(0,0,0)):
+ Toplevel.__init__(self,master,width=500,height=500)
+ self.resizable(False,False)
+ self.parent = master
+ self.title("Color Picker")
+ self.transient(master)
+ self.focus_set()
+ self.wait_visibility()
+ self.grab_set()
+ self.color = self.oldColor = color
+ cwidth = 120
+ rheight = 20
+ self.pframe=Frame(self,bd=0)
+ self.pframe.rowconfigure(0,weight=1)
+ self.pframe.columnconfigure(0,weight=1)
+ Label(self.pframe,text="Color Presets").grid(row=0,column=0)
+ self.colScroll = Scrollbar(self.pframe,orient=VERTICAL)
+ self.colorList = Canvas(self.pframe, width=cwidth*len(colorLayout), scrollregion=(0,0,20+cwidth*len(colorLayout),20+rheight*max([len(i) for i in colorLayout])),yscrollcommand=self.colScroll.set,relief=FLAT)
+ self.colScroll.config(command=self.colorList.yview)
+ self.colScroll.grid(row=1,column=1,sticky=N+S)
+ self.colorList.grid(row=1,column=0,sticky=W)
+ ccount = 0
+ for column in colorLayout:
+ rcount = 0
+ for name in column:
+ self.colorList.create_rectangle(10+cwidth*ccount,10+rheight*rcount,cwidth*ccount+25,rheight*rcount+25,tags=(name,"preset"),fill=RGB255hex(RGBreal255(asyColors[name])))
+ self.colorList.create_text(cwidth*ccount+30,10+rheight*rcount,text=name,anchor=NW,tags=(name,"preset"),fill="black",activefill=RGB255hex(RGBreal255(asyColors[name])))
+ rcount += 1
+ ccount += 1
+ self.colorList.tag_bind("preset","<Button-1>",self.setColorEvt)
+ Button(self,text="Custom color...",command=self.getCustom).grid(row=2,column=0,sticky=W,padx=5,pady=5)
+ self.colDisp = Canvas(self,width=200,height=20,background=RGB255hex(RGBreal255(self.color)),relief=SUNKEN, bd=3)
+ self.colDisp.grid(row=2,column=1,columnspan=2)
+ self.rowconfigure(3,minsize=10)
+ self.columnconfigure(0,weight=1)
+ self.columnconfigure(1,weight=1)
+ self.columnconfigure(2,weight=1)
+ Button(self,text="OK",default=ACTIVE,command=self.destroy).grid(row=4,column=1,sticky=E+W,padx=5,pady=5)
+ Button(self,text="Cancel",command=self.cancel).grid(row=4,column=2,sticky=E+W,padx=5,pady=5)
+ self.pframe.grid(row=1,column=0,columnspan=3,padx=10,pady=10)
+ self.bind("<Return>",self.closeUp)
+ self.setColor(color)
+ def closeUp(self,event):
+ """Close the dialog forcibly"""
+ self.destroy()
+ def getCustom(self):
+ """Request a custom RGB color using a tkColorChooser"""
+ result=tkColorChooser.askcolor(initialcolor=RGB255hex(RGBreal255(self.color)),title="Custom Color",parent=self)
+ if result != (None,None):
+ self.setColor((result[0][0]/255.0,result[0][1]/255.0,result[0][2]/255.0))
+ def cancel(self):
+ """Respond to the user pressing cancel"""
+ self.color = self.oldColor
+ self.destroy()
+ def setColor(self,color):
+ """Save the color and update the color display"""
+ self.color = color
+ self.colDisp.configure(background=RGB255hex(RGBreal255(self.color)))
+ def setColorEvt(self,event):
+ """Respond to the user clicking a color from the palette"""
+ self.setColor(asyColors[self.colorList.gettags(CURRENT)[0]])
+ def getColor(self,initialColor=(0,0,0)):
+ """Use this method to prompt for a color. It returns the new color or the old color if the user cancelled the operation.
+
+ e.g:
+ print xasyColorDlg(Tk()).getColor((1,1,0))
+ """
+ self.setColor(initialColor)
+ self.oldColor = initialColor
+ self.wait_window(self)
+ return self.color
+
+if __name__ == '__main__':
+ root = Tk()
+ Button(root,text="Pick Color",command=lambda:xasyColorDlg(root).getColor()).pack()
+ root.mainloop()
diff --git a/Master/texmf-dist/asymptote/GUI/xasyFile.py b/Master/texmf-dist/asymptote/GUI/xasyFile.py
new file mode 100755
index 00000000000..890f1ad3eef
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasyFile.py
@@ -0,0 +1,315 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# xasyFile implements the loading, parsing, and saving of an xasy file.
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+############################################################################
+
+from string import *
+from xasy2asy import *
+import re
+
+class xasyParseError(Exception):
+ """A parsing error"""
+ pass
+
+class xasyFileError(Exception):
+ """An i/o error or other error not related to parsing"""
+ pass
+
+def parseFile(inFile):
+ """Parse a file returning a list of xasyItems"""
+ lines = inFile.read()
+ lines = lines.splitlines()
+ #lines = [line for line in lines.splitlines() if not line.startswith("//")]
+ result = []
+ if lines[0] != "initXasyMode();":
+ raise xasyFileError,"Invalid file format: First line must be \"initXasyMode();\""
+ lines.pop(0)
+ lineCount = 2
+ lineNum = len(lines)
+ while lineNum > 0:
+ line = lines[0]
+ lines.pop(0)
+ if not line.isspace() and len(line)>0:
+ try:
+ #print "Line %d: %s"%(lineCount,line),
+ lineResult = parseLine(line.strip(),lines)
+ except:
+ raise xasyParseError,"Parsing error: line %d in %s\n%s"%(lineCount,inFile.name,line)
+
+ if lineResult != None:
+ result.append(lineResult)
+ #print "\tproduced: %s"%str(lineResult)
+ lineCount += lineNum-len(lines)
+ lineNum = len(lines)
+ return result
+
+transformPrefix = "xformStack"
+scriptPrefix = "startScript(); {"
+scriptSuffix = "} endScript();"
+def extractScript(lines):
+ """Find the code belonging to a script item"""
+ theScript = ""
+ line = lines.pop(0)
+ level = 1
+ while level > 0:
+ check = line.lstrip()
+ while check.endswith(scriptSuffix):
+ level -= 1
+ line = line[:len(line)-len(scriptSuffix)]
+ check = line.lstrip()
+ if check.startswith(scriptPrefix):
+ level += 1
+ theScript += line + "\n"
+ if level > 0:
+ line = lines.pop(0)
+
+ global pendingTransformsD
+ ts = pendingTransformsD[:]
+ pendingTransformsD = []
+ return xasyScript(None,script=theScript,transforms=ts[:])
+
+pendingTransforms = []
+pendingTransformsD = []
+def addTransform(index,t,active=1):
+ """Place a transform in the list of transforms, expanding the list as needed"""
+ while len(pendingTransformsD) < index+1:
+ pendingTransformsD.append(identity())
+ deleted = int(active==0)
+ pendingTransformsD[index]=asyTransform(t,deleted)
+
+def parseIndexedTransforms(args):
+ """Parse a list of indexedTransforms, adding them to the current list of transforms"""
+ global pendingTransformsD
+ pendingTransformsD = []
+ args = args.replace("indexedTransform","")
+ false = 0
+ tList = [eval(a) for a in ")?(".join(args.split("),(")).split("?")]
+ for a in tList:
+ addTransform(*a)
+
+def parseTransformExpression(line):
+ """Parse statements related to the xformStack
+
+ Syntax:
+ xformStack.push(transform)
+ e.g.: xformStack.push((0,0,1,0,0,1)); //the identity
+ xformStack.add(indexedTransform(index,transform)[,...])
+ e.g.: xformStack.add(indexedTransform(1,(0,0,1,0,0,1));
+ """
+ global pendingTransforms
+ stackCmd = line[len(transformPrefix)+1:line.find("(")]
+ if line[-2:] != ");":
+ raise xasyParseError,"Invalid syntax"
+ args = line[line.find("(")+1:-2]
+ if stackCmd == "push":
+ t = asyTransform(eval(args))
+ pendingTransforms.append(t)
+ elif stackCmd == "add":
+ parseIndexedTransforms(args)
+ else:
+ raise xasyParseError,"Invalid transform stack command."
+ return None
+
+def parseLabel(line):
+ """Parse an asy Label statement, returning an xasyText item"""
+ if not (line.startswith("Label(") and line.endswith(",align=SE)")):
+ raise xasyParseError,"Invalid syntax"
+ args = line[6:-1]
+ loc2 = args.rfind(",align=SE")
+ loc1 = args.rfind(",",0,loc2-1)
+ loc = args.rfind(",(",0,loc1-1)
+ if loc < 2:
+ raise xasyParseError,"Invalid syntax"
+ text = args[1:loc-1]
+ location = eval(args[loc+1:args.find("),",loc)+1])
+ pen = args[loc:loc2]
+ pen = pen[pen.find(",")+1:]
+ pen = pen[pen.find(",")+1:]
+ pen = pen[pen.find(",")+1:]
+ global pendingTransforms
+ return xasyText(text,location,parsePen(pen),pendingTransforms.pop())
+
+def parseLabelCommand(line):
+ """Parse a label command returning an xasyText object
+
+ Syntax:
+ label(Label(text,location,pen,align=SE));
+ e.g.: label(Label("Hello world!",(0,0),rgb(0,0,0)+0.5,align=SE));
+ """
+ if line[-2:] != ");":
+ raise xasyParseError,"Invalid syntax"
+ arguments = line[6:-2]
+ return parseLabel(arguments)
+
+def parseDrawCommand(line):
+ """Parse a draw command returning an xasyShape object
+
+ Syntax:
+ draw(path,pen);
+ e.g.: draw((0,0)..controls(0.33,0.33)and(0.66,0.66)..(1,1),rgb(1,0,1)+1.5);
+ """
+ if line[-2:] != ");":
+ raise xasyParseError,"Invalid syntax"
+ args = line[5:-2]
+ loc = args.rfind(",rgb")
+ path = args[:loc]
+ pen = args[loc+1:]
+ global pendingTransforms
+ return xasyShape(parsePathExpression(path),parsePen(pen),pendingTransforms.pop())
+
+def parseFillCommand(line):
+ """Parse a fill command returning an xasyFilledShape object
+
+ Syntax:
+ fill(cyclic path,pen);
+ e.g.: fill((0,0)..controls(0.33,0.33)and(0.66,0.66)..(1,1)..controls(0.66,0)and(0.33,0)..cycle,rgb(1,0,1)+1.5);
+ """
+ if line[-2:] != ");":
+ raise xasyParseError,"Invalid syntax"
+ args = line[5:-2]
+ loc = args.rfind(",rgb")
+ path = args[:loc]
+ pen = args[loc+1:]
+ global pendingTransforms
+ return xasyFilledShape(parsePathExpression(path),parsePen(pen),pendingTransforms.pop())
+
+def parsePen(pen):
+ """Parse a pen expression returning an asyPen
+
+ Syntax:
+ color+width[+options]
+ e.g.: rgb(0,0,0)+1.5+evenodd
+ e.g.: rgb(0,1,0)+1.23
+ """
+ try:
+ tokens = pen.split("+")
+ color = eval(tokens[0][3:])
+ width = float(tokens[1])
+ if len(tokens)>2:
+ options = "+".join(tokens[2:])
+ else:
+ options = ""
+ return asyPen(color,width,options)
+ except:
+ raise xasyParseError,"Invalid pen"
+
+def parsePathExpression(expr):
+ """Parse an asy path returning an asyPath()"""
+ result = asyPath()
+ expr = "".join(expr.split())
+ #print expr
+ if expr.find("controls") != -1:
+ #parse a path with control points
+ tokens = expr.split("..")
+ nodes = [a for a in tokens if not a.startswith("controls")]
+ for a in range(len(nodes)):
+ if nodes[a] != "cycle":
+ nodes[a] = eval(nodes[a])
+ controls = [map(eval,a.replace("controls","").split("and")) for a in tokens if a.startswith("controls")]
+ result.initFromControls(nodes, controls)
+ else:
+ #parse a path without control points
+ tokens = re.split(r"(::|--|\.\.)",expr)
+ linkSet = re.findall("::|--|\.\.",expr)
+ nodeSet = [a for a in tokens if not re.match(r"::|--|\.\.",a)]
+ #print nodeSet
+ for a in range(len(nodeSet)):
+ if nodeSet[a] != "cycle":
+ nodeSet[a] = eval(nodeSet[a])
+ #print nodeSet
+ result.initFromNodeList(nodeSet, linkSet)
+ return result
+
+def takeUntilSemicolon(line,lines):
+ """Read and concatenate lines until the collected lines end with a semicolon"""
+ data = line
+ while not data.endswith(";"):
+ newline = lines.pop(0)
+ data += newline
+ return data
+
+def parseLine(line,lines):
+ """Parse a line of the file"""
+ if len(line)==0 or line.isspace() or line.startswith("//"):
+ return None
+ elif line.startswith(scriptPrefix):
+ return extractScript(lines)
+ elif line.startswith(transformPrefix):
+ return parseTransformExpression(takeUntilSemicolon(line,lines))
+ elif line.startswith("label("):
+ return parseLabelCommand(takeUntilSemicolon(line,lines))
+ elif line.startswith("draw("):
+ return parseDrawCommand(takeUntilSemicolon(line,lines))
+ elif line.startswith("fill("):
+ return parseFillCommand(takeUntilSemicolon(line,lines))
+ elif line.startswith("exitXasyMode();"):
+ return None
+ raise Exception,"Could not parse the line"
+
+fileHeader = """initXasyMode();
+// This file was generated by xasy. It may be edited manually, however, a strict
+// syntax must be followed. It is advised that manually scripted items be added
+// in the form of a script either by using xasy or by mimicking the format of an
+// xasy-generated script item.
+// Please consult the documentation or the examples provided for details.
+"""
+
+fileFooter = """// This is the end of the file
+exitXasyMode();
+
+"""
+
+def saveFile(file,xasyItems):
+ """Write a list of xasyItems to a file"""
+ file.write(fileHeader)
+ for item in xasyItems:
+ file.write(item.getCode()+"\n\n")
+ file.write(fileFooter)
+
+if __name__ == '__main__':
+ root = Tk()
+ try:
+ name = raw_input("enter file name (\"../../xasyTest.asy\"):")
+ if name == '':
+ name = "../../xasyTest.asy"
+ f = open(name,"rt")
+ except:
+ print "Could not open file."
+ asy.quit()
+ sys.exit(1)
+
+ fileItems = []
+ try:
+ fileItems = parseFile(f)
+ res = map(str,fileItems)
+ print "----------------------------------"
+ print "Objects in %s"%f.name
+ print "----------------------------------"
+ for a in res:
+ print a
+ print "----------------------------------"
+ print "successful parse"
+ f.close()
+ except:
+ f.close()
+ print "parse failed"
+ raise
+
+ print "making a file"
+ f = open("testfile.asy","wt")
+ saveFile(f,fileItems)
+ f.close()
+ root.configure(width=500,height=500)
+ root.title("Results")
+ canv = Canvas(root,width=500,height=500)
+ canv.pack()
+ for i in fileItems[1].imageList:
+ canv.create_image(250+i.bbox[0],250-i.bbox[3],anchor = NW, image=i.image)
+ Button(root,image=i.image).pack(side=LEFT)
+ root.mainloop()
diff --git a/Master/texmf-dist/asymptote/GUI/xasyGUIIcons.py b/Master/texmf-dist/asymptote/GUI/xasyGUIIcons.py
new file mode 100755
index 00000000000..3afecfd349c
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasyGUIIcons.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+##################################################################
+# This file stores the icons used by the xasy GUI
+#
+# About images and base64
+#
+# Suppose you have image.gif and want to create a base64
+# string. This can be accomplished using:
+#
+# import base64
+# base64.encodestring(open("image.gif","rb").read())
+#
+# The resulting output, including the enclosing single quotes,
+# is the base64 encoding of the image and can be used in the
+# dictionary below.
+#
+#
+# Suppose you have a base64 string, b64str, and want to create
+# an image. This can be accomplished using:
+#
+# import base64
+# open("image.gif","w").write(base64.decodestring(b64str))
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+##################################################################
+import base64
+import os
+#toolbar icon image data in base64 eliminates need to worry about files
+#these are the base64 encodings of the content of the directory xasy3Imgs
+iconB64 = {
+'lower': 'R0lGODlhGAAYAPEBAAAAAP///8zMzAAAACH5BAEAAAIALAAAAAAYABgAAAItlI+py+0Po5yUgosz\nrrybK2giqADed6LHKCZm+p7xx2Zuqsqr95KcJpv9cJUCADs=\n',
+'rotate': 'R0lGODlhGAAYAPAAAAAAAAAAACH5BAEAAAEALAAAAAAYABgAAAI7jI8JkO231mux1mkistL1zX0Q\ng2Fi6aGmurKp+8KKrJB0Zt+nzOQw6XPZgqjczuQ7eohKEDKoUYWIgQIAOw==\n',
+'raise': 'R0lGODlhGAAYAPEBAAAAAP///8zMzAAAACH5BAEAAAIALAAAAAAYABgAAAIwlI+pywgND3ixzVvZ\nNDSn3nlKKH7fhaZmObKtk8Yh6dKlLcfC5vZ1jvIJh8SikVUAADs=\n',
+'fillPoly': 'R0lGODlhGAAYAPEAAAAAAIOBgwAAAAAAACH5BAEAAAIALAAAAAAYABgAAAJGlI+py+0PEYgNBDCp\nDPxqY3UcRoViRzrmKWbLyqIMHI9vHbsbfuoHjfOBcrlbT0ATIo+gldKpMD1lL8vUo5oqS9vS5wsp\nAAA7\n',
+'move': 'R0lGODlhGAAYAIABAAAAAP///yH5BAEAAAEALAAAAAAYABgAAAI4jI+py+0I3gNUNhqtwlVD7m3h\nkoVdUJ4MaKTYysVymbDoYcM4Tmv9eAO2cp6YEKUavY5BpvMZKgAAOw==\n',
+'drawBezi': 'R0lGODlhGAAYAPEBAAAAAP///6usrQAAACH5BAEAAAIALAAAAAAYABgAAAI6lI+py+0AnYRUKhox\nsFvUFDXdM4LWUaKnEaorhqSX1noPmMquWJukzpr0YitRcfE5oobFpPIJjUoZBQA7\n',
+'vertiMove': 'R0lGODlhGAAYAIABAAAAAP///yH5BAEAAAEALAAAAAAYABgAAAIsjI+py+0I3gNUNhqtwlVD7m3h\nko2QmZRooKKt+Y5xOFtc7dwrtrLd3gsKTQUAOw==\n',
+'horizMove': 'R0lGODlhGAAYAIABAAAAAP///yH5BAEAAAEALAAAAAAYABgAAAIljI+py+0Po5y02oshAGu/7Skg\n143mSYpgGTYt8mbyTNf2jedWAQA7\n',
+'fillEllip': 'R0lGODlhGAAYAPECAAAAAIOBg////6usrSH5BAEAAAMALAAAAAAYABgAAAJAnI+py+0PowS0gkmD\n3qE6wIXctYDi2SkmepLGyrYHHIcuXW93Lr+86BrgakHfrzjjIRGVFgVjWUqm1Kr1ijUUAAA7\n',
+'text': 'R0lGODlhGAAYAIABAAAAAP///yH5BAEAAAEALAAAAAAYABgAAAI+jI+py+0Po5x0AgSu1SZvHnhS\nBnpio5Ukt2Idm3bysYrnddLwy+czH0rhFDkbTigj6UzKl68CjUqn1Ko1UAAAOw==\n',
+'drawPoly': 'R0lGODlhGAAYAPAAAAAAAAAAACH5BAEAAAEALAAAAAAYABgAAAI4jI+py+0PEYhtgkmlzgFL/4DJ\nFULiVi4ns66smrUxrMj1fdqHR+60kfPdgCwLzbWTIU1LE+cJKQAAOw==\n',
+'drawLines': 'R0lGODlhGAAYAPEBAAAAAP///6usrQAAACH5BAEAAAIALAAAAAAYABgAAAI3lI+py+0AnYRAPmoZ\njvlwX3Vh8j2XUIIWNXoZS3ZoO8soSK+4fRuYnQPyFEHhcHecFV+ppDNRAAA7\n',
+'drawShape': 'R0lGODlhGAAYAPAAAAAAAAAAACH5BAEAAAEALAAAAAAYABgAAAI5jI+pywffIjQzIrCwdXnTplmh\nMoKmKIHVeZXp5cFcPH+0HbjbqKN17OoxgrTeKiOkPHjH3fIGjS4KADs=\n',
+'drawEllip': 'R0lGODlhGAAYAPEBAAAAAP///6usrQAAACH5BAEAAAIALAAAAAAYABgAAAIylI+py+0PowS0gklX\ndRd29XmgdIQh+Z1TSSJpyxpqZMLqzOB4sgsbmKFZgrCi8YhMNgoAOw==\n',
+'select': 'R0lGODlhGAAYAPIDAAAAAICAgMDAwP///6usrQAAAAAAAAAAACH5BAEAAAQALAAAAAAYABgAAANH\nSLrc/mvA6YCkGIiLIQhb54Gh2HwkZxKo4KoiSpam7L6rfdNZ4M+C3I+0Ush8wSLKCFIyPsnisyld\nAD7VabR6DWSt37BYmgAAOw==\n',
+'fillShape': 'R0lGODlhGAAYAPEAAAAAAIOBgwAAAAAAACH5BAEAAAIALAAAAAAYABgAAAJHlI+pywff4gsUxgSo\nrhflzXXCB4YXWQIiCqpnubnLw8KyU8Omket77wvcgD4ZUTcMIj3KlOLYejY1N8/R0qChaCIrtgsO\nRwoAOw==\n',
+'asy': 'R0lGODlhGAAYAIABAP8AAAAAACH5BAEKAAEALAIAAwAUABIAAAImjI+py+0AHINy0ZouNjBurmGd\nt40fFT4j2aydGqaBq8jvxH46UwAAOw==\n'
+}
+
+def createGIF(key):
+ """Create a gif file from the data in the iconB64 list of icons"""
+ if key not in iconB64.keys():
+ print "Error: %s not found in icon list."%key
+ print "Available icons:",iconB64.keys()
+ else:
+ print "Generating %s.gif"%key
+ open("%s.gif"%key,"w").write(base64.decodestring(iconB64[key]))
+
+def createGIFs():
+ """Create the files for all the icons in iconB64"""
+ for name in iconB64.keys():
+ createGIF(name)
+
+def createStrFromGif(gifFile):
+ """Create the base64 representation of a file"""
+ return base64.encodestring(gifFile.read())
+
+if __name__=='__main__':
+ print "Testing the xasyGUIIcons module."
+ print "Generating all the GIFs:"
+ createGIFs()
+ print "Checking consistency of all icons in iconB64"
+ allpassed = True
+ for icon in iconB64.keys():
+ print ("Checking %s"%icon),
+ if createStrFromGif(open("%s.gif"%icon,"rb")) == iconB64[icon]:
+ print "\tPassed."
+ else:
+ print "\tFailed."
+ allpassed= False
+ if allpassed:
+ print "All files succeeded."
+ s = raw_input("Delete generated files? (y/n)")
+ if s == "y":
+ for name in iconB64.keys():
+ print "Deleting %s.gif"%name,
+ os.unlink(name+".gif")
+ print "\tdone"
+ print "Done"
diff --git a/Master/texmf-dist/asymptote/GUI/xasyMainWin.py b/Master/texmf-dist/asymptote/GUI/xasyMainWin.py
new file mode 100755
index 00000000000..0967107ac1a
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasyMainWin.py
@@ -0,0 +1,1741 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# xasyMainWin implements the functionality of the GUI. It depends on
+# xasy2asy for its interaction with Asymptote.
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+###########################################################################
+
+import os
+from string import *
+import subprocess
+import math
+import copy
+
+from Tkinter import *
+import tkMessageBox
+import tkFileDialog
+import tkSimpleDialog
+import threading
+import time
+
+from xasyVersion import xasyVersion
+import xasyCodeEditor
+from xasy2asy import *
+import xasyFile
+import xasyOptions
+import xasyOptionsDialog
+import CubicBezier
+from xasyBezierEditor import xasyBezierEditor
+from xasyGUIIcons import iconB64
+from xasyColorPicker import *
+
+from UndoRedoStack import *
+from xasyActions import *
+
+import string
+
+try:
+ import ImageTk
+ import Image
+ PILAvailable = True
+except:
+ PILAvailable = False
+
+class xasyMainWin:
+ def __init__(self,master,file=None,magnification=1.0):
+ self.opLock = threading.Lock()
+ self.parent = master
+ self.magnification = magnification
+ self.previousZoom = self.magnification
+ self.magList = [0.1,0.25,1.0/3,0.5,1,2,3,4,5,10]
+ self.bindGlobalEvents()
+ self.createWidgets()
+ self.resetGUI()
+ if sys.platform[:3] == "win":
+ site="http://effbot.org/downloads/PIL-1.1.7.win32-py2.7.exe"
+ else:
+ site="http://effbot.org/downloads/Imaging-1.1.7.tar.gz"
+ if not PILAvailable:
+ tkMessageBox.showerror("Failed Dependencies","An error occurred loading the required PIL library. Please install "+site)
+ self.parent.destroy()
+ sys.exit(1)
+ if file != None:
+ self.loadFile(file)
+ self.parent.after(100,self.tickHandler)
+
+ def testOrAcquireLock(self):
+ val = self.opLock.acquire(False)
+ if val:
+ self.closeDisplayLock()
+ return val
+
+ def acquireLock(self):
+ self.closeDisplayLock()
+ self.opLock.acquire()
+
+ def releaseLock(self):
+ self.opLock.release()
+ self.openDisplayLock()
+
+ def tickHandler(self):
+ self.tickCount += 1
+ self.mainCanvas.itemconfigure("outlineBox",dashoffset=self.tickCount%9)
+ self.parent.after(100,self.tickHandler)
+
+ def closeDisplayLock(self):
+ self.status.config(text="Busy")
+ self.parent.update_idletasks()
+
+ def openDisplayLock(self):
+ self.status.config(text="Ready")
+
+ def bindGlobalEvents(self):
+ #global bindings
+ self.parent.bind_all("<Control-z>",lambda q:self.editUndoCmd())# z -> no shift
+ self.parent.bind_all("<Control-Z>",lambda q:self.editRedoCmd())# Z -> with shift
+ self.parent.bind_all("<Control-o>",lambda q:self.fileOpenCmd())
+ self.parent.bind_all("<Control-n>",lambda q:self.fileNewCmd())
+ self.parent.bind_all("<Control-s>",lambda q:self.fileSaveCmd())
+ self.parent.bind_all("<Control-q>",lambda q:self.fileExitCmd())
+ self.parent.bind_all("<F1>",lambda q:self.helpHelpCmd())
+
+ def unbindGlobalEvents(self):
+ #global bindings
+ self.parent.unbind("<Control-z>")
+ self.parent.unbind("<Control-Z>")
+ self.parent.unbind("<Control-o>")
+ self.parent.unbind("<Control-n>")
+ self.parent.unbind("<Control-s>")
+ self.parent.unbind("<Control-q>")
+ self.parent.unbind("<F1>")
+
+ def createWidgets(self):
+ #first some configuration
+ self.parent.geometry("800x600")
+ self.parent.title("Xasy")
+ self.parent.resizable(True,True)
+
+ #try to capture the closing of the window
+ #find a better way to do this since the widgets may
+ #already be destroyed when this is called
+ self.parent.protocol("WM_DELETE_WINDOW",self.canQuit)
+
+ #the main menu
+ self.mainMenu = Menu(self.parent)
+ self.parent.config(menu=self.mainMenu)
+
+ #the file menu
+ self.fileMenu = Menu(self.mainMenu,tearoff=0)
+ self.fileMenu.add_command(label="New",command=self.fileNewCmd,accelerator="Ctrl+N",underline=0)
+ self.fileMenu.add_command(label="Open",command=self.fileOpenCmd,accelerator="Ctrl+O",underline=0)
+ self.fileMenu.add_separator()
+ self.fileMenu.add_command(label="Save",command=self.fileSaveCmd,accelerator="Ctrl+S",underline=0)
+ self.fileMenu.add_command(label="Save As",command=self.fileSaveAsCmd,underline=5)
+ self.fileMenu.add_separator()
+
+ #an export menu
+ self.exportMenu = Menu(self.fileMenu,tearoff=0)
+ self.exportMenu.add_command(label="EPS...",command=self.exportEPS,underline=0)
+ self.exportMenu.add_command(label="PDF...",command=self.exportPDF,underline=0)
+ self.exportMenu.add_command(label="GIF...",command=self.exportGIF,underline=0)
+ self.exportMenu.add_command(label="PNG...",command=self.exportPNG,underline=1)
+ self.exportMenu.add_command(label="SVG...",command=self.exportSVG,underline=0)
+ self.fileMenu.add_cascade(label="Export",menu=self.exportMenu,underline=1)
+ self.fileMenu.add_separator()
+
+ self.fileMenu.add_command(label="Quit",command=self.fileExitCmd,accelerator="Ctrl+Q",underline=0)
+
+ self.mainMenu.add_cascade(label="File",menu=self.fileMenu,underline=0)
+
+ #the edit menu
+ self.editMenu = Menu(self.mainMenu,tearoff=0)
+ self.editMenu.add_command(label="Undo",command=self.editUndoCmd,accelerator="Ctrl+Z",underline=0)
+ self.editMenu.add_command(label="Redo",command=self.editRedoCmd,accelerator="Shift+Ctrl+Z",underline=0)
+ self.mainMenu.add_cascade(label="Edit",menu=self.editMenu,underline=0)
+
+ #the tools menu
+ self.toolsMenu = Menu(self.mainMenu,tearoff=0)
+ self.mainMenu.add_cascade(label="Tools",menu=self.toolsMenu,underline=0)
+
+ #the options menu
+ self.optionsMenu = Menu(self.toolsMenu,tearoff=0)
+ self.toolsMenu.add_cascade(label="Options",menu=self.optionsMenu,underline=0)
+ self.optionsMenu.add_command(label="Edit...",command=self.editOptions,underline=0)
+ self.optionsMenu.add_command(label="Reset defaults",command=self.resetOptions,underline=6)
+
+ #the help menu
+ self.helpMenu = Menu(self.mainMenu,tearoff=0)
+ self.helpMenu.add_command(label="Help",command=self.helpHelpCmd,state=DISABLED,accelerator="F1",underline=0)
+ self.helpMenu.add_command(label="Asymptote Documentation",command=self.helpAsyDocCmd,underline=10)
+ self.helpMenu.add_separator()
+ self.helpMenu.add_command(label="About xasy",command=self.helpAboutCmd,underline=0)
+ self.mainMenu.add_cascade(label="Help",menu=self.helpMenu,underline=0)
+
+ #status bar
+ self.statusBar = Frame(self.parent,relief=FLAT)
+
+ self.magVal = DoubleVar()
+ self.magVal.set(round(100*self.magnification,1))
+ self.magVal.trace('w',self.zoomViewCmd)
+ zoomList = self.magList
+ if self.magnification not in zoomList:
+ zoomList.append(self.magnification)
+ zoomList.sort()
+ zoomList = [round(100*i,1) for i in zoomList]
+ self.zoomMenu = OptionMenu(self.statusBar,self.magVal,*zoomList)
+ self.zoomMenu.pack(side=RIGHT)
+ Label(self.statusBar,text="Zoom:",anchor=E,width=7).pack(side=RIGHT)
+
+ self.coords = Label(self.statusBar,text="(0,0)",relief=SUNKEN,anchor=W)
+ self.coords.pack(side=RIGHT,anchor=S)
+ self.status = Label(self.statusBar,text="Ready",relief=SUNKEN,anchor=W)
+ self.status.pack(side=RIGHT,fill=X,expand=1,anchor=SW)
+ self.statusBar.pack(side=BOTTOM,fill=X)
+
+ #toolbar for transformation, drawing, and adjustment commands
+ self.toolBar = Frame(self.parent,relief=FLAT,borderwidth=3)
+
+ #let's load some images
+ self.toolIcons = {}
+ for x in iconB64.keys():
+ self.toolIcons[x] = PhotoImage(data=iconB64[x])
+
+ self.transformLbl = Label(self.toolBar,text="",anchor=W)
+ self.transformLbl.grid(row=0,column=0,columnspan=2,sticky=W)
+ self.toolSelectButton = Button(self.toolBar,command=self.toolSelectCmd,image=self.toolIcons["select"])
+ self.toolSelectButton.grid(row=1,column=0,sticky=N+S+E+W)
+ self.toolMoveButton = Button(self.toolBar,command=self.toolMoveCmd,image=self.toolIcons["move"])
+ self.toolMoveButton.grid(row=2,column=0,sticky=N+S+E+W)
+ self.toolRotateButton = Button(self.toolBar,command=self.toolRotateCmd,image=self.toolIcons["rotate"])
+ self.toolRotateButton.grid(row=2,column=1,sticky=N+S+E+W)
+ self.toolVertiMoveButton = Button(self.toolBar,command=self.toolVertiMoveCmd,image=self.toolIcons["vertiMove"])
+ self.toolVertiMoveButton.grid(row=3,column=0,sticky=N+S+E+W)
+ self.toolHorizMoveButton = Button(self.toolBar,command=self.toolHorizMoveCmd,image=self.toolIcons["horizMove"])
+ self.toolHorizMoveButton.grid(row=3,column=1,sticky=N+S+E+W)
+
+ self.drawLbl = Label(self.toolBar,text="",anchor=W)
+ self.drawLbl.grid(row=4,column=0,columnspan=2,sticky=W)
+ self.toolDrawLinesButton = Button(self.toolBar,command=self.toolDrawLinesCmd,image=self.toolIcons["drawLines"])
+ self.toolDrawLinesButton.grid(row=5,column=0,sticky=N+S+E+W)
+ self.toolDrawBeziButton = Button(self.toolBar,command=self.toolDrawBeziCmd,image=self.toolIcons["drawBezi"])
+ self.toolDrawBeziButton.grid(row=5,column=1,sticky=N+S+E+W)
+ self.toolDrawPolyButton = Button(self.toolBar,command=self.toolDrawPolyCmd,image=self.toolIcons["drawPoly"])
+ self.toolDrawPolyButton.grid(row=6,column=0,sticky=N+S+E+W)
+ self.toolFillPolyButton = Button(self.toolBar,command=self.toolFillPolyCmd,image=self.toolIcons["fillPoly"])
+ self.toolFillPolyButton.grid(row=6,column=1,sticky=N+S+E+W)
+ self.toolDrawEllipButton = Button(self.toolBar,command=self.toolDrawEllipCmd,image=self.toolIcons["drawEllip"],state=DISABLED,relief=FLAT)
+ #self.toolDrawEllipButton.grid(row=7,column=0,sticky=N+S+E+W)
+ self.toolFillEllipButton = Button(self.toolBar,command=self.toolFillEllipCmd,image=self.toolIcons["fillEllip"],state=DISABLED,relief=FLAT)
+ #self.toolFillEllipButton.grid(row=7,column=1,sticky=N+S+E+W)
+ self.toolDrawShapeButton = Button(self.toolBar,command=self.toolDrawShapeCmd,image=self.toolIcons["drawShape"])
+ self.toolDrawShapeButton.grid(row=8,column=0,sticky=N+S+E+W)
+ self.toolFillShapeButton = Button(self.toolBar,command=self.toolFillShapeCmd,image=self.toolIcons["fillShape"])
+ self.toolFillShapeButton.grid(row=8,column=1,sticky=N+S+E+W)
+ self.toolTextButton = Button(self.toolBar,command=self.toolTextCmd,image=self.toolIcons["text"])
+ self.toolTextButton.grid(row=9,column=0,sticky=N+S+E+W)
+ self.toolAsyButton = Button(self.toolBar,command=self.toolAsyCmd,image=self.toolIcons["asy"])
+ self.toolAsyButton.grid(row=9,column=1,sticky=N+S+E+W)
+
+ self.adjLbl = Label(self.toolBar,text="",anchor=W)
+ self.adjLbl.grid(row=10,column=0,columnspan=2,sticky=W)
+ self.toolRaiseButton = Button(self.toolBar,command=self.toolRaiseCmd,image=self.toolIcons["raise"])
+ self.toolRaiseButton.grid(row=11,column=0,sticky=N+S+E+W)
+ self.toolLowerButton = Button(self.toolBar,command=self.toolLowerCmd,image=self.toolIcons["lower"])
+ self.toolLowerButton.grid(row=11,column=1,sticky=N+S+E+W)
+
+ self.toolBar.pack(side=LEFT,anchor=NW)
+
+ #documentation for the tool bar buttons
+ self.toolDocs = {
+ self.toolSelectButton : "Click an item to select it. Control-Click will select/deselect additional items. Use mouse scroller (or Up/Down keys) to raise/lower highlighted items.",
+ self.toolMoveButton : "Drag a selected item.",
+ self.toolHorizMoveButton : "Drag a selected item. Only horizontal translation will be applied.",
+ self.toolVertiMoveButton : "Drag a selected item. Only vertical translation will be applied.",
+ self.toolRotateButton : "Drag a selected item to rotate it.",
+ self.toolDrawLinesButton : "Click to draw line segments. Double click to place last point.",
+ self.toolDrawBeziButton : "Click to place points. Double click to place last point.",
+ self.toolDrawPolyButton : "Click to place vertices. Double click to place last point.",
+ self.toolFillPolyButton : "Click to place vertices. Double click to place last point.",
+ self.toolDrawEllipButton : "(UNIMPLEMENTED)Click to place center. Move mouse to achieve correct shape and double click.",
+ self.toolFillEllipButton : "(UNIMPLEMENTED)Click to place center. Move mouse to achieve correct shape and double click.",
+ self.toolDrawShapeButton : "Click to place points. Double click to place last point.",
+ self.toolFillShapeButton : "Click to place points. Double click to place last point.",
+ self.toolTextButton : "Click location of top left label position and enter text in dialog.",
+ self.toolRaiseButton : "Raise selected items to top.",
+ self.toolLowerButton : "Lower selected items to bottom.",
+ self.toolAsyButton : "Insert/Edit Asymptote code."
+ }
+
+ #Current pen settings
+ self.optionsBar = Frame(self.parent,height=100,relief=FLAT,borderwidth=3)
+ self.penDisp = Canvas(self.optionsBar,width=100,height=25,bg="white",relief=SUNKEN,borderwidth=3)
+ self.penDisp.grid(row=0,column=0,padx=3,pady=3)
+ self.penDisp.create_line(10,25,30,10,60,20,80,10,smooth=True,tags="penDisp")
+ self.penDisp.create_text(100,30,text="x1",tags="penMag",anchor=SE,font=("times","8"))
+ self.penColButton = Button(self.optionsBar,text="Color...",width=5,command=self.setPenColCmd,relief=FLAT)
+ self.penColButton.grid(row=0,column=1,padx=3,pady=3)
+ Label(self.optionsBar,text="Width",anchor=E).grid(row=0,column=2)
+ self.penWidthEntry = Entry(self.optionsBar,width=5)
+ self.penWidthEntry.bind("<KeyRelease>",self.penWidthChanged)
+ self.penWidthEntry.bind("<FocusOut>",self.applyPenWidthEvt)
+ self.penWidthEntry.bind("<Return>",self.applyPenWidthEvt)
+ self.penWidthEntry.grid(row=0,column=3)
+ Label(self.optionsBar,text="Options",anchor=E).grid(row=0,column=4)
+ self.penOptEntry = Entry(self.optionsBar)
+ self.penOptEntry.bind("<FocusOut>",self.applyPenOptEvt)
+ self.penOptEntry.bind("<Return>",self.applyPenOptEvt)
+ self.penOptEntry.grid(row=0,column=5)
+ self.optionsBar.pack(side=BOTTOM,anchor=NW)
+
+ #a paned window for the canvas and propert explorer
+ self.windowPane = PanedWindow(self.parent)
+
+ #a property explorer
+ self.propFrame = Frame(self.parent)
+ self.propFrame.rowconfigure(1,weight=1)
+ self.propFrame.columnconfigure(0,weight=1)
+ Label(self.propFrame,text="Item List").grid(row=0,column=0,columnspan=2)
+ self.itemScroll = Scrollbar(self.propFrame,orient=VERTICAL)
+ self.propList = Listbox(self.propFrame, yscrollcommand=self.itemScroll.set)
+ self.itemScroll.config(command=self.propList.yview)
+ self.itemScroll.grid(row=1,column=1,sticky=N+S)
+ self.propList.grid(row=1,column=0,sticky=N+S+E+W)
+ self.propList.bind("<Double-Button-1>",self.propSelect)
+ self.propList.bind("<Button-3>",self.itemPropMenuPopup)
+
+ #the canvas's frame
+ self.canvFrame = Frame(self.parent,relief=FLAT,borderwidth=0)
+ self.canvFrame.rowconfigure(0,weight=1)
+ self.canvFrame.columnconfigure(0,weight=1)
+ self.canvVScroll = Scrollbar(self.canvFrame,orient=VERTICAL)
+ self.canvHScroll = Scrollbar(self.canvFrame,orient=HORIZONTAL)
+ self.canvHScroll.grid(row=1,column=0,sticky=E+W)
+ self.canvVScroll.grid(row=0,column=1,sticky=N+S)
+
+ #add the frames to the window pane
+ self.windowPane.pack(side=RIGHT,fill=BOTH,expand=True)
+ self.windowPane.add(self.canvFrame)
+ self.windowPane.add(self.propFrame)
+ self.windowPane.paneconfigure(self.propFrame,minsize=50,sticky=N+S+E+W)
+ self.windowPane.bind("<Double-Button-1>",self.togglePaneEvt)
+
+ #the highly important canvas!
+ self.mainCanvas = Canvas(self.canvFrame,relief=SUNKEN,background="white",borderwidth=3,
+ highlightthickness=0,closeenough=1.0,yscrollcommand=self.canvVScroll.set,
+ xscrollcommand=self.canvHScroll.set)
+ self.mainCanvas.grid(row=0,column=0,sticky=N+S+E+W)
+
+ self.canvVScroll.config(command=self.mainCanvas.yview)
+ self.canvHScroll.config(command=self.mainCanvas.xview)
+
+ self.mainCanvas.bind("<Motion>",self.canvMotion)
+ self.mainCanvas.bind("<Button-1>",self.canvLeftDown)
+ self.mainCanvas.bind("<Double-Button-1>",self.endDraw)
+ self.mainCanvas.bind("<ButtonRelease-1>",self.canvLeftUp)
+ self.mainCanvas.bind("<B1-Motion>",self.canvDrag)
+
+ self.mainCanvas.bind("<Enter>",self.canvEnter)
+ self.mainCanvas.bind("<Leave>",self.canvLeave)
+ self.mainCanvas.bind("<Delete>",self.itemDelete)
+ #self.mainCanvas.bind("<Button-3>",self.canvRightDown)
+ #self.mainCanvas.bind("<ButtonRelease-3>",self.canvRightUp)
+ self.mainCanvas.bind("<Button-4>",self.itemRaise)
+ self.mainCanvas.bind("<Button-5>",self.itemLower)
+ self.mainCanvas.bind("<Up>",self.itemRaise)
+ self.mainCanvas.bind("<Down>",self.itemLower)
+ self.mainCanvas.bind("<Configure>",self.configEvt)
+
+ def foregroundPenColor(self,hex):
+ hex = hex[1:]
+ rgb = max(hex[0:2], hex[2:4], hex[4:6])
+ if(rgb >= "80"):
+ return "black"
+ else:
+ return "white"
+
+ def resetGUI(self):
+ #set up the main window
+ self.filename = None
+ self.fileToOpen = None
+ self.retitle()
+
+ #set up the paned window
+ self.paneVisible = True
+
+ #setup the pen entries
+ self.pendingPenWidthChange = None
+ self.pendingPenOptChange = None
+
+ #load one-time configs
+ xasyOptions.load()
+ self.tkPenColor = xasyOptions.options['defPenColor']
+ self.penColor = makeRGBfromTkColor(self.tkPenColor)
+ self.penColButton.config(activebackground=self.tkPenColor,
+ activeforeground=self.foregroundPenColor(self.tkPenColor))
+ self.penWidth = xasyOptions.options['defPenWidth']
+ self.penWidthEntry.select_range(0,END)
+ self.penWidthEntry.delete(0,END)
+ self.penWidthEntry.insert(END,str(self.penWidth))
+ self.penOptions = xasyOptions.options['defPenOptions']
+ self.penOptEntry.select_range(0,END)
+ self.penOptEntry.delete(0,END)
+ self.penOptEntry.insert(END,str(self.penOptions))
+ self.showCurrentPen()
+
+ #load modifiable configs
+ self.applyOptions()
+
+ #set up editing
+ self.editor = None
+
+ #set up drawing
+ self.pathInProgress = asyPath()
+ self.currentIDTag = -1
+ self.inDrawingMode = False
+ self.freeMouseDown = True
+ self.dragSelecting = False
+ self.itemsBeingRotated = []
+ self.inRotatingMode = False
+
+ #set up the toolbar
+ try:
+ self.updateSelectedButton(self.toolSelectButton)
+ except:
+ self.selectedButton = self.toolSelectButton
+ self.updateSelectedButton(self.toolSelectButton)
+
+ #set up the canvas
+ self.mainCanvas.delete(ALL)
+ self.mainCanvas.create_rectangle(0,0,0,0,tags="outlineBox",width=0,outline="#801111",dash=(3,6))
+ self.backColor = "white" #in future, load this from an options file. Or, should this really be an option?
+ self.mainCanvas.configure(background=self.backColor)
+
+ #set up the xasy item list
+ self.fileItems = []
+ self.propList.delete(0,END)
+ self.updateCanvasSize()
+
+ #setup timer
+ self.tickCount = 0
+
+ #setup undo/redo!
+ self.undoRedoStack = actionStack()
+ self.amDragging = False
+
+ def retitle(self):
+ if self.filename == None:
+ self.parent.title("Xasy - New File")
+ else:
+ name = os.path.abspath(self.filename)
+ name = os.path.basename(name)
+ self.parent.title("Xasy - %s"%name)
+
+ def applyOptions(self):
+ self.gridcolor = xasyOptions.options['gridColor']
+ self.tickcolor = xasyOptions.options['tickColor']
+ self.axiscolor = xasyOptions.options['axesColor']
+ self.gridVisible = xasyOptions.options['showGrid']
+ self.gridxspace = xasyOptions.options['gridX']
+ self.gridyspace = xasyOptions.options['gridY']
+ self.axesVisible = xasyOptions.options['showAxes']
+ self.axisxspace = xasyOptions.options['axisX']
+ self.axisyspace = xasyOptions.options['axisY']
+ self.updateCanvasSize()
+ #test the asyProcess
+ startQuickAsy()
+ if not quickAsyRunning():
+ if tkMessageBox.askyesno("Xasy Error","Asymptote could not be executed.\r\nTry to find Asymptote automatically?"):
+ xasyOptions.setAsyPathFromWindowsRegistry()
+ xasyOptions.save()
+ startQuickAsy()
+ while not quickAsyRunning():
+ if tkMessageBox.askyesno("Xasy Error","Asymptote could not be executed.\r\nEdit settings?"):
+ xasyOptionsDialog.xasyOptionsDlg(self.parent)
+ xasyOptions.save()
+ startQuickAsy()
+ else:
+ self.parent.destroy()
+ sys.exit(1)
+
+ def drawGrid(self):
+ self.mainCanvas.delete("grid")
+ if not self.gridVisible:
+ return
+ left,top,right,bottom = map(int,self.mainCanvas.cget("scrollregion").split())
+ gridyspace = int(self.magnification*self.gridyspace)
+ gridxspace = int(self.magnification*self.gridxspace)
+ if gridxspace >= 3 and gridyspace >= 3:
+ for i in range(0,right,gridxspace):
+ self.mainCanvas.create_line(i,top,i,bottom,tags=("grid","vertical"),fill=self.gridcolor)
+ for i in range(-gridxspace,left,-gridxspace):
+ self.mainCanvas.create_line(i,top,i,bottom,tags=("grid","vertical"),fill=self.gridcolor)
+ for i in range(-gridyspace,top,-gridyspace):
+ self.mainCanvas.create_line(left,i,right,i,tags=("grid","horizontal"),fill=self.gridcolor)
+ for i in range(0,bottom,gridyspace):
+ self.mainCanvas.create_line(left,i,right,i,tags=("grid","horizontal"),fill=self.gridcolor)
+ self.mainCanvas.tag_lower("grid")
+
+ def drawAxes(self):
+ self.mainCanvas.delete("axes")
+ if not self.axesVisible:
+ return
+ left,top,right,bottom = map(int,self.mainCanvas.cget("scrollregion").split())
+ self.mainCanvas.create_line(0,top,0,bottom,tags=("axes","yaxis"),fill=self.axiscolor)
+ self.mainCanvas.create_line(left,0,right,0,tags=("axes","xaxis"),fill=self.axiscolor)
+ axisxspace = int(self.magnification*self.axisxspace)
+ axisyspace = int(self.magnification*self.axisyspace)
+ if axisxspace >= 3 and axisyspace >= 3:
+ for i in range(axisxspace,right,axisxspace):
+ self.mainCanvas.create_line(i,-5,i,5,tags=("axes","xaxis-ticks"),fill=self.tickcolor)
+ for i in range(-axisxspace,left,-axisxspace):
+ self.mainCanvas.create_line(i,-5,i,5,tags=("axes","xaxis-ticks"),fill=self.tickcolor)
+ for i in range(-axisyspace,top,-axisyspace):
+ self.mainCanvas.create_line(-5,i,5,i,tags=("axes","yaxis-ticks"),fill=self.tickcolor)
+ for i in range(axisyspace,bottom,axisyspace):
+ self.mainCanvas.create_line(-5,i,5,i,tags=("axes","yaxis-ticks"),fill=self.tickcolor)
+ self.mainCanvas.tag_lower("axes")
+
+ def updateCanvasSize(self,left=-200,top=-200,right=200,bottom=200):
+ self.parent.update_idletasks()
+ bbox = self.mainCanvas.bbox("drawn || image || node || precontrol || postcontrol")
+ if bbox == None:
+ bbox = (0,0,0,0)
+ #(topleft, bottomright)
+ left = min(bbox[0],left)
+ top = min(bbox[1],top)
+ right = max(bbox[2],right)
+ bottom = max(bbox[3],bottom)
+ w,h = self.mainCanvas.winfo_width(),self.mainCanvas.winfo_height()
+ if right-left < w:
+ extraw = w-(right-left)
+ right += extraw/2
+ left -= extraw/2
+ if bottom-top < h:
+ extrah = h-(bottom-top)
+ bottom += extrah/2
+ top -= extrah/2
+ self.mainCanvas.config(scrollregion=(left,top,right,bottom))
+ #self.mainCanvas.xview(MOVETO,float(split(self.mainCanvas["scrollregion"])[0]))
+ #self.mainCanvas.yview(MOVETO,float(split(self.mainCanvas["scrollregion"])[1]))
+ #self.mainCanvas.xview(MOVETO,(left+right)/2)
+ #self.mainCanvas.yview(MOVETO,(top+bottom)/2)
+ self.drawAxes()
+ self.drawGrid()
+
+ def bindEvents(self,tagorID):
+ if tagorID == None:
+ return
+ self.mainCanvas.tag_bind(tagorID,"<Control-Button-1>",self.itemToggleSelect)
+ self.mainCanvas.tag_bind(tagorID,"<Button-1>",self.itemSelect)
+ self.mainCanvas.tag_bind(tagorID,"<ButtonRelease-1>",self.itemMouseUp)
+ self.mainCanvas.tag_bind(tagorID,"<Double-Button-1>",self.itemEditEvt)
+ self.mainCanvas.tag_bind(tagorID,"<B1-Motion>",self.itemDrag)
+ self.mainCanvas.tag_bind(tagorID,"<Delete>",self.itemDelete)
+ self.mainCanvas.tag_bind(tagorID,"<Enter>",self.itemHighlight)
+ self.mainCanvas.tag_bind(tagorID,"<Button-3>",self.itemCanvasMenuPopup)
+
+ def bindItemEvents(self,item):
+ if item == None:
+ return
+ if isinstance(item,xasyScript) or isinstance(item,xasyText):
+ for image in item.imageList:
+ self.bindEvents(image.IDTag)
+ else:
+ self.bindEvents(item.IDTag)
+
+ def canQuit(self,force=False):
+ #print "Quitting"
+ if not force and not self.testOrAcquireLock():
+ return
+ try:
+ self.releaseLock()
+ except:
+ pass
+ if self.undoRedoStack.changesMade():
+ result = tkMessageBox._show("xasy","File has been modified.\nSave changes?",icon=tkMessageBox.QUESTION,type=tkMessageBox.YESNOCANCEL)
+ if str(result) == tkMessageBox.CANCEL:
+ return
+ elif result == tkMessageBox.YES:
+ self.fileSaveCmd()
+ try:
+ os.rmdir(getAsyTempDir())
+ except:
+ pass
+ self.parent.destroy()
+
+ def openFile(self,name):
+ if(not self.testOrAcquireLock()):
+ return
+ self.releaseLock() #release the lock for loadFile
+ self.resetGUI()
+ self.loadFile(name)
+
+ def loadFile(self,name):
+ self.status.config(text="Loading "+name)
+ self.filename = os.path.abspath(name)
+ startQuickAsy()
+ self.retitle()
+ try:
+ try:
+ f = open(self.filename,'rt')
+ except:
+ if self.filename[-4:] == ".asy":
+ raise
+ else:
+ f = open(self.filename+".asy",'rt')
+ self.filename += ".asy"
+ self.retitle()
+ self.fileItems = xasyFile.parseFile(f)
+ f.close()
+ except IOError:
+ tkMessageBox.showerror("File Opening Failed.","File could not be opened.")
+ self.fileItems = []
+ except:
+ self.fileItems = []
+ self.autoMakeScript = True
+ if self.autoMakeScript or tkMessageBox.askyesno("Error Opening File", "File was not recognized as an xasy file.\nLoad as a script item?"):
+ try:
+ item = xasyScript(self.mainCanvas)
+ f.seek(0)
+ item.setScript(f.read())
+ self.addItemToFile(item)
+ except:
+ tkMessageBox.showerror("File Opening Failed.","Could not load as a script item.")
+ self.fileItems = []
+ self.populateCanvasWithItems()
+ self.populatePropertyList()
+ self.updateCanvasSize()
+
+ def populateCanvasWithItems(self):
+ if(not self.testOrAcquireLock()):
+ return
+ self.mainCanvas.delete("drawn || image")
+ self.itemCount = 0
+ for item in self.fileItems:
+ item.drawOnCanvas(self.mainCanvas,self.magnification,forceAddition=True)
+ self.bindItemEvents(item)
+ self.releaseLock()
+
+ def propListCountItem(self,item):
+ plist = self.propList.get(0,END)
+ count = 1
+ for text in plist:
+ if text.startswith(item):
+ count += 1
+ return count
+
+ def describeItem(self,item):
+ if isinstance(item,xasyScript):
+ return "Code Module "+str(self.propListCountItem("Code Module"))
+ elif isinstance(item,xasyText):
+ return "Text Label "+str(self.propListCountItem("Text Label"))
+ elif isinstance(item,xasyFilledShape):
+ return "Filled Shape "+str(self.propListCountItem("Filled Shape"))
+ elif isinstance(item,xasyShape):
+ return "Outline "+str(self.propListCountItem("Outline"))
+ else:
+ return "If this happened, the program is corrupt!"
+
+ def populatePropertyList(self):
+ self.propList.delete(0,END)
+ for item in self.fileItems:
+ self.propList.insert(0,self.describeItem(item))
+
+ def saveFile(self,name):
+ if(not self.testOrAcquireLock()):
+ return
+ f = open(name,"wt")
+ xasyFile.saveFile(f,self.fileItems)
+ f.close()
+ self.undoRedoStack.setCommitLevel()
+ self.retitle()
+ self.releaseLock()
+
+ #menu commands
+ def fileNewCmd(self):
+ if(not self.testOrAcquireLock()):
+ return
+ self.releaseLock()
+ #print "Create New File"
+ if self.undoRedoStack.changesMade():
+ result = tkMessageBox._show("xasy","File has been modified.\nSave changes?",icon=tkMessageBox.QUESTION,type=tkMessageBox.YESNOCANCEL)
+ if str(result) == tkMessageBox.CANCEL:
+ return
+ elif result == tkMessageBox.YES:
+ self.fileSaveCmd()
+ self.resetGUI()
+
+ def fileOpenCmd(self):
+ if(not self.testOrAcquireLock()):
+ return
+ self.releaseLock()
+ #print "Open a file"
+ if self.undoRedoStack.changesMade():
+ result = tkMessageBox._show("xasy","File has been modified.\nSave changes?",icon=tkMessageBox.QUESTION,type=tkMessageBox.YESNOCANCEL)
+ if str(result) == tkMessageBox.CANCEL:
+ return
+ elif result == tkMessageBox.YES:
+ self.fileSaveCmd()
+ filename=tkFileDialog.askopenfilename(filetypes=[("asy files","*.asy"),("All files","*")],title="Open File",parent=self.parent)
+ if type(filename) != type((0,)) and filename != None and filename != '':
+ self.filename = filename
+ self.openFile(self.filename)
+
+ def fileSaveCmd(self):
+ #print "Save current file"
+ if(not self.testOrAcquireLock()):
+ return
+ self.releaseLock()
+ if self.filename == None:
+ filename=tkFileDialog.asksaveasfilename(defaultextension=".asy",filetypes=[("asy files","*.asy")],initialfile="newDrawing.asy",parent=self.parent,title="Save File")
+ if type(filename) != type((0,)) and filename != None and filename != '':
+ self.filename = filename
+ if self.filename != None:
+ self.saveFile(self.filename)
+
+ def fileSaveAsCmd(self):
+ if(not self.testOrAcquireLock()):
+ return
+ self.releaseLock()
+ #print "Save current file as"
+ filename=tkFileDialog.asksaveasfilename(defaultextension=".asy",filetypes=[("asy files","*.asy")],initialfile="newDrawing.asy",parent=self.parent,title="Save File")
+ if type(filename) != type((0,)) and filename != None and filename != '':
+ self.filename = filename
+ self.saveFile(self.filename)
+
+ #export the file
+ def exportEPS(self):
+ self.exportFile(self.filename,"eps")
+
+ def exportPDF(self):
+ self.exportFile(self.filename,"pdf")
+
+ def exportGIF(self):
+ self.exportFile(self.filename,"gif")
+
+ def exportPNG(self):
+ self.exportFile(self.filename,"png")
+
+ def exportSVG(self):
+ self.exportFile(self.filename,"svg")
+
+ def exportFile(self,inFile, outFormat):
+ if(not self.testOrAcquireLock()):
+ return
+ self.releaseLock()
+ if inFile == None:
+ if tkMessageBox.askyesno("xasy","File has not been saved.\nSave?"):
+ self.fileSaveAsCmd()
+ inFile = self.filename
+ else:
+ return
+ elif self.undoRedoStack.changesMade():
+ choice = tkMessageBox._show("xasy","File has been modified.\nOnly saved changes can be exported.\nDo you want to save changes?",icon=tkMessageBox.QUESTION,type=tkMessageBox.YESNOCANCEL)
+ choice = str(choice)
+ if choice != tkMessageBox.YES:
+ return
+ else:
+ self.fileSaveCmd()
+ name = os.path.splitext(os.path.basename(self.filename))[0]+'.'+outFormat
+ outfilename = tkFileDialog.asksaveasfilename(defaultextension = '.'+outFormat,filetypes=[(outFormat+" files","*."+outFormat)],initialfile=name,parent=self.parent,title="Choose output file")
+ if type(outfilename)==type((0,)) or not outfilename or outfilename == '':
+ return
+ fullname = os.path.abspath(outfilename)
+ outName = os.path.basename(outfilename)
+ command=[xasyOptions.options['asyPath'],"-f"+outFormat,"-o"+fullname,inFile]
+ saver = subprocess.Popen(command,stdin=PIPE,stdout=PIPE,stderr=PIPE)
+ saver.wait()
+ if saver.returncode != 0:
+ tkMessageBox.showerror("Export Error","Export Error:\n"+saver.stdout.read()+saver.stderr.read())
+ self.status.config(text="Error exporting file")
+ else:
+ self.status.config(text="File exported successfully")
+
+ def fileExitCmd(self):
+ #print "Exit xasy"
+ self.canQuit()
+
+ def editUndoCmd(self):
+ if not self.editor == None:
+ return
+ if(not self.testOrAcquireLock()):
+ return
+ self.undoOperation()
+ self.releaseLock()
+
+ def editRedoCmd(self):
+ if not self.editor == None:
+ return
+ if(not self.testOrAcquireLock()):
+ return
+ self.redoOperation()
+ self.releaseLock()
+
+ def helpHelpCmd(self):
+ print "Get help on xasy"
+
+ def helpAsyDocCmd(self):
+ #print "Open documentation about Asymptote"
+ asyExecute("help;\n")
+
+ def helpAboutCmd(self):
+ tkMessageBox.showinfo("About xasy","A graphical interface for Asymptote "+xasyVersion)
+
+ def updateSelectedButton(self,newB):
+ if(not self.testOrAcquireLock()):
+ return
+ self.releaseLock()
+ #disable switching modes during an incomplete drawing operation
+ if self.inDrawingMode:
+ return
+ self.selectedButton.config(relief = RAISED)
+ if newB == self.toolSelectButton or self.selectedButton == self.toolSelectButton:
+ self.mainCanvas.delete("highlightBox")
+ if self.editor != None:
+ self.editor.endEdit()
+ if self.editor.modified:
+ self.undoRedoStack.add(editDrawnItemAction(self,self.itemBeingEdited,copy.deepcopy(self.editor.shape),self.fileItems.index(self.editor.shape)))
+ if newB not in (self.toolSelectButton,self.toolMoveButton,self.toolHorizMoveButton,self.toolVertiMoveButton,self.toolRotateButton):
+ self.clearSelection()
+ self.selectedButton = newB
+ self.selectedButton.config(relief = SUNKEN)
+ self.status.config(text=self.toolDocs[newB])
+
+ #toolbar commands
+ def toolSelectCmd(self):
+ self.updateSelectedButton(self.toolSelectButton)
+ def toolMoveCmd(self):
+ self.updateSelectedButton(self.toolMoveButton)
+ def toolRotateCmd(self):
+ self.updateSelectedButton(self.toolRotateButton)
+ def toolVertiMoveCmd(self):
+ self.updateSelectedButton(self.toolVertiMoveButton)
+ def toolHorizMoveCmd(self):
+ self.updateSelectedButton(self.toolHorizMoveButton)
+ def toolDrawLinesCmd(self):
+ self.updateSelectedButton(self.toolDrawLinesButton)
+ def toolDrawBeziCmd(self):
+ self.updateSelectedButton(self.toolDrawBeziButton)
+ def toolDrawPolyCmd(self):
+ self.updateSelectedButton(self.toolDrawPolyButton)
+ def toolFillPolyCmd(self):
+ self.updateSelectedButton(self.toolFillPolyButton)
+ def toolDrawEllipCmd(self):
+ self.updateSelectedButton(self.toolDrawEllipButton)
+ def toolFillEllipCmd(self):
+ self.updateSelectedButton(self.toolFillEllipButton)
+ def toolDrawShapeCmd(self):
+ self.updateSelectedButton(self.toolDrawShapeButton)
+ def toolFillShapeCmd(self):
+ self.updateSelectedButton(self.toolFillShapeButton)
+ def toolTextCmd(self):
+ self.updateSelectedButton(self.toolTextButton)
+ def toolAsyCmd(self):
+ # ignore the command if we are too busy to process it
+ if not self.testOrAcquireLock():
+ return
+ self.updateSelectedButton(self.toolSelectButton)
+ self.clearSelection()
+ self.clearHighlight()
+ self.unbindGlobalEvents()
+ try:
+ self.getNewText("// enter your code here")
+ except Exception, e:
+ tkMessageBox.showerror('xasy Error',e.message)
+ else:
+ self.addItemToFile(xasyScript(self.mainCanvas))
+ text = self.newText
+ self.undoRedoStack.add(addScriptAction(self,self.fileItems[-1]))
+ self.fileItems[-1].setScript(text)
+ self.fileItems[-1].drawOnCanvas(self.mainCanvas,self.magnification)
+ self.bindItemEvents(self.fileItems[-1])
+ self.bindGlobalEvents()
+ self.releaseLock()
+ def toolRaiseCmd(self):
+ if(not self.testOrAcquireLock()):
+ return
+ self.releaseLock()
+ if not self.inDrawingMode and self.editor == None:
+ itemList = []
+ indexList = []
+ for ID in self.mainCanvas.find_withtag("selectedItem"):
+ item = self.findItem(ID)
+ if item not in itemList:
+ itemList.append(item)
+ indexList.append(self.fileItems.index(item))
+ self.raiseSomething(item)
+ self.undoRedoStack.add(itemRaiseAction(self,itemList,indexList))
+ def toolLowerCmd(self):
+ if(not self.testOrAcquireLock()):
+ return
+ self.releaseLock()
+ if not self.inDrawingMode and self.editor == None:
+ itemList = []
+ indexList = []
+ for ID in self.mainCanvas.find_withtag("selectedItem"):
+ item = self.findItem(ID)
+ if item not in itemList:
+ itemList.append(item)
+ indexList.append(self.fileItems.index(item))
+ self.lowerSomething(item)
+ self.undoRedoStack.add(itemLowerAction(self,itemList,indexList))
+ def itemRaise(self,event):
+ self.mainCanvas.tag_raise(CURRENT)
+ def itemLower(self,event):
+ self.mainCanvas.tag_lower(CURRENT)
+
+ #options bar commands
+ def setPenColCmd(self):
+ if not self.testOrAcquireLock():
+ return
+ old = self.penColor
+ self.penColor = xasyColorDlg(self.parent).getColor(self.penColor)
+ if self.penColor != old:
+ self.tkPenColor = RGB255hex(RGBreal255(self.penColor))
+ self.penColButton.config(activebackground=self.tkPenColor,
+ activeforeground=self.foregroundPenColor(self.tkPenColor))
+ self.showCurrentPen()
+ self.releaseLock()
+
+ def clearSelection(self):
+ self.hideSelectionBox()
+ self.mainCanvas.dtag("selectedItem","selectedItem")
+
+ def hideSelectionBox(self):
+ self.mainCanvas.itemconfigure("outlineBox",width=1,outline=self.backColor)
+ self.mainCanvas.tag_lower("outlineBox")
+ self.mainCanvas.coords("outlineBox",self.mainCanvas.bbox(ALL))
+
+ def showSelectionBox(self):
+ self.mainCanvas.itemconfigure("outlineBox",width=2,outline="#801111")
+ self.mainCanvas.tag_raise("outlineBox")
+
+ def setSelection(self,what):
+ self.mainCanvas.addtag_withtag("selectedItem",what)
+ self.updateSelection()
+ if self.selectedButton == self.toolSelectButton and len(self.mainCanvas.find_withtag("selectedItem")) > 0:
+ self.updateSelectedButton(self.toolMoveButton)
+
+ def unSelect(self,what):
+ self.mainCanvas.dtag(what,"selectedItem")
+ self.updateSelection()
+
+ def updateSelection(self):
+ self.clearHighlight()
+ theBbox = self.mainCanvas.bbox("selectedItem")
+ if theBbox != None:
+ theBbox = (theBbox[0]-2,theBbox[1]-2,theBbox[2]+2,theBbox[3]+2)
+ self.mainCanvas.coords("outlineBox",theBbox)
+ self.showSelectionBox()
+ else:
+ self.clearSelection()
+
+ #event handlers
+ def updateZoom(self):
+ self.zoomMenu.config(state=DISABLED)
+ self.magnification = self.magVal.get()/100.0
+ if self.magnification != self.previousZoom:
+ self.populateCanvasWithItems()
+ self.updateCanvasSize()
+ self.updateSelection()
+ self.drawAxes()
+ self.drawGrid()
+ self.previousZoom = self.magnification
+ self.zoomMenu.config(state=NORMAL)
+
+ def zoomViewCmd(self,*args):
+ magnification = self.magVal.get()/100.0
+ self.updateZoom();
+
+ def selectItem(self,item):
+ self.clearSelection()
+ if isinstance(item,xasyScript) or isinstance(item,xasyText):
+ for image in item.imageList:
+ self.setSelection(image.IDTag)
+ else:
+ self.setSelection(item.IDTag)
+
+ def propSelect(self,event):
+ items = map(int, self.propList.curselection())
+ if len(items)>0:
+ try:
+ self.selectItem(self.fileItems[len(self.fileItems)-items[0]-1])
+ except:
+ raise
+
+ def findItem(self,ID):
+ for item in self.fileItems:
+ if isinstance(item,xasyScript) or isinstance(item,xasyText):
+ for image in item.imageList:
+ if image.IDTag == ID:
+ return item
+ else:
+ if item.IDTag == ID:
+ return item
+ raise Exception,"Illegal operation: Item with matching ID could not be found."
+
+ def findItemImageIndex(self,item,ID):
+ count = 0
+ for image in item.imageList:
+ if image.IDTag == ID:
+ return count
+ else:
+ count += 1
+ raise Exception,"Illegal operation: Image with matching ID could not be found."
+ return None
+
+ def raiseSomething(self,item,force=False):
+ if self.fileItems[-1] != item or force:
+ index = len(self.fileItems)-self.fileItems.index(item)-1
+ text = self.propList.get(index)
+ self.propList.delete(index)
+ self.propList.insert(0,text)
+ for i in range(self.fileItems.index(item),len(self.fileItems)-1):
+ self.fileItems[i] = self.fileItems[i+1]
+ self.fileItems[-1] = item
+ if isinstance(item,xasyScript) or isinstance(item,xasyText):
+ for im in item.imageList:
+ if im.IDTag != None:
+ self.mainCanvas.tag_raise(im.IDTag)
+ else:
+ if item.IDTag != None:
+ self.mainCanvas.tag_raise(item.IDTag)
+
+ def lowerSomething(self,item):
+ if self.fileItems[0] != item:
+ index = len(self.fileItems)-self.fileItems.index(item)-1
+ text = self.propList.get(index)
+ self.propList.delete(index)
+ self.propList.insert(END,text)
+ indices = range(self.fileItems.index(item))
+ indices.reverse()
+ for i in indices:
+ self.fileItems[i+1] = self.fileItems[i]
+ self.fileItems[0] = item
+ if isinstance(item,xasyScript) or isinstance(item,xasyText):
+ item.imageList.reverse()
+ for im in item.imageList:
+ if im.IDTag != None:
+ self.mainCanvas.tag_lower(im.IDTag)
+ item.imageList.reverse()
+ else:
+ if item.IDTag != None:
+ self.mainCanvas.tag_lower(item.IDTag)
+ self.mainCanvas.tag_lower("axes || grid")
+
+ def translateSomething(self,ID,translation,specificItem=None,specificIndex=None):
+ transform = asyTransform((translation[0],translation[1],1,0,0,1))
+ if ID == -1:
+ item = specificItem
+ else:
+ item = self.findItem(ID)
+ if isinstance(item,xasyText) or isinstance(item,xasyScript):
+ if ID == -1:
+ index = specificIndex
+ else:
+ index = self.findItemImageIndex(item,ID)
+ try:
+ original = item.transform[index]
+ except:
+ original = identity()
+ item.transform[index] = transform*original
+ bbox = item.imageList[index].originalImage.bbox
+ item.imageList[index].originalImage.bbox = bbox[0]+translation[0],bbox[1]+translation[1],bbox[2]+translation[0],bbox[3]+translation[1]
+ else:
+ item.transform = [transform*item.transform[0]]
+
+ def makeRotationMatrix(self,theta,origin):
+ rotMat = (math.cos(theta),-math.sin(theta),math.sin(theta),math.cos(theta))
+ shift = asyTransform((0,0,1-rotMat[0],-rotMat[1],-rotMat[2],1-rotMat[3]))*origin
+ return asyTransform((shift[0],shift[1],rotMat[0],rotMat[1],rotMat[2],rotMat[3]))
+
+ def rotateSomething(self,ID,theta,origin,specificItem=None,specificIndex=None):
+ #print "Rotating by",theta*180.0/math.pi,"around",origin
+ rotMat = self.makeRotationMatrix(theta,(origin[0]/self.magnification,origin[1]/self.magnification))
+ #print rotMat
+ if ID == -1:
+ item = specificItem
+ else:
+ item = self.findItem(ID)
+ if isinstance(item,xasyText) or isinstance(item,xasyScript):
+ #transform the image
+ if ID == -1:
+ index = specificIndex
+ else:
+ index = self.findItemImageIndex(item,ID)
+ try:
+ original = item.transform[index]
+ except:
+ original = identity()
+ oldBbox = item.imageList[index].originalImage.bbox
+ oldBbox = (oldBbox[0],-oldBbox[1],oldBbox[2],-oldBbox[3])
+ item.transform[index] = rotMat*item.transform[index]
+ item.transform[index] = rotMat*original
+ item.imageList[index].originalImage.theta += theta
+ item.imageList[index].image = item.imageList[index].originalImage.rotate(item.imageList[index].originalImage.theta*180.0/math.pi,expand=True,resample=Image.BICUBIC)
+ item.imageList[index].itk = ImageTk.PhotoImage(item.imageList[index].image)
+ self.mainCanvas.itemconfigure(ID,image=item.imageList[index].itk)
+ #the image has been rotated in place
+ #now, compensate for any resizing and shift to the correct location
+ #
+ # p0 --- p1 p1
+ # | | ---> / \
+ # p2 --- p3 p0 p3
+ # \ /
+ # p2
+ #
+ rotMat2 = self.makeRotationMatrix(item.imageList[index].originalImage.theta,origin)
+ p0 = rotMat2*(oldBbox[0],-oldBbox[3])#switch to usual coordinates
+ p1 = rotMat2*(oldBbox[2],-oldBbox[3])
+ p2 = rotMat2*(oldBbox[0],-oldBbox[1])
+ p3 = rotMat2*(oldBbox[2],-oldBbox[1])
+ newTopLeft = (min(p0[0],p1[0],p2[0],p3[0]),-max(p0[1],p1[1],p2[1],p3[1]))#switch back to screen coords
+ shift = (newTopLeft[0]-oldBbox[0],newTopLeft[1]-oldBbox[3])
+ #print theta*180.0/math.pi,origin,oldBbox,newTopLeft,shift
+ #print item.imageList[index].originalImage.size
+ #print item.imageList[index].image.size
+ #print
+ self.mainCanvas.coords(ID,oldBbox[0]+shift[0],oldBbox[3]+shift[1])
+ else:
+ #transform each point of the object
+ xform = rotMat*item.transform[0]
+ item.transform = [identity()]
+ for i in range(len(item.path.nodeSet)):
+ if item.path.nodeSet[i] != 'cycle':
+ item.path.nodeSet[i] = xform*item.path.nodeSet[i]
+ for i in range(len(item.path.controlSet)):
+ item.path.controlSet[i][0] = xform*item.path.controlSet[i][0]
+ item.path.controlSet[i][1] = xform*item.path.controlSet[i][1]
+ item.drawOnCanvas(self.mainCanvas,self.magnification)
+
+ def deleteItem(self,item):
+ if isinstance(item,xasyScript) or isinstance(item,xasyText):
+ if isinstance(item,xasyScript):
+ self.undoRedoStack.add(deleteScriptAction(self,item,self.fileItems.index(item)))
+ else:
+ self.undoRedoStack.add(deleteLabelAction(self,item,self.fileItems.index(item)))
+ for image in item.imageList:
+ self.mainCanvas.delete(image.IDTag)
+ else:
+ if isinstance(item,xasyDrawnItem):
+ self.undoRedoStack.add(deleteDrawnItemAction(self,item,self.fileItems.index(item)))
+ self.mainCanvas.delete(item.IDTag)
+ self.fileItems.remove(item)
+ self.populatePropertyList()
+ self.clearSelection()
+
+ def deleteSomething(self,ID):
+ self.clearSelection()
+ self.clearHighlight()
+ if self.editor != None:
+ self.editor.endEdit()
+ if self.editor.modified:
+ self.undoRedoStack.add(editDrawnItemAction(self,self.itemBeingEdited,copy.deepcopy(self.editor.shape),self.fileItems.index(self.editor.shape)))
+ item = self.findItem(ID)
+ #save an event on the undoredo stack
+ if isinstance(item,xasyScript):
+ index = self.findItemImageIndex(item,ID)
+ item.transform[index].deleted = True
+ else:
+ if isinstance(item,xasyText):
+ self.undoRedoStack.add(deleteLabelAction(self,item,self.fileItems.index(item)))
+ elif isinstance(item,xasyDrawnItem):
+ self.undoRedoStack.add(deleteDrawnItemAction(self,item,self.fileItems.index(item)))
+ self.fileItems.remove(item)
+ self.mainCanvas.delete(ID)
+ self.populatePropertyList()
+
+ def scriptEditThread(self,oldText):
+ try:
+ self.newText = xasyCodeEditor.getText(oldText)
+ except:
+ self.newText = -1
+
+ def getNewText(self,oldText):
+ editThread = threading.Thread(target=self.scriptEditThread,args=(oldText,))
+ editThread.start()
+ while editThread.isAlive():
+ time.sleep(0.05)
+ self.parent.update()
+ editThread.join()
+ if type(self.newText)==type(-1):
+ self.newText = ''
+ raise Exception('Error launching external editor. Please check xasy options.')
+
+ def itemEdit(self,item):
+ # are we too busy?
+ if not self.testOrAcquireLock():
+ return
+ self.updateSelectedButton(self.toolSelectButton)
+ if isinstance(item,xasyScript):
+ self.unbindGlobalEvents()
+ oldText = item.script
+ try:
+ self.getNewText(oldText)
+ except Exception,e:
+ tkMessageBox.showerror('xasy Error',e.message)
+ else:
+ if self.newText != oldText:
+ self.undoRedoStack.add(editScriptAction(self,item,self.newText,oldText))
+ item.setScript(self.newText)
+ item.drawOnCanvas(self.mainCanvas,self.magnification)
+ self.bindItemEvents(item)
+ self.bindGlobalEvents()
+ elif isinstance(item,xasyText):
+ theText = tkSimpleDialog.askstring(title="Xasy - Text",prompt="Enter text to display:",initialvalue=item.label.text,parent=self.parent)
+ if theText != None and theText != "":
+ self.undoRedoStack.add(editLabelTextAction(self,item,theText,item.label.text))
+ item.label.text = theText
+ item.drawOnCanvas(self.mainCanvas,self.magnification)
+ self.bindItemEvents(item)
+ elif isinstance(item,xasyShape):
+ self.clearSelection()
+ self.clearHighlight()
+ self.itemBeingEdited = copy.deepcopy(item)
+ self.editor = xasyBezierEditor(self,item,self.mainCanvas)
+ self.updateSelection()
+ self.releaseLock()
+
+ def itemEditEvt(self,event):
+ if not self.inDrawingMode:
+ ID = self.mainCanvas.find_withtag(CURRENT)[0]
+ item = self.findItem(ID)
+ self.itemEdit(item)
+
+ def itemDrag(self,event):
+ x0,y0 = self.mainCanvas.canvasx(event.x),self.mainCanvas.canvasy(event.y)
+ x = x0/self.magnification
+ y = y0/self.magnification
+ if self.selectedButton not in [self.toolMoveButton,self.toolVertiMoveButton,self.toolHorizMoveButton]:
+ return
+ if "selectedItem" in self.mainCanvas.gettags(CURRENT):
+ self.amDragging = True
+ for ID in self.mainCanvas.find_withtag("selectedItem"):
+ transform = identity()
+ if self.selectedButton == self.toolMoveButton:
+ translation = (x0-self.dragStartx,-(y0-self.dragStarty))
+ elif self.selectedButton == self.toolVertiMoveButton:
+ translation = (0,-(y0-self.dragStarty))
+ elif self.selectedButton == self.toolHorizMoveButton:
+ translation = (x0-self.dragStartx,0)
+ self.translateSomething(ID,(translation[0]/self.magnification,translation[1]/self.magnification))
+ self.mainCanvas.move(ID,translation[0],-translation[1])
+ self.updateSelection()
+ self.updateCanvasSize()
+ self.distanceDragged = (self.distanceDragged[0]+translation[0],self.distanceDragged[1]-translation[1])
+ self.dragStartx,self.dragStarty = x0,y0
+
+ def itemMouseUp(self,event):
+ self.freeMouseDown = True
+ if self.amDragging:
+ IDList = self.mainCanvas.find_withtag("selectedItem")
+ itemList = []
+ indexList = []
+ for ID in IDList:
+ item = self.findItem(ID)
+ if item not in itemList:
+ itemList.append(item)
+ try:
+ indexList.append([self.findItemImageIndex(item,ID)])
+ except:
+ indexList.append([None])
+ else:
+ indexList[itemList.index(item)].append(self.findItemImageIndex(item,ID))
+ self.undoRedoStack.add(translationAction(self,itemList,indexList,(self.distanceDragged[0],-self.distanceDragged[1])))
+ self.amDragging = False
+
+ def itemSelect(self,event):
+ x0,y0 = self.mainCanvas.canvasx(event.x),self.mainCanvas.canvasy(event.y)
+ x = x0/self.magnification
+ y = y0/self.magnification
+ self.dragStartx,self.dragStarty = x0,y0
+ self.distanceDragged = (0,0)
+ if self.selectedButton in [self.toolSelectButton,self.toolMoveButton,self.toolVertiMoveButton,self.toolHorizMoveButton,self.toolRotateButton]:
+ self.freeMouseDown = False
+ if self.selectedButton == self.toolSelectButton or (len(self.mainCanvas.find_withtag("selectedItem"))<=1 and self.selectedButton in [self.toolMoveButton,self.toolVertiMoveButton,self.toolHorizMoveButton,self.toolRotateButton]):
+ self.clearSelection()
+ self.setSelection(CURRENT)
+
+ def itemToggleSelect(self,event):
+ #print "control click"
+ x0,y0 = self.mainCanvas.canvasx(event.x),self.mainCanvas.canvasy(event.y)
+ x = x0/self.magnification
+ y = y0/self.magnification
+ if self.selectedButton in [self.toolSelectButton,self.toolMoveButton,self.toolVertiMoveButton,self.toolHorizMoveButton,self.toolRotateButton]:
+ self.freeMouseDown = False
+ self.dragStartx,self.dragStarty = x0,y0
+ if "selectedItem" in self.mainCanvas.gettags(CURRENT):
+ self.unSelect(CURRENT)
+ else:
+ self.setSelection(CURRENT)
+
+ def itemDelete(self,event):
+ if(not self.testOrAcquireLock()):
+ return
+ itemList = []
+ self.undoRedoStack.add(endActionGroup)
+ for ID in self.mainCanvas.find_withtag("selectedItem"):
+ item = self.findItem(ID)
+ if isinstance(item,xasyScript):
+ index = self.findItemImageIndex(item,ID)
+ if item not in itemList:
+ itemList.append([item,[index],[item.transform[index]]])
+ else:
+ x = None
+ for i in itemList:
+ if i[0] == item:
+ x = i
+ x[1].append(index)
+ x[2].append(item.transform[index])
+ self.deleteSomething(ID)
+ for entry in itemList:
+ self.undoRedoStack.add(deleteScriptItemAction(self,entry[0],entry[1],entry[2]))
+ self.undoRedoStack.add(beginActionGroup)
+ self.clearSelection()
+ self.releaseLock()
+
+ def itemMotion(self,event):
+ pass
+
+ def itemHighlight(self,event):
+ if self.selectedButton in [self.toolSelectButton] and self.editor == None:
+ box = self.mainCanvas.bbox(CURRENT)
+ box = (box[0]-2,box[1]-2,box[2]+2,box[3]+2)
+ if len(self.mainCanvas.find_withtag("highlightBox"))==0:
+ self.mainCanvas.create_rectangle(box,tags="highlightBox",width=2,outline="red")
+ else:
+ self.mainCanvas.tag_raise("highlightBox")
+ self.mainCanvas.coords("highlightBox",*box)
+ self.mainCanvas.tag_bind("highlightBox","<Leave>",self.itemUnHighlight)
+
+ def itemUnHighlight(self,event):
+ self.clearHighlight()
+
+ def clearHighlight(self):
+ self.mainCanvas.delete("highlightBox")
+
+ def itemLeftDown(self,event):
+ pass
+
+ def itemLeftUp(self,event):
+ pass
+
+ def itemRightDown(self,event):
+ pass
+
+ def itemRightUp(self,event):
+ pass
+
+ def canvMotion(self,event):
+ self.coords.config(
+ text="(%.3f,%.3f)"%(self.mainCanvas.canvasx(event.x)/self.magnification,-self.mainCanvas.canvasy(event.y)/self.magnification)
+ )
+
+ def addItemToFile(self,item):
+ self.fileItems.append(item)
+ self.propList.insert(0,self.describeItem(item))
+ self.updateCanvasSize()
+
+ def startDraw(self,event):
+ # don't start if we can't finish
+ if not self.testOrAcquireLock() and not self.inDrawingMode:
+ return
+ x0,y0 = self.mainCanvas.canvasx(event.x),self.mainCanvas.canvasy(event.y)
+ x = x0/self.magnification
+ y = y0/self.magnification
+ #self.mainCanvas.create_oval(x,y,x,y,width=5)
+ if self.selectedButton == self.toolDrawEllipButton:
+ pass
+ elif self.selectedButton == self.toolFillEllipButton:
+ pass
+ elif self.selectedButton == self.toolTextButton:
+ theText = tkSimpleDialog.askstring(title="Xasy - Text",prompt="Enter text to display:",initialvalue="",parent=self.parent)
+ if theText != None and theText != "":
+ theItem = xasyText(theText,(x,-y),asyPen(self.penColor,self.penWidth,self.penOptions))
+ theItem.drawOnCanvas(self.mainCanvas,self.magnification)
+ self.bindItemEvents(theItem)
+ self.addItemToFile(theItem)
+ self.undoRedoStack.add(addLabelAction(self,theItem))
+ self.releaseLock()
+ self.updateSelectedButton(self.toolSelectButton)
+ elif self.selectedButton in [self.toolDrawLinesButton,self.toolDrawBeziButton,self.toolDrawPolyButton,self.toolDrawShapeButton,self.toolFillPolyButton,self.toolFillShapeButton]:
+ self.inDrawingMode = True
+ try:
+ if len(self.itemBeingDrawn.path.nodeSet) == 0:
+ raise Exception
+ else:
+ if self.selectedButton in [self.toolDrawLinesButton,self.toolDrawPolyButton,self.toolFillPolyButton]:
+ self.itemBeingDrawn.appendPoint((x,-y),'--')
+ else:#drawBezi,drawShape,fillShape
+ self.itemBeingDrawn.appendPoint((x,-y),'..')
+ except:
+ path = asyPath()
+ if self.selectedButton == self.toolDrawLinesButton:
+ path.initFromNodeList([(x,-y),(x,-y)],['--'])
+ elif self.selectedButton == self.toolDrawBeziButton:
+ path.initFromNodeList([(x,-y),(x,-y)],['..'])
+ elif self.selectedButton == self.toolDrawPolyButton or self.selectedButton == self.toolFillPolyButton:
+ path.initFromNodeList([(x,-y),(x,-y),'cycle'],['--','--'])
+ elif self.selectedButton == self.toolDrawShapeButton or self.selectedButton == self.toolFillShapeButton:
+ path.initFromNodeList([(x,-y),(x,-y),'cycle'],['..','..'])
+ if self.selectedButton in [self.toolDrawLinesButton,self.toolDrawBeziButton,self.toolDrawPolyButton,self.toolDrawShapeButton]:
+ self.itemBeingDrawn = xasyShape(path,pen=asyPen(self.penColor,self.penWidth,self.penOptions))
+ else:
+ if self.penOptions.find("fillrule") != -1 or self.penOptions.find("evenodd") != -1 or self.penOptions.find("zerowinding") != -1:
+ options = self.penOptions
+ else:
+ options = "evenodd"
+ self.itemBeingDrawn = xasyFilledShape(path,pen=asyPen(self.penColor,self.penWidth,options))
+ self.itemBeingDrawn.drawOnCanvas(self.mainCanvas,self.magnification)
+ self.bindItemEvents(self.itemBeingDrawn)
+ self.mainCanvas.bind("<Motion>",self.extendDraw)
+
+ def extendDraw(self,event):
+ x0,y0 = self.mainCanvas.canvasx(event.x),self.mainCanvas.canvasy(event.y)
+ x = x0/self.magnification
+ y = y0/self.magnification
+ tags = self.mainCanvas.gettags("itemBeingDrawn")
+ self.itemBeingDrawn.setLastPoint((x,-y))
+ self.itemBeingDrawn.drawOnCanvas(self.mainCanvas,self.magnification)
+ self.canvMotion(event)
+
+ def endDraw(self,event):
+ if not self.inDrawingMode or self.itemBeingDrawn == None:
+ return
+ x0,y0 = self.mainCanvas.canvasx(event.x),self.mainCanvas.canvasy(event.y)
+ x = x0/self.magnification
+ y = y0/self.magnification
+ #if self.selectedButton in [self.toolDrawLinesButton,self.toolDrawPolyButton,self.toolFillPolyButton]:
+ #self.itemBeingDrawn.appendPoint((x,-y),'--')
+ #else:
+ #self.itemBeingDrawn.appendPoint((x,-y),'..')
+
+ #only needed for certain key bindings when startDraw is triggered right before an endDraw
+ #e.g.: single click: startDraw, double click: endDraw
+ self.itemBeingDrawn.removeLastPoint()
+ self.itemBeingDrawn.setLastPoint((x,-y))
+ self.itemBeingDrawn.drawOnCanvas(self.mainCanvas,self.magnification)
+ self.addItemToFile(self.itemBeingDrawn)
+ self.undoRedoStack.add(addDrawnItemAction(self,self.itemBeingDrawn))
+ self.itemBeingDrawn = None
+ self.mainCanvas.dtag("itemBeingDrawn","itemBeingDrawn")
+ self.mainCanvas.bind("<Motion>",self.canvMotion)
+ self.inDrawingMode = False
+ self.releaseLock()
+
+ def canvLeftDown(self,event):
+ #print "Left Mouse Down"
+ self.selectDragStart = (self.mainCanvas.canvasx(event.x),self.mainCanvas.canvasy(event.y))
+ theBbox = self.mainCanvas.bbox("selectedItem")
+ if theBbox != None:
+ self.selectBboxMidpoint = (theBbox[0]+theBbox[2])/2.0,-(theBbox[1]+theBbox[3])/2.0
+ if self.freeMouseDown and self.editor != None:
+ self.editor.endEdit()
+ if self.editor.modified:
+ self.undoRedoStack.add(editDrawnItemAction(self,self.itemBeingEdited,copy.deepcopy(self.editor.shape),self.fileItems.index(self.editor.shape)))
+ self.editor = None
+ elif self.selectedButton in (self.toolSelectButton,self.toolMoveButton,self.toolVertiMoveButton,self.toolHorizMoveButton,self.toolRotateButton):
+ if self.freeMouseDown:
+ self.clearSelection()
+ self.dragSelecting = False
+ else:
+ self.startDraw(event)
+
+ def canvLeftUp(self,event):
+ #print "Left Mouse Up"
+ # if we're busy, ignore it
+ if not self.testOrAcquireLock():
+ return
+ self.freeMouseDown = True
+ if self.inRotatingMode:
+ for item in self.itemsBeingRotated:
+ item.drawOnCanvas(self.mainCanvas,self.magnification)
+ self.bindItemEvents(item)
+ self.updateSelection()
+ self.itemsBeingRotated = []
+ self.inRotatingMode = False
+ if self.dragSelecting:
+ self.hideSelectionBox()
+ self.dragSelecting = False
+ self.mainCanvas.addtag_enclosed("enclosed",self.selectDragStart[0],self.selectDragStart[1],self.mainCanvas.canvasx(event.x),self.mainCanvas.canvasy(event.y))
+ for item in self.mainCanvas.find_withtag("enclosed"):
+ tags = self.mainCanvas.gettags(item)
+ if "drawn" not in tags and "image" not in tags:
+ self.mainCanvas.dtag(item,"enclosed")
+ self.mainCanvas.addtag_withtag("selectedItem","enclosed")
+ self.mainCanvas.dtag("enclosed","enclosed")
+ if self.selectedButton == self.toolSelectButton and len(self.mainCanvas.find_withtag("selectedItem")) > 0:
+ self.updateSelectedButton(self.toolMoveButton)
+ self.updateSelection()
+ self.releaseLock()
+
+ def canvDrag(self,event):
+ x0,y0 = self.mainCanvas.canvasx(event.x),self.mainCanvas.canvasy(event.y)
+ x = x0/self.magnification
+ y = y0/self.magnification
+ if self.selectedButton == self.toolSelectButton and self.editor == None:
+ self.mainCanvas.coords("outlineBox",self.selectDragStart[0],self.selectDragStart[1],x0,y0)
+ self.showSelectionBox()
+ self.dragSelecting = True
+ elif self.selectedButton == self.toolRotateButton and self.editor == None:
+ bbox = self.mainCanvas.bbox("selectedItem")
+ if bbox != None:
+ p1 = self.selectDragStart[0]-self.selectBboxMidpoint[0],-self.selectDragStart[1]-self.selectBboxMidpoint[1]
+ mp1 = math.sqrt(p1[0]**2+p1[1]**2)
+ p2 = x0-self.selectBboxMidpoint[0],-y0-self.selectBboxMidpoint[1]
+ mp2 = math.sqrt(p2[0]**2+p2[1]**2)
+ if mp1 != 0:
+ t1 = math.acos(p1[0]/mp1)
+ if p1[1] < 0:
+ t1 *= -1
+ else:
+ t1 = 0
+ if mp2 != 0:
+ t2 = math.acos(p2[0]/mp2)
+ if p2[1] < 0:
+ t2 *= -1
+ else:
+ t2 = 0
+ theta = t2-t1
+ self.selectDragStart = x0,y0
+ self.itemsBeingRotated = []
+ for ID in self.mainCanvas.find_withtag("selectedItem"):
+ self.rotateSomething(ID,theta,self.selectBboxMidpoint)
+ item = self.findItem(ID)
+ if not item in self.itemsBeingRotated:
+ self.itemsBeingRotated.append(item)
+ self.updateSelection()
+ self.updateCanvasSize()
+ if not self.inRotatingMode:
+ self.currentRotationAngle = theta
+ IDList = self.mainCanvas.find_withtag("selectedItem")
+ itemList = []
+ indexList = []
+ for ID in IDList:
+ item = self.findItem(ID)
+ if item not in itemList:
+ itemList.append(item)
+ try:
+ indexList.append([self.findItemImageIndex(item,ID)])
+ except:
+ indexList.append([None])
+ else:
+ indexList[itemList.index(item)].append(self.findItemImageIndex(item,ID))
+ self.undoRedoStack.add(rotationAction(self,itemList,indexList,self.currentRotationAngle,self.selectBboxMidpoint))
+ self.inRotatingMode = True
+ else:
+ self.currentRotationAngle += theta
+ self.undoRedoStack.undoStack[-1].angle = self.currentRotationAngle
+
+ def canvEnter(self,event):
+ self.freeMouseDown = True
+ event.widget.focus_set()
+
+ def canvLeave(self,event):
+ self.freeMouseDown = False
+
+ def canvRightDown(self,event):
+ pass
+ #print "Right Mouse Down"
+
+ def canvRightUp(self,event):
+ pass
+ #print "Right Mouse Up"
+
+ def configEvt(self,event):
+ self.updateCanvasSize()
+ self.sizePane()
+
+ def sizePane(self):
+ width = self.windowPane.winfo_width()-10
+ cwidth = min(int(0.87*self.windowPane.winfo_width()),width-75)
+ if self.paneVisible:
+ self.windowPane.paneconfigure(self.canvFrame,minsize=cwidth)
+ else:
+ self.windowPane.paneconfigure(self.canvFrame,minsize=width)
+ self.windowPane.paneconfigure(self.propFrame,minsize=75)
+
+ def togglePaneEvt(self,event):
+ self.paneVisible = not self.paneVisible
+ self.sizePane()
+
+ def popupDelete(self):
+ self.deleteItem(self.itemPopupMenu.item)
+
+ def popupEdit(self):
+ self.itemEdit(self.itemPopupMenu.item)
+
+ def popupViewCode(self):
+ tkMessageBox.showinfo("Item Code",self.itemPopupMenu.item.getCode())
+
+ def popupClearTransform(self):
+ self.undoRedoStack.add(clearItemTransformsAction(self,self.itemPopupMenu.item,copy.deepcopy(self.itemPopupMenu.item.transform)))
+ if isinstance(self.itemPopupMenu.item,xasyScript) or isinstance(self.itemPopupMenu.item,xasyText):
+ for i in range(len(self.itemPopupMenu.item.transform)):
+ self.itemPopupMenu.item.transform[i] = identity()
+ else:
+ self.itemPopupMenu.item.transform = [identity()]
+ self.popupRedrawItem()
+
+ def popupRedrawItem(self):
+ if not self.testOrAcquireLock():
+ return
+ self.clearSelection()
+ self.clearHighlight()
+ self.itemPopupMenu.item.drawOnCanvas(self.mainCanvas,self.magnification)
+ self.bindItemEvents(self.itemPopupMenu.item)
+ self.updateCanvasSize()
+ self.releaseLock()
+
+ def hidePopupMenu(self):
+ try:
+ self.itemPopupMenu.unpost()
+ except:
+ pass
+
+ def itemMenuPopup(self,parent,item,x,y):
+ self.hidePopupMenu()
+ self.itemPopupMenu = Menu(parent,tearoff=False)
+ self.itemPopupMenu.add_command(label="Edit",command=self.popupEdit)
+ self.itemPopupMenu.add_command(label="Clear Transforms",command=self.popupClearTransform)
+ self.itemPopupMenu.add_command(label="Redraw",command=self.popupRedrawItem)
+ self.itemPopupMenu.add_command(label="View code",command=self.popupViewCode)
+ self.itemPopupMenu.add_separator()
+ self.itemPopupMenu.add_command(label="Delete",command=self.popupDelete)
+ self.itemPopupMenu.item = item
+ #self.itemPopupMenu.bind("<Leave>",lambda a:self.itemPopupMenu.unpost())
+ #self.itemPopupMenu.bind("<FocusOut>",lambda a:self.itemPopupMenu.unpost())
+ self.itemPopupMenu.post(x,y)
+
+ def itemPropMenuPopup(self,event):
+ try:
+ item = self.fileItems[len(self.fileItems)-int(self.propList.curselection()[0])-1]
+ self.itemMenuPopup(self.propList,item,event.x_root,event.y_root)
+ except:
+ pass
+
+ def itemCanvasMenuPopup(self,event):
+ if self.selectedButton in (self.toolSelectButton,self.toolMoveButton,self.toolVertiMoveButton,self.toolHorizMoveButton,self.toolRotateButton):
+ try:
+ item = self.findItem(self.mainCanvas.find_withtag(CURRENT)[0])
+ except:
+ item = None
+ if item != None:
+ self.itemMenuPopup(self.mainCanvas,item,event.x_root,event.y_root)
+
+ def editOptions(self):
+ if(not self.testOrAcquireLock()):
+ return
+ self.releaseLock()
+ xasyOptionsDialog.xasyOptionsDlg(self.parent)
+ self.applyOptions()
+
+ def resetOptions(self):
+ xasyOptions.setDefaults()
+ self.applyOptions()
+
+ def applyPenWidth(self):
+ self.pendingPenWidthChange = None
+ if self.validatePenWidth():
+ old = self.penWidth
+ self.penWidth = float(self.penWidthEntry.get())
+ if old != self.penWidth:
+ self.showCurrentPen()
+
+ def validatePenWidth(self):
+ text = self.penWidthEntry.get()
+ try:
+ width = float(text)
+ if width <= 0:
+ return False
+ else:
+ return True
+ except:
+ return False
+
+ def showCurrentPen(self):
+ mag = 1
+ width = self.penWidth
+ while width > 10:
+ width /= 2
+ mag *= 2
+ self.penDisp.itemconfigure("penDisp",width=width,fill=self.tkPenColor)
+ self.penDisp.itemconfigure("penMag",text="x%d"%mag)
+ #apply the new pen to any selected items
+ IDs = self.mainCanvas.find_withtag("selectedItem")
+ madeAChange = False
+ for ID in IDs:
+ item = self.findItem(ID)
+ if not isinstance(item,xasyScript):
+ if not madeAChange:
+ self.undoRedoStack.add(endActionGroup)
+ madeAChange = True
+ if isinstance(item,xasyText):
+ temp = item.label.pen
+ item.label.pen = asyPen(self.penColor,self.penWidth,self.penOptions)
+ item.drawOnCanvas(self.mainCanvas,self.magnification)
+ self.bindItemEvents(item)
+ self.setSelection(item.imageList[0].IDTag)
+ self.undoRedoStack.add(editLabelPenAction(self,temp,asyPen(self.penColor,self.penWidth,self.penOptions),self.fileItems.index(item)))
+ else:
+ temp = copy.deepcopy(item)
+ item.pen = asyPen(self.penColor,self.penWidth,self.penOptions)
+ item.drawOnCanvas(self.mainCanvas,self.magnification)
+ self.undoRedoStack.add(editDrawnItemAction(self,temp,copy.deepcopy(item),self.fileItems.index(item)))
+ if madeAChange:
+ self.undoRedoStack.add(beginActionGroup)
+
+ def applyPenWidthEvt(self,event):
+ if not self.testOrAcquireLock():
+ return
+ self.applyPenWidth()
+ self.releaseLock()
+
+ def penWidthChanged(self,event):
+ if self.pendingPenWidthChange is not None:
+ self.penWidthEntry.after_cancel(self.pendingPenWidthChange)
+ self.pendingPenWidthChange = self.penWidthEntry.after(1000,self.applyPenWidth)
+
+ def applyPenOptEvt(self,event):
+ if not self.testOrAcquireLock():
+ return
+ self.applyPenOpt()
+ self.releaseLock()
+
+ def validatePenOpt(self):
+ try:
+ penTest = asyPen(self.penColor,self.penWidth,self.penOptEntry.get())
+ return True
+ except:
+ self.penOptEntry.select_range(0,END)
+ self.penOptEntry.delete(0,END)
+ self.penOptEntry.insert(END,"Invalid Pen Options")
+ self.penOptEntry.after(5000,self.clearInvalidOptEntry)
+ self.penOptions = ""
+ return False
+
+ def clearInvalidOptEntry(self):
+ self.penOptEntry.select_range(0,END)
+ self.penOptEntry.delete(0,END)
+
+ def applyPenOpt(self):
+ if self.validatePenOpt():
+ old = self.penOptions
+ self.penOptions = self.penOptEntry.get()
+ if old != self.penOptions:
+ self.showCurrentPen()
+
+ def undoOperation(self):
+ self.undoRedoStack.undo()
+
+ def redoOperation(self):
+ self.undoRedoStack.redo()
+
+ def resetStacking(self):
+ for item in self.fileItems:
+ self.raiseSomething(item,force=True)
diff --git a/Master/texmf-dist/asymptote/GUI/xasyOptions.py b/Master/texmf-dist/asymptote/GUI/xasyOptions.py
new file mode 100755
index 00000000000..4406687cbf4
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasyOptions.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# xasyOptions provides a mechanism for storing and restoring a user's
+# preferences.
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+###########################################################################
+
+import pickle
+import sys,os
+import errno
+
+defaultOptions = {
+ 'asyPath':'asy',
+ 'showDebug':False,
+ 'showGrid':False,
+ 'gridX':10,
+ 'gridY':10,
+ 'gridColor':'#eeeeee',
+ 'showAxes':True,
+ 'axisX':10,
+ 'axisY':10,
+ 'axesColor':'#cccccc',
+ 'tickColor':'#eeeeee',
+ 'defPenOptions':'',
+ 'defPenColor':'#000000',
+ 'defPenWidth':1.0,
+ 'externalEditor':''
+ }
+
+if sys.platform[:3] == "win":
+ defaultOptions['externalEditor'] = "notepad.exe"
+else:
+ defaultOptions['externalEditor'] = "emacs"
+
+
+options = defaultOptions.copy()
+
+def settingsFileLocation():
+ folder = ""
+ try:
+ folder = os.path.expanduser("~/.asy/")
+ except:
+ pass
+ return os.path.normcase(os.path.join(folder,"xasy.conf"))
+
+def setAsyPathFromWindowsRegistry():
+ try:
+ import _winreg as registry
+ #test both registry locations
+ try:
+ key = registry.OpenKey(registry.HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\Asymptote")
+ options['asyPath'] = registry.QueryValueEx(key,"Path")[0]+"\\asy.exe"
+ registry.CloseKey(key)
+ except:
+ key = registry.OpenKey(registry.HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Asymptote")
+ options['asyPath'] = registry.QueryValueEx(key,"InstallLocation")[0]+"\\asy.exe"
+ registry.CloseKey(key)
+ except:
+ #looks like asy is not installed or this isn't Windows
+ pass
+
+def setDefaults():
+ global options
+ options = defaultOptions.copy()
+ if sys.platform[:3] == 'win': #for windows, wince, win32, etc
+ setAsyPathFromWindowsRegistry()
+ save()
+
+def load():
+ global options
+ fileName = settingsFileLocation()
+ if not os.path.exists(fileName):
+ #make folder
+ thedir = os.path.dirname(fileName)
+ if not os.path.exists(thedir):
+ try:
+ os.makedirs(thedir)
+ except:
+ raise Exception,"Could not create configuration folder"
+ if not os.path.isdir(thedir):
+ raise Exception,"Configuration folder path does not point to a folder"
+ setDefaults()
+ try:
+ f = open(fileName,"rb")
+ newOptions = pickle.load(f)
+ for key in options.keys():
+ if type(newOptions[key]) != type(options[key]):
+ raise Exception,"Bad type for entry in xasy settings"
+ options = newOptions
+ except:
+ setDefaults()
+
+def save():
+ global options
+ fileName = settingsFileLocation()
+ try:
+ f = open(fileName,"wb")
+ pickle.dump(options,f)
+ f.close()
+ except:
+ raise Exception,"Error saving preferences"
+
+load()
+
+if __name__=='__main__':
+ print settingsFileLocation()
+ print "Current content"
+ load()
+ print "Setting defaults"
+ setDefaults()
+ save()
+ load()
+ options['showAxes'] = options['showGrid'] = False
+ save()
+ print "Set to False"
+ load()
+ options['showAxes'] = options['showGrid'] = True
+ save()
+ print "Set to True"
+ load()
+ print options
diff --git a/Master/texmf-dist/asymptote/GUI/xasyOptionsDialog.py b/Master/texmf-dist/asymptote/GUI/xasyOptionsDialog.py
new file mode 100755
index 00000000000..c3162e8673b
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasyOptionsDialog.py
@@ -0,0 +1,228 @@
+#!/usr/bin/env python
+###########################################################################
+#
+# xasyOptionsDialog implements a dialog window to allow users to edit
+# their preferences and specify program options
+#
+#
+# Author: Orest Shardt
+# Created: June 29, 2007
+#
+###########################################################################
+
+from Tkinter import *
+import xasyOptions
+import tkSimpleDialog
+import xasyColorPicker
+import tkMessageBox
+import tkFileDialog
+import tkColorChooser
+import os
+import sys
+
+class xasyOptionsDlg(tkSimpleDialog.Dialog):
+ """A dialog to interact with users about their preferred settings"""
+ def __init__(self,master=None):
+ tkSimpleDialog.Dialog.__init__(self,master,"xasy Options")
+
+ def body(self,master):
+ optFrame = Frame(master)
+ optFrame.grid(row=0,column=0,sticky=N+S+E+W)
+
+ asyGrp = LabelFrame(optFrame,text="Asymptote",padx=5,pady=5)
+ asyGrp.grid(row=0,column=0,sticky=E+W)
+ asyGrp.rowconfigure(0,weight=1)
+ asyGrp.rowconfigure(1,weight=1)
+ asyGrp.columnconfigure(0,weight=1)
+ asyGrp.columnconfigure(0,weight=2)
+ Label(asyGrp,text="Command").grid(row=0,column=0,sticky=W)
+ self.ap = Entry(asyGrp)
+ self.ap.insert(END,xasyOptions.options['asyPath'])
+ self.ap.grid(row=0,column=1,sticky=E+W)
+ Button(asyGrp,text="...",command=self.findAsyPath).grid(row=0,column=2,sticky=E+W)
+ self.showDebug = BooleanVar()
+ self.showDebug.set(xasyOptions.options['showDebug'])
+ self.sd = Checkbutton(asyGrp,text="Show debugging info in console",var=self.showDebug)
+ self.sd.grid(row=1,column=0,columnspan=2,sticky=W)
+
+ editGrp = LabelFrame(optFrame,text="External Editor",padx=5,pady=5)
+ editGrp.grid(row=1,column=0,sticky=E+W)
+ editGrp.rowconfigure(0,weight=1)
+ editGrp.rowconfigure(1,weight=1)
+ editGrp.columnconfigure(0,weight=1)
+ editGrp.columnconfigure(0,weight=2)
+ Label(editGrp,text="Program").grid(row=0,column=0,sticky=W)
+ self.ee = Entry(editGrp)
+ self.ee.insert(END,xasyOptions.options['externalEditor'])
+ self.ee.grid(row=0,column=1,sticky=E+W)
+ Button(editGrp,text="...",command=self.findEEPath).grid(row=0,column=2,sticky=E+W)
+
+ penGrp = LabelFrame(optFrame,text="Default Pen",padx=5,pady=5)
+ penGrp.grid(row=2,column=0,sticky=E+W)
+ penGrp.rowconfigure(0,weight=1)
+ penGrp.rowconfigure(1,weight=1)
+ penGrp.rowconfigure(2,weight=1)
+ penGrp.columnconfigure(1,weight=1)
+ Label(penGrp,text="Color").grid(row=0,column=0,sticky=E)
+ self.pc = xasyOptions.options['defPenColor']
+ Button(penGrp,text="Change",command=self.changePenColor).grid(row=0,column=1,sticky=W)
+ Label(penGrp,text="Width").grid(row=1,column=0,sticky=E)
+ self.pw = Entry(penGrp)
+ self.pw.insert(END,str(xasyOptions.options['defPenWidth']))
+ self.pw.grid(row=1,column=1,sticky=E+W)
+ Label(penGrp,text="Options").grid(row=2,column=0,sticky=E)
+ self.po = Entry(penGrp)
+ self.po.insert(END,xasyOptions.options['defPenOptions'])
+ self.po.grid(row=2,column=1,sticky=E+W)
+
+ dispGrp = LabelFrame(optFrame,text="Display Options",padx=5,pady=5)
+ dispGrp.grid(row=3,column=0,sticky=E+W)
+ dispGrp.rowconfigure(0,weight=1)
+ dispGrp.rowconfigure(1,weight=1)
+ dispGrp.rowconfigure(2,weight=1)
+ dispGrp.rowconfigure(3,weight=1)
+ dispGrp.columnconfigure(0,weight=1)
+ dispGrp.columnconfigure(1,weight=1)
+ dispGrp.columnconfigure(2,weight=1)
+ self.showAxes = BooleanVar()
+ self.showAxes.set(xasyOptions.options['showAxes'])
+ self.sa = Checkbutton(dispGrp,text="Show Axes",var=self.showAxes)
+ self.sa.grid(row=0,column=0,sticky=W)
+ self.ac = xasyOptions.options['axesColor']
+ Button(dispGrp,text="Color...",command=self.changeAxesColor).grid(row=1,column=0)
+ Label(dispGrp,text="x").grid(row=0,column=1,padx=5,sticky=E)
+ self.axs = Entry(dispGrp,width=6)
+ self.axs.insert(END,xasyOptions.options['axisX'])
+ self.axs.grid(row=0,column=2,sticky=W+E)
+ Label(dispGrp,text="y").grid(row=1,column=1,padx=5,sticky=E)
+ self.ays = Entry(dispGrp,width=6)
+ self.ays.insert(END,xasyOptions.options['axisY'])
+ self.ays.grid(row=1,column=2,sticky=W+E)
+
+ self.showGrid = BooleanVar()
+ self.showGrid.set(xasyOptions.options['showGrid'])
+ self.sg = Checkbutton(dispGrp,text="Show Grid",var=self.showGrid)
+ self.sg.grid(row=4,column=0,sticky=W)
+ self.gc = xasyOptions.options['gridColor']
+ Button(dispGrp,text="Color...",command=self.changeGridColor).grid(row=3,column=0)
+ Label(dispGrp,text="x").grid(row=2,column=1,padx=5,sticky=E)
+ self.gxs = Entry(dispGrp,width=6)
+ self.gxs.insert(END,xasyOptions.options['gridX'])
+ self.gxs.grid(row=2,column=2,sticky=W+E)
+ Label(dispGrp,text="y").grid(row=3,column=1,padx=5,sticky=E)
+ self.gys = Entry(dispGrp,width=6)
+ self.gys.insert(END,xasyOptions.options['gridY'])
+ self.gys.grid(row=3,column=2,sticky=W+E)
+
+ def findEEPath(self):
+ if sys.platform[:3] == 'win': #for windows, wince, win32, etc
+ file=tkFileDialog.askopenfile(filetypes=[("Programs","*.exe"),("All files","*")],title="Choose External Editor",parent=self)
+ else:
+ file=tkFileDialog.askopenfile(filetypes=[("All files","*")],title="Choose External Editor",parent=self)
+ if file != None:
+ name = os.path.abspath(file.name)
+ file.close()
+ self.ee.delete(0,END)
+ self.ee.insert(END,name)
+ self.validate()
+
+ def findAsyPath(self):
+ if sys.platform[:3] == 'win': #for windows, wince, win32, etc
+ file=tkFileDialog.askopenfile(filetypes=[("Programs","*.exe"),("All files","*")],title="Find Asymptote Executable",parent=self)
+ else:
+ file=tkFileDialog.askopenfile(filetypes=[("All files","*")],title="Find Asymptote Executable",parent=self)
+ if file != None:
+ name = os.path.abspath(file.name)
+ file.close()
+ self.ap.delete(0,END)
+ self.ap.insert(END,name)
+ self.validate()
+
+ def getAColor(self,color):
+ result = xasyColorPicker.xasyColorDlg(self).getColor(xasyColorPicker.makeRGBfromTkColor(color))
+ return xasyColorPicker.RGB255hex(xasyColorPicker.RGBreal255(result))
+
+ def changeAxesColor(self):
+ self.ac = self.getAColor(self.ac)
+
+ def changeGridColor(self):
+ self.gc = self.getAColor(self.gc)
+
+ def changePenColor(self):
+ self.pc = self.getAColor(self.pc)
+
+ def apply(self):
+ xasyOptions.options['externalEditor'] = self.ee.get()
+ xasyOptions.options['asyPath'] = self.ap.get()
+ xasyOptions.options['showDebug'] = bool(self.showDebug.get())
+
+ xasyOptions.options['defPenColor'] = self.pc
+ xasyOptions.options['defPenWidth'] = float(self.pw.get())
+ xasyOptions.options['defPenOptions'] = self.po.get()
+
+ xasyOptions.options['showAxes'] = bool(self.showAxes.get())
+ xasyOptions.options['axesColor'] = self.ac
+ xasyOptions.options['tickColor'] = self.ac
+ xasyOptions.options['axisX'] = int(self.axs.get())
+ xasyOptions.options['axisY'] = int(self.ays.get())
+ xasyOptions.options['showGrid'] = bool(self.showGrid.get())
+ xasyOptions.options['gridColor'] = self.gc
+ xasyOptions.options['gridX'] = int(self.gxs.get())
+ xasyOptions.options['gridY'] = int(self.gys.get())
+ xasyOptions.save()
+
+ def validateAColor(self,color):
+ hexdigits = '0123456789abcdef'
+ if len(self.pc) != 7 or self.pc[0] != '#' or sum([1 for a in self.pc[1:] if a in hexdigits]) != 6:
+ return False
+ else:
+ return True
+
+ def validate(self):
+ """Validate the data entered into the dialog"""
+ #validate the color
+ hexdigits = '0123456789abcdef'
+ if not self.validateAColor(self.pc):
+ tkMessageBox.showerror("xasy Options","Invalid pen color.\r\n"+self.pc,parent=self)
+ return False
+ #validate the width
+ try:
+ test = float(self.pw.get())
+ except:
+ tkMessageBox.showerror("xasy Options","Pen width must be a number.",parent=self)
+ return False
+
+ #validate the options
+ #nothing to do
+
+ #validate the axis spacing
+ try:
+ test = int(self.axs.get())
+ test = int(self.ays.get())
+ except:
+ tkMessageBox.showerror("xasy Options","Axes' x- and y-spacing must be numbers.",parent=self)
+ return False
+
+ #validate the grid spacing
+ try:
+ test = int(self.gxs.get())
+ test = int(self.gys.get())
+ except:
+ tkMessageBox.showerror("xasy Options","Grid's x- and y-spacing must be numbers.",parent=self)
+ return False
+
+ if not self.validateAColor(self.ac):
+ tkMessageBox.showerror("xasy Options","Invalid axis color.\r\n"+self.ac,parent=self)
+ return False
+
+ if not self.validateAColor(self.gc):
+ tkMessageBox.showerror("xasy Options","Invalid grid color.\r\n"+self.gc,parent=self)
+ return False
+
+ return True
+
+if __name__ == '__main__':
+ root = Tk()
+ xasyOptions.load()
+ d = xasyOptionsDlg(root)
+ print d.result
diff --git a/Master/texmf-dist/asymptote/GUI/xasyVersion.py b/Master/texmf-dist/asymptote/GUI/xasyVersion.py
new file mode 100755
index 00000000000..7349b08d046
--- /dev/null
+++ b/Master/texmf-dist/asymptote/GUI/xasyVersion.py
@@ -0,0 +1,2 @@
+#!/usr/bin/env python
+xasyVersion = "2.16"