[gnome-clocks] Coding style: do not use cameCase for variables
- From: Paolo Borelli <pborelli src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gnome-clocks] Coding style: do not use cameCase for variables
- Date: Sun, 16 Sep 2012 15:07:06 +0000 (UTC)
commit fcedbf485ecbe4643815fe6a048ef2eab5fe3966
Author: Paolo Borelli <pborelli gnome org>
Date: Sun Sep 16 17:02:35 2012 +0200
Coding style: do not use cameCase for variables
gnomeclocks/alarm.py | 59 ++++++++---------
gnomeclocks/app.py | 158 +++++++++++++++++++++++-----------------------
gnomeclocks/clocks.py | 6 +-
gnomeclocks/stopwatch.py | 70 ++++++++++----------
gnomeclocks/timer.py | 96 ++++++++++++++--------------
gnomeclocks/world.py | 8 +-
6 files changed, 197 insertions(+), 200 deletions(-)
---
diff --git a/gnomeclocks/alarm.py b/gnomeclocks/alarm.py
index 2c0d01c..9f7fa76 100644
--- a/gnomeclocks/alarm.py
+++ b/gnomeclocks/alarm.py
@@ -272,19 +272,16 @@ class AlarmWidget():
timestr = alarm.get_time_as_string()
repeat = alarm.get_alarm_repeat_string()
self.drawing = DigitalClockDrawing()
- isDay = self.get_is_day(int(timestr[:2]))
- if isDay:
+ is_light = self.get_is_light(int(timestr[:2]))
+ if is_light:
img = os.path.join(Dirs.get_image_dir(), "cities", "day.png")
else:
img = os.path.join(Dirs.get_image_dir(), "cities", "night.png")
- self.drawing.render(timestr, img, isDay, repeat)
+ self.drawing.render(timestr, img, is_light, repeat)
self.standalone = None
- def get_is_day(self, hours):
- if hours > 7 and hours < 19:
- return True
- else:
- return False
+ def get_is_light(self, hours):
+ return hours > 7 and hours < 19
def get_pixbuf(self):
return self.drawing.pixbuf
@@ -427,46 +424,46 @@ class StandaloneAlarm(Gtk.Box):
self.alert = alert
self.can_edit = True
- self.timebox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+ time_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.alarm_label = Gtk.Label()
self.alarm_label.set_alignment(0.5, 0.5)
- self.timebox.pack_start(self.alarm_label, True, True, 0)
+ time_box.pack_start(self.alarm_label, True, True, 0)
self.repeat_label = Gtk.Label()
self.repeat_label.set_alignment(0.5, 0.5)
- self.timebox.pack_start(self.repeat_label, True, True, 0)
+ time_box.pack_start(self.repeat_label, True, True, 0)
self.buttons = Gtk.Box()
- self.leftButton = Gtk.Button()
- self.leftButton.get_style_context().add_class("clocks-stop")
- self.leftButton.set_size_request(200, -1)
- self.leftLabel = Gtk.Label()
- self.leftButton.add(self.leftLabel)
- self.rightButton = Gtk.Button()
- self.rightButton.set_size_request(200, -1)
- self.rightLabel = Gtk.Label()
- self.rightButton.add(self.rightLabel)
-
- self.buttons.pack_start(self.leftButton, True, True, 0)
+ self.left_button = Gtk.Button()
+ self.left_button.get_style_context().add_class("clocks-stop")
+ self.left_button.set_size_request(200, -1)
+ self.left_label = Gtk.Label()
+ self.left_button.add(self.left_label)
+ self.right_button = Gtk.Button()
+ self.right_button.set_size_request(200, -1)
+ self.right_label = Gtk.Label()
+ self.right_button.add(self.right_label)
+
+ self.buttons.pack_start(self.left_button, True, True, 0)
self.buttons.pack_start(Gtk.Box(), True, True, 24)
- self.buttons.pack_start(self.rightButton, True, True, 0)
+ self.buttons.pack_start(self.right_button, True, True, 0)
- self.leftLabel.set_markup("<span font_desc=\"18.0\">%s</span>" % (_("Stop")))
- self.leftLabel.set_padding(6, 0)
- self.rightLabel.set_markup("<span font_desc=\"18.0\">%s</span>" % (_("Snooze")))
- self.rightLabel.set_padding(6, 0)
+ self.left_label.set_markup("<span font_desc=\"18.0\">%s</span>" % (_("Stop")))
+ self.left_label.set_padding(6, 0)
+ self.right_label.set_markup("<span font_desc=\"18.0\">%s</span>" % (_("Snooze")))
+ self.right_label.set_padding(6, 0)
- self.leftButton.connect('clicked', self._on_stop_clicked)
- self.rightButton.connect('clicked', self._on_snooze_clicked)
+ self.left_button.connect('clicked', self._on_stop_clicked)
+ self.right_button.connect('clicked', self._on_snooze_clicked)
- self.timebox.pack_start(self.buttons, True, True, 48)
+ time_box.pack_start(self.buttons, True, True, 48)
hbox = Gtk.Box()
hbox.set_homogeneous(False)
hbox.pack_start(Gtk.Label(), True, True, 0)
- hbox.pack_start(self.timebox, False, False, 0)
+ hbox.pack_start(time_box, False, False, 0)
hbox.pack_start(Gtk.Label(), True, True, 0)
self.pack_start(Gtk.Label(), True, True, 0)
diff --git a/gnomeclocks/app.py b/gnomeclocks/app.py
index 0a41725..7783597 100644
--- a/gnomeclocks/app.py
+++ b/gnomeclocks/app.py
@@ -200,81 +200,81 @@ class ClocksToolbar(Gtk.Toolbar):
self.views = views
self.embed = embed
- sizeGroup = Gtk.SizeGroup(Gtk.SizeGroupMode.HORIZONTAL)
+ size_group = Gtk.SizeGroup(Gtk.SizeGroupMode.HORIZONTAL)
- leftItem = Gtk.ToolItem()
- self.insert(leftItem, -1)
- sizeGroup.add_widget(leftItem)
+ left_item = Gtk.ToolItem()
+ self.insert(left_item, -1)
+ size_group.add_widget(left_item)
- leftBox = Gtk.Box()
- leftItem.add(leftBox)
+ left_box = Gtk.Box()
+ left_item.add(left_box)
# Translators: "New" refers to a world clock or an alarm
- self.newButton = Gtk.Button(_("New"))
- self.newButton.set_action_name("win.new")
- self.newButton.set_size_request(64, 34)
- leftBox.pack_start(self.newButton, False, False, 0)
+ self.new_button = Gtk.Button(_("New"))
+ self.new_button.set_action_name("win.new")
+ self.new_button.set_size_request(64, 34)
+ left_box.pack_start(self.new_button, False, False, 0)
- self.backButton = SymbolicButton("go-previous-symbolic")
- self.backButton.connect("clicked",
+ self.back_button = SymbolicButton("go-previous-symbolic")
+ self.back_button.connect("clicked",
lambda w: self.emit("view-clock", self.current_view))
- leftBox.pack_start(self.backButton, False, False, 0)
+ left_box.pack_start(self.back_button, False, False, 0)
- centerItem = Gtk.ToolItem()
- centerItem.set_expand(True)
- self.insert(centerItem, -1)
+ center_item = Gtk.ToolItem()
+ center_item.set_expand(True)
+ self.insert(center_item, -1)
- centerBox = Gtk.Box()
- centerItem.add(centerBox)
+ center_box = Gtk.Box()
+ center_item.add(center_box)
- self.buttonBox = Gtk.Box()
- self.buttonBox.set_homogeneous(True)
- self.buttonBox.set_halign(Gtk.Align.CENTER)
- self.buttonBox.get_style_context().add_class("linked")
- centerBox.pack_start(self.buttonBox, True, False, 0)
+ self.button_box = Gtk.Box()
+ self.button_box.set_homogeneous(True)
+ self.button_box.set_halign(Gtk.Align.CENTER)
+ self.button_box.get_style_context().add_class("linked")
+ center_box.pack_start(self.button_box, True, False, 0)
- self.viewsButtons = {}
+ self.view_buttons = {}
self.current_view = None
for view in views:
button = ClockButton(view.label)
- self.buttonBox.pack_start(button, True, True, 0)
+ self.button_box.pack_start(button, True, True, 0)
button.connect("toggled", self._on_toggled, view)
- self.viewsButtons[view] = button
- if view.hasSelectionMode:
+ self.view_buttons[view] = button
+ if view.has_selection_mode:
view.connect("notify::can-select", self._on_can_select_changed)
if view == views[0]:
self.current_view = view
button.set_active(True)
- self.titleLabel = Gtk.Label()
- self.titleLabel.set_halign(Gtk.Align.CENTER)
- self.titleLabel.set_valign(Gtk.Align.CENTER)
- centerBox.pack_start(self.titleLabel, True, False, 0)
+ self.title_label = Gtk.Label()
+ self.title_label.set_halign(Gtk.Align.CENTER)
+ self.title_label.set_valign(Gtk.Align.CENTER)
+ center_box.pack_start(self.title_label, True, False, 0)
- rightItem = Gtk.ToolItem()
- sizeGroup.add_widget(rightItem)
+ right_item = Gtk.ToolItem()
+ size_group.add_widget(right_item)
- rightBox = Gtk.Box()
- rightItem.add(rightBox)
- self.insert(rightItem, -1)
+ right_box = Gtk.Box()
+ right_item.add(right_box)
+ self.insert(right_item, -1)
- self.selectButton = SymbolicButton("object-select-symbolic")
- self.selectButton.set_sensitive(self.current_view.can_select)
- self.selectButton.connect('clicked', self._on_select_clicked)
- rightBox.pack_end(self.selectButton, False, False, 0)
+ self.select_button = SymbolicButton("object-select-symbolic")
+ self.select_button.set_sensitive(self.current_view.can_select)
+ self.select_button.connect('clicked', self._on_select_clicked)
+ right_box.pack_end(self.select_button, False, False, 0)
- self.editButton = Gtk.Button(_("Edit"))
- self.editButton.set_size_request(64, 34)
- self.editButton.connect('clicked', self._on_edit_clicked)
- rightBox.pack_end(self.editButton, False, False, 0)
+ self.edit_button = Gtk.Button(_("Edit"))
+ self.edit_button.set_size_request(64, 34)
+ self.edit_button.connect('clicked', self._on_edit_clicked)
+ right_box.pack_end(self.edit_button, False, False, 0)
- self.doneButton = Gtk.Button(_("Done"))
- self.doneButton.get_style_context().add_class('suggested-action')
- self.doneButton.set_size_request(64, 34)
- self.doneButton.connect("clicked", self._on_done_clicked)
- rightBox.pack_end(self.doneButton, False, False, 0)
+ self.done_button = Gtk.Button(_("Done"))
+ self.done_button.get_style_context().add_class('suggested-action')
+ self.done_button.set_size_request(64, 34)
+ self.done_button.connect("clicked", self._on_done_clicked)
+ right_box.pack_end(self.done_button, False, False, 0)
- self.selectionHandler = 0
+ self.selection_handler = 0
self.embed._selectionToolbar._toolbarDelete.connect("clicked", self._on_delete_clicked)
@@ -284,46 +284,46 @@ class ClocksToolbar(Gtk.Toolbar):
def activate_view(self, view):
if view is not self.current_view:
- self.viewsButtons[view].set_active(True)
+ self.view_buttons[view].set_active(True)
def show_overview_toolbar(self):
self.get_style_context().remove_class("selection-mode")
self.standalone = None
- self.buttonBox.show()
- self.newButton.set_visible(self.current_view.hasNew)
- self.selectButton.set_visible(self.current_view.hasSelectionMode)
- self.backButton.hide()
- self.titleLabel.hide()
- self.editButton.hide()
- self.doneButton.hide()
- if self.selectionHandler:
+ self.button_box.show()
+ self.new_button.set_visible(self.current_view.has_new)
+ self.select_button.set_visible(self.current_view.has_selection_mode)
+ self.back_button.hide()
+ self.title_label.hide()
+ self.edit_button.hide()
+ self.done_button.hide()
+ if self.selection_handler:
self.current_view.disconnect_by_func(self._on_selection_changed)
- self.selectionHandler = 0
+ self.selection_handler = 0
def show_standalone_toolbar(self, widget):
self.get_style_context().remove_class("selection-mode")
self.standalone = widget
- self.buttonBox.hide()
- self.newButton.hide()
- self.selectButton.hide()
- self.backButton.show_all()
- self.titleLabel.set_markup("<b>%s</b>" % self.standalone.get_name())
- self.titleLabel.show()
- self.editButton.set_visible(self.standalone.can_edit)
- self.doneButton.hide()
+ self.button_box.hide()
+ self.new_button.hide()
+ self.select_button.hide()
+ self.back_button.show_all()
+ self.title_label.set_markup("<b>%s</b>" % self.standalone.get_name())
+ self.title_label.show()
+ self.edit_button.set_visible(self.standalone.can_edit)
+ self.done_button.hide()
def show_selection_toolbar(self):
self.get_style_context().add_class("selection-mode")
self.standalone = None
- self.buttonBox.hide()
- self.newButton.hide()
- self.selectButton.hide()
- self.backButton.hide()
+ self.button_box.hide()
+ self.new_button.hide()
+ self.select_button.hide()
+ self.back_button.hide()
self.set_selection_label(0)
- self.titleLabel.show()
- self.editButton.hide()
- self.doneButton.show()
- self.selectionHandler = \
+ self.title_label.show()
+ self.edit_button.hide()
+ self.done_button.show()
+ self.selection_handler = \
self.current_view.connect("selection-changed",
self._on_selection_changed)
@@ -332,10 +332,10 @@ class ClocksToolbar(Gtk.Toolbar):
def set_selection_label(self, n):
if n == 0:
- self.titleLabel.set_markup("(%s)" % _("Click on items to select them"))
+ self.title_label.set_markup("(%s)" % _("Click on items to select them"))
else:
msg = ngettext("{0} item selected", "{0} items selected", n).format(n)
- self.titleLabel.set_markup("<b>%s</b>" % (msg))
+ self.title_label.set_markup("<b>%s</b>" % (msg))
def _on_selection_changed(self, view):
selection = view.get_selection()
@@ -345,7 +345,7 @@ class ClocksToolbar(Gtk.Toolbar):
def _on_can_select_changed(self, view, pspec):
if view == self.current_view:
- self.selectButton.set_sensitive(view.can_select)
+ self.select_button.set_sensitive(view.can_select)
def _on_select_clicked(self, button):
self.show_selection_toolbar()
diff --git a/gnomeclocks/clocks.py b/gnomeclocks/clocks.py
index 65658a5..caddc82 100644
--- a/gnomeclocks/clocks.py
+++ b/gnomeclocks/clocks.py
@@ -29,11 +29,11 @@ class Clock(Gtk.EventBox):
())
}
- def __init__(self, label, hasNew=False, hasSelectionMode=False):
+ def __init__(self, label, has_new=False, has_selection_mode=False):
Gtk.EventBox.__init__(self)
self.label = label
- self.hasNew = hasNew
- self.hasSelectionMode = hasSelectionMode
+ self.has_new = has_new
+ self.has_selection_mode = has_selection_mode
self.get_style_context().add_class('view')
self.get_style_context().add_class('content-view')
diff --git a/gnomeclocks/stopwatch.py b/gnomeclocks/stopwatch.py
index 8d48474..d8a095f 100644
--- a/gnomeclocks/stopwatch.py
+++ b/gnomeclocks/stopwatch.py
@@ -46,47 +46,47 @@ class Stopwatch(Clock):
grid.set_column_homogeneous(True)
self.add(grid)
- self.timeLabel = Gtk.Label()
+ self.time_label = Gtk.Label()
# add margin to match the spinner size in the timer
- self.timeLabel.set_margin_top(42)
- self.timeLabel.set_margin_bottom(42)
+ self.time_label.set_margin_top(42)
+ self.time_label.set_margin_bottom(42)
self.set_time_label(0, 0)
- grid.attach(self.timeLabel, 0, 0, 2, 1)
-
- self.leftButton = Gtk.Button()
- self.leftButton.set_size_request(200, -1)
- self.leftLabel = Gtk.Label()
- self.leftLabel.set_markup(Stopwatch.BUTTON_MARKUP % (_("Start")))
- self.leftButton.add(self.leftLabel)
- self.leftButton.get_style_context().add_class("clocks-go")
- grid.attach(self.leftButton, 0, 1, 1, 1)
-
- self.rightButton = Gtk.Button()
- self.rightButton.set_size_request(200, -1)
- self.rightLabel = Gtk.Label()
- self.rightLabel.set_markup(Stopwatch.BUTTON_MARKUP % (_("Reset")))
- self.rightButton.add(self.rightLabel)
- self.rightButton.set_sensitive(False)
- grid.attach(self.rightButton, 1, 1, 1, 1)
-
- self.leftButton.connect("clicked", self._on_left_button_clicked)
- self.rightButton.connect("clicked", self._on_right_button_clicked)
+ grid.attach(self.time_label, 0, 0, 2, 1)
+
+ self.left_button = Gtk.Button()
+ self.left_button.set_size_request(200, -1)
+ self.left_label = Gtk.Label()
+ self.left_label.set_markup(Stopwatch.BUTTON_MARKUP % (_("Start")))
+ self.left_button.add(self.left_label)
+ self.left_button.get_style_context().add_class("clocks-go")
+ grid.attach(self.left_button, 0, 1, 1, 1)
+
+ self.right_button = Gtk.Button()
+ self.right_button.set_size_request(200, -1)
+ self.right_label = Gtk.Label()
+ self.right_label.set_markup(Stopwatch.BUTTON_MARKUP % (_("Reset")))
+ self.right_button.add(self.right_label)
+ self.right_button.set_sensitive(False)
+ grid.attach(self.right_button, 1, 1, 1, 1)
+
+ self.left_button.connect("clicked", self._on_left_button_clicked)
+ self.right_button.connect("clicked", self._on_right_button_clicked)
def _on_left_button_clicked(self, widget):
if self.state in (Stopwatch.State.RESET, Stopwatch.State.STOPPED):
self.state = Stopwatch.State.RUNNING
self.start()
- self.leftLabel.set_markup(Stopwatch.BUTTON_MARKUP % (_("Stop")))
- self.leftButton.get_style_context().add_class("clocks-stop")
- self.rightButton.set_sensitive(False)
+ self.left_label.set_markup(Stopwatch.BUTTON_MARKUP % (_("Stop")))
+ self.left_button.get_style_context().add_class("clocks-stop")
+ self.right_button.set_sensitive(False)
elif self.state == Stopwatch.State.RUNNING:
self.state = Stopwatch.State.STOPPED
self.stop()
- self.leftLabel.set_markup(Stopwatch.BUTTON_MARKUP % (_("Continue")))
- self.rightLabel.set_markup(Stopwatch.BUTTON_MARKUP % (_("Reset")))
- self.leftButton.get_style_context().remove_class("clocks-stop")
- self.leftButton.get_style_context().add_class("clocks-go")
- self.rightButton.set_sensitive(True)
+ self.left_label.set_markup(Stopwatch.BUTTON_MARKUP % (_("Continue")))
+ self.right_label.set_markup(Stopwatch.BUTTON_MARKUP % (_("Reset")))
+ self.left_button.get_style_context().remove_class("clocks-stop")
+ self.left_button.get_style_context().add_class("clocks-go")
+ self.right_button.set_sensitive(True)
def _on_right_button_clicked(self, widget):
if self.state == Stopwatch.State.RUNNING:
@@ -94,9 +94,9 @@ class Stopwatch(Clock):
if self.state == Stopwatch.State.STOPPED:
self.state = Stopwatch.State.RESET
self.time_diff = 0
- self.leftLabel.set_markup(Stopwatch.BUTTON_MARKUP % (_("Start")))
- self.leftButton.get_style_context().add_class("clocks-go")
- self.rightButton.set_sensitive(False)
+ self.left_label.set_markup(Stopwatch.BUTTON_MARKUP % (_("Start")))
+ self.left_button.get_style_context().add_class("clocks-go")
+ self.right_button.set_sensitive(False)
self.set_time_label(0, 0)
def get_time(self):
@@ -105,7 +105,7 @@ class Stopwatch(Clock):
return (m, s)
def set_time_label(self, m, s):
- self.timeLabel.set_markup(Stopwatch.LABEL_MARKUP % (m, s))
+ self.time_label.set_markup(Stopwatch.LABEL_MARKUP % (m, s))
def start(self):
if self.timeout_id == 0:
diff --git a/gnomeclocks/timer.py b/gnomeclocks/timer.py
index a0a4617..b31be34 100644
--- a/gnomeclocks/timer.py
+++ b/gnomeclocks/timer.py
@@ -34,49 +34,49 @@ class TimerScreen(Gtk.Grid):
self.set_column_spacing(24)
self.set_column_homogeneous(True)
- self.timeLabel = Gtk.Label()
- self.timeLabel.set_markup(Timer.LABEL_MARKUP % (0, 0, 0))
- size_group.add_widget(self.timeLabel)
- self.attach(self.timeLabel, 0, 0, 2, 1)
-
- self.leftButton = Gtk.Button()
- self.leftButton.set_size_request(200, -1)
- self.leftLabel = Gtk.Label()
- self.leftLabel.set_markup(Timer.BUTTON_MARKUP % (_("Pause")))
- self.leftButton.add(self.leftLabel)
- self.attach(self.leftButton, 0, 1, 1, 1)
-
- self.rightButton = Gtk.Button()
- self.rightButton.set_size_request(200, -1)
- self.rightLabel = Gtk.Label()
- self.rightLabel.set_markup(Timer.BUTTON_MARKUP % (_("Reset")))
- self.rightButton.add(self.rightLabel)
- self.attach(self.rightButton, 1, 1, 1, 1)
-
- self.leftButton.connect("clicked", self._on_left_button_clicked)
- self.rightButton.connect("clicked", self._on_right_button_clicked)
+ self.time_label = Gtk.Label()
+ self.time_label.set_markup(Timer.LABEL_MARKUP % (0, 0, 0))
+ size_group.add_widget(self.time_label)
+ self.attach(self.time_label, 0, 0, 2, 1)
+
+ self.left_button = Gtk.Button()
+ self.left_button.set_size_request(200, -1)
+ self.left_label = Gtk.Label()
+ self.left_label.set_markup(Timer.BUTTON_MARKUP % (_("Pause")))
+ self.left_button.add(self.left_label)
+ self.attach(self.left_button, 0, 1, 1, 1)
+
+ self.right_button = Gtk.Button()
+ self.right_button.set_size_request(200, -1)
+ self.right_label = Gtk.Label()
+ self.right_label.set_markup(Timer.BUTTON_MARKUP % (_("Reset")))
+ self.right_button.add(self.right_label)
+ self.attach(self.right_button, 1, 1, 1, 1)
+
+ self.left_button.connect("clicked", self._on_left_button_clicked)
+ self.right_button.connect("clicked", self._on_right_button_clicked)
def set_time(self, h, m, s):
- self.timeLabel.set_markup(Timer.LABEL_MARKUP % (h, m, s))
+ self.time_label.set_markup(Timer.LABEL_MARKUP % (h, m, s))
def _on_right_button_clicked(self, data):
- self.leftLabel.set_markup(Timer.BUTTON_MARKUP % (_("Pause")))
+ self.left_label.set_markup(Timer.BUTTON_MARKUP % (_("Pause")))
self.timer.reset()
def _on_left_button_clicked(self, widget):
if self.timer.state == Timer.State.RUNNING:
self.timer.pause()
- self.leftLabel.set_markup(Timer.BUTTON_MARKUP % (_("Continue")))
- self.leftButton.get_style_context().add_class("clocks-go")
+ self.left_label.set_markup(Timer.BUTTON_MARKUP % (_("Continue")))
+ self.left_button.get_style_context().add_class("clocks-go")
elif self.timer.state == Timer.State.PAUSED:
self.timer.cont()
- self.leftLabel.set_markup(Timer.BUTTON_MARKUP % (_("Pause")))
- self.leftButton.get_style_context().remove_class("clocks-go")
+ self.left_label.set_markup(Timer.BUTTON_MARKUP % (_("Pause")))
+ self.left_button.get_style_context().remove_class("clocks-go")
-class TimerWelcomeScreen(Gtk.Grid):
+class TimerSetupScreen(Gtk.Grid):
def __init__(self, timer, size_group):
- super(TimerWelcomeScreen, self).__init__()
+ super(TimerSetupScreen, self).__init__()
self.timer = timer
self.set_halign(Gtk.Align.CENTER)
@@ -104,15 +104,15 @@ class TimerWelcomeScreen(Gtk.Grid):
size_group.add_widget(spinner)
self.attach(spinner, 0, 0, 1, 1)
- self.startButton = Gtk.Button()
- self.startButton.set_size_request(200, -1)
- self.startLabel = Gtk.Label()
- self.startLabel.set_markup(Timer.BUTTON_MARKUP % (_("Start")))
- self.startButton.set_sensitive(False)
- self.startButton.add(self.startLabel)
- self.attach(self.startButton, 0, 1, 1, 1)
+ self.start_button = Gtk.Button()
+ self.start_button.set_size_request(200, -1)
+ label = Gtk.Label()
+ label.set_markup(Timer.BUTTON_MARKUP % (_("Start")))
+ self.start_button.set_sensitive(False)
+ self.start_button.add(label)
+ self.attach(self.start_button, 0, 1, 1, 1)
- self.startButton.connect('clicked', self._on_start_clicked)
+ self.start_button.connect('clicked', self._on_start_clicked)
def get_values(self):
h = self.hours.get_value()
@@ -129,11 +129,11 @@ class TimerWelcomeScreen(Gtk.Grid):
def update_start_button_status(self):
h, m, s = self.get_values()
if h == 0 and m == 0 and s == 0:
- self.startButton.set_sensitive(False)
- self.startButton.get_style_context().remove_class("clocks-go")
+ self.start_button.set_sensitive(False)
+ self.start_button.get_style_context().remove_class("clocks-go")
else:
- self.startButton.set_sensitive(True)
- self.startButton.get_style_context().add_class("clocks-go")
+ self.start_button.set_sensitive(True)
+ self.start_button.get_style_context().add_class("clocks-go")
def _on_spinner_changed(self, spinner):
self.update_start_button_status()
@@ -164,8 +164,8 @@ class Timer(Clock):
# force the time label and the spinner to the same size
size_group = Gtk.SizeGroup(Gtk.SizeGroupMode.VERTICAL);
- self.welcome_screen = TimerWelcomeScreen(self, size_group)
- self.notebook.append_page(self.welcome_screen, None)
+ self.setup_screen = TimerSetupScreen(self, size_group)
+ self.notebook.append_page(self.setup_screen, None)
self.timer_screen = TimerScreen(self, size_group)
self.notebook.append_page(self.timer_screen, None)
@@ -177,10 +177,10 @@ class Timer(Clock):
win = self.get_toplevel()
win.show_clock(self)
- def show_welcome_screen(self, reset):
+ def show_setup_screen(self, reset):
self.notebook.set_current_page(0)
if reset:
- self.welcome_screen.set_values(0, 0, 0)
+ self.setup_screen.set_values(0, 0, 0)
def show_timer_screen(self):
self.notebook.set_current_page(1)
@@ -195,7 +195,7 @@ class Timer(Clock):
def start(self):
if self.state == Timer.State.STOPPED and self.timeout_id == 0:
- h, m, s = self.welcome_screen.get_values()
+ h, m, s = self.setup_screen.get_values()
self.timer_screen.set_time(h, m, s)
self.duration = (h * 60 * 60) + (m * 60) + s
self.deadline = time.time() + self.duration
@@ -206,7 +206,7 @@ class Timer(Clock):
def reset(self):
self.state = Timer.State.STOPPED
self._remove_timeout()
- self.show_welcome_screen(True)
+ self.show_setup_screen(True)
def pause(self):
self.duration = self.deadline - time.time()
@@ -225,7 +225,7 @@ class Timer(Clock):
self.state = Timer.State.STOPPED
self._remove_timeout()
self.timer_screen.set_time(0, 0, 0)
- self.show_welcome_screen(False)
+ self.show_setup_screen(False)
return False
else:
r = self.deadline - t
diff --git a/gnomeclocks/world.py b/gnomeclocks/world.py
index 2964b41..95dbef9 100644
--- a/gnomeclocks/world.py
+++ b/gnomeclocks/world.py
@@ -169,16 +169,16 @@ class DigitalClock():
if not t == self._last_time \
or not self.sunrise == self._last_sunrise \
or not self.sunset == self._last_sunset:
- isDay = self.get_is_light(location_time)
- if isDay:
+ is_light = self.get_is_light(location_time)
+ if is_light:
img = os.path.join(Dirs.get_image_dir(), "cities", "day.png")
else:
img = os.path.join(Dirs.get_image_dir(), "cities", "night.png")
day = self.get_day()
if day == "Today":
- self.drawing.render(t, img, isDay)
+ self.drawing.render(t, img, is_light)
else:
- self.drawing.render(t, img, isDay, day)
+ self.drawing.render(t, img, is_light, day)
if self.path and self.list_store:
self.list_store[self.path][1] = self.drawing.pixbuf
if self.standalone:
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
