/[fenfire]/fenfire/org/fenfire/fenpdf/actions/mouse.py
ViewVC logotype

Diff of /fenfire/org/fenfire/fenpdf/actions/mouse.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.10 by tjl, Tue Oct 14 14:21:40 2003 UTC revision 1.11 by tjl, Thu Oct 23 19:09:56 2003 UTC
# Line 44  def defineActions(fenPDF, context): Line 44  def defineActions(fenPDF, context):
44      def getOldVS():      def getOldVS():
45          return fenPDF.animation.lastVs          return fenPDF.animation.lastVs
46    
47        def getOffset(node, x,y):
48            """ Get the text offset in screen coordinates if placeable
49            is textplaceable.
50            """
51            viewFunction = fenPDF.views.getMultiplexerNodeContentFunction()
52            placeable = viewFunction.f(fenPDF.fen.graph, node)
53            if isinstance(placeable, vob.lava.placeable.TextPlaceable):
54                cs = getMainNode().getNodeCS(getOldVS(), node)
55                ptsIn = jarray.array([x,y,0], 'f')
56                ptsOut = jarray.zeros(3, 'f')
57                getOldVS().coords.inverseTransformPoints3(cs, ptsIn, ptsOut)
58                offs = placeable.getCursorPos(ptsOut[0], ptsOut[1])
59                return offs
60    
61        def getOffsetXYY(node, canvasCS, offset):
62            """ Get the x, y top and t bottom of textplaceable offset
63            in canvas coordinates.
64            """
65            viewFunction = fenPDF.views.getMultiplexerNodeContentFunction()
66            placeable = viewFunction.f(fenPDF.fen.graph, node)
67            retArray = []
68            if isinstance(placeable, vob.lava.placeable.TextPlaceable):
69                cs = getMainNode().getNodeCS(getOldVS(), node)
70                xyy = jarray.zeros(3, 'f')
71                placeable.getCursorXYY(offset, xyy)
72                ptsIn = jarray.array([xyy[0],xyy[1],0], 'f')
73                ptsOut = jarray.zeros(3, 'f')
74                getOldVS().coords.transformPoints3(cs, ptsIn, ptsOut)
75                getOldVS().coords.inverseTransformPoints3(canvasCS, ptsOut, ptsOut)
76                retArray.append(ptsOut[0])
77                retArray.append(ptsOut[1])
78    
79                ptsIn = jarray.array([xyy[0],xyy[2],0], 'f')
80                getOldVS().coords.transformPoints3(cs, ptsIn, ptsOut)
81                getOldVS().coords.inverseTransformPoints3(canvasCS, ptsOut, ptsOut)
82                #retArray.append(ptsOut[0])
83                retArray.append(ptsOut[1])
84            return retArray
85            
86        def getTextWidthEdges(node, canvasCS):
87            """ Get left and rigth edges' coordinates of text placeable in
88            canvas coordinates.
89            """
90            viewFunction = fenPDF.views.getMultiplexerNodeContentFunction()
91            placeable = viewFunction.f(fenPDF.fen.graph, node)
92            retArray = []
93            if isinstance(placeable, vob.lava.placeable.TextPlaceable):
94                cs = getMainNode().getNodeCS(getOldVS(), node)
95                ptsOut = jarray.zeros(3, 'f')
96                ptsIn = jarray.array([0,0,0], 'f')
97                getOldVS().coords.transformPoints3(cs, ptsIn, ptsOut)
98                getOldVS().coords.inverseTransformPoints3(canvasCS, ptsOut, ptsOut)
99                retArray.append(ptsOut[0])
100    
101                ptsIn = jarray.array([placeable.getWidth(),0,0], 'f')
102                getOldVS().coords.transformPoints3(cs, ptsIn, ptsOut)
103                getOldVS().coords.inverseTransformPoints3(canvasCS, ptsOut, ptsOut)
104                retArray.append(ptsOut[0])
105            return retArray
106    
107  # Inside the action, we have the following symbols usable:  # Inside the action, we have the following symbols usable:
108  #  fenPDF - the main FenPDF object  #  fenPDF - the main FenPDF object
# Line 176  def defineActions(fenPDF, context): Line 235  def defineActions(fenPDF, context):
235              return self              return self
236          def set(self, node, x,y):          def set(self, node, x,y):
237              self.evX, self.evY = x, y              self.evX, self.evY = x, y
238              s = context.states              self.node = node
             self.node, self.pp, self.graph = node, s.ppActions, s.fen.graph  
239          def changedRelative(self, x,y):          def changedRelative(self, x,y):
240              f = getMainNode().getFocus()              f = getMainNode().getFocus()
241              fX, fY = f.getPanX(), f.getPanY()              fX, fY = f.getPanX(), f.getPanY()
242    
243              if self.node == None: raise 'No node!!!'              if self.node == None: raise 'No node!!!'
244    
245              g = self.graph              g = fenPDF.fen.graph
246              self.startPointX = ff.util.RDFUtil.getFloat(g, self.node, CANVAS2D.x)              self.startPointX = ff.util.RDFUtil.getFloat(g, self.node, CANVAS2D.x)
247              self.startPointY = ff.util.RDFUtil.getFloat(g, self.node, CANVAS2D.y)              self.startPointY = ff.util.RDFUtil.getFloat(g, self.node, CANVAS2D.y)
248              self.canvas =  fenPDF.structure.canvas2d.getCanvas(self.node)              self.canvas =  fenPDF.structure.canvas2d.getCanvas(self.node)
249    
250              fenPDF.events.eventHandler.eventGrabber = self.theUltimateEventGrabberUtilToMoveNodesWhereEver              grabber = ff.fenpdf.actions.eventgrabs.Grabber()
251    
252              # find out offset              # find out offset
253              viewFunction = fenPDF.views.getMultiplexerNodeContentFunction()              viewFunction = fenPDF.views.getMultiplexerNodeContentFunction()
254              placeable = viewFunction.f(fenPDF.fen.graph, self.node)              placeable = viewFunction.f(fenPDF.fen.graph, self.node)
255              if isinstance(placeable, vob.lava.placeable.TextPlaceable):              if isinstance(placeable, vob.lava.placeable.TextPlaceable):
                 p('text!')  
256                  cs = getMainNode().getNodeCS(getOldVS(), self.evX,self.evY)                  cs = getMainNode().getNodeCS(getOldVS(), self.evX,self.evY)
                 p('cs', cs)  
257                  ptsIn = jarray.array([self.evX,self.evY,0], 'f')                  ptsIn = jarray.array([self.evX,self.evY,0], 'f')
258                  ptsOut = jarray.zeros(3, 'f')                  ptsOut = jarray.zeros(3, 'f')
259                  getOldVS().coords.inverseTransformPoints3(cs, ptsIn, ptsOut)                  getOldVS().coords.inverseTransformPoints3(cs, ptsIn, ptsOut)
260                  offs = placeable.getCursorPos(ptsOut[0], ptsOut[1])                  offs = placeable.getCursorPos(ptsOut[0], ptsOut[1])
261                  p('offs', offs, ptsOut)                  if fenPDF.uistate.textScissors.isScissored(self.node, offs):
262                  if fenPDF.uistate.textScissor.isScissored(self.node, offs):                      fenPDF.uistate.textScissors.fixOffset()
263                      p('shoul scissor now...')                      node = ff.swamp.Nodes.N()
264                      p('implement the scissoring here ;)')                      enf = fenPDF.structure.ff \
265                              .deleteRegion(self.node,
266                                            fenPDF.uistate.textScissors.begin.offset,
267                                            fenPDF.uistate.textScissors.end.offset)
268                        fenPDF.structure.ff.setContent(node, enf)
269                        grabber = ff.fenpdf.actions.eventgrabs.TextCloud(
270                            fenPDF, self.canvas, self.node,
271                            fenPDF.uistate.textScissors.begin.offset,
272                            node)
273                        fenPDF.uistate.textScissors.clear()
274                    else:
275                        grabber = ff.fenpdf.actions.eventgrabs.NodeMoverActionGrabber(
276                            fenPDF, self.startPointX, self.startPointY, self.node, self.canvas)
277                else:
278                    grabber = ff.fenpdf.actions.eventgrabs.NodeMoverActionGrabber(
279                        fenPDF, self.startPointX, self.startPointY, self.node, self.canvas)
280                fenPDF.events.eventHandler.eventGrabber = grabber.getEventGrabber()
281                                            
             fenPDF.structure.canvas2d.removeNode(self.node)  
             self.nodeCS = None  
282              fenPDF.animation.noAnimation()              fenPDF.animation.noAnimation()
283              fenPDF.animation.regenerateVS()              fenPDF.animation.regenerateVS()
284    
# Line 230  def defineActions(fenPDF, context): Line 300  def defineActions(fenPDF, context):
300                  vob.AbstractUpdateManager.chg()                  vob.AbstractUpdateManager.chg()
301                  return                  return
302    
303              if ev.getType() == ev.MOUSE_DRAGGED:  
                 if dbg: p('drag')  
                 oldVS.coords.setTranslateParams(self.transCS, ev.getX(), ev.getY())  
             else:  
                 buoymanager = fenPDF.views.getBuoyManager()  
                 mainNode = buoymanager.findTopmostMainNode(oldVS, ev.getX(), ev.getY())  
                 if mainNode == None or not fenPDF.structure.canvas2d.isCanvas(mainNode.getPlane()):  
                     fenPDF.structure.canvas2d.placeOnCanvas(self.canvas, self.node, self.startPointX, self.startPointY)  
                 else:  
                     xy = mainNode.getXYHit(getOldVS(), ev.getX(), ev.getY())  
                     fenPDF.structure.canvas2d.placeOnCanvas(mainNode.getPlane(), self.node, xy[0], xy[1])  
                 # temporarily solution, flush drags away...  
                 fenPDF.events.mouse.mainMouse.flush()  
                 fenPDF.events.eventHandler.eventGrabber = None  
                 fenPDF.animation.regenerateVS()  
             vob.AbstractUpdateManager.chg()  
   
         def createFlyingNode(self,oldVS):  
             self.transCS = oldVS.translateCS(0,'NODE_CS', self.evX,self.evY)  
             viewFunction = fenPDF.views.getMultiplexerNodeContentFunction()  
             placeable = viewFunction.f(fenPDF.fen.graph, self.node)  
             self.nodeCS = oldVS.orthoBoxCS(self.transCS,  
                                            self.node, -1000,0,0, 1,1,  
                                            placeable.getWidth(),  
                                            placeable.getHeight())  
             placeable.place(oldVS, self.nodeCS)  
304    
305    
306    
# Line 264  def defineActions(fenPDF, context): Line 309  def defineActions(fenPDF, context):
309      class SelectArea(vob.mouse.MouseDragListener,      class SelectArea(vob.mouse.MouseDragListener,
310                       vob.mouse.MousePressListener):                       vob.mouse.MousePressListener):
311          def pressed(self, x,y):          def pressed(self, x,y):
312              """ dumb bersion of listener """              """ dumb version of listener """
313              return self              return self
314          def startDrag(self, x,y):          def startDrag(self, x,y):
315              self.oldxy = getMainNode().getXYHit(getOldVS(), x, y)              self.oldxy = getMainNode().getXYHit(getOldVS(), x, y)
316              p('old', self.oldxy)              self.node = getMainNode().getNodeOnPlane(getOldVS(), x,y)
317                offs = getOffset(self.node, x,y)
318                if dbg: p('old', self.oldxy, self.node, offs)
319                fenPDF.uistate.textScissors.setBegin(self.node, offs)
320          def drag(self, x, y):          def drag(self, x, y):
321                if self.node != None:
322                    offs = getOffset(self.node, x,y)
323                    fenPDF.uistate.textScissors.setEnd(self.node, offs)
324                    canvasCS = ff.view.CanvasView2D.getContainerCS(getOldVS(),
325                                                                   getMainNode().getBox2Screen())
326                    canvasCS = getOldVS().matcher.getCS(getMainNode().getBox2Screen(), 'AreaSelectingView_concat')
327                    if dbg: p(getOffsetXYY(self.node, canvasCS, offs))
328    
329              v = ff.util.lava.view.getView(getMainNode(), ff.view.AreaSelectingView2D)              v = ff.util.lava.view.getView(getMainNode(), ff.view.AreaSelectingView2D)
330              v.setCurrentPlane(getMainNode().getPlane())              v.setCurrentPlane(getMainNode().getPlane())
331              xy = getMainNode().getXYHit(getOldVS(), x,y)              xy = getMainNode().getXYHit(getOldVS(), x,y)
332              v.setArea(self.oldxy[0], self.oldxy[1], xy[0], xy[1])              if not fenPDF.uistate.textScissors.isScissored(self.node):
333                    v.setArea(self.oldxy[0], self.oldxy[1], xy[0], xy[1])
334                else:
335                    if dbg: p('begin',fenPDF.uistate.textScissors.begin.offset,
336                              'end', fenPDF.uistate.textScissors.end.offset)
337                    begin = getOffsetXYY(self.node, canvasCS,
338                                         fenPDF.uistate.textScissors.begin.offset)
339                    end = getOffsetXYY(self.node, canvasCS,
340                                       fenPDF.uistate.textScissors.end.offset)
341                    edge = getTextWidthEdges(self.node, canvasCS)
342                    v.setTextArea(begin[0], begin[1], begin[2],
343                                  end[0], end[1], end[2],
344                                  edge[0], edge[1])
345                
346              context.states.selection.setArea(              context.states.selection.setArea(
347                      (self.oldxy[0], self.oldxy[1], xy[0], xy[1]),                      (self.oldxy[0], self.oldxy[1], xy[0], xy[1]),
348                      getMainNode())                      getMainNode())

Legend:
Removed from v.1.10  
changed lines
  Added in v.1.11

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26