Coverage for C:\Repos\leo-editor\leo\plugins\qt_idle_time.py: 23%

56 statements  

« prev     ^ index     » next       coverage.py v6.4, created at 2022-05-24 10:21 -0500

1# -*- coding: utf-8 -*- 

2#@+leo-ver=5-thin 

3#@+node:ekr.20140907103315.18777: * @file ../plugins/qt_idle_time.py 

4#@@first 

5"""Leo's Qt idle-time code.""" 

6import time 

7from leo.core import leoGlobals as g 

8from leo.core.leoQt import QtCore 

9#@+others 

10#@+node:ekr.20141028061518.24: ** class IdleTime 

11class IdleTime: 

12 """ 

13 A class that executes a handler with a given delay at idle time. The 

14 handler takes a single argument, the IdleTime instance:: 

15 

16 def handler(timer): 

17 \"""IdleTime handler. timer is an IdleTime instance.\""" 

18 delta_t = timer.time-timer.starting_time 

19 g.trace(timer.count,timer.c.shortFileName(),'%2.4f' % (delta_t)) 

20 if timer.count >= 5: 

21 g.trace('done') 

22 timer.stop() 

23 

24 # Execute handler every 500 msec. at idle time. 

25 timer = g.IdleTime(c,handler,delay=500) 

26 if timer: timer.start() 

27 

28 Timer instances are completely independent:: 

29 

30 def handler1(timer): 

31 delta_t = timer.time-timer.starting_time 

32 g.trace('%2s %s %2.4f' % (timer.count,timer.c.shortFileName(),delta_t)) 

33 if timer.count >= 5: 

34 g.trace('done') 

35 timer.stop() 

36 

37 def handler2(timer): 

38 delta_t = timer.time-timer.starting_time 

39 g.trace('%2s %s %2.4f' % (timer.count,timer.c.shortFileName(),delta_t)) 

40 if timer.count >= 10: 

41 g.trace('done') 

42 timer.stop() 

43 

44 timer1 = g.IdleTime(c,handler1,delay=500) 

45 timer2 = g.IdleTime(c,handler2,delay=1000) 

46 if timer1 and timer2: 

47 timer1.start() 

48 timer2.start() 

49 """ 

50 #@+others 

51 #@+node:ekr.20140825042850.18406: *3* IdleTime.__init__ 

52 def __init__(self, handler, delay=500, tag=None): 

53 """ctor for IdleTime class.""" 

54 # For use by handlers... 

55 self.count = 0 # The number of times handler has been called. 

56 self.starting_time = None # Time that the timer started. 

57 self.time = None # Time that the handle is called. 

58 self.tag = tag # An arbitrary string/object for use during debugging. 

59 # For use by the IdleTime class... 

60 # The argument to self.timer.start: 0 for idle time, otherwise a delay in msec. 

61 self.delay = delay 

62 self.enabled = False # True: run the timer continuously. 

63 self.handler = handler # The user-provided idle-time handler. 

64 self.waiting_for_idle = False # True if we have already waited for the minimum delay. 

65 # Create the timer, but do not fire it. 

66 self.timer = QtCore.QTimer() 

67 self.timer.timeout.connect(self.at_idle_time) 

68 # Add this instance to the global idle_timers.list. 

69 # This reference prevents this instance from being destroyed. 

70 g.app.idle_timers.append(self) 

71 #@+node:ekr.20140825102404.18525: *3* IdleTime.__repr__ 

72 def __repr__(self): 

73 """IdleTime repr.""" 

74 tag = self.tag 

75 if tag: 

76 return f"<IdleTime: {tag if isinstance(tag, str) else repr(tag)}>" 

77 return f"<IdleTime: id: {id(self)}>" 

78 

79 __str__ = __repr__ 

80 #@+node:ekr.20140825042850.18407: *3* IdleTime.at_idle_time 

81 def at_idle_time(self): 

82 """Call self.handler not more than once every self.delay msec.""" 

83 if g.app.killed: 

84 self.stop() 

85 elif self.enabled: 

86 if self.waiting_for_idle: 

87 # At idle time: call the handler. 

88 self.call_handler() 

89 # Requeue the timer with the appropriate delay. 

90 # 0 means wait until idle time. 

91 self.waiting_for_idle = not self.waiting_for_idle 

92 if self.timer.isActive(): 

93 self.timer.stop() 

94 self.timer.start(0 if self.waiting_for_idle else self.delay) 

95 elif self.timer.isActive(): 

96 self.timer.stop() 

97 #@+node:ekr.20140825042850.18408: *3* IdleTime.call_handler 

98 def call_handler(self): 

99 """Carefully call the handler.""" 

100 try: 

101 self.count += 1 

102 self.time = time.time() 

103 self.handler(self) 

104 except Exception: 

105 g.es_exception() 

106 self.stop() 

107 #@+node:ekr.20140825080012.18529: *3* IdleTime.destroy_self 

108 def destroy_self(self): 

109 """Remove the instance from g.app.idle_timers.""" 

110 if not g.app.killed and self in g.app.idle_timers: 

111 g.app.idle_timers.remove(self) 

112 #@+node:ekr.20140825042850.18409: *3* IdleTime.start & stop 

113 def start(self): 

114 """Start idle-time processing""" 

115 self.enabled = True 

116 if self.starting_time is None: 

117 self.starting_time = time.time() 

118 # Wait at least self.delay msec, then wait for idle time. 

119 self.last_delay = self.delay 

120 self.timer.start(self.delay) 

121 

122 def stop(self): 

123 """Stop idle-time processing. May be called during shutdown.""" 

124 self.enabled = False 

125 if hasattr(self, 'timer') and self.timer.isActive(): 

126 self.timer.stop() 

127 #@-others 

128#@-others 

129#@@language python 

130#@@tabwidth -4 

131#@@pagewidth 70 

132#@-leo