ProgressBar.py

# -*- coding: utf-8 -*-
"""
$Id$

Copyright 2011 Lars Kruse <devel@sumpfralle.de>

This file is part of PyCAM.

PyCAM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

PyCAM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with PyCAM.  If not, see <http://www.gnu.org/licenses/>.
"""

import os
import time
import datetime

import pycam.Plugins



class ProgressBar(pycam.Plugins.PluginBase):

    UI_FILE = "progress_bar.ui"
    CATEGORIES = ["System"]

    def setup(self):
        if self.gui:
            box = self.gui.get_object("ProgressBox")
            box.unparent()
            self.core.register_ui("main_window", "Progress", box, 50)
            self.core.add_item("progress", lambda: ProgressGTK(self.core,
                    self.gui, self.log))
            show_progress_button = self.gui.get_object(
                    "ShowToolpathProgressButton")
            # TODO: move this setting somewhere else or rename it
            self.core.add_item("show_drill_progress",
                    show_progress_button.get_active,
                    show_progress_button.set_active)
        return True

    def teardown(self):
        if self.gui:
            self.core.unregister_ui("main_window",
                    self.gui.get_object("ProgressBox"))
        self.core.set("progress", None)


class ProgressGTK(object):

    _PROGRESS_STACK = []

    def __init__(self, core, gui, log):
        ProgressGTK._PROGRESS_STACK.append(self)
        import gtk
        self._finished = False
        self._gtk = gtk
        self._gui = gui
        self.log = log
        self.core = core
        self._cancel_requested = False
        self._start_time = 0
        self._multi_maximum = 0
        self._multi_counter = 0
        self._multi_base_text = ""
        self._last_gtk_events_time = None
        self._main_widget = self._gui.get_object("ProgressWidget")
        self._multi_widget = self._gui.get_object("MultipleProgressBar")
        self._cancel_button = self._gui.get_object("ProgressCancelButton")
        self._cancel_button.connect("clicked", self.cancel)
        self._progress_bar = self._gui.get_object("ProgressBar")
        self._progress_button = self._gui.get_object(
                "ShowToolpathProgressButton")
        self._start_time = time.time()
        self._progress_button.show()
        self._last_text = None
        self._last_percent = None
        self.update(text="", percent=0)
        self._cancel_button.set_sensitive(True)
        self._progress_button.hide()
        # enable "pulse" mode for a start (in case of unknown ETA)
        self._progress_bar.pulse()
        self._main_widget.show()
        self._multi_widget.hide()
        self._multi_widget.set_text("")
        self._multi_widget.set_fraction(0)
        self.core.emit_event("gui-disable")

    def set_multiple(self, count, base_text=None):
        if base_text:
            self._multi_base_text = base_text
        else:
            self._multi_base_text = ""
        self._multi_counter = 0
        if count > 1:
            self._multi_maximum = count
            self.update_multiple(increment=False)
        else:
            self._multi_maximum = 0

    def update_multiple(self, increment=True):
        if self._multi_maximum <= 1:
            self._multi_widget.hide()
            return
        self._multi_widget.show()
        if increment:
            self._multi_counter += 1
            self._progress_bar.set_fraction(0)
        if self._multi_base_text:
            text = "%s %d/%d" % (self._multi_base_text,
                    self._multi_counter + 1, self._multi_maximum)
        else:
            text = "%d/%d" % (self._multi_counter + 1, self._multi_maximum)
        self._multi_widget.set_text(text)
        self._multi_widget.set_fraction(min(1.0,
                float(self._multi_counter) / self._multi_maximum))

    def disable_cancel(self):
        self._cancel_button.set_sensitive(False)

    def cancel(self, widget=None):
        self._cancel_requested = True

    def finish(self):
        if self._finished:
            self.log.debug("Called progressbar 'finish' twice: %s" % self)
            return
        ProgressGTK._PROGRESS_STACK.remove(self)
        if ProgressGTK._PROGRESS_STACK:
            # restore the latest state of the previous progress
            current = ProgressGTK._PROGRESS_STACK[-1]
            current.update(text=current._last_text,
                    percent=current._last_percent)
            current.update_multiple(increment=False)
        else:
            # hide the widget
            self._main_widget.hide()
            self._multi_widget.hide()
            widget = self._main_widget
            while widget:
                if hasattr(widget, "resize_children"):
                    widget.resize_children()
                if hasattr(widget, "check_resize"):
                    widget.check_resize()
                widget = widget.get_parent()
            self.core.emit_event("gui-enable")
        self._finished = True

    def __del__(self):
        if not self._finished:
            self.finish()

    def update(self, text=None, percent=None):
        if text:
            self._last_text = text
        if percent:
            self._last_percent = percent
        if not percent is None:
            percent = min(max(percent, 0.0), 100.0)
            self._progress_bar.set_fraction(percent/100.0)
        if (not percent) and (self._progress_bar.get_fraction() == 0):
            # use "pulse" mode until we reach 1% of the work to be done
            self._progress_bar.pulse()
        # update the GUI
        current_time = time.time()
        # Don't update the GUI more often than once per second.
        # Exception: text-only updates
        # This restriction improves performance and reduces the
        # "snappiness" of the GUI.
        if (self._last_gtk_events_time is None) \
                or text \
                or (self._last_gtk_events_time + 0.5 <= current_time):
            # "estimated time of arrival" text
            time_estimation_suffix = " remaining ..."
            if self._progress_bar.get_fraction() > 0:
                total_fraction = (self._progress_bar.get_fraction() + self._multi_counter) / max(1, self._multi_maximum)
                total_fraction = max(0.0, min(total_fraction, 1.0))
                eta_full = (time.time() - self._start_time) / total_fraction
                if eta_full > 0:
                    eta_delta = eta_full - (time.time() - self._start_time)
                    eta_delta = int(round(eta_delta))
                    if hasattr(self, "_last_eta_delta"):
                        previous_eta_delta = self._last_eta_delta
                        if eta_delta == previous_eta_delta + 1:
                            # We are currently toggling between two numbers.
                            # We want to avoid screen flicker, thus we just live
                            # with the slight inaccuracy.
                            eta_delta = self._last_eta_delta
                    self._last_eta_delta = eta_delta
                    eta_delta_obj = datetime.timedelta(seconds=eta_delta)
                    eta_text = "%s%s" % (eta_delta_obj, time_estimation_suffix)
                else:
                    eta_text = None
            else:
                eta_text = None
            if not text is None:
                lines = [text]
            else:
                old_lines = self._progress_bar.get_text().split(os.linesep)
                # skip the time estimation line
                lines = [line for line in old_lines
                        if not line.endswith(time_estimation_suffix)]
            if eta_text:
                lines.append(eta_text)
            self._progress_bar.set_text(os.linesep.join(lines))
            # show the "show_tool_button" ("hide" is called in the progress decorator)
            # TODO: move "in_progress" somewhere else
            if self.core.get("toolpath_in_progress"):
                self._progress_button.show()
            while self._gtk.events_pending():
                self._gtk.main_iteration()
            if not text or (self._start_time + 5 < current_time):
                # We don't store the timining if the text was changed.
                # This is especially nice for the snappines during font
                # initialization. This exception is only valid for the first
                # five seconds of the operation.
                self._last_gtk_events_time = current_time
        # return if the user requested a break
        return self._cancel_requested