# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.0
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _WXP
else:
    import _WXP

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class String(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def init(self, *args):
        return _WXP.String_init(self, *args)

    def __init__(self, *args):
        _WXP.String_swiginit(self, _WXP.new_String(*args))
    __swig_destroy__ = _WXP.delete_String

    def set(self, *args):
        return _WXP.String_set(self, *args)

    def reset(self):
        return _WXP.String_reset(self)

    def valid(self):
        return _WXP.String_valid(self)

    def isAlphaNum(self):
        return _WXP.String_isAlphaNum(self)

    def get(self, *args):
        return _WXP.String_get(self, *args)

    def getChar(self, ind):
        return _WXP.String_getChar(self, ind)

    def length(self):
        return _WXP.String_length(self)

    def maxLength(self):
        return _WXP.String_maxLength(self)

    def clear(self):
        return _WXP.String_clear(self)

    def resize(self, *args):
        return _WXP.String_resize(self, *args)

    def rewind(self):
        return _WXP.String_rewind(self)

    def getPtr(self):
        return _WXP.String_getPtr(self)

    def scanf(self, mess):
        return _WXP.String_scanf(self, mess)

    def scanp(self, mess):
        return _WXP.String_scanp(self, mess)

    def printf(self, mess):
        return _WXP.String_printf(self, mess)

    def aprintf(self, mess):
        return _WXP.String_aprintf(self, mess)

    def replace(self, tar, rep):
        return _WXP.String_replace(self, tar, rep)

    def trimWS(self):
        return _WXP.String_trimWS(self)

    def stripWS(self):
        return _WXP.String_stripWS(self)

    def chop(self):
        return _WXP.String_chop(self)

    def upCase(self):
        return _WXP.String_upCase(self)

    def lowCase(self):
        return _WXP.String_lowCase(self)

    def index(self, ch):
        return _WXP.String_index(self, ch)

    def equal(self, *args):
        return _WXP.String_equal(self, *args)

    def iequal(self, *args):
        return _WXP.String_iequal(self, *args)

    def contains(self, str):
        return _WXP.String_contains(self, str)

    def occurs(self, ch):
        return _WXP.String_occurs(self, ch)

    def copy(self, *args):
        return _WXP.String_copy(self, *args)

    def append(self, *args):
        return _WXP.String_append(self, *args)

    def trunc(self, ind):
        return _WXP.String_trunc(self, ind)

    def _print(self):
        return _WXP.String__print(self)

# Register String in _WXP:
_WXP.String_swigregister(String)
class Strings(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.Strings_swiginit(self, _WXP.new_Strings(*args))
    __swig_destroy__ = _WXP.delete_Strings

    def init(self):
        return _WXP.Strings_init(self)

    def clear(self):
        return _WXP.Strings_clear(self)

    def expand(self, num):
        return _WXP.Strings_expand(self, num)

    def add(self, string):
        return _WXP.Strings_add(self, string)

    def set(self, *args):
        return _WXP.Strings_set(self, *args)

    def getString(self, *args):
        return _WXP.Strings_getString(self, *args)

    def getStringAfter(self, ind, ch):
        return _WXP.Strings_getStringAfter(self, ind, ch)

    def getChar(self, ind, off):
        return _WXP.Strings_getChar(self, ind, off)

    def valid(self, ind):
        return _WXP.Strings_valid(self, ind)

    def equal(self, *args):
        return _WXP.Strings_equal(self, *args)

    def iequal(self, *args):
        return _WXP.Strings_iequal(self, *args)

    def find(self, str):
        return _WXP.Strings_find(self, str)

    def index(self, ind, s1):
        return _WXP.Strings_index(self, ind, s1)

    def contains(self, ind, str):
        return _WXP.Strings_contains(self, ind, str)

    def occurs(self, ind, c):
        return _WXP.Strings_occurs(self, ind, c)

    def getLength(self, ind):
        return _WXP.Strings_getLength(self, ind)

    def scanf(self, *args):
        return _WXP.Strings_scanf(self, *args)

    def getInt(self, *args):
        return _WXP.Strings_getInt(self, *args)

    def getIntAfter(self, ind, ch):
        return _WXP.Strings_getIntAfter(self, ind, ch)

    def getFloat(self, *args):
        return _WXP.Strings_getFloat(self, *args)

    def getFloatAfter(self, ind, ch):
        return _WXP.Strings_getFloatAfter(self, ind, ch)

    def check(self, ind, pat):
        return _WXP.Strings_check(self, ind, pat)

    def getNum(self):
        return _WXP.Strings_getNum(self)

    def _print(self):
        return _WXP.Strings__print(self)

# Register Strings in _WXP:
_WXP.Strings_swigregister(Strings)
class Resrc(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.Resrc_swiginit(self, _WXP.new_Resrc())
    __swig_destroy__ = _WXP.delete_Resrc

    def clear(self):
        return _WXP.Resrc_clear(self)

    def init(self):
        return _WXP.Resrc_init(self)

    def add(self, name, data, type):
        return _WXP.Resrc_add(self, name, data, type)

    def set(self, *args):
        return _WXP.Resrc_set(self, *args)

    def put(self, name, data):
        return _WXP.Resrc_put(self, name, data)

    def prepend(self, *args):
        return _WXP.Resrc_prepend(self, *args)

    def append(self, *args):
        return _WXP.Resrc_append(self, *args)

    def getType(self, name):
        return _WXP.Resrc_getType(self, name)

    def getValues(self, name, value, flag):
        return _WXP.Resrc_getValues(self, name, value, flag)

    def getBool(self, name):
        return _WXP.Resrc_getBool(self, name)

    def get(self, *args):
        return _WXP.Resrc_get(self, *args)

    def scanf(self, name, form):
        return _WXP.Resrc_scanf(self, name, form)

    def rewind(self):
        return _WXP.Resrc_rewind(self)

    def getNext(self):
        return _WXP.Resrc_getNext(self)

    def _print(self, name):
        return _WXP.Resrc__print(self, name)

    def printAll(self):
        return _WXP.Resrc_printAll(self)
    NONE = _WXP.Resrc_NONE
    BASE = _WXP.Resrc_BASE
    FILE = _WXP.Resrc_FILE
    ENV = _WXP.Resrc_ENV
    COMMAND = _WXP.Resrc_COMMAND
    USER = _WXP.Resrc_USER

# Register Resrc in _WXP:
_WXP.Resrc_swigregister(Resrc)
class Const(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.Const_swiginit(self, _WXP.new_Const())
    __swig_destroy__ = _WXP.delete_Const

# Register Const in _WXP:
_WXP.Const_swigregister(Const)
cvar = _WXP.cvar
Const.MISS = _WXP.cvar.Const_MISS
Const.PI = _WXP.cvar.Const_PI
Const.EARTH = _WXP.cvar.Const_EARTH
Const.TWO_PI = _WXP.cvar.Const_TWO_PI
Const.DRC = _WXP.cvar.Const_DRC
Const.RDC = _WXP.cvar.Const_RDC
Const.R = _WXP.cvar.Const_R
Const.G = _WXP.cvar.Const_G
Const.CP = _WXP.cvar.Const_CP
Const.CV = _WXP.cvar.Const_CV

class Convert(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def CtoF(t):
        return _WXP.Convert_CtoF(t)

    @staticmethod
    def KtoF(t):
        return _WXP.Convert_KtoF(t)

    @staticmethod
    def CtoK(t):
        return _WXP.Convert_CtoK(t)

    @staticmethod
    def FtoK(t):
        return _WXP.Convert_FtoK(t)

    @staticmethod
    def FtoC(t):
        return _WXP.Convert_FtoC(t)

    @staticmethod
    def KtoC(t):
        return _WXP.Convert_KtoC(t)

    @staticmethod
    def INtoMB(p):
        return _WXP.Convert_INtoMB(p)

    @staticmethod
    def MBtoIN(p):
        return _WXP.Convert_MBtoIN(p)

    @staticmethod
    def KTtoMPS(w):
        return _WXP.Convert_KTtoMPS(w)

    @staticmethod
    def MPStoKT(w):
        return _WXP.Convert_MPStoKT(w)

    @staticmethod
    def KTtoKMH(l):
        return _WXP.Convert_KTtoKMH(l)

    @staticmethod
    def KMHtoKT(l):
        return _WXP.Convert_KMHtoKT(l)

    @staticmethod
    def KTtoMPH(l):
        return _WXP.Convert_KTtoMPH(l)

    @staticmethod
    def MPHtoKT(l):
        return _WXP.Convert_MPHtoKT(l)

    @staticmethod
    def MPHtoMPS(l):
        return _WXP.Convert_MPHtoMPS(l)

    @staticmethod
    def MPStoMPH(l):
        return _WXP.Convert_MPStoMPH(l)

    @staticmethod
    def FTtoM(l):
        return _WXP.Convert_FTtoM(l)

    @staticmethod
    def MtoFT(l):
        return _WXP.Convert_MtoFT(l)

    @staticmethod
    def MtoMI(l):
        return _WXP.Convert_MtoMI(l)

    @staticmethod
    def INtoMM(l):
        return _WXP.Convert_INtoMM(l)

    @staticmethod
    def MMtoIN(l):
        return _WXP.Convert_MMtoIN(l)

    @staticmethod
    def INtoCM(l):
        return _WXP.Convert_INtoCM(l)

    @staticmethod
    def CMtoIN(l):
        return _WXP.Convert_CMtoIN(l)

    @staticmethod
    def SMtoKM(l):
        return _WXP.Convert_SMtoKM(l)

    @staticmethod
    def KMtoSM(l):
        return _WXP.Convert_KMtoSM(l)

    @staticmethod
    def SMtoNM(l):
        return _WXP.Convert_SMtoNM(l)

    @staticmethod
    def NMtoSM(l):
        return _WXP.Convert_NMtoSM(l)

    @staticmethod
    def NMtoKM(l):
        return _WXP.Convert_NMtoKM(l)

    @staticmethod
    def KMtoNM(l):
        return _WXP.Convert_KMtoNM(l)

    @staticmethod
    def NMtoFT(l):
        return _WXP.Convert_NMtoFT(l)

    def __init__(self):
        _WXP.Convert_swiginit(self, _WXP.new_Convert())
    __swig_destroy__ = _WXP.delete_Convert

# Register Convert in _WXP:
_WXP.Convert_swigregister(Convert)
class FloatArray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def init(self, *args):
        return _WXP.FloatArray_init(self, *args)
    __swig_destroy__ = _WXP.delete_FloatArray

    def __init__(self, *args):
        _WXP.FloatArray_swiginit(self, _WXP.new_FloatArray(*args))

    def copy(self, data):
        return _WXP.FloatArray_copy(self, data)

    def clear(self):
        return _WXP.FloatArray_clear(self)

    def expand(self, size):
        return _WXP.FloatArray_expand(self, size)

    def add(self, rval):
        return _WXP.FloatArray_add(self, rval)

    def add1(self, rval):
        return _WXP.FloatArray_add1(self, rval)

    def set(self, *args):
        return _WXP.FloatArray_set(self, *args)

    def get(self, *args):
        return _WXP.FloatArray_get(self, *args)

    def getNum(self):
        return _WXP.FloatArray_getNum(self)

    def offset(self, ind, rval):
        return _WXP.FloatArray_offset(self, ind, rval)

    def _print(self):
        return _WXP.FloatArray__print(self)

# Register FloatArray in _WXP:
_WXP.FloatArray_swigregister(FloatArray)
class FileAttr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    READ = _WXP.FileAttr_READ
    WRITE = _WXP.FileAttr_WRITE
    APPEND = _WXP.FileAttr_APPEND

    def __init__(self):
        _WXP.FileAttr_swiginit(self, _WXP.new_FileAttr())
    __swig_destroy__ = _WXP.delete_FileAttr

# Register FileAttr in _WXP:
_WXP.FileAttr_swigregister(FileAttr)
class Wxp(Const, Convert):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NONE = _WXP.Wxp_NONE
    PRINT = _WXP.Wxp_PRINT
    ERROR = _WXP.Wxp_ERROR
    WARN = _WXP.Wxp_WARN
    MESS = _WXP.Wxp_MESS
    OUT1 = _WXP.Wxp_OUT1
    OUT2 = _WXP.Wxp_OUT2
    OUT3 = _WXP.Wxp_OUT3
    OUT4 = _WXP.Wxp_OUT4
    OUT5 = _WXP.Wxp_OUT5
    OUT6 = _WXP.Wxp_OUT6
    OUT7 = _WXP.Wxp_OUT7
    OUT8 = _WXP.Wxp_OUT8
    DEBUG1 = _WXP.Wxp_DEBUG1
    DEBUG2 = _WXP.Wxp_DEBUG2
    DEBUG3 = _WXP.Wxp_DEBUG3
    DEBUG4 = _WXP.Wxp_DEBUG4
    DEBUG5 = _WXP.Wxp_DEBUG5
    DEBUG6 = _WXP.Wxp_DEBUG6
    DEBUG7 = _WXP.Wxp_DEBUG7
    DEBUG8 = _WXP.Wxp_DEBUG8
    NOERR = _WXP.Wxp_NOERR
    NORUN = _WXP.Wxp_NORUN
    MISC = _WXP.Wxp_MISC
    NOMEMORY = _WXP.Wxp_NOMEMORY
    NOGRAPH = _WXP.Wxp_NOGRAPH
    NOINIT = _WXP.Wxp_NOINIT
    NOFILE = _WXP.Wxp_NOFILE
    NODBASE = _WXP.Wxp_NODBASE
    NOWRITE = _WXP.Wxp_NOWRITE
    NOINPUT = _WXP.Wxp_NOINPUT
    NODATA = _WXP.Wxp_NODATA
    BADPARAM = _WXP.Wxp_BADPARAM

    @staticmethod
    def isDebug(*args):
        return _WXP.Wxp_isDebug(*args)

    @staticmethod
    def setError(val):
        return _WXP.Wxp_setError(val)

    @staticmethod
    def getError():
        return _WXP.Wxp_getError()

    @staticmethod
    def setMessageLevel(*args):
        return _WXP.Wxp_setMessageLevel(*args)

    @staticmethod
    def getMessageLevel():
        return _WXP.Wxp_getMessageLevel()

    @staticmethod
    def setProgramName(str):
        return _WXP.Wxp_setProgramName(str)

    @staticmethod
    def getProgramName():
        return _WXP.Wxp_getProgramName()

    @staticmethod
    def setDatabasePath(str):
        return _WXP.Wxp_setDatabasePath(str)

    @staticmethod
    def getDatabasePath():
        return _WXP.Wxp_getDatabasePath()

    @staticmethod
    def validLicense(*args):
        return _WXP.Wxp_validLicense(*args)

    @staticmethod
    def pause():
        return _WXP.Wxp_pause()

    @staticmethod
    def sleep(secs):
        return _WXP.Wxp_sleep(secs)

    @staticmethod
    def checkMessage(level):
        return _WXP.Wxp_checkMessage(level)

    @staticmethod
    def _print(mess):
        return _WXP.Wxp__print(mess)

    @staticmethod
    def outMessage(*args):
        return _WXP.Wxp_outMessage(*args)

    @staticmethod
    def outWarning(*args):
        return _WXP.Wxp_outWarning(*args)

    @staticmethod
    def outError(*args):
        return _WXP.Wxp_outError(*args)

    @staticmethod
    def outDebug(*args):
        return _WXP.Wxp_outDebug(*args)

    @staticmethod
    def getTime():
        return _WXP.Wxp_getTime()

    @staticmethod
    def getVirtMem():
        return _WXP.Wxp_getVirtMem()

    @staticmethod
    def exit(val):
        return _WXP.Wxp_exit(val)

    @staticmethod
    def getVersion():
        return _WXP.Wxp_getVersion()

    @staticmethod
    def getLicenseVersion():
        return _WXP.Wxp_getLicenseVersion()

    @staticmethod
    def getComputerName():
        return _WXP.Wxp_getComputerName()

    @staticmethod
    def setInitTime(val):
        return _WXP.Wxp_setInitTime(val)

    @staticmethod
    def getInitTime():
        return _WXP.Wxp_getInitTime()

    @staticmethod
    def getResrcBool(name):
        return _WXP.Wxp_getResrcBool(name)

    @staticmethod
    def getResrc(*args):
        return _WXP.Wxp_getResrc(*args)

    @staticmethod
    def addResrc(name, data, type):
        return _WXP.Wxp_addResrc(name, data, type)

    @staticmethod
    def putResrc(name, data):
        return _WXP.Wxp_putResrc(name, data)

    @staticmethod
    def setResrc(name, data):
        return _WXP.Wxp_setResrc(name, data)

    @staticmethod
    def appendResrc(name, data):
        return _WXP.Wxp_appendResrc(name, data)

    @staticmethod
    def printAllResrc():
        return _WXP.Wxp_printAllResrc()

    @staticmethod
    def nextResrc():
        return _WXP.Wxp_nextResrc()

    @staticmethod
    def rewindResrc():
        return _WXP.Wxp_rewindResrc()

    @staticmethod
    def getResrcType(name):
        return _WXP.Wxp_getResrcType(name)

    def __init__(self):
        _WXP.Wxp_swiginit(self, _WXP.new_Wxp())
    __swig_destroy__ = _WXP.delete_Wxp

# Register Wxp in _WXP:
_WXP.Wxp_swigregister(Wxp)
class UnitData(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    _in = property(_WXP.UnitData__in_get, _WXP.UnitData__in_set)
    out = property(_WXP.UnitData_out_get, _WXP.UnitData_out_set)
    cvt = property(_WXP.UnitData_cvt_get, _WXP.UnitData_cvt_set)
    mult = property(_WXP.UnitData_mult_get, _WXP.UnitData_mult_set)
    offset = property(_WXP.UnitData_offset_get, _WXP.UnitData_offset_set)
    ifac = property(_WXP.UnitData_ifac_get, _WXP.UnitData_ifac_set)
    ofac = property(_WXP.UnitData_ofac_get, _WXP.UnitData_ofac_set)
    valid = property(_WXP.UnitData_valid_get, _WXP.UnitData_valid_set)
    flag = property(_WXP.UnitData_flag_get, _WXP.UnitData_flag_set)

    def __init__(self):
        _WXP.UnitData_swiginit(self, _WXP.new_UnitData())

    def init(self):
        return _WXP.UnitData_init(self)
    __swig_destroy__ = _WXP.delete_UnitData

# Register UnitData in _WXP:
_WXP.UnitData_swigregister(UnitData)
class Unit(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.Unit_swiginit(self, _WXP.new_Unit())

    def init(self):
        return _WXP.Unit_init(self)

    def valid(self, _in, out):
        return _WXP.Unit_valid(self, _in, out)

    def convert(self, value, _in, out):
        return _WXP.Unit_convert(self, value, _in, out)

    def readFile(self, uin, uout, data):
        return _WXP.Unit_readFile(self, uin, uout, data)

    @staticmethod
    def scale(_in, rscale, mstr, out):
        return _WXP.Unit_scale(_in, rscale, mstr, out)

    @staticmethod
    def parse(str, var, units):
        return _WXP.Unit_parse(str, var, units)

    @staticmethod
    def change(str, units):
        return _WXP.Unit_change(str, units)

    @staticmethod
    def equal(unit1, unit2):
        return _WXP.Unit_equal(unit1, unit2)

    @staticmethod
    def simplify(*args):
        return _WXP.Unit_simplify(*args)
    __swig_destroy__ = _WXP.delete_Unit

# Register Unit in _WXP:
_WXP.Unit_swigregister(Unit)
class LclData(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    p = property(_WXP.LclData_p_get, _WXP.LclData_p_set)
    t = property(_WXP.LclData_t_get, _WXP.LclData_t_set)

    def __init__(self):
        _WXP.LclData_swiginit(self, _WXP.new_LclData())

    def init(self):
        return _WXP.LclData_init(self)

    def getP(self):
        return _WXP.LclData_getP(self)

    def getT(self):
        return _WXP.LclData_getT(self)

    def _print(self):
        return _WXP.LclData__print(self)
    __swig_destroy__ = _WXP.delete_LclData

# Register LclData in _WXP:
_WXP.LclData_swigregister(LclData)
class Calc(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def windSpd(u, v):
        return _WXP.Calc_windSpd(u, v)

    @staticmethod
    def windDir(u, v):
        return _WXP.Calc_windDir(u, v)

    @staticmethod
    def windU(dir, spd):
        return _WXP.Calc_windU(dir, spd)

    @staticmethod
    def windV(dir, spd):
        return _WXP.Calc_windV(dir, spd)

    @staticmethod
    def vaporPres(t):
        return _WXP.Calc_vaporPres(t)

    @staticmethod
    def windChillTemp(temp, ws):
        return _WXP.Calc_windChillTemp(temp, ws)

    @staticmethod
    def windChillTemp2(temp, ws):
        return _WXP.Calc_windChillTemp2(temp, ws)

    @staticmethod
    def windChill(temp, ws):
        return _WXP.Calc_windChill(temp, ws)

    @staticmethod
    def heatIndex(temp, dewp):
        return _WXP.Calc_heatIndex(temp, dewp)

    @staticmethod
    def humiture(temp, dewp):
        return _WXP.Calc_humiture(temp, dewp)

    @staticmethod
    def tempHumIndex(temp, dewp):
        return _WXP.Calc_tempHumIndex(temp, dewp)

    @staticmethod
    def sfcPrAlt(alt, el):
        return _WXP.Calc_sfcPrAlt(alt, el)

    @staticmethod
    def presAlt(pres):
        return _WXP.Calc_presAlt(pres)

    @staticmethod
    def mixRatio(temp, pr):
        return _WXP.Calc_mixRatio(temp, pr)

    @staticmethod
    def specHum(temp, pr):
        return _WXP.Calc_specHum(temp, pr)

    @staticmethod
    def dewTemp(temp, rh):
        return _WXP.Calc_dewTemp(temp, rh)

    @staticmethod
    def potTemp(temp, pr):
        return _WXP.Calc_potTemp(temp, pr)

    @staticmethod
    def virtTemp(temp, dewp, pr):
        return _WXP.Calc_virtTemp(temp, dewp, pr)

    @staticmethod
    def virtPotTemp(temp, dewp, pr):
        return _WXP.Calc_virtPotTemp(temp, dewp, pr)

    @staticmethod
    def tempOnSatAd(pot, pr):
        return _WXP.Calc_tempOnSatAd(pot, pr)

    @staticmethod
    def tempOnDryAd(pot, pr):
        return _WXP.Calc_tempOnDryAd(pot, pr)

    @staticmethod
    def thetaeOnSatAd(temp, pr):
        return _WXP.Calc_thetaeOnSatAd(temp, pr)

    @staticmethod
    def tempVaporPres(e):
        return _WXP.Calc_tempVaporPres(e)

    @staticmethod
    def tempOnMixRat(w, pr):
        return _WXP.Calc_tempOnMixRat(w, pr)

    @staticmethod
    def relHum(t, td):
        return _WXP.Calc_relHum(t, td)

    @staticmethod
    def convTemp(wbar, pc, pr):
        return _WXP.Calc_convTemp(wbar, pc, pr)

    @staticmethod
    def lclPres(ts, tds, ps):
        return _WXP.Calc_lclPres(ts, tds, ps)

    @staticmethod
    def lclTemp(ts, ps, plcl):
        return _WXP.Calc_lclTemp(ts, ps, plcl)

    @staticmethod
    def lcl(*args):
        return _WXP.Calc_lcl(*args)

    @staticmethod
    def equivPotTemp(temp, dewp, pr):
        return _WXP.Calc_equivPotTemp(temp, dewp, pr)

    @staticmethod
    def wetBulb(temp, dewp, pr):
        return _WXP.Calc_wetBulb(temp, dewp, pr)

    @staticmethod
    def wetBulbPotTemp(temp, dewp, pr):
        return _WXP.Calc_wetBulbPotTemp(temp, dewp, pr)

    @staticmethod
    def stdAtmsPres(height):
        return _WXP.Calc_stdAtmsPres(height)

    @staticmethod
    def interpLinear(x, x1, x2, y1, y2):
        return _WXP.Calc_interpLinear(x, x1, x2, y1, y2)

    @staticmethod
    def interpTemp(t1, t2, p1, p2, pr):
        return _WXP.Calc_interpTemp(t1, t2, p1, p2, pr)

    @staticmethod
    def earthDist(lat1, lon1, lat2, lon2):
        return _WXP.Calc_earthDist(lat1, lon1, lat2, lon2)

    @staticmethod
    def earthAngle(lat1, lon1, lat2, lon2):
        return _WXP.Calc_earthAngle(lat1, lon1, lat2, lon2)

    @staticmethod
    def dist(x1, y1, x2, y2):
        return _WXP.Calc_dist(x1, y1, x2, y2)

    @staticmethod
    def Min(x, y):
        return _WXP.Calc_Min(x, y)

    @staticmethod
    def Max(x, y):
        return _WXP.Calc_Max(x, y)

    @staticmethod
    def ADD(x, y):
        return _WXP.Calc_ADD(x, y)

    @staticmethod
    def DIF(x, y):
        return _WXP.Calc_DIF(x, y)

    @staticmethod
    def MUL(x, y):
        return _WXP.Calc_MUL(x, y)

    @staticmethod
    def DIV(x, y):
        return _WXP.Calc_DIV(x, y)

    def __init__(self):
        _WXP.Calc_swiginit(self, _WXP.new_Calc())
    __swig_destroy__ = _WXP.delete_Calc

# Register Calc in _WXP:
_WXP.Calc_swigregister(Calc)
class DateVal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    year = property(_WXP.DateVal_year_get, _WXP.DateVal_year_set)
    month = property(_WXP.DateVal_month_get, _WXP.DateVal_month_set)
    day = property(_WXP.DateVal_day_get, _WXP.DateVal_day_set)
    hour = property(_WXP.DateVal_hour_get, _WXP.DateVal_hour_set)
    min = property(_WXP.DateVal_min_get, _WXP.DateVal_min_set)
    sec = property(_WXP.DateVal_sec_get, _WXP.DateVal_sec_set)
    num_day = property(_WXP.DateVal_num_day_get, _WXP.DateVal_num_day_set)
    num_day_leap = property(_WXP.DateVal_num_day_leap_get, _WXP.DateVal_num_day_leap_set)

    def init(self):
        return _WXP.DateVal_init(self)

    def __init__(self):
        _WXP.DateVal_swiginit(self, _WXP.new_DateVal())

    def validate(self):
        return _WXP.DateVal_validate(self)

    def computeSecs(self):
        return _WXP.DateVal_computeSecs(self)

    def set(self, ryear, rmonth, rday, rhour, rmin, rsec):
        return _WXP.DateVal_set(self, ryear, rmonth, rday, rhour, rmin, rsec)

    def setYear(self, val):
        return _WXP.DateVal_setYear(self, val)

    def getYear(self):
        return _WXP.DateVal_getYear(self)

    def setMonth(self, val):
        return _WXP.DateVal_setMonth(self, val)

    def getMonth(self):
        return _WXP.DateVal_getMonth(self)

    def setDay(self, val):
        return _WXP.DateVal_setDay(self, val)

    def getDay(self):
        return _WXP.DateVal_getDay(self)

    def setHour(self, val):
        return _WXP.DateVal_setHour(self, val)

    def getHour(self):
        return _WXP.DateVal_getHour(self)

    def setMinute(self, val):
        return _WXP.DateVal_setMinute(self, val)

    def getMinute(self):
        return _WXP.DateVal_getMinute(self)

    def setSecond(self, val):
        return _WXP.DateVal_setSecond(self, val)

    def getSecond(self):
        return _WXP.DateVal_getSecond(self)

    def _print(self):
        return _WXP.DateVal__print(self)
    __swig_destroy__ = _WXP.delete_DateVal

# Register DateVal in _WXP:
_WXP.DateVal_swigregister(DateVal)
class Date(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.Date_swiginit(self, _WXP.new_Date(*args))

    def __gt__(self, date):
        return _WXP.Date___gt__(self, date)

    def __lt__(self, date):
        return _WXP.Date___lt__(self, date)

    def __iadd__(self, rsecs):
        return _WXP.Date___iadd__(self, rsecs)

    def init(self):
        return _WXP.Date_init(self)

    def isSet(self):
        return _WXP.Date_isSet(self)

    def set(self, *args):
        return _WXP.Date_set(self, *args)

    def getVals(self, date):
        return _WXP.Date_getVals(self, date)

    def get(self):
        return _WXP.Date_get(self)

    def setYear(self, val):
        return _WXP.Date_setYear(self, val)

    def getYear(self):
        return _WXP.Date_getYear(self)

    def getYear00(self):
        return _WXP.Date_getYear00(self)

    def setMonth(self, val):
        return _WXP.Date_setMonth(self, val)

    def getMonth(self):
        return _WXP.Date_getMonth(self)

    def setDay(self, val):
        return _WXP.Date_setDay(self, val)

    def getDay(self):
        return _WXP.Date_getDay(self)

    def setHour(self, val):
        return _WXP.Date_setHour(self, val)

    def getHour(self):
        return _WXP.Date_getHour(self)

    def setMinute(self, val):
        return _WXP.Date_setMinute(self, val)

    def getMinute(self):
        return _WXP.Date_getMinute(self)

    def setSecond(self, val):
        return _WXP.Date_setSecond(self, val)

    def setFractionalSecond(self, val):
        return _WXP.Date_setFractionalSecond(self, val)

    def getSecond(self):
        return _WXP.Date_getSecond(self)

    def getSeconds(self):
        return _WXP.Date_getSeconds(self)

    def isLeap(self):
        return _WXP.Date_isLeap(self)

    def setDays(self, days):
        return _WXP.Date_setDays(self, days)

    def setTime(self, *args):
        return _WXP.Date_setTime(self, *args)

    def getDays(self):
        return _WXP.Date_getDays(self)

    def addYears(self, years):
        return _WXP.Date_addYears(self, years)

    def addMonths(self, months):
        return _WXP.Date_addMonths(self, months)

    def addDays(self, days):
        return _WXP.Date_addDays(self, days)

    def addHours(self, hours):
        return _WXP.Date_addHours(self, hours)

    def addMinutes(self, mins):
        return _WXP.Date_addMinutes(self, mins)

    def addSeconds(self, secs):
        return _WXP.Date_addSeconds(self, secs)

    def getDayOfWeek(self):
        return _WXP.Date_getDayOfWeek(self)

    def toString(self, str):
        return _WXP.Date_toString(self, str)

    def toText(self, *args):
        return _WXP.Date_toText(self, *args)

    def changeTimezone(self, roff, tz):
        return _WXP.Date_changeTimezone(self, roff, tz)

    def adjustMinute(self, *args):
        return _WXP.Date_adjustMinute(self, *args)

    def adjustSecond(self, rhour, rmin, rsec):
        return _WXP.Date_adjustSecond(self, rhour, rmin, rsec)

    def adjustHour(self, *args):
        return _WXP.Date_adjustHour(self, *args)

    def fix(self):
        return _WXP.Date_fix(self)

    def _print(self):
        return _WXP.Date__print(self)

    def printSeconds(self):
        return _WXP.Date_printSeconds(self)

    @staticmethod
    def getCurrentSeconds():
        return _WXP.Date_getCurrentSeconds()

    @staticmethod
    def isYearLeap(year):
        return _WXP.Date_isYearLeap(year)

    @staticmethod
    def setJulian(*args):
        return _WXP.Date_setJulian(*args)

    @staticmethod
    def getJulian(*args):
        return _WXP.Date_getJulian(*args)
    __swig_destroy__ = _WXP.delete_Date

# Register Date in _WXP:
_WXP.Date_swigregister(Date)
class Buffer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def initClass(self):
        return _WXP.Buffer_initClass(self)

    def init(self, rsize):
        return _WXP.Buffer_init(self, rsize)
    __swig_destroy__ = _WXP.delete_Buffer

    def __init__(self, *args):
        _WXP.Buffer_swiginit(self, _WXP.new_Buffer(*args))

    def copy(self, data):
        return _WXP.Buffer_copy(self, data)

    def clear(self):
        return _WXP.Buffer_clear(self)

    def resize(self, rsize):
        return _WXP.Buffer_resize(self, rsize)

    def check(self, rsize):
        return _WXP.Buffer_check(self, rsize)

    def add(self, dat, rsize):
        return _WXP.Buffer_add(self, dat, rsize)

    def insert(self, *args):
        return _WXP.Buffer_insert(self, *args)

    def get(self, *args):
        return _WXP.Buffer_get(self, *args)

    def read(self, *args):
        return _WXP.Buffer_read(self, *args)

    def readLine(self, dat, rsize):
        return _WXP.Buffer_readLine(self, dat, rsize)

    def skipLine(self):
        return _WXP.Buffer_skipLine(self)

    def clearUsed(self):
        return _WXP.Buffer_clearUsed(self)

    def seek(self, num):
        return _WXP.Buffer_seek(self, num)

    def inc(self, num):
        return _WXP.Buffer_inc(self, num)

    def trunc(self, num):
        return _WXP.Buffer_trunc(self, num)

    def equal(self, off, str):
        return _WXP.Buffer_equal(self, off, str)

    def getInd(self):
        return _WXP.Buffer_getInd(self)

    def getSize(self):
        return _WXP.Buffer_getSize(self)

    def getAvail(self):
        return _WXP.Buffer_getAvail(self)

    def getMax(self):
        return _WXP.Buffer_getMax(self)

    def _print(self):
        return _WXP.Buffer__print(self)

    def dump(self, *args):
        return _WXP.Buffer_dump(self, *args)

# Register Buffer in _WXP:
_WXP.Buffer_swigregister(Buffer)
class Timezone(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.Timezone_swiginit(self, _WXP.new_Timezone(*args))

    def set(self, str):
        return _WXP.Timezone_set(self, str)

    def init(self):
        return _WXP.Timezone_init(self)

    def isSet(self):
        return _WXP.Timezone_isSet(self)

    def getPM(self):
        return _WXP.Timezone_getPM(self)

    def getOffset(self):
        return _WXP.Timezone_getOffset(self)

    def getName(self):
        return _WXP.Timezone_getName(self)

    def _print(self):
        return _WXP.Timezone__print(self)
    __swig_destroy__ = _WXP.delete_Timezone

# Register Timezone in _WXP:
_WXP.Timezone_swigregister(Timezone)
class ForeTime(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.ForeTime_swiginit(self, _WXP.new_ForeTime(*args))

    def init(self):
        return _WXP.ForeTime_init(self)

    def isSet(self):
        return _WXP.ForeTime_isSet(self)

    def decode(self, str):
        return _WXP.ForeTime_decode(self, str)

    def toString(self, str):
        return _WXP.ForeTime_toString(self, str)

    def getFore(self):
        return _WXP.ForeTime_getFore(self)

    def getHours(self):
        return _WXP.ForeTime_getHours(self)

    def getSeconds(self):
        return _WXP.ForeTime_getSeconds(self)

    def toTimeLabelDay(self, str):
        return _WXP.ForeTime_toTimeLabelDay(self, str)

    def toTimeLabel(self, *args):
        return _WXP.ForeTime_toTimeLabel(self, *args)

    def toVarLabel(self, str):
        return _WXP.ForeTime_toVarLabel(self, str)

    def set(self, *args):
        return _WXP.ForeTime_set(self, *args)

    def setEnd(self, dv):
        return _WXP.ForeTime_setEnd(self, dv)

    def setOffset(self, val):
        return _WXP.ForeTime_setOffset(self, val)

    def getOffset(self):
        return _WXP.ForeTime_getOffset(self)

    def setTypeOffset(self, t):
        return _WXP.ForeTime_setTypeOffset(self, t)

    def getTypeOffset(self):
        return _WXP.ForeTime_getTypeOffset(self)

    def setType(self, t):
        return _WXP.ForeTime_setType(self, t)

    def getType(self):
        return _WXP.ForeTime_getType(self)

    def isTypeComplex(self):
        return _WXP.ForeTime_isTypeComplex(self)

    def setTime1(self, val):
        return _WXP.ForeTime_setTime1(self, val)

    def getTime1(self):
        return _WXP.ForeTime_getTime1(self)

    def setTime2(self, val):
        return _WXP.ForeTime_setTime2(self, val)

    def getTime2(self):
        return _WXP.ForeTime_getTime2(self)

    def getEnd(self):
        return _WXP.ForeTime_getEnd(self)

    def validEnd(self):
        return _WXP.ForeTime_validEnd(self)

    def valid(self):
        return _WXP.ForeTime_valid(self)

    def toCode(self):
        return _WXP.ForeTime_toCode(self)

    def _print(self):
        return _WXP.ForeTime__print(self)
    NONE = _WXP.ForeTime_NONE
    FORE = _WXP.ForeTime_FORE
    ANAL = _WXP.ForeTime_ANAL
    RNG = _WXP.ForeTime_RNG
    AVG = _WXP.ForeTime_AVG
    ACC = _WXP.ForeTime_ACC
    DIFF = _WXP.ForeTime_DIFF
    MAX = _WXP.ForeTime_MAX
    MIN = _WXP.ForeTime_MIN
    ANY = _WXP.ForeTime_ANY
    MINUTE = _WXP.ForeTime_MINUTE
    HOUR = _WXP.ForeTime_HOUR
    DAY = _WXP.ForeTime_DAY
    MONTH = _WXP.ForeTime_MONTH
    YEAR = _WXP.ForeTime_YEAR
    __swig_destroy__ = _WXP.delete_ForeTime

# Register ForeTime in _WXP:
_WXP.ForeTime_swigregister(ForeTime)
class DateTool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getSeconds(str):
        return _WXP.DateTool_getSeconds(str)

    @staticmethod
    def getMinutes(str):
        return _WXP.DateTool_getMinutes(str)

    @staticmethod
    def getCurrent(*args):
        return _WXP.DateTool_getCurrent(*args)

    @staticmethod
    def decode(str, date):
        return _WXP.DateTool_decode(str, date)

    @staticmethod
    def decodeMonth(str):
        return _WXP.DateTool_decodeMonth(str)

    @staticmethod
    def getMonthLower(month):
        return _WXP.DateTool_getMonthLower(month)

    @staticmethod
    def getMonth(month):
        return _WXP.DateTool_getMonth(month)

    @staticmethod
    def getMonthLong(month):
        return _WXP.DateTool_getMonthLong(month)

    @staticmethod
    def getDayWeek(day):
        return _WXP.DateTool_getDayWeek(day)

    @staticmethod
    def createLabel(*args):
        return _WXP.DateTool_createLabel(*args)

    @staticmethod
    def createHourLabel(hour, flag, str):
        return _WXP.DateTool_createHourLabel(hour, flag, str)

    @staticmethod
    def _print(secs):
        return _WXP.DateTool__print(secs)
    NONE = _WXP.DateTool_NONE
    DAY_OF_WEEK = _WXP.DateTool_DAY_OF_WEEK

    def __init__(self):
        _WXP.DateTool_swiginit(self, _WXP.new_DateTool())
    __swig_destroy__ = _WXP.delete_DateTool

# Register DateTool in _WXP:
_WXP.DateTool_swigregister(DateTool)
class Rect(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    xmin = property(_WXP.Rect_xmin_get, _WXP.Rect_xmin_set)
    ymin = property(_WXP.Rect_ymin_get, _WXP.Rect_ymin_set)
    xmax = property(_WXP.Rect_xmax_get, _WXP.Rect_xmax_set)
    ymax = property(_WXP.Rect_ymax_get, _WXP.Rect_ymax_set)

    def init(self):
        return _WXP.Rect_init(self)

    def __init__(self, *args):
        _WXP.Rect_swiginit(self, _WXP.new_Rect(*args))

    def set(self, x1, y1, x2, y2):
        return _WXP.Rect_set(self, x1, y1, x2, y2)

    def setu(self, x1, y1, x2, y2):
        return _WXP.Rect_setu(self, x1, y1, x2, y2)

    def getXMin(self):
        return _WXP.Rect_getXMin(self)

    def getXMax(self):
        return _WXP.Rect_getXMax(self)

    def getYMin(self):
        return _WXP.Rect_getYMin(self)

    def getYMax(self):
        return _WXP.Rect_getYMax(self)

    def _print(self):
        return _WXP.Rect__print(self)
    __swig_destroy__ = _WXP.delete_Rect

# Register Rect in _WXP:
_WXP.Rect_swigregister(Rect)
class EarthPoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    lat = property(_WXP.EarthPoint_lat_get, _WXP.EarthPoint_lat_set)
    lon = property(_WXP.EarthPoint_lon_get, _WXP.EarthPoint_lon_set)
    elev = property(_WXP.EarthPoint_elev_get, _WXP.EarthPoint_elev_set)

    def init(self):
        return _WXP.EarthPoint_init(self)

    def __init__(self, *args):
        _WXP.EarthPoint_swiginit(self, _WXP.new_EarthPoint(*args))

    def setElev(self, relev):
        return _WXP.EarthPoint_setElev(self, relev)

    def set(self, *args):
        return _WXP.EarthPoint_set(self, *args)

    def getLat(self):
        return _WXP.EarthPoint_getLat(self)

    def getLon(self):
        return _WXP.EarthPoint_getLon(self)

    def getElev(self):
        return _WXP.EarthPoint_getElev(self)

    def _print(self):
        return _WXP.EarthPoint__print(self)
    __swig_destroy__ = _WXP.delete_EarthPoint

# Register EarthPoint in _WXP:
_WXP.EarthPoint_swigregister(EarthPoint)
class EarthRange(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    min_lat = property(_WXP.EarthRange_min_lat_get, _WXP.EarthRange_min_lat_set)
    max_lat = property(_WXP.EarthRange_max_lat_get, _WXP.EarthRange_max_lat_set)
    min_lon = property(_WXP.EarthRange_min_lon_get, _WXP.EarthRange_min_lon_set)
    max_lon = property(_WXP.EarthRange_max_lon_get, _WXP.EarthRange_max_lon_set)

    def __init__(self, *args):
        _WXP.EarthRange_swiginit(self, _WXP.new_EarthRange(*args))

    def init(self):
        return _WXP.EarthRange_init(self)

    def set(self, nlat, xlat, nlon, xlon):
        return _WXP.EarthRange_set(self, nlat, xlat, nlon, xlon)

    def getMinLat(self):
        return _WXP.EarthRange_getMinLat(self)

    def getMaxLat(self):
        return _WXP.EarthRange_getMaxLat(self)

    def getMinLon(self):
        return _WXP.EarthRange_getMinLon(self)

    def getMaxLon(self):
        return _WXP.EarthRange_getMaxLon(self)

    def _print(self):
        return _WXP.EarthRange__print(self)
    __swig_destroy__ = _WXP.delete_EarthRange

# Register EarthRange in _WXP:
_WXP.EarthRange_swigregister(EarthRange)
class EarthPoints(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def init(self, *args):
        return _WXP.EarthPoints_init(self, *args)
    __swig_destroy__ = _WXP.delete_EarthPoints

    def __init__(self, *args):
        _WXP.EarthPoints_swiginit(self, _WXP.new_EarthPoints(*args))

    def copy(self, data):
        return _WXP.EarthPoints_copy(self, data)

    def clear(self):
        return _WXP.EarthPoints_clear(self)

    def expand(self, size):
        return _WXP.EarthPoints_expand(self, size)

    def add(self, *args):
        return _WXP.EarthPoints_add(self, *args)

    def add1(self, *args):
        return _WXP.EarthPoints_add1(self, *args)

    def set(self, *args):
        return _WXP.EarthPoints_set(self, *args)

    def get(self, *args):
        return _WXP.EarthPoints_get(self, *args)

    def getLat(self, ind):
        return _WXP.EarthPoints_getLat(self, ind)

    def getLon(self, ind):
        return _WXP.EarthPoints_getLon(self, ind)

    def getLat1(self, ind):
        return _WXP.EarthPoints_getLat1(self, ind)

    def getLon1(self, ind):
        return _WXP.EarthPoints_getLon1(self, ind)

    def getNum(self):
        return _WXP.EarthPoints_getNum(self)

    def offset(self, ind, rlat, rlon):
        return _WXP.EarthPoints_offset(self, ind, rlat, rlon)

    def within(self, ept):
        return _WXP.EarthPoints_within(self, ept)

    def getRange(self):
        return _WXP.EarthPoints_getRange(self)

    def _print(self):
        return _WXP.EarthPoints__print(self)

# Register EarthPoints in _WXP:
_WXP.EarthPoints_swigregister(EarthPoints)
class GridPoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    gx = property(_WXP.GridPoint_gx_get, _WXP.GridPoint_gx_set)
    gy = property(_WXP.GridPoint_gy_get, _WXP.GridPoint_gy_set)

    def init(self):
        return _WXP.GridPoint_init(self)

    def __init__(self, *args):
        _WXP.GridPoint_swiginit(self, _WXP.new_GridPoint(*args))

    def set(self, *args):
        return _WXP.GridPoint_set(self, *args)

    def offset(self, gx, gy):
        return _WXP.GridPoint_offset(self, gx, gy)

    def getGX(self):
        return _WXP.GridPoint_getGX(self)

    def getGY(self):
        return _WXP.GridPoint_getGY(self)

    def _print(self):
        return _WXP.GridPoint__print(self)
    __swig_destroy__ = _WXP.delete_GridPoint

# Register GridPoint in _WXP:
_WXP.GridPoint_swigregister(GridPoint)
class GridPoints(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def init(self, *args):
        return _WXP.GridPoints_init(self, *args)
    __swig_destroy__ = _WXP.delete_GridPoints

    def __init__(self, *args):
        _WXP.GridPoints_swiginit(self, _WXP.new_GridPoints(*args))

    def copy(self, *args):
        return _WXP.GridPoints_copy(self, *args)

    def clear(self):
        return _WXP.GridPoints_clear(self)

    def expand(self, size):
        return _WXP.GridPoints_expand(self, size)

    def add(self, *args):
        return _WXP.GridPoints_add(self, *args)

    def add1(self, *args):
        return _WXP.GridPoints_add1(self, *args)

    def set(self, *args):
        return _WXP.GridPoints_set(self, *args)

    def get(self, *args):
        return _WXP.GridPoints_get(self, *args)

    def remove(self, ind):
        return _WXP.GridPoints_remove(self, ind)

    def insert(self, *args):
        return _WXP.GridPoints_insert(self, *args)

    def getGX(self, ind):
        return _WXP.GridPoints_getGX(self, ind)

    def getGY(self, ind):
        return _WXP.GridPoints_getGY(self, ind)

    def getGX1(self, ind):
        return _WXP.GridPoints_getGX1(self, ind)

    def getGY1(self, ind):
        return _WXP.GridPoints_getGY1(self, ind)

    def getNum(self):
        return _WXP.GridPoints_getNum(self)

    def offset(self, *args):
        return _WXP.GridPoints_offset(self, *args)

    def within(self, gpt):
        return _WXP.GridPoints_within(self, gpt)

    def getCenter(self, gpt):
        return _WXP.GridPoints_getCenter(self, gpt)

    def getCentroid(self, gpt):
        return _WXP.GridPoints_getCentroid(self, gpt)

    def getBoundingBox(self, box):
        return _WXP.GridPoints_getBoundingBox(self, box)

    def getPointsWithin(self, gpts):
        return _WXP.GridPoints_getPointsWithin(self, gpts)

    def _print(self):
        return _WXP.GridPoints__print(self)

# Register GridPoints in _WXP:
_WXP.GridPoints_swigregister(GridPoints)
class GridStats(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    max = property(_WXP.GridStats_max_get, _WXP.GridStats_max_set)
    min = property(_WXP.GridStats_min_get, _WXP.GridStats_min_set)
    avg = property(_WXP.GridStats_avg_get, _WXP.GridStats_avg_set)
    num = property(_WXP.GridStats_num_get, _WXP.GridStats_num_set)

    def __init__(self):
        _WXP.GridStats_swiginit(self, _WXP.new_GridStats())

    def init(self):
        return _WXP.GridStats_init(self)

    def _print(self):
        return _WXP.GridStats__print(self)
    __swig_destroy__ = _WXP.delete_GridStats

# Register GridStats in _WXP:
_WXP.GridStats_swigregister(GridStats)
class Color(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    name = property(_WXP.Color_name_get, _WXP.Color_name_set)
    red = property(_WXP.Color_red_get, _WXP.Color_red_set)
    grn = property(_WXP.Color_grn_get, _WXP.Color_grn_set)
    blu = property(_WXP.Color_blu_get, _WXP.Color_blu_set)
    value = property(_WXP.Color_value_get, _WXP.Color_value_set)

    def __init__(self):
        _WXP.Color_swiginit(self, _WXP.new_Color())

    def init(self):
        return _WXP.Color_init(self)
    __swig_destroy__ = _WXP.delete_Color

# Register Color in _WXP:
_WXP.Color_swigregister(Color)
class RGB(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    red = property(_WXP.RGB_red_get, _WXP.RGB_red_set)
    grn = property(_WXP.RGB_grn_get, _WXP.RGB_grn_set)
    blu = property(_WXP.RGB_blu_get, _WXP.RGB_blu_set)

    def __init__(self):
        _WXP.RGB_swiginit(self, _WXP.new_RGB())

    def init(self):
        return _WXP.RGB_init(self)

    def set(self, r, g, b):
        return _WXP.RGB_set(self, r, g, b)

    def getRed(self):
        return _WXP.RGB_getRed(self)

    def getGrn(self):
        return _WXP.RGB_getGrn(self)

    def getBlu(self):
        return _WXP.RGB_getBlu(self)

    def isOff(self):
        return _WXP.RGB_isOff(self)

    def isWhite(self):
        return _WXP.RGB_isWhite(self)

    def isBlack(self):
        return _WXP.RGB_isBlack(self)

    def _print(self):
        return _WXP.RGB__print(self)
    __swig_destroy__ = _WXP.delete_RGB

# Register RGB in _WXP:
_WXP.RGB_swigregister(RGB)
class ColorMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.ColorMap_swiginit(self, _WXP.new_ColorMap(*args))
    __swig_destroy__ = _WXP.delete_ColorMap

    def init(self, *args):
        return _WXP.ColorMap_init(self, *args)

    def set(self, color):
        return _WXP.ColorMap_set(self, color)

    def add(self, *args):
        return _WXP.ColorMap_add(self, *args)

    def getMax(self):
        return _WXP.ColorMap_getMax(self)

    def getNum(self):
        return _WXP.ColorMap_getNum(self)

    def getInd(self, name):
        return _WXP.ColorMap_getInd(self, name)

    def getName(self, ind):
        return _WXP.ColorMap_getName(self, ind)

    def get(self, ind, rgb):
        return _WXP.ColorMap_get(self, ind, rgb)

    def getRGB(self, ind, red, grn, blu):
        return _WXP.ColorMap_getRGB(self, ind, red, grn, blu)

    def getIRGB(self, ind, red, grn, blu):
        return _WXP.ColorMap_getIRGB(self, ind, red, grn, blu)

    def setValue(self, ind, val):
        return _WXP.ColorMap_setValue(self, ind, val)

    def getValue(self, *args):
        return _WXP.ColorMap_getValue(self, *args)

    def getNumFill(self):
        return _WXP.ColorMap_getNumFill(self)

    def isColorNear(self, ind, rgb):
        return _WXP.ColorMap_isColorNear(self, ind, rgb)

    def setNumFill(self, nfill):
        return _WXP.ColorMap_setNumFill(self, nfill)

    def _print(self):
        return _WXP.ColorMap__print(self)
    BACK = _WXP.ColorMap_BACK
    OFF = _WXP.ColorMap_OFF
    END = _WXP.ColorMap_END

    @staticmethod
    def isColor(a):
        return _WXP.ColorMap_isColor(a)

# Register ColorMap in _WXP:
_WXP.ColorMap_swigregister(ColorMap)
class PlotAttr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.PlotAttr_swiginit(self, _WXP.new_PlotAttr(*args))

    def set(self, *args):
        return _WXP.PlotAttr_set(self, *args)

    def parse(self, str):
        return _WXP.PlotAttr_parse(self, str)

    def setWidth(self, val):
        return _WXP.PlotAttr_setWidth(self, val)

    def getWidth(self):
        return _WXP.PlotAttr_getWidth(self)

    def validWidth(self):
        return _WXP.PlotAttr_validWidth(self)

    def setWeight(self, val):
        return _WXP.PlotAttr_setWeight(self, val)

    def getWeight(self):
        return _WXP.PlotAttr_getWeight(self)

    def validWeight(self):
        return _WXP.PlotAttr_validWeight(self)

    def setHeight(self, val):
        return _WXP.PlotAttr_setHeight(self, val)

    def getHeight(self):
        return _WXP.PlotAttr_getHeight(self)

    def validHeight(self):
        return _WXP.PlotAttr_validHeight(self)

    def setExpan(self, val):
        return _WXP.PlotAttr_setExpan(self, val)

    def getExpan(self):
        return _WXP.PlotAttr_getExpan(self)

    def validExpan(self):
        return _WXP.PlotAttr_validExpan(self)

    def getStyle(self):
        return _WXP.PlotAttr_getStyle(self)

    def validStyle(self):
        return _WXP.PlotAttr_validStyle(self)

    def setShadow(self, val):
        return _WXP.PlotAttr_setShadow(self, val)

    def getShadow(self):
        return _WXP.PlotAttr_getShadow(self)

    def validShadow(self):
        return _WXP.PlotAttr_validShadow(self)

    def getFillPat(self):
        return _WXP.PlotAttr_getFillPat(self)

    def validFillPat(self):
        return _WXP.PlotAttr_validFillPat(self)

    def setColorInd(self, val):
        return _WXP.PlotAttr_setColorInd(self, val)

    def getColorInd(self):
        return _WXP.PlotAttr_getColorInd(self)

    def validColorInd(self):
        return _WXP.PlotAttr_validColorInd(self)

    def setColor(self, str):
        return _WXP.PlotAttr_setColor(self, str)

    def getColor(self):
        return _WXP.PlotAttr_getColor(self)

    def validColor(self):
        return _WXP.PlotAttr_validColor(self)

    def getFont(self):
        return _WXP.PlotAttr_getFont(self)

    def validFont(self):
        return _WXP.PlotAttr_validFont(self)

    def validLabel(self):
        return _WXP.PlotAttr_validLabel(self)

    def getLabel(self):
        return _WXP.PlotAttr_getLabel(self)

    def _print(self):
        return _WXP.PlotAttr__print(self)

    def init(self):
        return _WXP.PlotAttr_init(self)

    @staticmethod
    def parseFillStyle(str):
        return _WXP.PlotAttr_parseFillStyle(str)

    @staticmethod
    def parseMarker(str):
        return _WXP.PlotAttr_parseMarker(str)

    @staticmethod
    def update(*args):
        return _WXP.PlotAttr_update(*args)
    __swig_destroy__ = _WXP.delete_PlotAttr

# Register PlotAttr in _WXP:
_WXP.PlotAttr_swigregister(PlotAttr)
class ColorFill(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.ColorFill_swiginit(self, _WXP.new_ColorFill(*args))
    __swig_destroy__ = _WXP.delete_ColorFill

    def init(self):
        return _WXP.ColorFill_init(self)

    def set(self, *args):
        return _WXP.ColorFill_set(self, *args)

    def isSet(self):
        return _WXP.ColorFill_isSet(self)

    def setFill(self, color, str):
        return _WXP.ColorFill_setFill(self, color, str)

    def readFile(self, *args):
        return _WXP.ColorFill_readFile(self, *args)

    def validateValues(self):
        return _WXP.ColorFill_validateValues(self)

    def decode(self, *args):
        return _WXP.ColorFill_decode(self, *args)

    def setValues(self, vals, num):
        return _WXP.ColorFill_setValues(self, vals, num)

    def areValuesSet(self):
        return _WXP.ColorFill_areValuesSet(self)

    def getNum(self):
        return _WXP.ColorFill_getNum(self)

    def getBaseVal(self):
        return _WXP.ColorFill_getBaseVal(self)

    def getValue(self, ind):
        return _WXP.ColorFill_getValue(self, ind)

    def setBase(self, rbase):
        return _WXP.ColorFill_setBase(self, rbase)

    def getBase(self):
        return _WXP.ColorFill_getBase(self)

    def setInterval(self, rintrvl):
        return _WXP.ColorFill_setInterval(self, rintrvl)

    def getInterval(self):
        return _WXP.ColorFill_getInterval(self)

    def getInd(self, rvalue):
        return _WXP.ColorFill_getInd(self, rvalue)

    def get(self, *args):
        return _WXP.ColorFill_get(self, *args)

    def getColorName(self, ind):
        return _WXP.ColorFill_getColorName(self, ind)

    def getColor(self, *args):
        return _WXP.ColorFill_getColor(self, *args)

    def validLabel(self, ind):
        return _WXP.ColorFill_validLabel(self, ind)

    def getLabel(self, *args):
        return _WXP.ColorFill_getLabel(self, *args)

    def _print(self):
        return _WXP.ColorFill__print(self)

# Register ColorFill in _WXP:
_WXP.ColorFill_swigregister(ColorFill)
class Enhance(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.Enhance_swiginit(self, _WXP.new_Enhance(*args))
    __swig_destroy__ = _WXP.delete_Enhance

    def init(self):
        return _WXP.Enhance_init(self)

    def getNum(self):
        return _WXP.Enhance_getNum(self)

    def set(self, *args):
        return _WXP.Enhance_set(self, *args)

    def readFile(self, colormap, file):
        return _WXP.Enhance_readFile(self, colormap, file)

    def validateValues(self):
        return _WXP.Enhance_validateValues(self)

    def decode(self, colormap, str):
        return _WXP.Enhance_decode(self, colormap, str)

    def setIndex(self, ind, rindex):
        return _WXP.Enhance_setIndex(self, ind, rindex)

    def getValue(self, ind):
        return _WXP.Enhance_getValue(self, ind)

    def getIndex(self, *args):
        return _WXP.Enhance_getIndex(self, *args)

    def getColor(self, rvalue):
        return _WXP.Enhance_getColor(self, rvalue)

    def isIndex(self):
        return _WXP.Enhance_isIndex(self)

    def isValue(self):
        return _WXP.Enhance_isValue(self)

    def getName(self):
        return _WXP.Enhance_getName(self)

    def _print(self):
        return _WXP.Enhance__print(self)
    INDEX = _WXP.Enhance_INDEX
    VALUE = _WXP.Enhance_VALUE

# Register Enhance in _WXP:
_WXP.Enhance_swigregister(Enhance)
class Point(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_WXP.Point_x_get, _WXP.Point_x_set)
    y = property(_WXP.Point_y_get, _WXP.Point_y_set)
    z = property(_WXP.Point_z_get, _WXP.Point_z_set)

    def init(self):
        return _WXP.Point_init(self)

    def __init__(self, *args):
        _WXP.Point_swiginit(self, _WXP.new_Point(*args))

    def offset(self, rx, ry):
        return _WXP.Point_offset(self, rx, ry)

    def set(self, *args):
        return _WXP.Point_set(self, *args)

    def getX(self):
        return _WXP.Point_getX(self)

    def getY(self):
        return _WXP.Point_getY(self)

    def _print(self):
        return _WXP.Point__print(self)

    @staticmethod
    def interp(pt1, pt2, d):
        return _WXP.Point_interp(pt1, pt2, d)
    __swig_destroy__ = _WXP.delete_Point

# Register Point in _WXP:
_WXP.Point_swigregister(Point)
class Points(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def init(self, *args):
        return _WXP.Points_init(self, *args)
    __swig_destroy__ = _WXP.delete_Points

    def __init__(self, *args):
        _WXP.Points_swiginit(self, _WXP.new_Points(*args))

    def copy(self, *args):
        return _WXP.Points_copy(self, *args)

    def clear(self):
        return _WXP.Points_clear(self)

    def expand(self, size):
        return _WXP.Points_expand(self, size)

    def add(self, *args):
        return _WXP.Points_add(self, *args)

    def add1(self, *args):
        return _WXP.Points_add1(self, *args)

    def set(self, *args):
        return _WXP.Points_set(self, *args)

    def get(self, *args):
        return _WXP.Points_get(self, *args)

    def remove(self, ind):
        return _WXP.Points_remove(self, ind)

    def insert(self, *args):
        return _WXP.Points_insert(self, *args)

    def getX(self, ind):
        return _WXP.Points_getX(self, ind)

    def getY(self, ind):
        return _WXP.Points_getY(self, ind)

    def getX1(self, ind):
        return _WXP.Points_getX1(self, ind)

    def getY1(self, ind):
        return _WXP.Points_getY1(self, ind)

    def getNum(self):
        return _WXP.Points_getNum(self)

    def offset(self, *args):
        return _WXP.Points_offset(self, *args)

    def within(self, pt):
        return _WXP.Points_within(self, pt)

    def getCenter(self, pt):
        return _WXP.Points_getCenter(self, pt)

    def getCentroid(self, pt):
        return _WXP.Points_getCentroid(self, pt)

    def _print(self):
        return _WXP.Points__print(self)

# Register Points in _WXP:
_WXP.Points_swigregister(Points)
class GeomBox(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_WXP.GeomBox_x_get, _WXP.GeomBox_x_set)
    y = property(_WXP.GeomBox_y_get, _WXP.GeomBox_y_set)
    width = property(_WXP.GeomBox_width_get, _WXP.GeomBox_width_set)
    height = property(_WXP.GeomBox_height_get, _WXP.GeomBox_height_set)

    def init(self):
        return _WXP.GeomBox_init(self)

    def __init__(self, *args):
        _WXP.GeomBox_swiginit(self, _WXP.new_GeomBox(*args))

    def set(self, rx, ry, rwidth, rheight):
        return _WXP.GeomBox_set(self, rx, ry, rwidth, rheight)

    def _print(self):
        return _WXP.GeomBox__print(self)
    __swig_destroy__ = _WXP.delete_GeomBox

# Register GeomBox in _WXP:
_WXP.GeomBox_swigregister(GeomBox)
class Datum(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.Datum_swiginit(self, _WXP.new_Datum())

    def init(self):
        return _WXP.Datum_init(self)

    def initVals(self):
        return _WXP.Datum_initVals(self)

    def set(self, *args):
        return _WXP.Datum_set(self, *args)

    def setId(self, rid):
        return _WXP.Datum_setId(self, rid)

    def getId(self):
        return _WXP.Datum_getId(self)

    def setLoc(self, *args):
        return _WXP.Datum_setLoc(self, *args)

    def getLoc(self):
        return _WXP.Datum_getLoc(self)

    def getLat(self):
        return _WXP.Datum_getLat(self)

    def getLon(self):
        return _WXP.Datum_getLon(self)

    def setIndex(self, rindex):
        return _WXP.Datum_setIndex(self, rindex)

    def getIndex(self):
        return _WXP.Datum_getIndex(self)

    def setType(self, t):
        return _WXP.Datum_setType(self, t)

    def getType(self):
        return _WXP.Datum_getType(self)

    def setData(self, *args):
        return _WXP.Datum_setData(self, *args)

    def clearData(self):
        return _WXP.Datum_clearData(self)

    def formatData(self, format):
        return _WXP.Datum_formatData(self, format)

    def getData(self):
        return _WXP.Datum_getData(self)

    def getFormat(self):
        return _WXP.Datum_getFormat(self)

    def setFormat(self, str):
        return _WXP.Datum_setFormat(self, str)

    def addFormat(self, str):
        return _WXP.Datum_addFormat(self, str)

    def offsetValue(self, i, val):
        return _WXP.Datum_offsetValue(self, i, val)

    def scaleValue(self, i, val):
        return _WXP.Datum_scaleValue(self, i, val)

    def setValue(self, *args):
        return _WXP.Datum_setValue(self, *args)

    def getValue(self, i):
        return _WXP.Datum_getValue(self, i)

    def _print(self):
        return _WXP.Datum__print(self)
    NONE = _WXP.Datum_NONE
    DATA = _WXP.Datum_DATA
    VALUE = _WXP.Datum_VALUE
    TEXT = _WXP.Datum_TEXT
    MARK = _WXP.Datum_MARK
    INT = _WXP.Datum_INT
    CLOUD = _WXP.Datum_CLOUD
    WBARB = _WXP.Datum_WBARB
    CBARB = _WXP.Datum_CBARB
    DBARB = _WXP.Datum_DBARB
    VECT = _WXP.Datum_VECT
    AVECT = _WXP.Datum_AVECT
    WTRACK = _WXP.Datum_WTRACK
    SYMB = _WXP.Datum_SYMB
    LINE = _WXP.Datum_LINE
    CONST = _WXP.Datum_CONST
    __swig_destroy__ = _WXP.delete_Datum

# Register Datum in _WXP:
_WXP.Datum_swigregister(Datum)
class Filename(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def initParam(self):
        return _WXP.Filename_initParam(self)

    def init(self):
        return _WXP.Filename_init(self)

    def __init__(self, *args):
        _WXP.Filename_swiginit(self, _WXP.new_Filename(*args))
    __swig_destroy__ = _WXP.delete_Filename

    def set(self, *args):
        return _WXP.Filename_set(self, *args)

    def isSet(self):
        return _WXP.Filename_isSet(self)

    def setNameConv(self, nameconv):
        return _WXP.Filename_setNameConv(self, nameconv)

    def setPath(self, path):
        return _WXP.Filename_setPath(self, path)

    def setDate(self, rdate):
        return _WXP.Filename_setDate(self, rdate)

    def getDate(self, rdate):
        return _WXP.Filename_getDate(self, rdate)

    def getDateval(self):
        return _WXP.Filename_getDateval(self)

    def getOffset(self):
        return _WXP.Filename_getOffset(self)

    def setFixDate(self, *args):
        return _WXP.Filename_setFixDate(self, *args)

    def setType(self, rtype):
        return _WXP.Filename_setType(self, rtype)

    def getType(self):
        return _WXP.Filename_getType(self)

    def setForeTime(self, time):
        return _WXP.Filename_setForeTime(self, time)

    def getForeTime(self):
        return _WXP.Filename_getForeTime(self)

    def setKey(self, ch, str):
        return _WXP.Filename_setKey(self, ch, str)

    def getExt(self):
        return _WXP.Filename_getExt(self)

    def getKey(self, ch):
        return _WXP.Filename_getKey(self, ch)

    def setName(self, rname):
        return _WXP.Filename_setName(self, rname)

    def getName(self, *args):
        return _WXP.Filename_getName(self, *args)

    def setHeader(self, rname):
        return _WXP.Filename_setHeader(self, rname)

    def getHeader(self):
        return _WXP.Filename_getHeader(self)

    def validHeader(self):
        return _WXP.Filename_validHeader(self)

    def addOutPath(self, path):
        return _WXP.Filename_addOutPath(self, path)

    def isFixed(self):
        return _WXP.Filename_isFixed(self)

    def setNumFiles(self, *args):
        return _WXP.Filename_setNumFiles(self, *args)

    def getNumFiles(self):
        return _WXP.Filename_getNumFiles(self)

    def getNumType(self):
        return _WXP.Filename_getNumType(self)

    def setOutput(self, val):
        return _WXP.Filename_setOutput(self, val)

    def setLateLimit(self, val):
        return _WXP.Filename_setLateLimit(self, val)

    def setLateDate(self, rdate):
        return _WXP.Filename_setLateDate(self, rdate)

    def setBaseDate(self, rdate):
        return _WXP.Filename_setBaseDate(self, rdate)

    def checkFile(self, file):
        return _WXP.Filename_checkFile(self, file)

    def exist(self):
        return _WXP.Filename_exist(self)

    def setFile(self, *args):
        return _WXP.Filename_setFile(self, *args)

    def listFile(self):
        return _WXP.Filename_listFile(self)

    def _print(self):
        return _WXP.Filename__print(self)

    def printConv(self):
        return _WXP.Filename_printConv(self)
    UNK = _WXP.Filename_UNK
    HOURS = _WXP.Filename_HOURS
    FILES = _WXP.Filename_FILES

# Register Filename in _WXP:
_WXP.Filename_swigregister(Filename)
class NameConvFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.NameConvFile_swiginit(self, _WXP.new_NameConvFile())

    def init(self):
        return _WXP.NameConvFile_init(self)

    def setType(self, rtype):
        return _WXP.NameConvFile_setType(self, rtype)

    def getType(self):
        return _WXP.NameConvFile_getType(self)

    def setFilename(self, *args):
        return _WXP.NameConvFile_setFilename(self, *args)

    def getFilename(self):
        return _WXP.NameConvFile_getFilename(self)

    def setHdrFilename(self, *args):
        return _WXP.NameConvFile_setHdrFilename(self, *args)

    def getHdrFilename(self):
        return _WXP.NameConvFile_getHdrFilename(self)

    def setDate(self, rdate):
        return _WXP.NameConvFile_setDate(self, rdate)

    def getDate(self, *args):
        return _WXP.NameConvFile_getDate(self, *args)

    def setParam(self, str):
        return _WXP.NameConvFile_setParam(self, str)

    def getParam(self):
        return _WXP.NameConvFile_getParam(self)

    def setOffset(self, val):
        return _WXP.NameConvFile_setOffset(self, val)

    def getOffset(self):
        return _WXP.NameConvFile_getOffset(self)

    def _print(self):
        return _WXP.NameConvFile__print(self)
    __swig_destroy__ = _WXP.delete_NameConvFile

# Register NameConvFile in _WXP:
_WXP.NameConvFile_swigregister(NameConvFile)
class NameConv(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.NameConv_swiginit(self, _WXP.new_NameConv(*args))
    __swig_destroy__ = _WXP.delete_NameConv

    def initParam(self):
        return _WXP.NameConv_initParam(self)

    def init(self):
        return _WXP.NameConv_init(self)

    def set(self, type):
        return _WXP.NameConv_set(self, type)

    def setOutput(self, val):
        return _WXP.NameConv_setOutput(self, val)

    def setFixDate(self, *args):
        return _WXP.NameConv_setFixDate(self, *args)

    def getFixDate(self, rdate):
        return _WXP.NameConv_getFixDate(self, rdate)

    def setLateLimit(self, val):
        return _WXP.NameConv_setLateLimit(self, val)

    def setLateDate(self, rdate):
        return _WXP.NameConv_setLateDate(self, rdate)

    def getOffset(self):
        return _WXP.NameConv_getOffset(self)

    def getMinSize(self):
        return _WXP.NameConv_getMinSize(self)

    def getMinTime(self):
        return _WXP.NameConv_getMinTime(self)

    def getType(self):
        return _WXP.NameConv_getType(self)

    def setForeTime(self, val):
        return _WXP.NameConv_setForeTime(self, val)

    def getForeTime(self):
        return _WXP.NameConv_getForeTime(self)

    def getFile(self):
        return _WXP.NameConv_getFile(self)

    def setExt(self, str):
        return _WXP.NameConv_setExt(self, str)

    def getExt(self):
        return _WXP.NameConv_getExt(self)

    def setKey(self, ch, str):
        return _WXP.NameConv_setKey(self, ch, str)

    def getKey(self, ch):
        return _WXP.NameConv_getKey(self, ch)

    def setPath(self, *args):
        return _WXP.NameConv_setPath(self, *args)

    def getPath(self):
        return _WXP.NameConv_getPath(self)

    def getNumPath(self):
        return _WXP.NameConv_getNumPath(self)

    def setPathNum(self, ind):
        return _WXP.NameConv_setPathNum(self, ind)

    def encode(self, rdate, flag, filename):
        return _WXP.NameConv_encode(self, rdate, flag, filename)

    def encodeFile(self, rdate, filename):
        return _WXP.NameConv_encodeFile(self, rdate, filename)

    def encodeHdr(self, rdate, filename):
        return _WXP.NameConv_encodeHdr(self, rdate, filename)

    def decode(self, filename):
        return _WXP.NameConv_decode(self, filename)

    def setLatest(self, str, file):
        return _WXP.NameConv_setLatest(self, str, file)

    def setFile(self, rdate, file):
        return _WXP.NameConv_setFile(self, rdate, file)

    def getDate(self, rdate):
        return _WXP.NameConv_getDate(self, rdate)

    def _print(self):
        return _WXP.NameConv__print(self)

    @staticmethod
    def setOffset(*args):
        return _WXP.NameConv_setOffset(*args)
    FILENAME = _WXP.NameConv_FILENAME
    HEADER = _WXP.NameConv_HEADER

# Register NameConv in _WXP:
_WXP.NameConv_swigregister(NameConv)
class FileTool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def isFullPath(filename):
        return _WXP.FileTool_isFullPath(filename)

    @staticmethod
    def addPath(path, file, filename):
        return _WXP.FileTool_addPath(path, file, filename)

    @staticmethod
    def checkPath(path, file):
        return _WXP.FileTool_checkPath(path, file)

    @staticmethod
    def addOutPath(path, file, filename):
        return _WXP.FileTool_addOutPath(path, file, filename)

    @staticmethod
    def numPath(path):
        return _WXP.FileTool_numPath(path)

    @staticmethod
    def getPath(path, ind, spath):
        return _WXP.FileTool_getPath(path, ind, spath)

    @staticmethod
    def addPathDelim(path):
        return _WXP.FileTool_addPathDelim(path)

    @staticmethod
    def addUserPath(file, filename):
        return _WXP.FileTool_addUserPath(file, filename)

    @staticmethod
    def exist(file):
        return _WXP.FileTool_exist(file)

    @staticmethod
    def isStdio(file):
        return _WXP.FileTool_isStdio(file)

    @staticmethod
    def isDir(file):
        return _WXP.FileTool_isDir(file)

    @staticmethod
    def isFile(file):
        return _WXP.FileTool_isFile(file)

    @staticmethod
    def isFifo(file):
        return _WXP.FileTool_isFifo(file)

    @staticmethod
    def isDevice(file):
        return _WXP.FileTool_isDevice(file)

    @staticmethod
    def getSize(file):
        return _WXP.FileTool_getSize(file)

    @staticmethod
    def getModTime(file):
        return _WXP.FileTool_getModTime(file)

    @staticmethod
    def remove(file):
        return _WXP.FileTool_remove(file)

    @staticmethod
    def makeDir(dir, flag):
        return _WXP.FileTool_makeDir(dir, flag)

    def __init__(self):
        _WXP.FileTool_swiginit(self, _WXP.new_FileTool())
    __swig_destroy__ = _WXP.delete_FileTool

# Register FileTool in _WXP:
_WXP.FileTool_swigregister(FileTool)
class CityData(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.CityData_swiginit(self, _WXP.new_CityData())

    def init(self):
        return _WXP.CityData_init(self)

    def getId(self):
        return _WXP.CityData_getId(self)

    def getName(self):
        return _WXP.CityData_getName(self)

    def getState(self):
        return _WXP.CityData_getState(self)

    def getRegion(self):
        return _WXP.CityData_getRegion(self)

    def getWmo(self):
        return _WXP.CityData_getWmo(self)

    def getLat(self):
        return _WXP.CityData_getLat(self)

    def getLon(self):
        return _WXP.CityData_getLon(self)

    def getElev(self):
        return _WXP.CityData_getElev(self)

    def getPrior(self):
        return _WXP.CityData_getPrior(self)

    def getNum(self):
        return _WXP.CityData_getNum(self)

    def printLine(self):
        return _WXP.CityData_printLine(self)

    def _print(self):
        return _WXP.CityData__print(self)
    __swig_destroy__ = _WXP.delete_CityData

# Register CityData in _WXP:
_WXP.CityData_swigregister(CityData)
class CityFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.CityFile_swiginit(self, _WXP.new_CityFile(*args))
    __swig_destroy__ = _WXP.delete_CityFile

    def open(self, *args):
        return _WXP.CityFile_open(self, *args)

    def isOpen(self):
        return _WXP.CityFile_isOpen(self)

    def rewind(self):
        return _WXP.CityFile_rewind(self)

    def close(self):
        return _WXP.CityFile_close(self)

    def read(self, city):
        return _WXP.CityFile_read(self, city)

    def getNum(self):
        return _WXP.CityFile_getNum(self)

# Register CityFile in _WXP:
_WXP.CityFile_swigregister(CityFile)
class SfcData(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    comment_len = _WXP.SfcData_comment_len

    def __init__(self):
        _WXP.SfcData_swiginit(self, _WXP.new_SfcData())

    def init(self):
        return _WXP.SfcData_init(self)

    def setId(self, str):
        return _WXP.SfcData_setId(self, str)

    def getId(self):
        return _WXP.SfcData_getId(self)

    def setArea(self, str):
        return _WXP.SfcData_setArea(self, str)

    def getArea(self):
        return _WXP.SfcData_getArea(self)

    def setName(self, str):
        return _WXP.SfcData_setName(self, str)

    def getName(self):
        return _WXP.SfcData_getName(self)

    def setWmo(self, str):
        return _WXP.SfcData_setWmo(self, str)

    def getWmo(self):
        return _WXP.SfcData_getWmo(self)

    def setLoc(self, rlat, rlon):
        return _WXP.SfcData_setLoc(self, rlat, rlon)

    def getLat(self):
        return _WXP.SfcData_getLat(self)

    def getLon(self):
        return _WXP.SfcData_getLon(self)

    def setElev(self, el):
        return _WXP.SfcData_setElev(self, el)

    def getElev(self):
        return _WXP.SfcData_getElev(self)

    def setDate(self, rdate):
        return _WXP.SfcData_setDate(self, rdate)

    def getDate(self, *args):
        return _WXP.SfcData_getDate(self, *args)

    def getTime(self):
        return _WXP.SfcData_getTime(self)

    def getHour(self):
        return _WXP.SfcData_getHour(self)

    def getSeconds(self):
        return _WXP.SfcData_getSeconds(self)

    def setType(self, rtype):
        return _WXP.SfcData_setType(self, rtype)

    def getType(self):
        return _WXP.SfcData_getType(self)

    def setT(self, rt):
        return _WXP.SfcData_setT(self, rt)

    def getT(self):
        return _WXP.SfcData_getT(self)

    def setTd(self, rtd):
        return _WXP.SfcData_setTd(self, rtd)

    def getTd(self):
        return _WXP.SfcData_getTd(self)

    def setDir(self, rdir):
        return _WXP.SfcData_setDir(self, rdir)

    def getDir(self):
        return _WXP.SfcData_getDir(self)

    def setSpd(self, rspd):
        return _WXP.SfcData_setSpd(self, rspd)

    def getSpd(self):
        return _WXP.SfcData_getSpd(self)

    def setGust(self, rgust):
        return _WXP.SfcData_setGust(self, rgust)

    def getGust(self):
        return _WXP.SfcData_getGust(self)

    def setAlt(self, ralt):
        return _WXP.SfcData_setAlt(self, ralt)

    def getAlt(self):
        return _WXP.SfcData_getAlt(self)

    def setSlp(self, rslp):
        return _WXP.SfcData_setSlp(self, rslp)

    def getSlp(self):
        return _WXP.SfcData_getSlp(self)

    def setVis(self, rvis):
        return _WXP.SfcData_setVis(self, rvis)

    def getVis(self):
        return _WXP.SfcData_getVis(self)

    def setWeather(self, wx):
        return _WXP.SfcData_setWeather(self, wx)

    def getWeather(self):
        return _WXP.SfcData_getWeather(self)

    def weatherText(self, str):
        return _WXP.SfcData_weatherText(self, str)

    def setNumCld(self, num):
        return _WXP.SfcData_setNumCld(self, num)

    def getNumCld(self):
        return _WXP.SfcData_getNumCld(self)

    def setCldHeight(self, ind, height):
        return _WXP.SfcData_setCldHeight(self, ind, height)

    def getCldHeight(self, *args):
        return _WXP.SfcData_getCldHeight(self, *args)

    def setCldCover(self, ind, cover):
        return _WXP.SfcData_setCldCover(self, ind, cover)

    def getCldCover(self, *args):
        return _WXP.SfcData_getCldCover(self, *args)

    def setPtendType(self, type):
        return _WXP.SfcData_setPtendType(self, type)

    def getPtendType(self):
        return _WXP.SfcData_getPtendType(self)

    def setPtend(self, rptend):
        return _WXP.SfcData_setPtend(self, rptend)

    def getPtend(self):
        return _WXP.SfcData_getPtend(self)

    def setPrec3(self, val):
        return _WXP.SfcData_setPrec3(self, val)

    def getPrec3(self):
        return _WXP.SfcData_getPrec3(self)

    def setPrec6(self, val):
        return _WXP.SfcData_setPrec6(self, val)

    def getPrec6(self):
        return _WXP.SfcData_getPrec6(self)

    def setPrec12(self, val):
        return _WXP.SfcData_setPrec12(self, val)

    def getPrec12(self):
        return _WXP.SfcData_getPrec12(self)

    def setPrec24(self, val):
        return _WXP.SfcData_setPrec24(self, val)

    def getPrec24(self):
        return _WXP.SfcData_getPrec24(self)

    def setPrec(self, val):
        return _WXP.SfcData_setPrec(self, val)

    def getPrec(self):
        return _WXP.SfcData_getPrec(self)

    def setPrecPer(self, per):
        return _WXP.SfcData_setPrecPer(self, per)

    def getPrecPer(self):
        return _WXP.SfcData_getPrecPer(self)

    def setCldLow(self, low):
        return _WXP.SfcData_setCldLow(self, low)

    def getCldLow(self):
        return _WXP.SfcData_getCldLow(self)

    def setCldType(self, ind, type):
        return _WXP.SfcData_setCldType(self, ind, type)

    def getCldType(self, ind):
        return _WXP.SfcData_getCldType(self, ind)

    def setMaxT(self, t):
        return _WXP.SfcData_setMaxT(self, t)

    def getMaxT(self):
        return _WXP.SfcData_getMaxT(self)

    def setMinT(self, t):
        return _WXP.SfcData_setMinT(self, t)

    def getMinT(self):
        return _WXP.SfcData_getMinT(self)

    def setMax6T(self, t):
        return _WXP.SfcData_setMax6T(self, t)

    def getMax6T(self):
        return _WXP.SfcData_getMax6T(self)

    def setMin6T(self, t):
        return _WXP.SfcData_setMin6T(self, t)

    def getMin6T(self):
        return _WXP.SfcData_getMin6T(self)

    def setSnowCov(self, snow):
        return _WXP.SfcData_setSnowCov(self, snow)

    def getSnowCov(self):
        return _WXP.SfcData_getSnowCov(self)

    def setSolar(self, solar):
        return _WXP.SfcData_setSolar(self, solar)

    def getSolar(self):
        return _WXP.SfcData_getSolar(self)

    def setSst(self, sst):
        return _WXP.SfcData_setSst(self, sst)

    def getSst(self):
        return _WXP.SfcData_getSst(self)

    def setWavPer(self, wav_per):
        return _WXP.SfcData_setWavPer(self, wav_per)

    def getWavPer(self):
        return _WXP.SfcData_getWavPer(self)

    def setWavHgt(self, wav_hgt):
        return _WXP.SfcData_setWavHgt(self, wav_hgt)

    def getWavHgt(self):
        return _WXP.SfcData_getWavHgt(self)

    def setComment(self, str):
        return _WXP.SfcData_setComment(self, str)

    def addComment(self, *args):
        return _WXP.SfcData_addComment(self, *args)

    def getComment(self):
        return _WXP.SfcData_getComment(self)

    def setFlag(self, val):
        return _WXP.SfcData_setFlag(self, val)

    def orFlag(self, val):
        return _WXP.SfcData_orFlag(self, val)

    def getFlag(self):
        return _WXP.SfcData_getFlag(self)

    def _print(self):
        return _WXP.SfcData__print(self)

    def printLine(self):
        return _WXP.SfcData_printLine(self)

    def outString(self, str):
        return _WXP.SfcData_outString(self, str)

    def update(self, *args):
        return _WXP.SfcData_update(self, *args)

    def validate(self):
        return _WXP.SfcData_validate(self)

    @staticmethod
    def compare(rep1, rep2):
        return _WXP.SfcData_compare(rep1, rep2)

    @staticmethod
    def printDiff(diff):
        return _WXP.SfcData_printDiff(diff)
    USA = _WXP.SfcData_USA
    CANADA = _WXP.SfcData_CANADA
    MEXICO = _WXP.SfcData_MEXICO
    OTHER = _WXP.SfcData_OTHER
    MANNED = _WXP.SfcData_MANNED
    AMOS = _WXP.SfcData_AMOS
    ASOS = _WXP.SfcData_ASOS
    AWOS = _WXP.SfcData_AWOS
    UNK = _WXP.SfcData_UNK
    METAR = _WXP.SfcData_METAR
    SPECI = _WXP.SfcData_SPECI
    SA = _WXP.SfcData_SA
    SP = _WXP.SfcData_SP
    SYNOP = _WXP.SfcData_SYNOP
    SHIP = _WXP.SfcData_SHIP
    BUOY = _WXP.SfcData_BUOY
    DRIBU = _WXP.SfcData_DRIBU
    MOBIL = _WXP.SfcData_MOBIL
    CMAN = _WXP.SfcData_CMAN
    MISC = _WXP.SfcData_MISC
    RMK = _WXP.SfcData_RMK
    TGRP = _WXP.SfcData_TGRP
    SPECIAL = _WXP.SfcData_SPECIAL
    CORRECT = _WXP.SfcData_CORRECT
    AUTO = _WXP.SfcData_AUTO
    DF_TYPE = _WXP.SfcData_DF_TYPE
    DF_TIME = _WXP.SfcData_DF_TIME
    DF_TEMP = _WXP.SfcData_DF_TEMP
    DF_PRES = _WXP.SfcData_DF_PRES
    DF_WIND = _WXP.SfcData_DF_WIND
    DF_WX = _WXP.SfcData_DF_WX
    DF_CLD = _WXP.SfcData_DF_CLD
    DF_VIS = _WXP.SfcData_DF_VIS
    DF_PTND = _WXP.SfcData_DF_PTND
    DF_PREC = _WXP.SfcData_DF_PREC
    DF_EXTT = _WXP.SfcData_DF_EXTT
    DF_SNOW = _WXP.SfcData_DF_SNOW
    DF_SOL = _WXP.SfcData_DF_SOL
    DF_SEA = _WXP.SfcData_DF_SEA
    DF_CTYP = _WXP.SfcData_DF_CTYP
    DF_COM = _WXP.SfcData_DF_COM
    __swig_destroy__ = _WXP.delete_SfcData

# Register SfcData in _WXP:
_WXP.SfcData_swigregister(SfcData)
class SfcFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.SfcFile_swiginit(self, _WXP.new_SfcFile(*args))
    __swig_destroy__ = _WXP.delete_SfcFile

    def isOpen(self):
        return _WXP.SfcFile_isOpen(self)

    def open(self, *args):
        return _WXP.SfcFile_open(self, *args)

    def rewind(self):
        return _WXP.SfcFile_rewind(self)

    def close(self):
        return _WXP.SfcFile_close(self)

    def getDate(self, rdate):
        return _WXP.SfcFile_getDate(self, rdate)

    def getDatim(self):
        return _WXP.SfcFile_getDatim(self)

    def setDate(self, rdate):
        return _WXP.SfcFile_setDate(self, rdate)

    def read(self, data):
        return _WXP.SfcFile_read(self, data)

    def write(self, data):
        return _WXP.SfcFile_write(self, data)

    @staticmethod
    def checkType(filename):
        return _WXP.SfcFile_checkType(filename)

    @staticmethod
    def getType(type):
        return _WXP.SfcFile_getType(type)
    UNK = _WXP.SfcFile_UNK
    WXP = _WXP.SfcFile_WXP
    NETCDF = _WXP.SfcFile_NETCDF
    XML = _WXP.SfcFile_XML
    XMLC = _WXP.SfcFile_XMLC
    UNISYS = _WXP.SfcFile_UNISYS

# Register SfcFile in _WXP:
_WXP.SfcFile_swigregister(SfcFile)
class SfcWmoData(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.SfcWmoData_swiginit(self, _WXP.new_SfcWmoData())

    def init(self):
        return _WXP.SfcWmoData_init(self)

    def setId(self, rid):
        return _WXP.SfcWmoData_setId(self, rid)

    def getId(self):
        return _WXP.SfcWmoData_getId(self)

    def setData(self, rdata):
        return _WXP.SfcWmoData_setData(self, rdata)

    def getData(self):
        return _WXP.SfcWmoData_getData(self)

    def setDate(self, rdate):
        return _WXP.SfcWmoData_setDate(self, rdate)

    def getDate(self, *args):
        return _WXP.SfcWmoData_getDate(self, *args)

    def setProdDay(self, rpday):
        return _WXP.SfcWmoData_setProdDay(self, rpday)

    def getProdDay(self):
        return _WXP.SfcWmoData_getProdDay(self)

    def setProdHour(self, rphour):
        return _WXP.SfcWmoData_setProdHour(self, rphour)

    def getProdHour(self):
        return _WXP.SfcWmoData_getProdHour(self)

    def setProdMinute(self, rpmin):
        return _WXP.SfcWmoData_setProdMinute(self, rpmin)

    def getProdMinute(self):
        return _WXP.SfcWmoData_getProdMinute(self)

    def setFormat(self, rformat):
        return _WXP.SfcWmoData_setFormat(self, rformat)

    def getFormat(self):
        return _WXP.SfcWmoData_getFormat(self)

    def setLocation(self, rloc):
        return _WXP.SfcWmoData_setLocation(self, rloc)

    def getLocation(self):
        return _WXP.SfcWmoData_getLocation(self)

    def setWmo(self, rwmo):
        return _WXP.SfcWmoData_setWmo(self, rwmo)

    def getWmo(self):
        return _WXP.SfcWmoData_getWmo(self)

    def isMETAR(self):
        return _WXP.SfcWmoData_isMETAR(self)

    def isSA(self):
        return _WXP.SfcWmoData_isSA(self)

    def isSYNOP(self):
        return _WXP.SfcWmoData_isSYNOP(self)

    def isSPEC(self):
        return _WXP.SfcWmoData_isSPEC(self)

    def printData(self):
        return _WXP.SfcWmoData_printData(self)

    def _print(self):
        return _WXP.SfcWmoData__print(self)

    @staticmethod
    def isTypeMETAR(type):
        return _WXP.SfcWmoData_isTypeMETAR(type)

    @staticmethod
    def isTypeSA(type):
        return _WXP.SfcWmoData_isTypeSA(type)

    @staticmethod
    def isTypeSYNOP(type):
        return _WXP.SfcWmoData_isTypeSYNOP(type)

    @staticmethod
    def isTypeSPEC(type):
        return _WXP.SfcWmoData_isTypeSPEC(type)
    UNK = _WXP.SfcWmoData_UNK
    USA = _WXP.SfcWmoData_USA
    CANADA = _WXP.SfcWmoData_CANADA
    MEXICO = _WXP.SfcWmoData_MEXICO
    OTHER = _WXP.SfcWmoData_OTHER
    NONE = _WXP.SfcWmoData_NONE
    METAR = _WXP.SfcWmoData_METAR
    SPECI = _WXP.SfcWmoData_SPECI
    SA = _WXP.SfcWmoData_SA
    SP = _WXP.SfcWmoData_SP
    SYNOP = _WXP.SfcWmoData_SYNOP
    SHIP = _WXP.SfcWmoData_SHIP
    BUOY = _WXP.SfcWmoData_BUOY
    DRIBU = _WXP.SfcWmoData_DRIBU
    MOBIL = _WXP.SfcWmoData_MOBIL
    CMAN = _WXP.SfcWmoData_CMAN
    MISC = _WXP.SfcWmoData_MISC
    __swig_destroy__ = _WXP.delete_SfcWmoData

# Register SfcWmoData in _WXP:
_WXP.SfcWmoData_swigregister(SfcWmoData)
class SfcWmoFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.SfcWmoFile_swiginit(self, _WXP.new_SfcWmoFile(*args))
    __swig_destroy__ = _WXP.delete_SfcWmoFile

    def init(self):
        return _WXP.SfcWmoFile_init(self)

    def isOpen(self):
        return _WXP.SfcWmoFile_isOpen(self)

    def open(self, *args):
        return _WXP.SfcWmoFile_open(self, *args)

    def rewind(self):
        return _WXP.SfcWmoFile_rewind(self)

    def close(self):
        return _WXP.SfcWmoFile_close(self)

    def setDate(self, rdate):
        return _WXP.SfcWmoFile_setDate(self, rdate)

    def getDate(self, rdate):
        return _WXP.SfcWmoFile_getDate(self, rdate)

    def checkHeader(self, line):
        return _WXP.SfcWmoFile_checkHeader(self, line)

    def checkStart(self, line):
        return _WXP.SfcWmoFile_checkStart(self, line)

    def checkEnd(self, line):
        return _WXP.SfcWmoFile_checkEnd(self, line)

    def read(self, data):
        return _WXP.SfcWmoFile_read(self, data)

    @staticmethod
    def checkType(filename):
        return _WXP.SfcWmoFile_checkType(filename)
    UNK = _WXP.SfcWmoFile_UNK
    WXP = _WXP.SfcWmoFile_WXP
    LDM = _WXP.SfcWmoFile_LDM

# Register SfcWmoFile in _WXP:
_WXP.SfcWmoFile_swigregister(SfcWmoFile)
class MosData(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NumData = _WXP.MosData_NumData
    NONE = _WXP.MosData_NONE
    NGM = _WXP.MosData_NGM
    AVN = _WXP.MosData_AVN
    GFS = _WXP.MosData_GFS
    ETA = _WXP.MosData_ETA
    NAM = _WXP.MosData_NAM
    MRF = _WXP.MosData_MRF
    GFSX = _WXP.MosData_GFSX
    LFM = _WXP.MosData_LFM
    LAMP = _WXP.MosData_LAMP

    def __init__(self):
        _WXP.MosData_swiginit(self, _WXP.new_MosData())

    def init(self):
        return _WXP.MosData_init(self)

    def setId(self, *args):
        return _WXP.MosData_setId(self, *args)

    def getId(self):
        return _WXP.MosData_getId(self)

    def getLoc(self, *args):
        return _WXP.MosData_getLoc(self, *args)

    def getLat(self):
        return _WXP.MosData_getLat(self)

    def getLon(self):
        return _WXP.MosData_getLon(self)

    def setElev(self, relev):
        return _WXP.MosData_setElev(self, relev)

    def getElev(self):
        return _WXP.MosData_getElev(self)

    def getSeconds(self):
        return _WXP.MosData_getSeconds(self)

    def setDate(self, rdate):
        return _WXP.MosData_setDate(self, rdate)

    def getDate(self, *args):
        return _WXP.MosData_getDate(self, *args)

    def setModel(self, val):
        return _WXP.MosData_setModel(self, val)

    def getModel(self):
        return _WXP.MosData_getModel(self)

    def setNum(self, val):
        return _WXP.MosData_setNum(self, val)

    def getNum(self):
        return _WXP.MosData_getNum(self)

    def setHour(self, ind, val):
        return _WXP.MosData_setHour(self, ind, val)

    def getHour(self, ind):
        return _WXP.MosData_getHour(self, ind)

    def getInd(self, hr):
        return _WXP.MosData_getInd(self, hr)

    def setT(self, ind, val):
        return _WXP.MosData_setT(self, ind, val)

    def getT(self, ind):
        return _WXP.MosData_getT(self, ind)

    def setTd(self, ind, val):
        return _WXP.MosData_setTd(self, ind, val)

    def getTd(self, ind):
        return _WXP.MosData_getTd(self, ind)

    def setCover(self, ind, val):
        return _WXP.MosData_setCover(self, ind, val)

    def getCover(self, ind):
        return _WXP.MosData_getCover(self, ind)

    def setCeiling(self, ind, val):
        return _WXP.MosData_setCeiling(self, ind, val)

    def getCeiling(self, ind):
        return _WXP.MosData_getCeiling(self, ind)

    def setVis(self, ind, val):
        return _WXP.MosData_setVis(self, ind, val)

    def getVis(self, ind):
        return _WXP.MosData_getVis(self, ind)

    def setObvis(self, ind, val):
        return _WXP.MosData_setObvis(self, ind, val)

    def getObvis(self, ind, str):
        return _WXP.MosData_getObvis(self, ind, str)

    def setTMax(self, ind, val):
        return _WXP.MosData_setTMax(self, ind, val)

    def getTMax(self, ind):
        return _WXP.MosData_getTMax(self, ind)

    def setTMin(self, ind, val):
        return _WXP.MosData_setTMin(self, ind, val)

    def getTMin(self, ind):
        return _WXP.MosData_getTMin(self, ind)

    def setWDir(self, ind, val):
        return _WXP.MosData_setWDir(self, ind, val)

    def getWDir(self, ind):
        return _WXP.MosData_getWDir(self, ind)

    def setWSpd(self, ind, val):
        return _WXP.MosData_setWSpd(self, ind, val)

    def getWSpd(self, ind):
        return _WXP.MosData_getWSpd(self, ind)

    def setPop6(self, ind, val):
        return _WXP.MosData_setPop6(self, ind, val)

    def getPop6(self, ind):
        return _WXP.MosData_getPop6(self, ind)

    def setPop12(self, ind, val):
        return _WXP.MosData_setPop12(self, ind, val)

    def getPop12(self, ind):
        return _WXP.MosData_getPop12(self, ind)

    def setPop24(self, ind, val):
        return _WXP.MosData_setPop24(self, ind, val)

    def getPop24(self, ind):
        return _WXP.MosData_getPop24(self, ind)

    def setPot6(self, ind, val):
        return _WXP.MosData_setPot6(self, ind, val)

    def getPot6(self, ind):
        return _WXP.MosData_getPot6(self, ind)

    def setPot12(self, ind, val):
        return _WXP.MosData_setPot12(self, ind, val)

    def getPot12(self, ind):
        return _WXP.MosData_getPot12(self, ind)

    def setPot24(self, ind, val):
        return _WXP.MosData_setPot24(self, ind, val)

    def getPot24(self, ind):
        return _WXP.MosData_getPot24(self, ind)

    def setPost6(self, ind, val):
        return _WXP.MosData_setPost6(self, ind, val)

    def getPost6(self, ind):
        return _WXP.MosData_getPost6(self, ind)

    def setPost12(self, ind, val):
        return _WXP.MosData_setPost12(self, ind, val)

    def getPost12(self, ind):
        return _WXP.MosData_getPost12(self, ind)

    def setPType(self, ind, val):
        return _WXP.MosData_setPType(self, ind, val)

    def getPType(self, ind):
        return _WXP.MosData_getPType(self, ind)

    def setQpf6(self, ind, val):
        return _WXP.MosData_setQpf6(self, ind, val)

    def getQpf6(self, ind):
        return _WXP.MosData_getQpf6(self, ind)

    def setQpf12(self, ind, val):
        return _WXP.MosData_setQpf12(self, ind, val)

    def getQpf12(self, ind):
        return _WXP.MosData_getQpf12(self, ind)

    def setQsf6(self, ind, val):
        return _WXP.MosData_setQsf6(self, ind, val)

    def getQsf6(self, ind):
        return _WXP.MosData_getQsf6(self, ind)

    def setQsf12(self, ind, val):
        return _WXP.MosData_setQsf12(self, ind, val)

    def getQsf12(self, ind):
        return _WXP.MosData_getQsf12(self, ind)

    def cldHght(self, ind):
        return _WXP.MosData_cldHght(self, ind)

    def visibility(self, ind):
        return _WXP.MosData_visibility(self, ind)

    def quantPrec6(self, ind):
        return _WXP.MosData_quantPrec6(self, ind)

    def quantPrec12(self, ind):
        return _WXP.MosData_quantPrec12(self, ind)

    def quantPrec24(self, ind):
        return _WXP.MosData_quantPrec24(self, ind)

    def snow6(self, ind):
        return _WXP.MosData_snow6(self, ind)

    def snow12(self, ind):
        return _WXP.MosData_snow12(self, ind)

    def snow24(self, ind):
        return _WXP.MosData_snow24(self, ind)

    def weather6(self, ind, wx6):
        return _WXP.MosData_weather6(self, ind, wx6)

    def weather12(self, ind, wx12):
        return _WXP.MosData_weather12(self, ind, wx12)

    def getNMax(self):
        return _WXP.MosData_getNMax(self)

    def getNMin(self):
        return _WXP.MosData_getNMin(self)

    def getNPop(self):
        return _WXP.MosData_getNPop(self)

    def _print(self):
        return _WXP.MosData__print(self)

    def printTable(self):
        return _WXP.MosData_printTable(self)
    __swig_destroy__ = _WXP.delete_MosData

# Register MosData in _WXP:
_WXP.MosData_swigregister(MosData)
class MosFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.MosFile_swiginit(self, _WXP.new_MosFile(*args))
    __swig_destroy__ = _WXP.delete_MosFile

    def init(self):
        return _WXP.MosFile_init(self)

    def setModel(self, *args):
        return _WXP.MosFile_setModel(self, *args)

    def open(self, *args):
        return _WXP.MosFile_open(self, *args)

    def rewind(self):
        return _WXP.MosFile_rewind(self)

    def close(self):
        return _WXP.MosFile_close(self)

    def isOpen(self):
        return _WXP.MosFile_isOpen(self)

    def getDate(self, rdate):
        return _WXP.MosFile_getDate(self, rdate)

    def read(self, data):
        return _WXP.MosFile_read(self, data)

    def decodeNGM(self, str, data):
        return _WXP.MosFile_decodeNGM(self, str, data)

    def decodeETA(self, str, data):
        return _WXP.MosFile_decodeETA(self, str, data)

    def decodeNAM(self, str, data):
        return _WXP.MosFile_decodeNAM(self, str, data)

    def decodeAVN(self, str, data):
        return _WXP.MosFile_decodeAVN(self, str, data)

    def decodeGFS(self, str, data):
        return _WXP.MosFile_decodeGFS(self, str, data)

    def decodeMRF(self, str, data):
        return _WXP.MosFile_decodeMRF(self, str, data)

    def decodeGFSX(self, str, data):
        return _WXP.MosFile_decodeGFSX(self, str, data)

    def decodeLAMP(self, str, data):
        return _WXP.MosFile_decodeLAMP(self, str, data)

    def getWmo(self):
        return _WXP.MosFile_getWmo(self)

    @staticmethod
    def getModel(*args):
        return _WXP.MosFile_getModel(*args)
    NONE = _WXP.MosFile_NONE
    NGM = _WXP.MosFile_NGM
    ETA = _WXP.MosFile_ETA
    NAM = _WXP.MosFile_NAM
    AVN = _WXP.MosFile_AVN
    GFS = _WXP.MosFile_GFS
    MRF = _WXP.MosFile_MRF
    GFSX = _WXP.MosFile_GFSX
    LAMP = _WXP.MosFile_LAMP
    PFM = _WXP.MosFile_PFM
    UNK = _WXP.MosFile_UNK
    WMO = _WXP.MosFile_WMO
    BUFR = _WXP.MosFile_BUFR
    CDF = _WXP.MosFile_CDF

# Register MosFile in _WXP:
_WXP.MosFile_swigregister(MosFile)
class MetarFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.MetarFile_swiginit(self, _WXP.new_MetarFile(*args))
    __swig_destroy__ = _WXP.delete_MetarFile

    def open(self, filename):
        return _WXP.MetarFile_open(self, filename)

    def init(self):
        return _WXP.MetarFile_init(self)

    def isOpen(self):
        return _WXP.MetarFile_isOpen(self)

    def rewind(self):
        return _WXP.MetarFile_rewind(self)

    def close(self):
        return _WXP.MetarFile_close(self)

    def checkType(self, filename):
        return _WXP.MetarFile_checkType(self, filename)

    def getLine(self, str):
        return _WXP.MetarFile_getLine(self, str)

    def getHeader(self):
        return _WXP.MetarFile_getHeader(self)
    UNK = _WXP.MetarFile_UNK
    METAR = _WXP.MetarFile_METAR
    SPECI = _WXP.MetarFile_SPECI

# Register MetarFile in _WXP:
_WXP.MetarFile_swigregister(MetarFile)
class MetarTool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def decode(*args):
        return _WXP.MetarTool_decode(*args)

    def __init__(self):
        _WXP.MetarTool_swiginit(self, _WXP.new_MetarTool())
    __swig_destroy__ = _WXP.delete_MetarTool

# Register MetarTool in _WXP:
_WXP.MetarTool_swigregister(MetarTool)
class SynopTool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def decode(*args):
        return _WXP.SynopTool_decode(*args)

    @staticmethod
    def ceiling(cb):
        return _WXP.SynopTool_ceiling(cb)

    @staticmethod
    def visibility(vis):
        return _WXP.SynopTool_visibility(vis)

    @staticmethod
    def toCeilingCode(cb):
        return _WXP.SynopTool_toCeilingCode(cb)

    @staticmethod
    def weather(wx, wx_str):
        return _WXP.SynopTool_weather(wx, wx_str)

    @staticmethod
    def autoweather(wx, wx_str):
        return _WXP.SynopTool_autoweather(wx, wx_str)
    UNK = _WXP.SynopTool_UNK
    LAND = _WXP.SynopTool_LAND
    SHIP = _WXP.SynopTool_SHIP
    BUOY = _WXP.SynopTool_BUOY
    DRIBU = _WXP.SynopTool_DRIBU
    MOBIL = _WXP.SynopTool_MOBIL
    CMAN = _WXP.SynopTool_CMAN
    MISC = _WXP.SynopTool_MISC
    KNT = _WXP.SynopTool_KNT
    MPS = _WXP.SynopTool_MPS

    def __init__(self):
        _WXP.SynopTool_swiginit(self, _WXP.new_SynopTool())
    __swig_destroy__ = _WXP.delete_SynopTool

# Register SynopTool in _WXP:
_WXP.SynopTool_swigregister(SynopTool)
class Range(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    min = property(_WXP.Range_min_get, _WXP.Range_min_set)
    max = property(_WXP.Range_max_get, _WXP.Range_max_set)

    def __init__(self, *args):
        _WXP.Range_swiginit(self, _WXP.new_Range(*args))

    def init(self):
        return _WXP.Range_init(self)

    def set(self, min, max):
        return _WXP.Range_set(self, min, max)

    def getMin(self):
        return _WXP.Range_getMin(self)

    def getMax(self):
        return _WXP.Range_getMax(self)

    def getRange(self):
        return _WXP.Range_getRange(self)

    def _print(self):
        return _WXP.Range__print(self)
    __swig_destroy__ = _WXP.delete_Range

# Register Range in _WXP:
_WXP.Range_swigregister(Range)
class VCoord(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.VCoord_swiginit(self, _WXP.new_VCoord(*args))

    def init(self):
        return _WXP.VCoord_init(self)

    def set(self, rtype, rval):
        return _WXP.VCoord_set(self, rtype, rval)

    def setType(self, rtype):
        return _WXP.VCoord_setType(self, rtype)

    def getType(self):
        return _WXP.VCoord_getType(self)

    def setVal(self, rval):
        return _WXP.VCoord_setVal(self, rval)

    def getVal(self):
        return _WXP.VCoord_getVal(self)

    def _print(self):
        return _WXP.VCoord__print(self)
    SFC = _WXP.VCoord_SFC
    FREEZE = _WXP.VCoord_FREEZE
    LCL = _WXP.VCoord_LCL
    MAXWND = _WXP.VCoord_MAXWND
    TROP = _WXP.VCoord_TROP
    PRES = _WXP.VCoord_PRES
    HEIGHT = _WXP.VCoord_HEIGHT
    POT = _WXP.VCoord_POT
    PRESS = _WXP.VCoord_PRESS

    @staticmethod
    def equal(a, b):
        return _WXP.VCoord_equal(a, b)
    __swig_destroy__ = _WXP.delete_VCoord

# Register VCoord in _WXP:
_WXP.VCoord_swigregister(VCoord)
class Level(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.Level_swiginit(self, _WXP.new_Level(*args))

    def init(self):
        return _WXP.Level_init(self)

    def isSet(self):
        return _WXP.Level_isSet(self)

    def toLevelCode(self):
        return _WXP.Level_toLevelCode(self)

    def decode(self, *args):
        return _WXP.Level_decode(self, *args)

    def set(self, *args):
        return _WXP.Level_set(self, *args)

    def getType(self):
        return _WXP.Level_getType(self)

    def getType1(self):
        return _WXP.Level_getType1(self)

    def getType2(self):
        return _WXP.Level_getType2(self)

    def getLev1(self):
        return _WXP.Level_getLev1(self)

    def getLev2(self):
        return _WXP.Level_getLev2(self)

    def getLower(self, vc):
        return _WXP.Level_getLower(self, vc)

    def getUpper(self, vc):
        return _WXP.Level_getUpper(self, vc)

    def toString(self, str):
        return _WXP.Level_toString(self, str)

    def toLabel(self, str):
        return _WXP.Level_toLabel(self, str)

    def valid(self):
        return _WXP.Level_valid(self)

    def _print(self):
        return _WXP.Level__print(self)

    def isLayer(self):
        return _WXP.Level_isLayer(self)

    def isPres(self):
        return _WXP.Level_isPres(self)

    def isHght(self):
        return _WXP.Level_isHght(self)

    def isPot(self):
        return _WXP.Level_isPot(self)

    @staticmethod
    def toTypeCode(*args):
        return _WXP.Level_toTypeCode(*args)
    NONE = _WXP.Level_NONE
    SND = _WXP.Level_SND
    SFC = _WXP.Level_SFC
    CLD_BOT = _WXP.Level_CLD_BOT
    CLD_TOP = _WXP.Level_CLD_TOP
    FRZ = _WXP.Level_FRZ
    LCL = _WXP.Level_LCL
    MWND = _WXP.Level_MWND
    TROP = _WXP.Level_TROP
    TOP = _WXP.Level_TOP
    SEABOT = _WXP.Level_SEABOT
    WHOLE = _WXP.Level_WHOLE
    CB_BASE = _WXP.Level_CB_BASE
    CB_TOP = _WXP.Level_CB_TOP
    ISOTHERM = _WXP.Level_ISOTHERM
    PR = _WXP.Level_PR
    MSL = _WXP.Level_MSL
    HT = _WXP.Level_HT
    HAG = _WXP.Level_HAG
    SIG = _WXP.Level_SIG
    HYB = _WXP.Level_HYB
    HBG = _WXP.Level_HBG
    POT = _WXP.Level_POT
    PAG = _WXP.Level_PAG
    POT_VORT = _WXP.Level_POT_VORT
    ETA = _WXP.Level_ETA
    MISC = _WXP.Level_MISC
    WHOLEL = _WXP.Level_WHOLEL
    TOP_FRZ = _WXP.Level_TOP_FRZ
    GSCLD_BOT = _WXP.Level_GSCLD_BOT
    GSCLD_TOP = _WXP.Level_GSCLD_TOP
    BLCLD_BOT = _WXP.Level_BLCLD_BOT
    BLCLD_TOP = _WXP.Level_BLCLD_TOP
    BLCLD_LYR = _WXP.Level_BLCLD_LYR
    LCLD_BOT = _WXP.Level_LCLD_BOT
    LCLD_TOP = _WXP.Level_LCLD_TOP
    LCLD_LYR = _WXP.Level_LCLD_LYR
    CLD_CEIL = _WXP.Level_CLD_CEIL
    PBL = _WXP.Level_PBL
    MCLD_BOT = _WXP.Level_MCLD_BOT
    MCLD_TOP = _WXP.Level_MCLD_TOP
    MCLD_LYR = _WXP.Level_MCLD_LYR
    HCLD_BOT = _WXP.Level_HCLD_BOT
    HCLD_TOP = _WXP.Level_HCLD_TOP
    HCLD_LYR = _WXP.Level_HCLD_LYR
    CONV_BOT = _WXP.Level_CONV_BOT
    CONV_TOP = _WXP.Level_CONV_TOP
    CONV_LYR = _WXP.Level_CONV_LYR
    WBZERO = _WXP.Level_WBZERO
    MAXEPOT = _WXP.Level_MAXEPOT
    EQUILIB = _WXP.Level_EQUILIB
    SCCLD_BOT = _WXP.Level_SCCLD_BOT
    SCCLD_TOP = _WXP.Level_SCCLD_TOP
    DCCLD_BOT = _WXP.Level_DCCLD_BOT
    DCCLD_TOP = _WXP.Level_DCCLD_TOP
    SCLW_BOT = _WXP.Level_SCLW_BOT
    SCLW_TOP = _WXP.Level_SCLW_TOP
    __swig_destroy__ = _WXP.delete_Level

# Register Level in _WXP:
_WXP.Level_swigregister(Level)
class Variable(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    max_abbr = _WXP.Variable_max_abbr
    max_name = _WXP.Variable_max_name
    max_units = _WXP.Variable_max_units

    def __init__(self, *args):
        _WXP.Variable_swiginit(self, _WXP.new_Variable(*args))

    def init(self):
        return _WXP.Variable_init(self)

    def set(self, *args):
        return _WXP.Variable_set(self, *args)

    def setType(self, t):
        return _WXP.Variable_setType(self, t)

    def getType(self):
        return _WXP.Variable_getType(self)

    def setInd(self, t):
        return _WXP.Variable_setInd(self, t)

    def getInd(self):
        return _WXP.Variable_getInd(self)

    def setVal1(self, val):
        return _WXP.Variable_setVal1(self, val)

    def getVal1(self):
        return _WXP.Variable_getVal1(self)

    def setVal2(self, val):
        return _WXP.Variable_setVal2(self, val)

    def getVal2(self):
        return _WXP.Variable_getVal2(self)

    def setName(self, str):
        return _WXP.Variable_setName(self, str)

    def getName(self):
        return _WXP.Variable_getName(self)

    def setAbbr(self, str):
        return _WXP.Variable_setAbbr(self, str)

    def getAbbr(self):
        return _WXP.Variable_getAbbr(self)

    def setUnits(self, str):
        return _WXP.Variable_setUnits(self, str)

    def getUnits(self):
        return _WXP.Variable_getUnits(self)

    def toLabel(self, str):
        return _WXP.Variable_toLabel(self, str)

    def toIndCode(self):
        return _WXP.Variable_toIndCode(self)

    def toAbbrCode(self, str):
        return _WXP.Variable_toAbbrCode(self, str)

    def toString(self, str):
        return _WXP.Variable_toString(self, str)

    def decode(self, str):
        return _WXP.Variable_decode(self, str)

    def _print(self):
        return _WXP.Variable__print(self)
    REG = _WXP.Variable_REG
    ACCUM = _WXP.Variable_ACCUM
    MEAN = _WXP.Variable_MEAN
    MAX = _WXP.Variable_MAX
    MIN = _WXP.Variable_MIN
    PROB_LT = _WXP.Variable_PROB_LT
    PROB_GT = _WXP.Variable_PROB_GT
    PROB_LTH = _WXP.Variable_PROB_LTH
    PROB_GTL = _WXP.Variable_PROB_GTL
    PROB_BET = _WXP.Variable_PROB_BET
    ENS_MEMBER = _WXP.Variable_ENS_MEMBER
    ENS_MEAN = _WXP.Variable_ENS_MEAN
    ENS_STDEV = _WXP.Variable_ENS_STDEV
    ENS_PROB_LT = _WXP.Variable_ENS_PROB_LT
    ENS_PROB_GT = _WXP.Variable_ENS_PROB_GT
    ENS_PROB_BET = _WXP.Variable_ENS_PROB_BET
    PERC = _WXP.Variable_PERC
    __swig_destroy__ = _WXP.delete_Variable

# Register Variable in _WXP:
_WXP.Variable_swigregister(Variable)
class VarSpec(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    format_len = _WXP.VarSpec_format_len

    def __init__(self, *args):
        _WXP.VarSpec_swiginit(self, _WXP.new_VarSpec(*args))

    def init(self):
        return _WXP.VarSpec_init(self)

    def setType(self, t):
        return _WXP.VarSpec_setType(self, t)

    def getType(self):
        return _WXP.VarSpec_getType(self)

    def setPlot(self, t):
        return _WXP.VarSpec_setPlot(self, t)

    def getPlot(self):
        return _WXP.VarSpec_getPlot(self)

    def setFore(self, str):
        return _WXP.VarSpec_setFore(self, str)

    def getFore(self):
        return _WXP.VarSpec_getFore(self)

    def getForeType(self):
        return _WXP.VarSpec_getForeType(self)

    def getForeTypeOffset(self):
        return _WXP.VarSpec_getForeTypeOffset(self)

    def getForeHours(self):
        return _WXP.VarSpec_getForeHours(self)

    def getForeSeconds(self):
        return _WXP.VarSpec_getForeSeconds(self)

    def getForeString(self, str):
        return _WXP.VarSpec_getForeString(self, str)

    def isForeSet(self):
        return _WXP.VarSpec_isForeSet(self)

    def setLevel(self, str):
        return _WXP.VarSpec_setLevel(self, str)

    def getLevelType1(self):
        return _WXP.VarSpec_getLevelType1(self)

    def getLevel(self):
        return _WXP.VarSpec_getLevel(self)

    def getLevelString(self, str):
        return _WXP.VarSpec_getLevelString(self, str)

    def isLevelSet(self):
        return _WXP.VarSpec_isLevelSet(self)

    def setVar(self, *args):
        return _WXP.VarSpec_setVar(self, *args)

    def set(self, *args):
        return _WXP.VarSpec_set(self, *args)

    def get(self, *args):
        return _WXP.VarSpec_get(self, *args)

    def getVar(self):
        return _WXP.VarSpec_getVar(self)

    def setUnits(self, str):
        return _WXP.VarSpec_setUnits(self, str)

    def getUnits(self):
        return _WXP.VarSpec_getUnits(self)

    def setFormat(self, str):
        return _WXP.VarSpec_setFormat(self, str)

    def getFormat(self):
        return _WXP.VarSpec_getFormat(self)

    def getForeCode(self):
        return _WXP.VarSpec_getForeCode(self)

    def getLevelTypeCode(self):
        return _WXP.VarSpec_getLevelTypeCode(self)

    def getLevelCode(self):
        return _WXP.VarSpec_getLevelCode(self)

    def getVarCode(self):
        return _WXP.VarSpec_getVarCode(self)

    def getVarType(self):
        return _WXP.VarSpec_getVarType(self)

    def getVarInd(self):
        return _WXP.VarSpec_getVarInd(self)

    def getVarAbbr(self):
        return _WXP.VarSpec_getVarAbbr(self)

    def decode(self, str):
        return _WXP.VarSpec_decode(self, str)

    def toString(self, str):
        return _WXP.VarSpec_toString(self, str)

    def toForeLabel(self, str):
        return _WXP.VarSpec_toForeLabel(self, str)

    def toLevelLabel(self, str):
        return _WXP.VarSpec_toLevelLabel(self, str)

    def toVarLabel(self, str):
        return _WXP.VarSpec_toVarLabel(self, str)

    def toVarAbbr(self, str):
        return _WXP.VarSpec_toVarAbbr(self, str)

    def toInfoLabel(self, str):
        return _WXP.VarSpec_toInfoLabel(self, str)

    def toDateLabel(self, *args):
        return _WXP.VarSpec_toDateLabel(self, *args)

    def printFore(self):
        return _WXP.VarSpec_printFore(self)

    def printLevel(self):
        return _WXP.VarSpec_printLevel(self)

    def printVar(self):
        return _WXP.VarSpec_printVar(self)

    def printDetails(self):
        return _WXP.VarSpec_printDetails(self)

    def _print(self):
        return _WXP.VarSpec__print(self)
    NONE = _WXP.VarSpec_NONE
    PARAM = _WXP.VarSpec_PARAM
    VECT = _WXP.VarSpec_VECT
    GROUP = _WXP.VarSpec_GROUP
    FUNC = _WXP.VarSpec_FUNC
    VECTFUNC = _WXP.VarSpec_VECTFUNC
    MISC = _WXP.VarSpec_MISC
    DEF = _WXP.VarSpec_DEF
    PLOT = _WXP.VarSpec_PLOT
    DATA = _WXP.VarSpec_DATA
    CONTOUR = _WXP.VarSpec_CONTOUR
    VECTOR = _WXP.VarSpec_VECTOR
    MAP = _WXP.VarSpec_MAP
    PANEL = _WXP.VarSpec_PANEL
    FORETIME = _WXP.VarSpec_FORETIME
    LEVEL = _WXP.VarSpec_LEVEL
    VAR = _WXP.VarSpec_VAR
    FORMAT = _WXP.VarSpec_FORMAT
    ALL = _WXP.VarSpec_ALL

    @staticmethod
    def update(*args):
        return _WXP.VarSpec_update(*args)
    __swig_destroy__ = _WXP.delete_VarSpec

# Register VarSpec in _WXP:
_WXP.VarSpec_swigregister(VarSpec)
class VarNameItem(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.VarNameItem_swiginit(self, _WXP.new_VarNameItem())

    def setName(self, str):
        return _WXP.VarNameItem_setName(self, str)

    def setAbbr(self, str):
        return _WXP.VarNameItem_setAbbr(self, str)

    def getInd(self, *args):
        return _WXP.VarNameItem_getInd(self, *args)

    def getAbbr(self):
        return _WXP.VarNameItem_getAbbr(self)

    def getName(self):
        return _WXP.VarNameItem_getName(self)

    def init(self):
        return _WXP.VarNameItem_init(self)

    def _print(self):
        return _WXP.VarNameItem__print(self)
    __swig_destroy__ = _WXP.delete_VarNameItem

# Register VarNameItem in _WXP:
_WXP.VarNameItem_swigregister(VarNameItem)
class VarName(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    max_vname = _WXP.VarName_max_vname

    def __init__(self):
        _WXP.VarName_swiginit(self, _WXP.new_VarName())

    def init(self):
        return _WXP.VarName_init(self)

    def getAbbr(self, rind):
        return _WXP.VarName_getAbbr(self, rind)

    def get(self, *args):
        return _WXP.VarName_get(self, *args)

    @staticmethod
    def searchFile(*args):
        return _WXP.VarName_searchFile(*args)

    @staticmethod
    def makeLabel(var, units, fullname):
        return _WXP.VarName_makeLabel(var, units, fullname)
    __swig_destroy__ = _WXP.delete_VarName

# Register VarName in _WXP:
_WXP.VarName_swigregister(VarName)
class DomainVal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    proj = property(_WXP.DomainVal_proj_get, _WXP.DomainVal_proj_set)
    plat = property(_WXP.DomainVal_plat_get, _WXP.DomainVal_plat_set)
    plon = property(_WXP.DomainVal_plon_get, _WXP.DomainVal_plon_set)
    param = property(_WXP.DomainVal_param_get, _WXP.DomainVal_param_set)
    clat = property(_WXP.DomainVal_clat_get, _WXP.DomainVal_clat_set)
    clon = property(_WXP.DomainVal_clon_get, _WXP.DomainVal_clon_set)
    dx = property(_WXP.DomainVal_dx_get, _WXP.DomainVal_dx_set)
    dy = property(_WXP.DomainVal_dy_get, _WXP.DomainVal_dy_set)
    nx = property(_WXP.DomainVal_nx_get, _WXP.DomainVal_nx_set)
    ny = property(_WXP.DomainVal_ny_get, _WXP.DomainVal_ny_set)
    ellipse = property(_WXP.DomainVal_ellipse_get, _WXP.DomainVal_ellipse_set)

    def __init__(self):
        _WXP.DomainVal_swiginit(self, _WXP.new_DomainVal())

    def init(self):
        return _WXP.DomainVal_init(self)

    def setParam(self, i, val):
        return _WXP.DomainVal_setParam(self, i, val)

    def getAspect(self):
        return _WXP.DomainVal_getAspect(self)

    def _print(self):
        return _WXP.DomainVal__print(self)

    @staticmethod
    def compare(dom1, dom2):
        return _WXP.DomainVal_compare(dom1, dom2)

    @staticmethod
    def compareProj(dom1, dom2):
        return _WXP.DomainVal_compareProj(dom1, dom2)
    PSTEREO = _WXP.DomainVal_PSTEREO
    LATLON = _WXP.DomainVal_LATLON
    MERC = _WXP.DomainVal_MERC
    LAMB = _WXP.DomainVal_LAMB
    ORTHO = _WXP.DomainVal_ORTHO
    GNOM = _WXP.DomainVal_GNOM
    MOLL = _WXP.DomainVal_MOLL
    LAMBAZ = _WXP.DomainVal_LAMBAZ
    ALBERS = _WXP.DomainVal_ALBERS
    SAT = _WXP.DomainVal_SAT
    RADIAL = _WXP.DomainVal_RADIAL
    PIXEL = _WXP.DomainVal_PIXEL
    XY = _WXP.DomainVal_XY
    XZ = _WXP.DomainVal_XZ
    XP = _WXP.DomainVal_XP
    XLOGP = _WXP.DomainVal_XLOGP
    POLAR = _WXP.DomainVal_POLAR
    CAT = _WXP.DomainVal_CAT
    SKEWT = _WXP.DomainVal_SKEWT
    STUVE = _WXP.DomainVal_STUVE
    EMA = _WXP.DomainVal_EMA
    TEPH = _WXP.DomainVal_TEPH
    RTEPH = _WXP.DomainVal_RTEPH
    ZOOM = _WXP.DomainVal_ZOOM
    SIZE = _WXP.DomainVal_SIZE
    __swig_destroy__ = _WXP.delete_DomainVal

# Register DomainVal in _WXP:
_WXP.DomainVal_swigregister(DomainVal)
class Domain(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    earth_rad = property(_WXP.Domain_earth_rad_get, _WXP.Domain_earth_rad_set)
    earth_maj = property(_WXP.Domain_earth_maj_get, _WXP.Domain_earth_maj_set)
    earth_min = property(_WXP.Domain_earth_min_get, _WXP.Domain_earth_min_set)

    def __init__(self, *args):
        _WXP.Domain_swiginit(self, _WXP.new_Domain(*args))

    def init(self):
        return _WXP.Domain_init(self)

    def set(self, *args):
        return _WXP.Domain_set(self, *args)

    def get(self):
        return _WXP.Domain_get(self)

    def isSet(self):
        return _WXP.Domain_isSet(self)

    def setParam(self):
        return _WXP.Domain_setParam(self)

    def setLimits(self):
        return _WXP.Domain_setLimits(self)

    def getLimits(self, *args):
        return _WXP.Domain_getLimits(self, *args)

    def setView(self, rect):
        return _WXP.Domain_setView(self, rect)

    def getPLat(self):
        return _WXP.Domain_getPLat(self)

    def getPLon(self):
        return _WXP.Domain_getPLon(self)

    def getCLat(self):
        return _WXP.Domain_getCLat(self)

    def getCLon(self):
        return _WXP.Domain_getCLon(self)

    def getNx(self):
        return _WXP.Domain_getNx(self)

    def getNy(self):
        return _WXP.Domain_getNy(self)

    def getDx(self):
        return _WXP.Domain_getDx(self)

    def getDy(self):
        return _WXP.Domain_getDy(self)

    def getParam(self, i):
        return _WXP.Domain_getParam(self, i)

    def tranCenter(self, pt):
        return _WXP.Domain_tranCenter(self, pt)

    def getAspect(self):
        return _WXP.Domain_getAspect(self)
    UL = _WXP.Domain_UL
    UR = _WXP.Domain_UR
    LL = _WXP.Domain_LL
    LR = _WXP.Domain_LR
    CENTER = _WXP.Domain_CENTER

    def tran(self, *args):
        return _WXP.Domain_tran(self, *args)

    def within(self, *args):
        return _WXP.Domain_within(self, *args)

    def withinExt(self, *args):
        return _WXP.Domain_withinExt(self, *args)

    def where(self, *args):
        return _WXP.Domain_where(self, *args)

    def scaleSize(self, width, height):
        return _WXP.Domain_scaleSize(self, width, height)

    def scaleGrid(self, scale):
        return _WXP.Domain_scaleGrid(self, scale)

    def zoom(self, pt, zfac):
        return _WXP.Domain_zoom(self, pt, zfac)

    def pan(self, pt):
        return _WXP.Domain_pan(self, pt)

    def adjust(self, *args):
        return _WXP.Domain_adjust(self, *args)

    def adjustDir(self, *args):
        return _WXP.Domain_adjustDir(self, *args)

    def unadjustDir(self, *args):
        return _WXP.Domain_unadjustDir(self, *args)

    def offset(self, pt, dir, rad, opt):
        return _WXP.Domain_offset(self, pt, dir, rad, opt)

    def direct(self, pt1, pt2):
        return _WXP.Domain_direct(self, pt1, pt2)

    def getVert(self):
        return _WXP.Domain_getVert(self)

    def getMapFactor(self, ept):
        return _WXP.Domain_getMapFactor(self, ept)

    def wrapLine(self, *args):
        return _WXP.Domain_wrapLine(self, *args)

    def offsetLine(self, *args):
        return _WXP.Domain_offsetLine(self, *args)

    def toString(self, string):
        return _WXP.Domain_toString(self, string)

    def _print(self):
        return _WXP.Domain__print(self)

    def printLimits(self):
        return _WXP.Domain_printLimits(self)

    def isProj(self, p):
        return _WXP.Domain_isProj(self, p)

    @staticmethod
    def getProj(*args):
        return _WXP.Domain_getProj(*args)

    @staticmethod
    def compare(dom1, dom2):
        return _WXP.Domain_compare(dom1, dom2)

    @staticmethod
    def compareProj(dom1, dom2):
        return _WXP.Domain_compareProj(dom1, dom2)

    @staticmethod
    def translate(*args):
        return _WXP.Domain_translate(*args)

    @staticmethod
    def calcEarthDist(ept1, ept2):
        return _WXP.Domain_calcEarthDist(ept1, ept2)

    @staticmethod
    def offsetLatLon(ept, dir, rad, opt):
        return _WXP.Domain_offsetLatLon(ept, dir, rad, opt)
    PSTEREO = _WXP.Domain_PSTEREO
    LATLON = _WXP.Domain_LATLON
    MERC = _WXP.Domain_MERC
    LAMB = _WXP.Domain_LAMB
    ORTHO = _WXP.Domain_ORTHO
    GNOM = _WXP.Domain_GNOM
    MOLL = _WXP.Domain_MOLL
    LAMBAZ = _WXP.Domain_LAMBAZ
    ALBERS = _WXP.Domain_ALBERS
    SAT = _WXP.Domain_SAT
    RADIAL = _WXP.Domain_RADIAL
    PIXEL = _WXP.Domain_PIXEL
    XY = _WXP.Domain_XY
    XZ = _WXP.Domain_XZ
    XP = _WXP.Domain_XP
    XLOGP = _WXP.Domain_XLOGP
    POLAR = _WXP.Domain_POLAR
    CAT = _WXP.Domain_CAT
    SKEWT = _WXP.Domain_SKEWT
    STUVE = _WXP.Domain_STUVE
    EMA = _WXP.Domain_EMA
    TEPH = _WXP.Domain_TEPH
    RTEPH = _WXP.Domain_RTEPH
    ZOOM = _WXP.Domain_ZOOM
    SIZE = _WXP.Domain_SIZE

    @staticmethod
    def isMap(*args):
        return _WXP.Domain_isMap(*args)

    @staticmethod
    def isTherm(*args):
        return _WXP.Domain_isTherm(*args)

    @staticmethod
    def isCoord(*args):
        return _WXP.Domain_isCoord(*args)

    @staticmethod
    def isPolar(*args):
        return _WXP.Domain_isPolar(*args)
    OFFSET_LL = property(_WXP.Domain_OFFSET_LL_get, _WXP.Domain_OFFSET_LL_set)
    OFFSET_MERC = property(_WXP.Domain_OFFSET_MERC_get, _WXP.Domain_OFFSET_MERC_set)
    __swig_destroy__ = _WXP.delete_Domain

# Register Domain in _WXP:
_WXP.Domain_swigregister(Domain)
class DomainTool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def proj(proj):
        return _WXP.DomainTool_proj(proj)

    @staticmethod
    def decode(*args):
        return _WXP.DomainTool_decode(*args)

    @staticmethod
    def set(*args):
        return _WXP.DomainTool_set(*args)

    def __init__(self):
        _WXP.DomainTool_swiginit(self, _WXP.new_DomainTool())
    __swig_destroy__ = _WXP.delete_DomainTool

# Register DomainTool in _WXP:
_WXP.DomainTool_swigregister(DomainTool)
class ResrcDBItem(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    name = property(_WXP.ResrcDBItem_name_get, _WXP.ResrcDBItem_name_set)
    env = property(_WXP.ResrcDBItem_env_get, _WXP.ResrcDBItem_env_set)
    cmdln = property(_WXP.ResrcDBItem_cmdln_get, _WXP.ResrcDBItem_cmdln_set)
    help = property(_WXP.ResrcDBItem_help_get, _WXP.ResrcDBItem_help_set)
    next = property(_WXP.ResrcDBItem_next_get, _WXP.ResrcDBItem_next_set)

    def __init__(self, *args):
        _WXP.ResrcDBItem_swiginit(self, _WXP.new_ResrcDBItem(*args))

    def init(self):
        return _WXP.ResrcDBItem_init(self)

    def set(self, rname, renv, rcmdln, rhelp):
        return _WXP.ResrcDBItem_set(self, rname, renv, rcmdln, rhelp)
    __swig_destroy__ = _WXP.delete_ResrcDBItem

# Register ResrcDBItem in _WXP:
_WXP.ResrcDBItem_swigregister(ResrcDBItem)
class ResrcDBList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.ResrcDBList_swiginit(self, _WXP.new_ResrcDBList())

    def add(self, *args):
        return _WXP.ResrcDBList_add(self, *args)

    def rewind(self):
        return _WXP.ResrcDBList_rewind(self)

    def first(self, *args):
        return _WXP.ResrcDBList_first(self, *args)

    def next(self, *args):
        return _WXP.ResrcDBList_next(self, *args)

    def get(self, *args):
        return _WXP.ResrcDBList_get(self, *args)

    def getNum(self):
        return _WXP.ResrcDBList_getNum(self)

    def _print(self):
        return _WXP.ResrcDBList__print(self)
    __swig_destroy__ = _WXP.delete_ResrcDBList

# Register ResrcDBList in _WXP:
_WXP.ResrcDBList_swigregister(ResrcDBList)
class ResrcDB(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def create(args, key, pos):
        return _WXP.ResrcDB_create(args, key, pos)

    @staticmethod
    def decodeProgramName(string, prog):
        return _WXP.ResrcDB_decodeProgramName(string, prog)

    @staticmethod
    def printHelp(name, key, pos):
        return _WXP.ResrcDB_printHelp(name, key, pos)

    def __init__(self):
        _WXP.ResrcDB_swiginit(self, _WXP.new_ResrcDB())
    __swig_destroy__ = _WXP.delete_ResrcDB

# Register ResrcDB in _WXP:
_WXP.ResrcDB_swigregister(ResrcDB)
class Prog(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def readResrcFile(*args):
        return _WXP.Prog_readResrcFile(*args)

    @staticmethod
    def printProg(*args):
        return _WXP.Prog_printProg(*args)

    @staticmethod
    def printHelp(res_key, res_pos, descript):
        return _WXP.Prog_printHelp(res_key, res_pos, descript)

    @staticmethod
    def setCommand(string):
        return _WXP.Prog_setCommand(string)

    @staticmethod
    def prompt(*args):
        return _WXP.Prog_prompt(*args)

    def __init__(self):
        _WXP.Prog_swiginit(self, _WXP.new_Prog())
    __swig_destroy__ = _WXP.delete_Prog

# Register Prog in _WXP:
_WXP.Prog_swigregister(Prog)
class WmoProduct(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.WmoProduct_swiginit(self, _WXP.new_WmoProduct())

    def init(self):
        return _WXP.WmoProduct_init(self)

    def setHeader(self, rheader):
        return _WXP.WmoProduct_setHeader(self, rheader)

    def getHeader(self):
        return _WXP.WmoProduct_getHeader(self)

    def setAwip(self, rawip):
        return _WXP.WmoProduct_setAwip(self, rawip)

    def getAwip(self):
        return _WXP.WmoProduct_getAwip(self)

    def setLoc(self, rloc):
        return _WXP.WmoProduct_setLoc(self, rloc)

    def getLoc(self):
        return _WXP.WmoProduct_getLoc(self)

    def setSize(self, rsize):
        return _WXP.WmoProduct_setSize(self, rsize)

    def getSize(self):
        return _WXP.WmoProduct_getSize(self)
    __swig_destroy__ = _WXP.delete_WmoProduct

# Register WmoProduct in _WXP:
_WXP.WmoProduct_swigregister(WmoProduct)
class WmoParse(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    START = _WXP.WmoParse_START
    SEQ = _WXP.WmoParse_SEQ
    HEADER = _WXP.WmoParse_HEADER
    AWIP = _WXP.WmoParse_AWIP
    SDATA = _WXP.WmoParse_SDATA
    DATA = _WXP.WmoParse_DATA
    BLANK = _WXP.WmoParse_BLANK
    DOLLAR = _WXP.WmoParse_DOLLAR
    LOCATE = _WXP.WmoParse_LOCATE
    VTEC = _WXP.WmoParse_VTEC
    LATLON = _WXP.WmoParse_LATLON
    DESC = _WXP.WmoParse_DESC

    def __init__(self, *args):
        _WXP.WmoParse_swiginit(self, _WXP.new_WmoParse(*args))

    def init(self):
        return _WXP.WmoParse_init(self)

    def setParam(self, str):
        return _WXP.WmoParse_setParam(self, str)

    def open(self, *args):
        return _WXP.WmoParse_open(self, *args)

    def isOpen(self):
        return _WXP.WmoParse_isOpen(self)

    def rewind(self):
        return _WXP.WmoParse_rewind(self)

    def close(self):
        return _WXP.WmoParse_close(self)

    def useHdrFile(self, val):
        return _WXP.WmoParse_useHdrFile(self, val)

    def useAwipsHdr(self, val):
        return _WXP.WmoParse_useAwipsHdr(self, val)

    def isNewProd(self):
        return _WXP.WmoParse_isNewProd(self)

    def setHeader(self, string):
        return _WXP.WmoParse_setHeader(self, string)

    def setId(self, id):
        return _WXP.WmoParse_setId(self, id)

    def getHeader(self):
        return _WXP.WmoParse_getHeader(self)

    def getAwip(self):
        return _WXP.WmoParse_getAwip(self)

    def getLineStatus(self):
        return _WXP.WmoParse_getLineStatus(self)

    def tell(self):
        return _WXP.WmoParse_tell(self)

    def seek(self, loc):
        return _WXP.WmoParse_seek(self, loc)

    def getLoc(self):
        return _WXP.WmoParse_getLoc(self)

    def getHeaderLoc(self):
        return _WXP.WmoParse_getHeaderLoc(self)

    def getFileInd(self):
        return _WXP.WmoParse_getFileInd(self)

    def setLoc(self, *args):
        return _WXP.WmoParse_setLoc(self, *args)

    def peek(self, prod):
        return _WXP.WmoParse_peek(self, prod)

    def read(self, prod):
        return _WXP.WmoParse_read(self, prod)

    def getLine(self, *args):
        return _WXP.WmoParse_getLine(self, *args)

    def isData(self):
        return _WXP.WmoParse_isData(self)

    @staticmethod
    def isStart(line):
        return _WXP.WmoParse_isStart(line)

    @staticmethod
    def compare(header, awip, pattern):
        return _WXP.WmoParse_compare(header, awip, pattern)

    @staticmethod
    def checkZone(line, str):
        return _WXP.WmoParse_checkZone(line, str)
    RAW = _WXP.WmoParse_RAW
    WXP = _WXP.WmoParse_WXP
    __swig_destroy__ = _WXP.delete_WmoParse

# Register WmoParse in _WXP:
_WXP.WmoParse_swigregister(WmoParse)
class ModelSpec(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.ModelSpec_swiginit(self, _WXP.new_ModelSpec(*args))

    def init(self):
        return _WXP.ModelSpec_init(self)

    def set(self, model):
        return _WXP.ModelSpec_set(self, model)

    def valid(self):
        return _WXP.ModelSpec_valid(self)

    def getNum(self):
        return _WXP.ModelSpec_getNum(self)

    def getName(self, *args):
        return _WXP.ModelSpec_getName(self, *args)

    def getNx(self):
        return _WXP.ModelSpec_getNx(self)

    def getNy(self):
        return _WXP.ModelSpec_getNy(self)

    def getX(self, ind):
        return _WXP.ModelSpec_getX(self, ind)

    def getY(self, ind):
        return _WXP.ModelSpec_getY(self, ind)

    def getType(self, ind):
        return _WXP.ModelSpec_getType(self, ind)

    def _print(self):
        return _WXP.ModelSpec__print(self)
    __swig_destroy__ = _WXP.delete_ModelSpec

# Register ModelSpec in _WXP:
_WXP.ModelSpec_swigregister(ModelSpec)
class GridSpec(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.GridSpec_swiginit(self, _WXP.new_GridSpec(*args))

    def init(self):
        return _WXP.GridSpec_init(self)

    def set(self, *args):
        return _WXP.GridSpec_set(self, *args)

    def decode(self, str):
        return _WXP.GridSpec_decode(self, str)

    def setNum(self, val):
        return _WXP.GridSpec_setNum(self, val)

    def getNum(self):
        return _WXP.GridSpec_getNum(self)

    def setModel(self, val):
        return _WXP.GridSpec_setModel(self, val)

    def getModel(self):
        return _WXP.GridSpec_getModel(self)

    def setType(self, val):
        return _WXP.GridSpec_setType(self, val)

    def getType(self):
        return _WXP.GridSpec_getType(self)

    def setTime(self, val):
        return _WXP.GridSpec_setTime(self, val)

    def getTime(self):
        return _WXP.GridSpec_getTime(self)

    def getTimeType(self):
        return _WXP.GridSpec_getTimeType(self)

    def getTimeOffset(self):
        return _WXP.GridSpec_getTimeOffset(self)

    def getTime1(self):
        return _WXP.GridSpec_getTime1(self)

    def getTime2(self):
        return _WXP.GridSpec_getTime2(self)

    def setLevelType(self, val):
        return _WXP.GridSpec_setLevelType(self, val)

    def getLevelType(self):
        return _WXP.GridSpec_getLevelType(self)

    def setLevel(self, val):
        return _WXP.GridSpec_setLevel(self, val)

    def getLevel(self):
        return _WXP.GridSpec_getLevel(self)

    def setVar(self, *args):
        return _WXP.GridSpec_setVar(self, *args)

    def getVar(self):
        return _WXP.GridSpec_getVar(self)

    def isSet(self):
        return _WXP.GridSpec_isSet(self)

    def isVarSet(self):
        return _WXP.GridSpec_isVarSet(self)

    def setUnits(self, str):
        return _WXP.GridSpec_setUnits(self, str)

    def getUnits(self):
        return _WXP.GridSpec_getUnits(self)

    def _print(self):
        return _WXP.GridSpec__print(self)

    @staticmethod
    def equal(gs1, gs2):
        return _WXP.GridSpec_equal(gs1, gs2)
    __swig_destroy__ = _WXP.delete_GridSpec

# Register GridSpec in _WXP:
_WXP.GridSpec_swigregister(GridSpec)
class Grid(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.Grid_swiginit(self, _WXP.new_Grid(*args))
    __swig_destroy__ = _WXP.delete_Grid

    def init(self):
        return _WXP.Grid_init(self)

    def setType(self, val):
        return _WXP.Grid_setType(self, val)

    def getType(self):
        return _WXP.Grid_getType(self)

    def setSource(self, val):
        return _WXP.Grid_setSource(self, val)

    def getSource(self):
        return _WXP.Grid_getSource(self)

    def setVersion(self, val):
        return _WXP.Grid_setVersion(self, val)

    def getVersion(self):
        return _WXP.Grid_getVersion(self)

    def setDatim(self, *args):
        return _WXP.Grid_setDatim(self, *args)

    def getDatim(self):
        return _WXP.Grid_getDatim(self)

    def setInfo(self, str):
        return _WXP.Grid_setInfo(self, str)

    def getInfo(self):
        return _WXP.Grid_getInfo(self)

    def setDate(self, *args):
        return _WXP.Grid_setDate(self, *args)

    def getDate(self, *args):
        return _WXP.Grid_getDate(self, *args)

    def getInitDate(self):
        return _WXP.Grid_getInitDate(self)

    def getDateVal(self):
        return _WXP.Grid_getDateVal(self)

    def setSize(self, x, y):
        return _WXP.Grid_setSize(self, x, y)

    def getSize(self, x, y):
        return _WXP.Grid_getSize(self, x, y)

    def getNx(self):
        return _WXP.Grid_getNx(self)

    def getNy(self):
        return _WXP.Grid_getNy(self)

    def getDx(self):
        return _WXP.Grid_getDx(self)

    def getDy(self):
        return _WXP.Grid_getDy(self)

    def setGridType(self, type):
        return _WXP.Grid_setGridType(self, type)

    def getGridType(self):
        return _WXP.Grid_getGridType(self)

    def setDomain(self, *args):
        return _WXP.Grid_setDomain(self, *args)

    def getDomainVal(self):
        return _WXP.Grid_getDomainVal(self)

    def getDomain(self, *args):
        return _WXP.Grid_getDomain(self, *args)

    def getProj(self):
        return _WXP.Grid_getProj(self)

    def tran(self, *args):
        return _WXP.Grid_tran(self, *args)

    def adjustDir(self, dir, pt):
        return _WXP.Grid_adjustDir(self, dir, pt)

    def unadjustDir(self, dir, pt):
        return _WXP.Grid_unadjustDir(self, dir, pt)

    def setModel(self, val):
        return _WXP.Grid_setModel(self, val)

    def getModel(self):
        return _WXP.Grid_getModel(self)

    def setGenName(self, str):
        return _WXP.Grid_setGenName(self, str)

    def getGenName(self):
        return _WXP.Grid_getGenName(self)

    def getVarSpec(self):
        return _WXP.Grid_getVarSpec(self)

    def setLevel(self, *args):
        return _WXP.Grid_setLevel(self, *args)

    def getLevel(self, *args):
        return _WXP.Grid_getLevel(self, *args)

    def getLevelType(self):
        return _WXP.Grid_getLevelType(self)

    def setForeTime(self, *args):
        return _WXP.Grid_setForeTime(self, *args)

    def getForeTime(self, *args):
        return _WXP.Grid_getForeTime(self, *args)

    def getForeHours(self):
        return _WXP.Grid_getForeHours(self)

    def getForeSeconds(self):
        return _WXP.Grid_getForeSeconds(self)

    def setVar(self, *args):
        return _WXP.Grid_setVar(self, *args)

    def getUnits(self):
        return _WXP.Grid_getUnits(self)

    def setUnits(self, units):
        return _WXP.Grid_setUnits(self, units)

    def getVar(self, *args):
        return _WXP.Grid_getVar(self, *args)

    def getSpec(self, *args):
        return _WXP.Grid_getSpec(self, *args)

    def allocData(self):
        return _WXP.Grid_allocData(self)

    def allocLocate(self):
        return _WXP.Grid_allocLocate(self)

    def setValue(self, x, y, val):
        return _WXP.Grid_setValue(self, x, y, val)

    def setValue1(self, x, y, val):
        return _WXP.Grid_setValue1(self, x, y, val)

    def getValue1(self, x, y):
        return _WXP.Grid_getValue1(self, x, y)

    def getValue(self, *args):
        return _WXP.Grid_getValue(self, *args)

    def isLocate(self):
        return _WXP.Grid_isLocate(self)

    def isData(self):
        return _WXP.Grid_isData(self)

    def isValue(self):
        return _WXP.Grid_isValue(self)

    def setLocate(self, x, y, pt):
        return _WXP.Grid_setLocate(self, x, y, pt)

    def getLocate(self, *args):
        return _WXP.Grid_getLocate(self, *args)

    def getValid(self):
        return _WXP.Grid_getValid(self)

    def getAverage(self):
        return _WXP.Grid_getAverage(self)

    def getRange(self, *args):
        return _WXP.Grid_getRange(self, *args)

    def scale(self, scale):
        return _WXP.Grid_scale(self, scale)

    def offset(self, offset):
        return _WXP.Grid_offset(self, offset)

    def _print(self):
        return _WXP.Grid__print(self)

    def printInfo(self):
        return _WXP.Grid_printInfo(self)

    def printStats(self):
        return _WXP.Grid_printStats(self)

    def printData(self):
        return _WXP.Grid_printData(self)

    @staticmethod
    def copyInfo(*args):
        return _WXP.Grid_copyInfo(*args)

    @staticmethod
    def copyData(*args):
        return _WXP.Grid_copyData(*args)

    @staticmethod
    def copy(*args):
        return _WXP.Grid_copy(*args)

# Register Grid in _WXP:
_WXP.Grid_swigregister(Grid)
class Grids(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.Grids_swiginit(self, _WXP.new_Grids(*args))
    __swig_destroy__ = _WXP.delete_Grids

    def setSize(self, rmax):
        return _WXP.Grids_setSize(self, rmax)

    def resize(self, rmax):
        return _WXP.Grids_resize(self, rmax)

    def init(self):
        return _WXP.Grids_init(self)

    def setNum(self, val):
        return _WXP.Grids_setNum(self, val)

    def getNum(self):
        return _WXP.Grids_getNum(self)

    def addSpec(self, *args):
        return _WXP.Grids_addSpec(self, *args)

    def setSpec(self, *args):
        return _WXP.Grids_setSpec(self, *args)

    def getSpec(self, *args):
        return _WXP.Grids_getSpec(self, *args)

    def getVarSpec(self, *args):
        return _WXP.Grids_getVarSpec(self, *args)

    def add(self, grid):
        return _WXP.Grids_add(self, grid)

    def addGrid(self, grid):
        return _WXP.Grids_addGrid(self, grid)

    def setGrid(self, ind, grid):
        return _WXP.Grids_setGrid(self, ind, grid)

    def get(self, ind, grid):
        return _WXP.Grids_get(self, ind, grid)

    def getGrid(self, ind, grid):
        return _WXP.Grids_getGrid(self, ind, grid)

    def getDomainVal(self, ind):
        return _WXP.Grids_getDomainVal(self, ind)

    def getDomain(self, ind):
        return _WXP.Grids_getDomain(self, ind)

    def getProj(self, ind):
        return _WXP.Grids_getProj(self, ind)

    def setDomain(self, rdom):
        return _WXP.Grids_setDomain(self, rdom)

    def allocData(self):
        return _WXP.Grids_allocData(self)

    def setDate(self, *args):
        return _WXP.Grids_setDate(self, *args)

    def setDatim(self, *args):
        return _WXP.Grids_setDatim(self, *args)

    def setInfo(self, ind, str):
        return _WXP.Grids_setInfo(self, ind, str)

    def setVar(self, ind, vspec):
        return _WXP.Grids_setVar(self, ind, vspec)

    def getSpecUnits(self, ind):
        return _WXP.Grids_getSpecUnits(self, ind)

    def isSet(self, ind):
        return _WXP.Grids_isSet(self, ind)

    def isVarSet(self, *args):
        return _WXP.Grids_isVarSet(self, *args)

    def getNumSet(self):
        return _WXP.Grids_getNumSet(self)

    def setValue(self, ind, i, j, val):
        return _WXP.Grids_setValue(self, ind, i, j, val)

    def getValue(self, *args):
        return _WXP.Grids_getValue(self, *args)

    def equal(self, *args):
        return _WXP.Grids_equal(self, *args)

    def _print(self, *args):
        return _WXP.Grids__print(self, *args)

    def printStats(self):
        return _WXP.Grids_printStats(self)

    def printData(self):
        return _WXP.Grids_printData(self)

# Register Grids in _WXP:
_WXP.Grids_swigregister(Grids)
class GribParam(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ind = property(_WXP.GribParam_ind_get, _WXP.GribParam_ind_set)
    ver = property(_WXP.GribParam_ver_get, _WXP.GribParam_ver_set)
    src = property(_WXP.GribParam_src_get, _WXP.GribParam_src_set)
    table = property(_WXP.GribParam_table_get, _WXP.GribParam_table_set)
    disc = property(_WXP.GribParam_disc_get, _WXP.GribParam_disc_set)
    cat = property(_WXP.GribParam_cat_get, _WXP.GribParam_cat_set)
    param = property(_WXP.GribParam_param_get, _WXP.GribParam_param_set)
    name = property(_WXP.GribParam_name_get, _WXP.GribParam_name_set)
    units = property(_WXP.GribParam_units_get, _WXP.GribParam_units_set)
    lname = property(_WXP.GribParam_lname_get, _WXP.GribParam_lname_set)
    cnt = property(_WXP.GribParam_cnt_get, _WXP.GribParam_cnt_set)

    def init(self):
        return _WXP.GribParam_init(self)

    def _print(self):
        return _WXP.GribParam__print(self)

    @staticmethod
    def getVer1Param(ver, src, table, param):
        return _WXP.GribParam_getVer1Param(ver, src, table, param)

    @staticmethod
    def getVer2Param(src, disc, cat, param):
        return _WXP.GribParam_getVer2Param(src, disc, cat, param)

    def __init__(self):
        _WXP.GribParam_swiginit(self, _WXP.new_GribParam())
    __swig_destroy__ = _WXP.delete_GribParam

# Register GribParam in _WXP:
_WXP.GribParam_swigregister(GribParam)
class GribPDB(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    version = property(_WXP.GribPDB_version_get, _WXP.GribPDB_version_set)
    param_ver = property(_WXP.GribPDB_param_ver_get, _WXP.GribPDB_param_ver_set)
    source = property(_WXP.GribPDB_source_get, _WXP.GribPDB_source_set)
    subcenter = property(_WXP.GribPDB_subcenter_get, _WXP.GribPDB_subcenter_set)
    model = property(_WXP.GribPDB_model_get, _WXP.GribPDB_model_set)
    grid_type = property(_WXP.GribPDB_grid_type_get, _WXP.GribPDB_grid_type_set)
    dv = property(_WXP.GribPDB_dv_get, _WXP.GribPDB_dv_set)
    fore = property(_WXP.GribPDB_fore_get, _WXP.GribPDB_fore_set)
    level = property(_WXP.GribPDB_level_get, _WXP.GribPDB_level_set)
    var = property(_WXP.GribPDB_var_get, _WXP.GribPDB_var_set)
    for_num = property(_WXP.GribPDB_for_num_get, _WXP.GribPDB_for_num_set)
    sect_flag = property(_WXP.GribPDB_sect_flag_get, _WXP.GribPDB_sect_flag_set)
    ens = property(_WXP.GribPDB_ens_get, _WXP.GribPDB_ens_set)
    ens_type = property(_WXP.GribPDB_ens_type_get, _WXP.GribPDB_ens_type_set)
    ens_id = property(_WXP.GribPDB_ens_id_get, _WXP.GribPDB_ens_id_set)
    ens_prod = property(_WXP.GribPDB_ens_prod_get, _WXP.GribPDB_ens_prod_set)
    ens_smooth = property(_WXP.GribPDB_ens_smooth_get, _WXP.GribPDB_ens_smooth_set)

    def __init__(self):
        _WXP.GribPDB_swiginit(self, _WXP.new_GribPDB())

    def init(self):
        return _WXP.GribPDB_init(self)

    def decode(self, buf, size):
        return _WXP.GribPDB_decode(self, buf, size)

    def _print(self):
        return _WXP.GribPDB__print(self)
    __swig_destroy__ = _WXP.delete_GribPDB

# Register GribPDB in _WXP:
_WXP.GribPDB_swigregister(GribPDB)
class GribFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.GribFile_swiginit(self, _WXP.new_GribFile(*args))
    __swig_destroy__ = _WXP.delete_GribFile

    def init(self):
        return _WXP.GribFile_init(self)

    def isOpen(self):
        return _WXP.GribFile_isOpen(self)

    def setParam(self, str):
        return _WXP.GribFile_setParam(self, str)

    def useHdrFile(self, val):
        return _WXP.GribFile_useHdrFile(self, val)

    def setMaxBad(self, val):
        return _WXP.GribFile_setMaxBad(self, val)

    def setMissValue(self, rmiss):
        return _WXP.GribFile_setMissValue(self, rmiss)

    def setValueBits(self, val):
        return _WXP.GribFile_setValueBits(self, val)

    def setWrap(self, val):
        return _WXP.GribFile_setWrap(self, val)

    def open(self, *args):
        return _WXP.GribFile_open(self, *args)

    def close(self):
        return _WXP.GribFile_close(self)

    def rewind(self):
        return _WXP.GribFile_rewind(self)

    def getVersion(self):
        return _WXP.GribFile_getVersion(self)

    def getWmoHdr(self):
        return _WXP.GribFile_getWmoHdr(self)

    def getHeader(self, grid):
        return _WXP.GribFile_getHeader(self, grid)

    def read(self, *args):
        return _WXP.GribFile_read(self, *args)

    def makeInfo(self, pdb, grid):
        return _WXP.GribFile_makeInfo(self, pdb, grid)

    def makeDatim(self, grid):
        return _WXP.GribFile_makeDatim(self, grid)

    def peek(self, grid):
        return _WXP.GribFile_peek(self, grid)

    def next(self):
        return _WXP.GribFile_next(self)

    def readHeader(self):
        return _WXP.GribFile_readHeader(self)

    def searchGRIB(self):
        return _WXP.GribFile_searchGRIB(self)

    def readData(self, bytes):
        return _WXP.GribFile_readData(self, bytes)

    def readBits(self):
        return _WXP.GribFile_readBits(self)

    def getByte(self, loc):
        return _WXP.GribFile_getByte(self, loc)

    def seekData(self, val):
        return _WXP.GribFile_seekData(self, val)

    def tellData(self):
        return _WXP.GribFile_tellData(self)

    def getVer1Param(self, ver, src, table, param):
        return _WXP.GribFile_getVer1Param(self, ver, src, table, param)

    def readPDB(self, pdb):
        return _WXP.GribFile_readPDB(self, pdb)

    def setPDB(self, pdb, grid):
        return _WXP.GribFile_setPDB(self, pdb, grid)

    def readGDB(self, dv):
        return _WXP.GribFile_readGDB(self, dv)

    def readBMB(self):
        return _WXP.GribFile_readBMB(self)

    def checkBMB(self):
        return _WXP.GribFile_checkBMB(self)

    def readBDB(self, grid):
        return _WXP.GribFile_readBDB(self, grid)

    def readSection(self):
        return _WXP.GribFile_readSection(self)

    def skipSection(self):
        return _WXP.GribFile_skipSection(self)

    def getVer2Param(self, src, disc, cat, param):
        return _WXP.GribFile_getVer2Param(self, src, disc, cat, param)

    def readIDS(self, pdb):
        return _WXP.GribFile_readIDS(self, pdb)

    def readGDS(self, dv):
        return _WXP.GribFile_readGDS(self, dv)

    def readPDS(self, pdb):
        return _WXP.GribFile_readPDS(self, pdb)

    def readDRS(self):
        return _WXP.GribFile_readDRS(self)

    def readBMS(self):
        return _WXP.GribFile_readBMS(self)

    def readDS(self, grid):
        return _WXP.GribFile_readDS(self, grid)

    def writeBits(self, val):
        return _WXP.GribFile_writeBits(self, val)

    def write(self, grid):
        return _WXP.GribFile_write(self, grid)

    @staticmethod
    def checkType(filename):
        return _WXP.GribFile_checkType(filename)

    @staticmethod
    def convIBMFloat(*args):
        return _WXP.GribFile_convIBMFloat(*args)

    @staticmethod
    def convIEEEFloat(pc):
        return _WXP.GribFile_convIEEEFloat(pc)

    @staticmethod
    def convScale(*args):
        return _WXP.GribFile_convScale(*args)

    @staticmethod
    def setDomain(type, dv):
        return _WXP.GribFile_setDomain(type, dv)
    LIMIT = _WXP.GribFile_LIMIT
    NONE = _WXP.GribFile_NONE
    WXP = _WXP.GribFile_WXP
    WMO = _WXP.GribFile_WMO
    WXP_OLD = _WXP.GribFile_WXP_OLD
    NCEP = _WXP.GribFile_NCEP
    RAW = _WXP.GribFile_RAW
    RAW_NS = _WXP.GribFile_RAW_NS

# Register GribFile in _WXP:
_WXP.GribFile_swigregister(GribFile)
class GridFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    UNK = _WXP.GridFile_UNK
    WXP = _WXP.GridFile_WXP
    WXPB = _WXP.GridFile_WXPB
    NETCDF = _WXP.GridFile_NETCDF
    GRIB = _WXP.GridFile_GRIB

    def __init__(self, *args):
        _WXP.GridFile_swiginit(self, _WXP.new_GridFile(*args))
    __swig_destroy__ = _WXP.delete_GridFile

    def initClass(self):
        return _WXP.GridFile_initClass(self)

    def init(self):
        return _WXP.GridFile_init(self)

    def setVer(self, v):
        return _WXP.GridFile_setVer(self, v)

    def setParam(self, str):
        return _WXP.GridFile_setParam(self, str)

    def useHdrFile(self, val):
        return _WXP.GridFile_useHdrFile(self, val)

    def setMaxBad(self, val):
        return _WXP.GridFile_setMaxBad(self, val)

    def setMissValue(self, rmiss):
        return _WXP.GridFile_setMissValue(self, rmiss)

    def setValueBits(self, val):
        return _WXP.GridFile_setValueBits(self, val)

    def setFormat(self, rform):
        return _WXP.GridFile_setFormat(self, rform)

    def open(self, *args):
        return _WXP.GridFile_open(self, *args)

    def isOpen(self):
        return _WXP.GridFile_isOpen(self)

    def getType(self):
        return _WXP.GridFile_getType(self)

    def close(self):
        return _WXP.GridFile_close(self)

    def rewind(self):
        return _WXP.GridFile_rewind(self)

    def peek(self, grid):
        return _WXP.GridFile_peek(self, grid)

    def readHdr(self, grid):
        return _WXP.GridFile_readHdr(self, grid)

    def readData(self, grid):
        return _WXP.GridFile_readData(self, grid)

    def read(self, *args):
        return _WXP.GridFile_read(self, *args)

    def write(self, *args):
        return _WXP.GridFile_write(self, *args)

    @staticmethod
    def checkType(filename):
        return _WXP.GridFile_checkType(filename)

# Register GridFile in _WXP:
_WXP.GridFile_swigregister(GridFile)
class GridMath(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def process(*args):
        return _WXP.GridMath_process(*args)

    @staticmethod
    def checkVar(grid, var):
        return _WXP.GridMath_checkVar(grid, var)

    @staticmethod
    def isVectFunc(var):
        return _WXP.GridMath_isVectFunc(var)

    @staticmethod
    def setInfo(ogrid, name, units):
        return _WXP.GridMath_setInfo(ogrid, name, units)

    @staticmethod
    def units(grid, units):
        return _WXP.GridMath_units(grid, units)

    @staticmethod
    def isDomainEqual(*args):
        return _WXP.GridMath_isDomainEqual(*args)

    @staticmethod
    def isProjEqual(*args):
        return _WXP.GridMath_isProjEqual(*args)

    @staticmethod
    def maxSpd(ugrid, vgrid):
        return _WXP.GridMath_maxSpd(ugrid, vgrid)

    @staticmethod
    def remap(ogrid, domain, igrid):
        return _WXP.GridMath_remap(ogrid, domain, igrid)

    @staticmethod
    def revalue(ogrid, str, igrid):
        return _WXP.GridMath_revalue(ogrid, str, igrid)

    @staticmethod
    def cutoff(ogrid, cmd, cutoff, nval, igrid):
        return _WXP.GridMath_cutoff(ogrid, cmd, cutoff, nval, igrid)

    @staticmethod
    def resetMiss(grid, nval):
        return _WXP.GridMath_resetMiss(grid, nval)

    @staticmethod
    def scale(ogrid, scale):
        return _WXP.GridMath_scale(ogrid, scale)

    @staticmethod
    def offset(ogrid, off):
        return _WXP.GridMath_offset(ogrid, off)

    @staticmethod
    def interp(ogrid, grid1, ival, grid2):
        return _WXP.GridMath_interp(ogrid, grid1, ival, grid2)

    @staticmethod
    def add(*args):
        return _WXP.GridMath_add(*args)

    @staticmethod
    def avg(ogrid, grids):
        return _WXP.GridMath_avg(ogrid, grids)

    @staticmethod
    def diff(*args):
        return _WXP.GridMath_diff(*args)

    @staticmethod
    def mult(ogrid, grida, gridb):
        return _WXP.GridMath_mult(ogrid, grida, gridb)

    @staticmethod
    def div(ogrid, grida, gridb):
        return _WXP.GridMath_div(ogrid, grida, gridb)

    @staticmethod
    def mod(ogrid, grida, gridb):
        return _WXP.GridMath_mod(ogrid, grida, gridb)

    @staticmethod
    def max(ogrid, grids):
        return _WXP.GridMath_max(ogrid, grids)

    @staticmethod
    def min(ogrid, grids):
        return _WXP.GridMath_min(ogrid, grids)

    @staticmethod
    def sqrt(ogrid, grid):
        return _WXP.GridMath_sqrt(ogrid, grid)

    @staticmethod
    def abs(ogrid, grid):
        return _WXP.GridMath_abs(ogrid, grid)

    @staticmethod
    def inv(ogrid, grid):
        return _WXP.GridMath_inv(ogrid, grid)

    @staticmethod
    def log(ogrid, grid):
        return _WXP.GridMath_log(ogrid, grid)

    @staticmethod
    def log10(ogrid, grid):
        return _WXP.GridMath_log10(ogrid, grid)

    @staticmethod
    def exp(ogrid, grid):
        return _WXP.GridMath_exp(ogrid, grid)

    @staticmethod
    def pow(ogrid, grida, gridb):
        return _WXP.GridMath_pow(ogrid, grida, gridb)

    @staticmethod
    def adjustUV(ugrid, vgrid):
        return _WXP.GridMath_adjustUV(ugrid, vgrid)

    @staticmethod
    def locatePoint(ogrid, grid, oper):
        return _WXP.GridMath_locatePoint(ogrid, grid, oper)

    @staticmethod
    def coriolis(ogrid, grid, oper):
        return _WXP.GridMath_coriolis(ogrid, grid, oper)

    @staticmethod
    def dx(ogrid, grid):
        return _WXP.GridMath_dx(ogrid, grid)

    @staticmethod
    def dy(ogrid, grid):
        return _WXP.GridMath_dy(ogrid, grid)

    @staticmethod
    def laplacian(ogrid, grid):
        return _WXP.GridMath_laplacian(ogrid, grid)

    @staticmethod
    def converge(*args):
        return _WXP.GridMath_converge(*args)

    @staticmethod
    def vorticity(ogrid, ugrid, vgrid):
        return _WXP.GridMath_vorticity(ogrid, ugrid, vgrid)

    @staticmethod
    def deformation1(ogrid, ugrid, vgrid):
        return _WXP.GridMath_deformation1(ogrid, ugrid, vgrid)

    @staticmethod
    def deformation2(ogrid, ugrid, vgrid):
        return _WXP.GridMath_deformation2(ogrid, ugrid, vgrid)

    @staticmethod
    def advection(ogrid, ugrid, vgrid, zgrid):
        return _WXP.GridMath_advection(ogrid, ugrid, vgrid, zgrid)

    @staticmethod
    def windSpd(ogrid, ugrid, vgrid):
        return _WXP.GridMath_windSpd(ogrid, ugrid, vgrid)

    @staticmethod
    def windDir(ogrid, ugrid, vgrid, flag):
        return _WXP.GridMath_windDir(ogrid, ugrid, vgrid, flag)

    @staticmethod
    def windU(ogrid, dgrid, sgrid, flag):
        return _WXP.GridMath_windU(ogrid, dgrid, sgrid, flag)

    @staticmethod
    def windV(ogrid, dgrid, sgrid, flag):
        return _WXP.GridMath_windV(ogrid, dgrid, sgrid, flag)

    @staticmethod
    def dewTemp(ogrid, tgrid, rgrid):
        return _WXP.GridMath_dewTemp(ogrid, tgrid, rgrid)

    @staticmethod
    def relHum(ogrid, tgrid, dgrid):
        return _WXP.GridMath_relHum(ogrid, tgrid, dgrid)

    @staticmethod
    def specHum(ogrid, tgrid, dgrid):
        return _WXP.GridMath_specHum(ogrid, tgrid, dgrid)

    @staticmethod
    def wetBulb(ogrid, tgrid, rgrid):
        return _WXP.GridMath_wetBulb(ogrid, tgrid, rgrid)

    @staticmethod
    def mixRatio(ogrid, tgrid, rgrid):
        return _WXP.GridMath_mixRatio(ogrid, tgrid, rgrid)

    @staticmethod
    def windChill(ogrid, func, tgrid, sgrid):
        return _WXP.GridMath_windChill(ogrid, func, tgrid, sgrid)

    @staticmethod
    def heatIndex(ogrid, tgrid, rgrid):
        return _WXP.GridMath_heatIndex(ogrid, tgrid, rgrid)

    @staticmethod
    def potTemp(ogrid, grid):
        return _WXP.GridMath_potTemp(ogrid, grid)

    @staticmethod
    def virtTemp(ogrid, tgrid, rgrid):
        return _WXP.GridMath_virtTemp(ogrid, tgrid, rgrid)

    @staticmethod
    def virtPotTemp(ogrid, tgrid, rgrid):
        return _WXP.GridMath_virtPotTemp(ogrid, tgrid, rgrid)

    @staticmethod
    def equivPotTemp(ogrid, tgrid, rgrid):
        return _WXP.GridMath_equivPotTemp(ogrid, tgrid, rgrid)

    @staticmethod
    def geosU(ogrid, hgrid):
        return _WXP.GridMath_geosU(ogrid, hgrid)

    @staticmethod
    def geosV(ogrid, hgrid):
        return _WXP.GridMath_geosV(ogrid, hgrid)

    @staticmethod
    def showalter(ogrid, t8grid, r8grid, t5grid):
        return _WXP.GridMath_showalter(ogrid, t8grid, r8grid, t5grid)

    @staticmethod
    def adjustDir(ugrid, vgrid, dom, flag):
        return _WXP.GridMath_adjustDir(ugrid, vgrid, dom, flag)
    UVGRID = _WXP.GridMath_UVGRID
    UVEW = _WXP.GridMath_UVEW

    def __init__(self):
        _WXP.GridMath_swiginit(self, _WXP.new_GridMath())
    __swig_destroy__ = _WXP.delete_GridMath

# Register GridMath in _WXP:
_WXP.GridMath_swigregister(GridMath)
class GridPiece(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getDomain(self, grid, rnx, rny, rx, ry, dom):
        return _WXP.GridPiece_getDomain(self, grid, rnx, rny, rx, ry, dom)

    def set(self, *args):
        return _WXP.GridPiece_set(self, *args)

    def add(self, grid, x, y, igrid):
        return _WXP.GridPiece_add(self, grid, x, y, igrid)

    def __init__(self):
        _WXP.GridPiece_swiginit(self, _WXP.new_GridPiece())
    __swig_destroy__ = _WXP.delete_GridPiece

# Register GridPiece in _WXP:
_WXP.GridPiece_swigregister(GridPiece)
class GridRead(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.GridRead_swiginit(self, _WXP.new_GridRead())

    def init(self):
        return _WXP.GridRead_init(self)

    def setParam(self, params):
        return _WXP.GridRead_setParam(self, params)

    def setMissValue(self, val):
        return _WXP.GridRead_setMissValue(self, val)

    def read(self, *args):
        return _WXP.GridRead_read(self, *args)
    __swig_destroy__ = _WXP.delete_GridRead

# Register GridRead in _WXP:
_WXP.GridRead_swigregister(GridRead)
class Image(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def initClass(self):
        return _WXP.Image_initClass(self)

    def init(self):
        return _WXP.Image_init(self)

    def __init__(self, *args):
        _WXP.Image_swiginit(self, _WXP.new_Image(*args))
    __swig_destroy__ = _WXP.delete_Image

    def set(self, *args):
        return _WXP.Image_set(self, *args)

    def allocData(self):
        return _WXP.Image_allocData(self)

    def clearData(self):
        return _WXP.Image_clearData(self)

    def validData(self):
        return _WXP.Image_validData(self)

    def allocColors(self, num):
        return _WXP.Image_allocColors(self, num)

    def hasColors(self):
        return _WXP.Image_hasColors(self)

    def setSource(self, val):
        return _WXP.Image_setSource(self, val)

    def setType(self, val):
        return _WXP.Image_setType(self, val)

    def setDate(self, *args):
        return _WXP.Image_setDate(self, *args)

    def getDate(self, *args):
        return _WXP.Image_getDate(self, *args)

    def setDatim(self, *args):
        return _WXP.Image_setDatim(self, *args)

    def getDatim(self):
        return _WXP.Image_getDatim(self)

    def setInfo(self, *args):
        return _WXP.Image_setInfo(self, *args)

    def getInfo(self):
        return _WXP.Image_getInfo(self)

    def setDomain(self, *args):
        return _WXP.Image_setDomain(self, *args)

    def getDomainProj(self):
        return _WXP.Image_getDomainProj(self)

    def getDomain(self, *args):
        return _WXP.Image_getDomain(self, *args)

    def getDomainVal(self):
        return _WXP.Image_getDomainVal(self)

    def getPLat(self):
        return _WXP.Image_getPLat(self)

    def getPLon(self):
        return _WXP.Image_getPLon(self)

    def getWidth(self):
        return _WXP.Image_getWidth(self)

    def getHeight(self):
        return _WXP.Image_getHeight(self)

    def getDepth(self):
        return _WXP.Image_getDepth(self)

    def getBytes(self):
        return _WXP.Image_getBytes(self)

    def getBytesLine(self):
        return _WXP.Image_getBytesLine(self)

    def getColorType(self):
        return _WXP.Image_getColorType(self)

    def getNumColors(self):
        return _WXP.Image_getNumColors(self)

    def getRed(self, ind):
        return _WXP.Image_getRed(self, ind)

    def getGrn(self, ind):
        return _WXP.Image_getGrn(self, ind)

    def getBlu(self, ind):
        return _WXP.Image_getBlu(self, ind)

    def setWidth(self, val):
        return _WXP.Image_setWidth(self, val)

    def setHeight(self, val):
        return _WXP.Image_setHeight(self, val)

    def setDepth(self, val):
        return _WXP.Image_setDepth(self, val)

    def setBitsPixel(self, val):
        return _WXP.Image_setBitsPixel(self, val)

    def setBytesLine(self, *args):
        return _WXP.Image_setBytesLine(self, *args)

    def setColorType(self, val):
        return _WXP.Image_setColorType(self, val)

    def setByteOrder(self, val):
        return _WXP.Image_setByteOrder(self, val)

    def setRedMask(self, arg2):
        return _WXP.Image_setRedMask(self, arg2)

    def getRedMask(self):
        return _WXP.Image_getRedMask(self)

    def setGrnMask(self, arg2):
        return _WXP.Image_setGrnMask(self, arg2)

    def getGrnMask(self):
        return _WXP.Image_getGrnMask(self)

    def setBluMask(self, arg2):
        return _WXP.Image_setBluMask(self, arg2)

    def getBluMask(self):
        return _WXP.Image_getBluMask(self)

    def setRed(self, ind, val):
        return _WXP.Image_setRed(self, ind, val)

    def setGrn(self, ind, val):
        return _WXP.Image_setGrn(self, ind, val)

    def setBlu(self, ind, val):
        return _WXP.Image_setBlu(self, ind, val)

    def setColor(self, *args):
        return _WXP.Image_setColor(self, *args)

    def setRGB(self, ind, rgb):
        return _WXP.Image_setRGB(self, ind, rgb)

    def setTransColor(self, clr):
        return _WXP.Image_setTransColor(self, clr)

    def hasTransColor(self):
        return _WXP.Image_hasTransColor(self)

    def getTransColor(self):
        return _WXP.Image_getTransColor(self)

    def setColorVal(self, ind, val):
        return _WXP.Image_setColorVal(self, ind, val)

    def getColorVal(self, ind):
        return _WXP.Image_getColorVal(self, ind)

    def setPixAve(self, val):
        return _WXP.Image_setPixAve(self, val)

    def setCutBase(self, val):
        return _WXP.Image_setCutBase(self, val)

    def setCutoff(self, *args):
        return _WXP.Image_setCutoff(self, *args)

    def hasCutoff(self):
        return _WXP.Image_hasCutoff(self)

    def getCutBase(self):
        return _WXP.Image_getCutBase(self)

    def getCutoff(self, i):
        return _WXP.Image_getCutoff(self, i)

    def getNumCut(self):
        return _WXP.Image_getNumCut(self)

    def _print(self):
        return _WXP.Image__print(self)

    def printInt(self):
        return _WXP.Image_printInt(self)

    def printValues(self):
        return _WXP.Image_printValues(self)

    def printColors(self):
        return _WXP.Image_printColors(self)

    def printHist(self):
        return _WXP.Image_printHist(self)

    def printData(self, ept):
        return _WXP.Image_printData(self, ept)

    def isPixelTrans(self, x, y):
        return _WXP.Image_isPixelTrans(self, x, y)

    def getRGB(self, *args):
        return _WXP.Image_getRGB(self, *args)

    def getRow(self, row, odata):
        return _WXP.Image_getRow(self, row, odata)

    def getData(self):
        return _WXP.Image_getData(self)

    def getPixel(self, *args):
        return _WXP.Image_getPixel(self, *args)

    def allocValues(self):
        return _WXP.Image_allocValues(self)

    def hasValues(self):
        return _WXP.Image_hasValues(self)

    def setValues(self, array):
        return _WXP.Image_setValues(self, array)

    def getIndex(self, val):
        return _WXP.Image_getIndex(self, val)

    def getValue(self, *args):
        return _WXP.Image_getValue(self, *args)

    def getVal(self, *args):
        return _WXP.Image_getVal(self, *args)

    def setPixel(self, *args):
        return _WXP.Image_setPixel(self, *args)

    def setValue(self, *args):
        return _WXP.Image_setValue(self, *args)

    def getLimits(self):
        return _WXP.Image_getLimits(self)

    def getProj(self):
        return _WXP.Image_getProj(self)

    def tran(self, *args):
        return _WXP.Image_tran(self, *args)

    def getDx(self):
        return _WXP.Image_getDx(self)

    @staticmethod
    def copyInfo(*args):
        return _WXP.Image_copyInfo(*args)

    @staticmethod
    def copyData(*args):
        return _WXP.Image_copyData(*args)

    @staticmethod
    def copy(*args):
        return _WXP.Image_copy(*args)
    ALL = _WXP.Image_ALL
    INQ = _WXP.Image_INQ
    UNK = _WXP.Image_UNK
    IMG = _WXP.Image_IMG
    GINI = _WXP.Image_GINI
    AREA = _WXP.Image_AREA
    LSB = _WXP.Image_LSB
    MSB = _WXP.Image_MSB
    TRUECOL = _WXP.Image_TRUECOL
    INDEX = _WXP.Image_INDEX
    VALUE = _WXP.Image_VALUE

# Register Image in _WXP:
_WXP.Image_swigregister(Image)
class ImageFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    UNK = _WXP.ImageFile_UNK
    IMG = _WXP.ImageFile_IMG
    IMGZ = _WXP.ImageFile_IMGZ
    TIFF = _WXP.ImageFile_TIFF
    GIF = _WXP.ImageFile_GIF
    PNG = _WXP.ImageFile_PNG
    GINIP = _WXP.ImageFile_GINIP

    def __init__(self):
        _WXP.ImageFile_swiginit(self, _WXP.new_ImageFile())

    def setVer(self, v):
        return _WXP.ImageFile_setVer(self, v)

    def open(self, *args):
        return _WXP.ImageFile_open(self, *args)

    def isOpen(self):
        return _WXP.ImageFile_isOpen(self)

    def close(self):
        return _WXP.ImageFile_close(self)

    def getType(self, str):
        return _WXP.ImageFile_getType(self, str)

    def read(self, *args):
        return _WXP.ImageFile_read(self, *args)

    def write(self, *args):
        return _WXP.ImageFile_write(self, *args)

    @staticmethod
    def checkType(filename):
        return _WXP.ImageFile_checkType(filename)

    @staticmethod
    def checkFilename(filename):
        return _WXP.ImageFile_checkFilename(filename)
    __swig_destroy__ = _WXP.delete_ImageFile

# Register ImageFile in _WXP:
_WXP.ImageFile_swigregister(ImageFile)
class ImageTool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def addColor(image, cmap, fill):
        return _WXP.ImageTool_addColor(image, cmap, fill)

    @staticmethod
    def toGrid(grid, image):
        return _WXP.ImageTool_toGrid(grid, image)

    def __init__(self):
        _WXP.ImageTool_swiginit(self, _WXP.new_ImageTool())
    __swig_destroy__ = _WXP.delete_ImageTool

# Register ImageTool in _WXP:
_WXP.ImageTool_swigregister(ImageTool)
class ImageMath(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def clip(*args):
        return _WXP.ImageMath_clip(*args)

    @staticmethod
    def scale(image, scale, new_image):
        return _WXP.ImageMath_scale(image, scale, new_image)

    @staticmethod
    def remap(image, domain, new_image):
        return _WXP.ImageMath_remap(image, domain, new_image)

    @staticmethod
    def toIndex(*args):
        return _WXP.ImageMath_toIndex(*args)

    @staticmethod
    def toGray(image, new_image):
        return _WXP.ImageMath_toGray(image, new_image)

    @staticmethod
    def toTrueColor(*args):
        return _WXP.ImageMath_toTrueColor(*args)

    @staticmethod
    def compressColor(image):
        return _WXP.ImageMath_compressColor(image)

    @staticmethod
    def merge(oimg, img):
        return _WXP.ImageMath_merge(oimg, img)

    @staticmethod
    def blank(*args):
        return _WXP.ImageMath_blank(*args)

    @staticmethod
    def maskLesser(oimg, img, grid):
        return _WXP.ImageMath_maskLesser(oimg, img, grid)

    @staticmethod
    def maskGreater(oimg, img, grid):
        return _WXP.ImageMath_maskGreater(oimg, img, grid)

    def __init__(self):
        _WXP.ImageMath_swiginit(self, _WXP.new_ImageMath())
    __swig_destroy__ = _WXP.delete_ImageMath

# Register ImageMath in _WXP:
_WXP.ImageMath_swigregister(ImageMath)
class GridTool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def valueGrid(grid, value):
        return _WXP.GridTool_valueGrid(grid, value)

    @staticmethod
    def updateSpec(*args):
        return _WXP.GridTool_updateSpec(*args)

    @staticmethod
    def toImage(*args):
        return _WXP.GridTool_toImage(*args)

    @staticmethod
    def getStats(grid, gpts, stats):
        return _WXP.GridTool_getStats(grid, gpts, stats)

    @staticmethod
    def getCoverage(grid, gpts, min, max):
        return _WXP.GridTool_getCoverage(grid, gpts, min, max)

    def __init__(self):
        _WXP.GridTool_swiginit(self, _WXP.new_GridTool())
    __swig_destroy__ = _WXP.delete_GridTool

# Register GridTool in _WXP:
_WXP.GridTool_swigregister(GridTool)
class NidsData(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    info = property(_WXP.NidsData_info_get, _WXP.NidsData_info_set)
    misc = property(_WXP.NidsData_misc_get, _WXP.NidsData_misc_set)
    src = property(_WXP.NidsData_src_get, _WXP.NidsData_src_set)
    lat = property(_WXP.NidsData_lat_get, _WXP.NidsData_lat_set)
    lon = property(_WXP.NidsData_lon_get, _WXP.NidsData_lon_set)
    mode = property(_WXP.NidsData_mode_get, _WXP.NidsData_mode_set)
    code = property(_WXP.NidsData_code_get, _WXP.NidsData_code_set)
    type = property(_WXP.NidsData_type_get, _WXP.NidsData_type_set)
    vcp = property(_WXP.NidsData_vcp_get, _WXP.NidsData_vcp_set)
    seq = property(_WXP.NidsData_seq_get, _WXP.NidsData_seq_set)
    date = property(_WXP.NidsData_date_get, _WXP.NidsData_date_set)
    domain = property(_WXP.NidsData_domain_get, _WXP.NidsData_domain_set)
    nrad = property(_WXP.NidsData_nrad_get, _WXP.NidsData_nrad_set)
    nbin = property(_WXP.NidsData_nbin_get, _WXP.NidsData_nbin_set)
    data = property(_WXP.NidsData_data_get, _WXP.NidsData_data_set)
    data_size = property(_WXP.NidsData_data_size_get, _WXP.NidsData_data_size_set)

    def __init__(self):
        _WXP.NidsData_swiginit(self, _WXP.new_NidsData())
    __swig_destroy__ = _WXP.delete_NidsData

    def initClass(self):
        return _WXP.NidsData_initClass(self)

    def tran(self, *args):
        return _WXP.NidsData_tran(self, *args)

    def getLat(self):
        return _WXP.NidsData_getLat(self)

    def getLon(self):
        return _WXP.NidsData_getLon(self)

    def getNx(self):
        return _WXP.NidsData_getNx(self)

    def getNy(self):
        return _WXP.NidsData_getNy(self)

    def getDx(self):
        return _WXP.NidsData_getDx(self)

    def getDy(self):
        return _WXP.NidsData_getDy(self)

    def offset(self, val):
        return _WXP.NidsData_offset(self, val)

    def getValue(self, *args):
        return _WXP.NidsData_getValue(self, *args)

    def _print(self):
        return _WXP.NidsData__print(self)
    RADIAL = _WXP.NidsData_RADIAL
    RASTOR = _WXP.NidsData_RASTOR

# Register NidsData in _WXP:
_WXP.NidsData_swigregister(NidsData)
class NidsInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    info = property(_WXP.NidsInfo_info_get, _WXP.NidsInfo_info_set)
    misc = property(_WXP.NidsInfo_misc_get, _WXP.NidsInfo_misc_set)
    src = property(_WXP.NidsInfo_src_get, _WXP.NidsInfo_src_set)
    lat = property(_WXP.NidsInfo_lat_get, _WXP.NidsInfo_lat_set)
    lon = property(_WXP.NidsInfo_lon_get, _WXP.NidsInfo_lon_set)
    mode = property(_WXP.NidsInfo_mode_get, _WXP.NidsInfo_mode_set)
    code = property(_WXP.NidsInfo_code_get, _WXP.NidsInfo_code_set)
    type = property(_WXP.NidsInfo_type_get, _WXP.NidsInfo_type_set)
    vcp = property(_WXP.NidsInfo_vcp_get, _WXP.NidsInfo_vcp_set)
    seq = property(_WXP.NidsInfo_seq_get, _WXP.NidsInfo_seq_set)
    date = property(_WXP.NidsInfo_date_get, _WXP.NidsInfo_date_set)
    prod_date = property(_WXP.NidsInfo_prod_date_get, _WXP.NidsInfo_prod_date_set)
    mess_date = property(_WXP.NidsInfo_mess_date_get, _WXP.NidsInfo_mess_date_set)
    nx = property(_WXP.NidsInfo_nx_get, _WXP.NidsInfo_nx_set)
    ny = property(_WXP.NidsInfo_ny_get, _WXP.NidsInfo_ny_set)
    res = property(_WXP.NidsInfo_res_get, _WXP.NidsInfo_res_set)
    cres = property(_WXP.NidsInfo_cres_get, _WXP.NidsInfo_cres_set)
    alt = property(_WXP.NidsInfo_alt_get, _WXP.NidsInfo_alt_set)
    thres = property(_WXP.NidsInfo_thres_get, _WXP.NidsInfo_thres_set)
    elev = property(_WXP.NidsInfo_elev_get, _WXP.NidsInfo_elev_set)
    elevt = property(_WXP.NidsInfo_elevt_get, _WXP.NidsInfo_elevt_set)
    range = property(_WXP.NidsInfo_range_get, _WXP.NidsInfo_range_set)
    max = property(_WXP.NidsInfo_max_get, _WXP.NidsInfo_max_set)
    nmax = property(_WXP.NidsInfo_nmax_get, _WXP.NidsInfo_nmax_set)
    beg_date = property(_WXP.NidsInfo_beg_date_get, _WXP.NidsInfo_beg_date_set)
    beg_time = property(_WXP.NidsInfo_beg_time_get, _WXP.NidsInfo_beg_time_set)
    end_date = property(_WXP.NidsInfo_end_date_get, _WXP.NidsInfo_end_date_set)
    end_time = property(_WXP.NidsInfo_end_time_get, _WXP.NidsInfo_end_time_set)

    def __init__(self):
        _WXP.NidsInfo_swiginit(self, _WXP.new_NidsInfo())

    def init(self):
        return _WXP.NidsInfo_init(self)

    def getInfo(self):
        return _WXP.NidsInfo_getInfo(self)

    def getMisc(self):
        return _WXP.NidsInfo_getMisc(self)

    def getSrc(self):
        return _WXP.NidsInfo_getSrc(self)

    def getLat(self):
        return _WXP.NidsInfo_getLat(self)

    def getLon(self):
        return _WXP.NidsInfo_getLon(self)

    def getMode(self):
        return _WXP.NidsInfo_getMode(self)

    def getCode(self):
        return _WXP.NidsInfo_getCode(self)

    def getVcp(self):
        return _WXP.NidsInfo_getVcp(self)

    def getSeq(self):
        return _WXP.NidsInfo_getSeq(self)

    def getDate(self, *args):
        return _WXP.NidsInfo_getDate(self, *args)

    def getVolDate(self):
        return _WXP.NidsInfo_getVolDate(self)

    def getProdDate(self):
        return _WXP.NidsInfo_getProdDate(self)

    def getMessDate(self):
        return _WXP.NidsInfo_getMessDate(self)

    def getRes(self):
        return _WXP.NidsInfo_getRes(self)

    def _print(self):
        return _WXP.NidsInfo__print(self)
    __swig_destroy__ = _WXP.delete_NidsInfo

# Register NidsInfo in _WXP:
_WXP.NidsInfo_swigregister(NidsInfo)
class NidsRadial(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ang0 = property(_WXP.NidsRadial_ang0_get, _WXP.NidsRadial_ang0_set)
    ang1 = property(_WXP.NidsRadial_ang1_get, _WXP.NidsRadial_ang1_set)

    def _print(self):
        return _WXP.NidsRadial__print(self)

    def __init__(self):
        _WXP.NidsRadial_swiginit(self, _WXP.new_NidsRadial())
    __swig_destroy__ = _WXP.delete_NidsRadial

# Register NidsRadial in _WXP:
_WXP.NidsRadial_swigregister(NidsRadial)
class NidsRun(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    run = property(_WXP.NidsRun_run_get, _WXP.NidsRun_run_set)
    ival = property(_WXP.NidsRun_ival_get, _WXP.NidsRun_ival_set)
    val = property(_WXP.NidsRun_val_get, _WXP.NidsRun_val_set)

    def _print(self):
        return _WXP.NidsRun__print(self)

    def __init__(self):
        _WXP.NidsRun_swiginit(self, _WXP.new_NidsRun())
    __swig_destroy__ = _WXP.delete_NidsRun

# Register NidsRun in _WXP:
_WXP.NidsRun_swigregister(NidsRun)
class NidsText(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    val = property(_WXP.NidsText_val_get, _WXP.NidsText_val_set)
    x = property(_WXP.NidsText_x_get, _WXP.NidsText_x_set)
    y = property(_WXP.NidsText_y_get, _WXP.NidsText_y_set)
    data = property(_WXP.NidsText_data_get, _WXP.NidsText_data_set)

    def getData(self):
        return _WXP.NidsText_getData(self)

    def _print(self):
        return _WXP.NidsText__print(self)

    def __init__(self):
        _WXP.NidsText_swiginit(self, _WXP.new_NidsText())
    __swig_destroy__ = _WXP.delete_NidsText

# Register NidsText in _WXP:
_WXP.NidsText_swigregister(NidsText)
class NidsVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    val = property(_WXP.NidsVector_val_get, _WXP.NidsVector_val_set)
    x1 = property(_WXP.NidsVector_x1_get, _WXP.NidsVector_x1_set)
    y1 = property(_WXP.NidsVector_y1_get, _WXP.NidsVector_y1_set)
    x2 = property(_WXP.NidsVector_x2_get, _WXP.NidsVector_x2_set)
    y2 = property(_WXP.NidsVector_y2_get, _WXP.NidsVector_y2_set)

    def _print(self):
        return _WXP.NidsVector__print(self)

    def __init__(self):
        _WXP.NidsVector_swiginit(self, _WXP.new_NidsVector())
    __swig_destroy__ = _WXP.delete_NidsVector

# Register NidsVector in _WXP:
_WXP.NidsVector_swigregister(NidsVector)
class NidsWind(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    val = property(_WXP.NidsWind_val_get, _WXP.NidsWind_val_set)
    x = property(_WXP.NidsWind_x_get, _WXP.NidsWind_x_set)
    y = property(_WXP.NidsWind_y_get, _WXP.NidsWind_y_set)
    dir = property(_WXP.NidsWind_dir_get, _WXP.NidsWind_dir_set)
    spd = property(_WXP.NidsWind_spd_get, _WXP.NidsWind_spd_set)

    def _print(self):
        return _WXP.NidsWind__print(self)

    def __init__(self):
        _WXP.NidsWind_swiginit(self, _WXP.new_NidsWind())
    __swig_destroy__ = _WXP.delete_NidsWind

# Register NidsWind in _WXP:
_WXP.NidsWind_swigregister(NidsWind)
class NidsFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.NidsFile_swiginit(self, _WXP.new_NidsFile(*args))
    __swig_destroy__ = _WXP.delete_NidsFile

    def init(self):
        return _WXP.NidsFile_init(self)

    def open(self, filename):
        return _WXP.NidsFile_open(self, filename)

    def close(self):
        return _WXP.NidsFile_close(self)

    def isOpen(self):
        return _WXP.NidsFile_isOpen(self)

    def skipLine(self):
        return _WXP.NidsFile_skipLine(self)

    def readRaw(self):
        return _WXP.NidsFile_readRaw(self)

    def readBytes(self, data, size):
        return _WXP.NidsFile_readBytes(self, data, size)

    def dump(self, num, flag):
        return _WXP.NidsFile_dump(self, num, flag)

    def readShort(self, *args):
        return _WXP.NidsFile_readShort(self, *args)

    def readUshort(self, val):
        return _WXP.NidsFile_readUshort(self, val)

    def readLong(self, *args):
        return _WXP.NidsFile_readLong(self, *args)

    def readUlong(self, val):
        return _WXP.NidsFile_readUlong(self, val)

    def float16(self, val):
        return _WXP.NidsFile_float16(self, val)

    def float32(self, val1, val2):
        return _WXP.NidsFile_float32(self, val1, val2)

    def readHeader(self, info):
        return _WXP.NidsFile_readHeader(self, info)

    def messHeader(self):
        return _WXP.NidsFile_messHeader(self)

    def prodDesc(self):
        return _WXP.NidsFile_prodDesc(self)

    def prodSymb(self):
        return _WXP.NidsFile_prodSymb(self)

    def prodSymbLayer(self):
        return _WXP.NidsFile_prodSymbLayer(self)

    def gotoGraphic(self):
        return _WXP.NidsFile_gotoGraphic(self)

    def graphic(self):
        return _WXP.NidsFile_graphic(self)

    def graphicLayer(self):
        return _WXP.NidsFile_graphicLayer(self)

    def readPacket(self):
        return _WXP.NidsFile_readPacket(self)

    def readRastor(self):
        return _WXP.NidsFile_readRastor(self)

    def readRadial(self, radial):
        return _WXP.NidsFile_readRadial(self, radial)

    def readRun(self, data):
        return _WXP.NidsFile_readRun(self, data)

    def readVector(self, vect):
        return _WXP.NidsFile_readVector(self, vect)

    def skipVector(self):
        return _WXP.NidsFile_skipVector(self)

    def readText(self, text):
        return _WXP.NidsFile_readText(self, text)

    def skipText(self):
        return _WXP.NidsFile_skipText(self)

    def readWind(self, wind):
        return _WXP.NidsFile_readWind(self, wind)

    def skipWind(self):
        return _WXP.NidsFile_skipWind(self)

    def readData(self, data):
        return _WXP.NidsFile_readData(self, data)

    def getCode(self):
        return _WXP.NidsFile_getCode(self)

    def isBRef(self):
        return _WXP.NidsFile_isBRef(self)

    def isBSW(self):
        return _WXP.NidsFile_isBSW(self)

    def isCRef(self):
        return _WXP.NidsFile_isCRef(self)

    def isVel(self):
        return _WXP.NidsFile_isVel(self)

    def isSRVel(self):
        return _WXP.NidsFile_isSRVel(self)

    def isTops(self):
        return _WXP.NidsFile_isTops(self)

    def isEnhTops(self):
        return _WXP.NidsFile_isEnhTops(self)

    def isLRef(self):
        return _WXP.NidsFile_isLRef(self)

    def isVIL(self):
        return _WXP.NidsFile_isVIL(self)

    def isDigVIL(self):
        return _WXP.NidsFile_isDigVIL(self)

    def isVAD(self):
        return _WXP.NidsFile_isVAD(self)

    def isPrec(self):
        return _WXP.NidsFile_isPrec(self)

    def isDPrec(self):
        return _WXP.NidsFile_isDPrec(self)

    def isDPrRate(self):
        return _WXP.NidsFile_isDPrRate(self)

    def isHydroClass(self):
        return _WXP.NidsFile_isHydroClass(self)

    def isCorrel(self):
        return _WXP.NidsFile_isCorrel(self)

    def isDPA(self):
        return _WXP.NidsFile_isDPA(self)

    def isDHR(self):
        return _WXP.NidsFile_isDHR(self)

    def isDSP(self):
        return _WXP.NidsFile_isDSP(self)

    def isDRef(self):
        return _WXP.NidsFile_isDRef(self)

    def isDual(self):
        return _WXP.NidsFile_isDual(self)

    def isPacketRadial(self):
        return _WXP.NidsFile_isPacketRadial(self)

    def isPacketRastor(self):
        return _WXP.NidsFile_isPacketRastor(self)

    def isPacketVector(self):
        return _WXP.NidsFile_isPacketVector(self)

    def isPacketWindbarb(self):
        return _WXP.NidsFile_isPacketWindbarb(self)

    def isPacketText(self):
        return _WXP.NidsFile_isPacketText(self)

    def isPacketDpa(self):
        return _WXP.NidsFile_isPacketDpa(self)

    def getPacketCode(self):
        return _WXP.NidsFile_getPacketCode(self)

    def getNbin(self):
        return _WXP.NidsFile_getNbin(self)

    def getNrad(self):
        return _WXP.NidsFile_getNrad(self)

    def getDomainVal(self):
        return _WXP.NidsFile_getDomainVal(self)
    RADIAL = _WXP.NidsFile_RADIAL
    RASTOR = _WXP.NidsFile_RASTOR
    OM = _WXP.NidsFile_OM
    CLEARAIR = _WXP.NidsFile_CLEARAIR
    PRECIP = _WXP.NidsFile_PRECIP
    REG = _WXP.NidsFile_REG
    ZCOMP = _WXP.NidsFile_ZCOMP
    ENC = _WXP.NidsFile_ENC
    BCOMP = _WXP.NidsFile_BCOMP

# Register NidsFile in _WXP:
_WXP.NidsFile_swigregister(NidsFile)
class NidsImage(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.NidsImage_swiginit(self, _WXP.new_NidsImage(*args))

    def init(self):
        return _WXP.NidsImage_init(self)

    def setParam(self, str):
        return _WXP.NidsImage_setParam(self, str)

    def setClutterRad(self, crad):
        return _WXP.NidsImage_setClutterRad(self, crad)

    def setRamp(self, cut, len):
        return _WXP.NidsImage_setRamp(self, cut, len)

    def getRampCut(self):
        return _WXP.NidsImage_getRampCut(self)

    def getRampLen(self):
        return _WXP.NidsImage_getRampLen(self)

    def setThres(self, *args):
        return _WXP.NidsImage_setThres(self, *args)

    def setClearAirUse(self, val):
        return _WXP.NidsImage_setClearAirUse(self, val)

    def getClearAirUse(self):
        return _WXP.NidsImage_getClearAirUse(self)

    def getMode(self):
        return _WXP.NidsImage_getMode(self)

    def getIndex(self, val):
        return _WXP.NidsImage_getIndex(self, val)

    def setup(self, image):
        return _WXP.NidsImage_setup(self, image)

    def readSite(self, filename):
        return _WXP.NidsImage_readSite(self, filename)

    def addSite(self, *args):
        return _WXP.NidsImage_addSite(self, *args)

    def setImage(self, filename, image):
        return _WXP.NidsImage_setImage(self, filename, image)

    def applyMask(self, image, mask):
        return _WXP.NidsImage_applyMask(self, image, mask)

    def _print(self):
        return _WXP.NidsImage__print(self)

    def printSite(self):
        return _WXP.NidsImage_printSite(self)
    BREF = _WXP.NidsImage_BREF
    RALA = _WXP.NidsImage_RALA
    RADIAL = _WXP.NidsImage_RADIAL
    RASTOR = _WXP.NidsImage_RASTOR
    __swig_destroy__ = _WXP.delete_NidsImage

# Register NidsImage in _WXP:
_WXP.NidsImage_swigregister(NidsImage)
class StormAttr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_WXP.StormAttr_type_get, _WXP.StormAttr_type_set)
    id = property(_WXP.StormAttr_id_get, _WXP.StormAttr_id_set)
    ang = property(_WXP.StormAttr_ang_get, _WXP.StormAttr_ang_set)
    rad = property(_WXP.StormAttr_rad_get, _WXP.StormAttr_rad_set)
    tvs = property(_WXP.StormAttr_tvs_get, _WXP.StormAttr_tvs_set)
    meso = property(_WXP.StormAttr_meso_get, _WXP.StormAttr_meso_set)
    hail = property(_WXP.StormAttr_hail_get, _WXP.StormAttr_hail_set)
    shail = property(_WXP.StormAttr_shail_get, _WXP.StormAttr_shail_set)
    hsize = property(_WXP.StormAttr_hsize_get, _WXP.StormAttr_hsize_set)
    vil = property(_WXP.StormAttr_vil_get, _WXP.StormAttr_vil_set)
    max_dbz = property(_WXP.StormAttr_max_dbz_get, _WXP.StormAttr_max_dbz_set)
    max_dbz_z = property(_WXP.StormAttr_max_dbz_z_get, _WXP.StormAttr_max_dbz_z_set)
    vlow = property(_WXP.StormAttr_vlow_get, _WXP.StormAttr_vlow_set)
    tops = property(_WXP.StormAttr_tops_get, _WXP.StormAttr_tops_set)
    dir = property(_WXP.StormAttr_dir_get, _WXP.StormAttr_dir_set)
    spd = property(_WXP.StormAttr_spd_get, _WXP.StormAttr_spd_set)
    mw_vol = property(_WXP.StormAttr_mw_vol_get, _WXP.StormAttr_mw_vol_set)

    def __init__(self):
        _WXP.StormAttr_swiginit(self, _WXP.new_StormAttr())

    def init(self):
        return _WXP.StormAttr_init(self)

    def checkType(self, str):
        return _WXP.StormAttr_checkType(self, str)

    def decode(self, str):
        return _WXP.StormAttr_decode(self, str)

    def isValid(self):
        return _WXP.StormAttr_isValid(self)

    def getType(self):
        return _WXP.StormAttr_getType(self)

    def getId(self):
        return _WXP.StormAttr_getId(self)

    def getAng(self):
        return _WXP.StormAttr_getAng(self)

    def getRad(self):
        return _WXP.StormAttr_getRad(self)

    def getTvs(self):
        return _WXP.StormAttr_getTvs(self)

    def getMeso(self):
        return _WXP.StormAttr_getMeso(self)

    def getHail(self):
        return _WXP.StormAttr_getHail(self)

    def getSHail(self):
        return _WXP.StormAttr_getSHail(self)

    def getHSize(self):
        return _WXP.StormAttr_getHSize(self)

    def getVil(self):
        return _WXP.StormAttr_getVil(self)

    def getMaxDbz(self):
        return _WXP.StormAttr_getMaxDbz(self)

    def getMaxDbzZ(self):
        return _WXP.StormAttr_getMaxDbzZ(self)

    def getVLow(self):
        return _WXP.StormAttr_getVLow(self)

    def getTops(self):
        return _WXP.StormAttr_getTops(self)

    def getDir(self):
        return _WXP.StormAttr_getDir(self)

    def getSpd(self):
        return _WXP.StormAttr_getSpd(self)

    def getMWVol(self):
        return _WXP.StormAttr_getMWVol(self)

    def _print(self):
        return _WXP.StormAttr__print(self)
    __swig_destroy__ = _WXP.delete_StormAttr

# Register StormAttr in _WXP:
_WXP.StormAttr_swigregister(StormAttr)
class Listener(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _WXP.delete_Listener

    def callback(self, ev_str, ev_data, data):
        return _WXP.Listener_callback(self, ev_str, ev_data, data)

# Register Listener in _WXP:
_WXP.Listener_swigregister(Listener)
class GraphAttr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    HALIGN_NORMAL = _WXP.GraphAttr_HALIGN_NORMAL
    HALIGN_LEFT = _WXP.GraphAttr_HALIGN_LEFT
    HALIGN_CENTER = _WXP.GraphAttr_HALIGN_CENTER
    HALIGN_RIGHT = _WXP.GraphAttr_HALIGN_RIGHT
    VALIGN_NORMAL = _WXP.GraphAttr_VALIGN_NORMAL
    VALIGN_TOP = _WXP.GraphAttr_VALIGN_TOP
    VALIGN_CAP = _WXP.GraphAttr_VALIGN_CAP
    VALIGN_HALF = _WXP.GraphAttr_VALIGN_HALF
    VALIGN_BASE = _WXP.GraphAttr_VALIGN_BASE
    VALIGN_BOTTOM = _WXP.GraphAttr_VALIGN_BOTTOM
    MARK_NONE = _WXP.GraphAttr_MARK_NONE
    MARK_POINT = _WXP.GraphAttr_MARK_POINT
    MARK_PLUS = _WXP.GraphAttr_MARK_PLUS
    MARK_STAR = _WXP.GraphAttr_MARK_STAR
    MARK_O = _WXP.GraphAttr_MARK_O
    MARK_CIRCLE = _WXP.GraphAttr_MARK_CIRCLE
    MARK_X = _WXP.GraphAttr_MARK_X
    MARK_SQUARE = _WXP.GraphAttr_MARK_SQUARE
    MARK_TRIANGLE = _WXP.GraphAttr_MARK_TRIANGLE
    MARK_DOT = _WXP.GraphAttr_MARK_DOT
    MARK_INVTRIANGLE = _WXP.GraphAttr_MARK_INVTRIANGLE
    MARK_LIGHT = _WXP.GraphAttr_MARK_LIGHT
    VIEW_HLEFT = _WXP.GraphAttr_VIEW_HLEFT
    VIEW_HCENTER = _WXP.GraphAttr_VIEW_HCENTER
    VIEW_HRIGHT = _WXP.GraphAttr_VIEW_HRIGHT
    VIEW_VBOTTOM = _WXP.GraphAttr_VIEW_VBOTTOM
    VIEW_VCENTER = _WXP.GraphAttr_VIEW_VCENTER
    VIEW_VTOP = _WXP.GraphAttr_VIEW_VTOP
    IMAGE_HLEFT = _WXP.GraphAttr_IMAGE_HLEFT
    IMAGE_HCENTER = _WXP.GraphAttr_IMAGE_HCENTER
    IMAGE_HRIGHT = _WXP.GraphAttr_IMAGE_HRIGHT
    IMAGE_VBOTTOM = _WXP.GraphAttr_IMAGE_VBOTTOM
    IMAGE_VCENTER = _WXP.GraphAttr_IMAGE_VCENTER
    IMAGE_VTOP = _WXP.GraphAttr_IMAGE_VTOP
    TRAN_MAX = _WXP.GraphAttr_TRAN_MAX
    TRAN_PLOT = _WXP.GraphAttr_TRAN_PLOT
    CURSOR_X = _WXP.GraphAttr_CURSOR_X
    CURSOR_PTR = _WXP.GraphAttr_CURSOR_PTR
    CURSOR_MOVE = _WXP.GraphAttr_CURSOR_MOVE
    CURSOR_LOOP = _WXP.GraphAttr_CURSOR_LOOP
    CURSOR_STOP = _WXP.GraphAttr_CURSOR_STOP
    CURSOR_DRAW = _WXP.GraphAttr_CURSOR_DRAW
    CURSOR_RECT = _WXP.GraphAttr_CURSOR_RECT
    CURSOR_PLUS = _WXP.GraphAttr_CURSOR_PLUS
    CURSOR_TEXT = _WXP.GraphAttr_CURSOR_TEXT
    CURSOR_WAIT = _WXP.GraphAttr_CURSOR_WAIT

    def __init__(self):
        _WXP.GraphAttr_swiginit(self, _WXP.new_GraphAttr())
    __swig_destroy__ = _WXP.delete_GraphAttr

# Register GraphAttr in _WXP:
_WXP.GraphAttr_swigregister(GraphAttr)
class Graph(Listener, GraphAttr):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.Graph_swiginit(self, _WXP.new_Graph(*args))
    __swig_destroy__ = _WXP.delete_Graph

    def init(self):
        return _WXP.Graph_init(self)

    def setDevice(self, device, params):
        return _WXP.Graph_setDevice(self, device, params)

    def getDevice(self, str):
        return _WXP.Graph_getDevice(self, str)

    def open(self, *args):
        return _WXP.Graph_open(self, *args)

    def isOpen(self):
        return _WXP.Graph_isOpen(self)

    def close(self):
        return _WXP.Graph_close(self)

    def update(self):
        return _WXP.Graph_update(self)

    def manage(self):
        return _WXP.Graph_manage(self)

    def unmanage(self):
        return _WXP.Graph_unmanage(self)

    def isManaged(self):
        return _WXP.Graph_isManaged(self)

    def callback(self, ev_str, ev_data, data):
        return _WXP.Graph_callback(self, ev_str, ev_data, data)

    def doCallback(self, ev_str, ev_data):
        return _WXP.Graph_doCallback(self, ev_str, ev_data)

    def addCallback(self, ev, list, data):
        return _WXP.Graph_addCallback(self, ev, list, data)

    def setFixed(self, val):
        return _WXP.Graph_setFixed(self, val)

    def setSize(self, width, height):
        return _WXP.Graph_setSize(self, width, height)

    def setOffset(self, rx, ry):
        return _WXP.Graph_setOffset(self, rx, ry)

    def setInverse(self, val):
        return _WXP.Graph_setInverse(self, val)

    def getInverse(self):
        return _WXP.Graph_getInverse(self)

    def setBackground(self, str):
        return _WXP.Graph_setBackground(self, str)

    def setIcon(self, val):
        return _WXP.Graph_setIcon(self, val)

    def setTitle(self, str):
        return _WXP.Graph_setTitle(self, str)

    def setTran(self, num):
        return _WXP.Graph_setTran(self, num)

    def setViewportAspect(self, *args):
        return _WXP.Graph_setViewportAspect(self, *args)

    def setViewport(self, *args):
        return _WXP.Graph_setViewport(self, *args)

    def getViewport(self, *args):
        return _WXP.Graph_getViewport(self, *args)

    def getDeviceViewport(self, *args):
        return _WXP.Graph_getDeviceViewport(self, *args)

    def getMaxViewport(self, *args):
        return _WXP.Graph_getMaxViewport(self, *args)

    def setWindow(self, *args):
        return _WXP.Graph_setWindow(self, *args)

    def getWindow(self, *args):
        return _WXP.Graph_getWindow(self, *args)

    def getTran(self):
        return _WXP.Graph_getTran(self)

    def activateTran(self, *args):
        return _WXP.Graph_activateTran(self, *args)

    def tranPlotView(self, x1, y1, x2, y2):
        return _WXP.Graph_tranPlotView(self, x1, y1, x2, y2)

    def tranPlotWindow(self, *args):
        return _WXP.Graph_tranPlotWindow(self, *args)

    def tranWindow(self, *args):
        return _WXP.Graph_tranWindow(self, *args)

    def clear(self):
        return _WXP.Graph_clear(self)

    def clearRect(self, rect):
        return _WXP.Graph_clearRect(self, rect)

    def allocColor(self, *args):
        return _WXP.Graph_allocColor(self, *args)

    def drawLine(self, *args):
        return _WXP.Graph_drawLine(self, *args)

    def drawRect(self, *args):
        return _WXP.Graph_drawRect(self, *args)

    def drawCircle(self, *args):
        return _WXP.Graph_drawCircle(self, *args)

    def setLineColor(self, index):
        return _WXP.Graph_setLineColor(self, index)

    def setLineWidth(self, width):
        return _WXP.Graph_setLineWidth(self, width)

    def setLineStyle(self, style):
        return _WXP.Graph_setLineStyle(self, style)

    def drawFill(self, *args):
        return _WXP.Graph_drawFill(self, *args)

    def drawFillarea(self, data):
        return _WXP.Graph_drawFillarea(self, data)

    def setFillColor(self, index):
        return _WXP.Graph_setFillColor(self, index)

    def setFillStyle(self, index):
        return _WXP.Graph_setFillStyle(self, index)

    def drawMarkLine(self, x, y, size):
        return _WXP.Graph_drawMarkLine(self, x, y, size)

    def drawMark(self, *args):
        return _WXP.Graph_drawMark(self, *args)

    def setMarkColor(self, index):
        return _WXP.Graph_setMarkColor(self, index)

    def setMarkSize(self, size):
        return _WXP.Graph_setMarkSize(self, size)

    def setMarkType(self, type):
        return _WXP.Graph_setMarkType(self, type)

    def setMarkWeight(self, weight):
        return _WXP.Graph_setMarkWeight(self, weight)

    def drawText(self, *args):
        return _WXP.Graph_drawText(self, *args)

    def drawFormText(self, *args):
        return _WXP.Graph_drawFormText(self, *args)

    def setTextColor(self, color):
        return _WXP.Graph_setTextColor(self, color)

    def setFontSpec(self):
        return _WXP.Graph_setFontSpec(self)

    def setFont(self, str):
        return _WXP.Graph_setFont(self, str)

    def setTextBoxColor(self, index):
        return _WXP.Graph_setTextBoxColor(self, index)

    def setDropColor(self, index):
        return _WXP.Graph_setDropColor(self, index)

    def setDropShadow(self, val):
        return _WXP.Graph_setDropShadow(self, val)

    def getDropShadow(self):
        return _WXP.Graph_getDropShadow(self)

    def setDropWidth(self, val):
        return _WXP.Graph_setDropWidth(self, val)

    def setTextExpansion(self, expansion):
        return _WXP.Graph_setTextExpansion(self, expansion)

    def setTextWeight(self, weight):
        return _WXP.Graph_setTextWeight(self, weight)

    def setTextHeight(self, height):
        return _WXP.Graph_setTextHeight(self, height)

    def setTextDirection(self, x, y):
        return _WXP.Graph_setTextDirection(self, x, y)

    def setTextAlign(self, hor, vert):
        return _WXP.Graph_setTextAlign(self, hor, vert)

    def setTextCharWidth(self, space):
        return _WXP.Graph_setTextCharWidth(self, space)

    def setTextSpacing(self, space):
        return _WXP.Graph_setTextSpacing(self, space)

    def setSymbol(self, file):
        return _WXP.Graph_setSymbol(self, file)

    def drawSymbol(self, *args):
        return _WXP.Graph_drawSymbol(self, *args)

    def setImageAlign(self, h, v):
        return _WXP.Graph_setImageAlign(self, h, v)

    def drawImage(self, *args):
        return _WXP.Graph_drawImage(self, *args)

    def getImage(self, image):
        return _WXP.Graph_getImage(self, image)

    def setCursor(self, type):
        return _WXP.Graph_setCursor(self, type)

    def isLooping(self):
        return _WXP.Graph_isLooping(self)

    def getFrame(self):
        return _WXP.Graph_getFrame(self)

    def setFrame(self, ind):
        return _WXP.Graph_setFrame(self, ind)

    def newFrame(self):
        return _WXP.Graph_newFrame(self)

    def deleteFrame(self, ind):
        return _WXP.Graph_deleteFrame(self, ind)

    def getNumFrames(self):
        return _WXP.Graph_getNumFrames(self)

    def bell(self):
        return _WXP.Graph_bell(self)

    def message(self, str):
        return _WXP.Graph_message(self, str)

    def printTran(self):
        return _WXP.Graph_printTran(self)
    DEVICE_NONE = _WXP.Graph_DEVICE_NONE
    DEVICE_WINDOW = _WXP.Graph_DEVICE_WINDOW
    DEVICE_POSTSCRIPT = _WXP.Graph_DEVICE_POSTSCRIPT
    DEVICE_HPGL = _WXP.Graph_DEVICE_HPGL
    DEVICE_METAFILE = _WXP.Graph_DEVICE_METAFILE

# Register Graph in _WXP:
_WXP.Graph_swigregister(Graph)
class Plot(Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.Plot_swiginit(self, _WXP.new_Plot(*args))
    __swig_destroy__ = _WXP.delete_Plot

    def init(self):
        return _WXP.Plot_init(self)

    def open(self, *args):
        return _WXP.Plot_open(self, *args)

    def close(self):
        return _WXP.Plot_close(self)

    def setParam(self, param):
        return _WXP.Plot_setParam(self, param)

    def setLogo(self, rlogo):
        return _WXP.Plot_setLogo(self, rlogo)

    def setFixed(self, val):
        return _WXP.Plot_setFixed(self, val)

    def getDevice(self, str):
        return _WXP.Plot_getDevice(self, str)

    def callback(self, ev_str, ev_data, data):
        return _WXP.Plot_callback(self, ev_str, ev_data, data)

    def permitCallbacks(self, val):
        return _WXP.Plot_permitCallbacks(self, val)

    def initPanel(self):
        return _WXP.Plot_initPanel(self)

    def setDefaultPanel(self, str):
        return _WXP.Plot_setDefaultPanel(self, str)

    def setPanel(self, *args):
        return _WXP.Plot_setPanel(self, *args)

    def setPanelDomain(self, ind, dom):
        return _WXP.Plot_setPanelDomain(self, ind, dom)

    def getPanelDomain(self, ind, dom):
        return _WXP.Plot_getPanelDomain(self, ind, dom)

    def setDomain(self, *args):
        return _WXP.Plot_setDomain(self, *args)

    def getDomainVal(self):
        return _WXP.Plot_getDomainVal(self)

    def getDomain(self):
        return _WXP.Plot_getDomain(self)

    def getProj(self):
        return _WXP.Plot_getProj(self)

    def getPLat(self):
        return _WXP.Plot_getPLat(self)

    def getPLon(self):
        return _WXP.Plot_getPLon(self)

    def getDomVert(self):
        return _WXP.Plot_getDomVert(self)

    def getDomAspect(self):
        return _WXP.Plot_getDomAspect(self)

    def getDomCLat(self):
        return _WXP.Plot_getDomCLat(self)

    def getDomCLon(self):
        return _WXP.Plot_getDomCLon(self)

    def getDomNx(self):
        return _WXP.Plot_getDomNx(self)

    def getDomNy(self):
        return _WXP.Plot_getDomNy(self)

    def getDomDx(self):
        return _WXP.Plot_getDomDx(self)

    def getDomDy(self):
        return _WXP.Plot_getDomDy(self)

    def getVert(self):
        return _WXP.Plot_getVert(self)

    def withinDomain(self, *args):
        return _WXP.Plot_withinDomain(self, *args)

    def withinDomainExt(self, *args):
        return _WXP.Plot_withinDomainExt(self, *args)

    def whereDomain(self, *args):
        return _WXP.Plot_whereDomain(self, *args)

    def newPanel(self, params):
        return _WXP.Plot_newPanel(self, params)

    def clear(self):
        return _WXP.Plot_clear(self)

    def clearRect(self, rect):
        return _WXP.Plot_clearRect(self, rect)

    def update(self):
        return _WXP.Plot_update(self)

    def manage(self):
        return _WXP.Plot_manage(self)

    def isManaged(self):
        return _WXP.Plot_isManaged(self)

    def end(self):
        return _WXP.Plot_end(self)

    def isTimeSync(self):
        return _WXP.Plot_isTimeSync(self)

    def setTimeSync(self, val):
        return _WXP.Plot_setTimeSync(self, val)

    def setDate(self, rdate):
        return _WXP.Plot_setDate(self, rdate)

    def isDateSet(self):
        return _WXP.Plot_isDateSet(self)

    def setForeHour(self, val):
        return _WXP.Plot_setForeHour(self, val)

    def setDataSource(self, str):
        return _WXP.Plot_setDataSource(self, str)

    def getColorMap(self, *args):
        return _WXP.Plot_getColorMap(self, *args)

    def getNumFill(self):
        return _WXP.Plot_getNumFill(self)

    def allocColor(self, ind):
        return _WXP.Plot_allocColor(self, ind)

    def setColorMap(self, cmap):
        return _WXP.Plot_setColorMap(self, cmap)

    def getColorRGB(self, ind, r, g, b):
        return _WXP.Plot_getColorRGB(self, ind, r, g, b)

    def getColorValue(self, name):
        return _WXP.Plot_getColorValue(self, name)

    def cropLine(self, *args):
        return _WXP.Plot_cropLine(self, *args)

    def drawLine(self, *args):
        return _WXP.Plot_drawLine(self, *args)

    def drawSpline(self, *args):
        return _WXP.Plot_drawSpline(self, *args)

    def drawRect(self, *args):
        return _WXP.Plot_drawRect(self, *args)

    def drawCircle(self, *args):
        return _WXP.Plot_drawCircle(self, *args)

    def setLineColor(self, *args):
        return _WXP.Plot_setLineColor(self, *args)

    def setLineWidth(self, width):
        return _WXP.Plot_setLineWidth(self, width)

    def setLineStyle(self, style):
        return _WXP.Plot_setLineStyle(self, style)

    def setLine(self, *args):
        return _WXP.Plot_setLine(self, *args)

    def drawFill(self, *args):
        return _WXP.Plot_drawFill(self, *args)

    def drawFillarea(self, data):
        return _WXP.Plot_drawFillarea(self, data)

    def setFillColor(self, *args):
        return _WXP.Plot_setFillColor(self, *args)

    def setFillStyle(self, index):
        return _WXP.Plot_setFillStyle(self, index)

    def setFill(self, *args):
        return _WXP.Plot_setFill(self, *args)

    def drawText(self, *args):
        return _WXP.Plot_drawText(self, *args)

    def drawFormText(self, *args):
        return _WXP.Plot_drawFormText(self, *args)

    def setTextHeight(self, height):
        return _WXP.Plot_setTextHeight(self, height)

    def setTextWeight(self, weight):
        return _WXP.Plot_setTextWeight(self, weight)

    def setTextAlign(self, hor, vert):
        return _WXP.Plot_setTextAlign(self, hor, vert)

    def setTextColor(self, *args):
        return _WXP.Plot_setTextColor(self, *args)

    def setTextExpansion(self, expansion):
        return _WXP.Plot_setTextExpansion(self, expansion)

    def setTextSpacing(self, space):
        return _WXP.Plot_setTextSpacing(self, space)

    def setTextCharWidth(self, width):
        return _WXP.Plot_setTextCharWidth(self, width)

    def setTextDirection(self, x, y):
        return _WXP.Plot_setTextDirection(self, x, y)

    def setFont(self, str):
        return _WXP.Plot_setFont(self, str)

    def setDropShadow(self, val):
        return _WXP.Plot_setDropShadow(self, val)

    def getDropShadow(self):
        return _WXP.Plot_getDropShadow(self)

    def setText(self, *args):
        return _WXP.Plot_setText(self, *args)

    def drawMark(self, *args):
        return _WXP.Plot_drawMark(self, *args)

    def setMarkColor(self, *args):
        return _WXP.Plot_setMarkColor(self, *args)

    def setMarkType(self, *args):
        return _WXP.Plot_setMarkType(self, *args)

    def setMarkSize(self, size):
        return _WXP.Plot_setMarkSize(self, size)

    def setMarkWeight(self, weight):
        return _WXP.Plot_setMarkWeight(self, weight)

    def setMark(self, *args):
        return _WXP.Plot_setMark(self, *args)

    def setSymbol(self, symbol):
        return _WXP.Plot_setSymbol(self, symbol)

    def drawSymbol(self, pt, string, size):
        return _WXP.Plot_drawSymbol(self, pt, string, size)

    def setImageAlign(self, h, v):
        return _WXP.Plot_setImageAlign(self, h, v)

    def drawImage(self, *args):
        return _WXP.Plot_drawImage(self, *args)

    def getTran(self):
        return _WXP.Plot_getTran(self)

    def activateTran(self, val):
        return _WXP.Plot_activateTran(self, val)

    def setViewport(self, num, rect):
        return _WXP.Plot_setViewport(self, num, rect)

    def getViewport(self, lim):
        return _WXP.Plot_getViewport(self, lim)

    def setWindow(self, num, rect):
        return _WXP.Plot_setWindow(self, num, rect)

    def getWindow(self, lim):
        return _WXP.Plot_getWindow(self, lim)

    def tran(self, *args):
        return _WXP.Plot_tran(self, *args)

    def tranPlotWindow(self, x1, y1, x2, y2):
        return _WXP.Plot_tranPlotWindow(self, x1, y1, x2, y2)

    def tranWindow(self, tran1, pt1, tran2, pt2):
        return _WXP.Plot_tranWindow(self, tran1, pt1, tran2, pt2)

    def adjustDom(self, *args):
        return _WXP.Plot_adjustDom(self, *args)

    def adjustDir(self, dir, pt):
        return _WXP.Plot_adjustDir(self, dir, pt)

    def offsetPoint(self, *args):
        return _WXP.Plot_offsetPoint(self, *args)

    def getMapFactor(self, ept):
        return _WXP.Plot_getMapFactor(self, ept)

    def getInverse(self):
        return _WXP.Plot_getInverse(self)

    def addCallback(self, ev, list, data):
        return _WXP.Plot_addCallback(self, ev, list, data)

    def message(self, str):
        return _WXP.Plot_message(self, str)

    def getViewDomain(self, domain):
        return _WXP.Plot_getViewDomain(self, domain)

    def drawBorder(self):
        return _WXP.Plot_drawBorder(self)

    def saveImage(self, *args):
        return _WXP.Plot_saveImage(self, *args)

    def getImage(self, image):
        return _WXP.Plot_getImage(self, image)

    def setLabelColor(self, str):
        return _WXP.Plot_setLabelColor(self, str)

    def setLabelFormat(self, str):
        return _WXP.Plot_setLabelFormat(self, str)

    def addLabel(self, loc, label):
        return _WXP.Plot_addLabel(self, loc, label)

    def setLabel(self, loc, label):
        return _WXP.Plot_setLabel(self, loc, label)

    def getLabelPosIndex(self, str):
        return _WXP.Plot_getLabelPosIndex(self, str)

    def printLabels(self):
        return _WXP.Plot_printLabels(self)

    def formatLabel(self, form, str, len):
        return _WXP.Plot_formatLabel(self, form, str, len)

    def clearLabels(self):
        return _WXP.Plot_clearLabels(self)

    def drawLabels(self):
        return _WXP.Plot_drawLabels(self)

    def setBarLocate(self, str):
        return _WXP.Plot_setBarLocate(self, str)

    def setBarRange(self, rrange):
        return _WXP.Plot_setBarRange(self, rrange)

    def setBar(self, *args):
        return _WXP.Plot_setBar(self, *args)

    def drawEnhBar(self):
        return _WXP.Plot_drawEnhBar(self)

    def drawBar(self, *args):
        return _WXP.Plot_drawBar(self, *args)

    def setCursor(self, type):
        return _WXP.Plot_setCursor(self, type)

    def done(self):
        return _WXP.Plot_done(self)

    def newFrame(self):
        return _WXP.Plot_newFrame(self)

    def clearFrame(self):
        return _WXP.Plot_clearFrame(self)

    def deleteFrame(self, ind):
        return _WXP.Plot_deleteFrame(self, ind)

    def deleteAllFrames(self):
        return _WXP.Plot_deleteAllFrames(self)

    def setFull(self, val):
        return _WXP.Plot_setFull(self, val)

    def getFull(self):
        return _WXP.Plot_getFull(self)

    def setDrawing(self, str):
        return _WXP.Plot_setDrawing(self, str)

    def isDrawing(self, ind):
        return _WXP.Plot_isDrawing(self, ind)

    def printDrawing(self):
        return _WXP.Plot_printDrawing(self)

    def wrapLine(self, pts):
        return _WXP.Plot_wrapLine(self, pts)

    def offsetLine(self, pts, flag):
        return _WXP.Plot_offsetLine(self, pts, flag)

    def printTran(self):
        return _WXP.Plot_printTran(self)

    def printDomain(self):
        return _WXP.Plot_printDomain(self)

    @staticmethod
    def decodeGeometryStr(str, geom):
        return _WXP.Plot_decodeGeometryStr(str, geom)

    @staticmethod
    def decodePanelStr(rect, str, geom):
        return _WXP.Plot_decodePanelStr(rect, str, geom)
    WINDOW = _WXP.Plot_WINDOW
    IMAGE = _WXP.Plot_IMAGE
    PRINT = _WXP.Plot_PRINT
    DRAW_PLOT = _WXP.Plot_DRAW_PLOT
    DRAW_DATA = _WXP.Plot_DRAW_DATA
    DRAW_MAP = _WXP.Plot_DRAW_MAP
    DRAW_TEXT_UL = _WXP.Plot_DRAW_TEXT_UL
    DRAW_TEXT_UC = _WXP.Plot_DRAW_TEXT_UC
    DRAW_TEXT_UR = _WXP.Plot_DRAW_TEXT_UR
    DRAW_TEXT_LL = _WXP.Plot_DRAW_TEXT_LL
    DRAW_TEXT_LC = _WXP.Plot_DRAW_TEXT_LC
    DRAW_TEXT_LR = _WXP.Plot_DRAW_TEXT_LR
    DRAW_BORD = _WXP.Plot_DRAW_BORD
    TRAN_BASE = _WXP.Plot_TRAN_BASE
    TRAN_PROJ = _WXP.Plot_TRAN_PROJ
    TRAN_OVER = _WXP.Plot_TRAN_OVER

# Register Plot in _WXP:
_WXP.Plot_swigregister(Plot)
class Drawing(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _WXP.delete_Drawing

    def init(self):
        return _WXP.Drawing_init(self)

    def getDomain(self, domain):
        return _WXP.Drawing_getDomain(self, domain)

    def setFile(self):
        return _WXP.Drawing_setFile(self)

    def setInput(self, type):
        return _WXP.Drawing_setInput(self, type)

    def setNameConv(self, name):
        return _WXP.Drawing_setNameConv(self, name)

    def setFilename(self, *args):
        return _WXP.Drawing_setFilename(self, *args)

    def setForeTime(self, fore):
        return _WXP.Drawing_setForeTime(self, fore)

    def setParam(self, str):
        return _WXP.Drawing_setParam(self, str)

    def getDate(self, date):
        return _WXP.Drawing_getDate(self, date)

    def getLoopType(self):
        return _WXP.Drawing_getLoopType(self)

    def getInitDate(self, date):
        return _WXP.Drawing_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.Drawing_getDateOffset(self)

    def getNumFrames(self):
        return _WXP.Drawing_getNumFrames(self)

    def getSync(self):
        return _WXP.Drawing_getSync(self)

    def draw(self, plot):
        return _WXP.Drawing_draw(self, plot)

    def _print(self):
        return _WXP.Drawing__print(self)
    LOOP_NONE = _WXP.Drawing_LOOP_NONE
    LOOP_DATE = _WXP.Drawing_LOOP_DATE
    LOOP_FORE = _WXP.Drawing_LOOP_FORE

# Register Drawing in _WXP:
_WXP.Drawing_swigregister(Drawing)
class Figure(Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.Figure_swiginit(self, _WXP.new_Figure(*args))
    __swig_destroy__ = _WXP.delete_Figure

    def init(self):
        return _WXP.Figure_init(self)

    def setParam(self, param):
        return _WXP.Figure_setParam(self, param)

    def open(self, *args):
        return _WXP.Figure_open(self, *args)

    def close(self):
        return _WXP.Figure_close(self)

    def setForeTime(self, fore):
        return _WXP.Figure_setForeTime(self, fore)

    def setDomain(self, rdomain):
        return _WXP.Figure_setDomain(self, rdomain)

    def setLoopType(self, rtype):
        return _WXP.Figure_setLoopType(self, rtype)

    def setRefresh(self, val):
        return _WXP.Figure_setRefresh(self, val)

    def setDate(self, *args):
        return _WXP.Figure_setDate(self, *args)

    def startPlot(self, *args):
        return _WXP.Figure_startPlot(self, *args)

    def clearQueue(self):
        return _WXP.Figure_clearQueue(self)

    def addDrawing(self, draw):
        return _WXP.Figure_addDrawing(self, draw)

    def addPanel(self, param):
        return _WXP.Figure_addPanel(self, param)

    def draw(self, *args):
        return _WXP.Figure_draw(self, *args)

    def drawFrame(self, *args):
        return _WXP.Figure_drawFrame(self, *args)

    def endPlot(self):
        return _WXP.Figure_endPlot(self)

    def drawPlot(self):
        return _WXP.Figure_drawPlot(self)

    def updateLoop(self, date):
        return _WXP.Figure_updateLoop(self, date)

    def manage(self):
        return _WXP.Figure_manage(self)

    def setDrawing(self, str):
        return _WXP.Figure_setDrawing(self, str)

    def isDrawing(self, ind):
        return _WXP.Figure_isDrawing(self, ind)

    def callback(self, ev_str, ev_data, data):
        return _WXP.Figure_callback(self, ev_str, ev_data, data)

# Register Figure in _WXP:
_WXP.Figure_swigregister(Figure)
class ContPlot(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.ContPlot_swiginit(self, _WXP.new_ContPlot(*args))

    def init(self):
        return _WXP.ContPlot_init(self)

    def setParam(self, str):
        return _WXP.ContPlot_setParam(self, str)

    def setType(self, *args):
        return _WXP.ContPlot_setType(self, *args)

    def getType(self):
        return _WXP.ContPlot_getType(self)

    def isTypeFill(self):
        return _WXP.ContPlot_isTypeFill(self)

    def setInterval(self, val):
        return _WXP.ContPlot_setInterval(self, val)

    def getInterval(self):
        return _WXP.ContPlot_getInterval(self)

    def setBase(self, *args):
        return _WXP.ContPlot_setBase(self, *args)

    def getBase(self):
        return _WXP.ContPlot_getBase(self)

    def getMax(self):
        return _WXP.ContPlot_getMax(self)

    def getMin(self):
        return _WXP.ContPlot_getMin(self)

    def setLabelParam(self, skip, rad):
        return _WXP.ContPlot_setLabelParam(self, skip, rad)

    def setLabelSpace(self, x, y):
        return _WXP.ContPlot_setLabelSpace(self, x, y)

    def setFillStyle(self, type):
        return _WXP.ContPlot_setFillStyle(self, type)

    def setLineWidth(self, width):
        return _WXP.ContPlot_setLineWidth(self, width)

    def setTextFormat(self, fm):
        return _WXP.ContPlot_setTextFormat(self, fm)

    def setColorTable(self, str):
        return _WXP.ContPlot_setColorTable(self, str)

    def setColorFill(self, str):
        return _WXP.ContPlot_setColorFill(self, str)

    def setColorLine(self, str):
        return _WXP.ContPlot_setColorLine(self, str)

    def setColorLabel(self, str):
        return _WXP.ContPlot_setColorLabel(self, str)

    def setScaleFactor(self, sc):
        return _WXP.ContPlot_setScaleFactor(self, sc)

    def draw(self, plot, grid):
        return _WXP.ContPlot_draw(self, plot, grid)

    def drawLabels(self, plot, grid):
        return _WXP.ContPlot_drawLabels(self, plot, grid)

    def drawFill(self, plot, grid):
        return _WXP.ContPlot_drawFill(self, plot, grid)

    def drawBoxFill(self, plot):
        return _WXP.ContPlot_drawBoxFill(self, plot)

    def drawLine(self, plot, grid):
        return _WXP.ContPlot_drawLine(self, plot, grid)

    def drawBoxLine(self, plot):
        return _WXP.ContPlot_drawBoxLine(self, plot)

    def drawValues(self, plot, grid):
        return _WXP.ContPlot_drawValues(self, plot, grid)

    def drawLineLabels(self, plot, grid):
        return _WXP.ContPlot_drawLineLabels(self, plot, grid)

    def drawMaxMin(self, plot, grid):
        return _WXP.ContPlot_drawMaxMin(self, plot, grid)

    def getLevel(self, ind):
        return _WXP.ContPlot_getLevel(self, ind)

    def getColorFill(self, ind):
        return _WXP.ContPlot_getColorFill(self, ind)
    NONE = _WXP.ContPlot_NONE
    VALUE = _WXP.ContPlot_VALUE
    LINE = _WXP.ContPlot_LINE
    FILL = _WXP.ContPlot_FILL
    BOTH = _WXP.ContPlot_BOTH

    @staticmethod
    def decodeType(str):
        return _WXP.ContPlot_decodeType(str)
    __swig_destroy__ = _WXP.delete_ContPlot

# Register ContPlot in _WXP:
_WXP.ContPlot_swigregister(ContPlot)
class MapPlot(Drawing):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.MapPlot_swiginit(self, _WXP.new_MapPlot(*args))
    __swig_destroy__ = _WXP.delete_MapPlot

    def init(self):
        return _WXP.MapPlot_init(self)

    def getDomain(self, domain):
        return _WXP.MapPlot_getDomain(self, domain)

    def setMapFiles(self, str):
        return _WXP.MapPlot_setMapFiles(self, str)

    def setFile(self):
        return _WXP.MapPlot_setFile(self)

    def setInput(self, str):
        return _WXP.MapPlot_setInput(self, str)

    def setNameConv(self, name):
        return _WXP.MapPlot_setNameConv(self, name)

    def setFilename(self, *args):
        return _WXP.MapPlot_setFilename(self, *args)

    def setForeTime(self, fore):
        return _WXP.MapPlot_setForeTime(self, fore)

    def getDate(self, date):
        return _WXP.MapPlot_getDate(self, date)

    def getInitDate(self, date):
        return _WXP.MapPlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.MapPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.MapPlot_getLoopType(self)

    def getNumFrames(self):
        return _WXP.MapPlot_getNumFrames(self)

    def setFillCont(self, v):
        return _WXP.MapPlot_setFillCont(self, v)

    def setColorTable(self, str):
        return _WXP.MapPlot_setColorTable(self, str)

    def setColor(self, name):
        return _WXP.MapPlot_setColor(self, name)

    def setColorLatLon(self, name):
        return _WXP.MapPlot_setColorLatLon(self, name)

    def setColorLine(self, str):
        return _WXP.MapPlot_setColorLine(self, str)

    def setParam(self, str):
        return _WXP.MapPlot_setParam(self, str)

    def getSync(self):
        return _WXP.MapPlot_getSync(self)

    def drawSegment(self, plot, pts):
        return _WXP.MapPlot_drawSegment(self, plot, pts)

    def drawLatLon(self, plot, dlat, dlon):
        return _WXP.MapPlot_drawLatLon(self, plot, dlat, dlon)

    def draw(self, *args):
        return _WXP.MapPlot_draw(self, *args)

    def _print(self):
        return _WXP.MapPlot__print(self)
    UNDER = _WXP.MapPlot_UNDER
    OVER = _WXP.MapPlot_OVER

# Register MapPlot in _WXP:
_WXP.MapPlot_swigregister(MapPlot)
class ImagePlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.ImagePlot_swiginit(self, _WXP.new_ImagePlot(*args))

    def init(self):
        return _WXP.ImagePlot_init(self)

    def setParam(self, str):
        return _WXP.ImagePlot_setParam(self, str)

    def setPath(self, path):
        return _WXP.ImagePlot_setPath(self, path)

    def setFile(self):
        return _WXP.ImagePlot_setFile(self)

    def setInput(self, type):
        return _WXP.ImagePlot_setInput(self, type)

    def setNameConv(self, type):
        return _WXP.ImagePlot_setNameConv(self, type)

    def setType(self, type):
        return _WXP.ImagePlot_setType(self, type)

    def setFilename(self, *args):
        return _WXP.ImagePlot_setFilename(self, *args)

    def setModel(self, str):
        return _WXP.ImagePlot_setModel(self, str)

    def setForeTime(self, fore):
        return _WXP.ImagePlot_setForeTime(self, fore)

    def getDate(self, date):
        return _WXP.ImagePlot_getDate(self, date)

    def getNumFrames(self):
        return _WXP.ImagePlot_getNumFrames(self)

    def getInitDate(self, date):
        return _WXP.ImagePlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.ImagePlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.ImagePlot_getLoopType(self)

    def getDomain(self, domain):
        return _WXP.ImagePlot_getDomain(self, domain)

    def setColorTable(self, str):
        return _WXP.ImagePlot_setColorTable(self, str)

    def setColorFill(self, str):
        return _WXP.ImagePlot_setColorFill(self, str)

    def setMap(self, val):
        return _WXP.ImagePlot_setMap(self, val)

    def getSync(self):
        return _WXP.ImagePlot_getSync(self)

    def drawImage(self, plot, rimage):
        return _WXP.ImagePlot_drawImage(self, plot, rimage)

    def draw(self, *args):
        return _WXP.ImagePlot_draw(self, *args)

    def callback(self, ev_str, ev_data, data):
        return _WXP.ImagePlot_callback(self, ev_str, ev_data, data)

    def _print(self):
        return _WXP.ImagePlot__print(self)
    UNK = _WXP.ImagePlot_UNK
    IMAGE = _WXP.ImagePlot_IMAGE
    GRIB = _WXP.ImagePlot_GRIB
    GRID = _WXP.ImagePlot_GRID
    __swig_destroy__ = _WXP.delete_ImagePlot

# Register ImagePlot in _WXP:
_WXP.ImagePlot_swigregister(ImagePlot)
class NidsPlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.NidsPlot_swiginit(self, _WXP.new_NidsPlot(*args))

    def init(self):
        return _WXP.NidsPlot_init(self)

    def setParam(self, str):
        return _WXP.NidsPlot_setParam(self, str)

    def setPath(self, path):
        return _WXP.NidsPlot_setPath(self, path)

    def setFile(self):
        return _WXP.NidsPlot_setFile(self)

    def setInput(self, type):
        return _WXP.NidsPlot_setInput(self, type)

    def setNameConv(self, type):
        return _WXP.NidsPlot_setNameConv(self, type)

    def setHour(self, str):
        return _WXP.NidsPlot_setHour(self, str)

    def setFilename(self, *args):
        return _WXP.NidsPlot_setFilename(self, *args)

    def setForeTime(self, fore):
        return _WXP.NidsPlot_setForeTime(self, fore)

    def getDate(self, date):
        return _WXP.NidsPlot_getDate(self, date)

    def getInitDate(self, date):
        return _WXP.NidsPlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.NidsPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.NidsPlot_getLoopType(self)

    def getNumFrames(self):
        return _WXP.NidsPlot_getNumFrames(self)

    def getDomain(self, domain):
        return _WXP.NidsPlot_getDomain(self, domain)

    def getInfo(self, rinfo):
        return _WXP.NidsPlot_getInfo(self, rinfo)

    def setId(self, str):
        return _WXP.NidsPlot_setId(self, str)

    def setType(self, str):
        return _WXP.NidsPlot_setType(self, str)

    def setVariable(self, str):
        return _WXP.NidsPlot_setVariable(self, str)

    def setColorTable(self, str):
        return _WXP.NidsPlot_setColorTable(self, str)

    def setColorFill(self, str):
        return _WXP.NidsPlot_setColorFill(self, str)

    def setColor(self, str):
        return _WXP.NidsPlot_setColor(self, str)

    def setMap(self, val):
        return _WXP.NidsPlot_setMap(self, val)

    def getSync(self):
        return _WXP.NidsPlot_getSync(self)

    def drawImage(self, plot):
        return _WXP.NidsPlot_drawImage(self, plot)

    def drawData(self, plot):
        return _WXP.NidsPlot_drawData(self, plot)

    def getUnits(self, name):
        return _WXP.NidsPlot_getUnits(self, name)

    def drawStorm(self, plot, storm):
        return _WXP.NidsPlot_drawStorm(self, plot, storm)

    def draw(self, plot):
        return _WXP.NidsPlot_draw(self, plot)

    def callback(self, ev_str, ev_data, data):
        return _WXP.NidsPlot_callback(self, ev_str, ev_data, data)

    def _print(self):
        return _WXP.NidsPlot__print(self)
    __swig_destroy__ = _WXP.delete_NidsPlot

# Register NidsPlot in _WXP:
_WXP.NidsPlot_swigregister(NidsPlot)
class RadPlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.RadPlot_swiginit(self, _WXP.new_RadPlot(*args))

    def init(self):
        return _WXP.RadPlot_init(self)

    def setParam(self, str):
        return _WXP.RadPlot_setParam(self, str)

    def setPath(self, path):
        return _WXP.RadPlot_setPath(self, path)

    def setFile(self):
        return _WXP.RadPlot_setFile(self)

    def setInput(self, rtype):
        return _WXP.RadPlot_setInput(self, rtype)

    def getType(self, rtype):
        return _WXP.RadPlot_getType(self, rtype)

    def setSubType(self, str):
        return _WXP.RadPlot_setSubType(self, str)

    def setNameConv(self, name):
        return _WXP.RadPlot_setNameConv(self, name)

    def setHour(self, str):
        return _WXP.RadPlot_setHour(self, str)

    def setFilename(self, *args):
        return _WXP.RadPlot_setFilename(self, *args)

    def setForeTime(self, fore):
        return _WXP.RadPlot_setForeTime(self, fore)

    def setColorTable(self, str):
        return _WXP.RadPlot_setColorTable(self, str)

    def setColor(self, str):
        return _WXP.RadPlot_setColor(self, str)

    def setColorFill(self, str):
        return _WXP.RadPlot_setColorFill(self, str)

    def setVariable(self, str):
        return _WXP.RadPlot_setVariable(self, str)

    def setMap(self, val):
        return _WXP.RadPlot_setMap(self, val)

    def getDate(self, date):
        return _WXP.RadPlot_getDate(self, date)

    def getInitDate(self, date):
        return _WXP.RadPlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.RadPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.RadPlot_getLoopType(self)

    def getNumFrames(self):
        return _WXP.RadPlot_getNumFrames(self)

    def getDomain(self, domain):
        return _WXP.RadPlot_getDomain(self, domain)

    def getSync(self):
        return _WXP.RadPlot_getSync(self)

    def draw(self, *args):
        return _WXP.RadPlot_draw(self, *args)

    def callback(self, ev_str, ev_data, data):
        return _WXP.RadPlot_callback(self, ev_str, ev_data, data)

    def _print(self):
        return _WXP.RadPlot__print(self)
    UNK = _WXP.RadPlot_UNK
    MDR = _WXP.RadPlot_MDR
    MDRSITE = _WXP.RadPlot_MDRSITE
    RCM = _WXP.RadPlot_RCM
    RCMSITE = _WXP.RadPlot_RCMSITE
    IMG = _WXP.RadPlot_IMG
    NIDS = _WXP.RadPlot_NIDS
    LEV2 = _WXP.RadPlot_LEV2
    NOWRAD = _WXP.RadPlot_NOWRAD
    KAVRAD = _WXP.RadPlot_KAVRAD
    GRIB = _WXP.RadPlot_GRIB
    GINIP = _WXP.RadPlot_GINIP
    __swig_destroy__ = _WXP.delete_RadPlot

# Register RadPlot in _WXP:
_WXP.RadPlot_swigregister(RadPlot)
class SatPlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.SatPlot_swiginit(self, _WXP.new_SatPlot(*args))

    def init(self):
        return _WXP.SatPlot_init(self)

    def setParam(self, str):
        return _WXP.SatPlot_setParam(self, str)

    def setPath(self, path):
        return _WXP.SatPlot_setPath(self, path)

    def setFile(self):
        return _WXP.SatPlot_setFile(self)

    def setInput(self, rtype):
        return _WXP.SatPlot_setInput(self, rtype)

    def setOutput(self, str):
        return _WXP.SatPlot_setOutput(self, str)

    def setNameConv(self, name):
        return _WXP.SatPlot_setNameConv(self, name)

    def setHour(self, str):
        return _WXP.SatPlot_setHour(self, str)

    def setTimezone(self, str):
        return _WXP.SatPlot_setTimezone(self, str)

    def setFilename(self, *args):
        return _WXP.SatPlot_setFilename(self, *args)

    def setForeTime(self, fore):
        return _WXP.SatPlot_setForeTime(self, fore)

    def getDate(self, date):
        return _WXP.SatPlot_getDate(self, date)

    def getNumFrames(self):
        return _WXP.SatPlot_getNumFrames(self)

    def getInitDate(self, date):
        return _WXP.SatPlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.SatPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.SatPlot_getLoopType(self)

    def getDomain(self, domain):
        return _WXP.SatPlot_getDomain(self, domain)

    def setColorTable(self, str):
        return _WXP.SatPlot_setColorTable(self, str)

    def setColorFill(self, str):
        return _WXP.SatPlot_setColorFill(self, str)

    def setModelMask(self, str):
        return _WXP.SatPlot_setModelMask(self, str)

    def setCalibration(self, str):
        return _WXP.SatPlot_setCalibration(self, str)

    def setMap(self, val):
        return _WXP.SatPlot_setMap(self, val)

    def getSync(self):
        return _WXP.SatPlot_getSync(self)

    def maskModel(self, image, date):
        return _WXP.SatPlot_maskModel(self, image, date)

    def saveImage(self, image):
        return _WXP.SatPlot_saveImage(self, image)

    def draw(self, *args):
        return _WXP.SatPlot_draw(self, *args)

    def callback(self, ev_str, ev_data, data):
        return _WXP.SatPlot_callback(self, ev_str, ev_data, data)

    def _print(self):
        return _WXP.SatPlot__print(self)
    __swig_destroy__ = _WXP.delete_SatPlot

# Register SatPlot in _WXP:
_WXP.SatPlot_swigregister(SatPlot)
class SfcPlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.SfcPlot_swiginit(self, _WXP.new_SfcPlot(*args))

    def init(self):
        return _WXP.SfcPlot_init(self)

    def setParam(self, str):
        return _WXP.SfcPlot_setParam(self, str)

    def setPath(self, path):
        return _WXP.SfcPlot_setPath(self, path)

    def setFile(self):
        return _WXP.SfcPlot_setFile(self)

    def setInput(self, str):
        return _WXP.SfcPlot_setInput(self, str)

    def setNameConv(self, name):
        return _WXP.SfcPlot_setNameConv(self, name)

    def setHour(self, str):
        return _WXP.SfcPlot_setHour(self, str)

    def setFilename(self, *args):
        return _WXP.SfcPlot_setFilename(self, *args)

    def setForeTime(self, fore):
        return _WXP.SfcPlot_setForeTime(self, fore)

    def setColorTable(self, str):
        return _WXP.SfcPlot_setColorTable(self, str)

    def setColor(self, str):
        return _WXP.SfcPlot_setColor(self, str)

    def setVariable(self, str):
        return _WXP.SfcPlot_setVariable(self, str)

    def setPlotType(self, str):
        return _WXP.SfcPlot_setPlotType(self, str)

    def setTimezone(self, str):
        return _WXP.SfcPlot_setTimezone(self, str)

    def setGridDomain(self, str):
        return _WXP.SfcPlot_setGridDomain(self, str)

    def setOutput(self, file):
        return _WXP.SfcPlot_setOutput(self, file)

    def setMap(self, val):
        return _WXP.SfcPlot_setMap(self, val)

    def getDate(self, date):
        return _WXP.SfcPlot_getDate(self, date)

    def getInitDate(self, date):
        return _WXP.SfcPlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.SfcPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.SfcPlot_getLoopType(self)

    def getNumFrames(self):
        return _WXP.SfcPlot_getNumFrames(self)

    def getDomain(self, domain):
        return _WXP.SfcPlot_getDomain(self, domain)

    def getSync(self):
        return _WXP.SfcPlot_getSync(self)

    def draw(self, plot):
        return _WXP.SfcPlot_draw(self, plot)

    def callback(self, ev_str, ev_data, data):
        return _WXP.SfcPlot_callback(self, ev_str, ev_data, data)

    def _print(self):
        return _WXP.SfcPlot__print(self)
    __swig_destroy__ = _WXP.delete_SfcPlot

# Register SfcPlot in _WXP:
_WXP.SfcPlot_swigregister(SfcPlot)
class MosPlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.MosPlot_swiginit(self, _WXP.new_MosPlot(*args))

    def init(self):
        return _WXP.MosPlot_init(self)

    def setParam(self, str):
        return _WXP.MosPlot_setParam(self, str)

    def setPath(self, path):
        return _WXP.MosPlot_setPath(self, path)

    def setFile(self):
        return _WXP.MosPlot_setFile(self)

    def setInput(self, str):
        return _WXP.MosPlot_setInput(self, str)

    def setModel(self, str):
        return _WXP.MosPlot_setModel(self, str)

    def setNameConv(self, name):
        return _WXP.MosPlot_setNameConv(self, name)

    def setHour(self, str):
        return _WXP.MosPlot_setHour(self, str)

    def setForeTime(self, fore):
        return _WXP.MosPlot_setForeTime(self, fore)

    def setFilename(self, *args):
        return _WXP.MosPlot_setFilename(self, *args)

    def setColorTable(self, str):
        return _WXP.MosPlot_setColorTable(self, str)

    def setColor(self, str):
        return _WXP.MosPlot_setColor(self, str)

    def setVariable(self, str):
        return _WXP.MosPlot_setVariable(self, str)

    def setMap(self, val):
        return _WXP.MosPlot_setMap(self, val)

    def getDate(self, date):
        return _WXP.MosPlot_getDate(self, date)

    def getInitDate(self, date):
        return _WXP.MosPlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.MosPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.MosPlot_getLoopType(self)

    def getNumFrames(self):
        return _WXP.MosPlot_getNumFrames(self)

    def getDomain(self, domain):
        return _WXP.MosPlot_getDomain(self, domain)

    def getSync(self):
        return _WXP.MosPlot_getSync(self)

    def draw(self, plot):
        return _WXP.MosPlot_draw(self, plot)

    def callback(self, ev_str, ev_data, data):
        return _WXP.MosPlot_callback(self, ev_str, ev_data, data)

    def _print(self):
        return _WXP.MosPlot__print(self)
    __swig_destroy__ = _WXP.delete_MosPlot

# Register MosPlot in _WXP:
_WXP.MosPlot_swigregister(MosPlot)
class GridPlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.GridPlot_swiginit(self, _WXP.new_GridPlot(*args))

    def init(self):
        return _WXP.GridPlot_init(self)

    def setParam(self, str):
        return _WXP.GridPlot_setParam(self, str)

    def setPath(self, str):
        return _WXP.GridPlot_setPath(self, str)

    def setFile(self):
        return _WXP.GridPlot_setFile(self)

    def setInput(self, type):
        return _WXP.GridPlot_setInput(self, type)

    def setNameConv(self, name):
        return _WXP.GridPlot_setNameConv(self, name)

    def setHour(self, str):
        return _WXP.GridPlot_setHour(self, str)

    def setFilename(self, *args):
        return _WXP.GridPlot_setFilename(self, *args)

    def setForeTime(self, fore):
        return _WXP.GridPlot_setForeTime(self, fore)

    def getDate(self, date):
        return _WXP.GridPlot_getDate(self, date)

    def getInitDate(self, date):
        return _WXP.GridPlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.GridPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.GridPlot_getLoopType(self)

    def getNumFrames(self):
        return _WXP.GridPlot_getNumFrames(self)

    def setModel(self, str):
        return _WXP.GridPlot_setModel(self, str)

    def setMap(self, val):
        return _WXP.GridPlot_setMap(self, val)

    def callback(self, ev_str, ev_data, data):
        return _WXP.GridPlot_callback(self, ev_str, ev_data, data)

    def setColorTable(self, str):
        return _WXP.GridPlot_setColorTable(self, str)

    def setColorFill(self, str):
        return _WXP.GridPlot_setColorFill(self, str)

    def setVariable(self, str):
        return _WXP.GridPlot_setVariable(self, str)

    def isTypeFill(self):
        return _WXP.GridPlot_isTypeFill(self)

    def setMapFill(self, val):
        return _WXP.GridPlot_setMapFill(self, val)

    def getDomain(self, domain):
        return _WXP.GridPlot_getDomain(self, domain)

    def getSync(self):
        return _WXP.GridPlot_getSync(self)

    def draw(self, *args):
        return _WXP.GridPlot_draw(self, *args)

    def _print(self):
        return _WXP.GridPlot__print(self)
    __swig_destroy__ = _WXP.delete_GridPlot

# Register GridPlot in _WXP:
_WXP.GridPlot_swigregister(GridPlot)
class FrontData(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.FrontData_swiginit(self, _WXP.new_FrontData())

    def getDate(self, rdate):
        return _WXP.FrontData_getDate(self, rdate)

    def getSeconds(self):
        return _WXP.FrontData_getSeconds(self)

    def setType(self, rtype):
        return _WXP.FrontData_setType(self, rtype)

    def getType(self):
        return _WXP.FrontData_getType(self)

    def setFore(self, rfore):
        return _WXP.FrontData_setFore(self, rfore)

    def getFore(self):
        return _WXP.FrontData_getFore(self)

    def setPres(self, rpres):
        return _WXP.FrontData_setPres(self, rpres)

    def getPres(self):
        return _WXP.FrontData_getPres(self)

    def addPoint(self, lat, lon):
        return _WXP.FrontData_addPoint(self, lat, lon)

    def getPoint(self, ind, ept):
        return _WXP.FrontData_getPoint(self, ind, ept)

    def getLat(self, ind):
        return _WXP.FrontData_getLat(self, ind)

    def getLon(self, ind):
        return _WXP.FrontData_getLon(self, ind)

    def getNum(self):
        return _WXP.FrontData_getNum(self)

    def init(self):
        return _WXP.FrontData_init(self)

    def _print(self):
        return _WXP.FrontData__print(self)
    LOW = _WXP.FrontData_LOW
    HIGH = _WXP.FrontData_HIGH
    HURRICANE = _WXP.FrontData_HURRICANE
    TROP_STORM = _WXP.FrontData_TROP_STORM
    COLD = _WXP.FrontData_COLD
    WARM = _WXP.FrontData_WARM
    OCCLUDED = _WXP.FrontData_OCCLUDED
    STATIONARY = _WXP.FrontData_STATIONARY
    TROF = _WXP.FrontData_TROF
    MISC = _WXP.FrontData_MISC
    __swig_destroy__ = _WXP.delete_FrontData

# Register FrontData in _WXP:
_WXP.FrontData_swigregister(FrontData)
class FrontPlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.FrontPlot_swiginit(self, _WXP.new_FrontPlot(*args))

    def init(self):
        return _WXP.FrontPlot_init(self)

    def setParam(self, str):
        return _WXP.FrontPlot_setParam(self, str)

    def setFile(self):
        return _WXP.FrontPlot_setFile(self)

    def setInput(self, type):
        return _WXP.FrontPlot_setInput(self, type)

    def setNameConv(self, type):
        return _WXP.FrontPlot_setNameConv(self, type)

    def setFilename(self, *args):
        return _WXP.FrontPlot_setFilename(self, *args)

    def getDate(self, date):
        return _WXP.FrontPlot_getDate(self, date)

    def getInitDate(self, date):
        return _WXP.FrontPlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.FrontPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.FrontPlot_getLoopType(self)

    def setForeTime(self, fore):
        return _WXP.FrontPlot_setForeTime(self, fore)

    def getNumFrames(self):
        return _WXP.FrontPlot_getNumFrames(self)

    def getDomain(self, domain):
        return _WXP.FrontPlot_getDomain(self, domain)

    def setColor(self, str):
        return _WXP.FrontPlot_setColor(self, str)

    def setMap(self, val):
        return _WXP.FrontPlot_setMap(self, val)

    def getSync(self):
        return _WXP.FrontPlot_getSync(self)

    def draw(self, *args):
        return _WXP.FrontPlot_draw(self, *args)

    def drawTriangle(self, plot, pt1, pt2, dir):
        return _WXP.FrontPlot_drawTriangle(self, plot, pt1, pt2, dir)

    def drawHalfCircle(self, plot, pt1, pt2, dir):
        return _WXP.FrontPlot_drawHalfCircle(self, plot, pt1, pt2, dir)

    def callback(self, ev_str, ev_data, data):
        return _WXP.FrontPlot_callback(self, ev_str, ev_data, data)

    def _print(self):
        return _WXP.FrontPlot__print(self)
    __swig_destroy__ = _WXP.delete_FrontPlot

# Register FrontPlot in _WXP:
_WXP.FrontPlot_swigregister(FrontPlot)
class WatchPlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.WatchPlot_swiginit(self, _WXP.new_WatchPlot(*args))

    def init(self):
        return _WXP.WatchPlot_init(self)

    def setParam(self, str):
        return _WXP.WatchPlot_setParam(self, str)

    def setFile(self):
        return _WXP.WatchPlot_setFile(self)

    def setInput(self, type):
        return _WXP.WatchPlot_setInput(self, type)

    def setHour(self, str):
        return _WXP.WatchPlot_setHour(self, str)

    def setNameConv(self, type):
        return _WXP.WatchPlot_setNameConv(self, type)

    def setFilename(self, *args):
        return _WXP.WatchPlot_setFilename(self, *args)

    def setForeTime(self, fore):
        return _WXP.WatchPlot_setForeTime(self, fore)

    def getDate(self, date):
        return _WXP.WatchPlot_getDate(self, date)

    def getInitDate(self, date):
        return _WXP.WatchPlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.WatchPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.WatchPlot_getLoopType(self)

    def getNumFrames(self):
        return _WXP.WatchPlot_getNumFrames(self)

    def getDomain(self, domain):
        return _WXP.WatchPlot_getDomain(self, domain)

    def setScale(self, val):
        return _WXP.WatchPlot_setScale(self, val)

    def setTimezone(self, str):
        return _WXP.WatchPlot_setTimezone(self, str)

    def setShadow(self, val):
        return _WXP.WatchPlot_setShadow(self, val)

    def setValidDate(self, *args):
        return _WXP.WatchPlot_setValidDate(self, *args)

    def setColorTable(self, str):
        return _WXP.WatchPlot_setColorTable(self, str)

    def setColor(self, str):
        return _WXP.WatchPlot_setColor(self, str)

    def setMap(self, val):
        return _WXP.WatchPlot_setMap(self, val)

    def getSync(self):
        return _WXP.WatchPlot_getSync(self)

    def readFile(self, *args):
        return _WXP.WatchPlot_readFile(self, *args)

    def draw(self, plot):
        return _WXP.WatchPlot_draw(self, plot)

    def callback(self, ev_str, ev_data, data):
        return _WXP.WatchPlot_callback(self, ev_str, ev_data, data)

    def _print(self):
        return _WXP.WatchPlot__print(self)
    __swig_destroy__ = _WXP.delete_WatchPlot

# Register WatchPlot in _WXP:
_WXP.WatchPlot_swigregister(WatchPlot)
class WarnPlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.WarnPlot_swiginit(self, _WXP.new_WarnPlot(*args))

    def init(self):
        return _WXP.WarnPlot_init(self)

    def setParam(self, str):
        return _WXP.WarnPlot_setParam(self, str)

    def setFile(self):
        return _WXP.WarnPlot_setFile(self)

    def setInput(self, type):
        return _WXP.WarnPlot_setInput(self, type)

    def setHour(self, str):
        return _WXP.WarnPlot_setHour(self, str)

    def setNameConv(self, type):
        return _WXP.WarnPlot_setNameConv(self, type)

    def setFilename(self, *args):
        return _WXP.WarnPlot_setFilename(self, *args)

    def setForeTime(self, fore):
        return _WXP.WarnPlot_setForeTime(self, fore)

    def getDate(self, date):
        return _WXP.WarnPlot_getDate(self, date)

    def getInitDate(self, date):
        return _WXP.WarnPlot_getInitDate(self, date)

    def getDateOffset(self):
        return _WXP.WarnPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.WarnPlot_getLoopType(self)

    def getNumFrames(self):
        return _WXP.WarnPlot_getNumFrames(self)

    def getDomain(self, domain):
        return _WXP.WarnPlot_getDomain(self, domain)

    def setScale(self, val):
        return _WXP.WarnPlot_setScale(self, val)

    def setTimezone(self, str):
        return _WXP.WarnPlot_setTimezone(self, str)

    def setShadow(self, val):
        return _WXP.WarnPlot_setShadow(self, val)

    def setValidDate(self, *args):
        return _WXP.WarnPlot_setValidDate(self, *args)

    def setColorTable(self, str):
        return _WXP.WarnPlot_setColorTable(self, str)

    def setColor(self, str):
        return _WXP.WarnPlot_setColor(self, str)

    def setMap(self, val):
        return _WXP.WarnPlot_setMap(self, val)

    def getSync(self):
        return _WXP.WarnPlot_getSync(self)

    def readFile(self, filename):
        return _WXP.WarnPlot_readFile(self, filename)

    def draw(self, plot):
        return _WXP.WarnPlot_draw(self, plot)

    def callback(self, ev_str, ev_data, data):
        return _WXP.WarnPlot_callback(self, ev_str, ev_data, data)

    def _print(self):
        return _WXP.WarnPlot__print(self)
    __swig_destroy__ = _WXP.delete_WarnPlot

# Register WarnPlot in _WXP:
_WXP.WarnPlot_swigregister(WarnPlot)
class LightPlot(Drawing, Listener):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.LightPlot_swiginit(self, _WXP.new_LightPlot(*args))

    def init(self):
        return _WXP.LightPlot_init(self)

    def setParam(self, str):
        return _WXP.LightPlot_setParam(self, str)

    def setPath(self, path):
        return _WXP.LightPlot_setPath(self, path)

    def setFile(self):
        return _WXP.LightPlot_setFile(self)

    def setInput(self, str):
        return _WXP.LightPlot_setInput(self, str)

    def setNameConv(self, name):
        return _WXP.LightPlot_setNameConv(self, name)

    def setHour(self, str):
        return _WXP.LightPlot_setHour(self, str)

    def setFilename(self, *args):
        return _WXP.LightPlot_setFilename(self, *args)

    def setForeTime(self, fore):
        return _WXP.LightPlot_setForeTime(self, fore)

    def getDate(self, date):
        return _WXP.LightPlot_getDate(self, date)

    def getInitDate(self, date):
        return _WXP.LightPlot_getInitDate(self, date)

    def setValidDate(self, *args):
        return _WXP.LightPlot_setValidDate(self, *args)

    def getDateOffset(self):
        return _WXP.LightPlot_getDateOffset(self)

    def getLoopType(self):
        return _WXP.LightPlot_getLoopType(self)

    def getNumFrames(self):
        return _WXP.LightPlot_getNumFrames(self)

    def getDomain(self, domain):
        return _WXP.LightPlot_getDomain(self, domain)

    def getSync(self):
        return _WXP.LightPlot_getSync(self)

    def setColorTable(self, str):
        return _WXP.LightPlot_setColorTable(self, str)

    def setColor(self, str):
        return _WXP.LightPlot_setColor(self, str)

    def setColorFill(self, str):
        return _WXP.LightPlot_setColorFill(self, str)

    def setScale(self, val):
        return _WXP.LightPlot_setScale(self, val)

    def setTimezone(self, str):
        return _WXP.LightPlot_setTimezone(self, str)

    def setMap(self, val):
        return _WXP.LightPlot_setMap(self, val)

    def draw(self, plot):
        return _WXP.LightPlot_draw(self, plot)

    def callback(self, ev_str, ev_data, data):
        return _WXP.LightPlot_callback(self, ev_str, ev_data, data)

    def _print(self):
        return _WXP.LightPlot__print(self)
    __swig_destroy__ = _WXP.delete_LightPlot

# Register LightPlot in _WXP:
_WXP.LightPlot_swigregister(LightPlot)
class DatumPlot(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _WXP.DatumPlot_swiginit(self, _WXP.new_DatumPlot())

    def init(self):
        return _WXP.DatumPlot_init(self)

    def setParam(self, str):
        return _WXP.DatumPlot_setParam(self, str)

    def setType(self, str):
        return _WXP.DatumPlot_setType(self, str)

    def setColorTable(self, str):
        return _WXP.DatumPlot_setColorTable(self, str)

    def setColorFill(self, str):
        return _WXP.DatumPlot_setColorFill(self, str)

    def setInterval(self, val):
        return _WXP.DatumPlot_setInterval(self, val)

    def setBase(self, val):
        return _WXP.DatumPlot_setBase(self, val)

    def setAttr(self, *args):
        return _WXP.DatumPlot_setAttr(self, *args)

    def setColor(self, str):
        return _WXP.DatumPlot_setColor(self, str)

    def setFormat(self, str):
        return _WXP.DatumPlot_setFormat(self, str)

    def setScale(self, val):
        return _WXP.DatumPlot_setScale(self, val)

    def setMarker(self, type):
        return _WXP.DatumPlot_setMarker(self, type)

    def draw(self, *args):
        return _WXP.DatumPlot_draw(self, *args)

    def _print(self):
        return _WXP.DatumPlot__print(self)
    __swig_destroy__ = _WXP.delete_DatumPlot

# Register DatumPlot in _WXP:
_WXP.DatumPlot_swigregister(DatumPlot)
class MapFileHeader(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    num = property(_WXP.MapFileHeader_num_get, _WXP.MapFileHeader_num_set)
    minlat = property(_WXP.MapFileHeader_minlat_get, _WXP.MapFileHeader_minlat_set)
    maxlat = property(_WXP.MapFileHeader_maxlat_get, _WXP.MapFileHeader_maxlat_set)
    minlon = property(_WXP.MapFileHeader_minlon_get, _WXP.MapFileHeader_minlon_set)
    maxlon = property(_WXP.MapFileHeader_maxlon_get, _WXP.MapFileHeader_maxlon_set)
    index = property(_WXP.MapFileHeader_index_get, _WXP.MapFileHeader_index_set)
    label = property(_WXP.MapFileHeader_label_get, _WXP.MapFileHeader_label_set)

    def setNum(self, val):
        return _WXP.MapFileHeader_setNum(self, val)

    def getNum(self):
        return _WXP.MapFileHeader_getNum(self)

    def setMinLat(self, val):
        return _WXP.MapFileHeader_setMinLat(self, val)

    def getMinLat(self):
        return _WXP.MapFileHeader_getMinLat(self)

    def setMaxLat(self, val):
        return _WXP.MapFileHeader_setMaxLat(self, val)

    def getMaxLat(self):
        return _WXP.MapFileHeader_getMaxLat(self)

    def setMinLon(self, val):
        return _WXP.MapFileHeader_setMinLon(self, val)

    def getMinLon(self):
        return _WXP.MapFileHeader_getMinLon(self)

    def setMaxLon(self, val):
        return _WXP.MapFileHeader_setMaxLon(self, val)

    def getMaxLon(self):
        return _WXP.MapFileHeader_getMaxLon(self)

    def setIndex(self, val):
        return _WXP.MapFileHeader_setIndex(self, val)

    def getIndex(self):
        return _WXP.MapFileHeader_getIndex(self)

    def setLabel(self, lab):
        return _WXP.MapFileHeader_setLabel(self, lab)

    def hasLabel(self):
        return _WXP.MapFileHeader_hasLabel(self)

    def getLabel(self):
        return _WXP.MapFileHeader_getLabel(self)

    def init(self):
        return _WXP.MapFileHeader_init(self)

    def _print(self):
        return _WXP.MapFileHeader__print(self)

    def __init__(self):
        _WXP.MapFileHeader_swiginit(self, _WXP.new_MapFileHeader())
    __swig_destroy__ = _WXP.delete_MapFileHeader

# Register MapFileHeader in _WXP:
_WXP.MapFileHeader_swigregister(MapFileHeader)
class MapFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _WXP.MapFile_swiginit(self, _WXP.new_MapFile(*args))
    __swig_destroy__ = _WXP.delete_MapFile

    def checkType(self, filename):
        return _WXP.MapFile_checkType(self, filename)

    def open(self, *args):
        return _WXP.MapFile_open(self, *args)

    def isOpen(self):
        return _WXP.MapFile_isOpen(self)

    def rewind(self):
        return _WXP.MapFile_rewind(self)

    def seek(self, off):
        return _WXP.MapFile_seek(self, off)

    def tell(self):
        return _WXP.MapFile_tell(self)

    def close(self):
        return _WXP.MapFile_close(self)

    def isBinary(self):
        return _WXP.MapFile_isBinary(self)

    def readHeader(self, hdr):
        return _WXP.MapFile_readHeader(self, hdr)

    def skipData(self):
        return _WXP.MapFile_skipData(self)

    def readData(self, ept):
        return _WXP.MapFile_readData(self, ept)

    def writeHeader(self, hdr):
        return _WXP.MapFile_writeHeader(self, hdr)

    def writeData(self, ept):
        return _WXP.MapFile_writeData(self, ept)

    def _print(self):
        return _WXP.MapFile__print(self)
    UNK = _WXP.MapFile_UNK
    BINARY = _WXP.MapFile_BINARY
    ASCII = _WXP.MapFile_ASCII
    KML = _WXP.MapFile_KML
    SHAPE = _WXP.MapFile_SHAPE

# Register MapFile in _WXP:
_WXP.MapFile_swigregister(MapFile)