Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add prototype progress dialog.

Browse Source 
svn: r8127
This commit is contained in:
Richard Taylor 2007-02-16 13:06:49 +00:00
parent d912167cab
commit 73344ccb1c
4 changed files with 354 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@ -1,3 +1,8 @@
2007-02-16 Richard Taylor <rjt-gramps@thegrindstone.me.uk>
* src/GrampsDb/__init__.py: add prototype progress dialog
* src/GrampsDb/_LongOpStatus.py: add prototype progress dialog
* src/ProgressDialog.py: add prototype progress dialog
2007-02-16 Richard Taylor <rjt-gramps@thegrindstone.me.uk>
* src/GrampsDb/_LongOpStatus.py: more work on long operation framework
* src/GrampsDb/_CursorIterator.py: more work on long operation framework

177
src/GrampsDb/_LongOpStatus.py
View File

@ -59,89 +59,122 @@ class LongOpStatus(GrampsDBCallback):
'op-end' : None
}
def __init__(self,msg="",total_steps=None,interval=1,can_cancel=False):
"""
@param msg: A Message to indicated the purpose of the operation.
@type msg: string
@param total_steps: The total number of steps that the operation
will perform.
@type total_steps:
@param interval: The number of iterations between emissions.
@type interval:
@param can_cancel: Set to True if the operation can be cancelled.
If this is set the operation that creates the status object should
check the 'should_cancel' method regularly so that it can cancel
the operation.
@type can_cancel:
"""
def __init__(self, msg="",
total_steps=None,
interval=1,
can_cancel=False):
"""
@param msg: A Message to indicated the purpose of the operation.
@type msg: string
@param total_steps: The total number of steps that the operation
will perform.
@type total_steps:
@param interval: The number of iterations between emissions.
@type interval:
@param can_cancel: Set to True if the operation can be cancelled.
If this is set the operation that creates the status object should
check the 'should_cancel' method regularly so that it can cancel
the operation.
@type can_cancel:
"""
GrampsDBCallback.__init__(self)
self._msg = msg
self._total = total_steps
self._interval = interval
self._can_cancel = can_cancel
self._cancel = False
self._count = 0
self._countdown = interval
self._secs_left = 0
self._start = time.time()
self._msg = msg
self._total_steps = total_steps
self._interval = interval
self._can_cancel = can_cancel
self._cancel = False
self._count = 0
self._countdown = interval
self._secs_left = 0
self._start = time.time()
def heartbeat(self):
"""This should be called for each step in the operation. It will
emit a 'op-heartbeat' every 'interval' steps. It recalcuates the
'estimated_secs_to_complete' from the time taken for previous
steps.
"""
self._countdown -= 1
if self._countdown <= 0:
elapsed = time.time() - self._start
self._secs_left = \
( elapsed / self._interval ) \
* (self._total - self._count)
self._count += self._interval
self._countdown = self._interval
self._start = time.time()
self.emit('op-heartbeat')
"""This should be called for each step in the operation. It will
emit a 'op-heartbeat' every 'interval' steps. It recalcuates the
'estimated_secs_to_complete' from the time taken for previous
steps.
"""
self._countdown -= 1
if self._countdown <= 0:
elapsed = time.time() - self._start
self._secs_left = \
( elapsed / self._interval ) \
* (self._total_steps - self._count)
self._count += self._interval
self._countdown = self._interval
self._start = time.time()
self.emit('op-heartbeat')
def estimated_secs_to_complete(self):
"""Return the number of seconds estimated left before operation
completes. This will change as 'hearbeat' is called.
@return: estimated seconds to complete.
@rtype: int
"""
return self._secs_left
"""Return the number of seconds estimated left before operation
completes. This will change as 'hearbeat' is called.
@return: estimated seconds to complete.
@rtype: int
"""
return self._secs_left
def cancel(self):
"""Inform the operation that it should complete.
"""
self._cancel = True
self.end()
"""Inform the operation that it should complete.
"""
self._cancel = True
self.end()
def end(self):
"""End the operation. Causes the 'op-end' signal to be emitted.
"""
self.emit('op-end')
"""End the operation. Causes the 'op-end' signal to be emitted.
"""
self.emit('op-end')
def should_cancel(self):
"""Returns true of the user has asked for the operation to be cancelled.
@return: True of the operation should be cancelled.
@rtype: bool
"""
return self._cancel
"""Returns true of the user has asked for the operation to be cancelled.
@return: True of the operation should be cancelled.
@rtype: bool
"""
return self._cancel
def can_cancel(self):
return self._can_cancel
"""@return: True if the operation can be cancelled.
@rtype: bool
"""
return self._can_cancel
def get_msg(self):
return msg
"""@return: The current status description messages.
@rtype: string
"""
return self._msg
def set_msg(self, msg):
self._msg = msg
def set_msg(self, msg):
"""Set the current description message.
@param msg: The description message.
@type msg: string
"""
self._msg = msg
def get_total_steps(self):
"""Get to total number of steps. NOTE: this is not the
number of times that the 'op-heartbeat' message will be
emited. 'op-heartbeat' is emited get_total_steps/interval
times.
@return: total number of steps.
@rtype: int
"""
return self._total_steps
def get_interval(self):
"""Get the interval between 'op-hearbeat' signals.
@return: the interval between 'op-hearbeat' signals.
@rtype: int
"""
return self._interval
if __name__ == '__main__':
@ -149,17 +182,17 @@ if __name__ == '__main__':
s = LongOpStatus("msg", 100, 10)
def heartbeat():
print "heartbeat ", s.estimated_secs_to_complete()
print "heartbeat ", s.estimated_secs_to_complete()
def end():
print "end"
print "end"
s.connect('op-heartbeat', heartbeat)
s.connect('op-end', end)
for i in xrange(0,99):
time.sleep(0.1)
s.heartbeat()
for i in xrange(0, 99):
time.sleep(0.1)
s.heartbeat()
s.end()

3
src/GrampsDb/__init__.py
View File

@ -50,3 +50,6 @@ from _GrampsDBCallback import GrampsDBCallback
from _DbUtils import *
import _GrampsDbConst as GrampsDbConst
from _LongOpStatus import LongOpStatus

241
src/ProgressDialog.py Normal file
View File

@ -0,0 +1,241 @@
"""
This module provides a progess dialog for displaying the status of
long running operations.
"""
import gtk
class _GtkProgressBar(object):
"""This is just a structure to hold the visual elements of a
progress indicator."""
def __init__(self):
self.pbar = None
self.label = None
self.pbar_max = 0
self.pbar_index = 0.0
self.old_val = -1
class _GtkProgressDialog(gtk.Dialog):
"""A gtk window to display the status of a long running
process."""
def __init__(self, title):
gtk.Dialog.__init__(self)
self.connect('delete_event', self.warn)
self.set_has_separator(False)
self.set_title(title)
self.set_border_width(12)
self.vbox.set_spacing(10)
lbl = gtk.Label('<span size="larger" weight="bold">%s</span>' % title)
lbl.set_use_markup(True)
self.vbox.pack_start(lbl)
#self.set_size_request(350,125)
self.set_resize_mode(gtk.RESIZE_IMMEDIATE)
self.show_all()
self._progress_bars = []
def add(self,long_op_status):
# Create a new progress bar
pbar = _GtkProgressBar()
pbar.lbl = gtk.Label(long_op_status.get_msg())
pbar.lbl.set_use_markup(True)
self.vbox.set_border_width(24)
pbar.pbar = gtk.ProgressBar()
self.vbox.pack_start(pbar.lbl, expand=False, fill=False)
self.vbox.pack_start(pbar.pbar, expand=False, fill=False)
if long_op_status.get_msg() == '':
pbar.lbl.hide()
pbar.pbar_max = (long_op_status.get_total_steps()/
long_op_status.get_interval())
pbar.pbar_index = 0.0
pbar.pbar.set_fraction((float(long_op_status.get_total_steps())/
(float(long_op_status.get_interval())))/
100.0)
pbar.lbl.show()
pbar.pbar.show()
self.resize_children()
self.process_events()
self._progress_bars.append(pbar)
return len(self._progress_bars)-1
def remove(self, pbar_idx):
pbar = self._progress_bars[pbar_idx]
self.vbox.remove(pbar.pbar)
self.vbox.remove(pbar.lbl)
del self._progress_bars[pbar_idx]
def step(self, pbar_idx):
"""Click the progress bar over to the next value. Be paranoid
and insure that it doesn't go over 100%."""
pbar = self._progress_bars[pbar_idx]
pbar.pbar_index = pbar.pbar_index + 1.0
if pbar.pbar_index > pbar.pbar_max:
pbar.pbar_index = pbar.pbar_max
try:
val = int(100*pbar.pbar_index/pbar.pbar_max)
except ZeroDivisionError:
val = 0
if val != pbar.old_val:
pbar.pbar.set_text("%d%%" % val)
pbar.pbar.set_fraction(val/100.0)
pbar.old_val = val
self.process_events()
def process_events(self):
while gtk.events_pending():
gtk.main_iteration()
def show(self):
gtk.Dialog.show(self)
self.process_events()
def hide(self):
gtk.Dialog.hide(self)
self.process_events()
def warn(self):
return True
def close(self):
self.destroy()
class _StatusObjectFacade(object):
"""This provides a simple structure for recording the information
needs about a status object."""
def __init__(self, status_obj, heartbeat_cb_id=None, end_cb_id=None):
self.status_obj = status_obj
self.heartbeat_cb_id = heartbeat_cb_id
self.end_cb_id = end_cb_id
self.pbar_idx = None
self.active = False
class ProgressDialog(object):
"""A dialog for displaying the status of long running operations.
It will work with L{GrampsDb.LongOpStatus} objects to track the
progress of long running operations. If the operations is going to
take longer than I{popup_time} it will pop up a dialog with a
progress bar so that the user gets some feedback about what is
happening.
"""
__default_popup_time = 5 # seconds
def __init__(self, popup_time = None):
self._popup_time = popup_time
if self._popup_time == None:
self._popup_time = self.__class__.__default_popup_time
self._status_stack = [] # list of current status objects
self._dlg = None
def _get_dlg(self):
if self._dlg == None:
self._dlg = _GtkProgressDialog("Long running operation.")
self._dlg.show()
return self._dlg
def add_op(self, op_status):
facade = _StatusObjectFacade(op_status)
self._status_stack.append(facade)
idx = len(self._status_stack)-1
# wrap up the op_status object idx into the callback calls
def heartbeat_cb():
self._heartbeat(idx)
def end_cb():
self._end(idx)
facade.heartbeat_cb_id = op_status.connect('op-heartbeat',
heartbeat_cb)
facade.end_cb_id = op_status.connect('op-end', end_cb)
def _heartbeat(self, idx):
# check the estimated time to complete to see if we need
# to pop up a progress dialog.
facade = self._status_stack[idx]
if facade.status_obj.estimated_secs_to_complete() > self._popup_time:
facade.active = True
if facade.active:
dlg = self._get_dlg()
if facade.pbar_idx == None:
facade.pbar_idx = dlg.add(facade.status_obj)
dlg.step(facade.pbar_idx)
def _end(self, idx):
# hide any progress dialog
# remove the status object from the stack
facade = self._status_stack[idx]
if facade.active:
dlg = self._get_dlg()
if len(self._status_stack) == 1:
dlg.hide()
dlg.remove(facade.pbar_idx)
facade.status_obj.disconnect(facade.heartbeat_cb_id)
facade.status_obj.disconnect(facade.end_cb_id)
del self._status_stack[idx]
if __name__ == '__main__':
import time
from GrampsDb import LongOpStatus
def test(a,b):
d = ProgressDialog()
s = LongOpStatus("Doing very long operation", 100, 10)
d.add_op(s)
for i in xrange(0, 99):
time.sleep(0.1)
if i == 30:
t = LongOpStatus("doing a shorter one", 100, 10)
d.add_op(t)
for j in xrange(0, 99):
time.sleep(0.1)
t.heartbeat()
t.end()
if i == 60:
t = LongOpStatus("doing another shorter one", 100, 10)
d.add_op(t)
for j in xrange(0, 99):
time.sleep(0.1)
t.heartbeat()
t.end()
s.heartbeat()
s.end()
w = gtk.Window(gtk.WINDOW_TOPLEVEL)
w.connect('destroy', gtk.main_quit)
button = gtk.Button("Test")
button.connect("clicked", test, None)
w.add(button)
button.show()
w.show()
gtk.main()
print 'done'