commit 99f8bdb3f0acb1d02e8b8f47ddc4cd9212485008 · cduck.me/drawsvg

+35 -6

drawSvg/widgets/drawing_javascript.py

···

       11
       11
        
                   this.model.on('change:_image', this.image_changed, this);

     

       12
       12
        
                   this.model.on('change:_mousemove_blocked', this.block_changed,

     

       13
       13
        
                                 this);

     

       14
       14
       +
                   this.model.on('change:frame_delay', this.delay_changed,

     

       15
       15
       +
                                 this);

     

       16
       16
       +
                   this.model.on('change:_frame_blocked', this.delay_changed,

     

       17
       17
       +
                                 this);

     

       18
       18
       +
                   this.model.on('change:disable', this.delay_changed,

     

       19
       19
       +
                                 this);

     

       20
       20
       +
                   this.delay_changed();

     

       14
       21
        
               },

     

       15
       22
        
               image_changed: function() {

     

       16
       23
        
                   this.container.innerHTML = this.model.get('_image');

     
···

       19
       26
        
                   this.register_events();

     

       20
       27
        
               },

     

       21
       28
        
               last_move: null,

     

       29
       29
       +
               last_mousemove_blocked: null,

     

       30
       30
       +
               last_timer: null,

     

       22
       31
        
               block_changed: function() {

     

       23
       32
        
                   var widget = this;

     

       24
       33
        
                   window.setTimeout(function() {

     

       25
       25
       -
                       if (!widget.model.get('_mousemove_blocked') && widget.last_move) {

     

       34
       34
       +
                       if (widget.model.get('_mousemove_blocked')

     

       35
       35
       +
                               != widget.last_mousemove_blocked && widget.last_move) {

     

       26
       36
        
                           widget.send_mouse_event('mousemove', widget.last_move);

     

       27
       37
        
                       }

     

       28
       38
        
                   }, 0);

     
···

       31
       41
        
                   this.last_move = null;

     

       32
       42
        
                   if (this.model.get('disable')) {

     

       33
       43
        
                       return;

     

       34
       34
       -
                   }

     

       35
       35
       -
                   if (this.model.get('throttle')) {

     

       36
       36
       -
                       this.model.set('_mousemove_blocked', true);

     

       37
       37
       -
                       this.model.save_changes();

     

       38
       44
        
                   }

     

       39
       45
        
       

     

       40
       46
        
                   this.cursor_point.x = e.clientX;

     
···

       63
       69
        
                       relatedTargetId: e.relatedTarget ? e.relatedTarget.id : null,

     

       64
       70
        
                   });

     

       65
       71
        
               },

     

       72
       72
       +
               delay_changed: function() {

     

       73
       73
       +
                   var widget = this;

     

       74
       74
       +
                   window.clearTimeout(widget.last_timer);

     

       75
       75
       +
                   if (widget.model.get('disable')) {

     

       76
       76
       +
                       return;

     

       77
       77
       +
                   }

     

       78
       78
       +
                   var delay = widget.model.get('frame_delay');

     

       79
       79
       +
                   if (delay > 0) {

     

       80
       80
       +
                       widget.last_timer = window.setTimeout(function() {

     

       81
       81
       +
                           widget.send_timed_event('timed');

     

       82
       82
       +
                       }, delay);

     

       83
       83
       +
                   }

     

       84
       84
       +
               },

     

       85
       85
       +
               send_timed_event: function(name) {

     

       86
       86
       +
                   if (this.model.get('disable')) {

     

       87
       87
       +
                       return;

     

       88
       88
       +
                   }

     

       89
       89
       +
       

     

       90
       90
       +
                   this.send({

     

       91
       91
       +
                       name: name,

     

       92
       92
       +
                   });

     

       93
       93
       +
               },

     

       66
       94
        
               register_events: function() {

     

       67
       95
        
                   var widget = this;

     

       68
       96
        
                   this.svg_view.addEventListener('mousedown', function(e) {

     
···

       71
       99
        
                   });

     

       72
       100
        
                   this.svg_view.addEventListener('mousemove', function(e) {

     

       73
       101
        
                       e.preventDefault();

     

       74
       74
       -
                       if (widget.model.get('_mousemove_blocked')) {

     

       102
       102
       +
                       if (widget.model.get('_mousemove_blocked')

     

       103
       103
       +
                               == widget.last_mousemove_blocked) {

     

       75
       104
        
                           widget.last_move = e;

     

       76
       105
        
                       } else {

     

       77
       106
        
                           widget.send_mouse_event('mousemove', e);

+32 -7

drawSvg/widgets/drawing_widget.py

···

       1
       1
        
       from ipywidgets import widgets

     

       2
       2
       -
       from traitlets import Unicode, Bool

     

       2
       2
       +
       from traitlets import Unicode, Bool, Int

     

       3
       3
        
       

     

       4
       4
        
       

     

       5
       5
        
       # Register front end javascript

     
···

       14
       14
        
           _view_module = Unicode('drawingview').tag(sync=True)

     

       15
       15
        
           _view_module_version = Unicode('0.1.0').tag(sync=True)

     

       16
       16
        
           _image = Unicode().tag(sync=True)

     

       17
       17
       -
           _mousemove_blocked = Bool(False).tag(sync=True)

     

       17
       17
       +
           _mousemove_blocked = Int(0).tag(sync=True)

     

       18
       18
       +
           _frame_blocked = Int(0).tag(sync=True)

     

       18
       19
        
           throttle = Bool(True).tag(sync=True)

     

       19
       20
        
           disable = Bool(False).tag(sync=True)

     

       21
       21
       +
           frame_delay = Int(-1).tag(sync=True)

     

       20
       22
        
       

     

       21
       21
       -
           def __init__(self, drawing, throttle=True, disable=False):

     

       23
       23
       +
           def __init__(self, drawing, throttle=True, disable=False, frame_delay=-1):

     

       22
       24
        
               '''

     

       23
       25
        
               DrawingWidget is an interactive Jupyter notebook widget.  It works

     

       24
       26
        
               similarly to displaying a Drawing as a cell output but DrawingWidget

     
···

       31
       33
        
                   throttle: If True, limit the rate of mousemove events.  For drawings

     

       32
       34
        
                       with many elements, this will significantly reduce lag.

     

       33
       35
        
                   disable: While True, mouse events will be disabled.

     

       36
       36
       +
                   frame_delay: If greater than or equal to zero, a timed callback will

     

       37
       37
       +
                       occur frame_delay milliseconds after the previous drawing

     

       38
       38
       +
                       update.

     

       34
       39
        
               '''

     

       35
       40
        
               super().__init__()

     

       36
       41
        
               self.throttle = throttle

     

       37
       42
        
               self.disable = disable

     

       43
       43
       +
               self.frame_delay = frame_delay

     

       38
       44
        
               self.drawing = drawing

     

       39
       45
        
               self.mousedown_callbacks = []

     

       40
       46
        
               self.mousemove_callbacks = []

     

       41
       47
        
               self.mouseup_callbacks = []

     

       48
       48
       +
               self.timed_callbacks = []

     

       42
       49
        
       

     

       43
       50
        
               self.on_msg(self._receive_msg)

     

       44
       51
        
       

     
···

       60
       67
        
           def _receive_msg(self, _, content, buffers):

     

       61
       68
        
               if not isinstance(content, dict):

     

       62
       69
        
                   return

     

       70
       70
       +
               name = content.get('name')

     

       63
       71
        
               callbacks = {

     

       64
       72
        
                   'mousedown': self.mousedown_callbacks,

     

       65
       73
        
                   'mousemove': self.mousemove_callbacks,

     

       66
       74
        
                   'mouseup': self.mouseup_callbacks,

     

       67
       67
       -
               }.get(content.get('name'), ())

     

       75
       75
       +
                   'timed': self.timed_callbacks,

     

       76
       76
       +
               }.get(name, ())

     

       68
       77
        
               try:

     

       69
       78
        
                   if callbacks:

     

       70
       70
       -
                       self._call_handlers(callbacks, content.get('x'),

     

       71
       71
       -
                                           content.get('y'), content)

     

       79
       79
       +
                       if name == 'timed':

     

       80
       80
       +
                           self._call_handlers(callbacks, content)

     

       81
       81
       +
                       else:

     

       82
       82
       +
                           self._call_handlers(callbacks, content.get('x'),

     

       83
       83
       +
                                               content.get('y'), content)

     

       72
       84
        
               finally:

     

       73
       73
       -
                   self._mousemove_blocked = False

     

       85
       85
       +
                   if name == 'timed':

     

       86
       86
       +
                       self._frame_blocked += 1

     

       87
       87
       +
                   else:

     

       88
       88
       +
                       self._mousemove_blocked += 1

     

       74
       89
        
       

     

       75
       90
        
       

     

       76
       91
        
           def mousedown(self, handler, remove=False):

     
···

       103
       118
        
               '''

     

       104
       119
        
               self._register_handler(

     

       105
       120
        
                   self.mouseup_callbacks, handler, remove=remove)

     

       121
       121
       +
       

     

       122
       122
       +
           def timed(self, handler, remove=False):

     

       123
       123
       +
               '''

     

       124
       124
       +
               Register (or unregister) a handler for the timed event.

     

       125
       125
       +
       

     

       126
       126
       +
               Arguments:

     

       127
       127
       +
                   remove: If True, unregister, otherwise register.

     

       128
       128
       +
               '''

     

       129
       129
       +
               self._register_handler(

     

       130
       130
       +
                   self.timed_callbacks, handler, remove=remove)

     

       106
       131
        
       

     

       107
       132
        
           def _register_handler(self, callback_list, handler, remove=False):

     

       108
       133
        
               if remove: