pydrizzle.traits102.trait

1 #------------------------------------------------------------------------------- 2 # 3 # Define the classes needed to implement and support the trait change 4 # notification mechanism. 5 # 6 # Written by: David C. Morrill 7 # 8 # Date: 06/21/2002 9 # 10 # Refactored into a separate module: 07/04/2003 11 # 12 # Symbols defined: TraitChangeNotifier 13 # EventChangeNotify 14 # TraitChangeNotifyWrapper 15 # StaticAnyTraitChangeNotifyWrapper 16 # StaticTraitChangeNotifyWrapper 17 # InstanceTraitNotifier 18 # ClassTraitNotifier 19 # SpecificTraitNotifier 20 # SpecificEventNotifier 21 # AnyAndSpecificTraitNotifier 22 # AnyAndSpecificEventNotifier 23 # 24 # (c) Copyright 2002, 2003 by Enthought, Inc. 25 # 26 #------------------------------------------------------------------------------- 27 28 #------------------------------------------------------------------------------- 29 # Imports: 30 #------------------------------------------------------------------------------- 31 from __future__ import division # confidence high 32 33 import traceback 34 35 from types import MethodType 36 from trait_base import TraitNotifier 37 from trait_delegates import TraitEvent 38 39 #------------------------------------------------------------------------------- 40 # 'TraitChangeNotifier' class: 41 #------------------------------------------------------------------------------- 42

43 -class TraitChangeNotifier:

44 45 #---------------------------------------------------------------------------- 46 # Initialize the object: 47 #---------------------------------------------------------------------------- 48

49 - def __init__ ( self, object, name, anytrait_notifiers ):

50 self.trait_notifiers = [] 51 self.anytrait_notifiers = anytrait_notifiers 52 cls = object.__class__ 53 cls_notifier = cls.__dict__.get( TraitNotifier ) 54 self.trait_notifier = self.anytrait_notifier = None 55 trait_notifier = getattr( cls, name + '_changed', None ) 56 if trait_notifier is not None: 57 if cls_notifier is not None: 58 notifier = cls_notifier.notifiers.get( name ) 59 if notifier is not None: 60 self.trait_notifier = notifier.notifier 61 if self.trait_notifier is None: 62 self.trait_notifier = StaticTraitChangeNotifyWrapper( 63 trait_notifier ) 64 anytrait_notifier = getattr( cls, 'anytrait_changed', None ) 65 if anytrait_notifier is not None: 66 if cls_notifier is not None: 67 self.anytrait_notifier = cls_notifier.anytrait_notifier 68 else: 69 self.anytrait_notifier = StaticAnyTraitChangeNotifyWrapper( 70 anytrait_notifier )

71 72 #---------------------------------------------------------------------------- 73 # Add a new handler: 74 #---------------------------------------------------------------------------- 75

76 - def add ( self, handler ):

77 trait_notifiers = self.trait_notifiers 78 for cur_notifier in trait_notifiers: 79 # NOTE: 'is' seems like it should work, but it doesn't: 80 #if handler is cur_notifier.handler: 81 if handler == cur_notifier.handler: 82 return 0 83 trait_notifiers.append( TraitChangeNotifyWrapper( handler ) ) 84 return 1

85 86 #---------------------------------------------------------------------------- 87 # Remove an existing handler: 88 #---------------------------------------------------------------------------- 89

90 - def remove ( self, handler ):

91 trait_notifiers = self.trait_notifiers 92 for cur_notifier in trait_notifiers: 93 # NOTE: 'is' seems like it should work, but it doesn't: 94 #if handler is cur_notifier.handler: 95 if handler == cur_notifier.handler: 96 trait_notifiers.remove( cur_notifier ) 97 return 1 98 return 0

99 100 #---------------------------------------------------------------------------- 101 # Set a new value on the object: 102 #---------------------------------------------------------------------------- 103

104 - def __call__ ( self, object, name, value, default ):

105 obj_dict = object.__dict__ 106 old_value = obj_dict.get( name, default ) 107 try: 108 if old_value != value: 109 obj_dict[ name ] = value 110 if self.trait_notifier is not None: 111 self.trait_notifier( object, name, old_value, value ) 112 for notifier in self.trait_notifiers[:]: 113 notifier( object, name, old_value, value ) 114 if self.anytrait_notifier is not None: 115 self.anytrait_notifier( object, name, old_value, value ) 116 for notifier in self.anytrait_notifiers[:]: 117 notifier( object, name, old_value, value ) 118 return value 119 else: 120 obj_dict[ name ] = value 121 return value 122 except: 123 obj_dict[ name ] = value 124 if self.trait_notifier is not None: 125 self.trait_notifier( object, name, old_value, value ) 126 for notifier in self.trait_notifiers[:]: 127 notifier( object, name, old_value, value ) 128 if self.anytrait_notifier is not None: 129 self.anytrait_notifier( object, name, old_value, value ) 130 for notifier in self.anytrait_notifiers[:]: 131 notifier( object, name, old_value, value ) 132 return value

133 134 #---------------------------------------------------------------------------- 135 # Set a new value on the object (with deferred notification): 136 #---------------------------------------------------------------------------- 137

138 - def deferred ( self, object, name, value, default ):

139 obj_dict = object.__dict__ 140 old_value = obj_dict.get( name, default ) 141 try: 142 if old_value != value: 143 obj_dict[ name ] = value 144 tnotifier = getattr( object, TraitNotifier ) 145 if self.trait_notifier is not None: 146 tnotifier.defer_notify( self.trait_notifier, object, name, 147 old_value, value ) 148 for notifier in self.trait_notifiers: 149 tnotifier.defer_notify( notifier, object, name, 150 old_value, value ) 151 if self.anytrait_notifier is not None: 152 tnotifier.defer_notify( self.anytrait_notifier, object, name, 153 old_value, value ) 154 for notifier in self.anytrait_notifiers: 155 tnotifier.defer_notify( notifier, object, name, 156 old_value, value ) 157 return value 158 else: 159 obj_dict[ name ] = value 160 return value 161 except: 162 obj_dict[ name ] = value 163 tnotifier = getattr( object, TraitNotifier ) 164 if self.trait_notifier is not None: 165 tnotifier.defer_notify( self.trait_notifier, object, name, 166 old_value, value ) 167 for notifier in self.trait_notifiers: 168 tnotifier.defer_notify( notifier, object, name, 169 old_value, value ) 170 if self.anytrait_notifier is not None: 171 tnotifier.defer_notify( self.anytrait_notifier, object, name, 172 old_value, value ) 173 for notifier in self.anytrait_notifiers: 174 tnotifier.defer_notify( notifier, object, name, 175 old_value, value ) 176 return value

177 178 #------------------------------------------------------------------------------- 179 # 'EventChangeNotifier' class: 180 #------------------------------------------------------------------------------- 181

182 -class EventChangeNotifier ( TraitChangeNotifier ):

183 184 #---------------------------------------------------------------------------- 185 # Set a new value on the object: 186 #---------------------------------------------------------------------------- 187

188 - def __call__ ( self, object, name, value, default ):

189 if self.trait_notifier is not None: 190 self.trait_notifier( object, name, None, value ) 191 for notifier in self.trait_notifiers[:]: 192 notifier( object, name, None, value ) 193 if self.anytrait_notifier is not None: 194 self.anytrait_notifier( object, name, None, value ) 195 for notifier in self.anytrait_notifiers[:]: 196 notifier( object, name, None, value ) 197 return value

198

199 - def deferred ( self, object, name, value, default ):

200 tnotifier = getattr( object, TraitNotifier ) 201 if self.trait_notifier is not None: 202 tnotifier.defer_notify( self.trait_notifier, object, name, 203 None, value ) 204 for notifier in self.trait_notifiers: 205 tnotifier.defer_notify( notifier, object, name, None, value ) 206 if self.anytrait_notifier is not None: 207 tnotifier.defer_notify( self.anytrait_notifier, object, name, 208 None, value ) 209 for notifier in self.anytrait_notifiers: 210 tnotifier.defer_notify( notifier, object, name, None, value ) 211 return value

212 213 #------------------------------------------------------------------------------- 214 # 'TraitChangeNotifyWrapper' class: 215 #------------------------------------------------------------------------------- 216

217 -class TraitChangeNotifyWrapper:

218

219 - def __init__ ( self, handler ):

220 self.handler = handler 221 adjust = 0 222 func = handler 223 if type( handler ) is MethodType: 224 func = handler.im_func 225 adjust = 1 226 self.__call__ = getattr( self, 'call_%d' % 227 (func.func_code.co_argcount - adjust) )

228

229 - def call_0 ( self, object, trait_name, old, new ):

230 try: 231 self.handler() 232 except: 233 traceback.print_exc()

234

235 - def call_1 ( self, object, trait_name, old, new ):

236 try: 237 self.handler( new ) 238 except: 239 traceback.print_exc()

240

241 - def call_2 ( self, object, trait_name, old, new ):

242 try: 243 self.handler( trait_name, new ) 244 except: 245 traceback.print_exc()

246

247 - def call_3 ( self, object, trait_name, old, new ):

248 try: 249 self.handler( object, trait_name, new ) 250 except: 251 traceback.print_exc()

252

253 - def call_4 ( self, object, trait_name, old, new ):

254 try: 255 self.handler( object, trait_name, old, new ) 256 except: 257 traceback.print_exc()

258 259 #------------------------------------------------------------------------------- 260 # 'StaticAnyTraitChangeNotifyWrapper' class: 261 #------------------------------------------------------------------------------- 262

263 -class StaticAnyTraitChangeNotifyWrapper:

264

265 - def __init__ ( self, handler ):

266 self.handler = handler 267 self.__call__ = getattr( self, 'call_%d' % 268 handler.func_code.co_argcount )

269

270 - def call_0 ( self, object, trait_name, old, new ):

271 try: 272 self.handler() 273 except: 274 traceback.print_exc()

275

276 - def call_1 ( self, object, trait_name, old, new ):

277 try: 278 self.handler( object ) 279 except: 280 traceback.print_exc()

281

282 - def call_2 ( self, object, trait_name, old, new ):

283 try: 284 self.handler( object, trait_name ) 285 except: 286 traceback.print_exc()

287

288 - def call_3 ( self, object, trait_name, old, new ):

289 try: 290 self.handler( object, trait_name, new ) 291 except: 292 traceback.print_exc()

293

294 - def call_4 ( self, object, trait_name, old, new ):

295 try: 296 self.handler( object, trait_name, old, new ) 297 except: 298 traceback.print_exc()

299 300 #------------------------------------------------------------------------------- 301 # 'StaticTraitChangeNotifyWrapper' class: 302 #------------------------------------------------------------------------------- 303

304 -class StaticTraitChangeNotifyWrapper:

305

306 - def __init__ ( self, handler ):

307 self.handler = handler 308 self.__call__ = getattr( self, 'call_%d' % 309 handler.func_code.co_argcount )

310

311 - def call_0 ( self, object, trait_name, old, new ):

312 try: 313 self.handler() 314 except: 315 traceback.print_exc()

316

317 - def call_1 ( self, object, trait_name, old, new ):

318 try: 319 self.handler( object ) 320 except: 321 traceback.print_exc()

322

323 - def call_2 ( self, object, trait_name, old, new ):

324 try: 325 self.handler( object, new ) 326 except: 327 traceback.print_exc()

328

329 - def call_3 ( self, object, trait_name, old, new ):

330 try: 331 self.handler( object, old, new ) 332 except: 333 traceback.print_exc()

334

335 - def call_4 ( self, object, trait_name, old, new ):

336 try: 337 self.handler( object, trait_name, old, new ) 338 except: 339 traceback.print_exc()

340 341 #------------------------------------------------------------------------------- 342 # 'InstanceTraitNotifier' class: 343 #------------------------------------------------------------------------------- 344

345 -class InstanceTraitNotifier:

346

347 - def __init__ ( self, object, class_notifier ):

348 TraitNotifier.__init__ ( self ) 349 self.object = object 350 self.deferrals = None 351 self.deferral_level = 0 352 self.active_notifiers = 0 353 self.notifiers = {} 354 self.anytrait_notifiers = [] 355 self.binder = InstanceTraitNotifierBinder( 356 self, '_notifier_for', 357 TraitChangeNotifier ) 358 self.event_binder = InstanceTraitNotifierBinder( 359 self, '_event_notifier_for', 360 EventChangeNotifier ) 361 if class_notifier is not None: 362 obj_id = id( object ) 363 info = class_notifier.deferrals.get( obj_id ) 364 if info is not None: 365 self.deferral_level, deferrals = info 366 self.deferrals = {} 367 for trait_name in deferrals.keys(): 368 notifiers, old_value, new_value = deferrals[ trait_name ] 369 for notifier in notifiers.values(): 370 self.defer_notify( notifier, object, trait_name, 371 old_value, new_value ) 372 del class_notifier.deferrals[ obj_id ]

373

374 - def _set_trait_value ( self, object, name, value, default ):

375 return self.notifiers.get( name, self.binder )( 376 object, name, value, default )

377

378 - def _set_trait_value_deferred ( self, object, name, value, default ):

379 return self.notifiers.get( name, self.binder ).deferred( 380 object, name, value, default )

381

382 - def _set_event_value ( self, object, name, value, default ):

383 return self.notifiers.get( name, self.event_binder )( 384 object, name, value, default )

385

386 - def _set_event_value_deferred ( self, object, name, value, default ):

387 return self.notifiers.get( name, self.event_binder ).deferred( 388 object, name, value, default )

389

390 - def add ( self, handler, name ):

391 if name == 'anytrait': 392 anytrait_notifiers = self.anytrait_notifiers 393 if len( anytrait_notifiers ) == 0: 394 notifiers = self.notifiers 395 for name, notifier in notifiers.items(): 396 if not isinstance( notifier, TraitChangeNotifier ): 397 mutates_to = TraitChangeNotifier 398 if isinstance( self.object._trait( name ).setter, 399 TraitEvent ): 400 mutates_to = EventChangeNotifier 401 notifiers[ name ] = mutates_to( 402 self.object, name, anytrait_notifiers ) 403 anytrait_notifiers.append( TraitChangeNotifyWrapper( handler ) ) 404 else: 405 notifier = self.notifiers.get( name, None ) 406 if not isinstance( notifier, TraitChangeNotifier ): 407 mutates_to = TraitChangeNotifier 408 if isinstance( self.object._trait( name ).setter, TraitEvent ): 409 mutates_to = EventChangeNotifier 410 self.notifiers[ name ] = notifier = mutates_to( 411 self.object, name, self.anytrait_notifiers ) 412 self.active_notifiers += notifier.add( handler )

413

414 - def remove ( self, handler, name ):

415 if name == 'anytrait': 416 anytrait_notifiers = self.anytrait_notifiers 417 for notifier in anytrait_notifiers: 418 # NOTE: 'is' seems like it should work, but it doesn't: 419 #if handler is notifier.handler: 420 if handler == notifier.handler: 421 anytrait_notifiers.remove( notifier ) 422 if len( anytrait_notifiers ) == 0: 423 object = self.object 424 if self.active_notifiers == 0: 425 self.move_deferrals_to_class() 426 else: 427 notifiers = self.notifiers 428 for name, notifier in notifiers.items(): 429 if len( notifier.trait_notifiers ) == 0: 430 notifiers[ name ] = object._notifier_for( name ) 431 else: 432 notifiers = self.notifiers 433 notifier = notifiers.get( name, None ) 434 if isinstance( notifier, TraitChangeNotifier ): 435 self.active_notifiers -= notifier.remove( handler ) 436 if ((len( notifier.trait_notifiers ) == 0) and 437 (len( self.anytrait_notifiers ) == 0)): 438 object = self.object 439 notifiers[ name ] = object._notifier_for( name ) 440 if self.active_notifiers == 0: 441 self.move_deferrals_to_class()

442

443 - def reset_trait_value ( self, object ):

444 obj_dict = object.__dict__ 445 if self.deferral_level == 0: 446 obj_dict[ '_set_trait_value' ] = self._set_trait_value 447 obj_dict[ '_set_event_value' ] = self._set_event_value 448 else: 449 obj_dict[ '_set_trait_value' ] = self._set_trait_value_deferred 450 obj_dict[ '_set_event_value' ] = self._set_event_value_deferred

451

452 - def defer_trait_change ( self, object, defer = True ):

453 if defer: 454 self.deferral_level += 1 455 if self.deferral_level == 1: 456 self.deferrals = {} 457 object._reset_trait_value() 458 else: 459 self.deferral_level -= 1 460 if self.deferral_level == 0: 461 deferrals = self.deferrals 462 for trait_name in deferrals.keys(): 463 notifiers, old_value, new_value = deferrals[ trait_name ] 464 for notifier in notifiers.values(): 465 notifier( object, trait_name, old_value, new_value ) 466 self.deferrals = None 467 object._reset_trait_value()

468

469 - def defer_notify ( self, notifier, object, trait_name, old, new ):

470 info = self.deferrals.setdefault( trait_name, [ {}, old, new ] ) 471 info[0].setdefault( id( notifier ), notifier ) 472 info[2] = new

473

474 - def move_deferrals_to_class ( self ):

475 object = self.object 476 del object.__dict__[ TraitNotifier ] 477 deferrals = self.deferrals 478 if deferrals is not None: 479 cls_notifier = object._class_notifier() 480 info = cls_notifier.deferrals.setdefault( id( object ), [ 0, {} ] ) 481 info[0] = self.deferral_level 482 for trait_name in deferrals.keys(): 483 notifiers, old_value, new_value = deferrals[ trait_name ] 484 for notifier in notifiers.values(): 485 cls_notifier.defer_notify( notifier, object, trait_name, 486 old_value, new_value ) 487 self.deferrals = None 488 self.object = self.notifiers = None 489 object._reset_trait_value()

490 491 #------------------------------------------------------------------------------- 492 # 'InstanceTraitNotifierBinder' class: 493 #------------------------------------------------------------------------------- 494

495 -class InstanceTraitNotifierBinder:

496

497 - def __init__ ( self, tnotifier, notifier_for, notifier_factory ):

498 self.tnotifier = tnotifier 499 self.notifier_for = getattr( tnotifier.object, notifier_for ) 500 self.notifier_factory = notifier_factory

501

502 - def __call__ ( self, object, name, value, default ):

503 tnotifier = self.tnotifier 504 if len( tnotifier.anytrait_notifiers ) == 0: 505 notifier = self.notifier_for( name ) 506 else: 507 notifier = self.notifier_factory( object, name, 508 tnotifier.anytrait_notifiers ) 509 tnotifier.notifiers[ name ] = notifier 510 return notifier( object, name, value, default )

511

512 - def deferred ( self, object, name, value, default ):

513 tnotifier = self.tnotifier 514 if len( tnotifier.anytrait_notifiers ) == 0: 515 notifier = self.notifier_for( name ) 516 else: 517 notifier = self.notifier_factory( object, name, 518 tnotifier.anytrait_notifiers ) 519 tnotifier.notifiers[ name ] = notifier 520 return notifier.deferred( object, name, value, default )

521 522 #------------------------------------------------------------------------------- 523 # 'ClassTraitNotifier' class: 524 #------------------------------------------------------------------------------- 525

526 -class ClassTraitNotifier:

527

528 - def __init__ ( self, cls ):

529 TraitNotifier.__init__( self ) 530 self.cls = cls 531 self.notifiers = {} 532 self.deferrals = {} 533 self.bind_factory = self.no_anytrait_changed 534 self.event_bind_factory = self.event_no_anytrait_changed 535 handler = getattr( cls, 'anytrait_changed', None ) 536 if handler is not None: 537 self.anytrait_notifier = StaticAnyTraitChangeNotifyWrapper( handler ) 538 self.bind_factory = self.has_anytrait_changed 539 self.event_bind_factory = self.event_has_anytrait_changed 540 self.binder = ClassTraitNotifierBinder( self.notifiers, 541 self.bind_factory ) 542 self.event_binder = ClassTraitNotifierBinder( self.notifiers, 543 self.event_bind_factory )

544

545 - def _set_trait_value ( self, object, name, value, default ):

546 return self.notifiers.get( name, self.binder )( 547 object, name, value, default )

548

549 - def _set_trait_value_deferred ( self, object, name, value, default ):

550 return self.notifiers.get( name, self.binder ).deferred( 551 object, name, value, default )

552

553 - def notifier_for ( self, name ):

554 notifier = self.notifiers.get( name, None ) 555 if notifier is None: 556 self.notifiers[ name ] = notifier = self.bind_factory( name ) 557 return notifier

558

559 - def no_anytrait_changed ( self, name ):

560 notifier = getattr( self.cls, name + '_changed', None ) 561 if notifier is None: 562 return simple_set_trait_value 563 return SpecificTraitNotifier( StaticTraitChangeNotifyWrapper( notifier ))

564

565 - def has_anytrait_changed ( self, name ):

566 notifier = getattr( self.cls, name + '_changed', None ) 567 if notifier is None: 568 return SpecificTraitNotifier( self.anytrait_notifier ) 569 return AnyAndSpecificTraitNotifier( self.anytrait_notifier, notifier )

570

571 - def _set_event_value ( self, object, name, value, default ):

572 return self.notifiers.get( name, self.event_binder )( 573 object, name, value, default )

574

575 - def _set_event_value_deferred ( self, object, name, value, default ):

576 return self.notifiers.get( name, self.event_binder ).deferred( 577 object, name, value, default )

578

579 - def event_notifier_for ( self, name ):

580 notifier = self.notifiers.get( name, None ) 581 if notifier is None: 582 self.notifiers[ name ] = notifier = self.event_bind_factory( name ) 583 return notifier

584

585 - def event_no_anytrait_changed ( self, name ):

586 notifier = getattr( self.cls, name + '_changed', None ) 587 if notifier is None: 588 return ignore_set_trait_value 589 return SpecificEventNotifier( StaticTraitChangeNotifyWrapper( notifier ))

590

591 - def event_has_anytrait_changed ( self, name ):

592 notifier = getattr( self.cls, name + '_changed', None ) 593 if notifier is None: 594 return SpecificEventNotifier( self.anytrait_notifier ) 595 return AnyAndSpecificEventNotifier( self.anytrait_notifier, notifier )

596

597 - def event_anytrait_changed ( self, object, name, value, default ):

598 self.anytrait_notifier( object, name, None, value ) 599 return value

600

601 - def reset_trait_value ( self, object ):

602 obj_dict = object.__dict__ 603 if self.deferrals.get( id( object ) ) is None: 604 obj_dict[ '_set_trait_value' ] = self._set_trait_value 605 obj_dict[ '_set_event_value' ] = self._set_event_value 606 else: 607 obj_dict[ '_set_trait_value' ] = self._set_trait_value_deferred 608 obj_dict[ '_set_event_value' ] = self._set_event_value_deferred

609

610 - def defer_trait_change ( self, object, defer = True ):

611 obj_id = id( object ) 612 if defer: 613 info = self.deferrals.setdefault( obj_id, [ 0, {} ] ) 614 info[0] += 1 615 if info[0] == 1: 616 object._reset_trait_value() 617 else: 618 info = self.deferrals.get( obj_id ) 619 if info is not None: 620 info[0] -= 1 621 if info[0] == 0: 622 deferrals = info[1] 623 for trait_name in deferrals.keys(): 624 notifiers, old_value, new_value = deferrals[ trait_name ] 625 for notifier in notifiers.values(): 626 notifier( object, trait_name, old_value, new_value ) 627 del self.deferrals[ obj_id ] 628 object._reset_trait_value()

629

630 - def defer_notify ( self, notifier, object, trait_name, old, new ):

631 info = self.deferrals[ id( object ) ][1].setdefault( trait_name, 632 [ {}, old, new ] ) 633 info[0].setdefault( id( notifier ), notifier ) 634 info[2] = new

635 636 #------------------------------------------------------------------------------- 637 # 'ClassTraitNotifierBinder' class: 638 #------------------------------------------------------------------------------- 639

640 -class ClassTraitNotifierBinder:

641

642 - def __init__ ( self, notifiers, bind_factory ):

643 self.notifiers = notifiers 644 self.bind_factory = bind_factory

645

646 - def __call__ ( self, object, name, value, default ):

647 self.notifiers[ name ] = notifier = self.bind_factory( name ) 648 return notifier( object, name, value, default )

649

650 - def deferred ( self, object, name, value, default ):

651 self.notifiers[ name ] = notifier = self.bind_factory( name ) 652 return notifier.deferred( object, name, value, default )

653 654 #------------------------------------------------------------------------------- 655 # 'SimpleSetTraitValue' class: 656 #------------------------------------------------------------------------------- 657

658 -class SimpleSetTraitValue:

659

660 - def __call__ ( self, object, name, value, default ):

661 object.__dict__[ name ] = value 662 return value

663

664 - def deferred ( self, object, name, value, default ):

665 object.__dict__[ name ] = value 666 return value

667 668 simple_set_trait_value = SimpleSetTraitValue() 669 670 #------------------------------------------------------------------------------- 671 # 'IgnoreSetTraitValue' class: 672 #------------------------------------------------------------------------------- 673

674 -class IgnoreSetTraitValue:

675

676 - def __call__ ( self, object, name, value, default ):

677 pass

678

679 - def deferred ( self, object, name, value, default ):

680 pass

681 682 ignore_set_trait_value = IgnoreSetTraitValue() 683 684 #------------------------------------------------------------------------------- 685 # 'SpecificTraitNotifier' class: 686 #------------------------------------------------------------------------------- 687

688 -class SpecificTraitNotifier:

689

690 - def __init__ ( self, notifier ):

691 self.notifier = notifier

692

693 - def __call__ ( self, object, name, value, default ):

694 obj_dict = object.__dict__ 695 old_value = obj_dict.get( name, default ) 696 try: 697 if old_value != value: 698 obj_dict[ name ] = value 699 self.notifier( object, name, old_value, value ) 700 return value 701 else: 702 obj_dict[ name ] = value 703 return value 704 except: 705 obj_dict[ name ] = value 706 self.notifier( object, name, old_value, value ) 707 return value

708

709 - def deferred ( self, object, name, value, default ):

710 obj_dict = object.__dict__ 711 old_value = obj_dict.get( name, default ) 712 try: 713 if old_value != value: 714 obj_dict[ name ] = value 715 getattr( object.__class__, TraitNotifier ).defer_notify( 716 self.notifier, object, name, old_value, value ) 717 return value 718 else: 719 obj_dict[ name ] = value 720 return value 721 except: 722 obj_dict[ name ] = value 723 getattr( object.__class__, TraitNotifier ).defer_notify( 724 self.notifier, object, name, old_value, value ) 725 return value

726 727 #------------------------------------------------------------------------------- 728 # 'SpecificEventNotifier' class: 729 #------------------------------------------------------------------------------- 730

731 -class SpecificEventNotifier:

732

733 - def __init__ ( self, notifier ):

734 self.notifier = notifier

735

736 - def __call__ ( self, object, name, value, default ):

737 self.notifier( object, name, None, value ) 738 return value

739

740 - def deferred ( self, object, name, value, default ):

741 getattr( object.__class__, TraitNotifier ).defer_notify( 742 self.notifier, object, name, None, value ) 743 return value

744 745 #------------------------------------------------------------------------------- 746 # 'AnyAndSpecificTraitNotifier' class: 747 #------------------------------------------------------------------------------- 748

749 -class AnyAndSpecificTraitNotifier:

750

751 - def __init__ ( self, anytrait_notifier, notifier ):

752 self.anytrait_notifier = anytrait_notifier 753 self.notifier = StaticTraitChangeNotifyWrapper( notifier )

754

755 - def __call__ ( self, object, name, value, default ):

756 obj_dict = object.__dict__ 757 old_value = obj_dict.get( name, default ) 758 try: 759 if old_value != value: 760 obj_dict[ name ] = value 761 self.notifier( object, name, old_value, value ) 762 self.anytrait_notifier( object, name, old_value, value ) 763 return value 764 else: 765 obj_dict[ name ] = value 766 return value 767 except: 768 obj_dict[ name ] = value 769 self.notifier( object, name, old_value, value ) 770 self.anytrait_notifier( object, name, old_value, value ) 771 return value

772

773 - def deferred ( self, object, name, value, default ):

774 obj_dict = object.__dict__ 775 old_value = obj_dict.get( name, default ) 776 try: 777 if old_value != value: 778 obj_dict[ name ] = value 779 tnotifier = getattr( object.__class__, TraitNotifier ) 780 tnotifier.defer_notify( self.notifier, object, name, 781 old_value, value ) 782 tnotifier.defer_notify( self.anytrait_notifier, object, name, 783 old_value, value ) 784 return value 785 else: 786 obj_dict[ name ] = value 787 return value 788 except: 789 obj_dict[ name ] = value 790 tnotifier = getattr( object.__class__, TraitNotifier ) 791 tnotifier.defer_notify( self.notifier, object, name, 792 old_value, value ) 793 tnotifier.defer_notify( self.anytrait_notifier, object, name, 794 old_value, value ) 795 return value

796 797 #------------------------------------------------------------------------------- 798 # 'AnyAndSpecificEventNotifier' class: 799 #------------------------------------------------------------------------------- 800

801 -class AnyAndSpecificEventNotifier:

802

803 - def __init__ ( self, anytrait_notifier, notifier ):

804 self.anytrait_notifier = anytrait_notifier 805 self.notifier = StaticTraitChangeNotifyWrapper( notifier )

806

807 - def __call__ ( self, object, name, value, default ):

808 self.notifier( object, name, None, value ) 809 self.anytrait_notifier( object, name, None, value ) 810 return value

811

812 - def deferred ( self, object, name, value, default ):

813 tnotifier = getattr( object.__class__, TraitNotifier ) 814 tnotifier.defer_notify( self.notifier, object, name, None, value ) 815 tnotifier.defer_notify( self.anytrait_notifier, object, name, 816 None, value ) 817 return value

818

Source Code for Module pydrizzle.traits102.trait_notifiers