Thuban/UI/projdialog.py

#!/usr/bin/env python
# generated by wxGlade 0.2.1 on Thu Apr 17 11:51:39 2003

import os, sys
from wxPython.wx import *

from Thuban import _

from Thuban.Model.proj import Projection, ProjFile

from Thuban.Model.resource import GetUserProjFiles, GetSystemProjFiles, \
                                  ReadProjFile, WriteProjFile
from Thuban.UI.dialogs import NonModalDialog


ID_PROJ_ADVANCED  = 4001
ID_PROJ_PROJCHOICE = 4002
ID_PROJ_SAVEAS    = 4003
ID_PROJ_NEW       = 4004
ID_PROJ_TRY       = 4005
ID_PROJ_REVERT    = 4006
ID_PROJ_OK        = 4007
ID_PROJ_CLOSE     = 4008
ID_PROJ_AVAIL     = 4009
ID_PROJ_SAVE      = 4010
ID_PROJ_IMPORT    = 4011
ID_PROJ_EXPORT    = 4012
ID_PROJ_REMOVE    = 4013
ID_PROJ_PROJNAME  = 4014

CLIENT_PROJ = 0
CLIENT_PROJFILE = 1

class ProjFrame(NonModalDialog):

    def __init__(self, parent, name, receiver, *args, **kwds):
        """Initialize the projection dialog.

        receiver -- An object that implements the following methods:
                        SetProjection(projection)
                        GetProjection()
        """
        
        self.receiver = receiver
        self.originalProjection = -1
        self.curProjPanel = None

        self.projPanels = []
        self.projPanels.append(
            ("tmerc", _("Transverse Mercator"), TMPanel))
        self.projPanels.append(
            ("utm", _("Universal Transverse Mercator"), UTMPanel))
        self.projPanels.append(
            ("lcc", _("Lambert Conic Conformal"), LCCPanel))
        self.projPanels.append(
            ("latlong", _("Geographic"), GeoPanel))

        NonModalDialog.__init__(self, parent, name, "")
        # originally generate by wxGlade
        self.panel_1 = wxPanel(self, -1)
        self.panel_edit = wxPanel(self, -1)
        self.panel_buttons = wxPanel(self, -1)
        self.label_5 = wxStaticText(self.panel_1, -1, _("Available Projections:"))
        self.availprojs = wxListBox(self.panel_1, ID_PROJ_AVAIL, style=wxLB_EXTENDED |wxLB_SORT)
        self.projfilepath = wxStaticText(self.panel_1, -1, "")
        self.label_2 = wxStaticText(self.panel_edit, -1, _("Name:"))
        self.projname = wxTextCtrl(self.panel_edit, ID_PROJ_PROJNAME, "")
        self.label_3 = wxStaticText(self.panel_edit, -1, _("Projection:"))
        self.projchoice = wxChoice(self.panel_edit, ID_PROJ_PROJCHOICE)
        self.button_import = wxButton(self.panel_1, ID_PROJ_IMPORT, _("Import..."))
        self.button_export = wxButton(self.panel_1, ID_PROJ_EXPORT, _("Export..."))
        self.button_remove = wxButton(self.panel_1, ID_PROJ_REMOVE, _("Remove"))
        self.button_new = wxButton(self.panel_edit, ID_PROJ_NEW, _("New"))
        self.button_save = wxButton(self.panel_edit, ID_PROJ_SAVE,_("Save"))
        self.button_add = wxButton(self.panel_edit, ID_PROJ_SAVEAS,
                                      _("Add to List"))
        self.button_try = wxButton(self.panel_buttons, ID_PROJ_TRY, _("Try"))
        self.button_revert = wxButton(self.panel_buttons, ID_PROJ_REVERT, _("Revert"))
        self.button_ok = wxButton(self.panel_buttons, ID_PROJ_OK, _("OK"))
        self.button_close = wxButton(self.panel_buttons, ID_PROJ_CLOSE, _("Close"))

        self.__set_properties()
        self.__do_layout()
        # wxGlade

        self.__DoOnProjAvail()
        
        EVT_BUTTON(self, ID_PROJ_TRY, self._OnTry)
        EVT_BUTTON(self, ID_PROJ_REVERT, self._OnRevert)
        EVT_BUTTON(self, ID_PROJ_OK, self._OnOK)
        EVT_BUTTON(self, ID_PROJ_CLOSE, self._OnClose)
        EVT_CHOICE(self, ID_PROJ_PROJCHOICE, self._OnProjChoice)
        EVT_LISTBOX(self, ID_PROJ_AVAIL, self._OnProjAvail)
        EVT_BUTTON(self, ID_PROJ_IMPORT, self._OnImport)
        EVT_BUTTON(self, ID_PROJ_EXPORT, self._OnExport)
        EVT_BUTTON(self, ID_PROJ_REMOVE, self._OnRemove)

        EVT_BUTTON(self, ID_PROJ_NEW, self._OnNew)
        EVT_BUTTON(self, ID_PROJ_SAVE, self._OnSave)
        EVT_BUTTON(self, ID_PROJ_SAVEAS, self._OnSaveAs)

        EVT_TEXT(self, ID_PROJ_PROJNAME, self._OnProjName)

    def GetReceiver(self):
        return self.receiver

    def _OnTry(self, event):
        self.__SetProjection()

    def _OnRevert(self, event):
        if self.originalProjection != -1:
            self.receiver.SetProjection(self.originalProjection)

    def _OnOK(self, event):
        self.__SetProjection()
        self.Close()

    def _OnClose(self, event):
        self.Close()

    def _OnNew(self, event):
        self.__DoOnNew()

    def _OnSave(self, event):

        sel = self.availprojs.GetSelections()
        assert len(sel) == 1,  "button shouldn't be enabled"

        proj, projfile = self.availprojs.GetClientData(sel[0])

        assert proj is not None and projfile is not None

        newproj = self.__GetProjection()

        if newproj is not None:
            projfile.Remove(proj)
            projfile.Add(newproj)
            try:
                WriteProjFile(projfile)
            except IOError, (errno, errstr):
                wxMessageDialog(self, 
                    _("The following error occured:\n") + 
                    projfile.GetFileName() + "\n" + errstr, 
                    _("Error"), wxOK | wxICON_ERROR).ShowModal()
            self.__FillAvailList()

    def _OnSaveAs(self, event):

        proj = self.__GetProjection()
        if proj is not None:
            self.__usrProjFile.Add(proj)
            try:
                WriteProjFile(self.__usrProjFile)
            except IOError, (errno, errstr):
                wxMessageDialog(self, 
                    _("The following error occured:\n") + 
                    self.__usrProjFile.GetFileName() + "\n" + errstr, 
                    _("Error"), wxOK | wxICON_ERROR).ShowModal()
            self.__FillAvailList()

        return

        """Save the projection somewhere.

        There are three important cases to consider.
            1. the file already exists and the user wants to overwrite it.
            2. the file already exists and the user wants to append the
               current projection to the end of the file
            3. the file doesn't exist and the user wants to create it

        The list of available projections is then updated.
        """

        proj = Projection(self.curProjPanel.GetParameters())
        if self.projname.GetValue() != "":
            proj.SetName(self.projname.GetValue())

        dlg = wxFileDialog(self, _("Save As"), style = wxSAVE)
        if dlg.ShowModal() == wxID_OK:
            path = dlg.GetPath()

            if os.access(path, os.F_OK):
                # file already exists.
                if os.access(path, os.W_OK | os.R_OK):
                
                    # is it a .proj file?
                    try: 
                        projFile = ReadProjFile(path)
                    except:
                        # obviously not.
                        dlg = wxMessageDialog(self,
                            path + _(" already exists. Overwrite?"),
                            _(""),
                            wxYES | wxNO)

                        if dlg.ShowModal() == wxID_YES:
                            projFile = ProjFile(path)
                        else:
                            return # returning early
                    else:
                        # ask the user to overwrite or append
                        dlg = wxMessageDialog(self, 
                            _("The selected projection file already exists.\n"+
                              "The current projection can be added to the " +
                              "file, or it can completely replace the " +
                              "selected file.\n\nShould the current " +
                              "projection be added to the file?"),
                            _("Question"), 
                            wxYES | wxNO | wxICON_QUESTION)

                        if dlg.ShowModal() == wxID_NO:
                            projFile = ProjFile(path)
                else:
                    # can't access the file
                    dlg = wxMessageDialog(self,
                        _("Couldn't access ") + path, 
                        _(""),
                        wxOK | wxICON | wxICON_EXCLAMATION)
                    return

            else:
                # file doesn't exist. make a new one.
                projFile = ProjFile(path)
                
            #
            # if we get this far we have a valid projFile and 
            # can just write the file
            #
            projFile.Add(proj)
            try:
                WriteProjFile(projFile)
                self.__FillAvailList()
            except IOError, (errno, errstr):
                wxMessageDialog(self, 
                    _("The following error occured:\n") + 
                    dlg.GetPath() + "\n" + errstr, 
                    _("Error"), wxOK | wxICON_ERROR).ShowModal()
        dlg.Destroy()

    def _OnProjAvail(self, event):
        self.__DoOnProjAvail()

    def _OnImport(self, event):

        dlg = wxFileDialog(self, _("Import"), style = wxOPEN)

        if dlg.ShowModal() == wxID_OK:
            path = dlg.GetPath()

            try:
                projFile = ReadProjFile(path)
                for proj in projFile.GetProjections():
                    self.__usrProjFile.Add(proj)
                WriteProjFile(self.__usrProjFile)
            except IOError, (errno, errstr):
                wxMessageDialog(self, 
                    _("The following error occured:\n") + 
                    dlg.GetPath() + "\n" + errstr, 
                    _("Error"), wxOK | wxICON_ERROR).ShowModal()

            self.__FillAvailList()

        dlg.Destroy()

    def _OnExport(self, event):
        proj = self.__GetProjection()

        if proj is None: return

        dlg = wxFileDialog(self, _("Export"), 
                           style = wxSAVE|wxOVERWRITE_PROMPT)

        if dlg.ShowModal() == wxID_OK:
            path = dlg.GetPath()

            projFile = ProjFile(path)
            projFile.Add(proj)
            try:
                WriteProjFile(projFile)
            except IOError, (errno, errstr):
                wxMessageDialog(self, 
                    _("The following error occured:\n") + 
                    dlg.GetPath() + "\n" + errstr, 
                    _("Error"), wxOK | wxICON_ERROR).ShowModal()

        dlg.Destroy()

    def _OnRemove(self, event):

        sel = self.availprojs.GetSelections()
        assert len(sel) != 0, "button should be disabled!"

        #
        # remove the items backwards so the indices don't change
        #
        sel = list(sel)
        sel.sort()
        sel.reverse()

        newselection = -1
        if len(sel) == 1:
            newselection = sel[0] - 1
            if newselection < 0:
                newselection = 0

        for i in sel:
            proj, projfile = self.availprojs.GetClientData(i)

            #
            # this could be the case if they selected <None> or
            # the currently used projection
            #
            if proj is not None and projfile is not None:
                projfile.Remove(proj)

        try:
            WriteProjFile(projfile)
        except IOError, (errno, errstr):
            wxMessageDialog(self, 
                _("The following error occured:\n") + 
                projfile.GetFileName() + "\n" + errstr, 
                _("Error"), wxOK | wxICON_ERROR).ShowModal()


        self.__FillAvailList()

        #
        # this *could* produce incorrect results if the .proj files 
        # change between the last list update and this selection
        # because the list has been repopulated.
        #
        if newselection != -1 and self.availprojs.GetCount() > 0:
            self.availprojs.SetSelection(newselection)

    def _OnProjName(self, event):
        self.__VerifyButtons()

    def __VerifyButtons(self):
        sel = self.availprojs.GetSelections()

        self.button_import.Enable(True)
        self.button_export.Enable(True)
        self.button_save.Enable(True)
        self.button_remove.Enable(True)

        self.panel_edit.Enable(True)

        if len(sel) == 0:
            self.button_import.Enable(True)
            self.button_export.Enable(False)
            self.button_remove.Enable(False)

        elif len(sel) == 1:

            proj, projFile = self.availprojs.GetClientData(sel[0])

            self.button_save.Enable(len(self.projname.GetValue()) > 0)
            self.button_add.Enable(len(self.projname.GetValue()) > 0)

            if proj is None:
                self.button_export.Enable(False)
                self.button_remove.Enable(False)

            if projFile is None:
                self.button_save.Enable(False)

        else:
            self.panel_edit.Enable(False)

    def __DoOnNew(self):
        sel = self.availprojs.GetSelections()
        if len(sel) != 0:
            self.availprojs.SetSelection(sel, False)
        self.projname.Clear()
        self.curProjPanel.Clear()

    def __DoOnProjAvail(self):

        sel = self.availprojs.GetSelections()
        if len(sel) == 1: 

            proj = self.availprojs.GetClientData(sel[0])[CLIENT_PROJ]
            projfile = self.availprojs.GetClientData(sel[0])[CLIENT_PROJFILE]

            if proj is None:
                # user selected <None>
                self.projname.Clear()
            else:
            
                if projfile is not None:
                    self.projfilepath.SetLabel(projfile.GetFileName())
                else:
                    # only None if the currently used projection is selected
                    self.projfilepath.SetLabel("")

                self.projname.SetValue(proj.GetName())

                myProjType = proj.GetParameter("proj")
                i = 0
                for projType, name, clazz in self.projPanels:
                    if myProjType == projType:
                        self.projchoice.SetSelection(i)
                        self.__DoOnProjChoice()
                        self.curProjPanel.SetProjection(proj)
                    i += 1

        self.__VerifyButtons()

    def _OnProjChoice(self, event):
        self.__DoOnProjChoice()

    def __DoOnProjChoice(self):
        choice = self.projchoice

        sel = choice.GetSelection()
        if sel != -1:

            clazz, obj = choice.GetClientData(sel)

            if obj is None:
                obj = clazz(self.panel_edit, self.receiver)
                choice.SetClientData(sel, [clazz, obj])

            if self.curProjPanel is not None:
                self.curProjPanel.Hide()
                self.sizer_projctrls.Remove(self.curProjPanel)

            self.curProjPanel = obj
            self.curProjPanel.Show()

            self.sizer_projctrls.Add(self.curProjPanel, 1, 
                wxALL|wxEXPAND|wxADJUST_MINSIZE, 3)
            self.sizer_projctrls.Layout()
            self.Layout()
            self.topBox.SetSizeHints(self)

    def __SetProjection(self):

        #
        # save the original projection only once in case 
        # we try to apply several different projections
        #
        if self.originalProjection == -1:
            self.originalProjection = self.receiver.GetProjection()

        self.receiver.SetProjection(self.__GetProjection())

    def __GetProjection(self):
        """Return the packaged projection.

        Could be None.
        """

        proj = None

        if self.curProjPanel is not None:
            proj = Projection(self.curProjPanel.GetParameters())
            proj.SetName(self.projname.GetValue())

        return proj

    def __FillAvailList(self):
        self.availprojs.Clear()

        #
        # the list can never be empty. there will always be 
        # at least this one item
        #
        self.availprojs.Append("<None>", (None, None))

        self.__sysProjFile = None
        self.__usrProjFile = None

        projfile = GetSystemProjFiles()
        if len(projfile) > 0:
            projfile = projfile[0]
            for proj in projfile.GetProjections():
                self.availprojs.Append(proj.GetName(), [proj, projfile])
            self.__sysProjFile = projfile

        projfile = GetUserProjFiles()
        if len(projfile) > 0:
            projfile = projfile[0]
            for proj in projfile.GetProjections():
                self.availprojs.Append(proj.GetName(), [proj, projfile])
            self.__usrProjFile = projfile

#       projfiles = GetSystemProjFiles()
#       for projfile in projfiles:
#           for proj in projfile.GetProjections():
#               self.availprojs.Append(proj.GetName(), [proj, projfile])
#       self.__sysProjFiles = projfiles

#       projfiles = GetUserProjFiles()
#       for projfile in projfiles:
#           for proj in projfile.GetProjections():
#               self.availprojs.Append(proj.GetName(), [proj, projfile])
#       self.__usrProjFiles = projfiles

        proj = self.receiver.GetProjection()
        if proj is not None:
            self.availprojs.Append(proj.GetName() + _(" (current)"), 
                                   [proj, None])

        for proj, name, clazz in self.projPanels:
            self.projchoice.Append(name, [clazz, None])

    def __set_properties(self):
        self.__FillAvailList()

        # begin wxGlade: ProjFrame.__set_properties
        self.SetTitle(_("Projections"))
        self.availprojs.SetSelection(0)
        self.projchoice.SetSelection(0)
        # end wxGlade

        self.projname.SetMaxLength(32)

    def __do_layout(self):
        # originally generated by wxGlade

        self.topBox = wxBoxSizer(wxVERTICAL)
        self.sizer_panel = wxBoxSizer(wxVERTICAL)
        sizer_6 = wxBoxSizer(wxHORIZONTAL)
        self.sizer_mainctrls = wxBoxSizer(wxHORIZONTAL)
        self.sizer_edit = wxStaticBoxSizer(wxStaticBox(self.panel_edit, -1, _("Edit")), wxHORIZONTAL)
        sizer_11 = wxBoxSizer(wxVERTICAL)
        self.sizer_projctrls = wxBoxSizer(wxVERTICAL)
        sizer_14 = wxBoxSizer(wxHORIZONTAL)
        sizer_13 = wxBoxSizer(wxHORIZONTAL)
        sizer_15 = wxBoxSizer(wxVERTICAL)
        sizer_15.Add(self.button_import, 0, wxALL, 4)
        sizer_15.Add(self.button_export, 0, wxALL, 4)
        sizer_15.Add(20, 20, 0, wxEXPAND, 0)
        sizer_15.Add(self.button_remove, 0, wxALL|wxALIGN_BOTTOM, 4)

        # list controls
        grid_sizer_1 = wxFlexGridSizer(3, 2, 0, 0)
        grid_sizer_1.Add(self.label_5, 0, wxLEFT|wxRIGHT|wxTOP, 4)
        grid_sizer_1.Add(20, 20, 0, wxEXPAND, 0)
        grid_sizer_1.Add(self.availprojs, 1, wxALL|wxEXPAND|wxADJUST_MINSIZE, 4)
        grid_sizer_1.Add(sizer_15, 0, wxALL|wxEXPAND, 4)
        grid_sizer_1.Add(self.projfilepath, 0, wxALL|wxADJUST_MINSIZE, 4)
        grid_sizer_1.AddGrowableRow(1)
        grid_sizer_1.AddGrowableCol(0)

        # edit controls
        sizer_13.Add(self.label_2, 0, wxALL|wxALIGN_CENTER_VERTICAL, 4)
        sizer_13.Add(self.projname, 1, wxALL, 4)
        self.sizer_projctrls.Add(sizer_13, 0, wxEXPAND, 0)
        sizer_14.Add(self.label_3, 0, wxALL|wxALIGN_CENTER_VERTICAL, 4)
        sizer_14.Add(self.projchoice, 1, wxALL|wxEXPAND|wxADJUST_MINSIZE, 4)
        self.sizer_projctrls.Add(sizer_14, 0, wxEXPAND, 0)
        self.sizer_edit.Add(self.sizer_projctrls, 1, wxEXPAND, 0)
        sizer_11.Add(self.button_new, 0, wxALL|wxEXPAND, 4)
        sizer_11.Add(self.button_save, 0, wxALL|wxEXPAND, 4)
        sizer_11.Add(self.button_add, 0, wxALL|wxEXPAND, 4)
        self.sizer_edit.Add(sizer_11, 0, wxALL|wxEXPAND, 4)

        sizer_6.Add(20, 20, 1, wxEXPAND, 0)
        sizer_6.Add(self.button_try, 0, wxALL, 4)
        sizer_6.Add(20, 20, 1, 0, 0)
        sizer_6.Add(self.button_revert, 0, wxALL, 4)
        sizer_6.Add(20, 20, 1, 0, 0)
        sizer_6.Add(self.button_ok, 0, wxALL, 4)
        sizer_6.Add(20, 20, 1, 0, 0)
        sizer_6.Add(self.button_close, 0, wxALL, 4)
        sizer_6.Add(20, 20, 1, wxEXPAND, 0)

        self.panel_1.SetAutoLayout(1)
        self.panel_1.SetSizer(grid_sizer_1)
        grid_sizer_1.Fit(self.panel_1)
        grid_sizer_1.SetSizeHints(self.panel_1)

        self.panel_edit.SetAutoLayout(1)
        self.panel_edit.SetSizer(self.sizer_edit)
        self.sizer_edit.Fit(self.panel_edit)
        self.sizer_edit.SetSizeHints(self.panel_edit)

        self.panel_buttons.SetAutoLayout(1)
        self.panel_buttons.SetSizer(sizer_6)
        sizer_6.Fit(self.panel_buttons)
        sizer_6.SetSizeHints(self.panel_buttons)

        self.sizer_mainctrls.Add(self.panel_1, 0, 
            wxALL|wxEXPAND|wxADJUST_MINSIZE, 0)
        self.sizer_mainctrls.Add(self.panel_edit, 1, 
            wxALL|wxEXPAND|wxADJUST_MINSIZE, 0)

        self.topBox.Add(self.sizer_mainctrls, 1, wxALL|wxEXPAND, 4)
        self.topBox.Add(self.panel_buttons, 0, wxEXPAND, 0)

        self.SetAutoLayout(1)
        self.SetSizer(self.topBox)
        self.topBox.Fit(self)
        self.topBox.SetSizeHints(self)
        self.Layout()

# end of class ProjFrame


class ProjPanel(wxPanel):
    """Base class for all projection panels."""

    def __init__(self, parent):
        wxPanel.__init__(self, parent, -1)

        self.__ellps = wxChoice(self, -1)
        self.ellpsData = [("bessel", _("Bessel 1841")),
                          ("clrk66", _("Clarke 1866")), 
                          ("clrk80", _("Clarke 1880")),
                          ("GRS80" , _("GRS 1980 (IUGG, 1980)")),
                          ("intl"  , _("International 1909 (Hayford)")),
                          ("WGS84" , _("WGS 84"))]

        for tag, name in self.ellpsData:
            self.__ellps.Append(name, tag)

        self.__ellps.SetSelection(0)
        
    def _DoLayout(self, childPanel = None):

        panelSizer = wxBoxSizer(wxVERTICAL)

        if childPanel is not None:
            panelSizer.Add(childPanel, 0, wxALL|wxEXPAND, 4)
            
        sizer = wxBoxSizer(wxHORIZONTAL)
        sizer.Add(wxStaticText(self, -1, _("Ellipsoid:")), 0, wxALL, 4)
        sizer.Add(self.__ellps, 1, wxALL|wxEXPAND|wxADJUST_MINSIZE, 4)
        panelSizer.Add(sizer, 0, wxALL|wxEXPAND, 4)

        self.SetAutoLayout(1)
        self.SetSizer(panelSizer)
        panelSizer.Fit(self)
        panelSizer.SetSizeHints(self)
        self.Layout()

    def SetProjection(self, proj):
        if proj is not None:
            param = proj.GetParameter("ellps")
            i = 0
            for tag, name in self.ellpsData:
                if param == tag:
                    self.__ellps.SetSelection(i)
                    return # returning early!
                i += 1

        #
        # if proj is none, or the parameter couldn't be found...
        #
        self.__ellps.SetSelection(0)

    def GetParameters(self):
        return ["ellps=" + self.__ellps.GetClientData(
                                        self.__ellps.GetSelection())]


ID_TMPANEL_LAT = 4001
ID_TMPANEL_LONG = 4002
ID_TMPANEL_FASLE_EAST = 4003
ID_TMPANEL_FALSE_NORTH = 4004
ID_TMPANEL_SCALE = 4005

class UnknownProjPanel(ProjPanel):
    def __init__(self, parent, receiver):
        ProjPanel.__init__(self, parent)

        self._DoLayout()

    def _DoLayout(self):
        sizer = wxBoxSizer(wxVERTICAL)

        sizer.Add(wxStaticText(self, -1, 
            _("Thuban does not know the parameters for the " + 
              "current projection and cannot display a " + 
              "configuration panel.")))

        ProjPanel._DoLayout(self, sizer)

    def GetProjName(self):
        return "Unknown"

    def SetProjection(self, proj):
        pass

    def GetParameters(self):
        return None

class TMPanel(ProjPanel):
    """Projection panel for Transverse Mercator."""

    def __init__(self, parent, receiver):
        ProjPanel.__init__(self, parent)

        self.__latitude = wxTextCtrl(self, ID_TMPANEL_LAT)
        self.__longitude = wxTextCtrl(self, ID_TMPANEL_LONG)
        self.__falseEast = wxTextCtrl(self, ID_TMPANEL_FASLE_EAST)
        self.__falseNorth = wxTextCtrl(self, ID_TMPANEL_FALSE_NORTH)
        self.__scale = wxTextCtrl(self, ID_TMPANEL_SCALE)

        self._DoLayout()

    def _DoLayout(self):

        sizer = wxFlexGridSizer(4, 4, 0, 0)
        sizer.Add(wxStaticText(self, -1, _("Latitude:")), 0, wxALL, 4)
        sizer.Add(self.__latitude, 0, wxALL, 4)
        sizer.Add(wxStaticText(self, -1, _("False Easting:")), 0, wxALL, 4)
        sizer.Add(self.__falseEast, 0, wxALL, 4)
        sizer.Add(wxStaticText(self, -1, _("Longitude:")), 0, wxALL, 4)
        sizer.Add(self.__longitude, 0, wxALL, 4)
        sizer.Add(wxStaticText(self, -1, _("False Northing:")), 0, wxALL, 4)
        sizer.Add(self.__falseNorth, 0, wxALL, 4)
        sizer.Add(wxStaticText(self, -1, _("Scale Factor:")), 0, wxALL, 4)
        sizer.Add(self.__scale, 0, wxALL, 4)

        ProjPanel._DoLayout(self, sizer)

    def GetProjName(self):
        return _("Transverse Mercator")

    def SetProjection(self, proj):
        ProjPanel.SetProjection(self, proj)

        self.__latitude.SetValue(proj.GetParameter("lat_0"))
        self.__longitude.SetValue(proj.GetParameter("lon_0"))
        self.__falseEast.SetValue(proj.GetParameter("x_0"))
        self.__falseNorth.SetValue(proj.GetParameter("y_0"))
        self.__scale.SetValue(proj.GetParameter("k"))

        ProjPanel.SetProjection(self, proj)

    def GetParameters(self):
        params = ["proj=tmerc",
                  "lat_0=" + self.__latitude.GetValue(),
                  "lon_0=" + self.__longitude.GetValue(),
                  "x_0="   + self.__falseEast.GetValue(),
                  "y_0="   + self.__falseNorth.GetValue(),
                  "k="     + self.__scale.GetValue()]
        params.extend(ProjPanel.GetParameters(self))
        return params

    def Clear(self):
        self.__latitude.Clear()
        self.__longitude.Clear()
        self.__falseEast.Clear()
        self.__falseNorth.Clear()
        self.__scale.Clear()

        ProjPanel.Clear(self)

ID_UTMPANEL_ZONE = 4001
ID_UTMPANEL_SOUTH = 4002
ID_UTMPANEL_PROP = 4003

class UTMPanel(ProjPanel):
    """Projection Panel for Universal Transverse Mercator."""

    def __init__(self, parent, receiver):
        ProjPanel.__init__(self, parent)

        self.receiver = receiver

        self.__zone = wxSpinCtrl(self, ID_UTMPANEL_ZONE, "1", min=1, max=60)
        self.__south = wxCheckBox(self, ID_UTMPANEL_SOUTH, 
                                  _("Southern Hemisphere"))
        self.__propButton = wxButton(self, ID_UTMPANEL_PROP, _("Propose"))

        self._DoLayout()

        EVT_BUTTON(self, ID_UTMPANEL_PROP, self._OnPropose)

    def _DoLayout(self):

        sizer = wxBoxSizer(wxVERTICAL)
        psizer = wxBoxSizer(wxHORIZONTAL)
        psizer.Add(wxStaticText(self, -1, _("Zone:")), 0, wxALL, 4)
        psizer.Add(self.__zone, 0, wxALL, 4)
        psizer.Add(self.__propButton, 0, wxALL, 4)
        sizer.Add(psizer, 0, wxALL, 4)
        sizer.Add(self.__south, 0, wxALL, 4)

        ProjPanel._DoLayout(self, sizer)

    def GetProjName(self):
        return _("Universal Transverse Mercator")

    def SetProjection(self, proj):
        self.__zone.SetValue(int(proj.GetParameter("zone")))
        self.__south.SetValue(proj.GetParameter("south") != "")
        ProjPanel.SetProjection(self, proj)

    def GetParameters(self):
        params = ["proj=utm", "zone=" + str(self.__zone.GetValue())]
        if self.__south.IsChecked():
            params.append("south")

        params.extend(ProjPanel.GetParameters(self))
        return params

    def Clear(self):
        self.__zone.SetValue(1)
        self.__south.SetValue(False)
        ProjPanel.Clear(self)

    def _OnPropose(self, event):
        UTMProposeZoneDialog
        dlg = UTMProposeZoneDialog(self, self.receiver.BoundingBox())
        if dlg.ShowModal() == wxID_OK:
            self.__zone.SetValue(dlg.GetProposedZone())

class LCCPanel(ProjPanel): 
    """Projection Panel for Lambert Conic Conformal."""

    def __init__(self, parent, receiver):
        ProjPanel.__init__(self, parent)
        
        self.__fspLatitude = wxTextCtrl(self, -1)
        self.__sspLatitude = wxTextCtrl(self, -1)
        self.__originLat   = wxTextCtrl(self, -1)
        self.__meridian    = wxTextCtrl(self, -1)
        self.__falseEast   = wxTextCtrl(self, -1)
        self.__falseNorth  = wxTextCtrl(self, -1)

        self._DoLayout()

    def _DoLayout(self):

        sizer = wxFlexGridSizer(6, 2, 0, 0)
        sizer.Add(wxStaticText(self, -1, 
            _("Latitude of first standard parallel:")))
        sizer.Add(self.__fspLatitude, 0, wxALL, 4)
        sizer.Add(wxStaticText(self, -1,
            _("Latitude of second standard parallel:")))
        sizer.Add(self.__sspLatitude, 0, wxALL, 4)
        sizer.Add(wxStaticText(self, -1, _("Latitude of origin:")))
        sizer.Add(self.__originLat, 0, wxALL, 4)
        sizer.Add(wxStaticText(self, -1, _("Central Meridian:")))
        sizer.Add(self.__meridian, 0, wxALL, 4)
        sizer.Add(wxStaticText(self, -1, _("False Easting:")))
        sizer.Add(self.__falseEast, 0, wxALL, 4)
        sizer.Add(wxStaticText(self, -1, _("False Northing:")))
        sizer.Add(self.__falseNorth, 0, wxALL, 4)

        ProjPanel._DoLayout(self, sizer)

    def GetProjName(self):
        return _("Lambert Conic Conformal")
        
    def SetProjection(self, proj):
        self.__fspLatitude.SetValue(proj.GetParameter("lat_1"))
        self.__sspLatitude.SetValue(proj.GetParameter("lat_2"))
        self.__originLat.SetValue(proj.GetParameter("lat_0"))
        self.__meridian.SetValue(proj.GetParameter("lon_0"))
        self.__falseEast.SetValue(proj.GetParameter("x_0"))
        self.__falseNorth.SetValue(proj.GetParameter("y_0"))

        ProjPanel.SetProjection(self, proj)

    def GetParameters(self):
        params = ["proj=lcc", 
                  "lat_1=" + self.__fspLatitude.GetValue(),
                  "lat_2=" + self.__sspLatitude.GetValue(),
                  "lat_0=" + self.__originLat.GetValue(),
                  "lon_0=" + self.__meridian.GetValue(),
                  "x_0=" + self.__falseEast.GetValue(),
                  "y_0=" + self.__falseNorth.GetValue()]

        params.extend(ProjPanel.GetParameters(self))
        return params

    def Clear(self):
        self.__fspLatitude.Clear()
        self.__sspLatitude.Clear()
        self.__originLat.Clear()
        self.__meridian.Clear()
        self.__falseEast.Clear()
        self.__falseNorth.Clear()

        ProjPanel.Clear(self)

class GeoPanel(ProjPanel): 
    """Projection Panel for a Geographic Projection."""

    def __init__(self, parent, receiver):
        ProjPanel.__init__(self, parent)
        ProjPanel._DoLayout(self, None)

    def GetProjName(self):
        return _("Geographic")
        
    def SetProjection(self, proj):
        ProjPanel.SetProjection(self, proj)

    def GetParameters(self):
        params = ["proj=latlong"]
        params.extend(ProjPanel.GetParameters(self))
        return params

    def Clear(self):
        ProjPanel.Clear(self)


ID_UTM_PROPOSE_ZONE_DIALOG_TAKE   = 4001
ID_UTM_PROPOSE_ZONE_DIALOG_CANCEL = 4002
class UTMProposeZoneDialog(wxDialog):
                                                                                
    """Propose a sensible Zone considering the current map extent."""
                                                                                
    def __init__(self, parent, (x, y, x2, y2)):
        wxDialog.__init__(self, parent, -1, _("Projection: Propose UTM Zone"),
                          wxDefaultPosition, wxSize(200, 100))
        self.parent = parent
        #x, y, x2, y2 = elf.parent.parent.map_bounding_box
        x = x + 180
        x2 = x2 + 180
        center = (x2 - x) / 2 + x
        self.proposedZone = int(center / 6 + 1)
        self.dialogLayout()
                                                                                
    def dialogLayout(self):
        topBox = wxBoxSizer(wxVERTICAL)
                                                                                
        textBox = wxBoxSizer(wxVERTICAL)
        textBox.Add(wxStaticText(self, -1, _("The current map extent center " +
                                           "lies in UTM Zone")),
                    0, wxALIGN_CENTER|wxALL, 4)
        textBox.Add(wxStaticText(self, -1, str(self.proposedZone)),
                    0, wxALIGN_CENTER|wxALL, 4)
                                                                                
        topBox.Add(textBox, 1, wxEXPAND|wxALL, 4)
                                                                                
        buttonBox = wxBoxSizer(wxHORIZONTAL)
        buttonBox.Add(wxButton(self, ID_UTM_PROPOSE_ZONE_DIALOG_TAKE,
                      _("Take")), 0, wxALL, 4)
        buttonBox.Add(wxButton(self, ID_UTM_PROPOSE_ZONE_DIALOG_CANCEL,
                               _("Cancel")), 0, wxALL, 4)
        topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 10)
        EVT_BUTTON(self, ID_UTM_PROPOSE_ZONE_DIALOG_TAKE, self.OnTake)
        EVT_BUTTON(self, ID_UTM_PROPOSE_ZONE_DIALOG_CANCEL, self.OnCancel)
                                                                                
        self.SetAutoLayout(True)
        self.SetSizer(topBox)
        topBox.Fit(self)
        topBox.SetSizeHints(self)
                                                                                
    def OnTake(self, event):
        self.EndModal(wxID_OK)
                                                                                
    def OnCancel(self, event):
        self.EndModal(wxID_CANCEL)

    def GetProposedZone(self):
        return self.proposedZone
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision