Merge lp:~jcsims/pomodoro-timer/rewrite into lp:pomodoro-timer

[Chris Sims]

New direction.

A rewrite of the original Quickly base program. Window created and packed using pyGTK. Basic logic for various timer functions, countdown, display of time.

[Chris Sims (jcsims)]

Approving myself...

review: Approve

=== modified file 'bin/pomodorotimer'
--- bin/pomodorotimer	2010-04-04 22:06:22 +0000
+++ bin/pomodorotimer	2010-04-07 04:26:17 +0000
@@ -15,111 +15,225 @@
 #with this program.  If not, see <http://www.gnu.org/licenses/>.
 ### END LICENSE
 
-import sys
-import os
-import gtk
-
-# Check if we are working in the source tree or from the installed 
-# package and mangle the python path accordingly
-if os.path.dirname(sys.argv[0]) != ".":
-    if sys.argv[0][0] == "/":
-        fullPath = os.path.dirname(sys.argv[0])
-    else:
-        fullPath = os.getcwd() + "/" + os.path.dirname(sys.argv[0])
-else:
-    fullPath = os.getcwd()
-sys.path.insert(0, os.path.dirname(fullPath))
-
-from pomodorotimer import AboutPomodorotimerDialog, PreferencesPomodorotimerDialog
-from pomodorotimer.pomodorotimerconfig import getdatapath
-
-class PomodorotimerWindow(gtk.Window):
-    __gtype_name__ = "PomodorotimerWindow"
+import pygtk
+pygtk.require('2.0')
+import gtk, gobject
+
+class PomodorotimerWindow():
 
     def __init__(self):
-        """__init__ - This function is typically not called directly.
-        Creation a PomodorotimerWindow requires redeading the associated ui
-        file and parsing the ui definition extrenally,
-        and then calling PomodorotimerWindow.finish_initializing().
-
-        Use the convenience function NewPomodorotimerWindow to create
-        PomodorotimerWindow object.
-
-        """
-        pass
-
-    def finish_initializing(self, builder):
-        """finish_initalizing should be called after parsing the ui definition
-        and creating a PomodorotimerWindow object with it in order to finish
-        initializing the start of the new PomodorotimerWindow instance.
-
-        """
-        #get a reference to the builder and set up the signals
-        self.builder = builder
-        self.builder.connect_signals(self)
-
-        #uncomment the following code to read in preferences at start up
-        #dlg = PreferencesPomodorotimerDialog.NewPreferencesPomodorotimerDialog()
-        #self.preferences = dlg.get_preferences()
-
-        #code for other initialization actions should be added here
+        # Create the window and set attributes
+        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
+        self.window.set_title("Pomodoro Timer")
+        self.window.set_border_width(5)
+        self.window.set_resizable(False)
+        self.window.set_size_request(400, 200)
+
+        # Connect the delete_event event to the event handler
+        self.window.connect("delete_event", self.on_destroy)
+
+        # Create and add the one VBox that we'll need
+        box1 = gtk.VBox(False, 0)
+        self.window.add(box1)
+        box1.show()
+
+        # Create the file menu and pack it
+        file_menu = gtk.Menu()
+        quit_item = gtk.MenuItem("Quit")
+
+        file_menu.append(quit_item)
+
+        # Attach quit menu entry to our exit function
+        quit_item.connect("activate", self.on_destroy, None)
+
+        # And show it
+        quit_item.show()
+
+        # Create the menu bar, pack it, show it
+        menu_bar = gtk.MenuBar()
+        box1.pack_start(menu_bar, False, False, 0)
+        menu_bar.show()
+
+        # Create the visible "File" menu and associate it with our
+        # above created menu
+        file_item = gtk.MenuItem("File")
+        file_item.show()
+        file_item.set_submenu(file_menu)
+
+        # And then append the file menu to our menu bar
+        menu_bar.append(file_item)
+
+        # Create the help menu and pack it
+        help_menu = gtk.Menu()
+        about_item = gtk.MenuItem("About")
+
+        help_menu.append(about_item)
+
+        # Attach about menu entry to our about function
+        about_item.connect("activate", self.about, None)
+
+        # And show it
+        about_item.show()
+
+        # Create the visible "Help" menu and associate it with our
+        # above created menu
+        help_item = gtk.MenuItem("Help")
+        help_item.show()
+        help_item.set_submenu(help_menu)
+
+        # And then append the file menu to our menu bar
+        menu_bar.append(help_item)
+
+        # Create the HBox to hold the buttons and the timer
+        box2 = gtk.HBox(True, 0)
+        box1.pack_start(box2, False, False, 0)
+        box2.show()
+        
+        # Create our VBox for the radio buttons and the start button
+        box3 = gtk.VBox(True, 0)
+        box3.set_border_width(10)
+        box2.pack_start(box3, False, False, 5)
+        box3.show()
+
+        # Create the three radio buttons and pack them
+        rbutton1 = gtk.RadioButton(None, "Pomodoro!")
+        rbutton1.connect("toggled", self.pomodoro, None)
+        rbutton1.set_active(True)
+        box3.pack_start(rbutton1, False, False, 5)
+        rbutton1.show()
+
+        rbutton2 = gtk.RadioButton(rbutton1, "Short Break")
+        rbutton2.connect("toggled", self.short_break, None)
+        box3.pack_start(rbutton2, False, False, 5)
+        rbutton2.show()
+
+        rbutton3 = gtk.RadioButton(rbutton1, "Long Break")
+        rbutton3.connect("toggled", self.long_break, None)
+        box3.pack_start(rbutton3, False, False, 5)
+        rbutton3.show()
+
+        # Create a small HBox for our start and stop buttons
+        box4 = gtk.HBox(True, 0)
+        box3.pack_start(box4, False, False, 0)
+        box4.show()
+
+        start_button = gtk.Button("Start!")
+        start_button.connect("clicked", self.start, None)
+        box4.pack_start(start_button, False, False, 5)
+        start_button.show()
+
+        stop_button = gtk.Button("Stop!")
+        stop_button.connect("clicked", self.stop, None)
+        box4.pack_start(stop_button, False, False, 5)
+        stop_button.show()
+
+        # Create the label that will become our countdown timer
+        self.timer = gtk.Label("25:00")
+        box2.pack_start(self.timer, False, False, 5)
+        self.timer.show()
+		
+	
+        self.window.show()
 
     def about(self, widget, data=None):
         """about - display the about box for pomodorotimer """
-        about = AboutPomodorotimerDialog.NewAboutPomodorotimerDialog()
-        response = about.run()
-        about.destroy()
-
-    def preferences(self, widget, data=None):
-        """preferences - display the preferences window for pomodorotimer """
-        prefs = PreferencesPomodorotimerDialog.NewPreferencesPomodorotimerDialog()
-        response = prefs.run()
-        if response == gtk.RESPONSE_OK:
-            #TODO: Save changes made to preferences
-            pass
-        prefs.destroy()
-
-    def quit(self, widget, data=None):
-        """quit - signal handler for closing the PomodorotimerWindow"""
-        self.destroy()
+        # Borrowed from Jon Staley, from python-snippets package
+        # The AboutDialog has good helper methods which
+        # setup the dialog and add the content ensuring all
+        # about dialog are consistant.  Below is a small example
+
+        # Create AboutDialog object
+        dialog = gtk.AboutDialog()
+
+        # Add the application name to the dialog
+        dialog.set_name('About Pomodoro Timer')
+
+        # Set the application version
+        dialog.set_version('0.1')
+
+        # Pass a list of authors.  This is then connected to the 'Credits'
+        # button.  When clicked the buttons opens a new window showing
+        # each author on their own line.
+        dialog.set_authors(['Chris Sims', 'Steven Nance'])
+
+        # Add a short comment about the application, this appears below the application
+        # name in the dialog
+        dialog.set_comments('A simple pomodoro timer.')
+
+        # Add license information, this is connected to the 'License' button
+        # and is displayed in a new window.
+        dialog.set_license('Distributed under the GPL v3 license.\nhttp://www.gnu.org/licenses/gpl.html')
+
+        # Show the dialog
+        dialog.run()
+
+        # The destroy method must be called otherwise the 'Close' button will
+        # not work.
+        dialog.destroy()
+
+#    def preferences(self, widget, data=None):
+#        """preferences - display the preferences window for pomodorotimer """
+#        prefs = PreferencesPomodorotimerDialog.NewPreferencesPomodorotimerDialog()
+#        response = prefs.run()
+#        if response == gtk.RESPONSE_OK:
+#            #TODO: Save changes made to preferences
+#            pass
+#        prefs.destroy()
+
+    # Make sure to default our seconds to zero
+    seconds = 0
+
+    def pomodoro(self, widget, data=None):
+        if widget.get_active():
+            self.minutes = 25
+            self.timer.set_label("25:00")
+
+    def short_break(self, widget, data=None):
+        if widget.get_active():
+            self.minutes = 5
+            self.timer.set_label("5:00")
+
+    def long_break(self, widget, data=None):
+        if widget.get_active():
+            self.minutes = 15
+            self.timer.set_label("15:00")
+            
+    def start(self, widget, data=None):
+        gobject.timeout_add(1000, self.countdown)
+        self.countdown()
+
+    def countdown(self):
+        if self.seconds>= 0:
+            m = "%02d" % self.minutes
+            s = "%02d" % self.seconds
+            self.timer.set_text(m + ':' + s)
+            self.seconds -= 1
+            return True
+        elif self.minutes > 0:
+            self.minutes -= 1
+            self.seconds = 59
+            return True
+        else:
+            self.timer.set_text("All done!")
+            return False
+
+    def stop(self, widget, data=None):
+        self.minutes = 0
+        self.seconds = 0
+        self.countdown()
 
     def on_destroy(self, widget, data=None):
-        """on_destroy - called when the PomodorotimerWindow is close. """
+        """on_destroy - called when the PomodorotimerWindow is closed, 
+        or when "quit" is selected from the menu. """
         #TODO: Save any changes to historical data before closing
 
         gtk.main_quit()
-
-def NewPomodorotimerWindow():
-    """NewPomodorotimerWindow - returns a fully instantiated
-    PomodorotimerWindow object. Use this function rather than
-    creating a PomodorotimerWindow directly.
-    """
-
-    #look for the ui file that describes the ui
-    ui_filename = os.path.join(getdatapath(), 'ui', 'PomodorotimerWindow.ui')
-    if not os.path.exists(ui_filename):
-        ui_filename = None
-
-    builder = gtk.Builder()
-    builder.add_from_file(ui_filename)
-    window = builder.get_object("pomodorotimer_window")
-    window.finish_initializing(builder)
-    return window
+        
+    def main(self):
+        gtk.main()
 
 if __name__ == "__main__":
-    #support for command line options
-    import logging, optparse
-    parser = optparse.OptionParser(version="%prog %ver")
-    parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help="Show debug messages")
-    (options, args) = parser.parse_args()
-
-    #set the logging level to show debug messages
-    if options.verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        logging.debug('logging enabled')
-
     #run the application
-    window = NewPomodorotimerWindow()
-    window.show()
-    gtk.main()
+    window = PomodorotimerWindow()
+    window.main()