gnome-pygarmin

#!/usr/bin/env python
"""
   gnome-pygarmin

   This is a GNOME user application for communicating with Garmin
   GPS receivers.

   To use it you will need the gnome-python package installed, which
   can be found at ftp://ftp.daa.com.au/pub/james/python/

   This is released under the Gnu General Public Licence. A copy of
   this can be found at http://www.opensource.org/licenses/gpl-license.html

   For the latest information about PyGarmin, please see
   http://pygarmin.sourceforge.net/

   (c) 2000 James A. H. Skillen <jahs@jahs.net>

"""

import sys, garmin, gtk.glade
from gtk import *
from gnome.ui import *
import gnome
import gconf

class GnomePygarmin:
    def __init__(self):
        gnome.init("myapp", "0.8")
        self.widgets = glade.XML("gnome-pygarmin.glade",
                                 "gnome_pygarmin")
        signals = {
            "on_gnome_pygarmin_destroy"    : self.exit,
            # File
            "on_menu_new_activate"         : self.new,
            "on_menu_open_activate"        : self.open,
            "on_menu_save_activate"        : self.save,
            "on_menu_save_as_activate"     : self.save_as,
            "on_menu_exit_activate"        : self.exit,
            # Edit
            "on_menu_cut_activate"         : self.cut,
            "on_menu_copy_activate"        : self.copy,
            "on_menu_paste_activate"       : self.paste,
            "on_menu_clear_activate"       : self.clear,
            "on_menu_properties_activate"  : self.properties,
            # GPS
            "on_menu_download_activate"    : self.download,
            "on_menu_info_activate"        : self.info,
            # Settings
            "on_menu_preferences_activate" : self.prefs,
            # Help
            "on_menu_about_activate"       : self.about,
            # Toolbar
            "on_toolbar_open_clicked"      : self.open,
            "on_toolbar_save_clicked"      : self.save,
            "on_toolbar_download_clicked"  : self.download,
            "on_toolbar_info_clicked"      : self.info
            }

        self.widgets.signal_autoconnect(signals)

        self.wpt_list = gtk.ListStore(str, str, str)
        self.widgets.get_widget('wpt_view').set_model(self.wpt_list)

        cell = gtk.CellRendererText()
        column = gtk.TreeViewColumn('Name', cell, text=0)
        self.widgets.get_widget('wpt_view').append_column(column)

        cell = gtk.CellRendererText()
        column = gtk.TreeViewColumn('Longitude', cell, text=1)
        self.widgets.get_widget('wpt_view').append_column(column)

        cell = gtk.CellRendererText()
        column = gtk.TreeViewColumn('Latitude', cell, text=2)
        self.widgets.get_widget('wpt_view').append_column(column)

        self.gps = None
        self.client = gconf.client_get_default()
        device = self.client.get_string("/apps/gnome-pygarmin/Preferences/serial_device")
        self._init_gps(device)
        self.widgets.get_widget('gnome_pygarmin').show()

    def _init_gps(self, device = None):
        if device == None:
            self.prefs(None)
            d = gtk.MessageDialog(type=gtk.MESSAGE_ERROR,
 	                                flags=gtk.DIALOG_MODAL,
                                  buttons=gtk.BUTTONS_CLOSE,
                                  parent=self.widgets.get_widget("gnome_pygarmin"),
 	                                message_format="Please enter the serial device to which your GPS is connected.")
            d.connect('response', lambda dialog, response: dialog.destroy())
            d.run()

        else:
            try:
                phys = garmin.SerialLink(device)
                self.gps = garmin.Garmin(phys)
            except:
                msg = str(sys.exc_info()[1])
                if msg:
                    self.prefs(None)
                    d = gtk.MessageDialog(type=gtk.MESSAGE_ERROR,
                                          flags=gtk.DIALOG_MODAL,
                                          buttons=gtk.BUTTONS_CLOSE,
                                          message_format=msg)
                    d.connect('response', lambda dialog, response: dialog.destroy())
                    d.run()

    def _not_done(self):
        e = gtk.MessageDialog(type=gtk.MESSAGE_ERROR,
                              flags=gtk.DIALOG_MODAL,
                              buttons=gtk.BUTTONS_OK,
                              parent=self.widgets.get_widget("gnome_pygarmin"),
                              message_format="Not yet implemented!")
        e.connect('response', lambda dialog, response: dialog.destroy())
        e.run()

    # File
    def new(self, widget):
        self._not_done()

    def open(self, widget):
        self._not_done()

    def save(self, widget):
        self._not_done()

    def save_as(self, widget):
        self._not_done()

    def exit(self, widget):
    
        self.client.suggest_sync()
        gtk.main_quit()

    # Edit
    def cut(self, widget):
        self._not_done()

    def copy(self, widget):
        self._not_done()

    def paste(self, widget):
        self._not_done()

    def clear(self, widget):
        self._not_done()

    def properties(self, widget):
        self._not_done()

    # GPS
    def download(self, widget):
        Download(self)

    def info(self, widget):
        self._not_done()

    # Settings
    def prefs(self, widget):
        Preferences(self)

    # Help
    def about(self, widget):
        About(self)

class Preferences:
    def __init__(self, pygarmin):
        self.pygarmin = pygarmin
        self.widgets = glade.XML("gnome-pygarmin.glade",
                                 "preferences")
        signals = {
            "on_prefs_ok_clicked"     : self.ok,
            "on_prefs_apply_clicked"  : self.apply,
            "on_prefs_cancel_clicked" : self.cancel
            }
        self.widgets.signal_autoconnect(signals)

        window = self.widgets.get_widget("preferences")

        text_entry = self.widgets.get_widget("device")
        device = pygarmin.client.get_string("/apps/gnome-pygarmin/Preferences/serial_device")
        if device == None:
            device = ""
        text_entry.set_text(device)

        window.show()

    def ok(self, widget):
        text_entry = self.widgets.get_widget("device")
        device = text_entry.get_text()
        self.pygarmin._init_gps(device)
        self.pygarmin.client.set_string("/apps/gnome-pygarmin/Preferences/serial_device", device)
        self.cancel(None)

    def apply(self, widget):
        text_entry = self.widgets.get_widget("device")
        device = text_entry.get_text()
        self.pygarmin._init_gps(device)
        self.cancel(None)

    def cancel(self, widget):
        window = self.widgets.get_widget("preferences")
        window.destroy()

class Download:
    def __init__(self, pygarmin):
        self.pygarmin = pygarmin
        self.widgets = glade.XML("gnome-pygarmin.glade",
                                 "download")
        signals = {
            "on_download_ok_clicked"     : self.ok,
            "on_download_cancel_clicked" : self.cancel
            }
        self.widgets.signal_autoconnect(signals)

        window = self.widgets.get_widget("download")
        window.show()

    def _waypoints(self):
        if not self.pygarmin.gps:
            self.pygarmin._init_gps()
            return
        wpts = self.pygarmin.gps.getWaypoints()
        self.pygarmin.wpt_list.clear()

        for w in wpts:
            self.pygarmin.wpt_list.append((w.ident,
                                           str(garmin.degrees(w.slat)),
                                           str(garmin.degrees(w.slon))))

    def ok(self, widget):
        w = self.widgets.get_widget("download_waypoints")
        r = self.widgets.get_widget("download_routes")
        t = self.widgets.get_widget("download_tracks")

        get_w = w.get_active()
        self.cancel(None)

        if get_w:
            w = gtk.MessageDialog(type=gtk.MESSAGE_INFO,
                                  flags=gtk.DIALOG_MODAL,
                                  parent=self.widgets.get_widget("gnome_pygarmin"),
                                  message_format="Downloading waypoints")
            w.show()
            self._waypoints()
            w.destroy()

    def cancel(self, widget):
        window = self.widgets.get_widget("download")
        window.destroy()

class About:
    def __init__(self, pygarmin):
        self.pygarmin = pygarmin
        self.widgets = glade.XML("gnome-pygarmin.glade",
                                 "about")
        window = self.widgets.get_widget("about")
        window.show()

def main():
    app = GnomePygarmin()
    gtk.main()

if __name__ == "__main__":
    main()