Prevent overflowing of marks off the screen. Also remove a lot of trailing spaces.Gtk3

Fix #3280.

1 files changed, 64 insertions, 61 deletions

diff --git a/stopwatch.py b/stopwatch.py
index 325d6d6..3b62340 100644
--- a/stopwatch.py
+++ b/stopwatch.py
@@ -16,7 +16,7 @@
 
 import dbus
 import gi
-from gi.repository import Gtk 
+from gi.repository import Gtk
 from gi.repository import Gdk
 from gi.repository import GObject
 from gi.repository import Pango
@@ -34,11 +34,11 @@ suspend = powerd.Suspend()
 class WatchModel():
     STATE_PAUSED = 1
     STATE_RUNNING = 2
-    
+
     RUN_EVENT = 1
     PAUSE_EVENT = 2
     RESET_EVENT = 3
-    
+
     _default_basestate = (0.0, STATE_PAUSED)
 
     def _trans(self, s, pack):
@@ -53,40 +53,40 @@ class WatchModel():
         self._history_lock = threading.RLock()
 
         self._view_listener = None  #This must be done before _update_state
-        
+
         handler2 = handler.copy("basestate")
-        
+
         self._base_state = dobject.HighScore(handler2, WatchModel._default_basestate,
                      float("-inf"), self._trans, dobject.float_translator)
-        
+
         self._state = ()
         self._update_state() #sets the state to the base_state
-    
+
         self._base_state.register_listener(self._basestate_cb)
         self._history.register_listener(self._history_cb)
-        
+
     def get_state(self):
         return self._state
-    
+
     def get_last_update_time(self):
         if len(self._history) > 0:
             lastevent = self._history.last()
             return lastevent[0]
         else:
             return float("-inf")
-        
+
     def reset(self, s, t):
         self._base_state.set_value(s, t)
         self._update_state()
-    
+
     def _basestate_cb(self, v, s):
         self._update_state()
         self._trigger()
-    
+
     def _history_cb(self, diffset):
         self._update_state()
         self._trigger()
-    
+
     def add_event_from_view(self, ev):
         self._history_lock.acquire()
         if ev not in self._history:
@@ -99,7 +99,7 @@ class WatchModel():
         # and produce an old event that is irrelevant.  This results in the
         # UI reaching an inconsistent state, with the button toggled off
         # but the clock still running.
-        
+
     def _update_state(self):
         self._logger.debug("_update_state")
         L = len(self._history)
@@ -135,7 +135,7 @@ class WatchModel():
             return True
         else:
             return False
-    
+
     def register_view_listener(self, L):
         self._logger.debug("register_view_listener ")
         self._view_listener = L
@@ -152,18 +152,18 @@ class OneWatchView():
         self._name_model = myname
         self._marks_model = mymarks
         self._timer = timer
-        
+
         self._update_lock = threading.Lock()
         self._state = None
         self._timeval = 0
 
         self._offset = self._timer.get_offset()
-        
+
         self._name = Gtk.Entry()
         self._name_changed_handler = self._name.connect('changed', self._name_cb)
         self._name_lock = threading.Lock()
         self._name_model.register_listener(self._update_name_cb)
-        
+
         check = Gtk.Image()
         check.set_from_file('check.svg')
         self._run_button = Gtk.ToggleButton(gettext("Start/Stop"))
@@ -178,14 +178,14 @@ class OneWatchView():
         self._reset_button.set_image(circle)
         self._reset_button.props.focus_on_click = False
         self._reset_button.connect('clicked', self._reset_cb)
-        
+
         x = Gtk.Image()
         x.set_from_file('x.svg')
         self._mark_button = Gtk.Button(gettext("Mark"))
         self._mark_button.set_image(x)
         self._mark_button.props.focus_on_click = False
         self._mark_button.connect('clicked', self._mark_cb)
-        
+
         timefont = Pango.FontDescription()
         timefont.set_family("monospace")
         timefont.set_size(Pango.SCALE*14)
@@ -199,7 +199,7 @@ class OneWatchView():
         eb = Gtk.EventBox()
         eb.add(self._time_label)
         eb.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("white"))
-        
+
         self._should_update = threading.Event()
         self._is_visible = threading.Event()
         self._is_visible.set()
@@ -212,7 +212,7 @@ class OneWatchView():
         self.box.pack_start(self._reset_button, False, True, 0)
         self.box.pack_start(self._mark_button, False, True, 0)
         self.box.pack_end(eb, False, False, 6)
-        
+
         markfont = Pango.FontDescription()
         markfont.set_family("monospace")
         markfont.set_size(Pango.SCALE*10)
@@ -226,19 +226,22 @@ class OneWatchView():
         eb2 = Gtk.EventBox()
         eb2.add(self._marks_label)
         eb2.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("white"))
-        
+        self.scrolledwindow = Gtk.ScrolledWindow()
+        self.scrolledwindow.set_policy(Gtk.PolicyType.AUTOMATIC,
+                                       Gtk.PolicyType.NEVER)
+        self.scrolledwindow.add_with_viewport(eb2)
         filler0 = Gtk.VBox()
         filler0.pack_start(self.box, False, False, 0)
-        filler0.pack_start(eb2, False, False, 0)
-        
+        filler0.pack_start(self.scrolledwindow, False, False, 0)
+
         filler = Gtk.VBox()
         filler.pack_start(filler0, True, False, 0)
-        
+
         self.backbox = Gtk.EventBox()
         self.backbox.add(filler)
         self._black = Gdk.color_parse("black")
         self._gray = Gdk.Color(256*192, 256*192, 256*192)
-        
+
         self.display = Gtk.EventBox()
         self.display.add(self.backbox)
         #self.display.set_above_child(True)
@@ -248,11 +251,11 @@ class OneWatchView():
         self.display.add_events(Gdk.EventMask.ALL_EVENTS_MASK)
         self.display.connect('key-press-event', self._keypress_cb)
         #self.display.connect('key-release-event', self._keyrelease_cb)
-        
+
         self._watch_model.register_view_listener(self.update_state)
-        
+
         thread.start_new_thread(self._start_running, ())
-        
+
     def update_state(self, q):
         self._logger.debug("update_state: "+str(q))
         self._update_lock.acquire()
@@ -273,11 +276,11 @@ class OneWatchView():
             ev.wait()
             self._label_lock.release()
         self._update_lock.release()
-    
+
     def _update_name_cb(self, name):
         self._logger.debug("_update_name_cb " + name)
         thread.start_new_thread(self.update_name, (name,))
-    
+
     def update_name(self, name):
         self._logger.debug("update_name " + name)
         self._name_lock.acquire()
@@ -289,20 +292,20 @@ class OneWatchView():
         self._name.handler_unblock(self._name_changed_handler)
         self._name.set_editable(True)
         self._name_lock.release()
-            
+
     def _set_name(self, name, ev):
         self._name.set_text(name)
         ev.set()
         return False
-        
+
     def _format(self, t):
         return locale.format('%.2f', max(0,t))
-    
+
     def _update_label(self, string, ev):
         self._time_label.set_text(string)
         ev.set()
         return False
-    
+
     def _start_running(self):
         self._logger.debug("_start_running")
         ev = threading.Event()
@@ -317,7 +320,7 @@ class OneWatchView():
                 ev.wait()
                 time.sleep(0.07)
             self._label_lock.release()
-    
+
     def _run_cb(self, widget):
         t = time.time()
         self._logger.debug("run button pressed: " + str(t))
@@ -329,20 +332,20 @@ class OneWatchView():
             suspend.uninhibit()
         self._watch_model.add_event_from_view((self._timer.get_offset() + t, action))
         return True
-        
+
     def _set_run_button_active(self, v):
         self._run_button_lock.acquire()
         self._run_button.handler_block(self._run_handler)
         self._run_button.set_active(v)
         self._run_button.handler_unblock(self._run_handler)
         self._run_button_lock.release()
-            
+
     def _reset_cb(self, widget):
         t = time.time()
         self._logger.debug("reset button pressed: " + str(t))
         self._watch_model.add_event_from_view((self._timer.get_offset() + t, WatchModel.RESET_EVENT))
         return True
-    
+
     def _mark_cb(self, widget):
         t = time.time() + self._offset
         self._logger.debug("mark button pressed: " + str(t))
@@ -353,44 +356,44 @@ class OneWatchView():
         elif s == WatchModel.STATE_PAUSED:
             self._marks_model.add(tval)
         self._update_marks()
-    
+
     def _update_marks(self, diffset=None):
         L = list(self._marks_model)
         L.sort()
         s = [self._format(num) for num in L]
         p = " ".join(s)
         self._marks_label.set_text(p)
-    
+
     def _name_cb(self, widget):
         self._name_model.set_value(widget.get_text())
         return True
-        
+
     def pause(self):
         self._logger.debug("pause")
         self._is_visible.clear()
-    
+
     def resume(self):
         self._logger.debug("resume")
         self._is_visible.set()
-    
+
     def refresh(self):
         """Make sure display is up-to-date"""
         self._update_name_cb(self._name_model.get_value())
         thread.start_new_thread(self.update_state, (self._watch_model.get_state(),))
         self._update_marks()
-    
+
     def _got_focus_cb(self, widget, event):
         self._logger.debug("got focus")
         self.backbox.modify_bg(Gtk.StateType.NORMAL, self._black)
         self._name.modify_bg(Gtk.StateType.NORMAL, self._black)
         return True
-    
+
     def _lost_focus_cb(self, widget, event):
         self._logger.debug("lost focus")
         self.backbox.modify_bg(Gtk.StateType.NORMAL, self._gray)
         self._name.modify_bg(Gtk.StateType.NORMAL, self._gray)
         return True
-    
+
     # KP_End == check gamekey = 65436
     # KP_Page_Down == X gamekey = 65435
     # KP_Home == box gamekey = 65429
@@ -404,7 +407,7 @@ class OneWatchView():
         elif event.keyval == 65435:
             self._mark_button.clicked()
         return False
-            
+
 class GUIView():
     NUM_WATCHES = 9
 
@@ -426,39 +429,39 @@ class GUIView():
             self._markers.append(marks_model)
             watch_view = OneWatchView(watch_model, name_model, marks_model, timer)
             self._views.append(watch_view)
-            
+
         self.display = Gtk.VBox()
         for x in self._views:
             self.display.pack_start(x.display, True, True, 0)
-        
+
         self._pause_lock = threading.Lock()
-    
+
     def get_names(self):
         return [n.get_value() for n in self._names]
-    
+
     def set_names(self, namestate):
         for i in xrange(GUIView.NUM_WATCHES):
             self._names[i].set_value(namestate[i])
-    
+
     def get_state(self):
         return [(w.get_state(), w.get_last_update_time()) for w in self._watches]
-        
+
     def set_state(self,states):
         for i in xrange(GUIView.NUM_WATCHES):
             self._watches[i].reset(states[i][0], states[i][1])
             if self._watches[i].is_running():
                 suspend.inhibit()
-    
+
     def get_marks(self):
         return [list(m) for m in self._markers]
-    
+
     def set_marks(self, marks):
         for i in xrange(GUIView.NUM_WATCHES):
             self._markers[i].update(marks[i])
-    
+
     def get_all(self):
         return (self.timer.get_offset(), self.get_names(), self.get_state(), self.get_marks())
-    
+
     def set_all(self, q):
         self.timer.set_offset(q[0])
         self.set_names(q[1])
@@ -466,13 +469,13 @@ class GUIView():
         self.set_marks(q[3])
         for v in self._views:
             v.refresh()
-    
+
     def pause(self):
         self._pause_lock.acquire()
         for w in self._views:
             w.pause()
         self._pause_lock.release()
-    
+
     def resume(self):
         self._pause_lock.acquire()
         for w in self._views: