Changeset 415


Ignore:
Timestamp:
20.07.2011 15:46:09 (8 years ago)
Author:
marcus
Message:
  • refactoring
  • overlays now working correctly (picks and zoom window)
File:
1 edited

Legend:

Unmodified
Added
Removed
  • SHX/trunk/sandbox/traceplotter.py

    r414 r415  
    5858        self.parent = parent 
    5959        self.traces = Traces() 
    60         self.overlay = wx.Overlay() 
    61         self.ovPicks = wx.Overlay() 
     60        self.ZoomWindow = None 
    6261        self.refresh = False 
     62        self.AllowDoubleClick = True 
     63 
     64        # temporary layer for mouse motion 
     65        self.overlay_drag = wx.Overlay() 
     66        # layer for picks and zoom box 
     67        self.overlay_picks = wx.Overlay() 
    6368 
    6469        # application defaults 
     
    7681        self.Bind(wx.EVT_SIZE, self.OnPaint) 
    7782        self.Bind(wx.EVT_IDLE, self.OnIdle) 
    78         self.Bind(wx.EVT_MOTION, self.OnMotion) 
    79         self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp) 
    80         self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown) 
    81         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown) 
     83        self.Bind(wx.EVT_MOTION, self.OnMouseMotion) 
     84        self.Bind(wx.EVT_LEFT_UP, self.OnMouseLeftUp) 
     85        self.Bind(wx.EVT_LEFT_DCLICK, self.OnMouseLeftDouble) 
     86        self.Bind(wx.EVT_RIGHT_UP, self.OnMouseRightUp) 
     87        self.Bind(wx.EVT_RIGHT_DOWN, self.OnMouseRightDown) 
     88        self.Bind(wx.EVT_LEFT_DOWN, self.OnMouseLeftDown) 
    8289 
    8390    # event processing 
    84     def OnLeftDown(self, evt): 
     91    def OnMouseLeftDouble(self, evt): 
     92        """ 
     93        Remove phase. 
     94        """ 
     95        print "double" 
     96        trace, _ = self.ScreenToTraceAndTime(*(evt.GetPositionTuple())) 
     97        if trace: 
     98            self._debug("Delete phase") 
     99            del trace.shx.picks.manual[self.phasename] 
     100 
     101        evt.Skip() 
     102 
     103    def OnMouseLeftDown(self, evt): 
     104#        print "down", evt.ButtonDClick(wx.MOUSE_BTN_LEFT) 
     105        print "down", evt.ButtonDClick() 
    85106        self._captureMouse(evt) 
    86  
    87     def OnRightDown(self, evt): 
     107        evt.Skip() 
     108 
     109    def OnMouseRightDown(self, evt): 
    88110        self._captureMouse(evt) 
    89111 
    90     def OnMotion(self, evt): 
     112    def OnMouseMotion(self, evt): 
    91113        """ 
    92114        Mouse motion. 
     
    94116        x, y = evt.GetPositionTuple() 
    95117        trace, timestamp = self.ScreenToTraceAndTime(x, y) 
    96  
    97         # draw box 
    98         if evt.RightIsDown() and evt.Dragging(): 
    99             pass 
    100         # draw position line 
    101         elif evt.LeftIsDown() and evt.Dragging(): 
    102 #        else: 
    103             dc = wx.ClientDC(self) 
    104             odc = wx.DCOverlay(self.overlay, dc) 
    105             odc.Clear() 
    106             if trace: 
    107                 dc.SetPen(wx.Pen("Blue", 1)) 
    108                 dc.SetBrush(wx.TRANSPARENT_BRUSH) 
    109                 if self.traceOrder in [0, 1]: 
    110                     dc.DrawLine( 
    111                         x, trace.shx.midpoint - self.traceheight // 2, \ 
    112                         x, trace.shx.midpoint + self.traceheight // 2 
    113                     ) 
    114                 elif self.traceOrder in [2, 3]: 
    115                     dc.DrawLine( 
    116                         trace.shx.midpoint - self.traceheight // 2, y, 
    117                         trace.shx.midpoint + self.traceheight // 2, y 
    118                     ) 
    119             del odc 
    120118 
    121119        try: 
     
    128126        ) 
    129127 
     128        if evt.Dragging() and trace: 
     129            # new overlay for live display 
     130            dc = wx.ClientDC(self) 
     131            odc = wx.DCOverlay(self.overlay_drag, dc) 
     132            odc.Clear() 
     133            dc.SetBrush(wx.TRANSPARENT_BRUSH) 
     134 
     135            th2 = self.traceheight / 2 
     136            mpth2 = trace.shx.midpoint + th2 
     137            mmth2 = trace.shx.midpoint - th2 
     138 
     139            # draw box 
     140            if evt.RightIsDown(): 
     141                self.ZoomWindow = None 
     142                self.__zoombox(dc, self.dragStart, (x, y), trace.shx.midpoint, \ 
     143                                                                         size=2) 
     144            # draw position line 
     145            elif evt.LeftIsDown(): 
     146                dc.SetPen(wx.Pen("Blue", 1)) 
     147                if self.traceOrder in [0, 1]: 
     148                    dc.DrawLine( 
     149                        x, mmth2, \ 
     150                        x, mpth2 
     151                    ) 
     152                elif self.traceOrder in [2, 3]: 
     153                    dc.DrawLine( 
     154                        mmth2, y, 
     155                        mpth2, y 
     156                    ) 
     157            del odc 
     158 
    130159        # let the event propagate 
    131160        evt.Skip() 
    132161 
    133     def OnIdle(self, evt): 
    134         """ 
    135         Idle processing. Redraw is only triggered here not on PAINT event. 
    136         """ 
    137         if self.refresh: 
    138             self._drawTraces() 
    139             self._drawPicks() 
    140             self.refresh = False 
    141  
    142     def OnPaint(self, evt, renewOverlay=False): 
    143         """ 
    144         Called if redraw is requested. 
    145  
    146         Just set flag for redraw - execution triggered from IDLE event. In case 
    147         of resize renew overlay buffers. 
    148         """ 
    149         # if window was resized, renew overlay buffers 
    150         if evt and (renewOverlay or evt.GetEventType() == wx.EVT_SIZE.typeId): 
    151             self.overlay.Reset() 
    152             self.ovPicks.Reset() 
    153  
    154         # painting is only done in idle state 
    155         self.refresh = True 
    156  
    157     def OnTimeAxisChange(self, evt): 
    158         """ 
    159         Handle changes of time axis mode (absolute vs. relative time axis). 
    160         """ 
    161         recent = self.relativeAxis 
    162         self.relativeAxis = evt.GetString() == "relative" 
    163         if recent != self.relativeAxis: 
    164             self.OnPaint(evt, renewOverlay=True) 
    165  
    166     def OnTraceOrderChange(self, evt): 
    167         """ 
    168         Handle changes of trace plotting mode (horizontal vs. vertical modes). 
    169         """ 
    170         recent = self.traceOrder 
    171         self.traceOrder = evt.GetSelection() 
    172         if recent != self.traceOrder: 
    173             self.OnPaint(evt, renewOverlay=True) 
    174  
    175     def OnPhaseNameChange(self, evt): 
    176         """ 
    177         ... 
    178         """ 
    179         self.phasename = evt.GetString() 
    180  
    181     def OnLeftUp(self, evt): 
     162    def OnMouseRightUp(self, evt): 
     163        """ 
     164        Release of right mouse button. 
     165        """ 
     166        if self.HasCapture(): 
     167            self._releaseMouse(evt) 
     168            x, y = evt.GetPositionTuple() 
     169 
     170            trace, end = self.ScreenToTraceAndTime(x, y) 
     171            if self.traceOrder in [0, 1]: 
     172                _, start = self.ScreenToTraceAndTime(self.dragStart[0], y) 
     173            elif self.traceOrder in [2, 3]: 
     174                _, start = self.ScreenToTraceAndTime(x, self.dragStart[1]) 
     175 
     176            if start > end: 
     177                end, start = start, end 
     178 
     179            self.ZoomWindow = [trace, start, end,] 
     180            self.dragStart = None 
     181            self._drawPicksAndZoom() 
     182 
     183    def OnMouseLeftUp(self, evt): 
    182184        """ 
    183185        Release of left mouse button. 
    184186        """ 
    185187        if self.HasCapture(): 
    186             self.ReleaseMouse() 
     188            self._releaseMouse(evt) 
    187189            self.dragStart = None 
    188190 
     191#        print "up", evt.ButtonDClick(wx.MOUSE_BTN_LEFT) 
     192        print "up", evt.ButtonDClick() 
    189193        x, y = evt.GetPositionTuple() 
    190194        trace, timestamp = self.ScreenToTraceAndTime(x, y) 
     
    208212        self.parent.SetStatusText(msg) 
    209213        self._debug(msg) 
    210         self._drawPicks() 
     214        self._drawPicksAndZoom() 
     215 
     216    def OnIdle(self, evt): 
     217        """ 
     218        Idle processing. Redraw is only triggered here not on PAINT event. 
     219        """ 
     220        if self.refresh: 
     221            self._drawTraces() 
     222            self._drawPicksAndZoom() 
     223            self.refresh = False 
     224 
     225    def OnPaint(self, evt, renewOverlay=False): 
     226        """ 
     227        Called if redraw is requested. 
     228 
     229        Just set flag for redraw - execution triggered from IDLE event. In case 
     230        of resize renew overlay buffers. 
     231        """ 
     232        # if window was resized, renew overlay buffers 
     233        if evt and (renewOverlay or evt.GetEventType() == wx.EVT_SIZE.typeId): 
     234            self.overlay_picks.Reset() 
     235 
     236        # painting is only done in idle state 
     237        self.refresh = True 
     238 
     239    def OnTimeAxisChange(self, evt): 
     240        """ 
     241        Handle changes of time axis mode (absolute vs. relative time axis). 
     242        """ 
     243        recent = self.relativeAxis 
     244        self.relativeAxis = evt.GetString() == "relative" 
     245        if recent != self.relativeAxis: 
     246            self.OnPaint(evt, renewOverlay=True) 
     247 
     248    def OnTraceOrderChange(self, evt): 
     249        """ 
     250        Handle changes of trace plotting mode (horizontal vs. vertical modes). 
     251        """ 
     252        recent = self.traceOrder 
     253        self.traceOrder = evt.GetSelection() 
     254        if recent != self.traceOrder: 
     255            self.OnPaint(evt, renewOverlay=True) 
     256 
     257    def OnPhaseNameChange(self, evt): 
     258        """ 
     259        ... 
     260        """ 
     261        self.phasename = evt.GetString() 
    211262 
    212263    # helper functions 
     
    351402 
    352403    def _captureMouse(self, evt): 
     404        self._debug("_captureMouse") 
     405 
    353406        self.CaptureMouse() 
     407 
     408        dc = wx.ClientDC(self) 
     409        odc = wx.DCOverlay(self.overlay_drag, dc) 
     410        odc.Clear() 
     411 
    354412        self.dragStart = evt.GetPosition() 
    355413 
    356     def _drawPicks(self): 
     414    def _releaseMouse(self, evt): 
     415        self._debug("_releaseMouse") 
     416         
     417        self.ReleaseMouse() 
     418 
     419        # restore view 
     420        dc = wx.ClientDC(self) 
     421        odc = wx.DCOverlay(self.overlay_drag, dc) 
     422        odc.Clear() 
     423        del odc 
     424        self.overlay_drag.Reset() 
     425 
     426    def _drawPicksAndZoom(self): 
    357427        """ 
    358428        Draw picks. 
     
    372442                    ) 
    373443 
    374         if not _picks: 
     444        if not _picks and not self.ZoomWindow: 
    375445            return 
    376446 
    377         # XXX to get rid of the motion indicator 
    378         if len(_picks) == 1: 
    379             self.OnPaint(None) 
    380              
    381         # reset overlay for mouse motion indicator 
    382         self.overlay.Reset() 
    383  
    384447        dc = wx.ClientDC(self) 
    385         odc = wx.DCOverlay(self.ovPicks, dc) 
     448        odc = wx.DCOverlay(self.overlay_picks, dc) 
    386449        odc.Clear() 
    387450        dc.SetBrush(wx.TRANSPARENT_BRUSH) 
    388451 
    389452        th2 = self.traceheight / 2 
     453        # draw picks 
    390454        for pick in _picks: 
    391455            color = "Red" 
     
    403467                    pick[2][0] + th2, pick[2][1], 
    404468                ) 
     469                dc.DrawRotatedText(pick[1], pick[2][0]-th2+2, pick[2][1]-2, 90) 
     470 
     471        #draw zoom window 
     472        if self.ZoomWindow: 
     473            trace, start, end = self.ZoomWindow 
     474            start = self.TraceAndTimeToScreen(trace, start) 
     475            end = self.TraceAndTimeToScreen(trace, end) 
     476 
     477            self._debug("draw zoom window") 
     478            self.__zoombox(dc, start, end, trace.shx.midpoint, color="Blue") 
     479 
    405480        del odc 
    406481 
     
    579654        self.amplitude = amplitude 
    580655 
     656    def __zoombox(self, dc, start, end, midpoint, color="DARKORANGE", size=1): 
     657        marginfactor = 0.3 
     658        mf2 = (1-marginfactor)*2 
     659        th2 = self.traceheight / 2 
     660        offset = midpoint - th2 
     661 
     662        dc.SetPen(wx.Pen(color, size)) 
     663        if self.traceOrder in [0, 1]: 
     664            dc.DrawRectangle(start[0], offset + th2*marginfactor, \ 
     665                                                       end[0]-start[0], th2*mf2) 
     666        elif self.traceOrder in [2, 3]: 
     667            dc.DrawRectangle(offset + th2*marginfactor, start[1], \ 
     668                                                       th2*mf2, end[1]-start[1]) 
     669 
    581670class tracePlotter(wx.Frame): 
    582671    """ 
Note: See TracChangeset for help on using the changeset viewer.