// /usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/cc1plus -quiet -I../.. -I/usr/lib/wx/include/gtk2-2.4 -I/usr/include/gtk-2.0 -I/usr/lib/gtk-2.0/include -I/usr/include/atk-1.0 -I/usr/include/pango-1.0 -I/usr/X11R6/include -I/usr/include/freetype2 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -Isrc -I/usr/lib/wx/include/gtk2-2.4 -D__GNUC__=3 -D__GNUC_MINOR__=3 -D__GNUC_PATCHLEVEL__=2 -D_GNU_SOURCE -D__GTK2__ -DGTK_NO_CHECK_CASTS -D__WXGTK__ -D_FILE_OFFSET_BITS=64 -D_LARGE_FILES -DGTK_NO_CHECK_CASTS -D__WXGTK__ -D_FILE_OFFSET_BITS=64 -D_LARGE_FILES xh_bmpbt.cpp -D__GNUG__=3 -quiet -dumpbase xh_bmpbt.cpp -march=athlon-xp -auxbase xh_bmpbt -g -O2 -o -
# 1 "xh_bmpbt.cpp"
# 1 "<interno>"
# 1 "<l\355nea de orden>"
# 1 "xh_bmpbt.cpp"
# 12 "xh_bmpbt.cpp"
#pragma implementation "xh_bmpbt.h"



# 1 "/usr/include/wx/wxprec.h" 1 3 4
# 13 "/usr/include/wx/wxprec.h" 3 4
# 1 "/usr/include/wx/defs.h" 1 3 4
# 16 "/usr/include/wx/defs.h" 3 4
#pragma interface "defs.h"






# 1 "/usr/include/wx/platform.h" 1 3 4
# 85 "/usr/include/wx/platform.h" 3 4
# 1 "/usr/lib/wx/include/gtk2-2.4/wx/setup.h" 1 3 4







#pragma interface
# 1134 "/usr/lib/wx/include/gtk2-2.4/wx/setup.h" 3 4
# 1 "/usr/include/wx/chkconf.h" 1 3 4
# 1135 "/usr/lib/wx/include/gtk2-2.4/wx/setup.h" 2 3 4
# 86 "/usr/include/wx/platform.h" 2 3 4


# 1 "/usr/include/wx/chkconf.h" 1 3 4
# 89 "/usr/include/wx/platform.h" 2 3 4
# 24 "/usr/include/wx/defs.h" 2 3 4
# 39 "/usr/include/wx/defs.h" 3 4
# 1 "/usr/include/wx/features.h" 1 3 4
# 40 "/usr/include/wx/defs.h" 2 3 4
# 78 "/usr/include/wx/defs.h" 3 4
# 1 "/usr/include/wx/version.h" 1 3 4
# 79 "/usr/include/wx/defs.h" 2 3 4
# 209 "/usr/include/wx/defs.h" 3 4
typedef short int WXTYPE;






typedef int wxWindowID;
# 363 "/usr/include/wx/defs.h" 3 4
class wxObject;
class wxEvent;
# 398 "/usr/include/wx/defs.h" 3 4
# 1 "/usr/include/wx/debug.h" 1 3 4
# 15 "/usr/include/wx/debug.h" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 36 "/usr/include/assert.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 295 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 296 "/usr/include/features.h" 2 3 4
# 318 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 319 "/usr/include/features.h" 2 3 4
# 37 "/usr/include/assert.h" 2 3 4
# 65 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (__const char *__assertion, __const char *__file,
                           unsigned int __line, __const char *__function)
     throw () __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, __const char *__file,
                                  unsigned int __line,
                                  __const char *__function)
     throw () __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     throw () __attribute__ ((__noreturn__));


}
# 16 "/usr/include/wx/debug.h" 2 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/limits.h" 1 3 4
# 11 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/limits.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/limits.h" 1 3 4
# 122 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 144 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 130 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 36 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 37 "/usr/include/bits/local_lim.h" 2 3 4
# 131 "/usr/include/bits/posix1_lim.h" 2 3 4
# 145 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 149 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 34 "/usr/include/bits/xopen_lim.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 35 "/usr/include/bits/xopen_lim.h" 2 3 4
# 153 "/usr/include/limits.h" 2 3 4
# 123 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/syslimits.h" 2 3 4
# 12 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/limits.h" 2 3 4
# 17 "/usr/include/wx/debug.h" 2 3 4

# 1 "/usr/include/wx/wxchar.h" 1 3 4
# 16 "/usr/include/wx/wxchar.h" 3 4
#pragma interface "wxchar.h"
# 81 "/usr/include/wx/wxchar.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stdarg.h" 1 3 4
# 43 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 105 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 82 "/usr/include/wx/wxchar.h" 2 3 4
# 102 "/usr/include/wx/wxchar.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 37 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/stdio.h" 1 3 4
# 44 "/usr/include/stdio.h" 3 4


typedef struct _IO_FILE FILE;





# 62 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 38 "/usr/include/wchar.h" 2 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 213 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 3 4
typedef unsigned int size_t;
# 354 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 49 "/usr/include/wchar.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 51 "/usr/include/wchar.h" 2 3 4
# 76 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;
# 93 "/usr/include/wchar.h" 3 4


typedef __mbstate_t mbstate_t;



# 118 "/usr/include/wchar.h" 3 4
extern "C" {




struct tm;









extern wchar_t *wcscpy (wchar_t *__restrict __dest,
                        __const wchar_t *__restrict __src) throw ();

extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
                         __const wchar_t *__restrict __src, size_t __n)
     throw ();


extern wchar_t *wcscat (wchar_t *__restrict __dest,
                        __const wchar_t *__restrict __src) throw ();

extern wchar_t *wcsncat (wchar_t *__restrict __dest,
                         __const wchar_t *__restrict __src, size_t __n)
     throw ();


extern int wcscmp (__const wchar_t *__s1, __const wchar_t *__s2)
     throw () __attribute__ ((__pure__));

extern int wcsncmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n)
     throw () __attribute__ ((__pure__));




extern int wcscasecmp (__const wchar_t *__s1, __const wchar_t *__s2) throw ();


extern int wcsncasecmp (__const wchar_t *__s1, __const wchar_t *__s2,
                        size_t __n) throw ();



# 1 "/usr/include/xlocale.h" 1 3 4
# 28 "/usr/include/xlocale.h" 3 4
typedef struct __locale_struct
{

  struct locale_data *__locales[13];


  const unsigned short int *__ctype_b;
  const int *__ctype_tolower;
  const int *__ctype_toupper;


  const char *__names[13];
} *__locale_t;
# 167 "/usr/include/wchar.h" 2 3 4

extern int wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
                         __locale_t __loc) throw ();

extern int wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
                          size_t __n, __locale_t __loc) throw ();





extern int wcscoll (__const wchar_t *__s1, __const wchar_t *__s2) throw ();



extern size_t wcsxfrm (wchar_t *__restrict __s1,
                       __const wchar_t *__restrict __s2, size_t __n) throw ();








extern int wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2,
                      __locale_t __loc) throw ();




extern size_t wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2,
                         size_t __n, __locale_t __loc) throw ();


extern wchar_t *wcsdup (__const wchar_t *__s) throw () __attribute__ ((__malloc__));




extern wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
     throw () __attribute__ ((__pure__));

extern wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
     throw () __attribute__ ((__pure__));





extern wchar_t *wcschrnul (__const wchar_t *__s, wchar_t __wc)
     throw () __attribute__ ((__pure__));





extern size_t wcscspn (__const wchar_t *__wcs, __const wchar_t *__reject)
     throw () __attribute__ ((__pure__));


extern size_t wcsspn (__const wchar_t *__wcs, __const wchar_t *__accept)
     throw () __attribute__ ((__pure__));

extern wchar_t *wcspbrk (__const wchar_t *__wcs, __const wchar_t *__accept)
     throw () __attribute__ ((__pure__));

extern wchar_t *wcsstr (__const wchar_t *__haystack, __const wchar_t *__needle)
     throw () __attribute__ ((__pure__));


extern wchar_t *wcstok (wchar_t *__restrict __s,
                        __const wchar_t *__restrict __delim,
                        wchar_t **__restrict __ptr) throw ();


extern size_t wcslen (__const wchar_t *__s) throw () __attribute__ ((__pure__));




extern wchar_t *wcswcs (__const wchar_t *__haystack, __const wchar_t *__needle)
     throw () __attribute__ ((__pure__));




extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen)
     throw () __attribute__ ((__pure__));





extern wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c, size_t __n)
     throw () __attribute__ ((__pure__));


extern int wmemcmp (__const wchar_t *__restrict __s1,
                    __const wchar_t *__restrict __s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
                         __const wchar_t *__restrict __s2, size_t __n) throw ();



extern wchar_t *wmemmove (wchar_t *__s1, __const wchar_t *__s2, size_t __n)
     throw ();


extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();





extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
                          __const wchar_t *__restrict __s2, size_t __n)
     throw ();






extern wint_t btowc (int __c) throw ();



extern int wctob (wint_t __c) throw ();



extern int mbsinit (__const mbstate_t *__ps) throw () __attribute__ ((__pure__));



extern size_t mbrtowc (wchar_t *__restrict __pwc,
                       __const char *__restrict __s, size_t __n,
                       mbstate_t *__p) throw ();


extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
                       mbstate_t *__restrict __ps) throw ();


extern size_t __mbrlen (__const char *__restrict __s, size_t __n,
                        mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (__const char *__restrict __s, size_t __n,
                      mbstate_t *__restrict __ps) throw ();




extern __inline size_t mbrlen (__const char *__restrict __s, size_t __n,
                               mbstate_t *__restrict __ps) throw ()
{ return (__ps != __null
          ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }





extern size_t mbsrtowcs (wchar_t *__restrict __dst,
                         __const char **__restrict __src, size_t __len,
                         mbstate_t *__restrict __ps) throw ();



extern size_t wcsrtombs (char *__restrict __dst,
                         __const wchar_t **__restrict __src, size_t __len,
                         mbstate_t *__restrict __ps) throw ();






extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
                          __const char **__restrict __src, size_t __nmc,
                          size_t __len, mbstate_t *__restrict __ps) throw ();



extern size_t wcsnrtombs (char *__restrict __dst,
                          __const wchar_t **__restrict __src,
                          size_t __nwc, size_t __len,
                          mbstate_t *__restrict __ps) throw ();






extern int wcwidth (wchar_t __c) throw ();



extern int wcswidth (__const wchar_t *__s, size_t __n) throw ();






extern double wcstod (__const wchar_t *__restrict __nptr,
                      wchar_t **__restrict __endptr) throw ();



extern float wcstof (__const wchar_t *__restrict __nptr,
                     wchar_t **__restrict __endptr) throw ();
extern long double wcstold (__const wchar_t *__restrict __nptr,
                            wchar_t **__restrict __endptr) throw ();





extern long int wcstol (__const wchar_t *__restrict __nptr,
                        wchar_t **__restrict __endptr, int __base) throw ();



extern unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
                                  wchar_t **__restrict __endptr, int __base)
     throw ();




__extension__
extern long long int wcstoll (__const wchar_t *__restrict __nptr,
                              wchar_t **__restrict __endptr, int __base)
     throw ();



__extension__
extern unsigned long long int wcstoull (__const wchar_t *__restrict __nptr,
                                        wchar_t **__restrict __endptr,
                                        int __base) throw ();






__extension__
extern long long int wcstoq (__const wchar_t *__restrict __nptr,
                             wchar_t **__restrict __endptr, int __base)
     throw ();



__extension__
extern unsigned long long int wcstouq (__const wchar_t *__restrict __nptr,
                                       wchar_t **__restrict __endptr,
                                       int __base) throw ();
# 448 "/usr/include/wchar.h" 3 4
extern long int wcstol_l (__const wchar_t *__restrict __nptr,
                          wchar_t **__restrict __endptr, int __base,
                          __locale_t __loc) throw ();

extern unsigned long int wcstoul_l (__const wchar_t *__restrict __nptr,
                                    wchar_t **__restrict __endptr,
                                    int __base, __locale_t __loc) throw ();

__extension__
extern long long int wcstoll_l (__const wchar_t *__restrict __nptr,
                                wchar_t **__restrict __endptr,
                                int __base, __locale_t __loc) throw ();

__extension__
extern unsigned long long int wcstoull_l (__const wchar_t *__restrict __nptr,
                                          wchar_t **__restrict __endptr,
                                          int __base, __locale_t __loc)
     throw ();

extern double wcstod_l (__const wchar_t *__restrict __nptr,
                        wchar_t **__restrict __endptr, __locale_t __loc)
     throw ();

extern float wcstof_l (__const wchar_t *__restrict __nptr,
                       wchar_t **__restrict __endptr, __locale_t __loc)
     throw ();

extern long double wcstold_l (__const wchar_t *__restrict __nptr,
                              wchar_t **__restrict __endptr,
                              __locale_t __loc) throw ();





extern double __wcstod_internal (__const wchar_t *__restrict __nptr,
                                 wchar_t **__restrict __endptr, int __group)
     throw ();
extern float __wcstof_internal (__const wchar_t *__restrict __nptr,
                                wchar_t **__restrict __endptr, int __group)
     throw ();
extern long double __wcstold_internal (__const wchar_t *__restrict __nptr,
                                       wchar_t **__restrict __endptr,
                                       int __group) throw ();


extern long int __wcstol_internal (__const wchar_t *__restrict __nptr,
                                   wchar_t **__restrict __endptr,
                                   int __base, int __group) throw ();



extern unsigned long int __wcstoul_internal (__const wchar_t *__restrict __npt,
                                             wchar_t **__restrict __endptr,
                                             int __base, int __group) throw ();



__extension__
extern long long int __wcstoll_internal (__const wchar_t *__restrict __nptr,
                                         wchar_t **__restrict __endptr,
                                         int __base, int __group) throw ();



__extension__
extern unsigned long long int __wcstoull_internal (__const wchar_t *
                                                   __restrict __nptr,
                                                   wchar_t **
                                                   __restrict __endptr,
                                                   int __base,
                                                   int __group) throw ();








extern __inline double wcstod (__const wchar_t *__restrict __nptr,
                               wchar_t **__restrict __endptr) throw ()
{ return __wcstod_internal (__nptr, __endptr, 0); }
extern __inline long int wcstol (__const wchar_t *__restrict __nptr,
                                 wchar_t **__restrict __endptr,
                                 int __base) throw ()
{ return __wcstol_internal (__nptr, __endptr, __base, 0); }
extern __inline unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
                                           wchar_t **__restrict __endptr,
                                           int __base) throw ()
{ return __wcstoul_internal (__nptr, __endptr, __base, 0); }



extern __inline float wcstof (__const wchar_t *__restrict __nptr,
                              wchar_t **__restrict __endptr) throw ()
{ return __wcstof_internal (__nptr, __endptr, 0); }
extern __inline long double wcstold (__const wchar_t *__restrict __nptr,
                                     wchar_t **__restrict __endptr) throw ()
{ return __wcstold_internal (__nptr, __endptr, 0); }


__extension__
extern __inline long long int wcstoq (__const wchar_t *__restrict __nptr,
                                      wchar_t **__restrict __endptr,
                                      int __base) throw ()
{ return __wcstoll_internal (__nptr, __endptr, __base, 0); }
__extension__
extern __inline unsigned long long int wcstouq (__const wchar_t *
                                                __restrict __nptr,
                                                wchar_t **__restrict __endptr,
                                                int __base) throw ()
{ return __wcstoull_internal (__nptr, __endptr, __base, 0); }







extern wchar_t *wcpcpy (wchar_t *__dest, __const wchar_t *__src) throw ();



extern wchar_t *wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n)
     throw ();








extern int fwide (__FILE *__fp, int __mode) throw ();






extern int fwprintf (__FILE *__restrict __stream,
                     __const wchar_t *__restrict __format, ...)
                                                           ;




extern int wprintf (__const wchar_t *__restrict __format, ...)
                                                           ;

extern int swprintf (wchar_t *__restrict __s, size_t __n,
                     __const wchar_t *__restrict __format, ...)
     throw () ;





extern int vfwprintf (__FILE *__restrict __s,
                      __const wchar_t *__restrict __format,
                      __gnuc_va_list __arg)
                                                           ;




extern int vwprintf (__const wchar_t *__restrict __format,
                     __gnuc_va_list __arg)
                                                           ;


extern int vswprintf (wchar_t *__restrict __s, size_t __n,
                      __const wchar_t *__restrict __format,
                      __gnuc_va_list __arg)
     throw () ;






extern int fwscanf (__FILE *__restrict __stream,
                    __const wchar_t *__restrict __format, ...)
                                                          ;




extern int wscanf (__const wchar_t *__restrict __format, ...)
                                                          ;

extern int swscanf (__const wchar_t *__restrict __s,
                    __const wchar_t *__restrict __format, ...)
     throw () ;











extern int vfwscanf (__FILE *__restrict __s,
                     __const wchar_t *__restrict __format,
                     __gnuc_va_list __arg)
                                                          ;




extern int vwscanf (__const wchar_t *__restrict __format,
                    __gnuc_va_list __arg)
                                                          ;

extern int vswscanf (__const wchar_t *__restrict __s,
                     __const wchar_t *__restrict __format,
                     __gnuc_va_list __arg)
     throw () ;










extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);





extern wint_t getwchar (void);






extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);





extern wint_t putwchar (wchar_t __wc);







extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
                        __FILE *__restrict __stream);





extern int fputws (__const wchar_t *__restrict __ws,
                   __FILE *__restrict __stream);






extern wint_t ungetwc (wint_t __wc, __FILE *__stream);

# 736 "/usr/include/wchar.h" 3 4
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);







extern wint_t fgetwc_unlocked (__FILE *__stream);







extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
# 762 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 772 "/usr/include/wchar.h" 3 4
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
                                 __FILE *__restrict __stream);







extern int fputws_unlocked (__const wchar_t *__restrict __ws,
                            __FILE *__restrict __stream);







extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
                        __const wchar_t *__restrict __format,
                        __const struct tm *__restrict __tp) throw ();







extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
                          __const wchar_t *__restrict __format,
                          __const struct tm *__restrict __tp,
                          __locale_t __loc) throw ();
# 817 "/usr/include/wchar.h" 3 4
}
# 103 "/usr/include/wx/wxchar.h" 2 3 4
# 165 "/usr/include/wx/wxchar.h" 3 4
    typedef char wxChar;
    typedef signed char wxSChar;
    typedef unsigned char wxUChar;
# 434 "/usr/include/wx/wxchar.h" 3 4
# 1 "/usr/include/ctype.h" 1 3 4
# 28 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 28 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/bits/types.h" 2 3 4


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 32 "/usr/include/bits/types.h" 2 3 4


typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;




__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;







__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
# 129 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 130 "/usr/include/bits/types.h" 2 3 4






__extension__ typedef unsigned long long int __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef unsigned long long int __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef long long int __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef unsigned long long int __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;

__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;


__extension__ typedef int __clockid_t;


__extension__ typedef int __timer_t;


__extension__ typedef long int __blksize_t;




__extension__ typedef long int __blkcnt_t;
__extension__ typedef long long int __blkcnt64_t;


__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef unsigned long long int __fsblkcnt64_t;


__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef unsigned long long int __fsfilcnt64_t;

__extension__ typedef int __ssize_t;



typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;


__extension__ typedef int __intptr_t;


__extension__ typedef unsigned int __socklen_t;
# 29 "/usr/include/ctype.h" 2 3 4

extern "C" {
# 41 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 37 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/endian.h" 1 3 4
# 38 "/usr/include/endian.h" 2 3 4
# 42 "/usr/include/ctype.h" 2 3 4






enum
{
  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 81 "/usr/include/ctype.h" 3 4
extern __const unsigned short int **__ctype_b_loc (void)
     __attribute__ ((__const));
extern __const __int32_t **__ctype_tolower_loc (void)
     __attribute__ ((__const));
extern __const __int32_t **__ctype_toupper_loc (void)
     __attribute__ ((__const));
# 96 "/usr/include/ctype.h" 3 4






extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();



extern int tolower (int __c) throw ();


extern int toupper (int __c) throw ();








extern int isblank (int) throw ();






extern int isctype (int __c, int __mask) throw ();






extern int isascii (int __c) throw ();



extern int toascii (int __c) throw ();



extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 247 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();

extern int isblank_l (int, __locale_t) throw ();



extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();


extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
# 323 "/usr/include/ctype.h" 3 4
}
# 435 "/usr/include/wx/wxchar.h" 2 3 4
# 1 "/usr/include/string.h" 1 3 4
# 28 "/usr/include/string.h" 3 4
extern "C" {




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 34 "/usr/include/string.h" 2 3 4




extern void *memcpy (void *__restrict __dest,
                     __const void *__restrict __src, size_t __n) throw ();


extern void *memmove (void *__dest, __const void *__src, size_t __n)
     throw ();






extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
                      int __c, size_t __n)
     throw ();





extern void *memset (void *__s, int __c, size_t __n) throw ();


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern void *memchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__));





extern void *rawmemchr (__const void *__s, int __c) throw () __attribute__ ((__pure__));


extern void *memrchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__));





extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     throw ();

extern char *strncpy (char *__restrict __dest,
                      __const char *__restrict __src, size_t __n) throw ();


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
     throw ();

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
                      size_t __n) throw ();


extern int strcmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern int strcoll (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));

extern size_t strxfrm (char *__restrict __dest,
                       __const char *__restrict __src, size_t __n) throw ();

# 117 "/usr/include/string.h" 3 4
extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
     throw () __attribute__ ((__pure__));

extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
                         __locale_t __l) throw ();




extern char *strdup (__const char *__s) throw () __attribute__ ((__malloc__));






extern char *strndup (__const char *__string, size_t __n)
     throw () __attribute__ ((__malloc__));
# 160 "/usr/include/string.h" 3 4


extern char *strchr (__const char *__s, int __c) throw () __attribute__ ((__pure__));

extern char *strrchr (__const char *__s, int __c) throw () __attribute__ ((__pure__));





extern char *strchrnul (__const char *__s, int __c) throw () __attribute__ ((__pure__));





extern size_t strcspn (__const char *__s, __const char *__reject)
     throw () __attribute__ ((__pure__));


extern size_t strspn (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__));

extern char *strpbrk (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__));

extern char *strstr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__));



extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
     throw ();




extern char *__strtok_r (char *__restrict __s,
                         __const char *__restrict __delim,
                         char **__restrict __save_ptr) throw ();

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
                       char **__restrict __save_ptr) throw ();




extern char *strcasestr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__));






extern void *memmem (__const void *__haystack, size_t __haystacklen,
                     __const void *__needle, size_t __needlelen)
     throw () __attribute__ ((__pure__));



extern void *__mempcpy (void *__restrict __dest,
                        __const void *__restrict __src, size_t __n) throw ();
extern void *mempcpy (void *__restrict __dest,
                      __const void *__restrict __src, size_t __n) throw ();





extern size_t strlen (__const char *__s) throw () __attribute__ ((__pure__));





extern size_t strnlen (__const char *__string, size_t __maxlen)
     throw () __attribute__ ((__pure__));





extern char *strerror (int __errnum) throw ();




extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) throw ();




extern void __bzero (void *__s, size_t __n) throw ();



extern void bcopy (__const void *__src, void *__dest, size_t __n) throw ();


extern void bzero (void *__s, size_t __n) throw ();


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern char *index (__const char *__s, int __c) throw () __attribute__ ((__pure__));


extern char *rindex (__const char *__s, int __c) throw () __attribute__ ((__pure__));



extern int ffs (int __i) throw () __attribute__ ((__const__));




extern int ffsl (long int __l) throw () __attribute__ ((__const__));

__extension__ extern int ffsll (long long int __ll)
     throw () __attribute__ ((__const__));




extern int strcasecmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__));





extern int strcasecmp_l (__const char *__s1, __const char *__s2,
                         __locale_t __loc) throw () __attribute__ ((__pure__));

extern int strncasecmp_l (__const char *__s1, __const char *__s2,
                          size_t __n, __locale_t __loc)
     throw () __attribute__ ((__pure__));





extern char *strsep (char **__restrict __stringp,
                     __const char *__restrict __delim) throw ();




extern int strverscmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));


extern char *strsignal (int __sig) throw ();


extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw ();
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw ();



extern char *__stpncpy (char *__restrict __dest,
                        __const char *__restrict __src, size_t __n) throw ();
extern char *stpncpy (char *__restrict __dest,
                      __const char *__restrict __src, size_t __n) throw ();


extern char *strfry (char *__string) throw ();


extern void *memfrob (void *__s, size_t __n) throw ();






extern char *basename (__const char *__filename) throw ();
# 379 "/usr/include/string.h" 3 4
}
# 436 "/usr/include/wx/wxchar.h" 2 3 4
# 570 "/usr/include/wx/wxchar.h" 3 4
inline bool wxIsEmpty(const wxChar *p) { return !p || !*p; }


inline size_t wxStrlen(const wxChar *psz) { return psz ? strlen(psz) : 0; }

 bool wxOKlibc();
# 797 "/usr/include/wx/wxchar.h" 3 4
    size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n);
    size_t wxWC2MB(char *buf, const wchar_t *psz, size_t n);
# 19 "/usr/include/wx/debug.h" 2 3 4
# 125 "/usr/include/wx/debug.h" 3 4
extern const bool wxFalse;
# 399 "/usr/include/wx/defs.h" 2 3 4





# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 151 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 3 4
typedef int ptrdiff_t;
# 405 "/usr/include/wx/defs.h" 2 3 4
# 470 "/usr/include/wx/defs.h" 3 4
typedef void (*wxFunction) (wxObject&, wxEvent&);







enum
{
    wxUNKNOWN_PLATFORM,
    wxCURSES,
    wxXVIEW_X,
    wxMOTIF_X,
    wxCOSE_X,
    wxNEXTSTEP,
    wxMAC,
    wxMAC_DARWIN,
    wxBEOS,
    wxGTK,
    wxGTK_WIN32,
    wxGTK_OS2,
    wxGTK_BEOS,
    wxGEOS,
    wxOS2_PM,
    wxWINDOWS,
    wxMICROWINDOWS,
    wxPENWINDOWS,
    wxWINDOWS_NT,
    wxWIN32S,
    wxWIN95,
    wxWIN386,
    wxMGL_UNIX,
    wxMGL_X,
    wxMGL_WIN32,
    wxMGL_OS2,
    wxMGL_DOS,
    wxWINDOWS_OS2,
    wxUNIX,
    wxX11
};
# 528 "/usr/include/wx/defs.h" 3 4
        typedef int wxCoord;
# 595 "/usr/include/wx/defs.h" 3 4
typedef float wxFloat32 ;



    typedef double wxFloat64;





    typedef double wxDouble ;
# 780 "/usr/include/wx/defs.h" 3 4
enum wxGeometryCentre
{
    wxCENTRE = 0x0001,
    wxCENTER = wxCENTRE
};







enum wxOrientation
{
    wxHORIZONTAL = 0x0004,
    wxVERTICAL = 0x0008,

    wxBOTH = (wxVERTICAL | wxHORIZONTAL)
};

enum wxDirection
{
    wxLEFT = 0x0010,
    wxRIGHT = 0x0020,
    wxUP = 0x0040,
    wxDOWN = 0x0080,

    wxTOP = wxUP,
    wxBOTTOM = wxDOWN,

    wxNORTH = wxUP,
    wxSOUTH = wxDOWN,
    wxWEST = wxLEFT,
    wxEAST = wxRIGHT,

    wxALL = (wxUP | wxDOWN | wxRIGHT | wxLEFT)
};

enum wxAlignment
{
    wxALIGN_NOT = 0x0000,
    wxALIGN_CENTER_HORIZONTAL = 0x0100,
    wxALIGN_CENTRE_HORIZONTAL = wxALIGN_CENTER_HORIZONTAL,
    wxALIGN_LEFT = wxALIGN_NOT,
    wxALIGN_TOP = wxALIGN_NOT,
    wxALIGN_RIGHT = 0x0200,
    wxALIGN_BOTTOM = 0x0400,
    wxALIGN_CENTER_VERTICAL = 0x0800,
    wxALIGN_CENTRE_VERTICAL = wxALIGN_CENTER_VERTICAL,

    wxALIGN_CENTER = (wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL),
    wxALIGN_CENTRE = wxALIGN_CENTER,


    wxALIGN_MASK = 0x0f00
};

enum wxStretch
{
    wxSTRETCH_NOT = 0x0000,
    wxSHRINK = 0x1000,
    wxGROW = 0x2000,
    wxEXPAND = wxGROW,
    wxSHAPED = 0x4000,
    wxADJUST_MINSIZE = 0x8000,
    wxTILE = 0xc000
};


enum wxBorder
{


    wxBORDER_DEFAULT = 0,

    wxBORDER_NONE = 0x00200000,
    wxBORDER_STATIC = 0x01000000,
    wxBORDER_SIMPLE = 0x02000000,
    wxBORDER_RAISED = 0x04000000,
    wxBORDER_SUNKEN = 0x08000000,
    wxBORDER_DOUBLE = 0x10000000,


    wxBORDER_MASK = 0x1f200000
};
# 1277 "/usr/include/wx/defs.h" 3 4
enum
{
    wxID_ANY = -1
};


enum
{
    wxID_SEPARATOR = -1
};


enum
{
    wxID_LOWEST = 4999,

    wxID_OPEN,
    wxID_CLOSE,
    wxID_NEW,
    wxID_SAVE,
    wxID_SAVEAS,
    wxID_REVERT,
    wxID_EXIT,
    wxID_UNDO,
    wxID_REDO,
    wxID_HELP,
    wxID_PRINT,
    wxID_PRINT_SETUP,
    wxID_PREVIEW,
    wxID_ABOUT,
    wxID_HELP_CONTENTS,
    wxID_HELP_COMMANDS,
    wxID_HELP_PROCEDURES,
    wxID_HELP_CONTEXT,
    wxID_CLOSE_ALL,

    wxID_CUT = 5030,
    wxID_COPY,
    wxID_PASTE,
    wxID_CLEAR,
    wxID_FIND,
    wxID_DUPLICATE,
    wxID_SELECTALL,

    wxID_FILE1 = 5050,
    wxID_FILE2,
    wxID_FILE3,
    wxID_FILE4,
    wxID_FILE5,
    wxID_FILE6,
    wxID_FILE7,
    wxID_FILE8,
    wxID_FILE9,


    wxID_OK = 5100,
    wxID_CANCEL,
    wxID_APPLY,
    wxID_YES,
    wxID_NO,
    wxID_STATIC,
    wxID_FORWARD,
    wxID_BACKWARD,
    wxID_DEFAULT,
    wxID_MORE,
    wxID_SETUP,
    wxID_RESET,
    wxID_CONTEXT_HELP,
    wxID_YESTOALL,
    wxID_NOTOALL,
    wxID_ABORT,
    wxID_RETRY,
    wxID_IGNORE,


    wxID_SYSTEM_MENU = 5200,
    wxID_CLOSE_FRAME,
    wxID_MOVE_FRAME,
    wxID_RESIZE_FRAME,
    wxID_MAXIMIZE_FRAME,
    wxID_ICONIZE_FRAME,
    wxID_RESTORE_FRAME,


    wxID_FILEDLGG = 5900,

    wxID_HIGHEST = 5999
};






enum wxItemKind
{
    wxITEM_SEPARATOR = -1,
    wxITEM_NORMAL,
    wxITEM_CHECK,
    wxITEM_RADIO,
    wxITEM_MAX
};


enum wxHitTest
{
    wxHT_NOWHERE,


    wxHT_SCROLLBAR_FIRST = wxHT_NOWHERE,
    wxHT_SCROLLBAR_ARROW_LINE_1,
    wxHT_SCROLLBAR_ARROW_LINE_2,
    wxHT_SCROLLBAR_ARROW_PAGE_1,
    wxHT_SCROLLBAR_ARROW_PAGE_2,
    wxHT_SCROLLBAR_THUMB,
    wxHT_SCROLLBAR_BAR_1,
    wxHT_SCROLLBAR_BAR_2,
    wxHT_SCROLLBAR_LAST,


    wxHT_WINDOW_OUTSIDE,
    wxHT_WINDOW_INSIDE,
    wxHT_WINDOW_VERT_SCROLLBAR,
    wxHT_WINDOW_HORZ_SCROLLBAR,
    wxHT_WINDOW_CORNER,

    wxHT_MAX
};
# 1428 "/usr/include/wx/defs.h" 3 4
enum
{

    wxDEFAULT = 70,
    wxDECORATIVE,
    wxROMAN,
    wxSCRIPT,
    wxSWISS,
    wxMODERN,
    wxTELETYPE,


    wxVARIABLE = 80,
    wxFIXED,

    wxNORMAL = 90,
    wxLIGHT,
    wxBOLD,

    wxITALIC,
    wxSLANT,


    wxSOLID = 100,
    wxDOT,
    wxLONG_DASH,
    wxSHORT_DASH,
    wxDOT_DASH,
    wxUSER_DASH,

    wxTRANSPARENT,



    wxSTIPPLE_MASK_OPAQUE,
    wxSTIPPLE_MASK,

    wxSTIPPLE = 110,
    wxBDIAGONAL_HATCH,
    wxCROSSDIAG_HATCH,
    wxFDIAGONAL_HATCH,
    wxCROSS_HATCH,
    wxHORIZONTAL_HATCH,
    wxVERTICAL_HATCH,

    wxJOIN_BEVEL = 120,
    wxJOIN_MITER,
    wxJOIN_ROUND,

    wxCAP_ROUND = 130,
    wxCAP_PROJECTING,
    wxCAP_BUTT
};





typedef enum
{
  wxCLEAR, wxROP_BLACK = wxCLEAR, wxBLIT_BLACKNESS = wxCLEAR,
  wxXOR, wxROP_XORPEN = wxXOR, wxBLIT_SRCINVERT = wxXOR,
  wxINVERT, wxROP_NOT = wxINVERT, wxBLIT_DSTINVERT = wxINVERT,
  wxOR_REVERSE, wxROP_MERGEPENNOT = wxOR_REVERSE, wxBLIT_00DD0228 = wxOR_REVERSE,
  wxAND_REVERSE, wxROP_MASKPENNOT = wxAND_REVERSE, wxBLIT_SRCERASE = wxAND_REVERSE,
  wxCOPY, wxROP_COPYPEN = wxCOPY, wxBLIT_SRCCOPY = wxCOPY,
  wxAND, wxROP_MASKPEN = wxAND, wxBLIT_SRCAND = wxAND,
  wxAND_INVERT, wxROP_MASKNOTPEN = wxAND_INVERT, wxBLIT_00220326 = wxAND_INVERT,
  wxNO_OP, wxROP_NOP = wxNO_OP, wxBLIT_00AA0029 = wxNO_OP,
  wxNOR, wxROP_NOTMERGEPEN = wxNOR, wxBLIT_NOTSRCERASE = wxNOR,
  wxEQUIV, wxROP_NOTXORPEN = wxEQUIV, wxBLIT_00990066 = wxEQUIV,
  wxSRC_INVERT, wxROP_NOTCOPYPEN = wxSRC_INVERT, wxBLIT_NOTSCRCOPY = wxSRC_INVERT,
  wxOR_INVERT, wxROP_MERGENOTPEN = wxOR_INVERT, wxBLIT_MERGEPAINT = wxOR_INVERT,
  wxNAND, wxROP_NOTMASKPEN = wxNAND, wxBLIT_007700E6 = wxNAND,
  wxOR, wxROP_MERGEPEN = wxOR, wxBLIT_SRCPAINT = wxOR,
  wxSET, wxROP_WHITE = wxSET, wxBLIT_WHITENESS = wxSET
} form_ops_t;


enum
{
    wxFLOOD_SURFACE = 1,
    wxFLOOD_BORDER
};


enum
{
    wxODDEVEN_RULE = 1,
    wxWINDING_RULE
};


enum
{
    wxTOOL_TOP = 1,
    wxTOOL_BOTTOM,
    wxTOOL_LEFT,
    wxTOOL_RIGHT
};



enum wxDataFormatId
{
    wxDF_INVALID = 0,
    wxDF_TEXT = 1,
    wxDF_BITMAP = 2,
    wxDF_METAFILE = 3,
    wxDF_SYLK = 4,
    wxDF_DIF = 5,
    wxDF_TIFF = 6,
    wxDF_OEMTEXT = 7,
    wxDF_DIB = 8,
    wxDF_PALETTE = 9,
    wxDF_PENDATA = 10,
    wxDF_RIFF = 11,
    wxDF_WAVE = 12,
    wxDF_UNICODETEXT = 13,
    wxDF_ENHMETAFILE = 14,
    wxDF_FILENAME = 15,
    wxDF_LOCALE = 16,
    wxDF_PRIVATE = 20,
    wxDF_HTML = 30,
    wxDF_MAX
};


enum wxKeyCode
{
    WXK_BACK = 8,
    WXK_TAB = 9,
    WXK_RETURN = 13,
    WXK_ESCAPE = 27,
    WXK_SPACE = 32,
    WXK_DELETE = 127,

    WXK_START = 300,
    WXK_LBUTTON,
    WXK_RBUTTON,
    WXK_CANCEL,
    WXK_MBUTTON,
    WXK_CLEAR,
    WXK_SHIFT,
    WXK_ALT,
    WXK_CONTROL,
    WXK_MENU,
    WXK_PAUSE,
    WXK_CAPITAL,
    WXK_PRIOR,
    WXK_NEXT,
    WXK_END,
    WXK_HOME,
    WXK_LEFT,
    WXK_UP,
    WXK_RIGHT,
    WXK_DOWN,
    WXK_SELECT,
    WXK_PRINT,
    WXK_EXECUTE,
    WXK_SNAPSHOT,
    WXK_INSERT,
    WXK_HELP,
    WXK_NUMPAD0,
    WXK_NUMPAD1,
    WXK_NUMPAD2,
    WXK_NUMPAD3,
    WXK_NUMPAD4,
    WXK_NUMPAD5,
    WXK_NUMPAD6,
    WXK_NUMPAD7,
    WXK_NUMPAD8,
    WXK_NUMPAD9,
    WXK_MULTIPLY,
    WXK_ADD,
    WXK_SEPARATOR,
    WXK_SUBTRACT,
    WXK_DECIMAL,
    WXK_DIVIDE,
    WXK_F1,
    WXK_F2,
    WXK_F3,
    WXK_F4,
    WXK_F5,
    WXK_F6,
    WXK_F7,
    WXK_F8,
    WXK_F9,
    WXK_F10,
    WXK_F11,
    WXK_F12,
    WXK_F13,
    WXK_F14,
    WXK_F15,
    WXK_F16,
    WXK_F17,
    WXK_F18,
    WXK_F19,
    WXK_F20,
    WXK_F21,
    WXK_F22,
    WXK_F23,
    WXK_F24,
    WXK_NUMLOCK,
    WXK_SCROLL,
    WXK_PAGEUP,
    WXK_PAGEDOWN,

    WXK_NUMPAD_SPACE,
    WXK_NUMPAD_TAB,
    WXK_NUMPAD_ENTER,
    WXK_NUMPAD_F1,
    WXK_NUMPAD_F2,
    WXK_NUMPAD_F3,
    WXK_NUMPAD_F4,
    WXK_NUMPAD_HOME,
    WXK_NUMPAD_LEFT,
    WXK_NUMPAD_UP,
    WXK_NUMPAD_RIGHT,
    WXK_NUMPAD_DOWN,
    WXK_NUMPAD_PRIOR,
    WXK_NUMPAD_PAGEUP,
    WXK_NUMPAD_NEXT,
    WXK_NUMPAD_PAGEDOWN,
    WXK_NUMPAD_END,
    WXK_NUMPAD_BEGIN,
    WXK_NUMPAD_INSERT,
    WXK_NUMPAD_DELETE,
    WXK_NUMPAD_EQUAL,
    WXK_NUMPAD_MULTIPLY,
    WXK_NUMPAD_ADD,
    WXK_NUMPAD_SEPARATOR,
    WXK_NUMPAD_SUBTRACT,
    WXK_NUMPAD_DECIMAL,
    WXK_NUMPAD_DIVIDE
};


enum
{
    wxMM_TEXT = 1,
    wxMM_LOMETRIC,
    wxMM_HIMETRIC,
    wxMM_LOENGLISH,
    wxMM_HIENGLISH,
    wxMM_TWIPS,
    wxMM_ISOTROPIC,
    wxMM_ANISOTROPIC,
    wxMM_POINTS,
    wxMM_METRIC
};





typedef enum
{
    wxPAPER_NONE,
    wxPAPER_LETTER,
    wxPAPER_LEGAL,
    wxPAPER_A4,
    wxPAPER_CSHEET,
    wxPAPER_DSHEET,
    wxPAPER_ESHEET,
    wxPAPER_LETTERSMALL,
    wxPAPER_TABLOID,
    wxPAPER_LEDGER,
    wxPAPER_STATEMENT,
    wxPAPER_EXECUTIVE,
    wxPAPER_A3,
    wxPAPER_A4SMALL,
    wxPAPER_A5,
    wxPAPER_B4,
    wxPAPER_B5,
    wxPAPER_FOLIO,
    wxPAPER_QUARTO,
    wxPAPER_10X14,
    wxPAPER_11X17,
    wxPAPER_NOTE,
    wxPAPER_ENV_9,
    wxPAPER_ENV_10,
    wxPAPER_ENV_11,
    wxPAPER_ENV_12,
    wxPAPER_ENV_14,
    wxPAPER_ENV_DL,
    wxPAPER_ENV_C5,
    wxPAPER_ENV_C3,
    wxPAPER_ENV_C4,
    wxPAPER_ENV_C6,
    wxPAPER_ENV_C65,
    wxPAPER_ENV_B4,
    wxPAPER_ENV_B5,
    wxPAPER_ENV_B6,
    wxPAPER_ENV_ITALY,
    wxPAPER_ENV_MONARCH,
    wxPAPER_ENV_PERSONAL,
    wxPAPER_FANFOLD_US,
    wxPAPER_FANFOLD_STD_GERMAN,
    wxPAPER_FANFOLD_LGL_GERMAN,

    wxPAPER_ISO_B4,
    wxPAPER_JAPANESE_POSTCARD,
    wxPAPER_9X11,
    wxPAPER_10X11,
    wxPAPER_15X11,
    wxPAPER_ENV_INVITE,
    wxPAPER_LETTER_EXTRA,
    wxPAPER_LEGAL_EXTRA,
    wxPAPER_TABLOID_EXTRA,
    wxPAPER_A4_EXTRA,
    wxPAPER_LETTER_TRANSVERSE,
    wxPAPER_A4_TRANSVERSE,
    wxPAPER_LETTER_EXTRA_TRANSVERSE,
    wxPAPER_A_PLUS,
    wxPAPER_B_PLUS,
    wxPAPER_LETTER_PLUS,
    wxPAPER_A4_PLUS,
    wxPAPER_A5_TRANSVERSE,
    wxPAPER_B5_TRANSVERSE,
    wxPAPER_A3_EXTRA,
    wxPAPER_A5_EXTRA,
    wxPAPER_B5_EXTRA,
    wxPAPER_A2,
    wxPAPER_A3_TRANSVERSE,
    wxPAPER_A3_EXTRA_TRANSVERSE

} wxPaperSize;
# 1766 "/usr/include/wx/defs.h" 3 4
enum wxDuplexMode
{
    wxDUPLEX_SIMPLEX,
    wxDUPLEX_HORIZONTAL,
    wxDUPLEX_VERTICAL
};
# 1781 "/usr/include/wx/defs.h" 3 4
typedef int wxPrintQuality;




enum wxPrintMode
{
    wxPRINT_MODE_NONE = 0,
    wxPRINT_MODE_PREVIEW = 1,
    wxPRINT_MODE_FILE = 2,
    wxPRINT_MODE_PRINTER = 3
};
# 2037 "/usr/include/wx/defs.h" 3 4
typedef char gchar;
typedef signed char gint8;
typedef int gint;
typedef unsigned guint;
typedef unsigned long gulong;
typedef void* gpointer;
typedef struct _GSList GSList;


typedef struct _GdkColor GdkColor;
typedef struct _GdkColormap GdkColormap;
typedef struct _GdkFont GdkFont;
typedef struct _GdkGC GdkGC;
typedef struct _GdkVisual GdkVisual;


typedef struct _GdkAtom *GdkAtom;
typedef struct _GdkDrawable GdkWindow;
typedef struct _GdkDrawable GdkBitmap;
typedef struct _GdkDrawable GdkPixmap;







typedef struct _GdkCursor GdkCursor;
typedef struct _GdkRegion GdkRegion;
typedef struct _GdkDragContext GdkDragContext;


typedef struct _GdkIC GdkIC;
typedef struct _GdkICAttr GdkICAttr;



typedef struct _GtkWidget GtkWidget;
typedef struct _GtkStyle GtkStyle;
typedef struct _GtkAdjustment GtkAdjustment;
typedef struct _GtkList GtkList;
typedef struct _GtkToolbar GtkToolbar;
typedef struct _GtkTooltips GtkTooltips;
typedef struct _GtkNotebook GtkNotebook;
typedef struct _GtkNotebookPage GtkNotebookPage;
typedef struct _GtkAccelGroup GtkAccelGroup;
typedef struct _GtkItemFactory GtkItemFactory;
typedef struct _GtkSelectionData GtkSelectionData;

typedef GtkWidget *WXWidget;
# 2095 "/usr/include/wx/defs.h" 3 4
typedef struct _GtkIMMulticontext GtkIMMulticontext;
# 2108 "/usr/include/wx/defs.h" 3 4
typedef struct _PangoContext PangoContext;
typedef struct _PangoLayout PangoLayout;
typedef struct _PangoFontDescription PangoFontDescription;
# 14 "/usr/include/wx/wxprec.h" 2 3 4
# 17 "xh_bmpbt.cpp" 2





# 1 "../../wx/xrc/xh_bmpbt.h" 1
# 15 "../../wx/xrc/xh_bmpbt.h"
#pragma interface "xh_bmpbt.h"


# 1 "../../wx/xrc/xmlres.h" 1
# 15 "../../wx/xrc/xmlres.h"
#pragma interface "xmlres.h"



# 1 "/usr/include/wx/string.h" 1 3 4
# 22 "/usr/include/wx/string.h" 3 4
#pragma interface "string.h"
# 55 "/usr/include/wx/string.h" 3 4
# 1 "/usr/include/stdio.h" 1 3 4
# 30 "/usr/include/stdio.h" 3 4
extern "C" {



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 35 "/usr/include/stdio.h" 2 3 4
# 72 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 32 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 14 "/usr/include/_G_config.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 15 "/usr/include/_G_config.h" 2 3 4
# 26 "/usr/include/_G_config.h" 3 4
typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
# 44 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/gconv.h" 1 3 4
# 31 "/usr/include/gconv.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 32 "/usr/include/gconv.h" 2 3 4





enum
{
  __GCONV_OK = 0,
  __GCONV_NOCONV,
  __GCONV_NODB,
  __GCONV_NOMEM,

  __GCONV_EMPTY_INPUT,
  __GCONV_FULL_OUTPUT,
  __GCONV_ILLEGAL_INPUT,
  __GCONV_INCOMPLETE_INPUT,

  __GCONV_ILLEGAL_DESCRIPTOR,
  __GCONV_INTERNAL_ERROR
};



enum
{
  __GCONV_IS_LAST = 0x0001,
  __GCONV_IGNORE_ERRORS = 0x0002
};



struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;



typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
                            __const unsigned char **, __const unsigned char *,
                            unsigned char **, size_t *, int, int);


typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);


typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);



typedef int (*__gconv_trans_fct) (struct __gconv_step *,
                                  struct __gconv_step_data *, void *,
                                  __const unsigned char *,
                                  __const unsigned char **,
                                  __const unsigned char *, unsigned char **,
                                  size_t *);


typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
                                          __const unsigned char *,
                                          unsigned char *, unsigned char *);


typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
                                        size_t *);


typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);

struct __gconv_trans_data
{

  __gconv_trans_fct __trans_fct;
  __gconv_trans_context_fct __trans_context_fct;
  __gconv_trans_end_fct __trans_end_fct;
  void *__data;
  struct __gconv_trans_data *__next;
};



struct __gconv_step
{
  struct __gconv_loaded_object *__shlib_handle;
  __const char *__modname;

  int __counter;

  char *__from_name;
  char *__to_name;

  __gconv_fct __fct;
  __gconv_btowc_fct __btowc_fct;
  __gconv_init_fct __init_fct;
  __gconv_end_fct __end_fct;



  int __min_needed_from;
  int __max_needed_from;
  int __min_needed_to;
  int __max_needed_to;


  int __stateful;

  void *__data;
};



struct __gconv_step_data
{
  unsigned char *__outbuf;
  unsigned char *__outbufend;



  int __flags;



  int __invocation_counter;



  int __internal_use;

  __mbstate_t *__statep;
  __mbstate_t __state;



  struct __gconv_trans_data *__trans;
};



typedef struct __gconv_info
{
  size_t __nsteps;
  struct __gconv_step *__steps;
  __extension__ struct __gconv_step_data __data [];
} *__gconv_t;
# 45 "/usr/include/_G_config.h" 2 3 4
typedef union
{
  struct __gconv_info __cd;
  struct
  {
    struct __gconv_info __cd;
    struct __gconv_step_data __data;
  } __combined;
} _G_iconv_t;

typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 33 "/usr/include/libio.h" 2 3 4
# 163 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 173 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 196 "/usr/include/libio.h" 3 4
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 264 "/usr/include/libio.h" 3 4
struct _IO_FILE {
  int _flags;




  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;



  int _flags2;

  __off_t _old_offset;



  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 312 "/usr/include/libio.h" 3 4
  __off64_t _offset;





  void *__pad1;
  void *__pad2;

  int _mode;

  char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];

};





struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 351 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
                                 size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);


typedef int __io_close_fn (void *__cookie);




typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;


typedef struct
{
  __io_read_fn *read;
  __io_write_fn *write;
  __io_seek_fn *seek;
  __io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;

struct _IO_cookie_file;


extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
                             void *__cookie, _IO_cookie_io_functions_t __fns);




extern "C" {


extern int __underflow (_IO_FILE *) throw ();
extern int __uflow (_IO_FILE *) throw ();
extern int __overflow (_IO_FILE *, int) throw ();
extern wint_t __wunderflow (_IO_FILE *) throw ();
extern wint_t __wuflow (_IO_FILE *) throw ();
extern wint_t __woverflow (_IO_FILE *, wint_t) throw ();
# 433 "/usr/include/libio.h" 3 4
extern int _IO_getc (_IO_FILE *__fp) throw ();
extern int _IO_putc (int __c, _IO_FILE *__fp) throw ();
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();

extern int _IO_peekc_locked (_IO_FILE *__fp) throw ();





extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
# 463 "/usr/include/libio.h" 3 4
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
                        __gnuc_va_list, int *__restrict) throw ();
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
                         __gnuc_va_list) throw ();
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) throw ();
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) throw ();

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) throw ();
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) throw ();

extern void _IO_free_backup_area (_IO_FILE *) throw ();
# 521 "/usr/include/libio.h" 3 4
}
# 73 "/usr/include/stdio.h" 2 3 4
# 86 "/usr/include/stdio.h" 3 4




typedef _G_fpos64_t fpos_t;



typedef _G_fpos64_t fpos64_t;
# 138 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 139 "/usr/include/stdio.h" 2 3 4



extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;







extern int remove (__const char *__filename) throw ();

extern int rename (__const char *__old, __const char *__new) throw ();




# 167 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void) __asm__ ("" "tmpfile64");






extern FILE *tmpfile64 (void);



extern char *tmpnam (char *__s) throw ();





extern char *tmpnam_r (char *__s) throw ();
# 196 "/usr/include/stdio.h" 3 4
extern char *tempnam (__const char *__dir, __const char *__pfx)
     throw () __attribute__ ((__malloc__));








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

# 221 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 231 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);




# 252 "/usr/include/stdio.h" 3 4
extern FILE *fopen (__const char *__restrict __filename, __const char *__restrict __modes) __asm__ ("" "fopen64");

extern FILE *freopen (__const char *__restrict __filename, __const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64");









extern FILE *fopen64 (__const char *__restrict __filename,
                      __const char *__restrict __modes);
extern FILE *freopen64 (__const char *__restrict __filename,
                        __const char *__restrict __modes,
                        FILE *__restrict __stream);




extern FILE *fdopen (int __fd, __const char *__modes) throw ();





extern FILE *fopencookie (void *__restrict __magic_cookie,
                          __const char *__restrict __modes,
                          _IO_cookie_io_functions_t __io_funcs) throw ();


extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes) throw ();




extern FILE *open_memstream (char **__restrict __bufloc,
                             size_t *__restrict __sizeloc) throw ();






extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
                    int __modes, size_t __n) throw ();





extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
                       size_t __size) throw ();


extern void setlinebuf (FILE *__stream) throw ();








extern int fprintf (FILE *__restrict __stream,
                    __const char *__restrict __format, ...);




extern int printf (__const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,
                    __const char *__restrict __format, ...) throw ();





extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg);




extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);

extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg) throw ();





extern int snprintf (char *__restrict __s, size_t __maxlen,
                     __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
                      __const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 3, 0)));






extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
                      __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern int __asprintf (char **__restrict __ptr,
                       __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int asprintf (char **__restrict __ptr,
                     __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));







extern int vdprintf (int __fd, __const char *__restrict __fmt,
                     __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));








extern int fscanf (FILE *__restrict __stream,
                   __const char *__restrict __format, ...);




extern int scanf (__const char *__restrict __format, ...);

extern int sscanf (__const char *__restrict __s,
                   __const char *__restrict __format, ...) throw ();








extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
                    __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 2, 0)));





extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 1, 0)));


extern int vsscanf (__const char *__restrict __s,
                    __const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));









extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);





extern int getchar (void);

# 454 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 465 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);











extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);





extern int putchar (int __c);

# 498 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream);


extern int putw (int __w, FILE *__stream);








extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream);






extern char *gets (char *__s);

# 543 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
                             FILE *__restrict __stream);
# 559 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
                               size_t *__restrict __n, int __delimiter,
                               FILE *__restrict __stream);
extern __ssize_t getdelim (char **__restrict __lineptr,
                             size_t *__restrict __n, int __delimiter,
                             FILE *__restrict __stream);







extern __ssize_t getline (char **__restrict __lineptr,
                            size_t *__restrict __n,
                            FILE *__restrict __stream);








extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);





extern int puts (__const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
                     size_t __n, FILE *__restrict __stream);




extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
                      size_t __n, FILE *__restrict __s);

# 620 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (__const char *__restrict __s,
                           FILE *__restrict __stream);
# 631 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
                              size_t __n, FILE *__restrict __stream);
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
                               size_t __n, FILE *__restrict __stream);








extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream);




extern void rewind (FILE *__stream);

# 675 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64");


extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");








# 700 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64");

extern int fsetpos (FILE *__stream, __const fpos_t *__pos) __asm__ ("" "fsetpos64");









extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream);
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);




extern void clearerr (FILE *__stream) throw ();

extern int feof (FILE *__stream) throw ();

extern int ferror (FILE *__stream) throw ();




extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw ();
extern int ferror_unlocked (FILE *__stream) throw ();








extern void perror (__const char *__s);






# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 27 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern __const char *__const sys_errlist[];


extern int _sys_nerr;
extern __const char *__const _sys_errlist[];
# 748 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) throw ();




extern int fileno_unlocked (FILE *__stream) throw ();
# 767 "/usr/include/stdio.h" 3 4
extern FILE *popen (__const char *__command, __const char *__modes);





extern int pclose (FILE *__stream);





extern char *ctermid (char *__s) throw ();





extern char *cuserid (char *__s);




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
                           __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
                            __const char *__restrict __format,
                            __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));







extern void flockfile (FILE *__stream) throw ();



extern int ftrylockfile (FILE *__stream) throw ();


extern void funlockfile (FILE *__stream) throw ();
# 828 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 33 "/usr/include/bits/stdio.h" 3 4
inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}


inline int
getchar (void)
{
  return _IO_getc (stdin);
}




inline int
getc_unlocked (FILE *__fp)
{
  return ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


inline int
getchar_unlocked (void)
{
  return ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




inline int
putchar (int __c)
{
  return _IO_putc (__c, stdout);
}




inline int
fputc_unlocked (int __c, FILE *__stream)
{
  return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





inline int
putc_unlocked (int __c, FILE *__stream)
{
  return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


inline int
putchar_unlocked (int __c)
{
  return (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}





inline __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
  return __getdelim (__lineptr, __n, '\n', __stream);
}





inline int
feof_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x10) != 0);
}


inline int
ferror_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x20) != 0);
}
# 829 "/usr/include/stdio.h" 2 3 4


}
# 56 "/usr/include/wx/string.h" 2 3 4

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/limits.h" 1 3 4
# 58 "/usr/include/wx/string.h" 2 3 4
# 1 "/usr/include/stdlib.h" 1 3 4
# 33 "/usr/include/stdlib.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 34 "/usr/include/stdlib.h" 2 3 4

extern "C" {






# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 43 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 65 "/usr/include/bits/waitstatus.h" 3 4
union wait
  {
    int w_status;
    struct
      {

        unsigned int __w_termsig:7;
        unsigned int __w_coredump:1;
        unsigned int __w_retcode:8;
        unsigned int:16;







      } __wait_terminated;
    struct
      {

        unsigned int __w_stopval:8;
        unsigned int __w_stopsig:8;
        unsigned int:16;






      } __wait_stopped;
  };
# 44 "/usr/include/stdlib.h" 2 3 4
# 93 "/usr/include/stdlib.h" 3 4


typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;







__extension__ typedef struct
  {
    long long int quot;
    long long int rem;
  } lldiv_t;


# 137 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw ();




extern double atof (__const char *__nptr) throw () __attribute__ ((__pure__));

extern int atoi (__const char *__nptr) throw () __attribute__ ((__pure__));

extern long int atol (__const char *__nptr) throw () __attribute__ ((__pure__));





__extension__ extern long long int atoll (__const char *__nptr)
     throw () __attribute__ ((__pure__));





extern double strtod (__const char *__restrict __nptr,
                      char **__restrict __endptr) throw ();





extern float strtof (__const char *__restrict __nptr,
                     char **__restrict __endptr) throw ();

extern long double strtold (__const char *__restrict __nptr,
                            char **__restrict __endptr) throw ();





extern long int strtol (__const char *__restrict __nptr,
                        char **__restrict __endptr, int __base) throw ();

extern unsigned long int strtoul (__const char *__restrict __nptr,
                                  char **__restrict __endptr, int __base)
     throw ();




__extension__
extern long long int strtoq (__const char *__restrict __nptr,
                             char **__restrict __endptr, int __base) throw ();

__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
                                       char **__restrict __endptr, int __base)
     throw ();





__extension__
extern long long int strtoll (__const char *__restrict __nptr,
                              char **__restrict __endptr, int __base) throw ();

__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
                                        char **__restrict __endptr, int __base)
     throw ();

# 229 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (__const char *__restrict __nptr,
                          char **__restrict __endptr, int __base,
                          __locale_t __loc) throw ();

extern unsigned long int strtoul_l (__const char *__restrict __nptr,
                                    char **__restrict __endptr,
                                    int __base, __locale_t __loc) throw ();

__extension__
extern long long int strtoll_l (__const char *__restrict __nptr,
                                char **__restrict __endptr, int __base,
                                __locale_t __loc) throw ();

__extension__
extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
                                          char **__restrict __endptr,
                                          int __base, __locale_t __loc)
     throw ();

extern double strtod_l (__const char *__restrict __nptr,
                        char **__restrict __endptr, __locale_t __loc)
     throw ();

extern float strtof_l (__const char *__restrict __nptr,
                       char **__restrict __endptr, __locale_t __loc) throw ();

extern long double strtold_l (__const char *__restrict __nptr,
                              char **__restrict __endptr,
                              __locale_t __loc) throw ();






extern double __strtod_internal (__const char *__restrict __nptr,
                                 char **__restrict __endptr, int __group)
     throw ();
extern float __strtof_internal (__const char *__restrict __nptr,
                                char **__restrict __endptr, int __group)
     throw ();
extern long double __strtold_internal (__const char *__restrict __nptr,
                                       char **__restrict __endptr,
                                       int __group) throw ();

extern long int __strtol_internal (__const char *__restrict __nptr,
                                   char **__restrict __endptr,
                                   int __base, int __group) throw ();



extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
                                             char **__restrict __endptr,
                                             int __base, int __group) throw ();




__extension__
extern long long int __strtoll_internal (__const char *__restrict __nptr,
                                         char **__restrict __endptr,
                                         int __base, int __group) throw ();



__extension__
extern unsigned long long int __strtoull_internal (__const char *
                                                   __restrict __nptr,
                                                   char **__restrict __endptr,
                                                   int __base, int __group)
     throw ();








extern __inline double
strtod (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtod_internal (__nptr, __endptr, 0);
}
extern __inline long int
strtol (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base) throw ()
{
  return __strtol_internal (__nptr, __endptr, __base, 0);
}
extern __inline unsigned long int
strtoul (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base) throw ()
{
  return __strtoul_internal (__nptr, __endptr, __base, 0);
}




extern __inline float
strtof (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtof_internal (__nptr, __endptr, 0);
}
extern __inline long double
strtold (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtold_internal (__nptr, __endptr, 0);
}




__extension__ extern __inline long long int
strtoq (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base) throw ()
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtouq (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base) throw ()
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}




__extension__ extern __inline long long int
strtoll (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base) throw ()
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtoull (__const char * __restrict __nptr, char **__restrict __endptr,
          int __base) throw ()
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}




extern __inline double
atof (__const char *__nptr) throw ()
{
  return strtod (__nptr, (char **) __null);
}
extern __inline int
atoi (__const char *__nptr) throw ()
{
  return (int) strtol (__nptr, (char **) __null, 10);
}
extern __inline long int
atol (__const char *__nptr) throw ()
{
  return strtol (__nptr, (char **) __null, 10);
}




__extension__ extern __inline long long int
atoll (__const char *__nptr) throw ()
{
  return strtoll (__nptr, (char **) __null, 10);
}

# 408 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw ();


extern long int a64l (__const char *__s) throw () __attribute__ ((__pure__));




# 1 "/usr/include/sys/types.h" 1 3 4
# 29 "/usr/include/sys/types.h" 3 4
extern "C" {





typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;




typedef __loff_t loff_t;





typedef __ino64_t ino_t;




typedef __ino64_t ino64_t;




typedef __dev_t dev_t;




typedef __gid_t gid_t;




typedef __mode_t mode_t;




typedef __nlink_t nlink_t;




typedef __uid_t uid_t;







typedef __off64_t off_t;




typedef __off64_t off64_t;




typedef __pid_t pid_t;




typedef __id_t id_t;




typedef __ssize_t ssize_t;





typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;
# 133 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/time.h" 1 3 4
# 58 "/usr/include/time.h" 3 4


typedef __clock_t clock_t;



# 74 "/usr/include/time.h" 3 4


typedef __time_t time_t;



# 92 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
# 104 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
# 134 "/usr/include/sys/types.h" 2 3 4



typedef __useconds_t useconds_t;



typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 148 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 191 "/usr/include/sys/types.h" 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 216 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/sys/select.h" 1 3 4
# 31 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/bits/select.h" 1 3 4
# 32 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 23 "/usr/include/bits/sigset.h" 3 4
typedef int __sig_atomic_t;




typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 35 "/usr/include/sys/select.h" 2 3 4



typedef __sigset_t sigset_t;





# 1 "/usr/include/time.h" 1 3 4
# 118 "/usr/include/time.h" 3 4
struct timespec
  {
    __time_t tv_sec;
    long int tv_nsec;
  };
# 45 "/usr/include/sys/select.h" 2 3 4

# 1 "/usr/include/bits/time.h" 1 3 4
# 69 "/usr/include/bits/time.h" 3 4
struct timeval
  {
    __time_t tv_sec;
    __suseconds_t tv_usec;
  };
# 47 "/usr/include/sys/select.h" 2 3 4
# 55 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;
# 67 "/usr/include/sys/select.h" 3 4
typedef struct
  {



    __fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))];





  } fd_set;






typedef __fd_mask fd_mask;
# 99 "/usr/include/sys/select.h" 3 4
extern "C" {
# 109 "/usr/include/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
                   fd_set *__restrict __writefds,
                   fd_set *__restrict __exceptfds,
                   struct timeval *__restrict __timeout);
# 121 "/usr/include/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
                    fd_set *__restrict __writefds,
                    fd_set *__restrict __exceptfds,
                    const struct timespec *__restrict __timeout,
                    const __sigset_t *__restrict __sigmask);


}
# 217 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 29 "/usr/include/sys/sysmacros.h" 3 4
__extension__
extern __inline unsigned int gnu_dev_major (unsigned long long int __dev)
     throw ();
__extension__
extern __inline unsigned int gnu_dev_minor (unsigned long long int __dev)
     throw ();
__extension__
extern __inline unsigned long long int gnu_dev_makedev (unsigned int __major,
                                                        unsigned int __minor)
     throw ();


__extension__ extern __inline unsigned int
gnu_dev_major (unsigned long long int __dev) throw ()
{
  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
}

__extension__ extern __inline unsigned int
gnu_dev_minor (unsigned long long int __dev) throw ()
{
  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
}

__extension__ extern __inline unsigned long long int
gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
{
  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
          | (((unsigned long long int) (__minor & ~0xff)) << 12)
          | (((unsigned long long int) (__major & ~0xfff)) << 32));
}
# 220 "/usr/include/sys/types.h" 2 3 4




typedef __blksize_t blksize_t;
# 244 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt_t;



typedef __fsblkcnt64_t fsblkcnt_t;



typedef __fsfilcnt64_t fsfilcnt_t;





typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;





# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/bits/sched.h" 1 3 4
# 83 "/usr/include/bits/sched.h" 3 4
struct __sched_param
  {
    int __sched_priority;
  };
# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4


struct _pthread_fastlock
{
  long int __status;
  int __spinlock;

};



typedef struct _pthread_descr_struct *_pthread_descr;





typedef struct __pthread_attr_s
{
  int __detachstate;
  int __schedpolicy;
  struct __sched_param __schedparam;
  int __inheritsched;
  int __scope;
  size_t __guardsize;
  int __stackaddr_set;
  void *__stackaddr;
  size_t __stacksize;
} pthread_attr_t;





__extension__ typedef long long __pthread_cond_align_t;




typedef struct
{
  struct _pthread_fastlock __c_lock;
  _pthread_descr __c_waiting;
  char __padding[48 - sizeof (struct _pthread_fastlock)
                 - sizeof (_pthread_descr) - sizeof (__pthread_cond_align_t)];
  __pthread_cond_align_t __align;
} pthread_cond_t;



typedef struct
{
  int __dummy;
} pthread_condattr_t;


typedef unsigned int pthread_key_t;





typedef struct
{
  int __m_reserved;
  int __m_count;
  _pthread_descr __m_owner;
  int __m_kind;
  struct _pthread_fastlock __m_lock;
} pthread_mutex_t;



typedef struct
{
  int __mutexkind;
} pthread_mutexattr_t;



typedef int pthread_once_t;




typedef struct _pthread_rwlock_t
{
  struct _pthread_fastlock __rw_lock;
  int __rw_readers;
  _pthread_descr __rw_writer;
  _pthread_descr __rw_read_waiting;
  _pthread_descr __rw_write_waiting;
  int __rw_kind;
  int __rw_pshared;
} pthread_rwlock_t;



typedef struct
{
  int __lockkind;
  int __pshared;
} pthread_rwlockattr_t;




typedef volatile int pthread_spinlock_t;


typedef struct {
  struct _pthread_fastlock __ba_lock;
  int __ba_required;
  int __ba_present;
  _pthread_descr __ba_waiting;
} pthread_barrier_t;


typedef struct {
  int __pshared;
} pthread_barrierattr_t;





typedef unsigned long int pthread_t;
# 267 "/usr/include/sys/types.h" 2 3 4


}
# 417 "/usr/include/stdlib.h" 2 3 4






extern long int random (void) throw ();


extern void srandom (unsigned int __seed) throw ();





extern char *initstate (unsigned int __seed, char *__statebuf,
                        size_t __statelen) throw ();



extern char *setstate (char *__statebuf) throw ();







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
                     int32_t *__restrict __result) throw ();

extern int srandom_r (unsigned int __seed, struct random_data *__buf) throw ();

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
                        size_t __statelen,
                        struct random_data *__restrict __buf) throw ();

extern int setstate_r (char *__restrict __statebuf,
                       struct random_data *__restrict __buf) throw ();






extern int rand (void) throw ();

extern void srand (unsigned int __seed) throw ();




extern int rand_r (unsigned int *__seed) throw ();







extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw ();


extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3]) throw ();


extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3]) throw ();


extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3]) throw ();
extern void lcong48 (unsigned short int __param[7]) throw ();





struct drand48_data
  {
    unsigned short int __x[3];
    unsigned short int __old_x[3];
    unsigned short int __c;
    unsigned short int __init;
    unsigned long long int __a;
  };


extern int drand48_r (struct drand48_data *__restrict __buffer,
                      double *__restrict __result) throw ();
extern int erand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      double *__restrict __result) throw ();


extern int lrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) throw ();
extern int nrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) throw ();


extern int mrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) throw ();
extern int jrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) throw ();


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     throw ();

extern int seed48_r (unsigned short int __seed16v[3],
                     struct drand48_data *__buffer) throw ();

extern int lcong48_r (unsigned short int __param[7],
                      struct drand48_data *__buffer) throw ();









extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__));

extern void *calloc (size_t __nmemb, size_t __size)
     throw () __attribute__ ((__malloc__));







extern void *realloc (void *__ptr, size_t __size) throw () __attribute__ ((__malloc__));

extern void free (void *__ptr) throw ();




extern void cfree (void *__ptr) throw ();



# 1 "/usr/include/alloca.h" 1 3 4
# 25 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 26 "/usr/include/alloca.h" 2 3 4

extern "C" {





extern void *alloca (size_t __size) throw ();





}
# 579 "/usr/include/stdlib.h" 2 3 4




extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__));




extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     throw () __attribute__ ((__malloc__));




extern void abort (void) throw () __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) throw ();





extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     throw ();






extern void exit (int __status) throw () __attribute__ ((__noreturn__));






extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));






extern char *getenv (__const char *__name) throw ();




extern char *__secure_getenv (__const char *__name) throw ();





extern int putenv (char *__string) throw ();





extern int setenv (__const char *__name, __const char *__value, int __replace)
     throw ();


extern int unsetenv (__const char *__name) throw ();






extern int clearenv (void) throw ();
# 663 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw ();
# 677 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __asm__ ("" "mkstemp64");





extern int mkstemp64 (char *__template);
# 693 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw ();








extern int system (__const char *__command);







extern char *canonicalize_file_name (__const char *__name) throw ();
# 720 "/usr/include/stdlib.h" 3 4
extern char *realpath (__const char *__restrict __name,
                       char *__restrict __resolved) throw ();






typedef int (*__compar_fn_t) (__const void *, __const void *);


typedef __compar_fn_t comparison_fn_t;






extern void *bsearch (__const void *__key, __const void *__base,
                      size_t __nmemb, size_t __size, __compar_fn_t __compar);



extern void qsort (void *__base, size_t __nmemb, size_t __size,
                   __compar_fn_t __compar);



extern int abs (int __x) throw () __attribute__ ((__const__));
extern long int labs (long int __x) throw () __attribute__ ((__const__));



__extension__ extern long long int llabs (long long int __x)
     throw () __attribute__ ((__const__));







extern div_t div (int __numer, int __denom)
     throw () __attribute__ ((__const__));
extern ldiv_t ldiv (long int __numer, long int __denom)
     throw () __attribute__ ((__const__));




__extension__ extern lldiv_t lldiv (long long int __numer,
                                    long long int __denom)
     throw () __attribute__ ((__const__));

# 784 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) throw ();




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) throw ();




extern char *gcvt (double __value, int __ndigit, char *__buf) throw ();




extern char *qecvt (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign) throw ();
extern char *qfcvt (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign) throw ();
extern char *qgcvt (long double __value, int __ndigit, char *__buf) throw ();




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) throw ();
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) throw ();

extern int qecvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len) throw ();
extern int qfcvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len) throw ();







extern int mblen (__const char *__s, size_t __n) throw ();


extern int mbtowc (wchar_t *__restrict __pwc,
                   __const char *__restrict __s, size_t __n) throw ();


extern int wctomb (char *__s, wchar_t __wchar) throw ();



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
                        __const char *__restrict __s, size_t __n) throw ();

extern size_t wcstombs (char *__restrict __s,
                        __const wchar_t *__restrict __pwcs, size_t __n)
     throw ();








extern int rpmatch (__const char *__response) throw ();
# 866 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
                      char *__const *__restrict __tokens,
                      char **__restrict __valuep) throw ();





extern void setkey (__const char *__key) throw ();







extern int posix_openpt (int __oflag);







extern int grantpt (int __fd) throw ();



extern int unlockpt (int __fd) throw ();




extern char *ptsname (int __fd) throw ();






extern int ptsname_r (int __fd, char *__buf, size_t __buflen) throw ();


extern int getpt (void);






extern int getloadavg (double __loadavg[], int __nelem) throw ();





}
# 59 "/usr/include/wx/string.h" 2 3 4



# 1 "/usr/include/strings.h" 1 3 4
# 63 "/usr/include/wx/string.h" 2 3 4



# 1 "/usr/include/wx/buffer.h" 1 3 4
# 98 "/usr/include/wx/buffer.h" 3 4
class wxCharBuffer { public: wxCharBuffer(const char *str) : m_str(str ? strdup(str) : __null) { } wxCharBuffer(size_t len) : m_str((char *)malloc((len + 1)*sizeof(char))) { m_str[len] = (char)0; } ~wxCharBuffer() { free(m_str); } char *release() const { char *p = m_str; ((wxCharBuffer *)this)->m_str = __null; return p; } wxCharBuffer(const wxCharBuffer& src) : m_str(src.release()) { } wxCharBuffer& operator=(const char *str) { free(m_str); m_str = str ? strdup(str) : __null; return *this; } wxCharBuffer& operator=(const wxCharBuffer& src) { free(m_str); m_str = src.release(); return *this; } char *data() { return m_str; } const char *data() const { return m_str; } operator const char *() const { return m_str; } char operator[](size_t n) const { return m_str[n]; } private: char *m_str; };



inline wchar_t *wxWcsdupReplacement(const wchar_t *wcs)
{
    const size_t siz = (wcslen(wcs) + 1)*sizeof(wchar_t);
    wchar_t *wcsCopy = (wchar_t *)malloc(siz);
    memcpy(wcsCopy, wcs, siz);
    return wcsCopy;
}

class wxWCharBuffer { public: wxWCharBuffer(const wchar_t *str) : m_str(str ? wxWcsdupReplacement(str) : __null) { } wxWCharBuffer(size_t len) : m_str((wchar_t *)malloc((len + 1)*sizeof(wchar_t))) { m_str[len] = (wchar_t)0; } ~wxWCharBuffer() { free(m_str); } wchar_t *release() const { wchar_t *p = m_str; ((wxWCharBuffer *)this)->m_str = __null; return p; } wxWCharBuffer(const wxWCharBuffer& src) : m_str(src.release()) { } wxWCharBuffer& operator=(const wchar_t *str) { free(m_str); m_str = str ? wxWcsdupReplacement(str) : __null; return *this; } wxWCharBuffer& operator=(const wxWCharBuffer& src) { free(m_str); m_str = src.release(); return *this; } wchar_t *data() { return m_str; } const wchar_t *data() const { return m_str; } operator const wchar_t *() const { return m_str; } wchar_t operator[](size_t n) const { return m_str[n]; } private: wchar_t *m_str; };
# 133 "/usr/include/wx/buffer.h" 3 4
class wxMemoryBufferData
{
public:

    enum { BLOCK_SIZE = 1024 };

    friend class wxMemoryBuffer;


private:
    wxMemoryBufferData(size_t size = wxMemoryBufferData::BLOCK_SIZE)
        : m_data(size ? malloc(size) : __null), m_size(size), m_len(0), m_ref(0)
    {
    }
    ~wxMemoryBufferData() { free(m_data); }


    void ResizeIfNeeded(size_t newSize)
    {
        if (newSize > m_size)
        {
            void *dataOld = m_data;
            m_data = realloc(m_data, newSize + wxMemoryBufferData::BLOCK_SIZE);
            if ( !m_data )
            {
                free(dataOld);
            }

            m_size = newSize + wxMemoryBufferData::BLOCK_SIZE;
        }
    }

    void IncRef() { m_ref += 1; }
    void DecRef()
    {
        m_ref -= 1;
        if (m_ref == 0)
            delete this;
    }



    void *m_data;


    size_t m_size;


    size_t m_len;


    size_t m_ref;
};


class wxMemoryBuffer
{
public:

    wxMemoryBuffer(size_t size = wxMemoryBufferData::BLOCK_SIZE)
    {
        m_bufdata = new wxMemoryBufferData(size);
        m_bufdata->IncRef();
    }

    ~wxMemoryBuffer() { m_bufdata->DecRef(); }



    wxMemoryBuffer(const wxMemoryBuffer& src)
        : m_bufdata(src.m_bufdata)
    {
        m_bufdata->IncRef();
    }

    wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
    {
        m_bufdata->DecRef();
        m_bufdata = src.m_bufdata;
        m_bufdata->IncRef();
        return *this;
    }



    void *GetData() const { return m_bufdata->m_data; }
    size_t GetBufSize() const { return m_bufdata->m_size; }
    size_t GetDataLen() const { return m_bufdata->m_len; }

    void SetBufSize(size_t size) { m_bufdata->ResizeIfNeeded(size); }
    void SetDataLen(size_t len)
    {
        ;
        m_bufdata->m_len = len;
    }


    void *GetWriteBuf(size_t sizeNeeded)
    {
        m_bufdata->ResizeIfNeeded(sizeNeeded);
        return m_bufdata->m_data;
    }


    void UngetWriteBuf(size_t sizeUsed) { SetDataLen(sizeUsed); }


    void *GetAppendBuf(size_t sizeNeeded)
    {
        m_bufdata->ResizeIfNeeded(m_bufdata->m_len + sizeNeeded);
        return (char*)m_bufdata->m_data + m_bufdata->m_len;
    }


    void UngetAppendBuf(size_t sizeUsed)
    {
        SetDataLen(m_bufdata->m_len + sizeUsed);
    }


    void AppendByte(char data)
    {
        if (!(m_bufdata->m_data)) {; return; };

        m_bufdata->ResizeIfNeeded(m_bufdata->m_len + 1);
        *(((char*)m_bufdata->m_data) + m_bufdata->m_len) = data;
        m_bufdata->m_len += 1;
    }

    void AppendData(void* data, size_t len)
    {
        memcpy(GetAppendBuf(len), data, len);
        UngetAppendBuf(len);
    }

    operator const char *() const { return (const char*)GetData(); }

private:
    wxMemoryBufferData* m_bufdata;
};
# 67 "/usr/include/wx/string.h" 2 3 4
# 1 "/usr/include/wx/strconv.h" 1 3 4
# 16 "/usr/include/wx/strconv.h" 3 4
#pragma interface "strconv.h"
# 35 "/usr/include/wx/strconv.h" 3 4
class wxMBConv
{
public:

    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;


    const wxWCharBuffer cMB2WC(const char *psz) const;
    const wxCharBuffer cWC2MB(const wchar_t *psz) const;







    const char* cMB2WX(const char *psz) const { return psz; }
    const char* cWX2MB(const char *psz) const { return psz; }
    const wxCharBuffer cWC2WX(const wchar_t *psz) const { return cWC2MB(psz); }
    const wxWCharBuffer cWX2WC(const char *psz) const { return cMB2WC(psz); }



    virtual ~wxMBConv();
};

extern wxMBConv wxConvLibc;





class wxMBConvUTF7 : public wxMBConv
{
public:
    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
};

extern wxMBConvUTF7 wxConvUTF7;





class wxMBConvUTF8 : public wxMBConv
{
public:
    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
};

extern wxMBConvUTF8 wxConvUTF8;







class wxMBConvGdk : public wxMBConv
{
public:
    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
};

extern wxMBConvGdk wxConvGdk;







class wxCharacterSet;

class wxCSConv : public wxMBConv
{
public:
    wxCSConv(const wxChar *charset);
    wxCSConv(const wxCSConv& conv);
    virtual ~wxCSConv();

    wxCSConv& operator=(const wxCSConv& conv);

    void LoadNow();

    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;

    void Clear() ;

private:
    void SetName(const wxChar *charset);



    wxChar *m_name;
    wxCharacterSet *m_cset;
    bool m_deferred;
};


extern wxCSConv wxConvLocal;
extern wxCSConv wxConvISO8859_1;
extern wxMBConv * wxConvCurrent;
# 68 "/usr/include/wx/string.h" 2 3 4
# 95 "/usr/include/wx/string.h" 3 4
const unsigned int wxSTRING_MAXLEN = (2147483647 * 2U + 1U) - 100;
# 104 "/usr/include/wx/string.h" 3 4
extern const wxChar* wxEmptyString;
# 115 "/usr/include/wx/string.h" 3 4
inline bool IsEmpty(const char *p) { return (!p || !*p); }


inline size_t Strlen(const char *psz)
  { return psz ? strlen(psz) : 0; }


inline int Stricmp(const char *psz1, const char *psz2)
{
# 141 "/usr/include/wx/string.h" 3 4
  return strcasecmp(psz1, psz2);
# 166 "/usr/include/wx/string.h" 3 4
}


class wxString;
inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }






struct wxStringData
{
  int nRefs;
  size_t nDataLength,
          nAllocLength;


  wxChar* data() const { return (wxChar*)(this + 1); }


  bool IsEmpty() const { return (nRefs == -1); }
  bool IsShared() const { return (nRefs > 1); }


  void Lock() { if ( !IsEmpty() ) nRefs++; }
# 204 "/usr/include/wx/string.h" 3 4
  void Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this); }




  void Validate(bool b) { nRefs = (b ? 1 : 0); }
  bool IsValid() const { return (nRefs != 0); }
};
# 236 "/usr/include/wx/string.h" 3 4
class wxString
{
friend class wxArrayString;




private:

  wxChar *m_pchData;


  wxStringData* GetStringData() const { return (wxStringData*)m_pchData - 1; }




  void Init() { m_pchData = (wxChar *)wxEmptyString; }

  void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = wxSTRING_MAXLEN);

  void Reinit() { GetStringData()->Unlock(); Init(); }



  bool AllocBuffer(size_t nLen);

  bool AllocCopy(wxString&, int, int) const;

  bool AssignCopy(size_t, const wxChar *);


  bool ConcatSelf(int nLen, const wxChar *src);



  bool CopyBeforeWrite();
  bool AllocBeforeWrite(size_t);
# 282 "/usr/include/wx/string.h" 3 4
  wxString& operator=(int);





  wxString(int);

public:


  wxString() : m_pchData(__null) { Init(); }

  wxString(const wxString& stringSrc) : m_pchData(__null)
  {
    ;


    if ( stringSrc.IsEmpty() ) {

      Init();
    }
    else {
      m_pchData = stringSrc.m_pchData;
      GetStringData()->Lock();
    }
  }

  wxString(wxChar ch, size_t nRepeat = 1);


  wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)
      : m_pchData(__null)
      { InitWith(psz, 0, nLength); }
  wxString(const wxChar *psz, wxMBConv& , size_t nLength = wxSTRING_MAXLEN)
      : m_pchData(__null)
      { InitWith(psz, 0, nLength); }
# 330 "/usr/include/wx/string.h" 3 4
  wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)
      : m_pchData(__null)
      { InitWith((const char*)psz, 0, nLength); }



  wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN);



  wxString(const wxCharBuffer& psz)
      : m_pchData(__null)
      { InitWith(psz, 0, wxSTRING_MAXLEN); }



 ~wxString() { GetStringData()->Unlock(); }



  size_t Len() const { return GetStringData()->nDataLength; }

  bool IsEmpty() const { return Len() == 0; }

  bool operator!() const { return IsEmpty(); }

  wxString& Truncate(size_t uiLen);

  void Empty()
  {
    Truncate(0);

    ;
  }

  void Clear()
  {
    if ( !GetStringData()->IsEmpty() )
      Reinit();

    ;


  }



  bool IsAscii() const;

  bool IsNumber() const;

  bool IsWord() const;



    wxChar GetChar(size_t n) const
      { ; return m_pchData[n]; }

    wxChar& GetWritableChar(size_t n)
      { ; CopyBeforeWrite(); return m_pchData[n]; }

    void SetChar(size_t n, wxChar ch)
      { ; CopyBeforeWrite(); m_pchData[n] = ch; }


    wxChar Last() const
      {
          ;

          return m_pchData[Len() - 1];
      }


    wxChar& Last()
      {
          ;
          CopyBeforeWrite();
          return m_pchData[Len()-1];
      }
# 433 "/usr/include/wx/string.h" 3 4
    wxChar operator[](size_t n) const
      { ; return m_pchData[n]; }


    wxChar operator[](int n) const
      { ; return m_pchData[n]; }


    wxChar& operator[](size_t n)
      { ; CopyBeforeWrite(); return m_pchData[n]; }
# 455 "/usr/include/wx/string.h" 3 4
    operator const wxChar*() const { return m_pchData; }


    const wxChar* c_str() const { return m_pchData; }

    const wxChar* wx_str() const { return m_pchData; }

    const wxChar* GetData() const { return m_pchData; }
# 475 "/usr/include/wx/string.h" 3 4
    static wxString FromAscii(const char *ascii) { return wxString( ascii ); }
    static wxString FromAscii(const char ascii) { return wxString( ascii ); }
    const char *ToAscii() const { return c_str(); }
# 506 "/usr/include/wx/string.h" 3 4
    const wxChar* mb_str() const { return m_pchData; }


    const wxChar* mb_str(wxMBConv& ) const { return m_pchData; }

    const wxChar* mbc_str() const { return mb_str(); }


    const wxWCharBuffer wc_str(wxMBConv& conv) const
        { return conv.cMB2WC(m_pchData); }


    const wxChar* fn_str() const { return m_pchData; }




  wxString& operator=(const wxString& stringSrc);

  wxString& operator=(wxChar ch);

  wxString& operator=(const wxChar *psz);






  wxString& operator=(const unsigned char* psz);


  wxString& operator=(const wchar_t *pwz);


  wxString& operator=(const wxCharBuffer& psz)
  { (void) operator=((const char *)psz); return *this; }
# 552 "/usr/include/wx/string.h" 3 4
  wxString& operator<<(const wxString& s)
  {
    ;


    ConcatSelf(s.Len(), s);
    return *this;
  }

  wxString& operator<<(const wxChar *psz)
    { ConcatSelf(wxStrlen(psz), psz); return *this; }

  wxString& operator<<(wxChar ch) { ConcatSelf(1, &ch); return *this; }


  void operator+=(const wxString& s) { (void)operator<<(s); }

  void operator+=(const wxChar *psz) { (void)operator<<(psz); }

  void operator+=(wxChar ch) { (void)operator<<(ch); }
# 580 "/usr/include/wx/string.h" 3 4
  wxString& operator<<(const wxCharBuffer& s)
    { (void)operator<<((const char *)s); return *this; }
  void operator+=(const wxCharBuffer& s)
    { (void)operator<<((const char *)s); }



  wxString& Append(const wxString& s)
    {

        if ( IsEmpty() )
            *this = s;
        else
            ConcatSelf(s.Length(), s.c_str());
        return *this;
    }
  wxString& Append(const wxChar* psz)
    { ConcatSelf(wxStrlen(psz), psz); return *this; }

  wxString& Append(wxChar ch, size_t count = 1u)
    { wxString str(ch, count); return *this << str; }
  wxString& Append(const wxChar* psz, size_t nLen)
    { ConcatSelf(nLen, psz); return *this; }


  wxString& Prepend(const wxString& str)
    { *this = str + *this; return *this; }



  friend wxString operator+(const wxString& string1, const wxString& string2);

  friend wxString operator+(const wxString& string, wxChar ch);

  friend wxString operator+(wxChar ch, const wxString& string);

  friend wxString operator+(const wxString& string, const wxChar *psz);

  friend wxString operator+(const wxChar *psz, const wxString& string);



  wxString& operator<<(int i)
    { return (*this) << Format("%d", i); }

  wxString& operator<<(unsigned int ui)
    { return (*this) << Format("%u", ui); }

  wxString& operator<<(long l)
    { return (*this) << Format("%ld", l); }

  wxString& operator<<(unsigned long ul)
    { return (*this) << Format("%lu", ul); }

  wxString& operator<<(float f)
    { return (*this) << Format("%f", f); }

  wxString& operator<<(double d)
    { return (*this) << Format("%g", d); }



  int Cmp(const wxChar *psz) const { return strcmp(c_str(), psz); }

  int CmpNoCase(const wxChar *psz) const { return strcasecmp(c_str(), psz); }


  bool IsSameAs(const wxChar *psz, bool compareWithCase = ((bool)1)) const
    { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }

  bool IsSameAs(wxChar c, bool compareWithCase = ((bool)1)) const
    {
      return (Len() == 1) && (compareWithCase ? GetChar(0u) == c
                              : toupper(GetChar(0u)) == toupper(c));
    }




  wxString Mid(size_t nFirst, size_t nCount = wxSTRING_MAXLEN) const;


  wxString operator()(size_t start, size_t len) const
    { return Mid(start, len); }




  bool StartsWith(const wxChar *prefix, wxString *rest = __null) const;


  wxString Left(size_t nCount) const;

  wxString Right(size_t nCount) const;


  wxString BeforeFirst(wxChar ch) const;


  wxString BeforeLast(wxChar ch) const;


  wxString AfterFirst(wxChar ch) const;


  wxString AfterLast(wxChar ch) const;


  wxString Before(wxChar ch) const { return BeforeLast(ch); }
  wxString After(wxChar ch) const { return AfterFirst(ch); }



  wxString& MakeUpper();


  wxString Upper() const ;

  wxString& MakeLower();

  wxString Lower() const ;



  wxString& Trim(bool bFromRight = ((bool)1));

  wxString& Pad(size_t nCount, wxChar chPad = ' ', bool bFromRight = ((bool)1));



  int Find(wxChar ch, bool bFromEnd = ((bool)0)) const;

  int Find(const wxChar *pszSub) const;


  size_t Replace(const wxChar *szOld,
                 const wxChar *szNew,
                 bool bReplaceAll = ((bool)1));


  bool Matches(const wxChar *szMask) const;







    bool ToLong(long *val, int base = 10) const;

    bool ToULong(unsigned long *val, int base = 10) const;

    bool ToDouble(double *val) const;




  int Printf(const wxChar *pszFormat, ...) __attribute__ ((__format__ (__printf__, 2, 3)));

  int PrintfV(const wxChar* pszFormat, va_list argptr);


  static wxString Format(const wxChar *pszFormat, ...) __attribute__ ((__format__ (__printf__, 1, 2)));

  static wxString FormatV(const wxChar *pszFormat, va_list argptr);




  bool Alloc(size_t nLen);


  bool Shrink();


  wxChar *GetWriteBuf(size_t nLen);

  void UngetWriteBuf();
  void UngetWriteBuf(size_t nLen);




  wxString SubString(size_t from, size_t to) const
      { return Mid(from, (to - from + 1)); }

  enum caseCompare {exact, ignoreCase};

  enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};



  int sprintf(const wxChar *pszFormat, ...) __attribute__ ((__format__ (__printf__, 2, 3)));


  inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
    { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }


  size_t Length() const { return Len(); }

  int Freq(wxChar ch) const;

  void LowerCase() { MakeLower(); }

  void UpperCase() { MakeUpper(); }

  wxString Strip(stripType w = trailing) const;


  size_t Index(const wxChar* psz) const { return Find(psz); }
  size_t Index(wxChar ch) const { return Find(ch); }

  wxString& Remove(size_t pos) { return Truncate(pos); }
  wxString& RemoveLast(size_t n = 1) { return Truncate(Len() - n); }

  wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }


  int First( const wxChar ch ) const { return Find(ch); }
  int First( const wxChar* psz ) const { return Find(psz); }
  int First( const wxString &str ) const { return Find(str); }
  int Last( const wxChar ch ) const { return Find(ch, ((bool)1)); }
  bool Contains(const wxString& str) const { return Find(str) != -1; }


  bool IsNull() const { return IsEmpty(); }





  typedef wxChar value_type;
  typedef const value_type *const_iterator;


  static const size_t npos;



  wxString(const wxString& str, size_t nPos, size_t nLen)
      : m_pchData(__null)
  {
    ;


    InitWith(str.c_str(), nPos, nLen == npos ? 0 : nLen);
  }

  wxString(const void *pStart, const void *pEnd);



  size_t size() const { return Len(); }

  size_t length() const { return Len(); }

  size_t max_size() const { return wxSTRING_MAXLEN; }

  void resize(size_t nSize, wxChar ch = '\0');

  void clear() { Empty(); }

  bool empty() const { return IsEmpty(); }

  void reserve(size_t sz) { Alloc(sz); }



  wxChar at(size_t n) const { return GetChar(n); }

  wxChar& at(size_t n) { return GetWritableChar(n); }


  const_iterator begin() const { return wx_str(); }

  const_iterator end() const { return wx_str() + length(); }



  wxString& append(const wxString& str)
    { *this += str; return *this; }

  wxString& append(const wxString& str, size_t pos, size_t n)
    { ConcatSelf(n, str.c_str() + pos); return *this; }

  wxString& append(const wxChar *sz, size_t n = npos)
    { ConcatSelf(n == npos ? wxStrlen(sz) : n, sz); return *this; }


  wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }


  wxString& assign(const wxString& str)
    { return *this = str; }

  wxString& assign(const wxString& str, size_t pos, size_t n)
    { Empty(); return Append(str.c_str() + pos, n); }

  wxString& assign(const wxChar *sz, size_t n = npos)
    { Empty(); return Append(sz, n == npos ? wxStrlen(sz) : n); }

  wxString& assign(size_t n, wxChar ch)
    { Empty(); return Append(ch, n); }


  wxString& insert(size_t nPos, const wxString& str);

  wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n)
    { return insert(nPos, wxString((const wxChar *)str + nStart, n)); }


  wxString& insert(size_t nPos, const wxChar *sz, size_t n = npos)
    { return insert(nPos, wxString(sz, n)); }

  wxString& insert(size_t nPos, size_t n, wxChar ch)
    { return insert(nPos, wxString(ch, n)); }


  wxString& erase(size_t nStart = 0, size_t nLen = npos);


  wxString& replace(size_t nStart, size_t nLen, const wxChar* sz);

  wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxChar ch);

  wxString& replace(size_t nStart, size_t nLen,
                    const wxString& str, size_t nStart2, size_t nLen2);

  wxString& replace(size_t nStart, size_t nLen,
                    const wxChar* sz, size_t nCount);


  void swap(wxString& str);






  size_t find(const wxString& str, size_t nStart = 0) const;




  size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const;





  size_t find(wxChar ch, size_t nStart = 0) const;




  size_t rfind(const wxString& str, size_t nStart = npos) const;




  size_t rfind(const wxChar* sz, size_t nStart = npos,
          size_t n = npos) const;

  size_t rfind(wxChar ch, size_t nStart = npos) const;





  size_t find_first_of(const wxString& str, size_t nStart = 0) const
    { return find_first_of(str.c_str(), nStart); }

  size_t find_first_of(const wxChar* sz, size_t nStart = 0) const;

  size_t find_first_of(wxChar c, size_t nStart = 0) const
    { return find(c, nStart); }

  size_t find_last_of (const wxString& str, size_t nStart = npos) const
    { return find_last_of(str.c_str(), nStart); }

  size_t find_last_of (const wxChar* sz, size_t nStart = npos) const;

  size_t find_last_of(wxChar c, size_t nStart = npos) const
    { return rfind(c, nStart); }




  size_t find_first_not_of(const wxString& str, size_t nStart = 0) const
    { return find_first_not_of(str.c_str(), nStart); }

  size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const;

  size_t find_first_not_of(wxChar ch, size_t nStart = 0) const;

  size_t find_last_not_of(const wxString& str, size_t nStart = npos) const
    { return find_first_not_of(str.c_str(), nStart); }

  size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const;

  size_t find_last_not_of(wxChar ch, size_t nStart = npos) const;





  int compare(const wxString& str) const { return Cmp(str); }

  int compare(size_t nStart, size_t nLen, const wxString& str) const
    { return Mid(nStart, nLen).Cmp(str); }

  int compare(size_t nStart, size_t nLen,
              const wxString& str, size_t nStart2, size_t nLen2) const
    { return Mid(nStart, nLen).Cmp(str.Mid(nStart2, nLen2)); }

  int compare(const wxChar* sz) const { return Cmp(sz); }

  int compare(size_t nStart, size_t nLen,
              const wxChar* sz, size_t nCount = npos) const
    { return Mid(nStart, nLen).Cmp(wxString(sz, nCount)); }


  wxString substr(size_t nStart = 0, size_t nLen = npos) const
    { return Mid(nStart, nLen); }

};
# 1023 "/usr/include/wx/string.h" 3 4
class wxArrayString
{
public:

  typedef int (*CompareFunction)(const wxString& first,
                                 const wxString& second);



  wxArrayString()
      : m_nSize(0), m_nCount(0), m_pItems(__null), m_autoSort(((bool)0))
      { Init(((bool)0)); }
# 1043 "/usr/include/wx/string.h" 3 4
  wxArrayString(int autoSort)
      : m_nSize(0), m_nCount(0), m_pItems(__null), m_autoSort(((bool)0))
      { Init(autoSort != 0); }

  wxArrayString(const wxArrayString& array);

  wxArrayString& operator=(const wxArrayString& src);

 ~wxArrayString();



  void Empty();

  void Clear();

  void Alloc(size_t nCount);

  void Shrink();



  size_t GetCount() const { return m_nCount; }

  bool IsEmpty() const { return m_nCount == 0; }

  size_t Count() const { return m_nCount; }



  wxString& Item(size_t nIndex) const
    {
        ;


        return *(wxString *)&(m_pItems[nIndex]);
    }


  wxString& operator[](size_t nIndex) const { return Item(nIndex); }

  wxString& Last() const
  {
      ;

      return Item(Count() - 1);
  }





  wxString* GetStringArray() const;






  int Index (const wxChar *sz, bool bCase = ((bool)1), bool bFromEnd = ((bool)0)) const;


  size_t Add(const wxString& str, size_t nInsert = 1);

  void Insert(const wxString& str, size_t uiIndex, size_t nInsert = 1);

  void SetCount(size_t count);

  void Remove(const wxChar *sz);

  void Remove(size_t nIndex, size_t nRemove = 1);
  void RemoveAt(size_t nIndex, size_t nRemove = 1) { Remove(nIndex, nRemove); }




  void Sort(bool reverseOrder = ((bool)0));

  void Sort(CompareFunction compareFunction);



  bool operator==(const wxArrayString& a) const;

  bool operator!=(const wxArrayString& a) const { return !(*this == a); }

protected:
  void Init(bool autoSort);
  void Copy(const wxArrayString& src);

private:
  void Grow(size_t nIncrement = 0);
  void Free();

  void DoSort();

  size_t m_nSize,
          m_nCount;

  wxChar **m_pItems;

  bool m_autoSort;
};

class wxSortedArrayString : public wxArrayString
{
public:
  wxSortedArrayString() : wxArrayString(((bool)1))
    { }
  wxSortedArrayString(const wxArrayString& array) : wxArrayString(((bool)1))
    { Copy(array); }
};





class wxStringBuffer
{
public:
    wxStringBuffer(wxString& str, size_t lenWanted = 1024)
        : m_str(str), m_buf(__null)
        { m_buf = m_str.GetWriteBuf(lenWanted); }

    ~wxStringBuffer() { m_str.UngetWriteBuf(); }

    operator wxChar*() const { return m_buf; }

private:
    wxString& m_str;
    wxChar *m_buf;

    private: wxStringBuffer(const wxStringBuffer&); wxStringBuffer& operator=(const wxStringBuffer&);
};





inline bool operator==(const wxString& s1, const wxString& s2)
    { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }
inline bool operator==(const wxString& s1, const wxChar * s2)
    { return s1.Cmp(s2) == 0; }
inline bool operator==(const wxChar * s1, const wxString& s2)
    { return s2.Cmp(s1) == 0; }
inline bool operator!=(const wxString& s1, const wxString& s2)
    { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); }
inline bool operator!=(const wxString& s1, const wxChar * s2)
    { return s1.Cmp(s2) != 0; }
inline bool operator!=(const wxChar * s1, const wxString& s2)
    { return s2.Cmp(s1) != 0; }
inline bool operator< (const wxString& s1, const wxString& s2)
    { return s1.Cmp(s2) < 0; }
inline bool operator< (const wxString& s1, const wxChar * s2)
    { return s1.Cmp(s2) < 0; }
inline bool operator< (const wxChar * s1, const wxString& s2)
    { return s2.Cmp(s1) > 0; }
inline bool operator> (const wxString& s1, const wxString& s2)
    { return s1.Cmp(s2) > 0; }
inline bool operator> (const wxString& s1, const wxChar * s2)
    { return s1.Cmp(s2) > 0; }
inline bool operator> (const wxChar * s1, const wxString& s2)
    { return s2.Cmp(s1) < 0; }
inline bool operator<=(const wxString& s1, const wxString& s2)
    { return s1.Cmp(s2) <= 0; }
inline bool operator<=(const wxString& s1, const wxChar * s2)
    { return s1.Cmp(s2) <= 0; }
inline bool operator<=(const wxChar * s1, const wxString& s2)
    { return s2.Cmp(s1) >= 0; }
inline bool operator>=(const wxString& s1, const wxString& s2)
    { return s1.Cmp(s2) >= 0; }
inline bool operator>=(const wxString& s1, const wxChar * s2)
    { return s1.Cmp(s2) >= 0; }
inline bool operator>=(const wxChar * s1, const wxString& s2)
    { return s2.Cmp(s1) <= 0; }


inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
# 1235 "/usr/include/wx/string.h" 3 4
inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
    { return (s1.Cmp((const char *)s2) == 0); }
inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
    { return (s2.Cmp((const char *)s1) == 0); }
inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
    { return (s1.Cmp((const char *)s2) != 0); }
inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
    { return (s2.Cmp((const char *)s1) != 0); }


wxString operator+(const wxString& string1, const wxString& string2);
wxString operator+(const wxString& string, wxChar ch);
wxString operator+(wxChar ch, const wxString& string);
wxString operator+(const wxString& string, const wxChar *psz);
wxString operator+(const wxChar *psz, const wxString& string);






inline wxString operator+(const wxString& string, const wxCharBuffer& buf)
    { return string + (const char *)buf; }
inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
    { return (const char *)buf + string; }
# 20 "../../wx/xrc/xmlres.h" 2
# 1 "/usr/include/wx/dynarray.h" 1 3 4
# 16 "/usr/include/wx/dynarray.h" 3 4
#pragma interface "dynarray.h"
# 64 "/usr/include/wx/dynarray.h" 3 4
extern "C"
{
typedef int ( *CMPFUNC)(const void* pItem1, const void* pItem2);
}
# 468 "/usr/include/wx/dynarray.h" 3 4
typedef const void * _wxArraywxBaseArrayPtrVoid; class wxBaseArrayPtrVoid { public: wxBaseArrayPtrVoid(); wxBaseArrayPtrVoid(const wxBaseArrayPtrVoid& array); wxBaseArrayPtrVoid& operator=(const wxBaseArrayPtrVoid& src); ~wxBaseArrayPtrVoid(); void Empty() { m_nCount = 0; } void Clear(); void Alloc(size_t uiSize); void Shrink(); size_t GetCount() const { return m_nCount; } bool IsEmpty() const { return m_nCount == 0; } size_t Count() const { return m_nCount; } typedef _wxArraywxBaseArrayPtrVoid base_type; protected: _wxArraywxBaseArrayPtrVoid& Item(size_t uiIndex) const { ; return m_pItems[uiIndex]; } _wxArraywxBaseArrayPtrVoid& operator[](size_t uiIndex) const { return Item(uiIndex); } int Index(_wxArraywxBaseArrayPtrVoid lItem, bool bFromEnd = ((bool)0)) const; int Index(_wxArraywxBaseArrayPtrVoid lItem, CMPFUNC fnCompare) const; size_t IndexForInsert(_wxArraywxBaseArrayPtrVoid lItem, CMPFUNC fnCompare) const; void Add(_wxArraywxBaseArrayPtrVoid lItem, size_t nInsert = 1); void Add(_wxArraywxBaseArrayPtrVoid lItem, CMPFUNC fnCompare); void Insert(_wxArraywxBaseArrayPtrVoid lItem, size_t uiIndex, size_t nInsert = 1); void Remove(_wxArraywxBaseArrayPtrVoid lItem); void RemoveAt(size_t uiIndex, size_t nRemove = 1); void Sort(CMPFUNC fnCompare); private: void Grow(size_t nIncrement = 0); size_t m_nSize, m_nCount; _wxArraywxBaseArrayPtrVoid *m_pItems; };
typedef short _wxArraywxBaseArrayShort; class wxBaseArrayShort { public: wxBaseArrayShort(); wxBaseArrayShort(const wxBaseArrayShort& array); wxBaseArrayShort& operator=(const wxBaseArrayShort& src); ~wxBaseArrayShort(); void Empty() { m_nCount = 0; } void Clear(); void Alloc(size_t uiSize); void Shrink(); size_t GetCount() const { return m_nCount; } bool IsEmpty() const { return m_nCount == 0; } size_t Count() const { return m_nCount; } typedef _wxArraywxBaseArrayShort base_type; protected: _wxArraywxBaseArrayShort& Item(size_t uiIndex) const { ; return m_pItems[uiIndex]; } _wxArraywxBaseArrayShort& operator[](size_t uiIndex) const { return Item(uiIndex); } int Index(_wxArraywxBaseArrayShort lItem, bool bFromEnd = ((bool)0)) const; int Index(_wxArraywxBaseArrayShort lItem, CMPFUNC fnCompare) const; size_t IndexForInsert(_wxArraywxBaseArrayShort lItem, CMPFUNC fnCompare) const; void Add(_wxArraywxBaseArrayShort lItem, size_t nInsert = 1); void Add(_wxArraywxBaseArrayShort lItem, CMPFUNC fnCompare); void Insert(_wxArraywxBaseArrayShort lItem, size_t uiIndex, size_t nInsert = 1); void Remove(_wxArraywxBaseArrayShort lItem); void RemoveAt(size_t uiIndex, size_t nRemove = 1); void Sort(CMPFUNC fnCompare); private: void Grow(size_t nIncrement = 0); size_t m_nSize, m_nCount; _wxArraywxBaseArrayShort *m_pItems; };
typedef int _wxArraywxBaseArrayInt; class wxBaseArrayInt { public: wxBaseArrayInt(); wxBaseArrayInt(const wxBaseArrayInt& array); wxBaseArrayInt& operator=(const wxBaseArrayInt& src); ~wxBaseArrayInt(); void Empty() { m_nCount = 0; } void Clear(); void Alloc(size_t uiSize); void Shrink(); size_t GetCount() const { return m_nCount; } bool IsEmpty() const { return m_nCount == 0; } size_t Count() const { return m_nCount; } typedef _wxArraywxBaseArrayInt base_type; protected: _wxArraywxBaseArrayInt& Item(size_t uiIndex) const { ; return m_pItems[uiIndex]; } _wxArraywxBaseArrayInt& operator[](size_t uiIndex) const { return Item(uiIndex); } int Index(_wxArraywxBaseArrayInt lItem, bool bFromEnd = ((bool)0)) const; int Index(_wxArraywxBaseArrayInt lItem, CMPFUNC fnCompare) const; size_t IndexForInsert(_wxArraywxBaseArrayInt lItem, CMPFUNC fnCompare) const; void Add(_wxArraywxBaseArrayInt lItem, size_t nInsert = 1); void Add(_wxArraywxBaseArrayInt lItem, CMPFUNC fnCompare); void Insert(_wxArraywxBaseArrayInt lItem, size_t uiIndex, size_t nInsert = 1); void Remove(_wxArraywxBaseArrayInt lItem); void RemoveAt(size_t uiIndex, size_t nRemove = 1); void Sort(CMPFUNC fnCompare); private: void Grow(size_t nIncrement = 0); size_t m_nSize, m_nCount; _wxArraywxBaseArrayInt *m_pItems; };
typedef long _wxArraywxBaseArrayLong; class wxBaseArrayLong { public: wxBaseArrayLong(); wxBaseArrayLong(const wxBaseArrayLong& array); wxBaseArrayLong& operator=(const wxBaseArrayLong& src); ~wxBaseArrayLong(); void Empty() { m_nCount = 0; } void Clear(); void Alloc(size_t uiSize); void Shrink(); size_t GetCount() const { return m_nCount; } bool IsEmpty() const { return m_nCount == 0; } size_t Count() const { return m_nCount; } typedef _wxArraywxBaseArrayLong base_type; protected: _wxArraywxBaseArrayLong& Item(size_t uiIndex) const { ; return m_pItems[uiIndex]; } _wxArraywxBaseArrayLong& operator[](size_t uiIndex) const { return Item(uiIndex); } int Index(_wxArraywxBaseArrayLong lItem, bool bFromEnd = ((bool)0)) const; int Index(_wxArraywxBaseArrayLong lItem, CMPFUNC fnCompare) const; size_t IndexForInsert(_wxArraywxBaseArrayLong lItem, CMPFUNC fnCompare) const; void Add(_wxArraywxBaseArrayLong lItem, size_t nInsert = 1); void Add(_wxArraywxBaseArrayLong lItem, CMPFUNC fnCompare); void Insert(_wxArraywxBaseArrayLong lItem, size_t uiIndex, size_t nInsert = 1); void Remove(_wxArraywxBaseArrayLong lItem); void RemoveAt(size_t uiIndex, size_t nRemove = 1); void Sort(CMPFUNC fnCompare); private: void Grow(size_t nIncrement = 0); size_t m_nSize, m_nCount; _wxArraywxBaseArrayLong *m_pItems; };
typedef double _wxArraywxBaseArrayDouble; class wxBaseArrayDouble { public: wxBaseArrayDouble(); wxBaseArrayDouble(const wxBaseArrayDouble& array); wxBaseArrayDouble& operator=(const wxBaseArrayDouble& src); ~wxBaseArrayDouble(); void Empty() { m_nCount = 0; } void Clear(); void Alloc(size_t uiSize); void Shrink(); size_t GetCount() const { return m_nCount; } bool IsEmpty() const { return m_nCount == 0; } size_t Count() const { return m_nCount; } typedef _wxArraywxBaseArrayDouble base_type; protected: _wxArraywxBaseArrayDouble& Item(size_t uiIndex) const { ; return m_pItems[uiIndex]; } _wxArraywxBaseArrayDouble& operator[](size_t uiIndex) const { return Item(uiIndex); } int Index(_wxArraywxBaseArrayDouble lItem, bool bFromEnd = ((bool)0)) const; int Index(_wxArraywxBaseArrayDouble lItem, CMPFUNC fnCompare) const; size_t IndexForInsert(_wxArraywxBaseArrayDouble lItem, CMPFUNC fnCompare) const; void Add(_wxArraywxBaseArrayDouble lItem, size_t nInsert = 1); void Add(_wxArraywxBaseArrayDouble lItem, CMPFUNC fnCompare); void Insert(_wxArraywxBaseArrayDouble lItem, size_t uiIndex, size_t nInsert = 1); void Remove(_wxArraywxBaseArrayDouble lItem); void RemoveAt(size_t uiIndex, size_t nRemove = 1); void Sort(CMPFUNC fnCompare); private: void Grow(size_t nIncrement = 0); size_t m_nSize, m_nCount; _wxArraywxBaseArrayDouble *m_pItems; };
# 589 "/usr/include/wx/dynarray.h" 3 4
typedef short _wxArraywxArrayShort; struct wxAssert_wxArrayShort { unsigned int TypeTooBigToBeStoredInwxBaseArrayShort: sizeof(_wxArraywxArrayShort) <= sizeof(wxBaseArrayShort::base_type); }; typedef int ( *CMPFUNC_wxArraywxArrayShort)(_wxArraywxArrayShort *pItem1, _wxArraywxArrayShort *pItem2); class wxArrayShort : public wxBaseArrayShort { public: wxArrayShort() { } ~wxArrayShort() { } wxArrayShort& operator=(const wxArrayShort& src) { wxBaseArrayShort* temp = (wxBaseArrayShort*) this; (*temp) = ((const wxBaseArrayShort&)src); return *this; } _wxArraywxArrayShort& operator[](size_t uiIndex) const { return (_wxArraywxArrayShort&)(wxBaseArrayShort::Item(uiIndex)); } _wxArraywxArrayShort& Item(size_t uiIndex) const { return (_wxArraywxArrayShort&)(wxBaseArrayShort::Item(uiIndex)); } _wxArraywxArrayShort& Last() const { return (_wxArraywxArrayShort&)(wxBaseArrayShort::Item(Count() - 1)); } int Index(_wxArraywxArrayShort Item, bool bFromEnd = ((bool)0)) const { return wxBaseArrayShort::Index(Item, bFromEnd); } void Add(_wxArraywxArrayShort Item, size_t nInsert = 1) { wxBaseArrayShort::Add(Item, nInsert); } void Insert(_wxArraywxArrayShort Item, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayShort::Insert(Item, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayShort::RemoveAt(uiIndex, nRemove); } void Remove(_wxArraywxArrayShort Item) { int iIndex = Index(Item); if (!(iIndex != (-1))) {; return; }; wxBaseArrayShort::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArraywxArrayShort fCmp) { wxBaseArrayShort::Sort((CMPFUNC)fCmp); } };
typedef int _wxArraywxArrayInt; struct wxAssert_wxArrayInt { unsigned int TypeTooBigToBeStoredInwxBaseArrayInt: sizeof(_wxArraywxArrayInt) <= sizeof(wxBaseArrayInt::base_type); }; typedef int ( *CMPFUNC_wxArraywxArrayInt)(_wxArraywxArrayInt *pItem1, _wxArraywxArrayInt *pItem2); class wxArrayInt : public wxBaseArrayInt { public: wxArrayInt() { } ~wxArrayInt() { } wxArrayInt& operator=(const wxArrayInt& src) { wxBaseArrayInt* temp = (wxBaseArrayInt*) this; (*temp) = ((const wxBaseArrayInt&)src); return *this; } _wxArraywxArrayInt& operator[](size_t uiIndex) const { return (_wxArraywxArrayInt&)(wxBaseArrayInt::Item(uiIndex)); } _wxArraywxArrayInt& Item(size_t uiIndex) const { return (_wxArraywxArrayInt&)(wxBaseArrayInt::Item(uiIndex)); } _wxArraywxArrayInt& Last() const { return (_wxArraywxArrayInt&)(wxBaseArrayInt::Item(Count() - 1)); } int Index(_wxArraywxArrayInt Item, bool bFromEnd = ((bool)0)) const { return wxBaseArrayInt::Index(Item, bFromEnd); } void Add(_wxArraywxArrayInt Item, size_t nInsert = 1) { wxBaseArrayInt::Add(Item, nInsert); } void Insert(_wxArraywxArrayInt Item, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayInt::Insert(Item, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayInt::RemoveAt(uiIndex, nRemove); } void Remove(_wxArraywxArrayInt Item) { int iIndex = Index(Item); if (!(iIndex != (-1))) {; return; }; wxBaseArrayInt::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArraywxArrayInt fCmp) { wxBaseArrayInt::Sort((CMPFUNC)fCmp); } };
typedef long _wxArraywxArrayLong; struct wxAssert_wxArrayLong { unsigned int TypeTooBigToBeStoredInwxBaseArrayLong: sizeof(_wxArraywxArrayLong) <= sizeof(wxBaseArrayLong::base_type); }; typedef int ( *CMPFUNC_wxArraywxArrayLong)(_wxArraywxArrayLong *pItem1, _wxArraywxArrayLong *pItem2); class wxArrayLong : public wxBaseArrayLong { public: wxArrayLong() { } ~wxArrayLong() { } wxArrayLong& operator=(const wxArrayLong& src) { wxBaseArrayLong* temp = (wxBaseArrayLong*) this; (*temp) = ((const wxBaseArrayLong&)src); return *this; } _wxArraywxArrayLong& operator[](size_t uiIndex) const { return (_wxArraywxArrayLong&)(wxBaseArrayLong::Item(uiIndex)); } _wxArraywxArrayLong& Item(size_t uiIndex) const { return (_wxArraywxArrayLong&)(wxBaseArrayLong::Item(uiIndex)); } _wxArraywxArrayLong& Last() const { return (_wxArraywxArrayLong&)(wxBaseArrayLong::Item(Count() - 1)); } int Index(_wxArraywxArrayLong Item, bool bFromEnd = ((bool)0)) const { return wxBaseArrayLong::Index(Item, bFromEnd); } void Add(_wxArraywxArrayLong Item, size_t nInsert = 1) { wxBaseArrayLong::Add(Item, nInsert); } void Insert(_wxArraywxArrayLong Item, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayLong::Insert(Item, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayLong::RemoveAt(uiIndex, nRemove); } void Remove(_wxArraywxArrayLong Item) { int iIndex = Index(Item); if (!(iIndex != (-1))) {; return; }; wxBaseArrayLong::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArraywxArrayLong fCmp) { wxBaseArrayLong::Sort((CMPFUNC)fCmp); } };
typedef void * _wxArraywxArrayPtrVoid; struct wxAssert_wxArrayPtrVoid { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArraywxArrayPtrVoid) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArraywxArrayPtrVoid)(_wxArraywxArrayPtrVoid *pItem1, _wxArraywxArrayPtrVoid *pItem2); class wxArrayPtrVoid : public wxBaseArrayPtrVoid { public: wxArrayPtrVoid() { } ~wxArrayPtrVoid() { } wxArrayPtrVoid& operator=(const wxArrayPtrVoid& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArraywxArrayPtrVoid& operator[](size_t uiIndex) const { return (_wxArraywxArrayPtrVoid&)(wxBaseArrayPtrVoid::Item(uiIndex)); } _wxArraywxArrayPtrVoid& Item(size_t uiIndex) const { return (_wxArraywxArrayPtrVoid&)(wxBaseArrayPtrVoid::Item(uiIndex)); } _wxArraywxArrayPtrVoid& Last() const { return (_wxArraywxArrayPtrVoid&)(wxBaseArrayPtrVoid::Item(Count() - 1)); } int Index(_wxArraywxArrayPtrVoid Item, bool bFromEnd = ((bool)0)) const { return wxBaseArrayPtrVoid::Index(Item, bFromEnd); } void Add(_wxArraywxArrayPtrVoid Item, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add(Item, nInsert); } void Insert(_wxArraywxArrayPtrVoid Item, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert(Item, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArraywxArrayPtrVoid Item) { int iIndex = Index(Item); if (!(iIndex != (-1))) {; return; }; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArraywxArrayPtrVoid fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } };
# 21 "../../wx/xrc/xmlres.h" 2
# 1 "/usr/include/wx/datetime.h" 1 3 4
# 17 "/usr/include/wx/datetime.h" 3 4
#pragma interface "datetime.h"






# 1 "/usr/include/time.h" 1 3 4
# 30 "/usr/include/time.h" 3 4
extern "C" {







# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 39 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
# 43 "/usr/include/time.h" 2 3 4
# 129 "/usr/include/time.h" 3 4


struct tm
{
  int tm_sec;
  int tm_min;
  int tm_hour;
  int tm_mday;
  int tm_mon;
  int tm_year;
  int tm_wday;
  int tm_yday;
  int tm_isdst;


  long int tm_gmtoff;
  __const char *tm_zone;




};








struct itimerspec
  {
    struct timespec it_interval;
    struct timespec it_value;
  };


struct sigevent;
# 178 "/usr/include/time.h" 3 4



extern clock_t clock (void) throw ();


extern time_t time (time_t *__timer) throw ();


extern double difftime (time_t __time1, time_t __time0)
     throw () __attribute__ ((__const__));


extern time_t mktime (struct tm *__tp) throw ();





extern size_t strftime (char *__restrict __s, size_t __maxsize,
                        __const char *__restrict __format,
                        __const struct tm *__restrict __tp) throw ();





extern char *strptime (__const char *__restrict __s,
                       __const char *__restrict __fmt, struct tm *__tp)
     throw ();







extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
                          __const char *__restrict __format,
                          __const struct tm *__restrict __tp,
                          __locale_t __loc) throw ();

extern char *strptime_l (__const char *__restrict __s,
                         __const char *__restrict __fmt, struct tm *__tp,
                         __locale_t __loc) throw ();






extern struct tm *gmtime (__const time_t *__timer) throw ();



extern struct tm *localtime (__const time_t *__timer) throw ();





extern struct tm *gmtime_r (__const time_t *__restrict __timer,
                            struct tm *__restrict __tp) throw ();



extern struct tm *localtime_r (__const time_t *__restrict __timer,
                               struct tm *__restrict __tp) throw ();





extern char *asctime (__const struct tm *__tp) throw ();


extern char *ctime (__const time_t *__timer) throw ();







extern char *asctime_r (__const struct tm *__restrict __tp,
                        char *__restrict __buf) throw ();


extern char *ctime_r (__const time_t *__restrict __timer,
                      char *__restrict __buf) throw ();




extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;




extern char *tzname[2];



extern void tzset (void) throw ();



extern int daylight;
extern long int timezone;





extern int stime (__const time_t *__when) throw ();
# 309 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();


extern time_t timelocal (struct tm *__tp) throw ();


extern int dysize (int __year) throw () __attribute__ ((__const__));
# 324 "/usr/include/time.h" 3 4
extern int nanosleep (__const struct timespec *__requested_time,
                      struct timespec *__remaining);



extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();


extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();


extern int clock_settime (clockid_t __clock_id, __const struct timespec *__tp)
     throw ();






extern int clock_nanosleep (clockid_t __clock_id, int __flags,
                            __const struct timespec *__req,
                            struct timespec *__rem);


extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();




extern int timer_create (clockid_t __clock_id,
                         struct sigevent *__restrict __evp,
                         timer_t *__restrict __timerid) throw ();


extern int timer_delete (timer_t __timerid) throw ();


extern int timer_settime (timer_t __timerid, int __flags,
                          __const struct itimerspec *__restrict __value,
                          struct itimerspec *__restrict __ovalue) throw ();


extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
     throw ();


extern int timer_getoverrun (timer_t __timerid) throw ();
# 386 "/usr/include/time.h" 3 4
extern int getdate_err;
# 395 "/usr/include/time.h" 3 4
extern struct tm *getdate (__const char *__string);
# 409 "/usr/include/time.h" 3 4
extern int getdate_r (__const char *__restrict __string,
                      struct tm *__restrict __resbufp);


}
# 25 "/usr/include/wx/datetime.h" 2 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/limits.h" 1 3 4
# 26 "/usr/include/wx/datetime.h" 2 3 4

# 1 "/usr/include/wx/longlong.h" 1 3 4
# 17 "/usr/include/wx/longlong.h" 3 4
#pragma interface "longlong.h"





# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/limits.h" 1 3 4
# 24 "/usr/include/wx/longlong.h" 2 3 4
# 132 "/usr/include/wx/longlong.h" 3 4
    class wxLongLongNative;
    class wxULongLongNative;
    typedef wxLongLongNative wxLongLong;
    typedef wxULongLongNative wxULongLong;
# 146 "/usr/include/wx/longlong.h" 3 4
# 1 "/usr/include/wx/ioswrap.h" 1 3 4
# 147 "/usr/include/wx/longlong.h" 2 3 4



class wxLongLongNative
{
public:


    wxLongLongNative() : m_ll(0) { }

    wxLongLongNative(long long ll) : m_ll(ll) { }

    wxLongLongNative(long hi, unsigned long lo) : m_ll(0)
    {

        m_ll = ((long long) hi) << 32;
        m_ll |= (long long) lo;
    }







    wxLongLongNative& operator=(long long ll)
        { m_ll = ll; return *this; }




    wxLongLongNative& Assign(double d)
        { m_ll = (long long)d; return *this; }





    long GetHi() const
        { return (long)(m_ll >> 32); }

    unsigned long GetLo() const
        { return (unsigned long)m_ll; }


    wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); }
    wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; }


    long long GetValue() const { return m_ll; }


    long ToLong() const
    {
        ;


        return (long)m_ll;
    }







    wxLongLongNative operator+(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll + ll.m_ll); }
    wxLongLongNative& operator+=(const wxLongLongNative& ll)
        { m_ll += ll.m_ll; return *this; }

    wxLongLongNative operator+(const long long ll) const
        { return wxLongLongNative(m_ll + ll); }
    wxLongLongNative& operator+=(const long long ll)
        { m_ll += ll; return *this; }


    wxLongLongNative& operator++()
        { m_ll++; return *this; }


    wxLongLongNative operator++(int)
        { wxLongLongNative value(*this); m_ll++; return value; }


    wxLongLongNative operator-() const
        { return wxLongLongNative(-m_ll); }
    wxLongLongNative& Negate() { m_ll = -m_ll; return *this; }


    wxLongLongNative operator-(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll - ll.m_ll); }
    wxLongLongNative& operator-=(const wxLongLongNative& ll)
        { m_ll -= ll.m_ll; return *this; }

    wxLongLongNative operator-(const long long ll) const
        { return wxLongLongNative(m_ll - ll); }
    wxLongLongNative& operator-=(const long long ll)
        { m_ll -= ll; return *this; }


    wxLongLongNative& operator--()
        { m_ll--; return *this; }


    wxLongLongNative operator--(int)
        { wxLongLongNative value(*this); m_ll--; return value; }



    wxLongLongNative operator<<(int shift) const
        { return wxLongLongNative(m_ll << shift);; }
    wxLongLongNative& operator<<=(int shift)
        { m_ll <<= shift; return *this; }


    wxLongLongNative operator>>(int shift) const
        { return wxLongLongNative(m_ll >> shift);; }
    wxLongLongNative& operator>>=(int shift)
        { m_ll >>= shift; return *this; }


    wxLongLongNative operator&(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll & ll.m_ll); }
    wxLongLongNative& operator&=(const wxLongLongNative& ll)
        { m_ll &= ll.m_ll; return *this; }

    wxLongLongNative operator|(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll | ll.m_ll); }
    wxLongLongNative& operator|=(const wxLongLongNative& ll)
        { m_ll |= ll.m_ll; return *this; }

    wxLongLongNative operator^(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll ^ ll.m_ll); }
    wxLongLongNative& operator^=(const wxLongLongNative& ll)
        { m_ll ^= ll.m_ll; return *this; }


    wxLongLongNative operator*(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll * ll.m_ll); }
    wxLongLongNative operator*(long l) const
        { return wxLongLongNative(m_ll * l); }
    wxLongLongNative& operator*=(const wxLongLongNative& ll)
        { m_ll *= ll.m_ll; return *this; }
    wxLongLongNative& operator*=(long l)
        { m_ll *= l; return *this; }

    wxLongLongNative operator/(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll / ll.m_ll); }
    wxLongLongNative operator/(long l) const
        { return wxLongLongNative(m_ll / l); }
    wxLongLongNative& operator/=(const wxLongLongNative& ll)
        { m_ll /= ll.m_ll; return *this; }
    wxLongLongNative& operator/=(long l)
        { m_ll /= l; return *this; }

    wxLongLongNative operator%(const wxLongLongNative& ll) const
        { return wxLongLongNative(m_ll % ll.m_ll); }
    wxLongLongNative operator%(long l) const
        { return wxLongLongNative(m_ll % l); }


    bool operator==(const wxLongLongNative& ll) const
        { return m_ll == ll.m_ll; }
    bool operator==(long l) const
        { return m_ll == l; }
    bool operator!=(const wxLongLongNative& ll) const
        { return m_ll != ll.m_ll; }
    bool operator!=(long l) const
        { return m_ll != l; }
    bool operator<(const wxLongLongNative& ll) const
        { return m_ll < ll.m_ll; }
    bool operator<(long l) const
        { return m_ll < l; }
    bool operator>(const wxLongLongNative& ll) const
        { return m_ll > ll.m_ll; }
    bool operator>(long l) const
        { return m_ll > l; }
    bool operator<=(const wxLongLongNative& ll) const
        { return m_ll <= ll.m_ll; }
    bool operator<=(long l) const
        { return m_ll <= l; }
    bool operator>=(const wxLongLongNative& ll) const
        { return m_ll >= ll.m_ll; }
    bool operator>=(long l) const
        { return m_ll >= l; }




    wxString ToString() const;


    void *asArray() const;






private:
    long long m_ll;
};


class wxULongLongNative
{
public:


    wxULongLongNative() : m_ll(0) { }

    wxULongLongNative(unsigned long long ll) : m_ll(ll) { }

    wxULongLongNative(unsigned long hi, unsigned long lo) : m_ll(0)
    {

        m_ll = ((unsigned long long) hi) << 32;
        m_ll |= (unsigned long long) lo;
    }







    wxULongLongNative& operator=(unsigned long long ll)
        { m_ll = ll; return *this; }





    unsigned long GetHi() const
        { return (unsigned long)(m_ll >> 32); }

    unsigned long GetLo() const
        { return (unsigned long)m_ll; }


    unsigned long long GetValue() const { return m_ll; }


    unsigned long ToULong() const
    {
        ;


        return (unsigned long)m_ll;
    }



    wxULongLongNative operator+(const wxULongLongNative& ll) const
        { return wxULongLongNative(m_ll + ll.m_ll); }
    wxULongLongNative& operator+=(const wxULongLongNative& ll)
        { m_ll += ll.m_ll; return *this; }

    wxULongLongNative operator+(const unsigned long long ll) const
        { return wxULongLongNative(m_ll + ll); }
    wxULongLongNative& operator+=(const unsigned long long ll)
        { m_ll += ll; return *this; }


    wxULongLongNative& operator++()
        { m_ll++; return *this; }


    wxULongLongNative operator++(int)
        { wxULongLongNative value(*this); m_ll++; return value; }


    wxULongLongNative operator-(const wxULongLongNative& ll) const
        { return wxULongLongNative(m_ll - ll.m_ll); }
    wxULongLongNative& operator-=(const wxULongLongNative& ll)
        { m_ll -= ll.m_ll; return *this; }

    wxULongLongNative operator-(const unsigned long long ll) const
        { return wxULongLongNative(m_ll - ll); }
    wxULongLongNative& operator-=(const unsigned long long ll)
        { m_ll -= ll; return *this; }


    wxULongLongNative& operator--()
        { m_ll--; return *this; }


    wxULongLongNative operator--(int)
        { wxULongLongNative value(*this); m_ll--; return value; }



    wxULongLongNative operator<<(int shift) const
        { return wxULongLongNative(m_ll << shift);; }
    wxULongLongNative& operator<<=(int shift)
        { m_ll <<= shift; return *this; }


    wxULongLongNative operator>>(int shift) const
        { return wxULongLongNative(m_ll >> shift);; }
    wxULongLongNative& operator>>=(int shift)
        { m_ll >>= shift; return *this; }


    wxULongLongNative operator&(const wxULongLongNative& ll) const
        { return wxULongLongNative(m_ll & ll.m_ll); }
    wxULongLongNative& operator&=(const wxULongLongNative& ll)
        { m_ll &= ll.m_ll; return *this; }

    wxULongLongNative operator|(const wxULongLongNative& ll) const
        { return wxULongLongNative(m_ll | ll.m_ll); }
    wxULongLongNative& operator|=(const wxULongLongNative& ll)
        { m_ll |= ll.m_ll; return *this; }

    wxULongLongNative operator^(const wxULongLongNative& ll) const
        { return wxULongLongNative(m_ll ^ ll.m_ll); }
    wxULongLongNative& operator^=(const wxULongLongNative& ll)
        { m_ll ^= ll.m_ll; return *this; }


    wxULongLongNative operator*(const wxULongLongNative& ll) const
        { return wxULongLongNative(m_ll * ll.m_ll); }
    wxULongLongNative operator*(unsigned long l) const
        { return wxULongLongNative(m_ll * l); }
    wxULongLongNative& operator*=(const wxULongLongNative& ll)
        { m_ll *= ll.m_ll; return *this; }
    wxULongLongNative& operator*=(unsigned long l)
        { m_ll *= l; return *this; }

    wxULongLongNative operator/(const wxULongLongNative& ll) const
        { return wxULongLongNative(m_ll / ll.m_ll); }
    wxULongLongNative operator/(unsigned long l) const
        { return wxULongLongNative(m_ll / l); }
    wxULongLongNative& operator/=(const wxULongLongNative& ll)
        { m_ll /= ll.m_ll; return *this; }
    wxULongLongNative& operator/=(unsigned long l)
        { m_ll /= l; return *this; }

    wxULongLongNative operator%(const wxULongLongNative& ll) const
        { return wxULongLongNative(m_ll % ll.m_ll); }
    wxULongLongNative operator%(unsigned long l) const
        { return wxULongLongNative(m_ll % l); }


    bool operator==(const wxULongLongNative& ll) const
        { return m_ll == ll.m_ll; }
    bool operator==(unsigned long l) const
        { return m_ll == l; }
    bool operator!=(const wxULongLongNative& ll) const
        { return m_ll != ll.m_ll; }
    bool operator!=(unsigned long l) const
        { return m_ll != l; }
    bool operator<(const wxULongLongNative& ll) const
        { return m_ll < ll.m_ll; }
    bool operator<(unsigned long l) const
        { return m_ll < l; }
    bool operator>(const wxULongLongNative& ll) const
        { return m_ll > ll.m_ll; }
    bool operator>(unsigned long l) const
        { return m_ll > l; }
    bool operator<=(const wxULongLongNative& ll) const
        { return m_ll <= ll.m_ll; }
    bool operator<=(unsigned long l) const
        { return m_ll <= l; }
    bool operator>=(const wxULongLongNative& ll) const
        { return m_ll >= ll.m_ll; }
    bool operator>=(unsigned long l) const
        { return m_ll >= l; }




    wxString ToString() const;


    void *asArray() const;






private:
    unsigned long long m_ll;
};
# 914 "/usr/include/wx/longlong.h" 3 4
inline bool operator<(long l, const wxLongLong& ll) { return ll > l; }
inline bool operator>(long l, const wxLongLong& ll) { return ll < l; }
inline bool operator<=(long l, const wxLongLong& ll) { return ll >= l; }
inline bool operator>=(long l, const wxLongLong& ll) { return ll <= l; }
inline bool operator==(long l, const wxLongLong& ll) { return ll == l; }
inline bool operator!=(long l, const wxLongLong& ll) { return ll != l; }

inline wxLongLong operator+(long l, const wxLongLong& ll) { return ll + l; }
inline wxLongLong operator-(long l, const wxLongLong& ll)
{
    return wxLongLong(l) - ll;
}

inline bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; }
inline bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; }
inline bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; }
inline bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; }
inline bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; }
inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; }

inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }


inline wxULongLong operator-(unsigned long l, const wxULongLong& ull)
{
    return wxULongLong(l) - ull;
}
# 28 "/usr/include/wx/datetime.h" 2 3 4

class wxDateTime;
class wxTimeSpan;
class wxDateSpan;
# 120 "/usr/include/wx/datetime.h" 3 4
class wxDateTime;

extern const wxDateTime wxDefaultDateTime;






class wxDateTime
{
public:
# 140 "/usr/include/wx/datetime.h" 3 4
    typedef unsigned short wxDateTime_t;





    enum TZ
    {

        Local,






        GMT_12, GMT_11, GMT_10, GMT_9, GMT_8, GMT_7,
        GMT_6, GMT_5, GMT_4, GMT_3, GMT_2, GMT_1,
        GMT0,
        GMT1, GMT2, GMT3, GMT4, GMT5, GMT6,
        GMT7, GMT8, GMT9, GMT10, GMT11, GMT12,






        WET = GMT0,
        WEST = GMT1,
        CET = GMT1,
        CEST = GMT2,
        EET = GMT2,
        EEST = GMT3,
        MSK = GMT3,
        MSD = GMT4,


        AST = GMT_4,
        ADT = GMT_3,
        EST = GMT_5,
        EDT = GMT_4,
        CST = GMT_6,
        CDT = GMT_5,
        MST = GMT_7,
        MDT = GMT_6,
        PST = GMT_8,
        PDT = GMT_7,
        HST = GMT_10,
        AKST = GMT_9,
        AKDT = GMT_8,



        A_WST = GMT8,
        A_CST = GMT12 + 1,
        A_EST = GMT10,
        A_ESST = GMT11,





        UTC = GMT0
    };





    enum Calendar
    {
        Gregorian,
        Julian


    };
# 226 "/usr/include/wx/datetime.h" 3 4
    enum GregorianAdoption
    {
        Gr_Unknown,
        Gr_Standard,

        Gr_Alaska,
        Gr_Albania,

        Gr_Austria = Gr_Unknown,
        Gr_Austria_Brixen,
        Gr_Austria_Salzburg = Gr_Austria_Brixen,
        Gr_Austria_Tyrol = Gr_Austria_Brixen,
        Gr_Austria_Carinthia,
        Gr_Austria_Styria = Gr_Austria_Carinthia,

        Gr_Belgium,

        Gr_Bulgaria = Gr_Unknown,
        Gr_Bulgaria_1,
        Gr_Bulgaria_2,
        Gr_Bulgaria_3,

        Gr_Canada = Gr_Unknown,


        Gr_China = Gr_Unknown,
        Gr_China_1,
        Gr_China_2,

        Gr_Czechoslovakia,
        Gr_Denmark,
        Gr_Egypt,
        Gr_Estonia,
        Gr_Finland,

        Gr_France,
        Gr_France_Alsace,
        Gr_France_Lorraine,
        Gr_France_Strasbourg,

        Gr_Germany = Gr_Unknown,
        Gr_Germany_Catholic,
        Gr_Germany_Prussia,
        Gr_Germany_Protestant,

        Gr_GreatBritain,

        Gr_Greece,
        Gr_Hungary,
        Gr_Ireland = Gr_GreatBritain,
        Gr_Italy = Gr_Standard,

        Gr_Japan = Gr_Unknown,
        Gr_Japan_1,
        Gr_Japan_2,
        Gr_Japan_3,

        Gr_Latvia,
        Gr_Lithuania,
        Gr_Luxemburg,
        Gr_Netherlands = Gr_Belgium,






        Gr_Netherlands_Groningen,
        Gr_Netherlands_Gelderland,
        Gr_Netherlands_Utrecht,
        Gr_Netherlands_Friesland,

        Gr_Norway = Gr_Denmark,
        Gr_Poland = Gr_Standard,
        Gr_Portugal = Gr_Standard,
        Gr_Romania,
        Gr_Russia,
        Gr_Scotland = Gr_GreatBritain,
        Gr_Spain = Gr_Standard,
# 323 "/usr/include/wx/datetime.h" 3 4
        Gr_Sweden = Gr_Finland,

        Gr_Switzerland = Gr_Unknown,
        Gr_Switzerland_Catholic,
        Gr_Switzerland_Protestant,

        Gr_Turkey,
        Gr_USA = Gr_GreatBritain,
        Gr_Wales = Gr_GreatBritain,
        Gr_Yugoslavia
    };






    enum Country
    {
        Country_Unknown,
        Country_Default,







        Country_WesternEurope_Start,
        Country_EEC = Country_WesternEurope_Start,
        France,
        Germany,
        UK,
        Country_WesternEurope_End = UK,

        Russia,

        USA
    };


    enum Month
    {
        Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec, Inv_Month
    };


    enum WeekDay
    {
        Sun, Mon, Tue, Wed, Thu, Fri, Sat, Inv_WeekDay
    };


    enum Year
    {
        Inv_Year = (-32767 - 1)
    };


    enum NameFlags
    {
        Name_Full = 0x01,
        Name_Abbr = 0x02
    };


    enum WeekFlags
    {
        Default_First,
        Monday_First,
        Sunday_First
    };






    class TimeZone
    {
    public:
        TimeZone(TZ tz);
        TimeZone(wxDateTime_t offset = 0) { m_offset = offset; }

        long GetOffset() const { return m_offset; }

    private:

        long m_offset;
    };
# 421 "/usr/include/wx/datetime.h" 3 4
    struct Tm
    {
        wxDateTime_t msec, sec, min, hour, mday;
        Month mon;
        int year;


        Tm();


        Tm(const struct tm& tm, const TimeZone& tz);


        bool IsValid() const;


        WeekDay GetWeekDay()
        {
            if ( wday == Inv_WeekDay )
                ComputeWeekDay();

            return (WeekDay)wday;
        }


        void AddMonths(int monDiff);


        void AddDays(int dayDiff);

    private:

        void ComputeWeekDay();


        TimeZone m_tz;



        wxDateTime_t wday, yday;
    };





    static void SetCountry(Country country);

    static Country GetCountry();



    static bool IsWestEuropeanCountry(Country country = Country_Default);


    static int GetCurrentYear(Calendar cal = Gregorian);





    static int ConvertYearToBC(int year);


    static Month GetCurrentMonth(Calendar cal = Gregorian);


    static bool IsLeapYear(int year = Inv_Year, Calendar cal = Gregorian);


    static int GetCentury(int year = Inv_Year);



    static wxDateTime_t GetNumberOfDays(int year, Calendar cal = Gregorian);



    static wxDateTime_t GetNumberOfDays(Month month,
                                        int year = Inv_Year,
                                        Calendar cal = Gregorian);



    static wxString GetMonthName(Month month,
                                 NameFlags flags = Name_Full);



    static wxString GetWeekDayName(WeekDay weekday,
                                   NameFlags flags = Name_Full);


    static void GetAmPmStrings(wxString *am, wxString *pm);


    static bool IsDSTApplicable(int year = Inv_Year,
                                Country country = Country_Default);




    static wxDateTime GetBeginDST(int year = Inv_Year,
                                  Country country = Country_Default);



    static wxDateTime GetEndDST(int year = Inv_Year,
                                Country country = Country_Default);


    static inline wxDateTime Now();



    static wxDateTime UNow();



    static inline wxDateTime Today();







    wxDateTime() { m_time = wxLongLong((long)(2147483647L * 2UL + 1UL), (2147483647L * 2UL + 1UL)); }




    inline wxDateTime(time_t timet);


    inline wxDateTime(const struct tm& tm);

    inline wxDateTime(const Tm& tm);


    inline wxDateTime(double jdn);


    inline wxDateTime(wxDateTime_t hour,
                      wxDateTime_t minute = 0,
                      wxDateTime_t second = 0,
                      wxDateTime_t millisec = 0);

    inline wxDateTime(wxDateTime_t day,
                      Month month,
                      int year = Inv_Year,
                      wxDateTime_t hour = 0,
                      wxDateTime_t minute = 0,
                      wxDateTime_t second = 0,
                      wxDateTime_t millisec = 0);
# 587 "/usr/include/wx/datetime.h" 3 4
    inline wxDateTime& SetToCurrent();




    inline wxDateTime& Set(time_t timet);



    wxDateTime& Set(const struct tm& tm);


    inline wxDateTime& Set(const Tm& tm);


    wxDateTime& Set(double jdn);


    wxDateTime& Set(wxDateTime_t hour,
                    wxDateTime_t minute = 0,
                    wxDateTime_t second = 0,
                    wxDateTime_t millisec = 0);



    wxDateTime& Set(wxDateTime_t day,
                    Month month,
                    int year = Inv_Year,
                    wxDateTime_t hour = 0,
                    wxDateTime_t minute = 0,
                    wxDateTime_t second = 0,
                    wxDateTime_t millisec = 0);


    wxDateTime& ResetTime();





    wxDateTime& SetYear(int year);

    wxDateTime& SetMonth(Month month);

    wxDateTime& SetDay(wxDateTime_t day);

    wxDateTime& SetHour(wxDateTime_t hour);

    wxDateTime& SetMinute(wxDateTime_t minute);

    wxDateTime& SetSecond(wxDateTime_t second);

    wxDateTime& SetMillisecond(wxDateTime_t millisecond);


    wxDateTime& operator=(time_t timet) { return Set(timet); }


    wxDateTime& operator=(const struct tm& tm) { return Set(tm); }


    wxDateTime& operator=(const Tm& tm) { return Set(tm); }
# 658 "/usr/include/wx/datetime.h" 3 4
    wxDateTime& SetToWeekDayInSameWeek(WeekDay weekday,
                                       WeekFlags flags = Monday_First);
    inline wxDateTime GetWeekDayInSameWeek(WeekDay weekday,
                                           WeekFlags flags = Monday_First) const;


    wxDateTime& SetToNextWeekDay(WeekDay weekday);
    inline wxDateTime GetNextWeekDay(WeekDay weekday) const;


    wxDateTime& SetToPrevWeekDay(WeekDay weekday);
    inline wxDateTime GetPrevWeekDay(WeekDay weekday) const;





    bool SetToWeekDay(WeekDay weekday,
                      int n = 1,
                      Month month = Inv_Month,
                      int year = Inv_Year);
    inline wxDateTime GetWeekDay(WeekDay weekday,
                                 int n = 1,
                                 Month month = Inv_Month,
                                 int year = Inv_Year) const;


    inline bool SetToLastWeekDay(WeekDay weekday,
                                 Month month = Inv_Month,
                                 int year = Inv_Year);
    inline wxDateTime GetLastWeekDay(WeekDay weekday,
                                     Month month = Inv_Month,
                                     int year = Inv_Year);




    bool SetToTheWeek(wxDateTime_t numWeek,
                      WeekDay weekday = Mon,
                      WeekFlags flags = Monday_First);
    inline wxDateTime GetWeek(wxDateTime_t numWeek,
                              WeekDay weekday = Mon,
                              WeekFlags flags = Monday_First) const;



    wxDateTime& SetToLastMonthDay(Month month = Inv_Month,
                                  int year = Inv_Year);
    inline wxDateTime GetLastMonthDay(Month month = Inv_Month,
                                      int year = Inv_Year) const;


    wxDateTime& SetToYearDay(wxDateTime_t yday);
    inline wxDateTime GetYearDay(wxDateTime_t yday) const;
# 737 "/usr/include/wx/datetime.h" 3 4
    double GetJulianDayNumber() const;
    double GetJDN() const { return GetJulianDayNumber(); }




    double GetModifiedJulianDayNumber() const { return GetJDN() - 2400000.5; }
    double GetMJD() const { return GetModifiedJulianDayNumber(); }


    double GetRataDie() const;
# 767 "/usr/include/wx/datetime.h" 3 4
    inline wxDateTime ToTimezone(const TimeZone& tz, bool noDST = ((bool)0)) const;
    wxDateTime& MakeTimezone(const TimeZone& tz, bool noDST = ((bool)0));


    wxDateTime ToGMT(bool noDST = ((bool)0)) const { return ToTimezone(GMT0, noDST); }
    wxDateTime& MakeGMT(bool noDST = ((bool)0)) { return MakeTimezone(GMT0, noDST); }






    int IsDST(Country country = Country_Default) const;
# 789 "/usr/include/wx/datetime.h" 3 4
    inline bool IsValid() const { return m_time != wxDefaultDateTime.m_time; }






    Tm GetTm(const TimeZone& tz = Local) const;



    inline time_t GetTicks() const;


    int GetYear(const TimeZone& tz = Local) const
            { return GetTm(tz).year; }

    Month GetMonth(const TimeZone& tz = Local) const
            { return (Month)GetTm(tz).mon; }

    wxDateTime_t GetDay(const TimeZone& tz = Local) const
            { return GetTm(tz).mday; }

    WeekDay GetWeekDay(const TimeZone& tz = Local) const
            { return GetTm(tz).GetWeekDay(); }

    wxDateTime_t GetHour(const TimeZone& tz = Local) const
            { return GetTm(tz).hour; }

    wxDateTime_t GetMinute(const TimeZone& tz = Local) const
            { return GetTm(tz).min; }

    wxDateTime_t GetSecond(const TimeZone& tz = Local) const
            { return GetTm(tz).sec; }

    wxDateTime_t GetMillisecond(const TimeZone& tz = Local) const
            { return GetTm(tz).msec; }


    wxDateTime_t GetDayOfYear(const TimeZone& tz = Local) const;


    wxDateTime_t GetWeekOfYear(WeekFlags flags = Monday_First,
                               const TimeZone& tz = Local) const;


    wxDateTime_t GetWeekOfMonth(WeekFlags flags = Monday_First,
                                const TimeZone& tz = Local) const;



    bool IsWorkDay(Country country = Country_Default) const;







    bool IsGregorianDate(GregorianAdoption country = Gr_Standard) const;





    wxDateTime& SetFromDOS(unsigned long ddt);


    unsigned long GetAsDOS() const;





    inline bool IsEqualTo(const wxDateTime& datetime) const;


    inline bool IsEarlierThan(const wxDateTime& datetime) const;


    inline bool IsLaterThan(const wxDateTime& datetime) const;


    inline bool IsStrictlyBetween(const wxDateTime& t1,
                                  const wxDateTime& t2) const;


    inline bool IsBetween(const wxDateTime& t1, const wxDateTime& t2) const;


    inline bool IsSameDate(const wxDateTime& dt) const;


    inline bool IsSameTime(const wxDateTime& dt) const;


    inline bool IsEqualUpTo(const wxDateTime& dt, const wxTimeSpan& ts) const;





    inline wxDateTime Add(const wxTimeSpan& diff) const;

    inline wxDateTime& Add(const wxTimeSpan& diff);

    inline wxDateTime& operator+=(const wxTimeSpan& diff);


    inline wxDateTime Subtract(const wxTimeSpan& diff) const;

    inline wxDateTime& Subtract(const wxTimeSpan& diff);

    inline wxDateTime& operator-=(const wxTimeSpan& diff);


    inline wxDateTime Add(const wxDateSpan& diff) const;

    wxDateTime& Add(const wxDateSpan& diff);

    inline wxDateTime& operator+=(const wxDateSpan& diff);


    inline wxDateTime Subtract(const wxDateSpan& diff) const;

    inline wxDateTime& Subtract(const wxDateSpan& diff);

    inline wxDateTime& operator-=(const wxDateSpan& diff);


    inline wxTimeSpan Subtract(const wxDateTime& dt) const;
# 928 "/usr/include/wx/datetime.h" 3 4
    const wxChar *ParseRfc822Date(const wxChar* date);




    const wxChar *ParseFormat(const wxChar *date,
                              const wxChar *format = "%c",
                              const wxDateTime& dateDef = wxDefaultDateTime);


    const wxChar *ParseDateTime(const wxChar *datetime);


    const wxChar *ParseDate(const wxChar *date);

    const wxChar *ParseTime(const wxChar *time);





    wxString Format(const wxChar *format = "%c",
                    const TimeZone& tz = Local) const;

    wxString FormatDate() const { return Format("%x"); }

    wxString FormatTime() const { return Format("%X"); }


    wxString FormatISODate() const { return Format("%Y-%m-%d"); }


    wxString FormatISOTime() const { return Format("%H:%M:%S"); }





    wxDateTime(const wxLongLong& time) { m_time = time; }


    inline wxLongLong GetValue() const;


    static time_t GetTimeNow() { return time((time_t *)__null); }


    static struct tm *GetTmNow()
    {
        time_t t = GetTimeNow();
        return localtime(&t);
    }

private:



    static Country ms_country;




    static const long TIME_T_FACTOR;



    inline bool IsInStdRange() const;




    wxLongLong m_time;
};







class wxTimeSpan
{
public:




    static wxTimeSpan Seconds(long sec) { return wxTimeSpan(0, 0, sec); }
    static wxTimeSpan Second() { return Seconds(1); }


    static wxTimeSpan Minutes(long min) { return wxTimeSpan(0, min, 0 ); }
    static wxTimeSpan Minute() { return Minutes(1); }


    static wxTimeSpan Hours(long hours) { return wxTimeSpan(hours, 0, 0); }
    static wxTimeSpan Hour() { return Hours(1); }


    static wxTimeSpan Days(long days) { return Hours(24 * days); }
    static wxTimeSpan Day() { return Days(1); }


    static wxTimeSpan Weeks(long days) { return Days(7 * days); }
    static wxTimeSpan Week() { return Weeks(1); }


    wxTimeSpan() { }




    inline wxTimeSpan(long hours,
                      long minutes = 0,
                      long seconds = 0,
                      long milliseconds = 0);
# 1053 "/usr/include/wx/datetime.h" 3 4
    inline wxTimeSpan Add(const wxTimeSpan& diff) const;

    inline wxTimeSpan& Add(const wxTimeSpan& diff);

    wxTimeSpan& operator+=(const wxTimeSpan& diff) { return Add(diff); }


    inline wxTimeSpan Subtract(const wxTimeSpan& diff) const;

    inline wxTimeSpan& Subtract(const wxTimeSpan& diff);

    wxTimeSpan& operator-=(const wxTimeSpan& diff) { return Subtract(diff); }


    inline wxTimeSpan Multiply(int n) const;

    inline wxTimeSpan& Multiply(int n);

    wxTimeSpan& operator*=(int n) { return Multiply(n); }


    wxTimeSpan Negate() const { return wxTimeSpan(-GetValue()); }

    wxTimeSpan& Neg() { m_diff = -GetValue(); return *this; }

    wxTimeSpan& operator-() { return Neg(); }



    inline wxTimeSpan Abs() const;
# 1091 "/usr/include/wx/datetime.h" 3 4
    bool IsNull() const { return m_diff == 0l; }

    bool operator!() const { return !IsNull(); }


    bool IsPositive() const { return m_diff > 0l; }


    bool IsNegative() const { return m_diff < 0l; }


    inline bool IsEqualTo(const wxTimeSpan& ts) const;



    inline bool IsLongerThan(const wxTimeSpan& ts) const;



    bool IsShorterThan(const wxTimeSpan& t) const { return !IsLongerThan(t); }





    inline int GetWeeks() const;

    inline int GetDays() const;

    inline int GetHours() const;

    inline int GetMinutes() const;

    inline wxLongLong GetSeconds() const;

    wxLongLong GetMilliseconds() const { return m_diff; }
# 1137 "/usr/include/wx/datetime.h" 3 4
    wxString Format(const wxChar *format = "%H:%M:%S") const;





    wxTimeSpan(const wxLongLong& diff) { m_diff = diff; }


    wxLongLong GetValue() const { return m_diff; }

private:

    wxLongLong m_diff;
};
# 1182 "/usr/include/wx/datetime.h" 3 4
class wxDateSpan
{
public:




    wxDateSpan(int years = 0, int months = 0, int weeks = 0, int days = 0)
    {
        m_years = years;
        m_months = months;
        m_weeks = weeks;
        m_days = days;
    }


    static wxDateSpan Days(int days) { return wxDateSpan(0, 0, 0, days); }
    static wxDateSpan Day() { return Days(1); }


    static wxDateSpan Weeks(int weeks) { return wxDateSpan(0, 0, weeks, 0); }
    static wxDateSpan Week() { return Weeks(1); }


    static wxDateSpan Months(int mon) { return wxDateSpan(0, mon, 0, 0); }
    static wxDateSpan Month() { return Months(1); }


    static wxDateSpan Years(int years) { return wxDateSpan(years, 0, 0, 0); }
    static wxDateSpan Year() { return Years(1); }
# 1221 "/usr/include/wx/datetime.h" 3 4
    wxDateSpan& SetYears(int n) { m_years = n; return *this; }

    wxDateSpan& SetMonths(int n) { m_months = n; return *this; }

    wxDateSpan& SetWeeks(int n) { m_weeks = n; return *this; }

    wxDateSpan& SetDays(int n) { m_days = n; return *this; }


    int GetYears() const { return m_years; }

    int GetMonths() const { return m_months; }

    int GetWeeks() const { return m_weeks; }

    int GetDays() const { return m_days; }

    int GetTotalDays() const { return 7*m_weeks + m_days; }





    inline wxDateSpan Add(const wxDateSpan& other) const;

    inline wxDateSpan& Add(const wxDateSpan& other);

    inline wxDateSpan& operator+=(const wxDateSpan& other);


    inline wxDateSpan Subtract(const wxDateSpan& other) const;

    inline wxDateSpan& Subtract(const wxDateSpan& other);

    inline wxDateSpan& operator-=(const wxDateSpan& other);


    inline wxDateSpan Negate() const;

    inline wxDateSpan& Neg();

    wxDateSpan& operator-() { return Neg(); }


    inline wxDateSpan Multiply(int factor) const;

    inline wxDateSpan& Multiply(int factor);

    inline wxDateSpan& operator*=(int factor) { return Multiply(factor); }

private:
    int m_years,
        m_months,
        m_weeks,
        m_days;
};







typedef wxDateTime _wxObjArraywxDateTimeArray; typedef int ( *CMPFUNC_wxObjArraywxDateTimeArray)(_wxObjArraywxDateTimeArray **pItem1, _wxObjArraywxDateTimeArray **pItem2); class wxDateTimeArray : public wxArrayPtrVoid { typedef int ( *CMPFUNCwxArrayPtrVoid)(void **pItem1, void **pItem2); public: wxDateTimeArray() { } wxDateTimeArray(const wxDateTimeArray& src); wxDateTimeArray& operator=(const wxDateTimeArray& src); ~wxDateTimeArray(); _wxObjArraywxDateTimeArray& operator[](size_t uiIndex) const { return *(_wxObjArraywxDateTimeArray*)wxArrayPtrVoid::Item(uiIndex); } _wxObjArraywxDateTimeArray& Item(size_t uiIndex) const { return *(_wxObjArraywxDateTimeArray*)wxArrayPtrVoid::Item(uiIndex); } _wxObjArraywxDateTimeArray& Last() const { return *(_wxObjArraywxDateTimeArray*)(wxArrayPtrVoid::Item(Count() - 1)); } int Index(const _wxObjArraywxDateTimeArray& Item, bool bFromEnd = ((bool)0)) const; void Add(const _wxObjArraywxDateTimeArray& Item, size_t nInsert = 1); void Add(const _wxObjArraywxDateTimeArray* pItem) { wxArrayPtrVoid::Add((_wxObjArraywxDateTimeArray*)pItem); } void Insert(const _wxObjArraywxDateTimeArray& Item, size_t uiIndex, size_t nInsert = 1); void Insert(const _wxObjArraywxDateTimeArray* pItem, size_t uiIndex) { wxArrayPtrVoid::Insert((_wxObjArraywxDateTimeArray*)pItem, uiIndex); } void Empty() { DoEmpty(); wxArrayPtrVoid::Empty(); } void Clear() { DoEmpty(); wxArrayPtrVoid::Clear(); } _wxObjArraywxDateTimeArray* Detach(size_t uiIndex) { _wxObjArraywxDateTimeArray* p = (_wxObjArraywxDateTimeArray*)wxArrayPtrVoid::Item(uiIndex); wxArrayPtrVoid::RemoveAt(uiIndex); return p; } void RemoveAt(size_t uiIndex, size_t nRemove = 1); void Sort(CMPFUNC_wxObjArraywxDateTimeArray fCmp) { wxArrayPtrVoid::Sort((CMPFUNCwxArrayPtrVoid)fCmp); } private: void DoEmpty(); void DoCopy(const wxDateTimeArray& src); };
# 1295 "/usr/include/wx/datetime.h" 3 4
class wxDateTimeHolidayAuthority;
typedef wxDateTimeHolidayAuthority * _wxArraywxHolidayAuthoritiesArray; struct wxAssert_wxHolidayAuthoritiesArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArraywxHolidayAuthoritiesArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArraywxHolidayAuthoritiesArray)(_wxArraywxHolidayAuthoritiesArray *pItem1, _wxArraywxHolidayAuthoritiesArray *pItem2); class wxHolidayAuthoritiesArray : public wxBaseArrayPtrVoid { public: wxHolidayAuthoritiesArray() { } ~wxHolidayAuthoritiesArray() { } wxHolidayAuthoritiesArray& operator=(const wxHolidayAuthoritiesArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArraywxHolidayAuthoritiesArray& operator[](size_t uiIndex) const { return (_wxArraywxHolidayAuthoritiesArray&)(wxBaseArrayPtrVoid::Item(uiIndex)); } _wxArraywxHolidayAuthoritiesArray& Item(size_t uiIndex) const { return (_wxArraywxHolidayAuthoritiesArray&)(wxBaseArrayPtrVoid::Item(uiIndex)); } _wxArraywxHolidayAuthoritiesArray& Last() const { return (_wxArraywxHolidayAuthoritiesArray&)(wxBaseArrayPtrVoid::Item(Count() - 1)); } int Index(_wxArraywxHolidayAuthoritiesArray Item, bool bFromEnd = ((bool)0)) const { return wxBaseArrayPtrVoid::Index(Item, bFromEnd); } void Add(_wxArraywxHolidayAuthoritiesArray Item, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add(Item, nInsert); } void Insert(_wxArraywxHolidayAuthoritiesArray Item, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert(Item, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArraywxHolidayAuthoritiesArray Item) { int iIndex = Index(Item); if (!(iIndex != (-1))) {; return; }; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArraywxHolidayAuthoritiesArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } };

class wxDateTimeHolidaysModule;
class wxDateTimeHolidayAuthority
{
friend class wxDateTimeHolidaysModule;
public:

    static bool IsHoliday(const wxDateTime& dt);



    static size_t GetHolidaysInRange(const wxDateTime& dtStart,
                                     const wxDateTime& dtEnd,
                                     wxDateTimeArray& holidays);


    static void ClearAllAuthorities();



    static void AddAuthority(wxDateTimeHolidayAuthority *auth);

protected:

    virtual bool DoIsHoliday(const wxDateTime& dt) const = 0;
# 1331 "/usr/include/wx/datetime.h" 3 4
    virtual size_t DoGetHolidaysInRange(const wxDateTime& dtStart,
                                        const wxDateTime& dtEnd,
                                        wxDateTimeArray& holidays) const = 0;

private:

    static wxHolidayAuthoritiesArray ms_authorities;
};


class wxDateTimeWorkDays : public wxDateTimeHolidayAuthority
{
protected:
    virtual bool DoIsHoliday(const wxDateTime& dt) const;
    virtual size_t DoGetHolidaysInRange(const wxDateTime& dtStart,
                                        const wxDateTime& dtEnd,
                                        wxDateTimeArray& holidays) const;
};
# 1360 "/usr/include/wx/datetime.h" 3 4
# 1 "/usr/include/wx/datetime.inl" 1 3 4
# 43 "/usr/include/wx/datetime.inl" 3 4
inline bool wxDateTime::IsInStdRange() const
{
    return m_time >= 0l && (m_time / TIME_T_FACTOR) < 2147483647L;
}


inline wxDateTime wxDateTime::Now()
{
    return wxDateTime(*GetTmNow());
}


inline wxDateTime wxDateTime::Today()
{
    struct tm *time = GetTmNow();
    time->tm_hour = 0;
    time->tm_min = 0;
    time->tm_sec = 0;

    return wxDateTime(*time);
}


inline wxDateTime& wxDateTime::Set(time_t timet)
{

    m_time = timet - 0 ;
    m_time *= TIME_T_FACTOR;

    return *this;
}


inline wxDateTime& wxDateTime::SetToCurrent()
{
    *this = Now();
    return *this;
}


inline wxDateTime::wxDateTime(time_t timet)
{
    Set(timet);
}


inline wxDateTime::wxDateTime(const struct tm& tm)
{
    Set(tm);
}

inline wxDateTime::wxDateTime(const Tm& tm)
{
    Set(tm);
}

inline wxDateTime::wxDateTime(double jdn)
{
    Set(jdn);
}

inline wxDateTime& wxDateTime::Set(const Tm& tm)
{
    ;

    return Set(tm.mday, (Month)tm.mon, tm.year, tm.hour, tm.min, tm.sec);
}

inline wxDateTime::wxDateTime(wxDateTime_t hour,
                              wxDateTime_t minute,
                              wxDateTime_t second,
                              wxDateTime_t millisec)
{
    Set(hour, minute, second, millisec);
}

inline wxDateTime::wxDateTime(wxDateTime_t day,
                              Month month,
                              int year,
                              wxDateTime_t hour,
                              wxDateTime_t minute,
                              wxDateTime_t second,
                              wxDateTime_t millisec)
{
    Set(day, month, year, hour, minute, second, millisec);
}





inline wxLongLong wxDateTime::GetValue() const
{
    ;

    return m_time;
}

inline time_t wxDateTime::GetTicks() const
{
    ;
    if ( !IsInStdRange() )
    {
        return (time_t)-1;
    }

    return (time_t)((m_time / (long)TIME_T_FACTOR).GetLo())+0 ;
}

inline bool wxDateTime::SetToLastWeekDay(WeekDay weekday,
                                         Month month,
                                         int year)
{
    return SetToWeekDay(weekday, -1, month, year);
}

inline wxDateTime wxDateTime::GetWeekDayInSameWeek(WeekDay weekday,
                                                   WeekFlags flags) const
{
    return wxDateTime(*this).SetToWeekDayInSameWeek(weekday);
}

inline wxDateTime wxDateTime::GetNextWeekDay(WeekDay weekday) const
{
    return wxDateTime(*this).SetToNextWeekDay(weekday);
}

inline wxDateTime wxDateTime::GetPrevWeekDay(WeekDay weekday) const
{
    return wxDateTime(*this).SetToPrevWeekDay(weekday);
}

inline wxDateTime wxDateTime::GetWeekDay(WeekDay weekday,
                                         int n,
                                         Month month,
                                         int year) const
{
    wxDateTime dt(*this);

    return dt.SetToWeekDay(weekday, n, month, year) ? dt : wxDefaultDateTime;
}

inline wxDateTime wxDateTime::GetLastWeekDay(WeekDay weekday,
                                             Month month,
                                             int year)
{
    wxDateTime dt(*this);

    return dt.SetToLastWeekDay(weekday, month, year) ? dt : wxDefaultDateTime;
}

inline wxDateTime wxDateTime::GetWeek(wxDateTime_t numWeek,
                                      WeekDay weekday,
                                      WeekFlags flags) const
{
    wxDateTime dt(*this);

    return dt.SetToTheWeek(numWeek, weekday, flags) ? dt : wxDefaultDateTime;
}

inline wxDateTime wxDateTime::GetLastMonthDay(Month month, int year) const
{
    return wxDateTime(*this).SetToLastMonthDay(month, year);
}

inline wxDateTime wxDateTime::GetYearDay(wxDateTime_t yday) const
{
    return wxDateTime(*this).SetToYearDay(yday);
}





inline bool wxDateTime::IsEqualTo(const wxDateTime& datetime) const
{
    ;

    return m_time == datetime.m_time;
}

inline bool wxDateTime::IsEarlierThan(const wxDateTime& datetime) const
{
    ;

    return m_time < datetime.m_time;
}

inline bool wxDateTime::IsLaterThan(const wxDateTime& datetime) const
{
    ;

    return m_time > datetime.m_time;
}

inline bool wxDateTime::IsStrictlyBetween(const wxDateTime& t1,
                                          const wxDateTime& t2) const
{

    return IsLaterThan(t1) && IsEarlierThan(t2);
}

inline bool wxDateTime::IsBetween(const wxDateTime& t1,
                                  const wxDateTime& t2) const
{

    return IsEqualTo(t1) || IsEqualTo(t2) || IsStrictlyBetween(t1, t2);
}

inline bool wxDateTime::IsSameDate(const wxDateTime& dt) const
{
    Tm tm1 = GetTm(),
       tm2 = dt.GetTm();

    return tm1.year == tm2.year &&
           tm1.mon == tm2.mon &&
           tm1.mday == tm2.mday;
}

inline bool wxDateTime::IsSameTime(const wxDateTime& dt) const
{





    Tm tm1 = GetTm(),
       tm2 = dt.GetTm();

    return tm1.hour == tm2.hour &&
           tm1.min == tm2.min &&
           tm1.sec == tm2.sec &&
           tm1.msec == tm2.msec;
}

inline bool wxDateTime::IsEqualUpTo(const wxDateTime& dt,
                                    const wxTimeSpan& ts) const
{
    return IsBetween(dt.Subtract(ts), dt.Add(ts));
}





inline wxDateTime wxDateTime::Add(const wxTimeSpan& diff) const
{
    ;

    return wxDateTime(m_time + diff.GetValue());
}

inline wxDateTime& wxDateTime::Add(const wxTimeSpan& diff)
{
    ;

    m_time += diff.GetValue();

    return *this;
}

inline wxDateTime& wxDateTime::operator+=(const wxTimeSpan& diff)
{
    return Add(diff);
}

inline wxDateTime wxDateTime::Subtract(const wxTimeSpan& diff) const
{
    ;

    return wxDateTime(m_time - diff.GetValue());
}

inline wxDateTime& wxDateTime::Subtract(const wxTimeSpan& diff)
{
    ;

    m_time -= diff.GetValue();

    return *this;
}

inline wxDateTime& wxDateTime::operator-=(const wxTimeSpan& diff)
{
    return Subtract(diff);
}

inline wxTimeSpan wxDateTime::Subtract(const wxDateTime& datetime) const
{
    ;

    return wxTimeSpan(GetValue() - datetime.GetValue());
}

inline wxDateTime wxDateTime::Add(const wxDateSpan& diff) const
{
    return wxDateTime(*this).Add(diff);
}

inline wxDateTime& wxDateTime::Subtract(const wxDateSpan& diff)
{
    return Add(diff.Negate());
}

inline wxDateTime wxDateTime::Subtract(const wxDateSpan& diff) const
{
    return wxDateTime(*this).Subtract(diff);
}

inline wxDateTime& wxDateTime::operator-=(const wxDateSpan& diff)
{
    return Subtract(diff);
}

inline wxDateTime& wxDateTime::operator+=(const wxDateSpan& diff)
{
    return Add(diff);
}





inline wxDateTime wxDateTime::ToTimezone(const wxDateTime::TimeZone& tz,
                                         bool noDST) const
{
    return wxDateTime(*this).MakeTimezone(tz, noDST);
}





inline wxTimeSpan::wxTimeSpan(long hours,
                              long minutes,
                              long seconds,
                              long milliseconds)
{

    m_diff = hours;
    m_diff *= 60l;
    m_diff += minutes;
    m_diff *= 60l;
    m_diff += seconds;
    m_diff *= 1000l;
    m_diff += milliseconds;
}





inline wxLongLong wxTimeSpan::GetSeconds() const
{
    return m_diff / 1000l;
}

inline int wxTimeSpan::GetMinutes() const
{
    return (GetSeconds() / 60l).GetLo();
}

inline int wxTimeSpan::GetHours() const
{
    return GetMinutes() / 60;
}

inline int wxTimeSpan::GetDays() const
{
    return GetHours() / 24;
}

inline int wxTimeSpan::GetWeeks() const
{
    return GetDays() / 7;
}





inline wxTimeSpan wxTimeSpan::Add(const wxTimeSpan& diff) const
{
    return wxTimeSpan(m_diff + diff.GetValue());
}

inline wxTimeSpan& wxTimeSpan::Add(const wxTimeSpan& diff)
{
    m_diff += diff.GetValue();

    return *this;
}

inline wxTimeSpan wxTimeSpan::Subtract(const wxTimeSpan& diff) const
{
    return wxTimeSpan(m_diff - diff.GetValue());
}

inline wxTimeSpan& wxTimeSpan::Subtract(const wxTimeSpan& diff)
{
    m_diff -= diff.GetValue();

    return *this;
}

inline wxTimeSpan& wxTimeSpan::Multiply(int n)
{
    m_diff *= (long)n;

    return *this;
}

inline wxTimeSpan wxTimeSpan::Multiply(int n) const
{
    return wxTimeSpan(m_diff * (long)n);
}

inline wxTimeSpan wxTimeSpan::Abs() const
{
    return wxTimeSpan(GetValue().Abs());
}

inline bool wxTimeSpan::IsEqualTo(const wxTimeSpan& ts) const
{
    return GetValue() == ts.GetValue();
}

inline bool wxTimeSpan::IsLongerThan(const wxTimeSpan& ts) const
{
    return GetValue().Abs() > ts.GetValue().Abs();
}





inline wxDateSpan& wxDateSpan::operator+=(const wxDateSpan& other)
{
    m_years += other.m_years;
    m_months += other.m_months;
    m_weeks += other.m_weeks;
    m_days += other.m_days;

    return *this;
}

inline wxDateSpan& wxDateSpan::Add(const wxDateSpan& other)
{
    return *this += other;
}

inline wxDateSpan wxDateSpan::Add(const wxDateSpan& other) const
{
    wxDateSpan ds(*this);
    ds.Add(other);
    return ds;
}

inline wxDateSpan& wxDateSpan::Multiply(int factor)
{
    m_years *= factor;
    m_months *= factor;
    m_weeks *= factor;
    m_days *= factor;

    return *this;
}

inline wxDateSpan wxDateSpan::Multiply(int factor) const
{
    wxDateSpan ds(*this);
    ds.Multiply(factor);
    return ds;
}

inline wxDateSpan wxDateSpan::Negate() const
{
    return wxDateSpan(-m_years, -m_months, -m_weeks, -m_days);
}

inline wxDateSpan& wxDateSpan::Neg()
{
    m_years = -m_years;
    m_months = -m_months;
    m_weeks = -m_weeks;
    m_days = -m_days;

    return *this;
}

inline wxDateSpan& wxDateSpan::operator-=(const wxDateSpan& other)
{
    return *this += other.Negate();
}

inline wxDateSpan& wxDateSpan::Subtract(const wxDateSpan& other)
{
    return *this -= other;
}

inline wxDateSpan wxDateSpan::Subtract(const wxDateSpan& other) const
{
    wxDateSpan ds(*this);
    ds.Subtract(other);
    return ds;
}
# 1361 "/usr/include/wx/datetime.h" 2 3 4
# 1382 "/usr/include/wx/datetime.h" 3 4
inline wxDateTime operator+(const wxDateTime& dt,
                                        const wxTimeSpan& ts)
{
    return dt.Add(ts);
}

inline wxDateTime operator-(const wxDateTime& dt,
                                        const wxTimeSpan& ts)
{
    return dt.Subtract(ts);
}

inline wxDateTime operator+(const wxDateTime& dt,
                                        const wxDateSpan& ds)
{
    return dt.Add(ds);
}

inline wxDateTime operator-(const wxDateTime& dt,
                                        const wxDateSpan& ds)
{
    return dt.Subtract(ds);
}

inline wxTimeSpan operator-(const wxDateTime& dt1,
                                        const wxDateTime& dt2)
{
    return dt1.Subtract(dt2);
}




inline bool operator<(const wxDateTime& t1, const wxDateTime& t2)
{
    ;

    return t1.GetValue() < t2.GetValue();
}

inline bool operator<=(const wxDateTime& t1, const wxDateTime& t2)
{
    ;

    return t1.GetValue() <= t2.GetValue();
}

inline bool operator>(const wxDateTime& t1, const wxDateTime& t2)
{
    ;

    return t1.GetValue() > t2.GetValue();
}

inline bool operator>=(const wxDateTime& t1, const wxDateTime& t2)
{
    ;

    return t1.GetValue() >= t2.GetValue();
}

inline bool operator==(const wxDateTime& t1, const wxDateTime& t2)
{
    ;

    return t1.GetValue() == t2.GetValue();
}

inline bool operator!=(const wxDateTime& t1, const wxDateTime& t2)
{
    ;

    return t1.GetValue() != t2.GetValue();
}
# 1464 "/usr/include/wx/datetime.h" 3 4
inline wxTimeSpan operator+(const wxTimeSpan& ts1,
                                        const wxTimeSpan& ts2)
{
    return wxTimeSpan(ts1.GetValue() + ts2.GetValue());
}

inline wxTimeSpan operator-(const wxTimeSpan& ts1,
                                        const wxTimeSpan& ts2)
{
    return wxTimeSpan(ts1.GetValue() - ts2.GetValue());
}

inline wxTimeSpan operator*(const wxTimeSpan& ts, int n)
{
    return wxTimeSpan(ts).Multiply(n);
}

inline wxTimeSpan operator*(int n, const wxTimeSpan& ts)
{
    return wxTimeSpan(ts).Multiply(n);
}




inline bool operator<(const wxTimeSpan &t1, const wxTimeSpan &t2)
{
    return t1.GetValue() < t2.GetValue();
}

inline bool operator<=(const wxTimeSpan &t1, const wxTimeSpan &t2)
{
    return t1.GetValue() <= t2.GetValue();
}

inline bool operator>(const wxTimeSpan &t1, const wxTimeSpan &t2)
{
    return t1.GetValue() > t2.GetValue();
}

inline bool operator>=(const wxTimeSpan &t1, const wxTimeSpan &t2)
{
    return t1.GetValue() >= t2.GetValue();
}

inline bool operator==(const wxTimeSpan &t1, const wxTimeSpan &t2)
{
    return t1.GetValue() == t2.GetValue();
}

inline bool operator!=(const wxTimeSpan &t1, const wxTimeSpan &t2)
{
    return t1.GetValue() != t2.GetValue();
}
# 1526 "/usr/include/wx/datetime.h" 3 4
inline wxDateSpan operator+(const wxDateSpan& ds1,
                                        const wxDateSpan& ds2)
{
    return wxDateSpan(ds1.GetYears() + ds2.GetYears(),
                      ds1.GetMonths() + ds2.GetMonths(),
                      ds1.GetWeeks() + ds2.GetWeeks(),
                      ds1.GetDays() + ds2.GetDays());
}

inline wxDateSpan operator-(const wxDateSpan& ds1,
                                        const wxDateSpan& ds2)
{
    return wxDateSpan(ds1.GetYears() - ds2.GetYears(),
                      ds1.GetMonths() - ds2.GetMonths(),
                      ds1.GetWeeks() - ds2.GetWeeks(),
                      ds1.GetDays() - ds2.GetDays());
}

inline wxDateSpan operator*(const wxDateSpan& ds, int n)
{
    return wxDateSpan(ds).Multiply(n);
}

inline wxDateSpan operator*(int n, const wxDateSpan& ds)
{
    return wxDateSpan(ds).Multiply(n);
}
# 1564 "/usr/include/wx/datetime.h" 3 4
inline void wxNextMonth(wxDateTime::Month& m)
{
    ;


    m = (wxDateTime::Month)(m + 1);
}

inline void wxPrevMonth(wxDateTime::Month& m)
{
    ;

    m = m == wxDateTime::Jan ? wxDateTime::Inv_Month
                             : (wxDateTime::Month)(m - 1);
}

inline void wxNextWDay(wxDateTime::WeekDay& wd)
{
    ;


    wd = (wxDateTime::WeekDay)(wd + 1);
}

inline void wxPrevWDay(wxDateTime::WeekDay& wd)
{
    ;

    wd = wd == wxDateTime::Sun ? wxDateTime::Inv_WeekDay
                               : (wxDateTime::WeekDay)(wd - 1);
}
# 22 "../../wx/xrc/xmlres.h" 2
# 1 "/usr/include/wx/list.h" 1 3 4
# 29 "/usr/include/wx/list.h" 3 4
#pragma interface "list.h"







# 1 "/usr/include/wx/object.h" 1 3 4
# 17 "/usr/include/wx/object.h" 3 4
#pragma interface "object.h"







# 1 "/usr/include/wx/memory.h" 1 3 4
# 16 "/usr/include/wx/memory.h" 3 4
#pragma interface "memory.h"
# 341 "/usr/include/wx/memory.h" 3 4
inline void wxTrace(const wxChar *) {}
inline void wxTraceLevel(int , const wxChar *) {}
# 26 "/usr/include/wx/object.h" 2 3 4

class wxObject;
# 44 "/usr/include/wx/object.h" 3 4
class wxClassInfo;
class wxHashTable;
class wxObjectRefData;
# 57 "/usr/include/wx/object.h" 3 4
typedef wxObject *(*wxObjectConstructorFn)(void);

class wxClassInfo
{
public:
    wxClassInfo( const wxChar *className,
                 const wxChar *baseName1,
                 const wxChar *baseName2,
                 int size,
                 wxObjectConstructorFn ctor )
        : m_className(className)
        , m_baseClassName1(baseName1)
        , m_baseClassName2(baseName2)
        , m_objectSize(size)
        , m_objectConstructor(ctor)
        , m_baseInfo1(0)
        , m_baseInfo2(0)
        , m_next(sm_first)
        { sm_first = this; }

    ~wxClassInfo();

    wxObject *CreateObject() { return m_objectConstructor ? (*m_objectConstructor)() : 0; }

    const wxChar *GetClassName() const { return m_className; }
    const wxChar *GetBaseClassName1() const { return m_baseClassName1; }
    const wxChar *GetBaseClassName2() const { return m_baseClassName2; }
    const wxClassInfo *GetBaseClass1() const { return m_baseInfo1; }
    const wxClassInfo *GetBaseClass2() const { return m_baseInfo2; }
    int GetSize() const { return m_objectSize; }

    wxObjectConstructorFn GetConstructor() const { return m_objectConstructor; }
    static const wxClassInfo *GetFirst() { return sm_first; }
    const wxClassInfo *GetNext() const { return m_next; }
    static wxClassInfo *FindClass(const wxChar *className);




    bool IsKindOf(const wxClassInfo *info) const
    {
        return info != 0 &&
               ( info == this ||
                 ( m_baseInfo1 && m_baseInfo1->IsKindOf(info) ) ||
                 ( m_baseInfo2 && m_baseInfo2->IsKindOf(info) ) );
    }



    static void InitializeClasses();



    static void CleanUpClasses();

public:
    const wxChar *m_className;
    const wxChar *m_baseClassName1;
    const wxChar *m_baseClassName2;
    int m_objectSize;
    wxObjectConstructorFn m_objectConstructor;



    const wxClassInfo *m_baseInfo1;
    const wxClassInfo *m_baseInfo2;




    static wxClassInfo *sm_first;
    wxClassInfo *m_next;



    static wxHashTable *sm_classTable;

private:

    static wxClassInfo *GetBaseByName(const wxChar *name);

    private: wxClassInfo(const wxClassInfo&); wxClassInfo& operator=(const wxClassInfo&);
};

 wxObject *wxCreateDynamicObject(const wxChar *name);
# 404 "/usr/include/wx/object.h" 3 4
class wxObject
{
    public: static wxClassInfo sm_classwxObject; virtual wxClassInfo *GetClassInfo() const { return &wxObject::sm_classwxObject; }

private:
    void InitFrom(const wxObject& other);

public:
    wxObject() { m_refData = __null; }
    virtual ~wxObject() { UnRef(); }

    wxObject(const wxObject& other)
        {
            InitFrom(other);
        }

    wxObject& operator=(const wxObject& other)
    {
        if ( this != &other )
        {
            UnRef();
            InitFrom(other);
        }
        return *this;
    }

    bool IsKindOf(wxClassInfo *info) const;
# 471 "/usr/include/wx/object.h" 3 4
    wxObjectRefData *GetRefData() const { return m_refData; }
    void SetRefData(wxObjectRefData *data) { m_refData = data; }


    void Ref(const wxObject& clone);


    void UnRef();

protected:



    void AllocExclusive();





    virtual wxObjectRefData *CreateRefData() const;


    virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;

    wxObjectRefData *m_refData;
};





class wxObjectRefData
{
    friend class wxObject;

public:
    wxObjectRefData() : m_count(1) { }
    virtual ~wxObjectRefData() { }

    int GetRefCount() const { return m_count; }

private:
    int m_count;
};


inline wxObject *wxCheckDynamicCast(wxObject *obj, wxClassInfo *classInfo)
{
    return obj && obj->GetClassInfo()->IsKindOf(classInfo) ? obj : __null;
}
# 38 "/usr/include/wx/list.h" 2 3 4




extern wxChar* copystring(const wxChar *s);

class wxObjectListNode;
typedef wxObjectListNode wxNode;







enum wxKeyType
{
    wxKEY_NONE,
    wxKEY_INTEGER,
    wxKEY_STRING
};
# 67 "/usr/include/wx/list.h" 3 4
extern "C"
{
typedef int (* wxSortCompareFunction)(const void *elem1, const void *elem2);
}


typedef int (* wxListIterateFunction)(void *current);





union wxListKeyValue
{
    long integer;
    wxChar *string;
};







class wxListKey
{
public:

    wxListKey() : m_keyType(wxKEY_NONE)
        { }
    wxListKey(long i) : m_keyType(wxKEY_INTEGER)
        { m_key.integer = i; }
    wxListKey(const wxChar *s) : m_keyType(wxKEY_STRING)
        { m_key.string = strdup(s); }
    wxListKey(const wxString& s) : m_keyType(wxKEY_STRING)
        { m_key.string = strdup(s.c_str()); }


    wxKeyType GetKeyType() const { return m_keyType; }
    const wxChar *GetString() const
        { ; return m_key.string; }
    long GetNumber() const
        { ; return m_key.integer; }




    bool operator==(wxListKeyValue value) const ;


    ~wxListKey()
    {
        if ( m_keyType == wxKEY_STRING )
            free(m_key.string);
    }

private:
    wxKeyType m_keyType;
    wxListKeyValue m_key;
};





extern wxListKey wxDefaultListKey;

class wxListBase;

class wxNodeBase
{
friend class wxListBase;
public:

    wxNodeBase(wxListBase *list = (wxListBase *)__null,
               wxNodeBase *previous = (wxNodeBase *)__null,
               wxNodeBase *next = (wxNodeBase *)__null,
               void *data = __null,
               const wxListKey& key = wxDefaultListKey);

    virtual ~wxNodeBase();


    const wxChar *GetKeyString() const { return m_key.string; }
    long GetKeyInteger() const { return m_key.integer; }


    void SetKeyString(wxChar* s) { m_key.string = s; }
    void SetKeyInteger(long i) { m_key.integer = i; }



    wxNode *Next() const { return (wxNode *)GetNext(); }
    wxNode *Previous() const { return (wxNode *)GetPrevious(); }
    wxObject *Data() const { return (wxObject *)GetData(); }


protected:

    wxNodeBase *GetNext() const { return m_next; }
    wxNodeBase *GetPrevious() const { return m_previous; }

    void *GetData() const { return m_data; }
    void SetData(void *data) { m_data = data; }


    int IndexOf() const;

    virtual void DeleteData() { }

private:

    wxListKeyValue m_key;

    void *m_data;
    wxNodeBase *m_next,
                *m_previous;

    wxListBase *m_list;

    private: wxNodeBase(const wxNodeBase&); wxNodeBase& operator=(const wxNodeBase&);
};





class wxListBase : public wxObject
{
friend class wxNodeBase;
friend class wxHashTableBase;
private:

    void Init(wxKeyType keyType = wxKEY_NONE);
public:

    wxListBase(wxKeyType keyType = wxKEY_NONE)
        { Init(keyType); }
    virtual ~wxListBase();



    size_t GetCount() const { return m_count; }


    bool IsEmpty() const { return m_count == 0; }




    void Clear();


    void DeleteContents(bool destroy) { m_destroy = destroy; }


    bool GetDeleteContents() const
        { return m_destroy; }


    wxKeyType GetKeyType() const
        { return m_keyType; }


    void SetKeyType(wxKeyType keyType)
        { ; m_keyType = keyType; }


    int Number() const { return GetCount(); }
    wxNode *First() const { return (wxNode *)GetFirst(); }
    wxNode *Last() const { return (wxNode *)GetLast(); }
    wxNode *Nth(size_t n) const { return (wxNode *)Item(n); }


protected:





    virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,
                                   void *data,
                                   const wxListKey& key = wxDefaultListKey) = 0;
# 258 "/usr/include/wx/list.h" 3 4
    wxListBase(size_t count, void *elements[]);

    wxListBase(void *object, ... );

protected:

    wxListBase(const wxListBase& list) : wxObject()
        { Init(); DoCopy(list); }
    wxListBase& operator=(const wxListBase& list)
        { Clear(); DoCopy(list); return *this; }


    wxNodeBase *GetFirst() const { return m_nodeFirst; }
    wxNodeBase *GetLast() const { return m_nodeLast; }


    wxNodeBase *Item(size_t index) const;


    void *operator[](size_t n) const
    {
        wxNodeBase *node = Item(n);

        return node ? node->GetData() : (wxNodeBase *)__null;
    }



    wxNodeBase *Prepend(void *object)
        { return (wxNodeBase *)wxListBase::Insert(object); }

    wxNodeBase *Append(void *object);

    wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)__null, object); }

    wxNodeBase *Insert(size_t pos, void *object)
        { return pos == GetCount() ? Append(object)
                                   : Insert(Item(pos), object); }

    wxNodeBase *Insert(wxNodeBase *prev, void *object);


    wxNodeBase *Append(long key, void *object);
    wxNodeBase *Append(const wxChar *key, void *object);



    wxNodeBase *DetachNode(wxNodeBase *node);

    bool DeleteNode(wxNodeBase *node);


    bool DeleteObject(void *object);



    wxNodeBase *Find(void *object) const;


    wxNodeBase *Find(const wxListKey& key) const;


    int IndexOf( void *object ) const;



    void Sort(const wxSortCompareFunction compfunc);


    void *FirstThat(wxListIterateFunction func);
    void ForEach(wxListIterateFunction func);
    void *LastThat(wxListIterateFunction func);

private:


    void DoCopy(const wxListBase& list);

    wxNodeBase *AppendCommon(wxNodeBase *node);

    void DoDeleteNode(wxNodeBase *node);

    size_t m_count;
    bool m_destroy;
    wxNodeBase *m_nodeFirst,
               *m_nodeLast;

    wxKeyType m_keyType;
};
# 509 "/usr/include/wx/list.h" 3 4
typedef int (*wxSortFuncFor_wxObjectList)(const wxObject **, const wxObject **); class wxObjectListNode : public wxNodeBase { public: wxObjectListNode(wxListBase *list = (wxListBase *)__null, wxObjectListNode *previous = (wxObjectListNode *)__null, wxObjectListNode *next = (wxObjectListNode *)__null, wxObject *data = (wxObject *)__null, const wxListKey& key = wxDefaultListKey) : wxNodeBase(list, previous, next, data, key) { } wxObjectListNode *GetNext() const { return (wxObjectListNode *)wxNodeBase::GetNext(); } wxObjectListNode *GetPrevious() const { return (wxObjectListNode *)wxNodeBase::GetPrevious(); } wxObject *GetData() const { return (wxObject *)wxNodeBase::GetData(); } void SetData(wxObject *data) { wxNodeBase::SetData(data); } virtual void DeleteData(); }; class wxObjectList : public wxListBase { public: typedef wxObjectListNode Node; wxObjectList(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType) { } wxObjectList(size_t count, wxObject *elements[]) : wxListBase(count, (void **)elements) { } wxObjectList& operator=(const wxObjectList& list) { (void) wxListBase::operator=(list); return *this; } wxObjectListNode *GetFirst() const { return (wxObjectListNode *)wxListBase::GetFirst(); } wxObjectListNode *GetLast() const { return (wxObjectListNode *)wxListBase::GetLast(); } wxObjectListNode *Item(size_t index) const { return (wxObjectListNode *)wxListBase::Item(index); } wxObject *operator[](size_t index) const { wxObjectListNode *node = Item(index); return node ? (wxObject*)(node->GetData()) : (wxObject*)__null; } wxObjectListNode *Append(wxObject *object) { return (wxObjectListNode *)wxListBase::Append(object); } wxObjectListNode *Insert(wxObject *object) { return (wxObjectListNode *)Insert((wxObjectListNode*)__null, object); } wxObjectListNode *Insert(size_t pos, wxObject *object) { return (wxObjectListNode *)wxListBase::Insert(pos, object); } wxObjectListNode *Insert(wxObjectListNode *prev, wxObject *object) { return (wxObjectListNode *)wxListBase::Insert(prev, object); } wxObjectListNode *Append(long key, void *object) { return (wxObjectListNode *)wxListBase::Append(key, object); } wxObjectListNode *Append(const wxChar *key, void *object) { return (wxObjectListNode *)wxListBase::Append(key, object); } wxObjectListNode *DetachNode(wxObjectListNode *node) { return (wxObjectListNode *)wxListBase::DetachNode(node); } bool DeleteNode(wxObjectListNode *node) { return wxListBase::DeleteNode(node); } bool DeleteObject(wxObject *object) { return wxListBase::DeleteObject(object); } wxObjectListNode *Find(wxObject *object) const { return (wxObjectListNode *)wxListBase::Find(object); } virtual wxObjectListNode *Find(const wxListKey& key) const { return (wxObjectListNode *)wxListBase::Find(key); } int IndexOf(wxObject *object) const { return wxListBase::IndexOf(object); } void Sort(wxSortFuncFor_wxObjectList func) { wxListBase::Sort((wxSortCompareFunction)func); } protected: virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next, void *data, const wxListKey& key = wxDefaultListKey) { return new wxObjectListNode(this, (wxObjectListNode *)prev, (wxObjectListNode *)next, (wxObject *)data, key); } };

class wxList : public wxObjectList
{
public:
    wxList(int key_type = wxKEY_NONE) : wxObjectList((wxKeyType)key_type) { }

   ~wxList() { }

    wxList& operator=(const wxList& list)
        { (void) wxListBase::operator=(list); return *this; }


    void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }

    wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }

private:
    public: static wxClassInfo sm_classwxList; virtual wxClassInfo *GetClassInfo() const { return &wxList::sm_classwxList; }
};





typedef int (*wxSortFuncFor_wxStringListBase)(const wxChar **, const wxChar **); class wxStringListNode : public wxNodeBase { public: wxStringListNode(wxListBase *list = (wxListBase *)__null, wxStringListNode *previous = (wxStringListNode *)__null, wxStringListNode *next = (wxStringListNode *)__null, wxChar *data = (wxChar *)__null, const wxListKey& key = wxDefaultListKey) : wxNodeBase(list, previous, next, data, key) { } wxStringListNode *GetNext() const { return (wxStringListNode *)wxNodeBase::GetNext(); } wxStringListNode *GetPrevious() const { return (wxStringListNode *)wxNodeBase::GetPrevious(); } wxChar *GetData() const { return (wxChar *)wxNodeBase::GetData(); } void SetData(wxChar *data) { wxNodeBase::SetData(data); } virtual void DeleteData(); }; class wxStringListBase : public wxListBase { public: typedef wxStringListNode Node; wxStringListBase(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType) { } wxStringListBase(size_t count, wxChar *elements[]) : wxListBase(count, (void **)elements) { } wxStringListBase& operator=(const wxStringListBase& list) { (void) wxListBase::operator=(list); return *this; } wxStringListNode *GetFirst() const { return (wxStringListNode *)wxListBase::GetFirst(); } wxStringListNode *GetLast() const { return (wxStringListNode *)wxListBase::GetLast(); } wxStringListNode *Item(size_t index) const { return (wxStringListNode *)wxListBase::Item(index); } wxChar *operator[](size_t index) const { wxStringListNode *node = Item(index); return node ? (wxChar*)(node->GetData()) : (wxChar*)__null; } wxStringListNode *Append(wxChar *object) { return (wxStringListNode *)wxListBase::Append(object); } wxStringListNode *Insert(wxChar *object) { return (wxStringListNode *)Insert((wxStringListNode*)__null, object); } wxStringListNode *Insert(size_t pos, wxChar *object) { return (wxStringListNode *)wxListBase::Insert(pos, object); } wxStringListNode *Insert(wxStringListNode *prev, wxChar *object) { return (wxStringListNode *)wxListBase::Insert(prev, object); } wxStringListNode *Append(long key, void *object) { return (wxStringListNode *)wxListBase::Append(key, object); } wxStringListNode *Append(const wxChar *key, void *object) { return (wxStringListNode *)wxListBase::Append(key, object); } wxStringListNode *DetachNode(wxStringListNode *node) { return (wxStringListNode *)wxListBase::DetachNode(node); } bool DeleteNode(wxStringListNode *node) { return wxListBase::DeleteNode(node); } bool DeleteObject(wxChar *object) { return wxListBase::DeleteObject(object); } wxStringListNode *Find(wxChar *object) const { return (wxStringListNode *)wxListBase::Find(object); } virtual wxStringListNode *Find(const wxListKey& key) const { return (wxStringListNode *)wxListBase::Find(key); } int IndexOf(wxChar *object) const { return wxListBase::IndexOf(object); } void Sort(wxSortFuncFor_wxStringListBase func) { wxListBase::Sort((wxSortCompareFunction)func); } protected: virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next, void *data, const wxListKey& key = wxDefaultListKey) { return new wxStringListNode(this, (wxStringListNode *)prev, (wxStringListNode *)next, (wxChar *)data, key); } };

class wxStringList : public wxStringListBase
{
public:


    wxStringList() { DeleteContents(((bool)1)); }
    wxStringList(const wxChar *first ...);



    wxStringList(const wxStringList& other) : wxStringListBase() { DeleteContents(((bool)1)); DoCopy(other); }
    wxStringList& operator=(const wxStringList& other)
        { Clear(); DoCopy(other); return *this; }



    wxNode *Add(const wxChar *s)
        { return (wxNode *)wxStringListBase::Append(copystring(s)); }


    wxNode *Prepend(const wxChar *s)
        { return (wxNode *)wxStringListBase::Insert(copystring(s)); }

    bool Delete(const wxChar *s);

    wxChar **ListToArray(bool new_copies = ((bool)0)) const;
    bool Member(const wxChar *s) const;


    void Sort();

private:
    void DoCopy(const wxStringList&);

    public: static wxClassInfo sm_classwxStringList; virtual wxClassInfo *GetClassInfo() const { return &wxStringList::sm_classwxStringList; }
};
# 23 "../../wx/xrc/xmlres.h" 2
# 1 "/usr/include/wx/gdicmn.h" 1 3 4
# 20 "/usr/include/wx/gdicmn.h" 3 4
#pragma interface "gdicmn.h"




# 1 "/usr/include/wx/hash.h" 1 3 4
# 16 "/usr/include/wx/hash.h" 3 4
#pragma interface "hash.h"
# 37 "/usr/include/wx/hash.h" 3 4
class wxHashTableBase : public wxObject
{
public:
    wxHashTableBase();

    void Create(wxKeyType keyType = wxKEY_INTEGER,
                size_t size = (1000));
    void Destroy();

    size_t GetSize() const { return m_hashSize; }
    size_t GetCount() const { return m_count; }

    void DeleteContents(bool flag);

protected:

    wxNodeBase *GetNode(long key, long value) const;


    wxListBase **m_hashTable;


    size_t m_hashSize;


    wxKeyType m_keyType;


    size_t m_count;


    bool m_deleteContents;

private:

    private: wxHashTableBase(const wxHashTableBase&); wxHashTableBase& operator=(const wxHashTableBase&);
};





class wxHashTableLong : public wxObject
{
public:
    wxHashTableLong(size_t size = (1000))
        { Init(size); }
    virtual ~wxHashTableLong();

    void Create(size_t size = (1000));
    void Destroy();

    size_t GetSize() const { return m_hashSize; }
    size_t GetCount() const { return m_count; }

    void Put(long key, long value);
    long Get(long key) const;
    long Delete(long key);

protected:
    void Init(size_t size);

private:
    wxArrayLong **m_values,
                **m_keys;


    size_t m_hashSize;


    size_t m_count;


    private: wxHashTableLong(const wxHashTableLong&); wxHashTableLong& operator=(const wxHashTableLong&);
};





class wxStringHashTable : public wxObject
{
public:
    wxStringHashTable(size_t sizeTable = (1000));
    virtual ~wxStringHashTable();


    void Put(long key, const wxString& value);



    wxString Get(long key, bool *wasFound = __null) const;


    bool Delete(long key) const;


    void Destroy();

private:
    wxArrayLong **m_keys;
    wxArrayString **m_values;


    size_t m_hashSize;

    private: wxStringHashTable(const wxStringHashTable&); wxStringHashTable& operator=(const wxStringHashTable&);
};





class wxHashTable : public wxObject
{
public:
    int n;
    int current_position;
    wxNode *current_node;

    unsigned int key_type;
    wxList **hash_table;

    wxHashTable(int the_key_type = wxKEY_INTEGER,
                int size = (1000));
    ~wxHashTable();


    wxHashTable(const wxHashTable& table) : wxObject()
        { DoCopy(table); }
    wxHashTable& operator=(const wxHashTable& table)
        { Clear(); DoCopy(table); return *this; }

    void DoCopy(const wxHashTable& table);

    void Destroy();

    bool Create(int the_key_type = wxKEY_INTEGER,
                int size = (1000));
# 190 "/usr/include/wx/hash.h" 3 4
    void Put(long key, long value, wxObject *object);
    void Put(long key, const wxChar *value, wxObject *object);


    void Put(long value, wxObject *object);
    void Put(const wxChar *value, wxObject *object);


    wxObject *Get(long key, long value) const;
    wxObject *Get(long key, const wxChar *value) const;


    wxObject *Get(long value) const;
    wxObject *Get(const wxChar *value) const;


    wxObject *Delete(long key);
    wxObject *Delete(const wxChar *key);

    wxObject *Delete(long key, int value);
    wxObject *Delete(long key, const wxChar *value);



    long MakeKey(const wxChar *string) const;





    void BeginFind();
    wxNode *Next();

    void DeleteContents(bool flag);
    void Clear();


    size_t GetCount() const { return m_count; }

private:
    size_t m_count;
    bool m_deleteContents;

    public: static wxClassInfo sm_classwxHashTable; virtual wxClassInfo *GetClassInfo() const { return &wxHashTable::sm_classwxHashTable; }
};
# 26 "/usr/include/wx/gdicmn.h" 2 3 4


# 1 "/usr/include/wx/colour.h" 1 3 4
# 9 "/usr/include/wx/colour.h" 3 4
# 1 "/usr/include/wx/gtk/colour.h" 1 3 4
# 15 "/usr/include/wx/gtk/colour.h" 3 4
#pragma interface





# 1 "/usr/include/wx/gdiobj.h" 1 3 4
# 9 "/usr/include/wx/gdiobj.h" 3 4
# 1 "/usr/include/wx/gtk/gdiobj.h" 1 3 4
# 17 "/usr/include/wx/gtk/gdiobj.h" 3 4
#pragma interface


class wxGDIObject : public wxObject
{
public:
    inline wxGDIObject() { m_visible = ((bool)0); };
    inline ~wxGDIObject() {}

    virtual bool GetVisible() { return m_visible; }
    virtual void SetVisible( bool visible ) { m_visible = visible; }

    bool IsNull() const { return (m_refData == 0); }

protected:
    bool m_visible;

private:
    public: static wxClassInfo sm_classwxGDIObject; virtual wxClassInfo *GetClassInfo() const { return &wxGDIObject::sm_classwxGDIObject; }
};
# 10 "/usr/include/wx/gdiobj.h" 2 3 4
# 22 "/usr/include/wx/gtk/colour.h" 2 3 4
# 1 "/usr/include/wx/palette.h" 1 3 4
# 14 "/usr/include/wx/palette.h" 3 4
# 1 "/usr/include/wx/generic/paletteg.h" 1 3 4
# 16 "/usr/include/wx/generic/paletteg.h" 3 4
#pragma interface "paletteg.h"





# 1 "/usr/include/wx/gdicmn.h" 1 3 4
# 23 "/usr/include/wx/generic/paletteg.h" 2 3 4





class wxPalette;





class wxPalette: public wxGDIObject
{
  public: static wxClassInfo sm_classwxPalette; virtual wxClassInfo *GetClassInfo() const { return &wxPalette::sm_classwxPalette; }

  public:

    wxPalette();
    wxPalette( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue );
    wxPalette( const wxPalette& palette );
    ~wxPalette();
    wxPalette& operator = ( const wxPalette& palette );
    bool operator == ( const wxPalette& palette );
    bool operator != ( const wxPalette& palette );
    bool Ok() const;

    bool Create( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
    int GetPixel( const unsigned char red, const unsigned char green, const unsigned char blue ) const;
    bool GetRGB( int pixel, unsigned char *red, unsigned char *green, unsigned char *blue ) const;


};
# 15 "/usr/include/wx/palette.h" 2 3 4
# 23 "/usr/include/wx/gtk/colour.h" 2 3 4





class wxDC;
class wxPaintDC;
class wxBitmap;
class wxWindow;

class wxColour;





class wxColour: public wxGDIObject
{
public:
    wxColour() { }


    wxColour( unsigned char red, unsigned char green, unsigned char blue );
    wxColour( unsigned long colRGB ) { Set(colRGB); }


    wxColour( const wxString &colourName ) { InitFromName(colourName); }
    wxColour( const char *colourName ) { InitFromName( wxString::FromAscii(colourName) ); }





    wxColour( const wxColour& col )
        : wxGDIObject()
        { Ref(col); }
    wxColour& operator = ( const wxColour& col ) { Ref(col); return *this; }

    ~wxColour();

    bool Ok() const { return m_refData != __null; }

    bool operator == ( const wxColour& col ) const;
    bool operator != ( const wxColour& col ) const { return !(*this == col); }

    void Set( unsigned char red, unsigned char green, unsigned char blue );
    void Set( unsigned long colRGB )
    {


        Set((unsigned char)colRGB,
            (unsigned char)(colRGB >> 8),
            (unsigned char)(colRGB >> 16));
    }

    unsigned char Red() const;
    unsigned char Green() const;
    unsigned char Blue() const;



    void CalcPixel( GdkColormap *cmap );
    int GetPixel() const;
    GdkColor *GetColor() const;

protected:

    virtual wxObjectRefData *CreateRefData() const;
    virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;


    void InitFromName(const wxString& colourName);

private:
    public: static wxClassInfo sm_classwxColour; virtual wxClassInfo *GetClassInfo() const { return &wxColour::sm_classwxColour; }
};
# 10 "/usr/include/wx/colour.h" 2 3 4
# 29 "/usr/include/wx/gdicmn.h" 2 3 4
# 1 "/usr/include/wx/font.h" 1 3 4
# 16 "/usr/include/wx/font.h" 3 4
#pragma interface "fontbase.h"







# 1 "/usr/include/wx/fontenc.h" 1 3 4
# 18 "/usr/include/wx/fontenc.h" 3 4
enum wxFontEncoding
{
    wxFONTENCODING_SYSTEM = -1,
    wxFONTENCODING_DEFAULT,


    wxFONTENCODING_ISO8859_1,
    wxFONTENCODING_ISO8859_2,
    wxFONTENCODING_ISO8859_3,
    wxFONTENCODING_ISO8859_4,
    wxFONTENCODING_ISO8859_5,
    wxFONTENCODING_ISO8859_6,
    wxFONTENCODING_ISO8859_7,
    wxFONTENCODING_ISO8859_8,
    wxFONTENCODING_ISO8859_9,
    wxFONTENCODING_ISO8859_10,
    wxFONTENCODING_ISO8859_11,
    wxFONTENCODING_ISO8859_12,


    wxFONTENCODING_ISO8859_13,
    wxFONTENCODING_ISO8859_14,
    wxFONTENCODING_ISO8859_15,
    wxFONTENCODING_ISO8859_MAX,


    wxFONTENCODING_KOI8,
    wxFONTENCODING_ALTERNATIVE,
    wxFONTENCODING_BULGARIAN,



    wxFONTENCODING_CP437,
    wxFONTENCODING_CP850,
    wxFONTENCODING_CP852,
    wxFONTENCODING_CP855,
    wxFONTENCODING_CP866,

    wxFONTENCODING_CP874,
    wxFONTENCODING_CP932,
    wxFONTENCODING_CP936,
    wxFONTENCODING_CP949,
    wxFONTENCODING_CP950,
    wxFONTENCODING_CP1250,
    wxFONTENCODING_CP1251,
    wxFONTENCODING_CP1252,
    wxFONTENCODING_CP1253,
    wxFONTENCODING_CP1254,
    wxFONTENCODING_CP1255,
    wxFONTENCODING_CP1256,
    wxFONTENCODING_CP1257,
    wxFONTENCODING_CP12_MAX,

    wxFONTENCODING_UTF7,
    wxFONTENCODING_UTF8,



    wxFONTENCODING_GB2312 = wxFONTENCODING_CP936,
    wxFONTENCODING_BIG5 = wxFONTENCODING_CP950,


    wxFONTENCODING_SHIFT_JIS = wxFONTENCODING_CP932,
    wxFONTENCODING_EUC_JP = wxFONTENCODING_UTF8 + 1,

    wxFONTENCODING_UNICODE,


    wxFONTENCODING_MAX
};
# 109 "/usr/include/wx/fontenc.h" 3 4
struct wxNativeEncodingInfo
{
    wxString facename;
    wxFontEncoding encoding;
# 136 "/usr/include/wx/fontenc.h" 3 4
    bool FromString(const wxString& s);
    wxString ToString() const;
};
# 25 "/usr/include/wx/font.h" 2 3 4






class wxFontData;
class wxFontBase;
class wxFont;
# 43 "/usr/include/wx/font.h" 3 4
enum wxFontFamily
{
    wxFONTFAMILY_DEFAULT = wxDEFAULT,
    wxFONTFAMILY_DECORATIVE = wxDECORATIVE,
    wxFONTFAMILY_ROMAN = wxROMAN,
    wxFONTFAMILY_SCRIPT = wxSCRIPT,
    wxFONTFAMILY_SWISS = wxSWISS,
    wxFONTFAMILY_MODERN = wxMODERN,
    wxFONTFAMILY_TELETYPE = wxTELETYPE,
    wxFONTFAMILY_MAX,
    wxFONTFAMILY_UNKNOWN = wxFONTFAMILY_MAX
};


enum wxFontStyle
{
    wxFONTSTYLE_NORMAL = wxNORMAL,
    wxFONTSTYLE_ITALIC = wxITALIC,
    wxFONTSTYLE_SLANT = wxSLANT,
    wxFONTSTYLE_MAX
};


enum wxFontWeight
{
    wxFONTWEIGHT_NORMAL = wxNORMAL,
    wxFONTWEIGHT_LIGHT = wxLIGHT,
    wxFONTWEIGHT_BOLD = wxBOLD,
    wxFONTWEIGHT_MAX
};





class wxFontRefData;
struct wxNativeFontInfo;

class wxFontBase : public wxGDIObject
{
public:

    virtual ~wxFontBase();


    static wxFont *New(
        int pointSize,
        int family,
        int style,
        int weight,
        bool underlined = ((bool)0),
        const wxString& face = wxEmptyString,
        wxFontEncoding encoding = wxFONTENCODING_DEFAULT);


    static wxFont *New(const wxNativeFontInfo& nativeFontDesc);


    static wxFont *New(const wxString& strNativeFontDesc);


    bool Ok() const { return m_refData != __null; }


    bool operator == (const wxFont& font) const;
    bool operator != (const wxFont& font) const;


    virtual int GetPointSize() const = 0;
    virtual int GetFamily() const = 0;
    virtual int GetStyle() const = 0;
    virtual int GetWeight() const = 0;
    virtual bool GetUnderlined() const = 0;
    virtual wxString GetFaceName() const = 0;
    virtual wxFontEncoding GetEncoding() const = 0;
    virtual wxNativeFontInfo *GetNativeFontInfo() const;

    virtual bool IsFixedWidth() const;

    wxString GetNativeFontInfoDesc() const;
    wxString GetNativeFontInfoUserDesc() const;


    virtual void SetPointSize( int pointSize ) = 0;
    virtual void SetFamily( int family ) = 0;
    virtual void SetStyle( int style ) = 0;
    virtual void SetWeight( int weight ) = 0;
    virtual void SetFaceName( const wxString& faceName ) = 0;
    virtual void SetUnderlined( bool underlined ) = 0;
    virtual void SetEncoding(wxFontEncoding encoding) = 0;
    virtual void SetNativeFontInfo(const wxNativeFontInfo& info);

    void SetNativeFontInfo(const wxString& info);
    void SetNativeFontInfoUserDesc(const wxString& info);



    wxString GetFamilyString() const;
    wxString GetStyleString() const;
    wxString GetWeightString() const;


    virtual void SetNoAntiAliasing( bool no = ((bool)1) ) { }
    virtual bool GetNoAntiAliasing() { return ((bool)0); }



    static wxFontEncoding GetDefaultEncoding() { return ms_encodingDefault; }
    static void SetDefaultEncoding(wxFontEncoding encoding);

protected:

    wxFontRefData *GetFontData() const
        { return (wxFontRefData *)m_refData; }

private:




    static wxFontEncoding ms_encodingDefault;
};







# 1 "/usr/include/wx/gtk/font.h" 1 3 4
# 14 "/usr/include/wx/gtk/font.h" 3 4
#pragma interface
# 23 "/usr/include/wx/gtk/font.h" 3 4
class wxDC;
class wxPaintDC;
class wxWindow;

class wxFont;





class wxFont : public wxFontBase
{
public:

    wxFont() { Init(); }
    wxFont(const wxFont& font) : wxFontBase() { Init(); Ref(font); }


    wxFont(const wxString& fontname)
    {
        Init();

        Create(fontname);
    }

    wxFont(const wxNativeFontInfo& info);

    wxFont(int size,
           int family,
           int style,
           int weight,
           bool underlined = ((bool)0),
           const wxString& face = wxEmptyString,
           wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
    {
        Init();

        (void)Create(size, family, style, weight, underlined, face, encoding);
    }

    bool Create(int size,
                int family,
                int style,
                int weight,
                bool underlined = ((bool)0),
                const wxString& face = wxEmptyString,
                wxFontEncoding encoding = wxFONTENCODING_DEFAULT);


    bool Create(const wxString& fontname);

    ~wxFont();


    wxFont& operator=(const wxFont& font);


    virtual int GetPointSize() const;
    virtual int GetFamily() const;
    virtual int GetStyle() const;
    virtual int GetWeight() const;
    virtual wxString GetFaceName() const;
    virtual bool GetUnderlined() const;
    virtual wxFontEncoding GetEncoding() const;
    virtual wxNativeFontInfo *GetNativeFontInfo() const;
    virtual bool IsFixedWidth() const;

    virtual void SetPointSize( int pointSize );
    virtual void SetFamily( int family );
    virtual void SetStyle( int style );
    virtual void SetWeight( int weight );
    virtual void SetFaceName( const wxString& faceName );
    virtual void SetUnderlined( bool underlined );
    virtual void SetEncoding(wxFontEncoding encoding);
    virtual void SetNativeFontInfo( const wxNativeFontInfo& info );

    virtual void SetNoAntiAliasing( bool no = ((bool)1) );
    virtual bool GetNoAntiAliasing();


    void Unshare();

    GdkFont* GetInternalFont(float scale = 1.0) const;



protected:

    void Init();

private:
    public: static wxClassInfo sm_classwxFont; virtual wxClassInfo *GetClassInfo() const { return &wxFont::sm_classwxFont; }
};
# 173 "/usr/include/wx/font.h" 2 3 4
# 30 "/usr/include/wx/gdicmn.h" 2 3 4





class wxBitmap;
class wxBrush;
class wxColour;
class wxCursor;
class wxFont;
class wxIcon;
class wxPalette;
class wxPen;
class wxRegion;
class wxString;






enum wxBitmapType
{
    wxBITMAP_TYPE_INVALID,
    wxBITMAP_TYPE_BMP,
    wxBITMAP_TYPE_BMP_RESOURCE,
    wxBITMAP_TYPE_RESOURCE = wxBITMAP_TYPE_BMP_RESOURCE,
    wxBITMAP_TYPE_ICO,
    wxBITMAP_TYPE_ICO_RESOURCE,
    wxBITMAP_TYPE_CUR,
    wxBITMAP_TYPE_CUR_RESOURCE,
    wxBITMAP_TYPE_XBM,
    wxBITMAP_TYPE_XBM_DATA,
    wxBITMAP_TYPE_XPM,
    wxBITMAP_TYPE_XPM_DATA,
    wxBITMAP_TYPE_TIF,
    wxBITMAP_TYPE_TIF_RESOURCE,
    wxBITMAP_TYPE_GIF,
    wxBITMAP_TYPE_GIF_RESOURCE,
    wxBITMAP_TYPE_PNG,
    wxBITMAP_TYPE_PNG_RESOURCE,
    wxBITMAP_TYPE_JPEG,
    wxBITMAP_TYPE_JPEG_RESOURCE,
    wxBITMAP_TYPE_PNM,
    wxBITMAP_TYPE_PNM_RESOURCE,
    wxBITMAP_TYPE_PCX,
    wxBITMAP_TYPE_PCX_RESOURCE,
    wxBITMAP_TYPE_PICT,
    wxBITMAP_TYPE_PICT_RESOURCE,
    wxBITMAP_TYPE_ICON,
    wxBITMAP_TYPE_ICON_RESOURCE,
    wxBITMAP_TYPE_ANI,
    wxBITMAP_TYPE_IFF,
    wxBITMAP_TYPE_MACCURSOR,
    wxBITMAP_TYPE_MACCURSOR_RESOURCE,
    wxBITMAP_TYPE_ANY = 50
};


enum wxStockCursor
{
    wxCURSOR_NONE,
    wxCURSOR_ARROW,
    wxCURSOR_RIGHT_ARROW,
    wxCURSOR_BULLSEYE,
    wxCURSOR_CHAR,
    wxCURSOR_CROSS,
    wxCURSOR_HAND,
    wxCURSOR_IBEAM,
    wxCURSOR_LEFT_BUTTON,
    wxCURSOR_MAGNIFIER,
    wxCURSOR_MIDDLE_BUTTON,
    wxCURSOR_NO_ENTRY,
    wxCURSOR_PAINT_BRUSH,
    wxCURSOR_PENCIL,
    wxCURSOR_POINT_LEFT,
    wxCURSOR_POINT_RIGHT,
    wxCURSOR_QUESTION_ARROW,
    wxCURSOR_RIGHT_BUTTON,
    wxCURSOR_SIZENESW,
    wxCURSOR_SIZENS,
    wxCURSOR_SIZENWSE,
    wxCURSOR_SIZEWE,
    wxCURSOR_SIZING,
    wxCURSOR_SPRAYCAN,
    wxCURSOR_WAIT,
    wxCURSOR_WATCH,
    wxCURSOR_BLANK,

    wxCURSOR_DEFAULT,
# 132 "/usr/include/wx/gdicmn.h" 3 4
    wxCURSOR_ARROWWAIT,

    wxCURSOR_MAX
};
# 202 "/usr/include/wx/gdicmn.h" 3 4
class wxSize
{
public:



    int x, y;


    wxSize() : x(0), y(0) { }
    wxSize(int xx, int yy) : x(xx), y(yy) { }



    bool operator==(const wxSize& sz) const { return x == sz.x && y == sz.y; }
    bool operator!=(const wxSize& sz) const { return x != sz.x || y != sz.y; }


    wxSize operator+(const wxSize& sz) { return wxSize(x + sz.x, y + sz.y); }
    wxSize operator-(const wxSize& sz) { return wxSize(x - sz.x, y - sz.y); }


    void Set(int xx, int yy) { x = xx; y = yy; }
    void SetWidth(int w) { x = w; }
    void SetHeight(int h) { y = h; }

    int GetWidth() const { return x; }
    int GetHeight() const { return y; }


    int GetX() const { return x; }
    int GetY() const { return y; }
};





class wxRealPoint
{
public:
    double x;
    double y;

    wxRealPoint() : x(0.0), y(0.0) { }
    wxRealPoint(double xx, double yy) : x(xx), y(yy) { }

    wxRealPoint operator+(const wxRealPoint& pt) const { return wxRealPoint(x + pt.x, y + pt.y); }
    wxRealPoint operator-(const wxRealPoint& pt) const { return wxRealPoint(x - pt.x, y - pt.y); }

    bool operator==(const wxRealPoint& pt) const { return x == pt.x && y == pt.y; }
    bool operator!=(const wxRealPoint& pt) const { return x != pt.x || y != pt.y; }
};

class wxPoint
{
public:
    int x, y;

    wxPoint() : x(0), y(0) { }
    wxPoint(int xx, int yy) : x(xx), y(yy) { }




    bool operator==(const wxPoint& p) const { return x == p.x && y == p.y; }
    bool operator!=(const wxPoint& p) const { return !(*this == p); }


    wxPoint operator+(const wxPoint& p) const { return wxPoint(x + p.x, y + p.y); }
    wxPoint operator-(const wxPoint& p) const { return wxPoint(x - p.x, y - p.y); }

    wxPoint& operator+=(const wxPoint& p) { x += p.x; y += p.y; return *this; }
    wxPoint& operator-=(const wxPoint& p) { x -= p.x; y -= p.y; return *this; }
};
# 287 "/usr/include/wx/gdicmn.h" 3 4
class wxRect
{
public:
    wxRect()
        : x(0), y(0), width(0), height(0)
        { }
    wxRect(int xx, int yy, int ww, int hh)
        : x(xx), y(yy), width(ww), height(hh)
        { }
    wxRect(const wxPoint& topLeft, const wxPoint& bottomRight);
    wxRect(const wxPoint& pos, const wxSize& size);



    int GetX() const { return x; }
    void SetX(int xx) { x = xx; }

    int GetY() const { return y; }
    void SetY(int yy) { y = yy; }

    int GetWidth() const { return width; }
    void SetWidth(int w) { width = w; }

    int GetHeight() const { return height; }
    void SetHeight(int h) { height = h; }

    wxPoint GetPosition() const { return wxPoint(x, y); }
    void SetPosition( const wxPoint &p ) { x = p.x; y = p.y; }

    wxSize GetSize() const { return wxSize(width, height); }
    void SetSize( const wxSize &s ) { width = s.GetWidth(); height = s.GetHeight(); }

    int GetLeft() const { return x; }
    int GetTop() const { return y; }
    int GetBottom() const { return y + height - 1; }
    int GetRight() const { return x + width - 1; }

    void SetLeft(int left) { x = left; }
    void SetRight(int right) { width = right - x + 1; }
    void SetTop(int top) { y = top; }
    void SetBottom(int bottom) { height = bottom - y + 1; }


    wxRect& Inflate(wxCoord dx, wxCoord dy);
    wxRect& Inflate(wxCoord d) { return Inflate(d, d); }
    wxRect Inflate(wxCoord dx, wxCoord dy) const
    {
        wxRect r = *this;
        r.Inflate(dx, dy);
        return r;
    }

    wxRect& Deflate(wxCoord dx, wxCoord dy) { return Inflate(-dx, -dy); }
    wxRect& Deflate(wxCoord d) { return Inflate(-d); }
    wxRect Deflate(wxCoord dx, wxCoord dy) const
    {
        wxRect r = *this;
        r.Deflate(dx, dy);
        return r;
    }

    void Offset(wxCoord dx, wxCoord dy) { x += dx; y += dy; }
    void Offset(const wxPoint& pt) { Offset(pt.x, pt.y); }

    wxRect& Intersect(const wxRect& rect);
    wxRect Intersect(const wxRect& rect) const
    {
        wxRect r = *this;
        r.Intersect(rect);
        return r;
    }

    wxRect operator+(const wxRect& rect) const;
    wxRect& operator+=(const wxRect& rect);


    bool operator==(const wxRect& rect) const;
    bool operator!=(const wxRect& rect) const { return !(*this == rect); }


    bool Inside(int x, int y) const;
    bool Inside(const wxPoint& pt) const { return Inside(pt.x, pt.y); }


    bool Intersects(const wxRect& rect) const;

public:
    int x, y, width, height;
};





typedef char signed wxDash;

class wxPenList : public wxList
{
    public: static wxClassInfo sm_classwxPenList; virtual wxClassInfo *GetClassInfo() const { return &wxPenList::sm_classwxPenList; }

public:
    wxPenList() { }
    ~wxPenList();

    void AddPen(wxPen *pen);
    void RemovePen(wxPen *pen);
    wxPen *FindOrCreatePen(const wxColour& colour, int width, int style);
};

class wxBrushList : public wxList
{
    public: static wxClassInfo sm_classwxBrushList; virtual wxClassInfo *GetClassInfo() const { return &wxBrushList::sm_classwxBrushList; }

public:
    wxBrushList() { }
    ~wxBrushList();

    void AddBrush(wxBrush *brush);
    void RemoveBrush(wxBrush *brush);
    wxBrush *FindOrCreateBrush(const wxColour& colour, int style);
};

extern const wxChar* wxEmptyString;

class wxFontList : public wxList
{
    public: static wxClassInfo sm_classwxFontList; virtual wxClassInfo *GetClassInfo() const { return &wxFontList::sm_classwxFontList; }

public:
    wxFontList() { }
    ~wxFontList();

    void AddFont(wxFont *font);
    void RemoveFont(wxFont *font);
    wxFont *FindOrCreateFont(int pointSize, int family, int style, int weight,
                             bool underline = ((bool)0),
                             const wxString& face = wxEmptyString,
                             wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
};

class wxColourDatabase : public wxList
{
    public: static wxClassInfo sm_classwxColourDatabase; virtual wxClassInfo *GetClassInfo() const { return &wxColourDatabase::sm_classwxColourDatabase; }

public:
    wxColourDatabase(int type);
    ~wxColourDatabase() ;


    wxColour *FindColour(const wxString& colour) ;
    wxString FindName(const wxColour& colour) const;
    void Initialize();





};

class wxBitmapList : public wxList
{
    public: static wxClassInfo sm_classwxBitmapList; virtual wxClassInfo *GetClassInfo() const { return &wxBitmapList::sm_classwxBitmapList; }

public:
    wxBitmapList();
    ~wxBitmapList();

    void AddBitmap(wxBitmap *bitmap);
    void RemoveBitmap(wxBitmap *bitmap);
};

class wxResourceCache: public wxList
{
public:
    wxResourceCache() { }
    wxResourceCache(const unsigned int keyType) : wxList(keyType) { }
    ~wxResourceCache();

private:
    public: static wxClassInfo sm_classwxResourceCache; virtual wxClassInfo *GetClassInfo() const { return &wxResourceCache::sm_classwxResourceCache; }
};






extern wxPenList* wxThePenList;
extern wxBrushList* wxTheBrushList;
extern wxFontList* wxTheFontList;
extern wxBitmapList* wxTheBitmapList;


extern wxFont* wxNORMAL_FONT;
extern wxFont* wxSMALL_FONT;
extern wxFont* wxITALIC_FONT;
extern wxFont* wxSWISS_FONT;

extern wxPen* wxRED_PEN;
extern wxPen* wxCYAN_PEN;
extern wxPen* wxGREEN_PEN;
extern wxPen* wxBLACK_PEN;
extern wxPen* wxWHITE_PEN;
extern wxPen* wxTRANSPARENT_PEN;
extern wxPen* wxBLACK_DASHED_PEN;
extern wxPen* wxGREY_PEN;
extern wxPen* wxMEDIUM_GREY_PEN;
extern wxPen* wxLIGHT_GREY_PEN;

extern wxBrush* wxBLUE_BRUSH;
extern wxBrush* wxGREEN_BRUSH;
extern wxBrush* wxWHITE_BRUSH;
extern wxBrush* wxBLACK_BRUSH;
extern wxBrush* wxGREY_BRUSH;
extern wxBrush* wxMEDIUM_GREY_BRUSH;
extern wxBrush* wxLIGHT_GREY_BRUSH;
extern wxBrush* wxTRANSPARENT_BRUSH;
extern wxBrush* wxCYAN_BRUSH;
extern wxBrush* wxRED_BRUSH;

extern wxColour* wxBLACK;
extern wxColour* wxWHITE;
extern wxColour* wxRED;
extern wxColour* wxBLUE;
extern wxColour* wxGREEN;
extern wxColour* wxCYAN;
extern wxColour* wxLIGHT_GREY;


extern wxBitmap wxNullBitmap;
extern wxIcon wxNullIcon;
extern wxCursor wxNullCursor;
extern wxPen wxNullPen;
extern wxBrush wxNullBrush;
extern wxPalette wxNullPalette;
extern wxFont wxNullFont;
extern wxColour wxNullColour;


extern wxCursor* wxSTANDARD_CURSOR;
extern wxCursor* wxHOURGLASS_CURSOR;
extern wxCursor* wxCROSS_CURSOR;

extern wxColourDatabase* wxTheColourDatabase;

extern const wxChar* wxPanelNameStr;

extern const wxSize wxDefaultSize;
extern const wxPoint wxDefaultPosition;


extern wxList wxPendingDelete;






extern void wxInitializeStockObjects();
extern void wxInitializeStockLists();
extern void wxDeleteStockObjects();
extern void wxDeleteStockLists();


extern bool wxColourDisplay();


extern int wxDisplayDepth();



extern void wxDisplaySize(int *width, int *height);
extern wxSize wxGetDisplaySize();
extern void wxDisplaySizeMM(int *width, int *height);
extern wxSize wxGetDisplaySizeMM();


extern void wxClientDisplayRect(int *x, int *y, int *width, int *height);
extern wxRect wxGetClientDisplayRect();


extern void wxSetCursor(const wxCursor& cursor);
# 24 "../../wx/xrc/xmlres.h" 2
# 1 "/usr/include/wx/filesys.h" 1 3 4
# 14 "/usr/include/wx/filesys.h" 3 4
#pragma interface "filesys.h"
# 29 "/usr/include/wx/filesys.h" 3 4
# 1 "/usr/include/wx/stream.h" 1 3 4
# 16 "/usr/include/wx/stream.h" 3 4
#pragma interface "stream.h"
# 26 "/usr/include/wx/stream.h" 3 4
# 1 "/usr/include/wx/filefn.h" 1 3 4
# 16 "/usr/include/wx/filefn.h" 3 4
#pragma interface "filefn.h"
# 51 "/usr/include/wx/filefn.h" 3 4
const off_t wxInvalidOffset = (off_t)-1;


enum wxSeekMode
{
  wxFromStart,
  wxFromCurrent,
  wxFromEnd
};

extern const wxChar* wxEmptyString;
# 152 "/usr/include/wx/filefn.h" 3 4
 bool wxFileExists(const wxString& filename);


 bool wxPathExists(const wxChar *pszPathName);

 bool wxIsAbsolutePath(const wxString& filename);


 wxChar* wxFileNameFromPath(wxChar *path);
 wxString wxFileNameFromPath(const wxString& path);


 wxString wxPathOnly(const wxString& path);


 wxString wxRealPath(const wxString& path);

 void wxDos2UnixFilename(wxChar *s);

 void wxUnix2DosFilename(wxChar *s);


 void wxStripExtension(wxChar *buffer);
 void wxStripExtension(wxString& buffer);


 wxChar* wxGetTempFileName(const wxString& prefix, wxChar *buf = (wxChar *) __null);
 bool wxGetTempFileName(const wxString& prefix, wxString& buf);


 wxChar* wxExpandPath(wxChar *dest, const wxChar *path);
 bool wxExpandPath(wxString& dest, const wxChar *path);




 wxChar* wxContractPath(const wxString& filename,
                                   const wxString& envname = wxEmptyString,
                                   const wxString& user = wxEmptyString);


 wxChar* wxRealPath(wxChar *path);


 wxChar* wxCopyAbsolutePath(const wxString& path);





 wxString wxFindFirstFile(const wxChar *spec, int flags = 1);
 wxString wxFindNextFile();


 bool wxIsWild(const wxString& pattern);




 bool wxMatchWild(const wxString& pattern, const wxString& text, bool dot_special = ((bool)1));


 bool wxConcatFiles(const wxString& file1, const wxString& file2, const wxString& file3);


 bool wxCopyFile(const wxString& file1, const wxString& file2,
                            bool overwrite = ((bool)1));


 bool wxRemoveFile(const wxString& file);


 bool wxRenameFile(const wxString& file1, const wxString& file2);






 wxChar* wxGetWorkingDirectory(wxChar *buf = (wxChar *) __null, int sz = 1000);


 wxString wxGetCwd();


 bool wxSetWorkingDirectory(const wxString& d);


 bool wxMkdir(const wxString& dir, int perm = 0777);


 bool wxRmdir(const wxString& dir, int flags = 0);
# 306 "/usr/include/wx/filefn.h" 3 4
inline bool wxIsPathSeparator(wxChar c)
{


    return c == '/';



}


 bool wxEndsWithPathSeparator(const wxChar *pszFileName);



 void wxSplitPath(const wxChar *pszFileName,
                             wxString *pstrPath,
                             wxString *pstrName,
                             wxString *pstrExt);


 bool wxFindFileInPath(wxString *pStr, const wxChar *pszPath, const wxChar *pszFile);



 wxString wxGetOSDirectory();


 time_t wxFileModificationTime(const wxString& filename);






class wxPathList : public wxStringList
{
public:

    void AddEnvList(const wxString& envVariable);

    void Add(const wxString& path);

    wxNode *Add(const wxChar *s) { return wxStringList::Add(s); }

    wxString FindValidPath(const wxString& filename);


    wxString FindAbsoluteValidPath(const wxString& filename);

    void EnsureFileAccessible(const wxString& path);

    bool Member(const wxString& path);

private:
    public: static wxClassInfo sm_classwxPathList; virtual wxClassInfo *GetClassInfo() const { return &wxPathList::sm_classwxPathList; }
};
# 27 "/usr/include/wx/stream.h" 2 3 4

class wxStreamBase;
class wxInputStream;
class wxOutputStream;

typedef wxInputStream& (*__wxInputManip)(wxInputStream&);
typedef wxOutputStream& (*__wxOutputManip)(wxOutputStream&);

 wxOutputStream& wxEndL(wxOutputStream& o_stream);





enum wxStreamError
{
    wxSTREAM_NO_ERROR = 0,
    wxSTREAM_EOF,
    wxSTREAM_WRITE_ERROR,
    wxSTREAM_READ_ERROR
};
# 70 "/usr/include/wx/stream.h" 3 4
class wxStreamBase
{
public:
    wxStreamBase();
    virtual ~wxStreamBase();


    wxStreamError GetLastError() const { return m_lasterror; }
    bool IsOk() const { return GetLastError() == wxSTREAM_NO_ERROR; }
    bool operator!() const { return !IsOk(); }


    void Reset() { m_lasterror = wxSTREAM_NO_ERROR; }


    virtual size_t GetSize() const { return 0; }



    wxStreamError LastError() const { return m_lasterror; }
    size_t StreamSize() const { return GetSize(); }


protected:
    virtual off_t OnSysSeek(off_t seek, wxSeekMode mode);
    virtual off_t OnSysTell() const;

    size_t m_lastcount;
    wxStreamError m_lasterror;

    friend class wxStreamBuffer;
};





class wxInputStream : public wxStreamBase
{
public:

    wxInputStream();
    virtual ~wxInputStream();
# 124 "/usr/include/wx/stream.h" 3 4
    virtual char Peek();





    char GetC();
# 143 "/usr/include/wx/stream.h" 3 4
    virtual wxInputStream& Read(void *buffer, size_t size);



    wxInputStream& Read(wxOutputStream& streamOut);
# 158 "/usr/include/wx/stream.h" 3 4
    virtual size_t LastRead() const { return wxStreamBase::m_lastcount; }



    virtual bool CanRead() const;





    virtual bool Eof() const;
# 178 "/usr/include/wx/stream.h" 3 4
    size_t Ungetch(const void *buffer, size_t size);




    bool Ungetch(char c);
# 193 "/usr/include/wx/stream.h" 3 4
    virtual off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);


    virtual off_t TellI() const;





    wxInputStream& operator>>(wxOutputStream& out) { return Read(out); }
    wxInputStream& operator>>(__wxInputManip func) { return func(*this); }

protected:





    virtual size_t OnSysRead(void *buffer, size_t size) = 0;





    char *AllocSpaceWBack(size_t sizeNeeded);



    size_t GetWBack(void *buf, size_t size);


    char *m_wback;


    size_t m_wbacksize;


    size_t m_wbackcur;

    friend class wxStreamBuffer;
};





class wxOutputStream : public wxStreamBase
{
public:
    wxOutputStream();
    virtual ~wxOutputStream();

    void PutC(char c);
    virtual wxOutputStream& Write(const void *buffer, size_t size);
    wxOutputStream& Write(wxInputStream& stream_in);

    virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
    virtual off_t TellO() const;

    virtual size_t LastWrite() const { return wxStreamBase::m_lastcount; }

    virtual void Sync();

    wxOutputStream& operator<<(wxInputStream& out) { return Write(out); }
    wxOutputStream& operator<<( __wxOutputManip func) { return func(*this); }

protected:


    virtual size_t OnSysWrite(const void *buffer, size_t bufsize);

    friend class wxStreamBuffer;
};
# 275 "/usr/include/wx/stream.h" 3 4
class wxCountingOutputStream : public wxOutputStream
{
public:
    wxCountingOutputStream();

    size_t GetSize() const;
    bool Ok() const { return ((bool)1); }

protected:
    virtual size_t OnSysWrite(const void *buffer, size_t size);
    virtual off_t OnSysSeek(off_t pos, wxSeekMode mode);
    virtual off_t OnSysTell() const;

    size_t m_currentPos;
};





class wxFilterInputStream : public wxInputStream
{
public:
    wxFilterInputStream();
    wxFilterInputStream(wxInputStream& stream);
    virtual ~wxFilterInputStream();

    char Peek() { return m_parent_i_stream->Peek(); }

    size_t GetSize() const { return m_parent_i_stream->GetSize(); }

    wxInputStream *GetFilterInputStream() const { return m_parent_i_stream; }

protected:
    wxInputStream *m_parent_i_stream;
};

class wxFilterOutputStream : public wxOutputStream
{
public:
    wxFilterOutputStream();
    wxFilterOutputStream(wxOutputStream& stream);
    virtual ~wxFilterOutputStream();

    size_t GetSize() const { return m_parent_o_stream->GetSize(); }

    wxOutputStream *GetFilterOutputStream() const { return m_parent_o_stream; }

protected:
    wxOutputStream *m_parent_o_stream;
};
# 336 "/usr/include/wx/stream.h" 3 4
class wxStreamBuffer
{
public:
    enum BufMode
    {
        read,
        write,
        read_write
    };

    wxStreamBuffer(wxStreamBase& stream, BufMode mode);
    wxStreamBuffer(const wxStreamBuffer& buf);
    virtual ~wxStreamBuffer();


    virtual size_t Read(void *buffer, size_t size);
    size_t Read(wxStreamBuffer *buf);
    virtual size_t Write(const void *buffer, size_t size);
    size_t Write(wxStreamBuffer *buf);

    virtual char Peek();
    virtual char GetChar();
    virtual void PutChar(char c);
    virtual off_t Tell() const;
    virtual off_t Seek(off_t pos, wxSeekMode mode);


    void ResetBuffer();



    void SetBufferIO(void *start, void *end, bool takeOwnership = ((bool)0));
    void SetBufferIO(void *start, size_t len, bool takeOwnership = ((bool)0));
    void SetBufferIO(size_t bufsize);
    void *GetBufferStart() const { return m_buffer_start; }
    void *GetBufferEnd() const { return m_buffer_end; }
    void *GetBufferPos() const { return m_buffer_pos; }
    size_t GetBufferSize() const { return m_buffer_size; }
    size_t GetIntPosition() const { return m_buffer_pos - m_buffer_start; }
    void SetIntPosition(size_t pos) { m_buffer_pos = m_buffer_start + pos; }
    size_t GetLastAccess() const { return m_buffer_end - m_buffer_start; }
    size_t GetBytesLeft() const { return m_buffer_end - m_buffer_pos; }

    void Fixed(bool fixed) { m_fixed = fixed; }
    void Flushable(bool f) { m_flushable = f; }

    bool FlushBuffer();
    bool FillBuffer();
    size_t GetDataLeft();


    wxStreamBase *GetStream() const { return m_stream; }
    bool HasBuffer() const { return m_buffer_size != 0; }

    bool IsFixed() const { return m_fixed; }
    bool IsFlushable() const { return m_flushable; }


    wxInputStream *GetInputStream() const;
    wxOutputStream *GetOutputStream() const;


    wxStreamBase *Stream() { return m_stream; }



    wxStreamBuffer(BufMode mode);

protected:
    void GetFromBuffer(void *buffer, size_t size);
    void PutToBuffer(const void *buffer, size_t size);


    void SetError(wxStreamError err);


    void Init();


    void InitBuffer();


    void FreeBuffer();



    char *m_buffer_start,
         *m_buffer_end,
         *m_buffer_pos;



    size_t m_buffer_size;


    wxStreamBase *m_stream;


    BufMode m_mode;


    bool m_destroybuf,
         m_fixed,
         m_flushable;
};





class wxBufferedInputStream : public wxFilterInputStream
{
public:

    wxBufferedInputStream(wxInputStream& stream,
                          wxStreamBuffer *buffer = __null);
    virtual ~wxBufferedInputStream();

    char Peek();
    wxInputStream& Read(void *buffer, size_t size);


    off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
    off_t TellI() const;


    void SetInputStreamBuffer(wxStreamBuffer *buffer);
    wxStreamBuffer *GetInputStreamBuffer() const { return m_i_streambuf; }


    wxStreamBuffer *InputStreamBuffer() const { return m_i_streambuf; }

protected:
    virtual size_t OnSysRead(void *buffer, size_t bufsize);
    virtual off_t OnSysSeek(off_t seek, wxSeekMode mode);
    virtual off_t OnSysTell() const;

    wxStreamBuffer *m_i_streambuf;
};





class wxBufferedOutputStream : public wxFilterOutputStream
{
public:

    wxBufferedOutputStream(wxOutputStream& stream,
                           wxStreamBuffer *buffer = __null);
    virtual ~wxBufferedOutputStream();

    wxOutputStream& Write(const void *buffer, size_t size);


    off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
    off_t TellO() const;

    void Sync();

    size_t GetSize() const;


    void SetOutputStreamBuffer(wxStreamBuffer *buffer);
    wxStreamBuffer *GetOutputStreamBuffer() const { return m_o_streambuf; }


    wxStreamBuffer *OutputStreamBuffer() const { return m_o_streambuf; }

protected:
    virtual size_t OnSysWrite(const void *buffer, size_t bufsize);
    virtual off_t OnSysSeek(off_t seek, wxSeekMode mode);
    virtual off_t OnSysTell() const;

    wxStreamBuffer *m_o_streambuf;
};
# 30 "/usr/include/wx/filesys.h" 2 3 4
# 1 "/usr/include/wx/url.h" 1 3 4
# 16 "/usr/include/wx/url.h" 3 4
#pragma interface "url.h"







# 1 "/usr/include/wx/protocol/protocol.h" 1 3 4
# 16 "/usr/include/wx/protocol/protocol.h" 3 4
#pragma interface
# 28 "/usr/include/wx/protocol/protocol.h" 3 4
# 1 "/usr/include/wx/socket.h" 1 3 4
# 16 "/usr/include/wx/socket.h" 3 4
#pragma interface "socket.h"
# 30 "/usr/include/wx/socket.h" 3 4
# 1 "/usr/include/wx/event.h" 1 3 4
# 16 "/usr/include/wx/event.h" 3 4
#pragma interface "event.h"




# 1 "/usr/include/wx/clntdata.h" 1 3 4
# 16 "/usr/include/wx/clntdata.h" 3 4
#pragma interface "clntdata.h"
# 25 "/usr/include/wx/clntdata.h" 3 4
enum wxClientDataType
{
    wxClientData_None,
    wxClientData_Object,
    wxClientData_Void
};

class wxClientData
{
public:
    wxClientData() { }
    virtual ~wxClientData() { }
};

class wxStringClientData : public wxClientData
{
public:
    wxStringClientData() : m_data() { }
    wxStringClientData( const wxString &data ) : m_data(data) { }
    void SetData( const wxString &data ) { m_data = data; }
    const wxString& GetData() const { return m_data; }

private:
    wxString m_data;
};
# 62 "/usr/include/wx/clntdata.h" 3 4
class wxClientDataContainer
{
public:
    wxClientDataContainer();
    virtual ~wxClientDataContainer();

    void SetClientObject( wxClientData *data ) { DoSetClientObject(data); }
    wxClientData *GetClientObject() const { return DoGetClientObject(); }

    void SetClientData( void *data ) { DoSetClientData(data); }
    void *GetClientData() const { return DoGetClientData(); }

protected:





    union
    {
        wxClientData *m_clientObject;
        void *m_clientData;
    };


    virtual void DoSetClientObject( wxClientData *data );
    virtual wxClientData *DoGetClientObject() const;

    virtual void DoSetClientData( void *data );
    virtual void *DoGetClientData() const;


    wxClientDataType m_clientDataType;

};
# 22 "/usr/include/wx/event.h" 2 3 4



# 1 "/usr/include/wx/cursor.h" 1 3 4
# 9 "/usr/include/wx/cursor.h" 3 4
# 1 "/usr/include/wx/gtk/cursor.h" 1 3 4
# 15 "/usr/include/wx/gtk/cursor.h" 3 4
#pragma interface







# 1 "/usr/include/wx/image.h" 1 3 4
# 14 "/usr/include/wx/image.h" 3 4
#pragma interface "image.h"






# 1 "/usr/include/wx/bitmap.h" 1 3 4
# 20 "/usr/include/wx/bitmap.h" 3 4
#pragma interface "bitmapbase.h"
# 29 "/usr/include/wx/bitmap.h" 3 4
class wxBitmap;
class wxBitmapHandler;
class wxImage;
class wxMask;
class wxPalette;
# 162 "/usr/include/wx/bitmap.h" 3 4
# 1 "/usr/include/wx/gtk/bitmap.h" 1 3 4
# 15 "/usr/include/wx/gtk/bitmap.h" 3 4
#pragma interface
# 28 "/usr/include/wx/gtk/bitmap.h" 3 4
class wxMask;
class wxBitmap;
class wxImage;





class wxMask: public wxObject
{
public:
    wxMask();
    wxMask( const wxBitmap& bitmap, const wxColour& colour );
    wxMask( const wxBitmap& bitmap, int paletteIndex );
    wxMask( const wxBitmap& bitmap );
    ~wxMask();

    bool Create( const wxBitmap& bitmap, const wxColour& colour );
    bool Create( const wxBitmap& bitmap, int paletteIndex );
    bool Create( const wxBitmap& bitmap );


    GdkBitmap *m_bitmap;

    GdkBitmap *GetBitmap() const;

private:
    public: static wxClassInfo sm_classwxMask; virtual wxClassInfo *GetClassInfo() const { return &wxMask::sm_classwxMask; }
};





class wxBitmap: public wxGDIObject
{
public:
    wxBitmap();
    wxBitmap( int width, int height, int depth = -1 );
    wxBitmap( const char bits[], int width, int height, int depth = 1 );
    wxBitmap( const char **bits ) { (void)CreateFromXpm(bits); }
    wxBitmap( char **bits ) { (void)CreateFromXpm((const char **)bits); }
    wxBitmap( const wxBitmap& bmp );
    wxBitmap( const wxString &filename, int type = wxBITMAP_TYPE_XPM );
    wxBitmap( const wxImage& image, int depth = -1 ) { (void)CreateFromImage(image, depth); }
    ~wxBitmap();
    wxBitmap& operator = ( const wxBitmap& bmp );
    bool operator == ( const wxBitmap& bmp ) const;
    bool operator != ( const wxBitmap& bmp ) const;
    bool Ok() const;

    bool Create(int width, int height, int depth = -1);

    int GetHeight() const;
    int GetWidth() const;
    int GetDepth() const;

    wxImage ConvertToImage() const;


    virtual bool CopyFromIcon(const wxIcon& icon);

    wxMask *GetMask() const;
    void SetMask( wxMask *mask );

    wxBitmap GetSubBitmap( const wxRect& rect ) const;

    bool SaveFile( const wxString &name, int type, wxPalette *palette = (wxPalette *) __null );
    bool LoadFile( const wxString &name, int type = wxBITMAP_TYPE_XPM );

    wxPalette *GetPalette() const;
    wxPalette *GetColourMap() const
    { return GetPalette(); };




    void SetHeight( int height );
    void SetWidth( int width );
    void SetDepth( int depth );
    void SetPixmap( GdkPixmap *pixmap );
    void SetBitmap( GdkBitmap *bitmap );

    GdkPixmap *GetPixmap() const;
    GdkBitmap *GetBitmap() const;

protected:
    bool CreateFromXpm(const char **bits);
    bool CreateFromImage(const wxImage& image, int depth);

private:
    public: static wxClassInfo sm_classwxBitmap; virtual wxClassInfo *GetClassInfo() const { return &wxBitmap::sm_classwxBitmap; }
};
# 163 "/usr/include/wx/bitmap.h" 2 3 4
# 22 "/usr/include/wx/image.h" 2 3 4
# 1 "/usr/include/wx/hashmap.h" 1 3 4
# 16 "/usr/include/wx/hashmap.h" 3 4
#pragma interface "hashmap.h"




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 22 "/usr/include/wx/hashmap.h" 2 3 4


struct _wxHashTable_NodeBase
{
    _wxHashTable_NodeBase() : m_nxt(0) {}

    _wxHashTable_NodeBase* m_nxt;
};






class _wxHashTableBase2
{
public:
    typedef void (*NodeDtor)(_wxHashTable_NodeBase*);
    typedef unsigned long (*BucketFromNode)(_wxHashTableBase2*,_wxHashTable_NodeBase*);
    typedef _wxHashTable_NodeBase* (*ProcessNode)(_wxHashTable_NodeBase*);
protected:
    static _wxHashTable_NodeBase* DummyProcessNode(_wxHashTable_NodeBase* node);
    static void DeleteNodes( size_t buckets, _wxHashTable_NodeBase** table,
                             NodeDtor dtor );
    static _wxHashTable_NodeBase* GetFirstNode( size_t buckets,
                                                _wxHashTable_NodeBase** table )
    {
        for( size_t i = 0; i < buckets; ++i )
            if( table[i] )
                return table[i];
        return 0;
    }


    enum { prime_count = 31 };
    static const unsigned long ms_primes[prime_count];


    static unsigned long GetNextPrime( unsigned long n );



    static unsigned long GetPreviousPrime( unsigned long n );

    static void CopyHashTable( _wxHashTable_NodeBase** srcTable,
                               size_t srcBuckets, _wxHashTableBase2* dst,
                               _wxHashTable_NodeBase** dstTable,
                               BucketFromNode func, ProcessNode proc );

    static void** AllocTable( size_t sz )
    {
        return (void **)calloc(sz, sizeof(void*));
    }
};
# 398 "/usr/include/wx/hashmap.h" 3 4
inline bool never_grow( size_t, size_t ) { return ((bool)0); }
inline bool never_shrink( size_t, size_t ) { return ((bool)0); }
inline bool grow_lf70( size_t buckets, size_t items )
{
    return float(items)/float(buckets) >= 0.85;
}
# 414 "/usr/include/wx/hashmap.h" 3 4
class wxIntegerHash
{
public:
    wxIntegerHash() { }
    unsigned long operator()( long x ) const { return (unsigned long)x; }
    unsigned long operator()( unsigned long x ) const { return x; }
    unsigned long operator()( int x ) const { return (unsigned long)x; }
    unsigned long operator()( unsigned int x ) const { return x; }
    unsigned long operator()( short x ) const { return (unsigned long)x; }
    unsigned long operator()( unsigned short x ) const { return x; }

    wxIntegerHash& operator=(const wxIntegerHash&) { return *this; }
};

class wxIntegerEqual
{
public:
    wxIntegerEqual() { }
    bool operator()( long a, long b ) const { return a == b; }
    bool operator()( unsigned long a, unsigned long b ) const { return a == b; }
    bool operator()( int a, int b ) const { return a == b; }
    bool operator()( unsigned int a, unsigned int b ) const { return a == b; }
    bool operator()( short a, short b ) const { return a == b; }
    bool operator()( unsigned short a, unsigned short b ) const { return a == b; }

    wxIntegerEqual& operator=(const wxIntegerEqual&) { return *this; }
};


class wxPointerHash
{
public:
    wxPointerHash() { }



    unsigned long operator()( const void* k ) const { return (unsigned long)k; }

    wxPointerHash& operator=(const wxPointerHash&) { return *this; }
};

class wxPointerEqual
{
public:
    wxPointerEqual() { }
    bool operator()( const void* a, const void* b ) const { return a == b; }

    wxPointerEqual& operator=(const wxPointerEqual&) { return *this; }
};


class wxStringHash
{
public:
    wxStringHash() {}
    unsigned long operator()( const wxString& x ) const
        { return wxCharStringHash( x.c_str() ); }
    unsigned long operator()( const wxChar* x ) const
        { return wxCharStringHash( x ); }
    static unsigned long wxCharStringHash( const wxChar* );






    wxStringHash& operator=(const wxStringHash&) { return *this; }
};

class wxStringEqual
{
public:
    wxStringEqual() {}
    bool operator()( const wxString& a, const wxString& b ) const
        { return a == b; }
    bool operator()( const wxChar* a, const wxChar* b ) const
        { return strcmp( a, b ) == 0; }





    wxStringEqual& operator=(const wxStringEqual&) { return *this; }
};
# 23 "/usr/include/wx/image.h" 2 3 4
# 36 "/usr/include/wx/image.h" 3 4
class wxImageHandler;
class wxImage;





class wxImageHandler: public wxObject
{
public:
    wxImageHandler()
        : m_name(""), m_extension(""), m_mime(), m_type(0)
        { }


    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=((bool)1) );

    virtual int GetImageCount( wxInputStream& stream );

    bool CanRead( wxInputStream& stream ) { return CallDoCanRead(stream); }
    bool CanRead( const wxString& name );


    void SetName(const wxString& name) { m_name = name; }
    void SetExtension(const wxString& ext) { m_extension = ext; }
    void SetType(long type) { m_type = type; }
    void SetMimeType(const wxString& type) { m_mime = type; }
    wxString GetName() const { return m_name; }
    wxString GetExtension() const { return m_extension; }
    long GetType() const { return m_type; }
    wxString GetMimeType() const { return m_mime; }

protected:

    virtual bool DoCanRead( wxInputStream& stream ) = 0;


    bool CallDoCanRead(wxInputStream& stream);


    wxString m_name;
    wxString m_extension;
    wxString m_mime;
    long m_type;

private:
    public: static wxClassInfo sm_classwxImageHandler; virtual wxClassInfo *GetClassInfo() const { return &wxImageHandler::sm_classwxImageHandler; }
};





class wxImageHistogramEntry
{
public:
    wxImageHistogramEntry() : index(0), value(0) {}
    unsigned long index;
    unsigned long value;
};





class wxImageHistogram_wxImplementation_Pair { public: typedef unsigned long t1; typedef wxImageHistogramEntry t2; typedef const unsigned long const_t1; typedef const wxImageHistogramEntry const_t2; wxImageHistogram_wxImplementation_Pair( const const_t1& f, const const_t2& s ):first(t1(f)),second(t2(s)) {} wxImageHistogram_wxImplementation_Pair( const const_t1& f ):first(t1(f)),second(t2()) {} t1 first; t2 second; }; class wxImageHistogram_wxImplementation_KeyEx { typedef unsigned long key_type; typedef wxImageHistogram_wxImplementation_Pair pair_type; typedef const key_type const_key_type; typedef const pair_type const_pair_type; typedef const_key_type& const_key_reference; typedef const_pair_type& const_pair_reference; public: wxImageHistogram_wxImplementation_KeyEx() { } const_key_reference operator()( const_pair_reference pair ) const { return pair.first; } wxImageHistogram_wxImplementation_KeyEx& operator=(const wxImageHistogram_wxImplementation_KeyEx&) { return *this; } }; class wxImageHistogram_wxImplementation_HashTable : protected _wxHashTableBase2 { public: typedef unsigned long key_type; typedef wxImageHistogram_wxImplementation_Pair value_type; typedef wxIntegerHash hasher; typedef wxIntegerEqual key_equal; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; typedef const value_type& const_reference; typedef const unsigned long const_key_type; typedef const wxImageHistogram_wxImplementation_Pair const_mapped_type; public: struct Node; typedef wxImageHistogram_wxImplementation_KeyEx key_extractor; typedef wxImageHistogram_wxImplementation_HashTable Self; protected: Node** m_table; size_t m_tableBuckets; size_t m_items; hasher m_hasher; key_equal m_equals; key_extractor m_getKey; public: struct Node:public _wxHashTable_NodeBase { public: Node( const value_type& value ) : m_value( value ) {} Node* m_next() { return (Node*)this->m_nxt; } value_type m_value; }; struct Iterator; friend struct Iterator; protected: static void DeleteNode( _wxHashTable_NodeBase* node ) { delete (Node*)node; } public: struct Iterator { Node* m_node; Self* m_ht; Iterator() : m_node(0), m_ht(0) {} Iterator( Node* node, const Self* ht ) : m_node(node), m_ht((Self*)ht) {} bool operator ==( const Iterator& it ) const { return m_node == it.m_node; } bool operator !=( const Iterator& it ) const { return m_node != it.m_node; } protected: Node* GetNextNode() { size_type bucket = GetBucketForNode(m_ht,m_node); for( size_type i = bucket + 1; i < m_ht->m_tableBuckets; ++i ) { if( m_ht->m_table[i] ) return m_ht->m_table[i]; } return 0; } void PlusPlus() { Node* next = m_node->m_next(); m_node = next ? next : GetNextNode(); } }; public: struct iterator:public Iterator { iterator() : Iterator() {} iterator( Node* node, Self* ht ) : Iterator( node, ht ) {} iterator& operator++() { PlusPlus(); return *this; } iterator operator++(int) { iterator it=*this;PlusPlus();return it; } reference operator *() const { return m_node->m_value; } pointer operator ->() const { return &(m_node->m_value); } }; struct const_iterator:public Iterator { const_iterator() : Iterator() {} const_iterator( Node* node, const Self* ht ) : Iterator( node, (Self*)ht ) {} const_iterator& operator++() { PlusPlus();return *this; } const_iterator operator++(int) { const_iterator it=*this;PlusPlus();return it; } const_reference operator *() const { return m_node->m_value; } const_pointer operator ->() const { return &(m_node->m_value); } }; wxImageHistogram_wxImplementation_HashTable( size_type sz = 10, const hasher& hfun = hasher(), const key_equal& k_eq = key_equal(), const key_extractor& k_ex = key_extractor() ) : m_tableBuckets( GetNextPrime( sz ) ), m_items( 0 ), m_hasher( hfun ), m_equals( k_eq ), m_getKey( k_ex ) { m_table = (Node**)AllocTable( m_tableBuckets ); } wxImageHistogram_wxImplementation_HashTable( const Self& ht ) : m_table( 0 ), m_tableBuckets( 0 ), m_items( ht.m_items ), m_hasher( ht.m_hasher ), m_equals( ht.m_equals ), m_getKey( ht.m_getKey ) { HashCopy( ht ); } const Self& operator=( const Self& ht ) { clear(); m_hasher = ht.m_hasher; m_equals = ht.m_equals; m_getKey = ht.m_getKey; m_items = ht.m_items; HashCopy( ht ); return *this; } ~wxImageHistogram_wxImplementation_HashTable() { clear(); free(m_table); } hasher hash_funct() { return m_hasher; } key_equal key_eq() { return m_equals; } void clear() { DeleteNodes( m_tableBuckets, (_wxHashTable_NodeBase**)m_table, DeleteNode ); m_items = 0; } size_type size() const { return m_items; } size_type max_size() const { return size_type(-1); } bool empty() const { return size() == 0; } const_iterator end() const { return const_iterator( 0, this ); } iterator end() { return iterator( 0, this ); } const_iterator begin() const { return const_iterator( (Node*)GetFirstNode( m_tableBuckets, (_wxHashTable_NodeBase**)m_table ), this ); }; iterator begin() { return iterator( (Node*)GetFirstNode( m_tableBuckets, (_wxHashTable_NodeBase**)m_table ), this ); }; size_type erase( const const_key_type& key ) { Node** node = GetNodePtr( key ); if( !node ) return 0; --m_items; Node* temp = (*node)->m_next(); delete *node; (*node) = temp; if( never_shrink( m_tableBuckets, m_items ) ) ResizeTable( GetPreviousPrime( m_tableBuckets ) - 1 ); return 1; } protected: static size_type GetBucketForNode( Self* ht, Node* node ) { return ht->m_hasher( ht->m_getKey( node->m_value ) ) % ht->m_tableBuckets; } static Node* CopyNode( Node* node ) { return new Node( *node ); } Node* GetOrCreateNode( const value_type& value ) { const const_key_type& key = m_getKey( value ); size_t bucket = m_hasher( key ) % m_tableBuckets; Node* node = m_table[bucket]; while( node ) { if( m_equals( m_getKey( node->m_value ), key ) ) return node; node = node->m_next(); } node = new Node( value ); node->m_nxt = m_table[bucket]; m_table[bucket] = node; ++m_items; if( grow_lf70( m_tableBuckets, m_items ) ) ResizeTable( m_tableBuckets ); return node; } Node** GetNodePtr( const const_key_type& key ) const { unsigned long hash = m_hasher( key ); Node** node = &m_table[hash % m_tableBuckets]; while( *node ) { if( m_equals( m_getKey( (*node)->m_value ), key ) ) return node; node = (Node**)&(*node)->m_nxt; } return 0; } Node* GetNode( const const_key_type& key ) const { unsigned long hash = m_hasher( key ); Node* node = m_table[hash % m_tableBuckets]; while( node ) { if( m_equals( m_getKey( node->m_value ), key ) ) return node; node = node->m_next(); } return 0; } void ResizeTable( size_t newSize ) { newSize = GetNextPrime( newSize ); Node** srcTable = m_table; size_t srcBuckets = m_tableBuckets; m_table = (Node**)AllocTable( newSize ); m_tableBuckets = newSize; CopyHashTable( (_wxHashTable_NodeBase**)srcTable, srcBuckets, this, (_wxHashTable_NodeBase**)m_table, (BucketFromNode)GetBucketForNode, (ProcessNode)&DummyProcessNode ); free(srcTable); } void HashCopy( const Self& ht ) { ResizeTable( ht.size() ); CopyHashTable( (_wxHashTable_NodeBase**)ht.m_table, ht.m_tableBuckets, (_wxHashTableBase2*)this, (_wxHashTable_NodeBase**)m_table, (BucketFromNode)GetBucketForNode, (ProcessNode)CopyNode ); } }; class wxImageHistogram:public wxImageHistogram_wxImplementation_HashTable { public: typedef wxImageHistogramEntry mapped_type; wxImageHistogram( size_type hint = 100, hasher hf = hasher(), key_equal eq = key_equal() ) : wxImageHistogram_wxImplementation_HashTable( hint, hf, eq, wxImageHistogram_wxImplementation_KeyEx() ) {} mapped_type& operator[]( const const_key_type& key ) { return GetOrCreateNode( wxImageHistogram_wxImplementation_Pair( key ) )->m_value.second; } const_iterator find( const const_key_type& key ) const { return const_iterator( GetNode( key ), this ); } iterator find( const const_key_type& key ) { return iterator( GetNode( key ), this ); } void insert( const value_type& v ) { (*this)[v.first] = v.second; } size_type erase( const key_type& k ) { return wxImageHistogram_wxImplementation_HashTable::erase( k ); } void erase( const iterator& it ) { erase( it->first ); } void erase( const const_iterator& it ) { erase( it->first ); } size_type count( const const_key_type& key ) { return GetNode( key ) ? 1 : 0; } };
# 114 "/usr/include/wx/image.h" 3 4
class wxImage: public wxObject
{
public:
    wxImage();
    wxImage( int width, int height );
    wxImage( int width, int height, unsigned char* data, bool static_data = ((bool)0) );
    wxImage( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
    wxImage( const wxString& name, const wxString& mimetype, int index = -1 );


    wxImage( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1 );
    wxImage( wxInputStream& stream, const wxString& mimetype, int index = -1 );


    wxImage( const wxImage& image );
    wxImage( const wxImage* image );



    wxImage( const wxBitmap &bitmap );
    wxBitmap ConvertToBitmap() const;

    wxBitmap ConvertToMonoBitmap( unsigned char red, unsigned char green, unsigned char blue ) const;



    void Create( int width, int height );
    void Create( int width, int height, unsigned char* data, bool static_data = ((bool)0) );
    void Destroy();



    wxImage Copy() const;


    wxImage GetSubImage( const wxRect& ) const;



    void Paste( const wxImage &image, int x, int y );


    wxImage Scale( int width, int height ) const;

    wxImage ShrinkBy( int xFactor , int yFactor ) const ;


    wxImage& Rescale( int width, int height ) { return *this = Scale(width, height); }



    wxImage Rotate(double angle, const wxPoint & centre_of_rotation,
                   bool interpolating = ((bool)1), wxPoint * offset_after_rotation = (wxPoint*) __null) const;

    wxImage Rotate90( bool clockwise = ((bool)1) ) const;
    wxImage Mirror( bool horizontally = ((bool)1) ) const;


    void Replace( unsigned char r1, unsigned char g1, unsigned char b1,
                  unsigned char r2, unsigned char g2, unsigned char b2 );


    wxImage ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const;


    void SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b );
    unsigned char GetRed( int x, int y ) const;
    unsigned char GetGreen( int x, int y ) const;
    unsigned char GetBlue( int x, int y ) const;



    bool FindFirstUnusedColour( unsigned char *r, unsigned char *g, unsigned char *b,
                                unsigned char startR = 1, unsigned char startG = 0,
                                unsigned char startB = 0 ) const;

    bool SetMaskFromImage(const wxImage & mask,
                          unsigned char mr, unsigned char mg, unsigned char mb);

    static bool CanRead( const wxString& name );
    static int GetImageCount( const wxString& name, long type = wxBITMAP_TYPE_ANY );
    virtual bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
    virtual bool LoadFile( const wxString& name, const wxString& mimetype, int index = -1 );


    static bool CanRead( wxInputStream& stream );
    static int GetImageCount( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY );
    virtual bool LoadFile( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1 );
    virtual bool LoadFile( wxInputStream& stream, const wxString& mimetype, int index = -1 );


    virtual bool SaveFile( const wxString& name ) const;
    virtual bool SaveFile( const wxString& name, int type ) const;
    virtual bool SaveFile( const wxString& name, const wxString& mimetype ) const;


    virtual bool SaveFile( wxOutputStream& stream, int type ) const;
    virtual bool SaveFile( wxOutputStream& stream, const wxString& mimetype ) const;


    bool Ok() const;
    int GetWidth() const;
    int GetHeight() const;

    char unsigned *GetData() const;
    void SetData( char unsigned *data );
    void SetData( char unsigned *data, int new_width, int new_height );


    void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );
    unsigned char GetMaskRed() const;
    unsigned char GetMaskGreen() const;
    unsigned char GetMaskBlue() const;
    void SetMask( bool mask = ((bool)1) );
    bool HasMask() const;



    bool HasPalette() const;
    const wxPalette& GetPalette() const;
    void SetPalette(const wxPalette& palette);



    void SetOption(const wxString& name, const wxString& value);
    void SetOption(const wxString& name, int value);
    wxString GetOption(const wxString& name) const;
    int GetOptionInt(const wxString& name) const;
    bool HasOption(const wxString& name) const;

    unsigned long CountColours( unsigned long stopafter = (unsigned long) -1 ) const;







    unsigned long ComputeHistogram( wxImageHistogram &h ) const;

    wxImage& operator = (const wxImage& image)
    {
        if ( (*this) != image )
            Ref(image);
        return *this;
    }

    bool operator == (const wxImage& image) const
        { return m_refData == image.m_refData; }
    bool operator != (const wxImage& image) const
        { return m_refData != image.m_refData; }

    static wxList& GetHandlers() { return sm_handlers; }
    static void AddHandler( wxImageHandler *handler );
    static void InsertHandler( wxImageHandler *handler );
    static bool RemoveHandler( const wxString& name );
    static wxImageHandler *FindHandler( const wxString& name );
    static wxImageHandler *FindHandler( const wxString& extension, long imageType );
    static wxImageHandler *FindHandler( long imageType );
    static wxImageHandler *FindHandlerMime( const wxString& mimetype );

    static void CleanUpHandlers();
    static void InitStandardHandlers();

protected:
    static wxList sm_handlers;

private:
    friend class wxImageHandler;

    public: static wxClassInfo sm_classwxImage; virtual wxClassInfo *GetClassInfo() const { return &wxImage::sm_classwxImage; }
};


extern void wxInitAllImageHandlers();

extern wxImage wxNullImage;





# 1 "/usr/include/wx/imagbmp.h" 1 3 4
# 14 "/usr/include/wx/imagbmp.h" 3 4
#pragma interface "imagbmp.h"


# 1 "/usr/include/wx/image.h" 1 3 4
# 18 "/usr/include/wx/imagbmp.h" 2 3 4
# 34 "/usr/include/wx/imagbmp.h" 3 4
enum
{
    wxBMP_24BPP = 24,

    wxBMP_8BPP = 8,
    wxBMP_8BPP_GREY = 9,
    wxBMP_8BPP_GRAY = wxBMP_8BPP_GREY,
    wxBMP_8BPP_RED = 10,
    wxBMP_8BPP_PALETTE = 11,
    wxBMP_4BPP = 4,
    wxBMP_1BPP = 1,
    wxBMP_1BPP_BW = 2
};





class wxBMPHandler : public wxImageHandler
{
public:
    wxBMPHandler()
    {
        m_name = "Windows bitmap file";
        m_extension = "bmp";
        m_type = wxBITMAP_TYPE_BMP;
        m_mime = "image/x-bmp";
    };


    virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=((bool)1) );
    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool DoCanRead( wxInputStream& stream );

protected:
    bool SaveDib(wxImage *image, wxOutputStream& stream, bool verbose,
                 bool IsBmp, bool IsMask);
    bool DoLoadDib(wxImage *image, int width, int height, int bpp, int ncolors,
                   int comp, off_t bmpOffset, wxInputStream& stream,
                   bool verbose, bool IsBmp, bool hasPalette);
    bool LoadDib(wxImage *image, wxInputStream& stream, bool verbose, bool IsBmp);


private:
     public: static wxClassInfo sm_classwxBMPHandler; virtual wxClassInfo *GetClassInfo() const { return &wxBMPHandler::sm_classwxBMPHandler; }
};






class wxICOHandler : public wxBMPHandler
{
public:
    wxICOHandler()
    {
        m_name = "Windows icon file";
        m_extension = "ico";
        m_type = wxBITMAP_TYPE_ICO;
        m_mime = "image/x-ico";
    };


    virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=((bool)1) );
    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool DoLoadFile( wxImage *image, wxInputStream& stream, bool verbose, int index );
    virtual bool DoCanRead( wxInputStream& stream );
    virtual int GetImageCount( wxInputStream& stream );


private:
    public: static wxClassInfo sm_classwxICOHandler; virtual wxClassInfo *GetClassInfo() const { return &wxICOHandler::sm_classwxICOHandler; }
};






class wxCURHandler : public wxICOHandler
{
public:
    wxCURHandler()
    {
        m_name = "Windows cursor file";
        m_extension = "cur";
        m_type = wxBITMAP_TYPE_CUR;
        m_mime = "image/x-cur";
    };






    virtual bool DoCanRead( wxInputStream& stream );


private:
    public: static wxClassInfo sm_classwxCURHandler; virtual wxClassInfo *GetClassInfo() const { return &wxCURHandler::sm_classwxCURHandler; }
};




class wxANIHandler : public wxCURHandler
{
public:
    wxANIHandler()
    {
        m_name = "Windows animated cursor file";
        m_extension = "ani";
        m_type = wxBITMAP_TYPE_ANI;
        m_mime = "image/x-ani";
    };



    virtual bool SaveFile( wxImage *, wxOutputStream& , bool ){return ((bool)0) ;};
    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool DoCanRead( wxInputStream& stream );
    virtual int GetImageCount( wxInputStream& stream );


private:
    public: static wxClassInfo sm_classwxANIHandler; virtual wxClassInfo *GetClassInfo() const { return &wxANIHandler::sm_classwxANIHandler; }
};
# 297 "/usr/include/wx/image.h" 2 3 4
# 1 "/usr/include/wx/imagpng.h" 1 3 4
# 14 "/usr/include/wx/imagpng.h" 3 4
#pragma interface "imagpng.h"
# 24 "/usr/include/wx/imagpng.h" 3 4
class wxPNGHandler: public wxImageHandler
{
public:
    inline wxPNGHandler()
    {
        m_name = "PNG file";
        m_extension = "png";
        m_type = wxBITMAP_TYPE_PNG;
        m_mime = "image/png";
    }


    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=((bool)1) );
    virtual bool DoCanRead( wxInputStream& stream );


private:
    public: static wxClassInfo sm_classwxPNGHandler; virtual wxClassInfo *GetClassInfo() const { return &wxPNGHandler::sm_classwxPNGHandler; }
};
# 298 "/usr/include/wx/image.h" 2 3 4
# 1 "/usr/include/wx/imaggif.h" 1 3 4
# 14 "/usr/include/wx/imaggif.h" 3 4
#pragma interface "imaggif.h"
# 26 "/usr/include/wx/imaggif.h" 3 4
class wxGIFHandler : public wxImageHandler
{
public:
    inline wxGIFHandler()
    {
        m_name = "GIF file";
        m_extension = "gif";
        m_type = wxBITMAP_TYPE_GIF;
        m_mime = "image/gif";
    }


    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=((bool)1) );
    virtual bool DoCanRead( wxInputStream& stream );


private:
    public: static wxClassInfo sm_classwxGIFHandler; virtual wxClassInfo *GetClassInfo() const { return &wxGIFHandler::sm_classwxGIFHandler; }
};
# 299 "/usr/include/wx/image.h" 2 3 4
# 1 "/usr/include/wx/imagpcx.h" 1 3 4
# 14 "/usr/include/wx/imagpcx.h" 3 4
#pragma interface "imagpcx.h"
# 25 "/usr/include/wx/imagpcx.h" 3 4
class wxPCXHandler : public wxImageHandler
{
public:
    inline wxPCXHandler()
    {
        m_name = "PCX file";
        m_extension = "pcx";
        m_type = wxBITMAP_TYPE_PCX;
        m_mime = "image/pcx";
    }


    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=((bool)1) );
    virtual bool DoCanRead( wxInputStream& stream );


private:
    public: static wxClassInfo sm_classwxPCXHandler; virtual wxClassInfo *GetClassInfo() const { return &wxPCXHandler::sm_classwxPCXHandler; }
};
# 300 "/usr/include/wx/image.h" 2 3 4
# 1 "/usr/include/wx/imagjpeg.h" 1 3 4
# 14 "/usr/include/wx/imagjpeg.h" 3 4
#pragma interface "imagjpeg.h"
# 24 "/usr/include/wx/imagjpeg.h" 3 4
class wxJPEGHandler: public wxImageHandler
{
public:
    inline wxJPEGHandler()
    {
        m_name = "JPEG file";
        m_extension = "jpg";
        m_type = wxBITMAP_TYPE_JPEG;
        m_mime = "image/jpeg";
    }


    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=((bool)1) );
    virtual bool DoCanRead( wxInputStream& stream );


private:
    public: static wxClassInfo sm_classwxJPEGHandler; virtual wxClassInfo *GetClassInfo() const { return &wxJPEGHandler::sm_classwxJPEGHandler; }
};
# 301 "/usr/include/wx/image.h" 2 3 4
# 1 "/usr/include/wx/imagtiff.h" 1 3 4
# 14 "/usr/include/wx/imagtiff.h" 3 4
#pragma interface "imagtiff.h"
# 25 "/usr/include/wx/imagtiff.h" 3 4
class wxTIFFHandler: public wxImageHandler
{
public:
    inline wxTIFFHandler()
    {
        m_name = "TIFF file";
        m_extension = "tif";
        m_type = wxBITMAP_TYPE_TIF;
        m_mime = "image/tiff";
    }


    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=((bool)1) );
    virtual bool DoCanRead( wxInputStream& stream );
    virtual int GetImageCount( wxInputStream& stream );


private:
    public: static wxClassInfo sm_classwxTIFFHandler; virtual wxClassInfo *GetClassInfo() const { return &wxTIFFHandler::sm_classwxTIFFHandler; }
};
# 302 "/usr/include/wx/image.h" 2 3 4
# 1 "/usr/include/wx/imagpnm.h" 1 3 4
# 14 "/usr/include/wx/imagpnm.h" 3 4
#pragma interface "imagpnm.h"
# 24 "/usr/include/wx/imagpnm.h" 3 4
class wxPNMHandler : public wxImageHandler
{
public:
    inline wxPNMHandler()
    {
        m_name = "PNM file";
        m_extension = "pnm";
        m_type = wxBITMAP_TYPE_PNM;
        m_mime = "image/pnm";
    }


    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=((bool)1) );
    virtual bool DoCanRead( wxInputStream& stream );


private:
    public: static wxClassInfo sm_classwxPNMHandler; virtual wxClassInfo *GetClassInfo() const { return &wxPNMHandler::sm_classwxPNMHandler; }
};
# 303 "/usr/include/wx/image.h" 2 3 4
# 1 "/usr/include/wx/imagxpm.h" 1 3 4
# 14 "/usr/include/wx/imagxpm.h" 3 4
#pragma interface "imagxpm.h"
# 24 "/usr/include/wx/imagxpm.h" 3 4
class wxXPMHandler : public wxImageHandler
{
public:
    inline wxXPMHandler()
    {
        m_name = "XPM file";
        m_extension = "xpm";
        m_type = wxBITMAP_TYPE_XPM;
        m_mime = "image/xpm";
    }


    virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=((bool)1), int index=-1 );
    virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=((bool)1) );
    virtual bool DoCanRead( wxInputStream& stream );


private:
    public: static wxClassInfo sm_classwxXPMHandler; virtual wxClassInfo *GetClassInfo() const { return &wxXPMHandler::sm_classwxXPMHandler; }
};
# 304 "/usr/include/wx/image.h" 2 3 4
# 1 "/usr/include/wx/imagiff.h" 1 3 4
# 14 "/usr/include/wx/imagiff.h" 3 4
#pragma interface "imagiff.h"
# 305 "/usr/include/wx/image.h" 2 3 4
# 24 "/usr/include/wx/gtk/cursor.h" 2 3 4






class wxCursor: public wxObject
{
public:

    wxCursor();
    wxCursor( int cursorId );
    wxCursor( const wxCursor &cursor );

    wxCursor( const wxImage & image );

    wxCursor( const char bits[], int width, int height,
              int hotSpotX=-1, int hotSpotY=-1,
              const char maskBits[]=0, wxColour *fg=0, wxColour *bg=0 );
    ~wxCursor();
    wxCursor& operator = ( const wxCursor& cursor );
    bool operator == ( const wxCursor& cursor ) const;
    bool operator != ( const wxCursor& cursor ) const;
    bool Ok() const;



    GdkCursor *GetCursor() const;

private:
    public: static wxClassInfo sm_classwxCursor; virtual wxClassInfo *GetClassInfo() const { return &wxCursor::sm_classwxCursor; }
};
# 10 "/usr/include/wx/cursor.h" 2 3 4
# 22 "/usr/include/wx/cursor.h" 3 4
# 1 "/usr/include/wx/utils.h" 1 3 4
# 20 "/usr/include/wx/utils.h" 3 4
#pragma interface "utils.h"
# 42 "/usr/include/wx/utils.h" 3 4
class wxProcess;
class wxFrame;
class wxWindow;
class wxWindowList;
class wxPoint;
# 66 "/usr/include/wx/utils.h" 3 4
 wxChar* copystring(const wxChar *s);
# 81 "/usr/include/wx/utils.h" 3 4
 void wxBell();


 wxString wxGetOsDescription();


 int wxGetOsVersion(int *majorVsn = (int *) __null,
                               int *minorVsn = (int *) __null);


 wxString wxNow();


 const wxChar *wxGetInstallPrefix();

 wxString wxGetDataDir();






 bool wxSetDetectableAutoRepeat( bool flag );






 long wxNewId();





 void wxRegisterId(long id);





 long wxGetCurrentId();







extern const wxChar* wxFloatToStringStr;
extern const wxChar* wxDoubleToStringStr;

 void StringToFloat(const wxChar *s, float *number);
 wxChar* FloatToString(float number, const wxChar *fmt = wxFloatToStringStr);
 void StringToDouble(const wxChar *s, double *number);
 wxChar* DoubleToString(double number, const wxChar *fmt = wxDoubleToStringStr);
 void StringToInt(const wxChar *s, int *number);
 void StringToLong(const wxChar *s, long *number);
 wxChar* IntToString(int number);
 wxChar* LongToString(long number);


 int wxHexToDec(const wxString& buf);


 void wxDecToHex(int dec, wxChar *buf);
 wxString wxDecToHex(int dec);
# 156 "/usr/include/wx/utils.h" 3 4
enum
{

    wxEXEC_ASYNC = 0,


    wxEXEC_SYNC = 1,



    wxEXEC_NOHIDE = 2,



    wxEXEC_MAKE_GROUP_LEADER = 4
};






 long wxExecute(wxChar **argv, int flags = wxEXEC_ASYNC,
                           wxProcess *process = (wxProcess *) __null);
 long wxExecute(const wxString& command, int flags = wxEXEC_ASYNC,
                           wxProcess *process = (wxProcess *) __null);



 long wxExecute(const wxString& command,
                           wxArrayString& output);


 long wxExecute(const wxString& command,
                           wxArrayString& output,
                           wxArrayString& error);

enum wxSignal
{
    wxSIGNONE = 0,
    wxSIGHUP,
    wxSIGINT,
    wxSIGQUIT,
    wxSIGILL,
    wxSIGTRAP,
    wxSIGABRT,
    wxSIGIOT = wxSIGABRT,
    wxSIGEMT,
    wxSIGFPE,
    wxSIGKILL,
    wxSIGBUS,
    wxSIGSEGV,
    wxSIGSYS,
    wxSIGPIPE,
    wxSIGALRM,
    wxSIGTERM


};

enum wxKillError
{
    wxKILL_OK,
    wxKILL_BAD_SIGNAL,
    wxKILL_ACCESS_DENIED,
    wxKILL_NO_PROCESS,
    wxKILL_ERROR
};

enum wxShutdownFlags
{
    wxSHUTDOWN_POWEROFF,
    wxSHUTDOWN_REBOOT
};


 bool wxShutdown(wxShutdownFlags wFlags);





 int wxKill(long pid,
                       wxSignal sig = wxSIGTERM,
                       wxKillError *rc = __null);



 bool wxShell(const wxString& command = wxEmptyString);



 bool wxShell(const wxString& command, wxArrayString& output);


 void wxSleep(int nSecs);


 void wxUsleep(unsigned long milliseconds);


 unsigned long wxGetProcessId();


 long wxGetFreeMemory();


 bool wxHandleFatalExceptions(bool doit = ((bool)1));







 bool wxGetEnv(const wxString& var, wxString *value);


 bool wxSetEnv(const wxString& var, const wxChar *value);


inline bool wxUnsetEnv(const wxString& var) { return wxSetEnv(var, __null); }
# 286 "/usr/include/wx/utils.h" 3 4
 bool wxGetEmailAddress(wxChar *buf, int maxSize);
 wxString wxGetEmailAddress();


 bool wxGetHostName(wxChar *buf, int maxSize);
 wxString wxGetHostName();


 wxString wxGetFullHostName();
 bool wxGetFullHostName(wxChar *buf, int maxSize);


 bool wxGetUserId(wxChar *buf, int maxSize);
 wxString wxGetUserId();


 bool wxGetUserName(wxChar *buf, int maxSize);
 wxString wxGetUserName();


 wxString wxGetHomeDir();
 const wxChar* wxGetHomeDir(wxString *pstr);






 wxChar* wxGetUserHome(const wxString& user = wxEmptyString);



 bool wxGetDiskSpace(const wxString& path,
                                wxLongLong *pTotal = __null,
                                wxLongLong *pFree = __null);







 wxChar* wxStripMenuCodes(const wxChar *in, wxChar *out = (wxChar *) __null);
 wxString wxStripMenuCodes(const wxString& str);


class wxAcceleratorEntry;
 wxAcceleratorEntry *wxGetAccelFromString(const wxString& label);







 int wxFindMenuItemId(wxFrame *frame, const wxString& menuString, const wxString& itemString);



 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt);
 wxWindow* wxFindWindowAtPoint(const wxPoint& pt);






 wxWindow* wxFindWindowByLabel(const wxString& title, wxWindow *parent = (wxWindow *) __null);




 wxWindow* wxFindWindowByName(const wxString& name, wxWindow *parent = (wxWindow *) __null);
# 367 "/usr/include/wx/utils.h" 3 4
 bool wxYield();


 bool wxYieldIfNeeded();


 bool wxSafeYield(wxWindow *win = __null, bool onlyIfNeeded = ((bool)0));


 void wxEnableTopLevelWindows(bool enable = ((bool)1));



 bool wxCheckForInterrupt(wxWindow *wnd);


 void wxFlushEvents();



class wxWindowDisabler
{
public:
    wxWindowDisabler(wxWindow *winToSkip = (wxWindow *)__null);
    ~wxWindowDisabler();

private:
    wxWindowList *m_winDisabled;

    private: wxWindowDisabler(const wxWindowDisabler&); wxWindowDisabler& operator=(const wxWindowDisabler&);
};






class wxCursor;
extern wxCursor* wxHOURGLASS_CURSOR;
 void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);


 void wxEndBusyCursor();


 bool wxIsBusy();


class wxBusyCursor
{
public:
    wxBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR)
        { wxBeginBusyCursor(cursor); }
    ~wxBusyCursor()
        { wxEndBusyCursor(); }






    static const wxCursor &GetStoredCursor();
    static const wxCursor GetBusyCursor();
};
# 449 "/usr/include/wx/utils.h" 3 4
void wxGetMousePosition( int* x, int* y );
# 463 "/usr/include/wx/utils.h" 3 4
    void *wxGetDisplay();
# 495 "/usr/include/wx/utils.h" 3 4
 void wxDebugMsg(const wxChar *fmt ...) __attribute__ ((__format__ (__printf__, 1, 2)));


extern const wxChar* wxInternalErrorStr;
 void wxError(const wxString& msg, const wxString& title = wxInternalErrorStr);


extern const wxChar* wxFatalErrorStr;
 void wxFatalError(const wxString& msg, const wxString& title = wxFatalErrorStr);
# 23 "/usr/include/wx/cursor.h" 2 3 4
# 41 "/usr/include/wx/cursor.h" 3 4
class wxBusyCursorSuspender
{
public:
    wxBusyCursorSuspender()
    {
        if( wxIsBusy() )
        {
            wxSetCursor( wxBusyCursor::GetStoredCursor() );
        }
    }
    ~wxBusyCursorSuspender()
    {
        if( wxIsBusy() )
        {
            wxSetCursor( wxBusyCursor::GetBusyCursor() );
        }
    }
};
# 26 "/usr/include/wx/event.h" 2 3 4


# 1 "/usr/include/wx/thread.h" 1 3 4
# 27 "/usr/include/wx/thread.h" 3 4
#pragma interface "thread.h"







# 1 "/usr/include/wx/module.h" 1 3 4
# 16 "/usr/include/wx/module.h" 3 4
#pragma interface "module.h"






class wxModule;
typedef wxModule _WX_LIST_ITEM_TYPE_wxModuleList; typedef int (*wxSortFuncFor_wxModuleList)(const wxModule **, const wxModule **); class wxwxModuleListNode : public wxNodeBase { public: wxwxModuleListNode(wxListBase *list = (wxListBase *)__null, wxwxModuleListNode *previous = (wxwxModuleListNode *)__null, wxwxModuleListNode *next = (wxwxModuleListNode *)__null, wxModule *data = (wxModule *)__null, const wxListKey& key = wxDefaultListKey) : wxNodeBase(list, previous, next, data, key) { } wxwxModuleListNode *GetNext() const { return (wxwxModuleListNode *)wxNodeBase::GetNext(); } wxwxModuleListNode *GetPrevious() const { return (wxwxModuleListNode *)wxNodeBase::GetPrevious(); } wxModule *GetData() const { return (wxModule *)wxNodeBase::GetData(); } void SetData(wxModule *data) { wxNodeBase::SetData(data); } virtual void DeleteData(); }; class wxModuleList : public wxListBase { public: typedef wxwxModuleListNode Node; wxModuleList(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType) { } wxModuleList(size_t count, wxModule *elements[]) : wxListBase(count, (void **)elements) { } wxModuleList& operator=(const wxModuleList& list) { (void) wxListBase::operator=(list); return *this; } wxwxModuleListNode *GetFirst() const { return (wxwxModuleListNode *)wxListBase::GetFirst(); } wxwxModuleListNode *GetLast() const { return (wxwxModuleListNode *)wxListBase::GetLast(); } wxwxModuleListNode *Item(size_t index) const { return (wxwxModuleListNode *)wxListBase::Item(index); } wxModule *operator[](size_t index) const { wxwxModuleListNode *node = Item(index); return node ? (wxModule*)(node->GetData()) : (wxModule*)__null; } wxwxModuleListNode *Append(wxModule *object) { return (wxwxModuleListNode *)wxListBase::Append(object); } wxwxModuleListNode *Insert(wxModule *object) { return (wxwxModuleListNode *)Insert((wxwxModuleListNode*)__null, object); } wxwxModuleListNode *Insert(size_t pos, wxModule *object) { return (wxwxModuleListNode *)wxListBase::Insert(pos, object); } wxwxModuleListNode *Insert(wxwxModuleListNode *prev, wxModule *object) { return (wxwxModuleListNode *)wxListBase::Insert(prev, object); } wxwxModuleListNode *Append(long key, void *object) { return (wxwxModuleListNode *)wxListBase::Append(key, object); } wxwxModuleListNode *Append(const wxChar *key, void *object) { return (wxwxModuleListNode *)wxListBase::Append(key, object); } wxwxModuleListNode *DetachNode(wxwxModuleListNode *node) { return (wxwxModuleListNode *)wxListBase::DetachNode(node); } bool DeleteNode(wxwxModuleListNode *node) { return wxListBase::DeleteNode(node); } bool DeleteObject(wxModule *object) { return wxListBase::DeleteObject(object); } wxwxModuleListNode *Find(wxModule *object) const { return (wxwxModuleListNode *)wxListBase::Find(object); } virtual wxwxModuleListNode *Find(const wxListKey& key) const { return (wxwxModuleListNode *)wxListBase::Find(key); } int IndexOf(wxModule *object) const { return wxListBase::IndexOf(object); } void Sort(wxSortFuncFor_wxModuleList func) { wxListBase::Sort((wxSortCompareFunction)func); } protected: virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next, void *data, const wxListKey& key = wxDefaultListKey) { return new wxwxModuleListNode(this, (wxwxModuleListNode *)prev, (wxwxModuleListNode *)next, (wxModule *)data, key); } };




class wxModule : public wxObject
{
public:
    wxModule() {}
    virtual ~wxModule() {}




    bool Init() { return OnInit(); }
    void Exit() { OnExit(); }




    virtual bool OnInit() = 0;




    virtual void OnExit() = 0;

    static void RegisterModule(wxModule* module);
    static void RegisterModules();
    static bool InitializeModules();
    static void CleanUpModules();



    static void UnregisterModule(wxModule* module);

protected:
    static wxModuleList m_modules;

    public: static wxClassInfo sm_classwxModule; virtual wxClassInfo *GetClassInfo() const { return &wxModule::sm_classwxModule; }
};
# 36 "/usr/include/wx/thread.h" 2 3 4





enum wxMutexError
{
    wxMUTEX_NO_ERROR = 0,
    wxMUTEX_INVALID,
    wxMUTEX_DEAD_LOCK,
    wxMUTEX_BUSY,
    wxMUTEX_UNLOCKED,
    wxMUTEX_MISC_ERROR
};

enum wxCondError
{
    wxCOND_NO_ERROR = 0,
    wxCOND_INVALID,
    wxCOND_TIMEOUT,
    wxCOND_MISC_ERROR
};

enum wxSemaError
{
    wxSEMA_NO_ERROR = 0,
    wxSEMA_INVALID,
    wxSEMA_BUSY,
    wxSEMA_TIMEOUT,
    wxSEMA_OVERFLOW,
    wxSEMA_MISC_ERROR
};

enum wxThreadError
{
    wxTHREAD_NO_ERROR = 0,
    wxTHREAD_NO_RESOURCE,
    wxTHREAD_RUNNING,
    wxTHREAD_NOT_RUNNING,
    wxTHREAD_KILLED,
    wxTHREAD_MISC_ERROR
};

enum wxThreadKind
{
    wxTHREAD_DETACHED,
    wxTHREAD_JOINABLE
};


enum
{
    WXTHREAD_MIN_PRIORITY = 0u,
    WXTHREAD_DEFAULT_PRIORITY = 50u,
    WXTHREAD_MAX_PRIORITY = 100u
};
# 109 "/usr/include/wx/thread.h" 3 4
enum wxMutexType
{

    wxMUTEX_DEFAULT,


    wxMUTEX_RECURSIVE
};


class wxConditionInternal;
class wxMutexInternal;
class wxSemaphoreInternal;
class wxThreadInternal;
# 133 "/usr/include/wx/thread.h" 3 4
class wxMutex
{
public:




    wxMutex(wxMutexType mutexType = wxMUTEX_DEFAULT);


    ~wxMutex();


    bool IsOk() const;
# 156 "/usr/include/wx/thread.h" 3 4
    wxMutexError Lock();



    wxMutexError TryLock();


    wxMutexError Unlock();

protected:
    wxMutexInternal *m_internal;

    friend class wxConditionInternal;

    private: wxMutex(const wxMutex&); wxMutex& operator=(const wxMutex&);
};




class wxMutexLocker
{
public:

    wxMutexLocker(wxMutex& mutex)
        : m_isOk(((bool)0)), m_mutex(mutex)
        { m_isOk = ( m_mutex.Lock() == wxMUTEX_NO_ERROR ); }


    bool IsOk() const
        { return m_isOk; }


    ~wxMutexLocker()
        { if ( IsOk() ) m_mutex.Unlock(); }

private:

    wxMutexLocker(const wxMutexLocker&);
    wxMutexLocker& operator=(const wxMutexLocker&);

    bool m_isOk;
    wxMutex& m_mutex;
};
# 225 "/usr/include/wx/thread.h" 3 4
class wxCriticalSection
{
public:

    inline wxCriticalSection();
    inline ~wxCriticalSection();


    inline void Enter();


    inline void Leave();

private:

    wxMutex m_mutex;
# 265 "/usr/include/wx/thread.h" 3 4
    private: wxCriticalSection(const wxCriticalSection&); wxCriticalSection& operator=(const wxCriticalSection&);
};



    inline wxCriticalSection::wxCriticalSection() { }
    inline wxCriticalSection::~wxCriticalSection() { }

    inline void wxCriticalSection::Enter() { (void)m_mutex.Lock(); }
    inline void wxCriticalSection::Leave() { (void)m_mutex.Unlock(); }







class wxCriticalSectionLocker
{
public:
    wxCriticalSectionLocker(wxCriticalSection& cs)
        : m_critsect(cs)
    {
        m_critsect.Enter();
    }

    ~wxCriticalSectionLocker()
    {
        m_critsect.Leave();
    }

private:
    wxCriticalSection& m_critsect;

    private: wxCriticalSectionLocker(const wxCriticalSectionLocker&); wxCriticalSectionLocker& operator=(const wxCriticalSectionLocker&);
};






class wxCondition
{
public:


    wxCondition(wxMutex& mutex);


    ~wxCondition();


    bool IsOk() const;







    wxCondError Wait();
# 335 "/usr/include/wx/thread.h" 3 4
    wxCondError WaitTimeout(unsigned long milliseconds);







    wxCondError Signal();







    wxCondError Broadcast();



    bool Wait(unsigned long milliseconds)
        { return WaitTimeout(milliseconds) == wxCOND_NO_ERROR; }

private:
    wxConditionInternal *m_internal;

    private: wxCondition(const wxCondition&); wxCondition& operator=(const wxCondition&);
};






class wxSemaphore
{
public:


    wxSemaphore( int initialcount = 0, int maxcount = 0 );


    ~wxSemaphore();


    bool IsOk() const;




    wxSemaError Wait();



    wxSemaError TryWait();



    wxSemaError WaitTimeout(unsigned long milliseconds);


    wxSemaError Post();

private:
    wxSemaphoreInternal *m_internal;

    private: wxSemaphore(const wxSemaphore&); wxSemaphore& operator=(const wxSemaphore&);
};
# 421 "/usr/include/wx/thread.h" 3 4
   typedef unsigned long wxThreadIdType;


class wxThread
{
public:

    typedef void *ExitCode;







    static wxThread *This();


    static bool IsMain();


    static void Yield();




    static void Sleep(unsigned long milliseconds);





    static int GetCPUCount();




   static wxThreadIdType GetCurrentId();
# 467 "/usr/include/wx/thread.h" 3 4
    static bool SetConcurrency(size_t level);



    wxThread(wxThreadKind kind = wxTHREAD_DETACHED);
# 481 "/usr/include/wx/thread.h" 3 4
    wxThreadError Create(unsigned int stackSize = 0);




    wxThreadError Run();
# 498 "/usr/include/wx/thread.h" 3 4
    wxThreadError Delete(ExitCode *rc = (ExitCode *)__null);





    ExitCode Wait();
# 514 "/usr/include/wx/thread.h" 3 4
    wxThreadError Kill();



    wxThreadError Pause();


    wxThreadError Resume();





    void SetPriority(unsigned int prio);


    unsigned int GetPriority() const;



    bool IsAlive() const;

    bool IsRunning() const;

    bool IsPaused() const;


    bool IsDetached() const { return m_isDetached; }



    wxThreadIdType GetId() const;




    virtual void OnExit() { }



    virtual ~wxThread();

protected:



    bool TestDestroy();


    void Exit(ExitCode exitcode = 0);



    virtual void *Entry() = 0;

private:

    wxThread(const wxThread&);
    wxThread& operator=(const wxThread&);

    friend class wxThreadInternal;


    wxThreadInternal *m_internal;


    wxCriticalSection m_critsect;


    bool m_isDetached;
};






void wxMutexGuiEnter();
void wxMutexGuiLeave();
# 638 "/usr/include/wx/thread.h" 3 4
class wxMutexGuiLocker
{
public:
    wxMutexGuiLocker() { wxMutexGuiEnter(); }
   ~wxMutexGuiLocker() { wxMutexGuiLeave(); }
};
# 29 "/usr/include/wx/event.h" 2 3 4





class wxList;


    class wxDC;
    class wxMenu;
    class wxWindow;






typedef int wxEventType;
# 97 "/usr/include/wx/event.h" 3 4
extern wxEventType wxNewEventType();




# 110 "/usr/include/wx/event.h" 3 4
    extern const wxEventType wxEVT_NULL;
    const wxEventType wxEVT_FIRST = 10000;
    const wxEventType wxEVT_USER_FIRST = wxEVT_FIRST + 2000;


    extern const wxEventType wxEVT_COMMAND_BUTTON_CLICKED;
    extern const wxEventType wxEVT_COMMAND_CHECKBOX_CLICKED;
    extern const wxEventType wxEVT_COMMAND_CHOICE_SELECTED;
    extern const wxEventType wxEVT_COMMAND_LISTBOX_SELECTED;
    extern const wxEventType wxEVT_COMMAND_LISTBOX_DOUBLECLICKED;
    extern const wxEventType wxEVT_COMMAND_CHECKLISTBOX_TOGGLED;







    extern const wxEventType wxEVT_COMMAND_MENU_SELECTED;
    extern const wxEventType wxEVT_COMMAND_SLIDER_UPDATED;
    extern const wxEventType wxEVT_COMMAND_RADIOBOX_SELECTED;
    extern const wxEventType wxEVT_COMMAND_RADIOBUTTON_SELECTED;




    extern const wxEventType wxEVT_COMMAND_SCROLLBAR_UPDATED;
    extern const wxEventType wxEVT_COMMAND_VLBOX_SELECTED;
    extern const wxEventType wxEVT_COMMAND_COMBOBOX_SELECTED;
    extern const wxEventType wxEVT_COMMAND_TOOL_RCLICKED;
    extern const wxEventType wxEVT_COMMAND_TOOL_ENTER;
    extern const wxEventType wxEVT_COMMAND_SPINCTRL_UPDATED;


    extern const wxEventType wxEVT_SOCKET;
    extern const wxEventType wxEVT_TIMER;


    extern const wxEventType wxEVT_LEFT_DOWN;
    extern const wxEventType wxEVT_LEFT_UP;
    extern const wxEventType wxEVT_MIDDLE_DOWN;
    extern const wxEventType wxEVT_MIDDLE_UP;
    extern const wxEventType wxEVT_RIGHT_DOWN;
    extern const wxEventType wxEVT_RIGHT_UP;
    extern const wxEventType wxEVT_MOTION;
    extern const wxEventType wxEVT_ENTER_WINDOW;
    extern const wxEventType wxEVT_LEAVE_WINDOW;
    extern const wxEventType wxEVT_LEFT_DCLICK;
    extern const wxEventType wxEVT_MIDDLE_DCLICK;
    extern const wxEventType wxEVT_RIGHT_DCLICK;
    extern const wxEventType wxEVT_SET_FOCUS;
    extern const wxEventType wxEVT_KILL_FOCUS;
    extern const wxEventType wxEVT_CHILD_FOCUS;
    extern const wxEventType wxEVT_MOUSEWHEEL;


    extern const wxEventType wxEVT_NC_LEFT_DOWN;
    extern const wxEventType wxEVT_NC_LEFT_UP;
    extern const wxEventType wxEVT_NC_MIDDLE_DOWN;
    extern const wxEventType wxEVT_NC_MIDDLE_UP;
    extern const wxEventType wxEVT_NC_RIGHT_DOWN;
    extern const wxEventType wxEVT_NC_RIGHT_UP;
    extern const wxEventType wxEVT_NC_MOTION;
    extern const wxEventType wxEVT_NC_ENTER_WINDOW;
    extern const wxEventType wxEVT_NC_LEAVE_WINDOW;
    extern const wxEventType wxEVT_NC_LEFT_DCLICK;
    extern const wxEventType wxEVT_NC_MIDDLE_DCLICK;
    extern const wxEventType wxEVT_NC_RIGHT_DCLICK;


    extern const wxEventType wxEVT_CHAR;
    extern const wxEventType wxEVT_CHAR_HOOK;
    extern const wxEventType wxEVT_NAVIGATION_KEY;
    extern const wxEventType wxEVT_KEY_DOWN;
    extern const wxEventType wxEVT_KEY_UP;


    extern const wxEventType wxEVT_SET_CURSOR;


    extern const wxEventType wxEVT_SCROLL_TOP;
    extern const wxEventType wxEVT_SCROLL_BOTTOM;
    extern const wxEventType wxEVT_SCROLL_LINEUP;
    extern const wxEventType wxEVT_SCROLL_LINEDOWN;
    extern const wxEventType wxEVT_SCROLL_PAGEUP;
    extern const wxEventType wxEVT_SCROLL_PAGEDOWN;
    extern const wxEventType wxEVT_SCROLL_THUMBTRACK;
    extern const wxEventType wxEVT_SCROLL_THUMBRELEASE;
    extern const wxEventType wxEVT_SCROLL_ENDSCROLL;


    extern const wxEventType wxEVT_SCROLLWIN_TOP;
    extern const wxEventType wxEVT_SCROLLWIN_BOTTOM;
    extern const wxEventType wxEVT_SCROLLWIN_LINEUP;
    extern const wxEventType wxEVT_SCROLLWIN_LINEDOWN;
    extern const wxEventType wxEVT_SCROLLWIN_PAGEUP;
    extern const wxEventType wxEVT_SCROLLWIN_PAGEDOWN;
    extern const wxEventType wxEVT_SCROLLWIN_THUMBTRACK;
    extern const wxEventType wxEVT_SCROLLWIN_THUMBRELEASE;


    extern const wxEventType wxEVT_SIZE;
    extern const wxEventType wxEVT_MOVE;
    extern const wxEventType wxEVT_CLOSE_WINDOW;
    extern const wxEventType wxEVT_END_SESSION;
    extern const wxEventType wxEVT_QUERY_END_SESSION;
    extern const wxEventType wxEVT_ACTIVATE_APP;
    extern const wxEventType wxEVT_POWER;
    extern const wxEventType wxEVT_ACTIVATE;
    extern const wxEventType wxEVT_CREATE;
    extern const wxEventType wxEVT_DESTROY;
    extern const wxEventType wxEVT_SHOW;
    extern const wxEventType wxEVT_ICONIZE;
    extern const wxEventType wxEVT_MAXIMIZE;
    extern const wxEventType wxEVT_MOUSE_CAPTURE_CHANGED;
    extern const wxEventType wxEVT_PAINT;
    extern const wxEventType wxEVT_ERASE_BACKGROUND;
    extern const wxEventType wxEVT_NC_PAINT;
    extern const wxEventType wxEVT_PAINT_ICON;
    extern const wxEventType wxEVT_MENU_OPEN;
    extern const wxEventType wxEVT_MENU_CLOSE;
    extern const wxEventType wxEVT_MENU_HIGHLIGHT;

    extern const wxEventType wxEVT_CONTEXT_MENU;
    extern const wxEventType wxEVT_SYS_COLOUR_CHANGED;
    extern const wxEventType wxEVT_DISPLAY_CHANGED;
    extern const wxEventType wxEVT_SETTING_CHANGED;
    extern const wxEventType wxEVT_QUERY_NEW_PALETTE;
    extern const wxEventType wxEVT_PALETTE_CHANGED;
    extern const wxEventType wxEVT_JOY_BUTTON_DOWN;
    extern const wxEventType wxEVT_JOY_BUTTON_UP;
    extern const wxEventType wxEVT_JOY_MOVE;
    extern const wxEventType wxEVT_JOY_ZMOVE;
    extern const wxEventType wxEVT_DROP_FILES;
    extern const wxEventType wxEVT_DRAW_ITEM;
    extern const wxEventType wxEVT_MEASURE_ITEM;
    extern const wxEventType wxEVT_COMPARE_ITEM;
    extern const wxEventType wxEVT_INIT_DIALOG;
    extern const wxEventType wxEVT_IDLE;
    extern const wxEventType wxEVT_UPDATE_UI;



    extern const wxEventType wxEVT_COMMAND_LEFT_CLICK;
    extern const wxEventType wxEVT_COMMAND_LEFT_DCLICK;
    extern const wxEventType wxEVT_COMMAND_RIGHT_CLICK;
    extern const wxEventType wxEVT_COMMAND_RIGHT_DCLICK;
    extern const wxEventType wxEVT_COMMAND_SET_FOCUS;
    extern const wxEventType wxEVT_COMMAND_KILL_FOCUS;
    extern const wxEventType wxEVT_COMMAND_ENTER;


    extern const wxEventType wxEVT_HELP;
    extern const wxEventType wxEVT_DETAILED_HELP;


# 279 "/usr/include/wx/event.h" 3 4
    extern const wxEventType wxEVT_COMMAND_TEXT_UPDATED;
# 338 "/usr/include/wx/event.h" 3 4
class wxEvent : public wxObject
{
private:
    wxEvent& operator=(const wxEvent&);

protected:
    wxEvent(const wxEvent&);

public:
    wxEvent(int id = 0, wxEventType commandType = wxEVT_NULL );

    void SetEventType(wxEventType typ) { m_eventType = typ; }
    wxEventType GetEventType() const { return m_eventType; }
    wxObject *GetEventObject() const { return m_eventObject; }
    void SetEventObject(wxObject *obj) { m_eventObject = obj; }
    long GetTimestamp() const { return m_timeStamp; }
    void SetTimestamp(long ts = 0) { m_timeStamp = ts; }
    int GetId() const { return m_id; }
    void SetId(int Id) { m_id = Id; }





    void Skip(bool skip = ((bool)1)) { m_skipped = skip; }
    bool GetSkipped() const { return m_skipped; };



    bool IsCommandEvent() const { return m_isCommandEvent; }




    virtual wxEvent *Clone() const = 0;

public:
    wxObject* m_eventObject;
    wxEventType m_eventType;
    long m_timeStamp;
    int m_id;
    wxObject* m_callbackUserData;
    bool m_skipped;
    bool m_isCommandEvent;

private:
    public: static wxClassInfo sm_classwxEvent; virtual wxClassInfo *GetClassInfo() const { return &wxEvent::sm_classwxEvent; }
};
# 408 "/usr/include/wx/event.h" 3 4
class wxCommandEvent : public wxEvent
{
private:
    wxCommandEvent& operator=(const wxCommandEvent& event);

public:
    wxCommandEvent(wxEventType commandType = wxEVT_NULL, int id = 0);

    wxCommandEvent(const wxCommandEvent& event)
        : wxEvent(event),
          m_commandString(event.m_commandString),
          m_commandInt(event.m_commandInt),
          m_extraLong(event.m_extraLong),
          m_clientData(event.m_clientData),
          m_clientObject(event.m_clientObject)
        { }


    void SetClientData(void* clientData) { m_clientData = clientData; }
    void *GetClientData() const { return m_clientData; }


    void SetClientObject(wxClientData* clientObject) { m_clientObject = clientObject; }
    void *GetClientObject() const { return m_clientObject; }


    int GetSelection() const { return m_commandInt; }


    void SetString(const wxString& s) { m_commandString = s; }
    wxString GetString() const { return m_commandString; }


    bool IsChecked() const { return m_commandInt != 0; }


    bool IsSelection() const { return (m_extraLong != 0); }

    void SetExtraLong(long extraLong) { m_extraLong = extraLong; }
    long GetExtraLong() const { return m_extraLong ; }

    void SetInt(int i) { m_commandInt = i; }
    long GetInt() const { return m_commandInt ; }

    virtual wxEvent *Clone() const { return new wxCommandEvent(*this); }





public:
    wxString m_commandString;
    int m_commandInt;
    long m_extraLong;
    void* m_clientData;
    wxClientData* m_clientObject;

private:
    public: static wxClassInfo sm_classwxCommandEvent; virtual wxClassInfo *GetClassInfo() const { return &wxCommandEvent::sm_classwxCommandEvent; }
};



class wxNotifyEvent : public wxCommandEvent
{
public:
    wxNotifyEvent(wxEventType commandType = wxEVT_NULL, int id = 0)
        : wxCommandEvent(commandType, id)
        { m_bAllow = ((bool)1); }

    wxNotifyEvent(const wxNotifyEvent& event)
        : wxCommandEvent(event)
        { m_bAllow = event.m_bAllow; }


    void Veto() { m_bAllow = ((bool)0); }


    void Allow() { m_bAllow = ((bool)1); }


    bool IsAllowed() const { return m_bAllow; }

    virtual wxEvent *Clone() const { return new wxNotifyEvent(*this); }

private:
    bool m_bAllow;

private:
    public: static wxClassInfo sm_classwxNotifyEvent; virtual wxClassInfo *GetClassInfo() const { return &wxNotifyEvent::sm_classwxNotifyEvent; }
};
# 514 "/usr/include/wx/event.h" 3 4
class wxScrollEvent : public wxCommandEvent
{
public:
    wxScrollEvent(wxEventType commandType = wxEVT_NULL,
                  int id = 0, int pos = 0, int orient = 0);

    int GetOrientation() const { return (int) m_extraLong ; }
    int GetPosition() const { return m_commandInt ; }
    void SetOrientation(int orient) { m_extraLong = (long) orient; }
    void SetPosition(int pos) { m_commandInt = pos; }

    virtual wxEvent *Clone() const { return new wxScrollEvent(*this); }

private:
    public: static wxClassInfo sm_classwxScrollEvent; virtual wxClassInfo *GetClassInfo() const { return &wxScrollEvent::sm_classwxScrollEvent; }
};
# 544 "/usr/include/wx/event.h" 3 4
class wxScrollWinEvent : public wxEvent
{
public:
    wxScrollWinEvent(wxEventType commandType = wxEVT_NULL,
                     int pos = 0, int orient = 0);
        wxScrollWinEvent(const wxScrollWinEvent & event) : wxEvent(event)
                { m_commandInt = event.m_commandInt;
                        m_extraLong = event.m_extraLong; }

    int GetOrientation() const { return (int) m_extraLong ; }
    int GetPosition() const { return m_commandInt ; }
    void SetOrientation(int orient) { m_extraLong = (long) orient; }
    void SetPosition(int pos) { m_commandInt = pos; }

    virtual wxEvent *Clone() const { return new wxScrollWinEvent(*this); }

public:
    int m_commandInt;
    long m_extraLong;

private:
    public: static wxClassInfo sm_classwxScrollWinEvent; virtual wxClassInfo *GetClassInfo() const { return &wxScrollWinEvent::sm_classwxScrollWinEvent; }
};
# 598 "/usr/include/wx/event.h" 3 4
enum
{
    wxMOUSE_BTN_ANY = -1,
    wxMOUSE_BTN_NONE = -1,
    wxMOUSE_BTN_LEFT = 0,
    wxMOUSE_BTN_MIDDLE = 1,
    wxMOUSE_BTN_RIGHT = 2
};

class wxMouseEvent : public wxEvent
{
public:
    wxMouseEvent(wxEventType mouseType = wxEVT_NULL);
    wxMouseEvent(const wxMouseEvent& event) : wxEvent(event)
                { Assign(event); }


    bool IsButton() const { return Button(wxMOUSE_BTN_ANY); }


    bool ButtonDown(int but = wxMOUSE_BTN_ANY) const;


    bool ButtonDClick(int but = wxMOUSE_BTN_ANY) const;


    bool ButtonUp(int but = wxMOUSE_BTN_ANY) const;


    bool Button(int but) const;


    bool ButtonIsDown(int but) const;


    int GetButton() const;


    bool ControlDown() const { return m_controlDown; }
    bool MetaDown() const { return m_metaDown; }
    bool AltDown() const { return m_altDown; }
    bool ShiftDown() const { return m_shiftDown; }


    bool LeftDown() const { return (m_eventType == wxEVT_LEFT_DOWN); }
    bool MiddleDown() const { return (m_eventType == wxEVT_MIDDLE_DOWN); }
    bool RightDown() const { return (m_eventType == wxEVT_RIGHT_DOWN); }

    bool LeftUp() const { return (m_eventType == wxEVT_LEFT_UP); }
    bool MiddleUp() const { return (m_eventType == wxEVT_MIDDLE_UP); }
    bool RightUp() const { return (m_eventType == wxEVT_RIGHT_UP); }

    bool LeftDClick() const { return (m_eventType == wxEVT_LEFT_DCLICK); }
    bool MiddleDClick() const { return (m_eventType == wxEVT_MIDDLE_DCLICK); }
    bool RightDClick() const { return (m_eventType == wxEVT_RIGHT_DCLICK); }



    bool LeftIsDown() const { return m_leftDown; }
    bool MiddleIsDown() const { return m_middleDown; }
    bool RightIsDown() const { return m_rightDown; }


    bool Dragging() const
    {
        return ((m_eventType == wxEVT_MOTION) &&
                (LeftIsDown() || MiddleIsDown() || RightIsDown()));
    }


    bool Moving() const { return (m_eventType == wxEVT_MOTION); }


    bool Entering() const { return (m_eventType == wxEVT_ENTER_WINDOW); }


    bool Leaving() const { return (m_eventType == wxEVT_LEAVE_WINDOW); }


    void GetPosition(wxCoord *xpos, wxCoord *ypos) const
    {
        if (xpos)
            *xpos = m_x;
        if (ypos)
            *ypos = m_y;
    }


    void GetPosition(long *xpos, long *ypos) const
    {
        if (xpos)
            *xpos = (long)m_x;
        if (ypos)
            *ypos = (long)m_y;
    }



    wxPoint GetPosition() const { return wxPoint(m_x, m_y); }


    wxPoint GetLogicalPosition(const wxDC& dc) const ;
# 718 "/usr/include/wx/event.h" 3 4
    wxCoord GetX() const { return m_x; }


    wxCoord GetY() const { return m_y; }
# 730 "/usr/include/wx/event.h" 3 4
    int GetWheelRotation() const { return m_wheelRotation; }




    int GetWheelDelta() const { return m_wheelDelta; }



    int GetLinesPerAction() const { return m_linesPerAction; }


    bool IsPageScroll() const { return ((unsigned int)m_linesPerAction == (2147483647 * 2U + 1U)); }

    virtual wxEvent *Clone() const { return new wxMouseEvent(*this); }

    wxMouseEvent& operator=(const wxMouseEvent& event) { Assign(event); return *this; }

public:
    wxCoord m_x, m_y;

    bool m_leftDown;
    bool m_middleDown;
    bool m_rightDown;

    bool m_controlDown;
    bool m_shiftDown;
    bool m_altDown;
    bool m_metaDown;

    int m_wheelRotation;
    int m_wheelDelta;
    int m_linesPerAction;

protected:
    void Assign(const wxMouseEvent& evt);

private:
    public: static wxClassInfo sm_classwxMouseEvent; virtual wxClassInfo *GetClassInfo() const { return &wxMouseEvent::sm_classwxMouseEvent; }
};







class wxSetCursorEvent : public wxEvent
{
public:
    wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0)
        : wxEvent(0, wxEVT_SET_CURSOR),
          m_x(x), m_y(y), m_cursor()
        { }

        wxSetCursorEvent(const wxSetCursorEvent & event) : wxEvent(event)
                { m_x = event.m_x;
                        m_y = event.m_y;
                        m_cursor = event.m_cursor; }

    wxCoord GetX() const { return m_x; }
    wxCoord GetY() const { return m_y; }

    void SetCursor(const wxCursor& cursor) { m_cursor = cursor; }
    const wxCursor& GetCursor() const { return m_cursor; }
    bool HasCursor() const { return m_cursor.Ok(); }

    virtual wxEvent *Clone() const { return new wxSetCursorEvent(*this); }

private:
    wxCoord m_x, m_y;
    wxCursor m_cursor;

private:
    public: static wxClassInfo sm_classwxSetCursorEvent; virtual wxClassInfo *GetClassInfo() const { return &wxSetCursorEvent::sm_classwxSetCursorEvent; }
};
# 816 "/usr/include/wx/event.h" 3 4
class wxKeyEvent : public wxEvent
{
public:
    wxKeyEvent(wxEventType keyType = wxEVT_NULL);
        wxKeyEvent(const wxKeyEvent& evt);


    bool ControlDown() const { return m_controlDown; }
    bool MetaDown() const { return m_metaDown; }
    bool AltDown() const { return m_altDown; }
    bool ShiftDown() const { return m_shiftDown; }




    bool HasModifiers() const { return ControlDown() || AltDown(); }


    int GetKeyCode() const { return (int)m_keyCode; }


    int unsigned GetRawKeyCode() const { return m_rawCode; }


    int unsigned GetRawKeyFlags() const { return m_rawFlags; }


    void GetPosition(wxCoord *xpos, wxCoord *ypos) const
    {
        if (xpos) *xpos = m_x;
        if (ypos) *ypos = m_y;
    }


    void GetPosition(long *xpos, long *ypos) const
    {
        if (xpos) *xpos = (long)m_x;
        if (ypos) *ypos = (long)m_y;
    }


    wxPoint GetPosition() const
        { return wxPoint(m_x, m_y); }


    wxCoord GetX() const { return m_x; }


    wxCoord GetY() const { return m_y; }


    long KeyCode() const { return m_keyCode; }

    virtual wxEvent *Clone() const { return new wxKeyEvent(*this); }



    wxKeyEvent& operator=(const wxKeyEvent& evt)
    {
        m_x = evt.m_x;
        m_y = evt.m_y;

        m_keyCode = evt.m_keyCode;

        m_controlDown = evt.m_controlDown;
        m_shiftDown = evt.m_shiftDown;
        m_altDown = evt.m_altDown;
        m_metaDown = evt.m_metaDown;
        m_scanCode = evt.m_scanCode;
        m_rawCode = evt.m_rawCode;
        m_rawFlags = evt.m_rawFlags;

        return *this;
    }

public:
    wxCoord m_x, m_y;

    long m_keyCode;

    bool m_controlDown;
    bool m_shiftDown;
    bool m_altDown;
    bool m_metaDown;
    bool m_scanCode;
# 910 "/usr/include/wx/event.h" 3 4
    int unsigned m_rawCode;
    int unsigned m_rawFlags;

private:
    public: static wxClassInfo sm_classwxKeyEvent; virtual wxClassInfo *GetClassInfo() const { return &wxKeyEvent::sm_classwxKeyEvent; }
};






class wxSizeEvent : public wxEvent
{
public:
    wxSizeEvent() : wxEvent(0, wxEVT_SIZE)
        { }
    wxSizeEvent(const wxSize& sz, int id = 0)
        : wxEvent(id, wxEVT_SIZE),
          m_size(sz)
        { }
    wxSizeEvent(const wxSizeEvent & event)
                : wxEvent(event),
                  m_size(event.m_size)
                { }

    wxSize GetSize() const { return m_size; }

    virtual wxEvent *Clone() const { return new wxSizeEvent(*this); }

public:
    wxSize m_size;

private:
    public: static wxClassInfo sm_classwxSizeEvent; virtual wxClassInfo *GetClassInfo() const { return &wxSizeEvent::sm_classwxSizeEvent; }
};







class wxMoveEvent : public wxEvent
{
public:
    wxMoveEvent()
        : wxEvent(0, wxEVT_MOVE)
        { }
    wxMoveEvent(const wxPoint& pos, int id = 0)
        : wxEvent(id, wxEVT_MOVE),
          m_pos(pos)
        { }
    wxMoveEvent(const wxMoveEvent& event)
        : wxEvent(event),
                  m_pos(event.m_pos)
        { }

    wxPoint GetPosition() const { return m_pos; }

    virtual wxEvent *Clone() const { return new wxMoveEvent(*this); }

    wxPoint m_pos;

private:
    public: static wxClassInfo sm_classwxMoveEvent; virtual wxClassInfo *GetClassInfo() const { return &wxMoveEvent::sm_classwxMoveEvent; }
};
# 990 "/usr/include/wx/event.h" 3 4
class wxPaintEvent : public wxEvent
{
public:
    wxPaintEvent(int Id = 0)
        : wxEvent(Id, wxEVT_PAINT)
    {




    }
# 1009 "/usr/include/wx/event.h" 3 4
    virtual wxEvent *Clone() const { return new wxPaintEvent(*this); }

private:
    public: static wxClassInfo sm_classwxPaintEvent; virtual wxClassInfo *GetClassInfo() const { return &wxPaintEvent::sm_classwxPaintEvent; }
};

class wxNcPaintEvent : public wxEvent
{
public:
    wxNcPaintEvent(int id = 0)
        : wxEvent(id, wxEVT_NC_PAINT)
        { }

    virtual wxEvent *Clone() const { return new wxNcPaintEvent(*this); }

private:
    public: static wxClassInfo sm_classwxNcPaintEvent; virtual wxClassInfo *GetClassInfo() const { return &wxNcPaintEvent::sm_classwxNcPaintEvent; }
};






class wxEraseEvent : public wxEvent
{
private:
    wxEraseEvent& operator=(const wxEraseEvent& event);

public:
    wxEraseEvent(int Id = 0, wxDC *dc = (wxDC *) __null)
        : wxEvent(Id, wxEVT_ERASE_BACKGROUND),
          m_dc(dc)
        { }

    wxEraseEvent(const wxEraseEvent& event)
        : wxEvent(event),
          m_dc(event.m_dc)
        { }

    wxDC *GetDC() const { return m_dc; }

    virtual wxEvent *Clone() const { return new wxEraseEvent(*this); }

    wxDC *m_dc;

private:
    public: static wxClassInfo sm_classwxEraseEvent; virtual wxClassInfo *GetClassInfo() const { return &wxEraseEvent::sm_classwxEraseEvent; }
};







class wxFocusEvent : public wxEvent
{
private:
    wxFocusEvent& operator=(const wxFocusEvent& event);

public:
    wxFocusEvent(wxEventType type = wxEVT_NULL, int id = 0)
        : wxEvent(id, type)
        { m_win = __null; }

    wxFocusEvent(const wxFocusEvent& event)
        : wxEvent(event)
        { m_win = event.m_win; }




    wxWindow *GetWindow() const { return m_win; }
    void SetWindow(wxWindow *win) { m_win = win; }

    virtual wxEvent *Clone() const { return new wxFocusEvent(*this); }

private:
    wxWindow *m_win;

private:
    public: static wxClassInfo sm_classwxFocusEvent; virtual wxClassInfo *GetClassInfo() const { return &wxFocusEvent::sm_classwxFocusEvent; }
};



class wxChildFocusEvent : public wxCommandEvent
{
public:
    wxChildFocusEvent(wxWindow *win = __null);

    wxWindow *GetWindow() const { return (wxWindow *)GetEventObject(); }

    virtual wxEvent *Clone() const { return new wxChildFocusEvent(*this); }

private:
    public: static wxClassInfo sm_classwxChildFocusEvent; virtual wxClassInfo *GetClassInfo() const { return &wxChildFocusEvent::sm_classwxChildFocusEvent; }
};







class wxActivateEvent : public wxEvent
{
public:
    wxActivateEvent(wxEventType type = wxEVT_NULL, bool active = ((bool)1), int Id = 0)
        : wxEvent(Id, type)
        { m_active = active; }
    wxActivateEvent(const wxActivateEvent& event)
        : wxEvent(event)
        { m_active = event.m_active; }

    bool GetActive() const { return m_active; }

    virtual wxEvent *Clone() const { return new wxActivateEvent(*this); }

private:
    bool m_active;

private:
    public: static wxClassInfo sm_classwxActivateEvent; virtual wxClassInfo *GetClassInfo() const { return &wxActivateEvent::sm_classwxActivateEvent; }
};






class wxInitDialogEvent : public wxEvent
{
public:
    wxInitDialogEvent(int Id = 0)
        : wxEvent(Id, wxEVT_INIT_DIALOG)
        { }

    virtual wxEvent *Clone() const { return new wxInitDialogEvent(*this); }

private:
    public: static wxClassInfo sm_classwxInitDialogEvent; virtual wxClassInfo *GetClassInfo() const { return &wxInitDialogEvent::sm_classwxInitDialogEvent; }
};
# 1161 "/usr/include/wx/event.h" 3 4
class wxMenuEvent : public wxEvent
{
public:
    wxMenuEvent(wxEventType type = wxEVT_NULL, int id = 0)
        : wxEvent(id, type)
        { m_menuId = id; }
    wxMenuEvent(const wxMenuEvent & event)
        : wxEvent(event)
        { m_menuId = event.m_menuId; }


    int GetMenuId() const { return m_menuId; }


    bool IsPopup() const { return m_menuId == -1; }

    virtual wxEvent *Clone() const { return new wxMenuEvent(*this); }

private:
    int m_menuId;

    public: static wxClassInfo sm_classwxMenuEvent; virtual wxClassInfo *GetClassInfo() const { return &wxMenuEvent::sm_classwxMenuEvent; }
};
# 1192 "/usr/include/wx/event.h" 3 4
class wxCloseEvent : public wxEvent
{
public:
    wxCloseEvent(wxEventType type = wxEVT_NULL, int id = 0)
        : wxEvent(id, type),
          m_loggingOff(((bool)1)),
          m_veto(((bool)0)),
          m_canVeto(((bool)1))
    {



    }
    wxCloseEvent(const wxCloseEvent & event)
        : wxEvent(event),
                m_loggingOff(event.m_loggingOff),
                m_veto(event.m_veto),
                m_canVeto(event.m_canVeto)
    {



        }

    void SetLoggingOff(bool logOff) { m_loggingOff = logOff; }
    bool GetLoggingOff() const { return m_loggingOff; }

    void Veto(bool veto = ((bool)1))
    {

        if (!(m_canVeto)) {; return; };


        m_veto = veto;
    }
    void SetCanVeto(bool canVeto) { m_canVeto = canVeto; }

    bool CanVeto() const { return m_canVeto; }
    bool GetVeto() const { return m_canVeto && m_veto; }
# 1240 "/usr/include/wx/event.h" 3 4
    virtual wxEvent *Clone() const { return new wxCloseEvent(*this); }

protected:
    bool m_loggingOff;
    bool m_veto, m_canVeto;





private:
    public: static wxClassInfo sm_classwxCloseEvent; virtual wxClassInfo *GetClassInfo() const { return &wxCloseEvent::sm_classwxCloseEvent; }

};





class wxShowEvent : public wxEvent
{
public:
    wxShowEvent(int id = 0, bool show = ((bool)0))
        : wxEvent(id, wxEVT_SHOW)
        { m_show = show; }
    wxShowEvent(const wxShowEvent & event)
        : wxEvent(event)
        { m_show = event.m_show; }

    void SetShow(bool show) { m_show = show; }
    bool GetShow() const { return m_show; }

    virtual wxEvent *Clone() const { return new wxShowEvent(*this); }

protected:
    bool m_show;

private:
    public: static wxClassInfo sm_classwxShowEvent; virtual wxClassInfo *GetClassInfo() const { return &wxShowEvent::sm_classwxShowEvent; }
};





class wxIconizeEvent : public wxEvent
{
public:
    wxIconizeEvent(int id = 0, bool iconized = ((bool)1))
        : wxEvent(id, wxEVT_ICONIZE)
        { m_iconized = iconized; }
    wxIconizeEvent(const wxIconizeEvent & event)
        : wxEvent(event)
        { m_iconized = event.m_iconized; }


    bool Iconized() const { return m_iconized; }

    virtual wxEvent *Clone() const { return new wxIconizeEvent(*this); }

protected:
    bool m_iconized;

private:
    public: static wxClassInfo sm_classwxIconizeEvent; virtual wxClassInfo *GetClassInfo() const { return &wxIconizeEvent::sm_classwxIconizeEvent; }
};




class wxMaximizeEvent : public wxEvent
{
public:
    wxMaximizeEvent(int id = 0)
        : wxEvent(id, wxEVT_MAXIMIZE)
        { }

    virtual wxEvent *Clone() const { return new wxMaximizeEvent(*this); }

private:
    public: static wxClassInfo sm_classwxMaximizeEvent; virtual wxClassInfo *GetClassInfo() const { return &wxMaximizeEvent::sm_classwxMaximizeEvent; }
};
# 1332 "/usr/include/wx/event.h" 3 4
enum
{
    wxJOYSTICK1,
    wxJOYSTICK2
};


enum
{
    wxJOY_BUTTON_ANY = -1,
    wxJOY_BUTTON1 = 1,
    wxJOY_BUTTON2 = 2,
    wxJOY_BUTTON3 = 4,
    wxJOY_BUTTON4 = 8
};

class wxJoystickEvent : public wxEvent
{
public:
    wxPoint m_pos;
    int m_zPosition;
    int m_buttonChange;
    int m_buttonState;
    int m_joyStick;

    wxJoystickEvent(wxEventType type = wxEVT_NULL,
                    int state = 0,
                    int joystick = wxJOYSTICK1,
                    int change = 0)
        : wxEvent(0, type),
          m_pos(0, 0),
          m_zPosition(0),
          m_buttonChange(change),
          m_buttonState(state),
          m_joyStick(joystick)
    {
    }
    wxJoystickEvent(const wxJoystickEvent & event)
                : wxEvent(event),
                  m_pos(event.m_pos),
                  m_zPosition(event.m_zPosition),
                  m_buttonChange(event.m_buttonChange),
                  m_buttonState(event.m_buttonState),
                  m_joyStick(event.m_joyStick)
    { }

    wxPoint GetPosition() const { return m_pos; }
    int GetZPosition() const { return m_zPosition; }
    int GetButtonState() const { return m_buttonState; }
    int GetButtonChange() const { return m_buttonChange; }
    int GetJoystick() const { return m_joyStick; }

    void SetJoystick(int stick) { m_joyStick = stick; }
    void SetButtonState(int state) { m_buttonState = state; }
    void SetButtonChange(int change) { m_buttonChange = change; }
    void SetPosition(const wxPoint& pos) { m_pos = pos; }
    void SetZPosition(int zPos) { m_zPosition = zPos; }


    bool IsButton() const { return ((GetEventType() == wxEVT_JOY_BUTTON_DOWN) ||
            (GetEventType() == wxEVT_JOY_BUTTON_UP)); }


    bool IsMove() const { return (GetEventType() == wxEVT_JOY_MOVE) ; }


    bool IsZMove() const { return (GetEventType() == wxEVT_JOY_ZMOVE) ; }


    bool ButtonDown(int but = wxJOY_BUTTON_ANY) const
    { return ((GetEventType() == wxEVT_JOY_BUTTON_DOWN) &&
            ((but == wxJOY_BUTTON_ANY) || (but == m_buttonChange))); }


    bool ButtonUp(int but = wxJOY_BUTTON_ANY) const
    { return ((GetEventType() == wxEVT_JOY_BUTTON_UP) &&
            ((but == wxJOY_BUTTON_ANY) || (but == m_buttonChange))); }


    bool ButtonIsDown(int but = wxJOY_BUTTON_ANY) const
    { return (((but == wxJOY_BUTTON_ANY) && (m_buttonState != 0)) ||
            ((m_buttonState & but) == but)); }

    virtual wxEvent *Clone() const { return new wxJoystickEvent(*this); }

private:
    public: static wxClassInfo sm_classwxJoystickEvent; virtual wxClassInfo *GetClassInfo() const { return &wxJoystickEvent::sm_classwxJoystickEvent; }
};
# 1430 "/usr/include/wx/event.h" 3 4
class wxDropFilesEvent : public wxEvent
{
private:
    wxDropFilesEvent& operator=(const wxDropFilesEvent& event);

public:
    int m_noFiles;
    wxPoint m_pos;
    wxString* m_files;

    wxDropFilesEvent(wxEventType type = wxEVT_NULL,
                     int noFiles = 0,
                     wxString *files = (wxString *) __null)
        : wxEvent(0, type),
          m_noFiles(noFiles),
          m_pos(),
          m_files(files)
        { }


    wxDropFilesEvent(const wxDropFilesEvent& other)
        : wxEvent(other),
          m_noFiles(other.m_noFiles),
          m_pos(other.m_pos),
          m_files(__null)
    {
        m_files = new wxString[m_noFiles];
        for ( int n = 0; n < m_noFiles; n++ )
        {
            m_files[n] = other.m_files[n];
        }
    }

    virtual ~wxDropFilesEvent()
    {
        delete [] m_files;
    }

    wxPoint GetPosition() const { return m_pos; }
    int GetNumberOfFiles() const { return m_noFiles; }
    wxString *GetFiles() const { return m_files; }

    virtual wxEvent *Clone() const { return new wxDropFilesEvent(*this); }

private:
    public: static wxClassInfo sm_classwxDropFilesEvent; virtual wxClassInfo *GetClassInfo() const { return &wxDropFilesEvent::sm_classwxDropFilesEvent; }
};
# 1488 "/usr/include/wx/event.h" 3 4
class wxUpdateUIEvent : public wxCommandEvent
{
public:
    wxUpdateUIEvent(wxWindowID commandId = 0)
        : wxCommandEvent(wxEVT_UPDATE_UI, commandId)
    {
        m_checked =
        m_enabled =
        m_setEnabled =
        m_setText =
        m_setChecked = ((bool)0);
    }
    wxUpdateUIEvent(const wxUpdateUIEvent & event)
        : wxCommandEvent(event),
                  m_checked(event.m_checked),
                  m_enabled(event.m_enabled),
                  m_setEnabled(event.m_setEnabled),
                  m_setText(event.m_setText),
                  m_setChecked(event.m_setChecked),
                  m_text(event.m_text)
        { }

    bool GetChecked() const { return m_checked; }
    bool GetEnabled() const { return m_enabled; }
    wxString GetText() const { return m_text; }
    bool GetSetText() const { return m_setText; }
    bool GetSetChecked() const { return m_setChecked; }
    bool GetSetEnabled() const { return m_setEnabled; }

    void Check(bool check) { m_checked = check; m_setChecked = ((bool)1); }
    void Enable(bool enable) { m_enabled = enable; m_setEnabled = ((bool)1); }
    void SetText(const wxString& text) { m_text = text; m_setText = ((bool)1); }

    virtual wxEvent *Clone() const { return new wxUpdateUIEvent(*this); }

protected:
    bool m_checked;
    bool m_enabled;
    bool m_setEnabled;
    bool m_setText;
    bool m_setChecked;
    wxString m_text;

private:
    public: static wxClassInfo sm_classwxUpdateUIEvent; virtual wxClassInfo *GetClassInfo() const { return &wxUpdateUIEvent::sm_classwxUpdateUIEvent; }
};






class wxSysColourChangedEvent : public wxEvent
{
public:
    wxSysColourChangedEvent()
        : wxEvent(0, wxEVT_SYS_COLOUR_CHANGED)
        { }

    virtual wxEvent *Clone() const { return new wxSysColourChangedEvent(*this); }

private:
    public: static wxClassInfo sm_classwxSysColourChangedEvent; virtual wxClassInfo *GetClassInfo() const { return &wxSysColourChangedEvent::sm_classwxSysColourChangedEvent; }
};







class wxMouseCaptureChangedEvent : public wxEvent
{
private:
    wxMouseCaptureChangedEvent operator=(const wxMouseCaptureChangedEvent& event);

public:
    wxMouseCaptureChangedEvent(wxWindowID id = 0, wxWindow* gainedCapture = __null)
        : wxEvent(id, wxEVT_MOUSE_CAPTURE_CHANGED),
          m_gainedCapture(gainedCapture)
        { }

    wxMouseCaptureChangedEvent(const wxMouseCaptureChangedEvent& event)
        : wxEvent(event),
          m_gainedCapture(event.m_gainedCapture)
        { }

    virtual wxEvent *Clone() const { return new wxMouseCaptureChangedEvent(*this); }

    wxWindow* GetCapturedWindow() const { return m_gainedCapture; };

private:
    wxWindow* m_gainedCapture;
    public: static wxClassInfo sm_classwxMouseCaptureChangedEvent; virtual wxClassInfo *GetClassInfo() const { return &wxMouseCaptureChangedEvent::sm_classwxMouseCaptureChangedEvent; }
};




class wxDisplayChangedEvent : public wxEvent
{
private:
    public: static wxClassInfo sm_classwxDisplayChangedEvent; virtual wxClassInfo *GetClassInfo() const { return &wxDisplayChangedEvent::sm_classwxDisplayChangedEvent; }

public:
    wxDisplayChangedEvent()
        : wxEvent(0, wxEVT_DISPLAY_CHANGED)
        { }

    virtual wxEvent *Clone() const { return new wxDisplayChangedEvent(*this); }
};





class wxPaletteChangedEvent : public wxEvent
{
private:
    wxPaletteChangedEvent& operator=(const wxPaletteChangedEvent& event);

public:
    wxPaletteChangedEvent(wxWindowID id = 0)
        : wxEvent(id, wxEVT_PALETTE_CHANGED),
          m_changedWindow((wxWindow *) __null)
        { }

    wxPaletteChangedEvent(const wxPaletteChangedEvent& event)
        : wxEvent(event),
          m_changedWindow(event.m_changedWindow)
        { }

    void SetChangedWindow(wxWindow* win) { m_changedWindow = win; }
    wxWindow* GetChangedWindow() const { return m_changedWindow; }

    virtual wxEvent *Clone() const { return new wxPaletteChangedEvent(*this); }

protected:
    wxWindow* m_changedWindow;

private:
    public: static wxClassInfo sm_classwxPaletteChangedEvent; virtual wxClassInfo *GetClassInfo() const { return &wxPaletteChangedEvent::sm_classwxPaletteChangedEvent; }
};






class wxQueryNewPaletteEvent : public wxEvent
{
public:
    wxQueryNewPaletteEvent(wxWindowID id = 0)
        : wxEvent(id, wxEVT_QUERY_NEW_PALETTE),
          m_paletteRealized(((bool)0))
        { }
    wxQueryNewPaletteEvent(const wxQueryNewPaletteEvent & event)
        : wxEvent(event),
                m_paletteRealized(event.m_paletteRealized)
        { }


    void SetPaletteRealized(bool realized) { m_paletteRealized = realized; }
    bool GetPaletteRealized() const { return m_paletteRealized; }

    virtual wxEvent *Clone() const { return new wxQueryNewPaletteEvent(*this); }

protected:
    bool m_paletteRealized;

private:
    public: static wxClassInfo sm_classwxQueryNewPaletteEvent; virtual wxClassInfo *GetClassInfo() const { return &wxQueryNewPaletteEvent::sm_classwxQueryNewPaletteEvent; }
};






class wxNavigationKeyEvent : public wxEvent
{
private:
    wxNavigationKeyEvent& operator=(const wxNavigationKeyEvent& event);

public:
    wxNavigationKeyEvent()
        : wxEvent(0, wxEVT_NAVIGATION_KEY),
          m_flags(IsForward | Propagate),
          m_focus((wxWindow *)__null)
        { }

    wxNavigationKeyEvent(const wxNavigationKeyEvent& event)
        : wxEvent(event),
          m_flags(event.m_flags),
          m_focus(event.m_focus)
        { }


    bool GetDirection() const
        { return (m_flags & IsForward) != 0; }
    void SetDirection(bool bForward)
        { if ( bForward ) m_flags |= IsForward; else m_flags &= ~IsForward; }



    bool IsWindowChange() const
        { return (m_flags & WinChange) != 0; }
    void SetWindowChange(bool bIs)
        { if ( bIs ) m_flags |= WinChange; else m_flags &= ~WinChange; }




    bool ShouldPropagate() const
        { return (m_flags & Propagate) != 0; }
    void SetPropagate(bool bDoIt)
        { if ( bDoIt ) m_flags |= Propagate; else m_flags &= ~Propagate; }



    wxWindow* GetCurrentFocus() const { return m_focus; }
    void SetCurrentFocus(wxWindow *win) { m_focus = win; }

    virtual wxEvent *Clone() const { return new wxNavigationKeyEvent(*this); }

private:
    enum
    {
        IsForward = 0x0001,
        WinChange = 0x0002,
        Propagate = 0x0004
    };

    long m_flags;
    wxWindow *m_focus;

private:
    public: static wxClassInfo sm_classwxNavigationKeyEvent; virtual wxClassInfo *GetClassInfo() const { return &wxNavigationKeyEvent::sm_classwxNavigationKeyEvent; }
};
# 1738 "/usr/include/wx/event.h" 3 4
class wxWindowCreateEvent : public wxCommandEvent
{
public:
    wxWindowCreateEvent(wxWindow *win = __null);

    wxWindow *GetWindow() const { return (wxWindow *)GetEventObject(); }

    virtual wxEvent *Clone() const { return new wxWindowCreateEvent(*this); }

private:
    public: static wxClassInfo sm_classwxWindowCreateEvent; virtual wxClassInfo *GetClassInfo() const { return &wxWindowCreateEvent::sm_classwxWindowCreateEvent; }
};

class wxWindowDestroyEvent : public wxCommandEvent
{
public:
    wxWindowDestroyEvent(wxWindow *win = __null);

    wxWindow *GetWindow() const { return (wxWindow *)GetEventObject(); }

    virtual wxEvent *Clone() const { return new wxWindowDestroyEvent(*this); }

private:
    public: static wxClassInfo sm_classwxWindowDestroyEvent; virtual wxClassInfo *GetClassInfo() const { return &wxWindowDestroyEvent::sm_classwxWindowDestroyEvent; }
};







class wxHelpEvent : public wxCommandEvent
{
public:
    wxHelpEvent(wxEventType type = wxEVT_NULL,
                wxWindowID id = 0,
                const wxPoint& pt = wxDefaultPosition)
        : wxCommandEvent(type, id),
          m_pos(pt), m_target(), m_link()
    { }
    wxHelpEvent(const wxHelpEvent & event)
        : wxCommandEvent(event),
                  m_pos(event.m_pos),
                  m_target(event.m_target),
                  m_link(event.m_link)
    { }


    const wxPoint& GetPosition() const { return m_pos; }
    void SetPosition(const wxPoint& pos) { m_pos = pos; }


    const wxString& GetLink() const { return m_link; }
    void SetLink(const wxString& link) { m_link = link; }


    const wxString& GetTarget() const { return m_target; }
    void SetTarget(const wxString& target) { m_target = target; }

    virtual wxEvent *Clone() const { return new wxHelpEvent(*this); }

protected:
    wxPoint m_pos;
    wxString m_target;
    wxString m_link;

private:
    public: static wxClassInfo sm_classwxHelpEvent; virtual wxClassInfo *GetClassInfo() const { return &wxHelpEvent::sm_classwxHelpEvent; }
};
# 1817 "/usr/include/wx/event.h" 3 4
class wxContextMenuEvent : public wxCommandEvent
{
public:
    wxContextMenuEvent(wxEventType type = wxEVT_NULL,
                       wxWindowID id = 0,
                       const wxPoint& pt = wxDefaultPosition)
        : wxCommandEvent(type, id),
          m_pos(pt)
    { }
    wxContextMenuEvent(const wxContextMenuEvent & event)
        : wxCommandEvent(event),
                m_pos(event.m_pos)
    { }


    const wxPoint& GetPosition() const { return m_pos; }
    void SetPosition(const wxPoint& pos) { m_pos = pos; }

    virtual wxEvent *Clone() const { return new wxContextMenuEvent(*this); }

protected:
    wxPoint m_pos;

private:
    public: static wxClassInfo sm_classwxContextMenuEvent; virtual wxClassInfo *GetClassInfo() const { return &wxContextMenuEvent::sm_classwxContextMenuEvent; }
};






class wxIdleEvent : public wxEvent
{
public:
    wxIdleEvent()
        : wxEvent(0, wxEVT_IDLE),
          m_requestMore(((bool)0))
        { }
    wxIdleEvent(const wxIdleEvent & event)
        : wxEvent(event),
                m_requestMore(event.m_requestMore)
        { }

    void RequestMore(bool needMore = ((bool)1)) { m_requestMore = needMore; }
    bool MoreRequested() const { return m_requestMore; }

    virtual wxEvent *Clone() const { return new wxIdleEvent(*this); }

protected:
    bool m_requestMore;

private:
    public: static wxClassInfo sm_classwxIdleEvent; virtual wxClassInfo *GetClassInfo() const { return &wxIdleEvent::sm_classwxIdleEvent; }
};
# 1891 "/usr/include/wx/event.h" 3 4
typedef void (wxObject::*wxObjectEventFunction)(wxEvent&);
# 1914 "/usr/include/wx/event.h" 3 4
struct wxEventTableEntryBase
{
private:
    wxEventTableEntryBase& operator=(const wxEventTableEntryBase& event);

public:
    wxEventTableEntryBase(int id, int idLast,
                          wxObjectEventFunction fn, wxObject *data)
        : m_id(id),
          m_lastId(idLast),
          m_fn(fn),
          m_callbackUserData(data)
    { }

    wxEventTableEntryBase(const wxEventTableEntryBase& event)
        : m_id(event.m_id),
          m_lastId(event.m_lastId),
          m_fn(event.m_fn),
          m_callbackUserData(event.m_callbackUserData)
    { }



    int m_id,
        m_lastId;


    wxObjectEventFunction m_fn;


    wxObject* m_callbackUserData;
};


struct wxEventTableEntry : public wxEventTableEntryBase
{
    wxEventTableEntry(const int& evType, int id, int idLast,
                      wxObjectEventFunction fn, wxObject *data)
        : wxEventTableEntryBase(id, idLast, fn, data),
        m_eventType(evType)
    { }







    const int& m_eventType;
};


struct wxDynamicEventTableEntry : public wxEventTableEntryBase
{
    wxDynamicEventTableEntry(int evType, int id, int idLast,
                             wxObjectEventFunction fn, wxObject *data)
        : wxEventTableEntryBase(id, idLast, fn, data),
          m_eventType(evType)
    { }




    int m_eventType;
};






struct wxEventTable
{
    const wxEventTable *baseTable;
    const wxEventTableEntry *entries;
};





class wxEvtHandler : public wxObject
{
public:
    wxEvtHandler();
    virtual ~wxEvtHandler();

    wxEvtHandler *GetNextHandler() const { return m_nextHandler; }
    wxEvtHandler *GetPreviousHandler() const { return m_previousHandler; }
    void SetNextHandler(wxEvtHandler *handler) { m_nextHandler = handler; }
    void SetPreviousHandler(wxEvtHandler *handler) { m_previousHandler = handler; }

    void SetEvtHandlerEnabled(bool enabled) { m_enabled = enabled; }
    bool GetEvtHandlerEnabled() const { return m_enabled; }


    virtual bool ProcessEvent(wxEvent& event);


    void AddPendingEvent(wxEvent& event);


    void ProcessPendingEvents();



    bool ProcessThreadEvent(wxEvent& event);




    void Connect( int id, int lastId, int eventType,
                  wxObjectEventFunction func,
                  wxObject *userData = (wxObject *) __null );


    void Connect( int id, int eventType,
                  wxObjectEventFunction func,
                  wxObject *userData = (wxObject *) __null )
        { Connect(id, wxID_ANY, eventType, func, userData); }

    bool Disconnect( int id, int lastId, wxEventType eventType,
                  wxObjectEventFunction func = __null,
                  wxObject *userData = (wxObject *) __null );


    bool Disconnect( int id, wxEventType eventType = wxEVT_NULL,
                  wxObjectEventFunction func = __null,
                  wxObject *userData = (wxObject *) __null )
        { return Disconnect(id, wxID_ANY, eventType, func, userData); }



    void SetClientObject( wxClientData *data ) { DoSetClientObject(data); }
    wxClientData *GetClientObject() const { return DoGetClientObject(); }

    void SetClientData( void *data ) { DoSetClientData(data); }
    void *GetClientData() const { return DoGetClientData(); }



    virtual bool SearchEventTable(wxEventTable& table, wxEvent& event);
    bool SearchDynamicEventTable( wxEvent& event );


    void ClearEventLocker()
   {

      delete m_eventsLocker;
      m_eventsLocker = __null;

   };
# 2086 "/usr/include/wx/event.h" 3 4
private:
    static const wxEventTableEntry sm_eventTableEntries[];

protected:
    static const wxEventTable sm_eventTable;

    virtual const wxEventTable *GetEventTable() const;

    wxEvtHandler* m_nextHandler;
    wxEvtHandler* m_previousHandler;
    wxList* m_dynamicEvents;
    wxList* m_pendingEvents;





    wxCriticalSection* m_eventsLocker;





    bool m_isWindow;


    bool m_enabled;







    union
    {
        wxClientData *m_clientObject;
        void *m_clientData;
    };


    wxClientDataType m_clientDataType;


    virtual void DoSetClientObject( wxClientData *data );
    virtual wxClientData *DoGetClientObject() const;

    virtual void DoSetClientData( void *data );
    virtual void *DoGetClientData() const;

private:
    private: wxEvtHandler(const wxEvtHandler&); wxEvtHandler& operator=(const wxEvtHandler&);
    public: static wxClassInfo sm_classwxEvtHandler; virtual wxClassInfo *GetClassInfo() const { return &wxEvtHandler::sm_classwxEvtHandler; }
};

typedef void (wxEvtHandler::*wxEventFunction)(wxEvent&);

typedef void (wxEvtHandler::*wxCommandEventFunction)(wxCommandEvent&);
typedef void (wxEvtHandler::*wxScrollEventFunction)(wxScrollEvent&);
typedef void (wxEvtHandler::*wxScrollWinEventFunction)(wxScrollWinEvent&);
typedef void (wxEvtHandler::*wxSizeEventFunction)(wxSizeEvent&);
typedef void (wxEvtHandler::*wxMoveEventFunction)(wxMoveEvent&);
typedef void (wxEvtHandler::*wxPaintEventFunction)(wxPaintEvent&);
typedef void (wxEvtHandler::*wxEraseEventFunction)(wxEraseEvent&);
typedef void (wxEvtHandler::*wxMouseEventFunction)(wxMouseEvent&);
typedef void (wxEvtHandler::*wxCharEventFunction)(wxKeyEvent&);
typedef void (wxEvtHandler::*wxFocusEventFunction)(wxFocusEvent&);
typedef void (wxEvtHandler::*wxChildFocusEventFunction)(wxChildFocusEvent&);
typedef void (wxEvtHandler::*wxActivateEventFunction)(wxActivateEvent&);
typedef void (wxEvtHandler::*wxMenuEventFunction)(wxMenuEvent&);
typedef void (wxEvtHandler::*wxJoystickEventFunction)(wxJoystickEvent&);
typedef void (wxEvtHandler::*wxDropFilesEventFunction)(wxDropFilesEvent&);
typedef void (wxEvtHandler::*wxInitDialogEventFunction)(wxInitDialogEvent&);
typedef void (wxEvtHandler::*wxSysColourChangedFunction)(wxSysColourChangedEvent&);
typedef void (wxEvtHandler::*wxDisplayChangedFunction)(wxDisplayChangedEvent&);
typedef void (wxEvtHandler::*wxUpdateUIEventFunction)(wxUpdateUIEvent&);
typedef void (wxEvtHandler::*wxIdleEventFunction)(wxIdleEvent&);
typedef void (wxEvtHandler::*wxCloseEventFunction)(wxCloseEvent&);
typedef void (wxEvtHandler::*wxShowEventFunction)(wxShowEvent&);
typedef void (wxEvtHandler::*wxIconizeEventFunction)(wxIconizeEvent&);
typedef void (wxEvtHandler::*wxMaximizeEventFunction)(wxMaximizeEvent&);
typedef void (wxEvtHandler::*wxNavigationKeyEventFunction)(wxNavigationKeyEvent&);
typedef void (wxEvtHandler::*wxPaletteChangedEventFunction)(wxPaletteChangedEvent&);
typedef void (wxEvtHandler::*wxQueryNewPaletteEventFunction)(wxQueryNewPaletteEvent&);
typedef void (wxEvtHandler::*wxWindowCreateEventFunction)(wxWindowCreateEvent&);
typedef void (wxEvtHandler::*wxWindowDestroyEventFunction)(wxWindowDestroyEvent&);
typedef void (wxEvtHandler::*wxSetCursorEventFunction)(wxSetCursorEvent&);
typedef void (wxEvtHandler::*wxNotifyEventFunction)(wxNotifyEvent&);
typedef void (wxEvtHandler::*wxHelpEventFunction)(wxHelpEvent&);
typedef void (wxEvtHandler::*wxContextMenuEventFunction)(wxContextMenuEvent&);
typedef void (wxEvtHandler::*wxMouseCaptureChangedEventFunction)(wxMouseCaptureChangedEvent&);
# 2432 "/usr/include/wx/event.h" 3 4
extern wxList *wxPendingEvents;

    extern wxCriticalSection *wxPendingEventsLocker;
# 2445 "/usr/include/wx/event.h" 3 4
wxWindow* wxFindFocusDescendant(wxWindow* ancestor);
# 31 "/usr/include/wx/socket.h" 2 3 4



# 1 "/usr/include/wx/sckaddr.h" 1 3 4
# 16 "/usr/include/wx/sckaddr.h" 3 4
#pragma interface "sckaddr.h"







# 1 "/usr/include/wx/gsocket.h" 1 3 4
# 28 "/usr/include/wx/gsocket.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 29 "/usr/include/wx/gsocket.h" 2 3 4
# 40 "/usr/include/wx/gsocket.h" 3 4
extern "C" {


typedef struct _GSocket GSocket;
typedef struct _GAddress GAddress;

typedef enum {
  GSOCK_NOFAMILY = 0,
  GSOCK_INET,
  GSOCK_INET6,
  GSOCK_UNIX
} GAddressType;

typedef enum {
  GSOCK_STREAMED,
  GSOCK_UNSTREAMED
} GSocketStream;

typedef enum {
  GSOCK_NOERROR = 0,
  GSOCK_INVOP,
  GSOCK_IOERR,
  GSOCK_INVADDR,
  GSOCK_INVSOCK,
  GSOCK_NOHOST,
  GSOCK_INVPORT,
  GSOCK_WOULDBLOCK,
  GSOCK_TIMEDOUT,
  GSOCK_MEMERR
} GSocketError;



typedef enum {
  GSOCK_INPUT = 0,
  GSOCK_OUTPUT = 1,
  GSOCK_CONNECTION = 2,
  GSOCK_LOST = 3,
  GSOCK_MAX_EVENT = 4
} GSocketEvent;

enum {
  GSOCK_INPUT_FLAG = 1 << GSOCK_INPUT,
  GSOCK_OUTPUT_FLAG = 1 << GSOCK_OUTPUT,
  GSOCK_CONNECTION_FLAG = 1 << GSOCK_CONNECTION,
  GSOCK_LOST_FLAG = 1 << GSOCK_LOST
};

typedef int GSocketEventFlags;

typedef void (*GSocketCallback)(GSocket *socket, GSocketEvent event,
                                char *cdata);





int GSocket_Init(void);


void GSocket_Cleanup(void);




GSocket *GSocket_new(void);
void GSocket_destroy(GSocket *socket);







void GSocket_Shutdown(GSocket *socket);
# 132 "/usr/include/wx/gsocket.h" 3 4
GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address);
GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address);
GAddress *GSocket_GetLocal(GSocket *socket);
GAddress *GSocket_GetPeer(GSocket *socket);
# 149 "/usr/include/wx/gsocket.h" 3 4
GSocketError GSocket_SetServer(GSocket *socket);
# 163 "/usr/include/wx/gsocket.h" 3 4
GSocket *GSocket_WaitConnection(GSocket *socket);
# 191 "/usr/include/wx/gsocket.h" 3 4
GSocketError GSocket_Connect(GSocket *socket, GSocketStream stream);
# 207 "/usr/include/wx/gsocket.h" 3 4
GSocketError GSocket_SetNonOriented(GSocket *socket);
# 217 "/usr/include/wx/gsocket.h" 3 4
int GSocket_Read(GSocket *socket, char *buffer, int size);
int GSocket_Write(GSocket *socket, const char *buffer,
                  int size);
# 228 "/usr/include/wx/gsocket.h" 3 4
GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags);
# 237 "/usr/include/wx/gsocket.h" 3 4
void GSocket_SetNonBlocking(GSocket *socket, int non_block);





void GSocket_SetTimeout(GSocket *socket, unsigned long millisec);






GSocketError GSocket_GetError(GSocket *socket);
# 283 "/usr/include/wx/gsocket.h" 3 4
void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags,
                         GSocketCallback fallback, char *cdata);





void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags);




GAddress *GAddress_new(void);
GAddress *GAddress_copy(GAddress *address);
void GAddress_destroy(GAddress *address);

void GAddress_SetFamily(GAddress *address, GAddressType type);
GAddressType GAddress_GetFamily(GAddress *address);






GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname);
GSocketError GAddress_INET_SetAnyAddress(GAddress *address);
GSocketError GAddress_INET_SetHostAddress(GAddress *address,
                                          unsigned long hostaddr);
GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
                                       const char *protocol);
GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port);

GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname,
                                       size_t sbuf);
unsigned long GAddress_INET_GetHostAddress(GAddress *address);
unsigned short GAddress_INET_GetPort(GAddress *address);



GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path);
GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf);


}
# 25 "/usr/include/wx/sckaddr.h" 2 3 4


class wxSockAddress : public wxObject {
  public: static wxClassInfo sm_classwxSockAddress; virtual wxClassInfo *GetClassInfo() const { return &wxSockAddress::sm_classwxSockAddress; }
public:
  typedef enum { IPV4=1, IPV6=2, UNIX=3 } Addr;

  wxSockAddress();
  wxSockAddress(const wxSockAddress& other);
  virtual ~wxSockAddress();

  wxSockAddress& operator=(const wxSockAddress& other);

  virtual void Clear();
  virtual int Type() = 0;

  GAddress *GetAddress() const { return m_address; }
  void SetAddress(GAddress *address);



  virtual wxSockAddress *Clone() const = 0;

protected:
  GAddress *m_address;

private:
  void Init();
};

class wxIPV4address : public wxSockAddress {
  public: static wxClassInfo sm_classwxIPV4address; virtual wxClassInfo *GetClassInfo() const { return &wxIPV4address::sm_classwxIPV4address; }
public:
  wxIPV4address();
  wxIPV4address(const wxIPV4address& other);
  virtual ~wxIPV4address();

  bool Hostname(const wxString& name);
  bool Hostname(unsigned long addr);
  bool Service(const wxString& name);
  bool Service(unsigned short port);
  bool LocalHost();
  bool AnyAddress();

  wxString Hostname();
  wxString OrigHostname() { return m_origHostname; }
  unsigned short Service();

  virtual int Type() { return wxSockAddress::IPV4; }
  virtual wxSockAddress *Clone() const;

private:
  wxString m_origHostname;
};
# 105 "/usr/include/wx/sckaddr.h" 3 4
# 1 "/usr/include/sys/socket.h" 1 3 4
# 25 "/usr/include/sys/socket.h" 3 4
extern "C" {

# 1 "/usr/include/sys/uio.h" 1 3 4
# 26 "/usr/include/sys/uio.h" 3 4
extern "C" {


# 1 "/usr/include/bits/uio.h" 1 3 4
# 42 "/usr/include/bits/uio.h" 3 4
struct iovec
  {
    void *iov_base;
    size_t iov_len;
  };
# 30 "/usr/include/sys/uio.h" 2 3 4
# 40 "/usr/include/sys/uio.h" 3 4
extern ssize_t readv (int __fd, __const struct iovec *__vector, int __count);
# 50 "/usr/include/sys/uio.h" 3 4
extern ssize_t writev (int __fd, __const struct iovec *__vector, int __count);

}
# 28 "/usr/include/sys/socket.h" 2 3 4

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 30 "/usr/include/sys/socket.h" 2 3 4





# 1 "/usr/include/bits/socket.h" 1 3 4
# 29 "/usr/include/bits/socket.h" 3 4
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/stddef.h" 1 3 4
# 30 "/usr/include/bits/socket.h" 2 3 4

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.2/include/limits.h" 1 3 4
# 32 "/usr/include/bits/socket.h" 2 3 4




typedef __socklen_t socklen_t;




enum __socket_type
{
  SOCK_STREAM = 1,


  SOCK_DGRAM = 2,


  SOCK_RAW = 3,

  SOCK_RDM = 4,

  SOCK_SEQPACKET = 5,


  SOCK_PACKET = 10



};
# 142 "/usr/include/bits/socket.h" 3 4
# 1 "/usr/include/bits/sockaddr.h" 1 3 4
# 29 "/usr/include/bits/sockaddr.h" 3 4
typedef unsigned short int sa_family_t;
# 143 "/usr/include/bits/socket.h" 2 3 4


struct sockaddr
  {
    sa_family_t sa_family;
    char sa_data[14];
  };
# 162 "/usr/include/bits/socket.h" 3 4
struct sockaddr_storage
  {
    sa_family_t ss_family;
    __uint32_t __ss_align;
    char __ss_padding[(128 - (2 * sizeof (__uint32_t)))];
  };



enum
  {
    MSG_OOB = 0x01,

    MSG_PEEK = 0x02,

    MSG_DONTROUTE = 0x04,



    MSG_TRYHARD = MSG_DONTROUTE,


    MSG_CTRUNC = 0x08,

    MSG_PROXY = 0x10,

    MSG_TRUNC = 0x20,

    MSG_DONTWAIT = 0x40,

    MSG_EOR = 0x80,

    MSG_WAITALL = 0x100,

    MSG_FIN = 0x200,

    MSG_SYN = 0x400,

    MSG_CONFIRM = 0x800,

    MSG_RST = 0x1000,

    MSG_ERRQUEUE = 0x2000,

    MSG_NOSIGNAL = 0x4000,

    MSG_MORE = 0x8000

  };




struct msghdr
  {
    void *msg_name;
    socklen_t msg_namelen;

    struct iovec *msg_iov;
    size_t msg_iovlen;

    void *msg_control;
    size_t msg_controllen;

    int msg_flags;
  };


struct cmsghdr
  {
    size_t cmsg_len;

    int cmsg_level;
    int cmsg_type;

    __extension__ unsigned char __cmsg_data [];

  };
# 257 "/usr/include/bits/socket.h" 3 4
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
                                      struct cmsghdr *__cmsg) throw ();




extern __inline struct cmsghdr *
__cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg) throw ()
{
  if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))

    return 0;

  __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
                               + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1)));
  if ((unsigned char *) (__cmsg + 1) > ((unsigned char *) __mhdr->msg_control
                                        + __mhdr->msg_controllen)
      || ((unsigned char *) __cmsg + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))
          > ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)))

    return 0;
  return __cmsg;
}




enum
  {
    SCM_RIGHTS = 0x01,


    SCM_CREDENTIALS = 0x02,


    __SCM_CONNECT = 0x03
  };



struct ucred
{
  pid_t pid;
  uid_t uid;
  gid_t gid;
};


# 1 "/usr/include/asm/socket.h" 1 3 4



# 1 "/usr/include/asm/sockios.h" 1 3 4
# 5 "/usr/include/asm/socket.h" 2 3 4
# 306 "/usr/include/bits/socket.h" 2 3 4



struct linger
  {
    int l_onoff;
    int l_linger;
  };
# 36 "/usr/include/sys/socket.h" 2 3 4




struct osockaddr
  {
    unsigned short int sa_family;
    unsigned char sa_data[14];
  };




enum
{
  SHUT_RD = 0,

  SHUT_WR,

  SHUT_RDWR

};
# 100 "/usr/include/sys/socket.h" 3 4
extern int socket (int __domain, int __type, int __protocol) throw ();





extern int socketpair (int __domain, int __type, int __protocol,
                       int __fds[2]) throw ();


extern int bind (int __fd, __const struct sockaddr * __addr, socklen_t __len)
     throw ();


extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
                        socklen_t *__restrict __len) throw ();
# 124 "/usr/include/sys/socket.h" 3 4
extern int connect (int __fd, __const struct sockaddr * __addr, socklen_t __len);



extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
                        socklen_t *__restrict __len) throw ();






extern ssize_t send (int __fd, __const void *__buf, size_t __n, int __flags);






extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);






extern ssize_t sendto (int __fd, __const void *__buf, size_t __n,
                       int __flags, __const struct sockaddr * __addr,
                       socklen_t __addr_len);
# 161 "/usr/include/sys/socket.h" 3 4
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
                         int __flags, struct sockaddr *__restrict __addr,
                         socklen_t *__restrict __addr_len);







extern ssize_t sendmsg (int __fd, __const struct msghdr *__message,
                        int __flags);






extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);





extern int getsockopt (int __fd, int __level, int __optname,
                       void *__restrict __optval,
                       socklen_t *__restrict __optlen) throw ();




extern int setsockopt (int __fd, int __level, int __optname,
                       __const void *__optval, socklen_t __optlen) throw ();





extern int listen (int __fd, int __n) throw ();
# 209 "/usr/include/sys/socket.h" 3 4
extern int accept (int __fd, struct sockaddr *__restrict __addr,
                   socklen_t *__restrict __addr_len);







extern int shutdown (int __fd, int __how) throw ();




extern int sockatmark (int __fd) throw ();







extern int isfdtype (int __fd, int __fdtype) throw ();


}
# 106 "/usr/include/wx/sckaddr.h" 2 3 4

# 1 "/usr/include/sys/un.h" 1 3 4
# 27 "/usr/include/sys/un.h" 3 4
extern "C" {


struct sockaddr_un
  {
    sa_family_t sun_family;
    char sun_path[108];
  };
# 45 "/usr/include/sys/un.h" 3 4
}
# 108 "/usr/include/wx/sckaddr.h" 2 3 4


class wxUNIXaddress : public wxSockAddress {
  public: static wxClassInfo sm_classwxUNIXaddress; virtual wxClassInfo *GetClassInfo() const { return &wxUNIXaddress::sm_classwxUNIXaddress; }
private:
  struct sockaddr_un *m_addr;
public:
  wxUNIXaddress();
  wxUNIXaddress(const wxUNIXaddress& other);
  virtual ~wxUNIXaddress();

  void Filename(const wxString& name);
  wxString Filename();

  virtual int Type() { return wxSockAddress::UNIX; }
  virtual wxSockAddress *Clone() const { return new wxUNIXaddress(*this); }
};
# 35 "/usr/include/wx/socket.h" 2 3 4







enum wxSocketNotify
{
  wxSOCKET_INPUT = GSOCK_INPUT,
  wxSOCKET_OUTPUT = GSOCK_OUTPUT,
  wxSOCKET_CONNECTION = GSOCK_CONNECTION,
  wxSOCKET_LOST = GSOCK_LOST
};

enum
{
  wxSOCKET_INPUT_FLAG = GSOCK_INPUT_FLAG,
  wxSOCKET_OUTPUT_FLAG = GSOCK_OUTPUT_FLAG,
  wxSOCKET_CONNECTION_FLAG = GSOCK_CONNECTION_FLAG,
  wxSOCKET_LOST_FLAG = GSOCK_LOST_FLAG
};

typedef GSocketEventFlags wxSocketEventFlags;

enum wxSocketError
{

  wxSOCKET_NOERROR = GSOCK_NOERROR,
  wxSOCKET_INVOP = GSOCK_INVOP,
  wxSOCKET_IOERR = GSOCK_IOERR,
  wxSOCKET_INVADDR = GSOCK_INVADDR,
  wxSOCKET_INVSOCK = GSOCK_INVSOCK,
  wxSOCKET_NOHOST = GSOCK_NOHOST,
  wxSOCKET_INVPORT = GSOCK_INVPORT,
  wxSOCKET_WOULDBLOCK = GSOCK_WOULDBLOCK,
  wxSOCKET_TIMEDOUT = GSOCK_TIMEDOUT,
  wxSOCKET_MEMERR = GSOCK_MEMERR,


  wxSOCKET_DUMMY
};

enum
{
  wxSOCKET_NONE = 0,
  wxSOCKET_NOWAIT = 1,
  wxSOCKET_WAITALL = 2,
  wxSOCKET_BLOCK = 4
};

enum wxSocketType
{
  wxSOCKET_UNINIT,
  wxSOCKET_CLIENT,
  wxSOCKET_SERVER,
  wxSOCKET_BASE,
  wxSOCKET_DATAGRAM
};

typedef int wxSocketFlags;
# 108 "/usr/include/wx/socket.h" 3 4
class wxSocketBase : public wxObject
{
  public: static wxClassInfo sm_classwxSocketBase; virtual wxClassInfo *GetClassInfo() const { return &wxSocketBase::sm_classwxSocketBase; }

public:
# 135 "/usr/include/wx/socket.h" 3 4
public:





  wxSocketBase();
  wxSocketBase(wxSocketFlags flags, wxSocketType type);
  virtual ~wxSocketBase();
  void Init();
  bool Destroy();


  inline bool Ok() const { return (m_socket != __null); };
  inline bool Error() const { return m_error; };
  inline bool IsConnected() const { return m_connected; };
  inline bool IsData() { return WaitForRead(0, 0); };
  inline bool IsDisconnected() const { return !IsConnected(); };
  inline int unsigned LastCount() const { return m_lcount; }
  inline wxSocketError LastError() const { return (wxSocketError)GSocket_GetError(m_socket); }
  void SaveState();
  void RestoreState();


  virtual bool GetLocal(wxSockAddress& addr_man) const;
  virtual bool GetPeer(wxSockAddress& addr_man) const;


  virtual bool Close();
  wxSocketBase& Discard();
  wxSocketBase& Peek(void* buffer, int unsigned nbytes);
  wxSocketBase& Read(void* buffer, int unsigned nbytes);
  wxSocketBase& ReadMsg(void *buffer, int unsigned nbytes);
  wxSocketBase& Unread(const void *buffer, int unsigned nbytes);
  wxSocketBase& Write(const void *buffer, int unsigned nbytes);
  wxSocketBase& WriteMsg(const void *buffer, int unsigned nbytes);

  void InterruptWait() { m_interrupt = ((bool)1); };
  bool Wait(long seconds = -1, long milliseconds = 0);
  bool WaitForRead(long seconds = -1, long milliseconds = 0);
  bool WaitForWrite(long seconds = -1, long milliseconds = 0);
  bool WaitForLost(long seconds = -1, long milliseconds = 0);

  inline wxSocketFlags GetFlags() const { return m_flags; }
  void SetFlags(wxSocketFlags flags);
  void SetTimeout(long seconds);


  void *GetClientData() const { return m_clientData; }
  void SetClientData(void *data) { m_clientData = data; }
  void SetEventHandler(wxEvtHandler& handler, int id = -1);
  void SetNotify(wxSocketEventFlags flags);
  void Notify(bool notify);


  static bool IsInitialized();
  static bool Initialize();
  static void Shutdown();
# 205 "/usr/include/wx/socket.h" 3 4
  void OnRequest(wxSocketNotify notify);


  inline bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); }
  inline wxSocketType GetType() const { return m_type; }

private:
  friend class wxSocketClient;
  friend class wxSocketServer;
  friend class wxDatagramSocket;


  int unsigned _Read(void* buffer, int unsigned nbytes);
  int unsigned _Write(const void *buffer, int unsigned nbytes);
  bool _Wait(long seconds, long milliseconds, wxSocketEventFlags flags);


  void Pushback(const void *buffer, int unsigned size);
  int unsigned GetPushback(void *buffer, int unsigned size, bool peek);

private:

  GSocket *m_socket;
  wxSocketType m_type;


  wxSocketFlags m_flags;
  bool m_connected;
  bool m_establishing;
  bool m_reading;
  bool m_writing;
  bool m_error;
  wxSocketError m_lasterror;
  int unsigned m_lcount;
  unsigned long m_timeout;
  wxList m_states;
  bool m_interrupt;
  bool m_beingDeleted;


  void *m_unread;
  int unsigned m_unrd_size;
  int unsigned m_unrd_cur;


  int m_id;
  wxEvtHandler *m_handler;
  void *m_clientData;
  bool m_notify;
  wxSocketEventFlags m_eventmask;


  static size_t m_countInit;






};






class wxSocketServer : public wxSocketBase
{
  public: static wxClassInfo sm_classwxSocketServer; virtual wxClassInfo *GetClassInfo() const { return &wxSocketServer::sm_classwxSocketServer; }

public:
  wxSocketServer(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);

  wxSocketBase* Accept(bool wait = ((bool)1));
  bool AcceptWith(wxSocketBase& socket, bool wait = ((bool)1));

  bool WaitForAccept(long seconds = -1, long milliseconds = 0);
};






class wxSocketClient : public wxSocketBase
{
  public: static wxClassInfo sm_classwxSocketClient; virtual wxClassInfo *GetClassInfo() const { return &wxSocketClient::sm_classwxSocketClient; }

public:
  wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE);
  virtual ~wxSocketClient();

  virtual bool Connect(wxSockAddress& addr, bool wait = ((bool)1));

  bool WaitOnConnect(long seconds = -1, long milliseconds = 0);
};
# 309 "/usr/include/wx/socket.h" 3 4
class wxDatagramSocket : public wxSocketBase
{
  public: static wxClassInfo sm_classwxDatagramSocket; virtual wxClassInfo *GetClassInfo() const { return &wxDatagramSocket::sm_classwxDatagramSocket; }

public:
  wxDatagramSocket(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);

  wxDatagramSocket& RecvFrom( wxSockAddress& addr,
                              void* buf,
                              int unsigned nBytes );
  wxDatagramSocket& SendTo( wxSockAddress& addr,
                            const void* buf,
                            int unsigned nBytes );




};






class wxSocketEvent : public wxEvent
{
public:
  wxSocketEvent(int id = 0)
      : wxEvent(id, wxEVT_SOCKET)
      {
      }

  wxSocketNotify GetSocketEvent() const { return m_event; }
  wxSocketBase *GetSocket() const { return (wxSocketBase *) GetEventObject(); }
  void *GetClientData() const { return m_clientData; }







  virtual wxEvent *Clone() const { return new wxSocketEvent(*this); }

public:
  wxSocketNotify m_event;
  void *m_clientData;

  public: static wxClassInfo sm_classwxSocketEvent; virtual wxClassInfo *GetClassInfo() const { return &wxSocketEvent::sm_classwxSocketEvent; }
};


typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
# 29 "/usr/include/wx/protocol/protocol.h" 2 3 4






typedef enum
{
    wxPROTO_NOERR = 0,
    wxPROTO_NETERR,
    wxPROTO_PROTERR,
    wxPROTO_CONNERR,
    wxPROTO_INVVAL,
    wxPROTO_NOHNDLR,
    wxPROTO_NOFILE,
    wxPROTO_ABRT,
    wxPROTO_RCNCT,
    wxPROTO_STREAMING
} wxProtocolError;





class wxProtocol

 : public wxSocketClient



{
public:
    wxProtocol();


    bool Reconnect();
    virtual bool Connect( const wxString& ) { return ((bool)0); }
    virtual bool Connect( wxSockAddress& addr, bool = ((bool)1)) { return wxSocketClient::Connect(addr); }



    static wxProtocolError ReadLine(wxSocketBase *socket, wxString& result);



    virtual wxProtocolError ReadLine(wxString& result);


    virtual bool Abort() = 0;
    virtual wxInputStream *GetInputStream(const wxString& path) = 0;
    virtual wxProtocolError GetError() = 0;
    virtual wxString GetContentType() { return wxEmptyString; }
    virtual void SetUser(const wxString& ) {}
    virtual void SetPassword(const wxString& ) {}

private:
    public: static wxClassInfo sm_classwxProtocol; virtual wxClassInfo *GetClassInfo() const { return &wxProtocol::sm_classwxProtocol; }
};


wxProtocolError GetLine(wxSocketBase *sock, wxString& result);
# 111 "/usr/include/wx/protocol/protocol.h" 3 4
class wxProtoInfo : public wxObject
{
public:
    wxProtoInfo(const wxChar *name,
                const wxChar *serv_name,
                const bool need_host1,
                wxClassInfo *info);

protected:
    wxProtoInfo *next;
    wxString m_protoname;
    wxString prefix;
    wxString m_servname;
    wxClassInfo *m_cinfo;
    bool m_needhost;

    friend class wxURL;

    public: static wxClassInfo sm_classwxProtoInfo; virtual wxClassInfo *GetClassInfo() const { return &wxProtoInfo::sm_classwxProtoInfo; }
};
# 25 "/usr/include/wx/url.h" 2 3 4


# 1 "/usr/include/wx/protocol/http.h" 1 3 4
# 21 "/usr/include/wx/protocol/http.h" 3 4
class wxHTTP : public wxProtocol {
  public: static wxClassInfo sm_classwxHTTP; virtual wxClassInfo *GetClassInfo() const { return &wxHTTP::sm_classwxHTTP; }
  public: static wxProtoInfo g_proto_wxHTTP;
protected:
  wxProtocolError m_perr;
  wxList m_headers;
  bool m_read, m_proxy_mode;
  wxSockAddress *m_addr;
public:
  wxHTTP();
  ~wxHTTP();

  bool Connect(const wxString& host);
  bool Connect(wxSockAddress& addr, bool wait);
  bool Abort();
  wxInputStream *GetInputStream(const wxString& path);
  inline wxProtocolError GetError() { return m_perr; }
  wxString GetContentType();

  void SetHeader(const wxString& header, const wxString& h_data);
  wxString GetHeader(const wxString& header);

  void SetProxyMode(bool on);

protected:
  typedef enum {
    wxHTTP_GET,
    wxHTTP_HEAD
  } wxHTTP_Req;
  bool BuildRequest(const wxString& path, wxHTTP_Req req);
  void SendHeaders();
  bool ParseHeaders();


  void ClearHeaders();
};
# 28 "/usr/include/wx/url.h" 2 3 4


typedef enum {
  wxURL_NOERR = 0,
  wxURL_SNTXERR,
  wxURL_NOPROTO,
  wxURL_NOHOST,
  wxURL_NOPATH,
  wxURL_CONNERR,
  wxURL_PROTOERR
} wxURLError;

class wxURL : public wxObject
{
public:
    wxURL(const wxString& url);
    virtual ~wxURL();

    wxString GetProtocolName() const { return m_protoinfo->m_protoname; }
    wxString GetHostName() const { return m_hostname; }
    wxString GetURL() const { return m_url; }
    wxProtocol& GetProtocol() { return *m_protocol; }
    wxURLError GetError() const { return m_error; }
    wxString GetPath() const { return m_path; }

    wxInputStream *GetInputStream();


    static void SetDefaultProxy(const wxString& url_proxy);
    void SetProxy(const wxString& url_proxy);


    static wxString ConvertToValidURI(
                        const wxString& uri,
                        const wxChar* delims = ";/?:@&=+$,"
                    );
    static wxString ConvertFromURI(const wxString& uri);

protected:
    static wxProtoInfo *ms_protocols;


    static wxHTTP *ms_proxyDefault;
    static bool ms_useDefaultProxy;
    wxHTTP *m_proxy;


    wxProtoInfo *m_protoinfo;
    wxProtocol *m_protocol;

    wxURLError m_error;
    wxString m_protoname, m_hostname, m_servname, m_path, m_url;
    wxString m_user, m_password;
    bool m_useProxy;

    bool PrepProto(wxString& url);
    bool PrepHost(wxString& url);
    bool PrepPath(wxString& url);
    bool ParseURL();
    void CleanData();
    bool FetchProtocol();

    friend class wxProtoInfo;
    friend class wxURLModule;

private:


    private: wxURL(const wxURL&); wxURL& operator=(const wxURL&);

    public: static wxClassInfo sm_classwxURL; virtual wxClassInfo *GetClassInfo() const { return &wxURL::sm_classwxURL; }
};
# 31 "/usr/include/wx/filesys.h" 2 3 4

# 1 "/usr/include/wx/filename.h" 1 3 4
# 16 "/usr/include/wx/filename.h" 3 4
#pragma interface "filename.h"
# 41 "/usr/include/wx/filename.h" 3 4
class wxFile;
# 50 "/usr/include/wx/filename.h" 3 4
enum wxPathFormat
{
    wxPATH_NATIVE = 0,
    wxPATH_UNIX,
    wxPATH_MAC,
    wxPATH_DOS,
    wxPATH_VMS,

    wxPATH_BEOS = wxPATH_UNIX,
    wxPATH_WIN = wxPATH_DOS,
    wxPATH_OS2 = wxPATH_DOS
};



enum wxPathNormalize
{
    wxPATH_NORM_ENV_VARS = 0x0001,
    wxPATH_NORM_DOTS = 0x0002,
    wxPATH_NORM_TILDE = 0x0004,
    wxPATH_NORM_CASE = 0x0008,
    wxPATH_NORM_ABSOLUTE = 0x0010,
    wxPATH_NORM_LONG = 0x0020,
    wxPATH_NORM_ALL = 0x003f
};


enum
{
    wxPATH_GET_VOLUME = 0x0001,
    wxPATH_GET_SEPARATOR = 0x0002
};


enum
{
    wxPATH_MKDIR_FULL = 0x0001
};





class wxFileName
{
public:



    wxFileName() { Clear(); }
    wxFileName( const wxFileName &filepath ) { Assign(filepath); }




    wxFileName( const wxString& fullpath, wxPathFormat format = wxPATH_NATIVE )
        { Assign( fullpath, format ); }


    wxFileName(const wxString& path,
               const wxString& name,
               wxPathFormat format = wxPATH_NATIVE)
        { Assign(path, name, format); }


    wxFileName(const wxString& volume,
               const wxString& path,
               const wxString& name,
               const wxString& ext,
               wxPathFormat format = wxPATH_NATIVE)
        { Assign(volume, path, name, ext, format); }


    wxFileName(const wxString& path,
               const wxString& name,
               const wxString& ext,
               wxPathFormat format = wxPATH_NATIVE)
        { Assign(path, name, ext, format); }



    void Assign(const wxFileName& filepath);

    void Assign(const wxString& fullpath,
                wxPathFormat format = wxPATH_NATIVE);

    void Assign(const wxString& volume,
                const wxString& path,
                const wxString& name,
                const wxString& ext,
                wxPathFormat format = wxPATH_NATIVE);

    void Assign(const wxString& path,
                const wxString& name,
                wxPathFormat format = wxPATH_NATIVE);

    void Assign(const wxString& path,
                const wxString& name,
                const wxString& ext,
                wxPathFormat format = wxPATH_NATIVE)
    {

        Assign("", path, name, ext, format);
    }

    void AssignDir(const wxString& dir, wxPathFormat format = wxPATH_NATIVE);



    wxFileName& operator=(const wxFileName& filename)
        { Assign(filename); return *this; }

    wxFileName& operator=(const wxString& filename)
        { Assign(filename); return *this; }


    void Clear();


    static wxFileName FileName(const wxString& file);
    static wxFileName DirName(const wxString& dir);




    bool IsOk() const { return !m_dirs.IsEmpty() || !m_name.IsEmpty(); }


    bool FileExists();
    static bool FileExists( const wxString &file );


    bool DirExists();
    static bool DirExists( const wxString &dir );







    bool SetTimes(const wxDateTime *dtAccess,
                  const wxDateTime *dtMod,
                  const wxDateTime *dtCreate);


    bool Touch();



    bool GetTimes(wxDateTime *dtAccess,
                  wxDateTime *dtMod,
                  wxDateTime *dtCreate) const;


    wxDateTime GetModificationTime() const
    {
        wxDateTime dtMod;
        (void)GetTimes(__null, &dtMod, __null);
        return dtMod;
    }
# 226 "/usr/include/wx/filename.h" 3 4
    void AssignCwd(const wxString& volume = wxEmptyString);
    static wxString GetCwd(const wxString& volume = wxEmptyString);


    bool SetCwd();
    static bool SetCwd( const wxString &cwd );


    void AssignHomeDir();
    static wxString GetHomeDir();




    void AssignTempFileName(const wxString& prefix, wxFile *fileTemp = __null);
    static wxString CreateTempFileName(const wxString& prefix,
                                       wxFile *fileTemp = __null);



    bool Mkdir( int perm = 0777, int flags = 0);
    static bool Mkdir( const wxString &dir, int perm = 0777, int flags = 0 );

    bool Rmdir();
    static bool Rmdir( const wxString &dir );
# 259 "/usr/include/wx/filename.h" 3 4
    bool Normalize(int flags = wxPATH_NORM_ALL,
                   const wxString& cwd = wxEmptyString,
                   wxPathFormat format = wxPATH_NATIVE);
# 271 "/usr/include/wx/filename.h" 3 4
    bool MakeRelativeTo(const wxString& pathBase = "",
                        wxPathFormat format = wxPATH_NATIVE);

    bool MakeAbsolute(const wxString& cwd = wxEmptyString,
                      wxPathFormat format = wxPATH_NATIVE)
        { return Normalize(wxPATH_NORM_DOTS | wxPATH_NORM_ABSOLUTE |
                           wxPATH_NORM_TILDE, cwd, format); }




    bool SameAs(const wxFileName& filepath,
                wxPathFormat format = wxPATH_NATIVE) const;


    bool operator==(const wxFileName& filename) const
        { return SameAs(filename); }
    bool operator!=(const wxFileName& filename) const
        { return !SameAs(filename); }


    bool operator==(const wxString& filename) const
        { return SameAs(wxFileName(filename)); }
    bool operator!=(const wxString& filename) const
        { return !SameAs(wxFileName(filename)); }


    static bool IsCaseSensitive( wxPathFormat format = wxPATH_NATIVE );


    bool IsAbsolute(wxPathFormat format = wxPATH_NATIVE) const;


    bool IsRelative(wxPathFormat format = wxPATH_NATIVE) const
        { return !IsAbsolute(format); }






    static wxString GetVolumeSeparator(wxPathFormat format = wxPATH_NATIVE);


    static wxString GetPathSeparators(wxPathFormat format = wxPATH_NATIVE);


    static wxChar GetPathSeparator(wxPathFormat format = wxPATH_NATIVE)
        { return GetPathSeparators(format)[0u]; }


    static bool IsPathSeparator(wxChar ch, wxPathFormat format = wxPATH_NATIVE);


    void AppendDir( const wxString &dir );
    void PrependDir( const wxString &dir );
    void InsertDir( int before, const wxString &dir );
    void RemoveDir( int pos );
    size_t GetDirCount() const { return m_dirs.GetCount(); }


    void SetExt( const wxString &ext ) { m_ext = ext; }
    wxString GetExt() const { return m_ext; }
    bool HasExt() const { return !m_ext.empty(); }

    void SetName( const wxString &name ) { m_name = name; }
    wxString GetName() const { return m_name; }
    bool HasName() const { return !m_name.empty(); }

    void SetVolume( const wxString &volume ) { m_volume = volume; }
    wxString GetVolume() const { return m_volume; }
    bool HasVolume() const { return !m_volume.empty(); }


    void SetFullName(const wxString& fullname);
    wxString GetFullName() const;

    const wxArrayString& GetDirs() const { return m_dirs; }


    wxString GetPath(int flags = 0, wxPathFormat format = wxPATH_NATIVE) const;


    void SetPath( const wxString &path, wxPathFormat format = wxPATH_NATIVE );


    wxString GetFullPath( wxPathFormat format = wxPATH_NATIVE ) const;


    wxString GetShortPath() const;


    wxString GetLongPath() const;


    bool IsDir() const { return m_name.empty() && m_ext.empty(); }




    static wxPathFormat GetFormat( wxPathFormat format = wxPATH_NATIVE );



    static void SplitPath(const wxString& fullpath,
                          wxString *volume,
                          wxString *path,
                          wxString *name,
                          wxString *ext,
                          wxPathFormat format = wxPATH_NATIVE);


    static void SplitPath(const wxString& fullpath,
                          wxString *path,
                          wxString *name,
                          wxString *ext,
                          wxPathFormat format = wxPATH_NATIVE);





    wxString GetPath( bool withSep, wxPathFormat format = wxPATH_NATIVE ) const
        { return GetPath(withSep ? wxPATH_GET_SEPARATOR : 0, format); }

    wxString GetPathWithSep(wxPathFormat format = wxPATH_NATIVE ) const
        { return GetPath(wxPATH_GET_SEPARATOR, format); }

private:

    wxString m_volume;


    wxArrayString m_dirs;


    wxString m_name,
                    m_ext;
# 418 "/usr/include/wx/filename.h" 3 4
    bool m_relative;
};
# 33 "/usr/include/wx/filesys.h" 2 3 4

class wxFSFile;
class wxFileSystemHandler;
class wxFileSystem;
# 45 "/usr/include/wx/filesys.h" 3 4
class wxFSFile : public wxObject
{
public:
    wxFSFile(wxInputStream *stream, const wxString& loc,
             const wxString& mimetype, const wxString& anchor,
             wxDateTime modif)
    {
        m_Stream = stream;
        m_Location = loc;
        m_MimeType = mimetype; m_MimeType.MakeLower();
        m_Anchor = anchor;
        m_Modif = modif;
    }
    virtual ~wxFSFile() { if (m_Stream) delete m_Stream; }



    wxInputStream *GetStream() const {return m_Stream;}


    const wxString& GetMimeType() const {return m_MimeType;}


    const wxString& GetLocation() const {return m_Location;}

    const wxString& GetAnchor() const {return m_Anchor;}

    wxDateTime GetModificationTime() const {return m_Modif;}

private:
    wxInputStream *m_Stream;
    wxString m_Location;
    wxString m_MimeType;
    wxString m_Anchor;
    wxDateTime m_Modif;

    public: static wxClassInfo sm_classwxFSFile; virtual wxClassInfo *GetClassInfo() const { return &wxFSFile::sm_classwxFSFile; }
};
# 95 "/usr/include/wx/filesys.h" 3 4
class wxFileSystemHandler : public wxObject
{
public:
    wxFileSystemHandler() : wxObject() {}


    virtual bool CanOpen(const wxString& location) = 0;




    virtual wxFSFile* OpenFile(wxFileSystem& fs, const wxString& location) = 0;




    virtual wxString FindFirst(const wxString& spec, int flags = 0);
    virtual wxString FindNext();

protected:



    wxString GetProtocol(const wxString& location) const;



    wxString GetLeftLocation(const wxString& location) const;




    wxString GetAnchor(const wxString& location) const;



    wxString GetRightLocation(const wxString& location) const;



    wxString GetMimeTypeFromExt(const wxString& location);

    public: static wxClassInfo sm_classwxFileSystemHandler; virtual wxClassInfo *GetClassInfo() const { return &wxFileSystemHandler::sm_classwxFileSystemHandler; }
};
# 149 "/usr/include/wx/filesys.h" 3 4
class wxFileSystem : public wxObject
{
public:
    wxFileSystem() : wxObject() {m_Path = m_LastName = wxEmptyString; m_Handlers.DeleteContents(((bool)1)); m_FindFileHandler = __null;}







    void ChangePathTo(const wxString& location, bool is_dir = ((bool)0));

    wxString GetPath() const {return m_Path;}






    wxFSFile* OpenFile(const wxString& location);




    wxString FindFirst(const wxString& spec, int flags = 0);
    wxString FindNext();



    static void AddHandler(wxFileSystemHandler *handler);


    static void CleanUpHandlers();


    static wxFileName URLToFileName(const wxString& url);


    static wxString FileNameToURL(const wxFileName& filename);


protected:
    wxString m_Path;




    wxString m_LastName;

    static wxList m_Handlers;

    wxFileSystemHandler *m_FindFileHandler;


    public: static wxClassInfo sm_classwxFileSystem; virtual wxClassInfo *GetClassInfo() const { return &wxFileSystem::sm_classwxFileSystem; }
};
# 232 "/usr/include/wx/filesys.h" 3 4
class wxLocalFSHandler : public wxFileSystemHandler
{
public:
    virtual bool CanOpen(const wxString& location);
    virtual wxFSFile* OpenFile(wxFileSystem& fs, const wxString& location);
    virtual wxString FindFirst(const wxString& spec, int flags = 0);
    virtual wxString FindNext();





    static void Chroot(const wxString& root) { ms_root = root; }

protected:
    static wxString ms_root;
};
# 25 "../../wx/xrc/xmlres.h" 2

# 1 "/usr/include/wx/icon.h" 1 3 4
# 15 "/usr/include/wx/icon.h" 3 4
# 1 "/usr/include/wx/gtk/icon.h" 1 3 4
# 15 "/usr/include/wx/gtk/icon.h" 3 4
#pragma interface
# 26 "/usr/include/wx/gtk/icon.h" 3 4
class wxIcon;





class wxIcon: public wxBitmap
{
public:
    wxIcon();
    wxIcon( const wxIcon& icon);
    wxIcon( const char **bits, int width=-1, int height=-1 );



    wxIcon( const wxString& filename, int type = wxBITMAP_TYPE_XPM,
            int =-1, int =-1 ) :
        wxBitmap(filename, type)
    {
    }
    wxIcon( char **bits, int width=-1, int height=-1 );

    wxIcon& operator=(const wxIcon& icon);
    bool operator==(const wxIcon& icon) const { return m_refData == icon.m_refData; }
    bool operator!=(const wxIcon& icon) const { return !(*this == icon); }




    void CopyFromBitmap(const wxBitmap& bmp);

private:
    public: static wxClassInfo sm_classwxIcon; virtual wxClassInfo *GetClassInfo() const { return &wxIcon::sm_classwxIcon; }
};
# 16 "/usr/include/wx/icon.h" 2 3 4
# 27 "../../wx/xrc/xmlres.h" 2
# 1 "/usr/include/wx/artprov.h" 1 3 4
# 16 "/usr/include/wx/artprov.h" 3 4
#pragma interface "artprov.h"






class wxArtProvidersList;
class wxArtProviderCache;
class wxArtProviderModule;





typedef wxString wxArtClient;
typedef wxString wxArtID;
# 92 "/usr/include/wx/artprov.h" 3 4
class wxArtProvider : public wxObject
{
public:

    static void PushProvider(wxArtProvider *provider);


    static bool PopProvider();



    static bool RemoveProvider(wxArtProvider *provider);



    static wxBitmap GetBitmap(const wxArtID& id,
                              const wxArtClient& client = "wxART_OTHER" "_C",
                              const wxSize& size = wxDefaultSize);



    static wxIcon GetIcon(const wxArtID& id,
                          const wxArtClient& client = "wxART_OTHER" "_C",
                          const wxSize& size = wxDefaultSize);

protected:
    friend class wxArtProviderModule;

    static void InitStdProvider();

    static void CleanUpProviders();




    virtual wxBitmap CreateBitmap(const wxArtID& ,
                                  const wxArtClient& ,
                                  const wxSize& ) = 0;

private:

    static wxArtProvidersList *sm_providers;

    static wxArtProviderCache *sm_cache;

    public: static wxClassInfo sm_classwxArtProvider; virtual wxClassInfo *GetClassInfo() const { return &wxArtProvider::sm_classwxArtProvider; }
};
# 28 "../../wx/xrc/xmlres.h" 2

# 1 "../../wx/xrc/xml.h" 1
# 15 "../../wx/xrc/xml.h"
#pragma interface "xml.h"
# 29 "../../wx/xrc/xml.h"
class wxXmlNode;
class wxXmlProperty;
class wxXmlDocument;
class wxXmlIOHandler;
class wxInputStream;
class wxOutputStream;



enum wxXmlNodeType
{

    wxXML_ELEMENT_NODE = 1,
    wxXML_ATTRIBUTE_NODE = 2,
    wxXML_TEXT_NODE = 3,
    wxXML_CDATA_SECTION_NODE = 4,
    wxXML_ENTITY_REF_NODE = 5,
    wxXML_ENTITY_NODE = 6,
    wxXML_PI_NODE = 7,
    wxXML_COMMENT_NODE = 8,
    wxXML_DOCUMENT_NODE = 9,
    wxXML_DOCUMENT_TYPE_NODE = 10,
    wxXML_DOCUMENT_FRAG_NODE = 11,
    wxXML_NOTATION_NODE = 12,
    wxXML_HTML_DOCUMENT_NODE = 13
};






class wxXmlProperty
{
public:
    wxXmlProperty() : m_next(__null) {}
    wxXmlProperty(const wxString& name, const wxString& value,
                  wxXmlProperty *next)
            : m_name(name), m_value(value), m_next(next) {}

    wxString GetName() const { return m_name; }
    wxString GetValue() const { return m_value; }
    wxXmlProperty *GetNext() const { return m_next; }

    void SetName(const wxString& name) { m_name = name; }
    void SetValue(const wxString& value) { m_value = value; }
    void SetNext(wxXmlProperty *next) { m_next = next; }

private:
    wxString m_name;
    wxString m_value;
    wxXmlProperty *m_next;
};
# 94 "../../wx/xrc/xml.h"
class wxXmlNode
{
public:
    wxXmlNode() : m_properties(__null), m_parent(__null),
                  m_children(__null), m_next(__null) {}
    wxXmlNode(wxXmlNode *parent,wxXmlNodeType type,
              const wxString& name, const wxString& content,
              wxXmlProperty *props, wxXmlNode *next);
    ~wxXmlNode();





    wxXmlNode(const wxXmlNode& node);
    wxXmlNode& operator=(const wxXmlNode& node);


    wxXmlNode(wxXmlNodeType type, const wxString& name,
              const wxString& content = wxEmptyString);
    void AddChild(wxXmlNode *child);
    void InsertChild(wxXmlNode *child, wxXmlNode *before_node);
    bool RemoveChild(wxXmlNode *child);
    void AddProperty(const wxString& name, const wxString& value);
    bool DeleteProperty(const wxString& name);


    wxXmlNodeType GetType() const { return m_type; }
    wxString GetName() const { return m_name; }
    wxString GetContent() const { return m_content; }

    wxXmlNode *GetParent() const { return m_parent; }
    wxXmlNode *GetNext() const { return m_next; }
    wxXmlNode *GetChildren() const { return m_children; }

    wxXmlProperty *GetProperties() const { return m_properties; }
    bool GetPropVal(const wxString& propName, wxString *value) const;
    wxString GetPropVal(const wxString& propName,
                        const wxString& defaultVal) const;
    bool HasProp(const wxString& propName) const;

    void SetType(wxXmlNodeType type) { m_type = type; }
    void SetName(const wxString& name) { m_name = name; }
    void SetContent(const wxString& con) { m_content = con; }

    void SetParent(wxXmlNode *parent) { m_parent = parent; }
    void SetNext(wxXmlNode *next) { m_next = next; }
    void SetChildren(wxXmlNode *child) { m_children = child; }

    void SetProperties(wxXmlProperty *prop) { m_properties = prop; }
    void AddProperty(wxXmlProperty *prop);

private:
    wxXmlNodeType m_type;
    wxString m_name;
    wxString m_content;
    wxXmlProperty *m_properties;
    wxXmlNode *m_parent, *m_children, *m_next;

    void DoCopy(const wxXmlNode& node);
};
# 164 "../../wx/xrc/xml.h"
class wxXmlDocument : public wxObject
{
public:
    wxXmlDocument();
    wxXmlDocument(const wxString& filename,
                  const wxString& encoding = "UTF-8");
    wxXmlDocument(wxInputStream& stream,
                  const wxString& encoding = "UTF-8");
    ~wxXmlDocument() { delete m_root; }

    wxXmlDocument(const wxXmlDocument& doc);
    wxXmlDocument& operator=(const wxXmlDocument& doc);



    bool Load(const wxString& filename,
              const wxString& encoding = "UTF-8");
    bool Load(wxInputStream& stream,
              const wxString& encoding = "UTF-8");


    bool Save(const wxString& filename) const;
    bool Save(wxOutputStream& stream) const;

    bool IsOk() const { return m_root != __null; }


    wxXmlNode *GetRoot() const { return m_root; }


    wxString GetVersion() const { return m_version; }



    wxString GetFileEncoding() const { return m_fileEncoding; }


    void SetRoot(wxXmlNode *node) { delete m_root ; m_root = node; }
    void SetVersion(const wxString& version) { m_version = version; }
    void SetFileEncoding(const wxString& encoding) { m_fileEncoding = encoding; }





    wxString GetEncoding() const { return m_encoding; }
    void SetEncoding(const wxString& enc) { m_encoding = enc; }


private:
    wxString m_version;
    wxString m_fileEncoding;

    wxString m_encoding;

    wxXmlNode *m_root;

    void DoCopy(const wxXmlDocument& doc);
};
# 30 "../../wx/xrc/xmlres.h" 2

class wxMenu;
class wxMenuBar;
class wxDialog;
class wxPanel;
class wxWindow;
class wxFrame;
class wxToolBar;

class wxXmlResourceHandler;
class wxXmlSubclassFactory;
class wxXmlSubclassFactoriesList;
class wxXmlResourceModule;
# 69 "../../wx/xrc/xmlres.h"
class wxXmlResourceDataRecord
{
public:
    wxXmlResourceDataRecord() : Doc(__null), Time(wxDateTime::Now()) {}
    ~wxXmlResourceDataRecord() {delete Doc;}

    wxString File;
    wxXmlDocument *Doc;
    wxDateTime Time;
};





typedef wxXmlResourceDataRecord _wxObjArraywxXmlResourceDataRecords; typedef int ( *CMPFUNC_wxObjArraywxXmlResourceDataRecords)(_wxObjArraywxXmlResourceDataRecords **pItem1, _wxObjArraywxXmlResourceDataRecords **pItem2); class wxXmlResourceDataRecords : public wxArrayPtrVoid { typedef int ( *CMPFUNCwxArrayPtrVoid)(void **pItem1, void **pItem2); public: wxXmlResourceDataRecords() { } wxXmlResourceDataRecords(const wxXmlResourceDataRecords& src); wxXmlResourceDataRecords& operator=(const wxXmlResourceDataRecords& src); ~wxXmlResourceDataRecords(); _wxObjArraywxXmlResourceDataRecords& operator[](size_t uiIndex) const { return *(_wxObjArraywxXmlResourceDataRecords*)wxArrayPtrVoid::Item(uiIndex); } _wxObjArraywxXmlResourceDataRecords& Item(size_t uiIndex) const { return *(_wxObjArraywxXmlResourceDataRecords*)wxArrayPtrVoid::Item(uiIndex); } _wxObjArraywxXmlResourceDataRecords& Last() const { return *(_wxObjArraywxXmlResourceDataRecords*)(wxArrayPtrVoid::Item(Count() - 1)); } int Index(const _wxObjArraywxXmlResourceDataRecords& Item, bool bFromEnd = ((bool)0)) const; void Add(const _wxObjArraywxXmlResourceDataRecords& Item, size_t nInsert = 1); void Add(const _wxObjArraywxXmlResourceDataRecords* pItem) { wxArrayPtrVoid::Add((_wxObjArraywxXmlResourceDataRecords*)pItem); } void Insert(const _wxObjArraywxXmlResourceDataRecords& Item, size_t uiIndex, size_t nInsert = 1); void Insert(const _wxObjArraywxXmlResourceDataRecords* pItem, size_t uiIndex) { wxArrayPtrVoid::Insert((_wxObjArraywxXmlResourceDataRecords*)pItem, uiIndex); } void Empty() { DoEmpty(); wxArrayPtrVoid::Empty(); } void Clear() { DoEmpty(); wxArrayPtrVoid::Clear(); } _wxObjArraywxXmlResourceDataRecords* Detach(size_t uiIndex) { _wxObjArraywxXmlResourceDataRecords* p = (_wxObjArraywxXmlResourceDataRecords*)wxArrayPtrVoid::Item(uiIndex); wxArrayPtrVoid::RemoveAt(uiIndex); return p; } void RemoveAt(size_t uiIndex, size_t nRemove = 1); void Sort(CMPFUNC_wxObjArraywxXmlResourceDataRecords fCmp) { wxArrayPtrVoid::Sort((CMPFUNCwxArrayPtrVoid)fCmp); } private: void DoEmpty(); void DoCopy(const wxXmlResourceDataRecords& src); };


enum wxXmlResourceFlags
{
    wxXRC_USE_LOCALE = 1,
    wxXRC_NO_SUBCLASSING = 2
};




class wxXmlResource : public wxObject
{
public:






    wxXmlResource(int flags = wxXRC_USE_LOCALE);







    wxXmlResource(const wxString& filemask, int flags = wxXRC_USE_LOCALE);


    ~wxXmlResource();



    bool Load(const wxString& filemask);




    void InitAllHandlers();






    void AddHandler(wxXmlResourceHandler *handler);


    void InsertHandler(wxXmlResourceHandler *handler);


    void ClearHandlers();




    static void AddSubclassFactory(wxXmlSubclassFactory *factory);


    wxMenu *LoadMenu(const wxString& name);


    wxMenuBar *LoadMenuBar(wxWindow *parent, const wxString& name);


    wxMenuBar *LoadMenuBar(const wxString& name) { return LoadMenuBar(__null, name); }



    wxToolBar *LoadToolBar(wxWindow *parent, const wxString& name);



    wxDialog *LoadDialog(wxWindow *parent, const wxString& name);
# 169 "../../wx/xrc/xmlres.h"
    bool LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name);


    wxPanel *LoadPanel(wxWindow *parent, const wxString& name);



    bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name);


    wxFrame *LoadFrame(wxWindow* parent, const wxString& name);
    bool LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name);



    wxObject *LoadObject(wxWindow *parent, const wxString& name,
                         const wxString& classname);




    bool LoadObject(wxObject *instance, wxWindow *parent, const wxString& name,
                    const wxString& classname);


    wxBitmap LoadBitmap(const wxString& name);


    wxIcon LoadIcon(const wxString& name);



    bool AttachUnknownControl(const wxString& name, wxWindow *control,
                              wxWindow *parent = __null);




    static int GetXRCID(const wxChar *str_id);


    long GetVersion() const { return m_version; }



    int CompareVersion(int major, int minor, int release, int revision) const
        { return GetVersion() -
                 (major*256*256*256 + minor*256*256 + release*256 + revision); }




    static wxXmlResource *Get();


    static wxXmlResource *Set(wxXmlResource *res);


    int GetFlags() const { return m_flags; }

    void SetFlags(int flags) { m_flags = flags; }

protected:


    void UpdateResources();


    wxXmlNode *FindResource(const wxString& name, const wxString& classname, bool recursive = ((bool)0));


    wxXmlNode *DoFindResource(wxXmlNode *parent, const wxString& name, const wxString& classname, bool recursive);


    wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent, wxObject *instance = __null);

private:
    long m_version;

    int m_flags;
    wxList m_handlers;
    wxXmlResourceDataRecords m_data;

    wxFileSystem m_curFileSystem;
    wxFileSystem& GetCurFileSystem() { return m_curFileSystem; }


    friend class wxXmlResourceHandler;
    friend class wxXmlResourceModule;

    static wxXmlSubclassFactoriesList *ms_subclassFactories;


    static wxXmlResource *ms_instance;
};
# 300 "../../wx/xrc/xmlres.h"
class wxXmlResourceHandler : public wxObject
{
public:

    wxXmlResourceHandler();


    virtual ~wxXmlResourceHandler() {}







    wxObject *CreateResource(wxXmlNode *node, wxObject *parent,
                             wxObject *instance);



    virtual wxObject *DoCreateResource() = 0;



    virtual bool CanHandle(wxXmlNode *node) = 0;


    void SetParentResource(wxXmlResource *res) { m_resource = res; }

protected:
    wxXmlResource *m_resource;
    wxArrayString m_styleNames;
    wxArrayInt m_styleValues;


    wxXmlNode *m_node;
    wxString m_class;
    wxObject *m_parent, *m_instance;
    wxWindow *m_parentAsWindow, *m_instanceAsWindow;





    bool IsOfClass(wxXmlNode *node, const wxString& classname)
        { return node->GetPropVal("class", wxEmptyString) == classname; }






    wxString GetNodeContent(wxXmlNode *node);


    bool HasParam(const wxString& param);


    wxXmlNode *GetParamNode(const wxString& param);


    wxString GetParamValue(const wxString& param);



    void AddStyle(const wxString& name, int value);


    void AddWindowStyles();



    int GetStyle(const wxString& param = "style", int defaults = 0);





    wxString GetText(const wxString& param, bool translate = ((bool)1));


    int GetID();


    wxString GetName();


    bool GetBool(const wxString& param, bool defaultv = ((bool)0));


    long GetLong( const wxString& param, long defaultv = 0 );


    wxColour GetColour(const wxString& param);


    wxSize GetSize(const wxString& param = "size");


    wxPoint GetPosition(const wxString& param = "pos");


    wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0);


    wxBitmap GetBitmap(const wxString& param = "bitmap",
                       const wxArtClient& defaultArtClient = "wxART_OTHER" "_C",
                       wxSize size = wxDefaultSize);


    wxIcon GetIcon(const wxString& param = "icon",
                   const wxArtClient& defaultArtClient = "wxART_OTHER" "_C",
                   wxSize size = wxDefaultSize);


    wxFont GetFont(const wxString& param = "font");


    void SetupWindow(wxWindow *wnd);


    void CreateChildren(wxObject *parent, bool this_hnd_only = ((bool)0));


    void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = __null);


    wxObject *CreateResFromNode(wxXmlNode *node,
                                wxObject *parent, wxObject *instance = __null)
        { return m_resource->CreateResFromNode(node, parent, instance); }



    wxFileSystem& GetCurFileSystem() { return m_resource->GetCurFileSystem(); }

};
# 451 "../../wx/xrc/xmlres.h"
void wxXmlInitResourceModule();







class wxXmlSubclassFactory
{
public:

    virtual wxObject *Create(const wxString& className) = 0;
    virtual ~wxXmlSubclassFactory() {}
};
# 19 "../../wx/xrc/xh_bmpbt.h" 2


class wxBitmapButtonXmlHandler : public wxXmlResourceHandler
{
public:
    wxBitmapButtonXmlHandler();
    virtual wxObject *DoCreateResource();
    virtual bool CanHandle(wxXmlNode *node);
};
# 23 "xh_bmpbt.cpp" 2
# 1 "/usr/include/wx/bmpbuttn.h" 1 3 4
# 18 "/usr/include/wx/bmpbuttn.h" 3 4
# 1 "/usr/include/wx/button.h" 1 3 4
# 36 "/usr/include/wx/button.h" 3 4
# 1 "/usr/include/wx/control.h" 1 3 4
# 20 "/usr/include/wx/control.h" 3 4
#pragma interface "controlbase.h"




# 1 "/usr/include/wx/window.h" 1 3 4
# 16 "/usr/include/wx/window.h" 3 4
#pragma interface "windowbase.h"
# 30 "/usr/include/wx/window.h" 3 4
# 1 "/usr/include/wx/region.h" 1 3 4
# 9 "/usr/include/wx/region.h" 3 4
# 1 "/usr/include/wx/gtk/region.h" 1 3 4
# 14 "/usr/include/wx/gtk/region.h" 3 4
#pragma interface
# 25 "/usr/include/wx/gtk/region.h" 3 4
class wxRegion;





enum wxRegionContain
{
    wxOutRegion = 0,
    wxPartRegion = 1,
    wxInRegion = 2
};


enum wxRegionOp
{
   wxRGN_AND,
   wxRGN_COPY,
   wxRGN_DIFF,
   wxRGN_OR,
   wxRGN_XOR
};





class wxRegion : public wxGDIObject
{
public:
    wxRegion() { }

    wxRegion( wxCoord x, wxCoord y, wxCoord w, wxCoord h )
    {
        InitRect(x, y, w, h);
    }

    wxRegion( const wxPoint& topLeft, const wxPoint& bottomRight )
    {
        InitRect(topLeft.x, topLeft.y,
                 bottomRight.x - topLeft.x, bottomRight.y - topLeft.y);
    }

    wxRegion( const wxRect& rect )
    {
        InitRect(rect.x, rect.y, rect.width, rect.height);
    }

    wxRegion( size_t n, const wxPoint *points, int fillStyle = wxODDEVEN_RULE );

    wxRegion( const wxBitmap& bmp,
              const wxColour& transColour = wxNullColour,
              int tolerance = 0)
    {
        Union(bmp, transColour, tolerance);
    }

    ~wxRegion();

    wxRegion( const wxRegion& region )
        : wxGDIObject()
        { Ref(region); }
    wxRegion& operator = ( const wxRegion& region ) { Ref(region); return *this; }

    bool Ok() const { return m_refData != __null; }

    bool operator == ( const wxRegion& region );
    bool operator != ( const wxRegion& region ) { return !(*this == region); }

    void Clear();

    bool Offset( wxCoord x, wxCoord y );

    bool Union( wxCoord x, wxCoord y, wxCoord width, wxCoord height );
    bool Union( const wxRect& rect );
    bool Union( const wxRegion& region );

    bool Intersect( wxCoord x, wxCoord y, wxCoord width, wxCoord height );
    bool Intersect( const wxRect& rect );
    bool Intersect( const wxRegion& region );

    bool Subtract( wxCoord x, wxCoord y, wxCoord width, wxCoord height );
    bool Subtract( const wxRect& rect );
    bool Subtract( const wxRegion& region );

    bool Xor( wxCoord x, wxCoord y, wxCoord width, wxCoord height );
    bool Xor( const wxRect& rect );
    bool Xor( const wxRegion& region );

    void GetBox( wxCoord& x, wxCoord& y, wxCoord&w, wxCoord &h ) const;
    wxRect GetBox() const ;

    bool Empty() const;
    bool IsEmpty() const { return Empty(); }

    wxRegionContain Contains( wxCoord x, wxCoord y ) const;
    wxRegionContain Contains( wxCoord x, wxCoord y, wxCoord w, wxCoord h ) const;
    wxRegionContain Contains(const wxPoint& pt) const;
    wxRegionContain Contains(const wxRect& rect) const;



    wxBitmap ConvertToBitmap() const;





    bool Union(const wxBitmap& bmp,
               const wxColour& transColour = wxNullColour,
               int tolerance = 0);


public:


    wxRegion( GdkRegion *region );

    GdkRegion *GetRegion() const;

protected:

    virtual wxObjectRefData *CreateRefData() const;
    virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;


    void InitRect(wxCoord x, wxCoord y, wxCoord w, wxCoord h);

private:
    public: static wxClassInfo sm_classwxRegion; virtual wxClassInfo *GetClassInfo() const { return &wxRegion::sm_classwxRegion; };
};





class wxRegionIterator: public wxObject
{
public:
    wxRegionIterator();
    wxRegionIterator(const wxRegion& region);

    void Reset() { m_current = 0u; }
    void Reset(const wxRegion& region);

    bool HaveRects() const;
    operator bool () const { return HaveRects(); }

    wxRegionIterator& operator ++ ();
    wxRegionIterator operator ++ (int);

    wxCoord GetX() const;
    wxCoord GetY() const;
    wxCoord GetW() const;
    wxCoord GetWidth() const { return GetW(); }
    wxCoord GetH() const;
    wxCoord GetHeight() const { return GetH(); }
    wxRect GetRect() const;

private:
    size_t m_current;
    wxRegion m_region;

private:
    public: static wxClassInfo sm_classwxRegionIterator; virtual wxClassInfo *GetClassInfo() const { return &wxRegionIterator::sm_classwxRegionIterator; };
};
# 10 "/usr/include/wx/region.h" 2 3 4
# 31 "/usr/include/wx/window.h" 2 3 4


# 1 "/usr/include/wx/validate.h" 1 3 4
# 16 "/usr/include/wx/validate.h" 3 4
#pragma interface "validate.h"
# 30 "/usr/include/wx/validate.h" 3 4
class wxWindow;
class wxWindowBase;
# 45 "/usr/include/wx/validate.h" 3 4
class wxValidator : public wxEvtHandler
{
public:
    wxValidator();
    virtual ~wxValidator();





    virtual wxObject *Clone() const
        { return (wxValidator *)__null; }
    bool Copy(const wxValidator& val)
        { m_validatorWindow = val.m_validatorWindow; return ((bool)1); }



    virtual bool Validate(wxWindow *) { return ((bool)0); };


    virtual bool TransferToWindow() { return ((bool)0); }


    virtual bool TransferFromWindow() { return ((bool)0); };


    wxWindow *GetWindow() const { return (wxWindow *)m_validatorWindow; }
    void SetWindow(wxWindowBase *win) { m_validatorWindow = win; }



    static bool IsSilent() { return ms_isSilent; }
    static void SetBellOnError(bool doIt = ((bool)1)) { ms_isSilent = doIt; }

protected:
    wxWindowBase *m_validatorWindow;

private:
    static bool ms_isSilent;

    public: static wxClassInfo sm_classwxValidator; virtual wxClassInfo *GetClassInfo() const { return &wxValidator::sm_classwxValidator; }
    private: wxValidator(const wxValidator&); wxValidator& operator=(const wxValidator&);
};

extern const wxValidator wxDefaultValidator;
# 34 "/usr/include/wx/window.h" 2 3 4


# 1 "/usr/include/wx/dcclient.h" 1 3 4
# 9 "/usr/include/wx/dcclient.h" 3 4
# 1 "/usr/include/wx/gtk/dcclient.h" 1 3 4
# 14 "/usr/include/wx/gtk/dcclient.h" 3 4
#pragma interface


# 1 "/usr/include/wx/dc.h" 1 3 4
# 16 "/usr/include/wx/dc.h" 3 4
#pragma interface "dcbase.h"
# 28 "/usr/include/wx/dc.h" 3 4
# 1 "/usr/include/wx/brush.h" 1 3 4
# 9 "/usr/include/wx/brush.h" 3 4
# 1 "/usr/include/wx/gtk/brush.h" 1 3 4
# 15 "/usr/include/wx/gtk/brush.h" 3 4
#pragma interface
# 28 "/usr/include/wx/gtk/brush.h" 3 4
class wxBrush;





class wxBrush: public wxGDIObject
{
public:
    wxBrush() { }

    wxBrush( const wxColour &colour, int style );
    wxBrush( const wxBitmap &stippleBitmap );
    ~wxBrush();

    wxBrush( const wxBrush &brush )
        : wxGDIObject()
        { Ref(brush); }
    wxBrush& operator = ( const wxBrush& brush ) { Ref(brush); return *this; }

    bool Ok() const { return m_refData != __null; }

    bool operator == ( const wxBrush& brush ) const;
    bool operator != (const wxBrush& brush) const { return !(*this == brush); }

    int GetStyle() const;
    wxColour &GetColour() const;
    wxBitmap *GetStipple() const;

    void SetColour( const wxColour& col );
    void SetColour( unsigned char r, unsigned char g, unsigned char b );
    void SetStyle( int style );
    void SetStipple( const wxBitmap& stipple );

private:

    virtual wxObjectRefData *CreateRefData() const;
    virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;

    public: static wxClassInfo sm_classwxBrush; virtual wxClassInfo *GetClassInfo() const { return &wxBrush::sm_classwxBrush; }
};
# 10 "/usr/include/wx/brush.h" 2 3 4
# 29 "/usr/include/wx/dc.h" 2 3 4
# 1 "/usr/include/wx/pen.h" 1 3 4
# 9 "/usr/include/wx/pen.h" 3 4
# 1 "/usr/include/wx/gtk/pen.h" 1 3 4
# 15 "/usr/include/wx/gtk/pen.h" 3 4
#pragma interface
# 28 "/usr/include/wx/gtk/pen.h" 3 4
class wxPen;


typedef gint8 wxGTKDash;
# 40 "/usr/include/wx/gtk/pen.h" 3 4
class wxPen: public wxGDIObject
{
public:
    wxPen() { }

    wxPen( const wxColour &colour, int width, int style );
    ~wxPen();

    wxPen( const wxPen& pen )
        : wxGDIObject()
        { Ref(pen); }
    wxPen& operator = ( const wxPen& pen ) { Ref(pen); return *this; }

    bool Ok() const { return m_refData != __null; }

    bool operator == ( const wxPen& pen ) const;
    bool operator != (const wxPen& pen) const { return !(*this == pen); }

    void SetColour( const wxColour &colour );
    void SetColour( int red, int green, int blue );
    void SetCap( int capStyle );
    void SetJoin( int joinStyle );
    void SetStyle( int style );
    void SetWidth( int width );
    void SetDashes( int number_of_dashes, const wxDash *dash );

    wxColour &GetColour() const;
    int GetCap() const;
    int GetJoin() const;
    int GetStyle() const;
    int GetWidth() const;
    int GetDashes(wxDash **ptr) const;
    int GetDashCount() const;
    wxDash* GetDash() const;

private:

    virtual wxObjectRefData *CreateRefData() const;
    virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;

    public: static wxClassInfo sm_classwxPen; virtual wxClassInfo *GetClassInfo() const { return &wxPen::sm_classwxPen; }
};
# 10 "/usr/include/wx/pen.h" 2 3 4
# 30 "/usr/include/wx/dc.h" 2 3 4



class wxDCBase;

class wxDrawObject
{
public:

    wxDrawObject()
        : m_isBBoxValid(((bool)0))
        , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
    { }

    virtual ~wxDrawObject() { }

    virtual void Draw(wxDCBase&) const { }

    virtual void CalcBoundingBox(wxCoord x, wxCoord y)
    {
      if ( m_isBBoxValid )
      {
         if ( x < m_minX ) m_minX = x;
         if ( y < m_minY ) m_minY = y;
         if ( x > m_maxX ) m_maxX = x;
         if ( y > m_maxY ) m_maxY = y;
      }
      else
      {
         m_isBBoxValid = ((bool)1);

         m_minX = x;
         m_minY = y;
         m_maxX = x;
         m_maxY = y;
      }
    }

    void ResetBoundingBox()
    {
        m_isBBoxValid = ((bool)0);

        m_minX = m_maxX = m_minY = m_maxY = 0;
    }



    wxCoord MinX() const { return m_minX; }
    wxCoord MaxX() const { return m_maxX; }
    wxCoord MinY() const { return m_minY; }
    wxCoord MaxY() const { return m_maxY; }


    virtual int GetType()=0;

protected:

    bool m_isBBoxValid:1;

    wxCoord m_minX, m_minY, m_maxX, m_maxY;
};





extern int wxPageNumber;





class wxDCBase : public wxObject
{
public:
    wxDCBase()
        : m_colour(wxColourDisplay())
        , m_ok(((bool)1))
        , m_clipping(((bool)0))
        , m_isInteractive(0)
        , m_isBBoxValid(((bool)0))
        , m_logicalOriginX(0), m_logicalOriginY(0)
        , m_deviceOriginX(0), m_deviceOriginY(0)
        , m_logicalScaleX(1.0), m_logicalScaleY(1.0)
        , m_userScaleX(1.0), m_userScaleY(1.0)
        , m_scaleX(1.0), m_scaleY(1.0)
        , m_signX(1), m_signY(1)
        , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
        , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0)
        , m_logicalFunction(wxCOPY)
        , m_backgroundMode(wxTRANSPARENT)
        , m_mappingMode(wxMM_TEXT)
        , m_pen()
        , m_brush()
        , m_backgroundBrush(*wxTRANSPARENT_BRUSH)
        , m_textForegroundColour(*wxBLACK)
        , m_textBackgroundColour(*wxWHITE)
        , m_font()

        , m_palette()
        , m_hasCustomPalette(((bool)0))

    {
        ResetBoundingBox();
    }

    ~wxDCBase() { }

    virtual void BeginDrawing() { }
    virtual void EndDrawing() { }




    virtual void DrawObject(wxDrawObject* drawobject)
    {
        drawobject->Draw(*this);
        CalcBoundingBox(drawobject->MinX(),drawobject->MinY());
        CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
    }

    bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
                   int style = wxFLOOD_SURFACE)
        { return DoFloodFill(x, y, col, style); }
    bool FloodFill(const wxPoint& pt, const wxColour& col,
                   int style = wxFLOOD_SURFACE)
        { return DoFloodFill(pt.x, pt.y, col, style); }

    bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const
        { return DoGetPixel(x, y, col); }
    bool GetPixel(const wxPoint& pt, wxColour *col) const
        { return DoGetPixel(pt.x, pt.y, col); }

    void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
        { DoDrawLine(x1, y1, x2, y2); }
    void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
        { DoDrawLine(pt1.x, pt1.y, pt2.x, pt2.y); }

    void CrossHair(wxCoord x, wxCoord y)
        { DoCrossHair(x, y); }
    void CrossHair(const wxPoint& pt)
        { DoCrossHair(pt.x, pt.y); }

    void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
                 wxCoord xc, wxCoord yc)
        { DoDrawArc(x1, y1, x2, y2, xc, yc); }
    void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
        { DoDrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); }

    void DrawCheckMark(wxCoord x, wxCoord y,
                       wxCoord width, wxCoord height)
        { DoDrawCheckMark(x, y, width, height); }
    void DrawCheckMark(const wxRect& rect)
        { DoDrawCheckMark(rect.x, rect.y, rect.width, rect.height); }

    void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
                         double sa, double ea)
        { DoDrawEllipticArc(x, y, w, h, sa, ea); }
    void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
                         double sa, double ea)
        { DoDrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); }

    void DrawPoint(wxCoord x, wxCoord y)
        { DoDrawPoint(x, y); }
    void DrawPoint(const wxPoint& pt)
        { DoDrawPoint(pt.x, pt.y); }

    void DrawLines(int n, wxPoint points[],
                   wxCoord xoffset = 0, wxCoord yoffset = 0)
        { DoDrawLines(n, points, xoffset, yoffset); }
    void DrawLines(const wxList *list,
                   wxCoord xoffset = 0, wxCoord yoffset = 0);

    void DrawPolygon(int n, wxPoint points[],
                     wxCoord xoffset = 0, wxCoord yoffset = 0,
                     int fillStyle = wxODDEVEN_RULE)
        { DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }

    void DrawPolygon(const wxList *list,
                     wxCoord xoffset = 0, wxCoord yoffset = 0,
                     int fillStyle = wxODDEVEN_RULE);

    void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
        { DoDrawRectangle(x, y, width, height); }
    void DrawRectangle(const wxPoint& pt, const wxSize& sz)
        { DoDrawRectangle(pt.x, pt.y, sz.x, sz.y); }
    void DrawRectangle(const wxRect& rect)
        { DoDrawRectangle(rect.x, rect.y, rect.width, rect.height); }

    void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
                              double radius)
        { DoDrawRoundedRectangle(x, y, width, height, radius); }
    void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
                             double radius)
        { DoDrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); }
    void DrawRoundedRectangle(const wxRect& r, double radius)
        { DoDrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); }

    void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
        { DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
    void DrawCircle(const wxPoint& pt, wxCoord radius)
        { DrawCircle(pt.x, pt.y, radius); }

    void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
        { DoDrawEllipse(x, y, width, height); }
    void DrawEllipse(const wxPoint& pt, const wxSize& sz)
        { DoDrawEllipse(pt.x, pt.y, sz.x, sz.y); }
    void DrawEllipse(const wxRect& rect)
        { DoDrawEllipse(rect.x, rect.y, rect.width, rect.height); }

    void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
        { DoDrawIcon(icon, x, y); }
    void DrawIcon(const wxIcon& icon, const wxPoint& pt)
        { DoDrawIcon(icon, pt.x, pt.y); }

    void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
                    bool useMask = ((bool)0))
        { DoDrawBitmap(bmp, x, y, useMask); }
    void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
                    bool useMask = ((bool)0))
        { DoDrawBitmap(bmp, pt.x, pt.y, useMask); }

    void DrawText(const wxString& text, wxCoord x, wxCoord y)
        { DoDrawText(text, x, y); }
    void DrawText(const wxString& text, const wxPoint& pt)
        { DoDrawText(text, pt.x, pt.y); }

    void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
        { DoDrawRotatedText(text, x, y, angle); }
    void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)
        { DoDrawRotatedText(text, pt.x, pt.y, angle); }





    virtual void DrawLabel(const wxString& text,
                           const wxBitmap& image,
                           const wxRect& rect,
                           int alignment = wxALIGN_LEFT | wxALIGN_TOP,
                           int indexAccel = -1,
                           wxRect *rectBounding = __null);

    void DrawLabel(const wxString& text, const wxRect& rect,
                   int alignment = wxALIGN_LEFT | wxALIGN_TOP,
                   int indexAccel = -1)
        { DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }

    bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
              wxDC *source, wxCoord xsrc, wxCoord ysrc,
              int rop = wxCOPY, bool useMask = ((bool)0), wxCoord xsrcMask = -1, wxCoord ysrcMask = -1)
    {
        return DoBlit(xdest, ydest, width, height,
                      source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
    }
    bool Blit(const wxPoint& destPt, const wxSize& sz,
              wxDC *source, const wxPoint& srcPt,
              int rop = wxCOPY, bool useMask = ((bool)0), const wxPoint& srcPtMask = wxPoint(-1, -1))
    {
        return DoBlit(destPt.x, destPt.y, sz.x, sz.y,
                      source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y);
    }



    void DrawSpline(wxCoord x1, wxCoord y1,
                    wxCoord x2, wxCoord y2,
                    wxCoord x3, wxCoord y3);
    void DrawSpline(int n, wxPoint points[]);

    void DrawSpline(wxList *points) { DoDrawSpline(points); }





    virtual void Clear() = 0;

    virtual bool StartDoc(const wxString& ) { return ((bool)1); }
    virtual void EndDoc() { }

    virtual void StartPage() { }
    virtual void EndPage() { }




    virtual void SetFont(const wxFont& font) = 0;
    virtual void SetPen(const wxPen& pen) = 0;
    virtual void SetBrush(const wxBrush& brush) = 0;
    virtual void SetBackground(const wxBrush& brush) = 0;
    virtual void SetBackgroundMode(int mode) = 0;

    virtual void SetPalette(const wxPalette& palette) = 0;





    void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
        { DoSetClippingRegion(x, y, width, height); }
    void SetClippingRegion(const wxPoint& pt, const wxSize& sz)
        { DoSetClippingRegion(pt.x, pt.y, sz.x, sz.y); }
    void SetClippingRegion(const wxRect& rect)
        { DoSetClippingRegion(rect.x, rect.y, rect.width, rect.height); }
    void SetClippingRegion(const wxRegion& region)
        { DoSetClippingRegionAsRegion(region); }

    virtual void DestroyClippingRegion() = 0;

    void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
        { DoGetClippingBox(x, y, w, h); }
    void GetClippingBox(wxRect& rect) const
        {

          wxCoord x, y, w, h;
          DoGetClippingBox(&x, &y, &w, &h);
          rect.x = x; rect.y = y; rect.width = w; rect.height = h;
        }




    virtual wxCoord GetCharHeight() const = 0;
    virtual wxCoord GetCharWidth() const = 0;


    void GetTextExtent(const wxString& string,
                       wxCoord *x, wxCoord *y,
                       wxCoord *descent = __null,
                       wxCoord *externalLeading = __null,
                       wxFont *theFont = __null) const
        { DoGetTextExtent(string, x, y, descent, externalLeading, theFont); }


    virtual void GetMultiLineTextExtent(const wxString& text,
                                        wxCoord *width,
                                        wxCoord *height,
                                        wxCoord *heightLine = __null,
                                        wxFont *font = __null);





    void GetSize(int *width, int *height) const
        { DoGetSize(width, height); }
    wxSize GetSize() const
    {
        int w, h;
        DoGetSize(&w, &h);

        return wxSize(w, h);
    }


    void GetSizeMM(int* width, int* height) const
        { DoGetSizeMM(width, height); }
    wxSize GetSizeMM() const
    {
        int w, h;
        DoGetSizeMM(&w, &h);

        return wxSize(w, h);
    }






    wxCoord DeviceToLogicalX(wxCoord x) const;
    wxCoord DeviceToLogicalY(wxCoord y) const;
    wxCoord DeviceToLogicalXRel(wxCoord x) const;
    wxCoord DeviceToLogicalYRel(wxCoord y) const;
    wxCoord LogicalToDeviceX(wxCoord x) const;
    wxCoord LogicalToDeviceY(wxCoord y) const;
    wxCoord LogicalToDeviceXRel(wxCoord x) const;
    wxCoord LogicalToDeviceYRel(wxCoord y) const;




    virtual bool CanDrawBitmap() const = 0;
    virtual bool CanGetTextExtent() const = 0;


    virtual int GetDepth() const = 0;


    virtual wxSize GetPPI() const = 0;

    virtual bool Ok() const { return m_ok; }





    int GetBackgroundMode() const { return m_backgroundMode; }
    const wxBrush& GetBackground() const { return m_backgroundBrush; }
    const wxBrush& GetBrush() const { return m_brush; }
    const wxFont& GetFont() const { return m_font; }
    const wxPen& GetPen() const { return m_pen; }
    const wxColour& GetTextBackground() const { return m_textBackgroundColour; }
    const wxColour& GetTextForeground() const { return m_textForegroundColour; }


    wxBrush& GetBackground() { return m_backgroundBrush; }
    wxBrush& GetBrush() { return m_brush; }
    wxFont& GetFont() { return m_font; }
    wxPen& GetPen() { return m_pen; }
    wxColour& GetTextBackground() { return m_textBackgroundColour; }
    wxColour& GetTextForeground() { return m_textForegroundColour; }

    virtual void SetTextForeground(const wxColour& colour)
        { m_textForegroundColour = colour; }
    virtual void SetTextBackground(const wxColour& colour)
        { m_textBackgroundColour = colour; }

    int GetMapMode() const { return m_mappingMode; }
    virtual void SetMapMode(int mode) = 0;

    virtual void GetUserScale(double *x, double *y) const
    {
        if ( x ) *x = m_userScaleX;
        if ( y ) *y = m_userScaleY;
    }
    virtual void SetUserScale(double x, double y) = 0;

    virtual void GetLogicalScale(double *x, double *y)
    {
        if ( x ) *x = m_logicalScaleX;
        if ( y ) *y = m_logicalScaleY;
    }
    virtual void SetLogicalScale(double x, double y)
    {
        m_logicalScaleX = x;
        m_logicalScaleY = y;
    }

    void GetLogicalOrigin(wxCoord *x, wxCoord *y) const
        { DoGetLogicalOrigin(x, y); }
    wxPoint GetLogicalOrigin() const
        { wxCoord x, y; DoGetLogicalOrigin(&x, &y); return wxPoint(x, y); }
    virtual void SetLogicalOrigin(wxCoord x, wxCoord y) = 0;

    void GetDeviceOrigin(wxCoord *x, wxCoord *y) const
        { DoGetDeviceOrigin(x, y); }
    wxPoint GetDeviceOrigin() const
        { wxCoord x, y; DoGetDeviceOrigin(&x, &y); return wxPoint(x, y); }
    virtual void SetDeviceOrigin(wxCoord x, wxCoord y) = 0;

    virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp) = 0;

    int GetLogicalFunction() const { return m_logicalFunction; }
    virtual void SetLogicalFunction(int function) = 0;





    virtual void SetOptimization(bool ) { }
    virtual bool GetOptimization() { return ((bool)0); }
# 507 "/usr/include/wx/dc.h" 3 4
    virtual void CalcBoundingBox(wxCoord x, wxCoord y)
    {
      if ( m_isBBoxValid )
      {
         if ( x < m_minX ) m_minX = x;
         if ( y < m_minY ) m_minY = y;
         if ( x > m_maxX ) m_maxX = x;
         if ( y > m_maxY ) m_maxY = y;
      }
      else
      {
         m_isBBoxValid = ((bool)1);

         m_minX = x;
         m_minY = y;
         m_maxX = x;
         m_maxY = y;
      }
    }

    void ResetBoundingBox()
    {
        m_isBBoxValid = ((bool)0);

        m_minX = m_maxX = m_minY = m_maxY = 0;
    }


    wxCoord MinX() const { return m_minX; }
    wxCoord MaxX() const { return m_maxX; }
    wxCoord MinY() const { return m_minY; }
    wxCoord MaxY() const { return m_maxY; }






    void GetTextExtent(const wxString& string,
                       long *x, long *y,
                       long *descent = __null,
                       long *externalLeading = __null,
                       wxFont *theFont = __null) const
    {
        wxCoord x2, y2, descent2, externalLeading2;
        DoGetTextExtent(string, &x2, &y2,
                        &descent2, &externalLeading2,
                        theFont);
        if ( x )
            *x = x2;
        if ( y )
            *y = y2;
        if ( descent )
            *descent = descent2;
        if ( externalLeading )
            *externalLeading = externalLeading2;
    }

    void GetLogicalOrigin(long *x, long *y) const
    {
        wxCoord x2, y2;
        DoGetLogicalOrigin(&x2, &y2);
        if ( x )
            *x = x2;
        if ( y )
            *y = y2;
    }

    void GetDeviceOrigin(long *x, long *y) const
    {
        wxCoord x2, y2;
        DoGetDeviceOrigin(&x2, &y2);
        if ( x )
            *x = x2;
        if ( y )
            *y = y2;
    }
    void GetClippingBox(long *x, long *y, long *w, long *h) const
    {
        wxCoord xx,yy,ww,hh;
        DoGetClippingBox(&xx, &yy, &ww, &hh);
        if (x) *x = xx;
        if (y) *y = yy;
        if (w) *w = ww;
        if (h) *h = hh;
    }
# 609 "/usr/include/wx/dc.h" 3 4
protected:

    virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
                             int style = wxFLOOD_SURFACE) = 0;

    virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const = 0;

    virtual void DoDrawPoint(wxCoord x, wxCoord y) = 0;
    virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) = 0;

    virtual void DoDrawArc(wxCoord x1, wxCoord y1,
                           wxCoord x2, wxCoord y2,
                           wxCoord xc, wxCoord yc) = 0;
    virtual void DoDrawCheckMark(wxCoord x, wxCoord y,
                                 wxCoord width, wxCoord height);
    virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
                                   double sa, double ea) = 0;

    virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) = 0;
    virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
                                        wxCoord width, wxCoord height,
                                        double radius) = 0;
    virtual void DoDrawEllipse(wxCoord x, wxCoord y,
                               wxCoord width, wxCoord height) = 0;

    virtual void DoCrossHair(wxCoord x, wxCoord y) = 0;

    virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) = 0;
    virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
                              bool useMask = ((bool)0)) = 0;

    virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y) = 0;
    virtual void DoDrawRotatedText(const wxString& text,
                                   wxCoord x, wxCoord y, double angle) = 0;

    virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
                        wxCoord width, wxCoord height,
                        wxDC *source, wxCoord xsrc, wxCoord ysrc,
                        int rop = wxCOPY, bool useMask = ((bool)0), wxCoord xsrcMask = -1, wxCoord ysrcMask = -1) = 0;

    virtual void DoGetSize(int *width, int *height) const = 0;
    virtual void DoGetSizeMM(int* width, int* height) const = 0;

    virtual void DoDrawLines(int n, wxPoint points[],
                             wxCoord xoffset, wxCoord yoffset) = 0;
    virtual void DoDrawPolygon(int n, wxPoint points[],
                               wxCoord xoffset, wxCoord yoffset,
                               int fillStyle = wxODDEVEN_RULE) = 0;

    virtual void DoSetClippingRegionAsRegion(const wxRegion& region) = 0;
    virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
                                     wxCoord width, wxCoord height) = 0;


    virtual void DoGetClippingRegion(wxCoord *x, wxCoord *y,
                                     wxCoord *w, wxCoord *h)
        { DoGetClippingBox(x, y, w, h); }
    virtual void DoGetClippingBox(wxCoord *x, wxCoord *y,
                                  wxCoord *w, wxCoord *h) const
    {
        if ( m_clipping )
        {
            if ( x ) *x = m_clipX1;
            if ( y ) *y = m_clipY1;
            if ( w ) *w = m_clipX2 - m_clipX1;
            if ( h ) *h = m_clipY2 - m_clipY1;
        }
        else
        {
            *x = *y = *w = *h = 0;
        }
    }

    virtual void DoGetLogicalOrigin(wxCoord *x, wxCoord *y) const
    {
        if ( x ) *x = m_logicalOriginX;
        if ( y ) *y = m_logicalOriginY;
    }

    virtual void DoGetDeviceOrigin(wxCoord *x, wxCoord *y) const
    {
        if ( x ) *x = m_deviceOriginX;
        if ( y ) *y = m_deviceOriginY;
    }

    virtual void DoGetTextExtent(const wxString& string,
                                 wxCoord *x, wxCoord *y,
                                 wxCoord *descent = __null,
                                 wxCoord *externalLeading = __null,
                                 wxFont *theFont = __null) const = 0;


    virtual void DoDrawSpline(wxList *points);


protected:

    bool m_colour:1;
    bool m_ok:1;
    bool m_clipping:1;
    bool m_isInteractive:1;
    bool m_isBBoxValid:1;
# 719 "/usr/include/wx/dc.h" 3 4
    wxCoord m_logicalOriginX, m_logicalOriginY;
    wxCoord m_deviceOriginX, m_deviceOriginY;

    double m_logicalScaleX, m_logicalScaleY;
    double m_userScaleX, m_userScaleY;
    double m_scaleX, m_scaleY;


    int m_signX, m_signY;


    wxCoord m_minX, m_minY, m_maxX, m_maxY;
    wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2;

    int m_logicalFunction;
    int m_backgroundMode;
    int m_mappingMode;


    wxPen m_pen;
    wxBrush m_brush;
    wxBrush m_backgroundBrush;
    wxColour m_textForegroundColour;
    wxColour m_textBackgroundColour;
    wxFont m_font;


    wxPalette m_palette;
    bool m_hasCustomPalette;


private:
    private: wxDCBase(const wxDCBase&); wxDCBase& operator=(const wxDCBase&);
    public: static wxClassInfo sm_classwxDCBase; virtual wxClassInfo *GetClassInfo() const { return &wxDCBase::sm_classwxDCBase; }
};
# 764 "/usr/include/wx/dc.h" 3 4
# 1 "/usr/include/wx/gtk/dc.h" 1 3 4
# 15 "/usr/include/wx/gtk/dc.h" 3 4
#pragma interface






class wxDC;
# 41 "/usr/include/wx/gtk/dc.h" 3 4
class wxDC : public wxDCBase
{
public:
    wxDC();
    ~wxDC() { }

    void SetColourMap( const wxPalette& palette ) { SetPalette(palette); };


    virtual void DestroyClippingRegion();


    virtual wxSize GetPPI() const;

    virtual bool StartDoc( const wxString& ) { return ((bool)1); }
    virtual void EndDoc() { }
    virtual void StartPage() { }
    virtual void EndPage() { }

    virtual void SetMapMode( int mode );
    virtual void SetUserScale( double x, double y );
    virtual void SetLogicalScale( double x, double y );
    virtual void SetLogicalOrigin( wxCoord x, wxCoord y );
    virtual void SetDeviceOrigin( wxCoord x, wxCoord y );

    virtual void SetAxisOrientation( bool xLeftRight, bool yBottomUp );




    virtual void ComputeScaleAndOrigin();

    wxCoord XDEV2LOG(wxCoord x) const
    {
        wxCoord new_x = x - m_deviceOriginX;
        if (new_x > 0)
            return (wxCoord)((double)(new_x) / m_scaleX + 0.5) * m_signX + m_logicalOriginX;
        else
            return (wxCoord)((double)(new_x) / m_scaleX - 0.5) * m_signX + m_logicalOriginX;
    }
    wxCoord XDEV2LOGREL(wxCoord x) const
    {
        if (x > 0)
            return (wxCoord)((double)(x) / m_scaleX + 0.5);
        else
            return (wxCoord)((double)(x) / m_scaleX - 0.5);
    }
    wxCoord YDEV2LOG(wxCoord y) const
    {
        wxCoord new_y = y - m_deviceOriginY;
        if (new_y > 0)
            return (wxCoord)((double)(new_y) / m_scaleY + 0.5) * m_signY + m_logicalOriginY;
        else
            return (wxCoord)((double)(new_y) / m_scaleY - 0.5) * m_signY + m_logicalOriginY;
    }
    wxCoord YDEV2LOGREL(wxCoord y) const
    {
        if (y > 0)
            return (wxCoord)((double)(y) / m_scaleY + 0.5);
        else
            return (wxCoord)((double)(y) / m_scaleY - 0.5);
    }
    wxCoord XLOG2DEV(wxCoord x) const
    {
        wxCoord new_x = x - m_logicalOriginX;
        if (new_x > 0)
            return (wxCoord)((double)(new_x) * m_scaleX + 0.5) * m_signX + m_deviceOriginX;
        else
            return (wxCoord)((double)(new_x) * m_scaleX - 0.5) * m_signX + m_deviceOriginX;
    }
    wxCoord XLOG2DEVREL(wxCoord x) const
    {
        if (x > 0)
            return (wxCoord)((double)(x) * m_scaleX + 0.5);
        else
            return (wxCoord)((double)(x) * m_scaleX - 0.5);
    }
    wxCoord YLOG2DEV(wxCoord y) const
    {
        wxCoord new_y = y - m_logicalOriginY;
        if (new_y > 0)
            return (wxCoord)((double)(new_y) * m_scaleY + 0.5) * m_signY + m_deviceOriginY;
        else
            return (wxCoord)((double)(new_y) * m_scaleY - 0.5) * m_signY + m_deviceOriginY;
    }
    wxCoord YLOG2DEVREL(wxCoord y) const
    {
        if (y > 0)
            return (wxCoord)((double)(y) * m_scaleY + 0.5);
        else
            return (wxCoord)((double)(y) * m_scaleY - 0.5);
    }

protected:

    virtual void DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
    virtual void DoGetSizeMM(int* width, int* height) const;

public:




    double m_mm_to_pix_x,
                 m_mm_to_pix_y;

    bool m_needComputeScaleX,
                 m_needComputeScaleY;


private:
    public: static wxClassInfo sm_classwxDC; virtual wxClassInfo *GetClassInfo() const { return &wxDC::sm_classwxDC; }
};
# 765 "/usr/include/wx/dc.h" 2 3 4
# 782 "/usr/include/wx/dc.h" 3 4
class wxDCTextColourChanger
{
public:
    wxDCTextColourChanger(wxDC& dc) : m_dc(dc), m_colFgOld() { }

    ~wxDCTextColourChanger()
    {
        if ( m_colFgOld.Ok() )
            m_dc.SetTextForeground(m_colFgOld);
    }

    void Set(const wxColour& col)
    {
        if ( !m_colFgOld.Ok() )
            m_colFgOld = m_dc.GetTextForeground();
        m_dc.SetTextForeground(col);
    }

private:
    wxDC& m_dc;

    wxColour m_colFgOld;
};






class wxDCClipper
{
public:
    wxDCClipper(wxDC& dc, const wxRect& r) : m_dc(dc)
        { dc.SetClippingRegion(r.x, r.y, r.width, r.height); }
    wxDCClipper(wxDC& dc, wxCoord x, wxCoord y, wxCoord w, wxCoord h) : m_dc(dc)
        { dc.SetClippingRegion(x, y, w, h); }

    ~wxDCClipper() { m_dc.DestroyClippingRegion(); }

private:
    wxDC& m_dc;
};
# 18 "/usr/include/wx/gtk/dcclient.h" 2 3 4
# 1 "/usr/include/wx/window.h" 1 3 4
# 19 "/usr/include/wx/gtk/dcclient.h" 2 3 4





class wxWindowDC;
class wxPaintDC;
class wxClientDC;





class wxWindowDC : public wxDC
{
public:
    wxWindowDC();
    wxWindowDC( wxWindow *win );

    virtual ~wxWindowDC();

    virtual bool CanDrawBitmap() const { return ((bool)1); }
    virtual bool CanGetTextExtent() const { return ((bool)1); }

protected:
    virtual void DoGetSize(int *width, int *height) const;
    virtual bool DoFloodFill( wxCoord x, wxCoord y, const wxColour& col, int style=wxFLOOD_SURFACE );
    virtual bool DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const;

    virtual void DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 );
    virtual void DoCrossHair( wxCoord x, wxCoord y );
    virtual void DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
                            wxCoord xc, wxCoord yc );
    virtual void DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height,
                                    double sa, double ea );
    virtual void DoDrawPoint( wxCoord x, wxCoord y );

    virtual void DoDrawLines(int n, wxPoint points[],
                             wxCoord xoffset, wxCoord yoffset);
    virtual void DoDrawPolygon(int n, wxPoint points[],
                               wxCoord xoffset, wxCoord yoffset,
                               int fillStyle = wxODDEVEN_RULE);

    virtual void DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height );
    virtual void DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius = 20.0 );
    virtual void DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height );

    virtual void DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y );
    virtual void DoDrawBitmap( const wxBitmap &bitmap, wxCoord x, wxCoord y,
                               bool useMask = ((bool)0) );

    virtual bool DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
                         wxDC *source, wxCoord xsrc, wxCoord ysrc,
                         int logical_func = wxCOPY, bool useMask = ((bool)0), wxCoord xsrcMask = -1, wxCoord ysrcMask = -1 );

    virtual void DoDrawText( const wxString &text, wxCoord x, wxCoord y );
    virtual void DoDrawRotatedText(const wxString& text, wxCoord x, wxCoord y,
                                   double angle);
    virtual void DoGetTextExtent( const wxString &string,
                                wxCoord *width, wxCoord *height,
                                wxCoord *descent = (wxCoord *) __null,
                                wxCoord *externalLeading = (wxCoord *) __null,
                                wxFont *theFont = (wxFont *) __null) const;

public:
    virtual wxCoord GetCharWidth() const;
    virtual wxCoord GetCharHeight() const;

    virtual void Clear();

    virtual void SetFont( const wxFont &font );
    virtual void SetPen( const wxPen &pen );
    virtual void SetBrush( const wxBrush &brush );
    virtual void SetBackground( const wxBrush &brush );
    virtual void SetLogicalFunction( int function );
    virtual void SetTextForeground( const wxColour &col );
    virtual void SetTextBackground( const wxColour &col );
    virtual void SetBackgroundMode( int mode );
    virtual void SetPalette( const wxPalette& palette );

    virtual void DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height );
    virtual void DestroyClippingRegion();
    virtual void DoSetClippingRegionAsRegion( const wxRegion &region );


    virtual wxSize GetPPI() const;
    virtual int GetDepth() const;




    GdkWindow *m_window;
    GdkGC *m_penGC;
    GdkGC *m_brushGC;
    GdkGC *m_textGC;
    GdkGC *m_bgGC;
    GdkColormap *m_cmap;
    bool m_isMemDC;
    bool m_isScreenDC;
    wxWindow *m_owner;
    wxRegion m_currentClippingRegion;
    wxRegion m_paintClippingRegion;



    PangoContext *m_context;
    PangoFontDescription *m_fontdesc;


    void SetUpDC();
    void Destroy();
    void ComputeScaleAndOrigin();

    GdkWindow *GetWindow() { return m_window; }

private:
    public: static wxClassInfo sm_classwxWindowDC; virtual wxClassInfo *GetClassInfo() const { return &wxWindowDC::sm_classwxWindowDC; }
};





class wxClientDC : public wxWindowDC
{
public:
    wxClientDC() { }
    wxClientDC( wxWindow *win );

protected:
    virtual void DoGetSize(int *width, int *height) const;

private:
    public: static wxClassInfo sm_classwxClientDC; virtual wxClassInfo *GetClassInfo() const { return &wxClientDC::sm_classwxClientDC; }
};





class wxPaintDC : public wxClientDC
{
public:
    wxPaintDC() { }
    wxPaintDC( wxWindow *win );

private:
    public: static wxClassInfo sm_classwxPaintDC; virtual wxClassInfo *GetClassInfo() const { return &wxPaintDC::sm_classwxPaintDC; }
};
# 10 "/usr/include/wx/dcclient.h" 2 3 4
# 37 "/usr/include/wx/window.h" 2 3 4




# 1 "/usr/include/wx/accel.h" 1 3 4
# 21 "/usr/include/wx/accel.h" 3 4
class wxAcceleratorTable;
class wxMenuItem;
class wxKeyEvent;






enum
{
    wxACCEL_NORMAL = 0x0000,
    wxACCEL_ALT = 0x0001,
    wxACCEL_CTRL = 0x0002,
    wxACCEL_SHIFT = 0x0004
};





class wxAcceleratorEntry
{
public:
    wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0,
                       wxMenuItem *item = __null)
        : m_flags(flags)
        , m_keyCode(keyCode)
        , m_command(cmd)
        , m_item(item)
        { }

    wxAcceleratorEntry(const wxAcceleratorEntry& entry)
        : m_flags(entry.m_flags)
        , m_keyCode(entry.m_keyCode)
        , m_command(entry.m_command)
        , m_item(entry.m_item)
        { }

    wxAcceleratorEntry& operator=(const wxAcceleratorEntry& entry)
    {
        Set(entry.m_flags, entry.m_keyCode, entry.m_command, entry.m_item);
        return *this;
    }

    void Set(int flags, int keyCode, int cmd, wxMenuItem *item = __null)
    {
        m_flags = flags;
        m_keyCode = keyCode;
        m_command = cmd;
        m_item = item;
    }

    void SetMenuItem(wxMenuItem *item) { m_item = item; }

    int GetFlags() const { return m_flags; }
    int GetKeyCode() const { return m_keyCode; }
    int GetCommand() const { return m_command; }

    wxMenuItem *GetMenuItem() const { return m_item; }

    bool operator==(const wxAcceleratorEntry& entry) const
    {
        return m_flags == entry.m_flags &&
               m_keyCode == entry.m_keyCode &&
               m_command == entry.m_command &&
               m_item == entry.m_item;
    }

    bool operator!=(const wxAcceleratorEntry& entry) const
        { return !(*this == entry); }






private:
    int m_flags;
    int m_keyCode;
    int m_command;


    wxMenuItem *m_item;


    friend class wxMenu;
};
# 122 "/usr/include/wx/accel.h" 3 4
# 1 "/usr/include/wx/gtk/accel.h" 1 3 4



# 1 "/usr/include/wx/generic/accel.h" 1 3 4
# 14 "/usr/include/wx/generic/accel.h" 3 4
#pragma interface "accel.h"


class wxKeyEvent;





class wxAcceleratorTable : public wxObject
{
public:
    wxAcceleratorTable();
    wxAcceleratorTable(int n, const wxAcceleratorEntry entries[]);
    virtual ~wxAcceleratorTable();

    wxAcceleratorTable(const wxAcceleratorTable& accel)
        : wxObject()
        { Ref(accel); }
    wxAcceleratorTable& operator=(const wxAcceleratorTable& accel)
      { if ( m_refData != accel.m_refData ) Ref(accel); return *this; }

    bool operator==(const wxAcceleratorTable& accel) const
        { return m_refData == accel.m_refData; }
    bool operator!=(const wxAcceleratorTable& accel) const
        { return !(*this == accel); }

    bool Ok() const;

    void Add(const wxAcceleratorEntry& entry);
    void Remove(const wxAcceleratorEntry& entry);




    wxMenuItem *GetMenuItem(const wxKeyEvent& event) const;
    int GetCommand(const wxKeyEvent& event) const;

    const wxAcceleratorEntry *GetEntry(const wxKeyEvent& event) const;

protected:

    virtual wxObjectRefData *CreateRefData() const;
    virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;

private:
    public: static wxClassInfo sm_classwxAcceleratorTable; virtual wxClassInfo *GetClassInfo() const { return &wxAcceleratorTable::sm_classwxAcceleratorTable; }
};
# 5 "/usr/include/wx/gtk/accel.h" 2 3 4
# 123 "/usr/include/wx/accel.h" 2 3 4
# 131 "/usr/include/wx/accel.h" 3 4
extern wxAcceleratorTable wxNullAcceleratorTable;
# 42 "/usr/include/wx/window.h" 2 3 4
# 56 "/usr/include/wx/window.h" 3 4
class wxCaret;
class wxControl;
class wxCursor;
class wxDC;
class wxDropTarget;
class wxItemResource;
class wxLayoutConstraints;
class wxResourceTable;
class wxSizer;
class wxToolTip;
class wxWindowBase;
class wxWindow;





typedef int (*wxSortFuncFor_wxWindowList)(const wxWindow **, const wxWindow **); class wxWindowListNode : public wxNodeBase { public: wxWindowListNode(wxListBase *list = (wxListBase *)__null, wxWindowListNode *previous = (wxWindowListNode *)__null, wxWindowListNode *next = (wxWindowListNode *)__null, wxWindow *data = (wxWindow *)__null, const wxListKey& key = wxDefaultListKey) : wxNodeBase(list, previous, next, data, key) { } wxWindowListNode *GetNext() const { return (wxWindowListNode *)wxNodeBase::GetNext(); } wxWindowListNode *GetPrevious() const { return (wxWindowListNode *)wxNodeBase::GetPrevious(); } wxWindow *GetData() const { return (wxWindow *)wxNodeBase::GetData(); } void SetData(wxWindow *data) { wxNodeBase::SetData(data); } virtual void DeleteData(); }; class wxWindowList : public wxListBase { public: typedef wxWindowListNode Node; wxWindowList(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType) { } wxWindowList(size_t count, wxWindow *elements[]) : wxListBase(count, (void **)elements) { } wxWindowList& operator=(const wxWindowList& list) { (void) wxListBase::operator=(list); return *this; } wxWindowListNode *GetFirst() const { return (wxWindowListNode *)wxListBase::GetFirst(); } wxWindowListNode *GetLast() const { return (wxWindowListNode *)wxListBase::GetLast(); } wxWindowListNode *Item(size_t index) const { return (wxWindowListNode *)wxListBase::Item(index); } wxWindow *operator[](size_t index) const { wxWindowListNode *node = Item(index); return node ? (wxWindow*)(node->GetData()) : (wxWindow*)__null; } wxWindowListNode *Append(wxWindowBase *object) { return (wxWindowListNode *)wxListBase::Append(object); } wxWindowListNode *Insert(wxWindowBase *object) { return (wxWindowListNode *)Insert((wxWindowListNode*)__null, object); } wxWindowListNode *Insert(size_t pos, wxWindowBase *object) { return (wxWindowListNode *)wxListBase::Insert(pos, object); } wxWindowListNode *Insert(wxWindowListNode *prev, wxWindowBase *object) { return (wxWindowListNode *)wxListBase::Insert(prev, object); } wxWindowListNode *Append(long key, void *object) { return (wxWindowListNode *)wxListBase::Append(key, object); } wxWindowListNode *Append(const wxChar *key, void *object) { return (wxWindowListNode *)wxListBase::Append(key, object); } wxWindowListNode *DetachNode(wxWindowListNode *node) { return (wxWindowListNode *)wxListBase::DetachNode(node); } bool DeleteNode(wxWindowListNode *node) { return wxListBase::DeleteNode(node); } bool DeleteObject(wxWindowBase *object) { return wxListBase::DeleteObject(object); } wxWindowListNode *Find(wxWindowBase *object) const { return (wxWindowListNode *)wxListBase::Find(object); } virtual wxWindowListNode *Find(const wxListKey& key) const { return (wxWindowListNode *)wxListBase::Find(key); } int IndexOf(wxWindowBase *object) const { return wxListBase::IndexOf(object); } void Sort(wxSortFuncFor_wxWindowList func) { wxListBase::Sort((wxSortCompareFunction)func); } protected: virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next, void *data, const wxListKey& key = wxDefaultListKey) { return new wxWindowListNode(this, (wxWindowListNode *)prev, (wxWindowListNode *)next, (wxWindow *)data, key); } };





extern wxWindowList wxTopLevelWindows;
# 92 "/usr/include/wx/window.h" 3 4
class wxWindowBase : public wxEvtHandler
{
public:




    wxWindowBase() { InitBase(); }


    bool CreateBase(wxWindowBase *parent,
                    wxWindowID id,
                    const wxPoint& pos = wxDefaultPosition,
                    const wxSize& size = wxDefaultSize,
                    long style = 0,
                    const wxValidator& validator = wxDefaultValidator,
                    const wxString& name = wxPanelNameStr);

    virtual ~wxWindowBase();
# 127 "/usr/include/wx/window.h" 3 4
    bool Close( bool force = ((bool)0) );






    virtual bool Destroy();

    bool DestroyChildren();


    bool IsBeingDeleted() const { return m_isBeingDeleted; }
# 150 "/usr/include/wx/window.h" 3 4
    virtual void SetTitle( const wxString& ) {}
    virtual wxString GetTitle() const { return wxEmptyString; }



    virtual void SetLabel(const wxString& label) { SetTitle(label); }
    virtual wxString GetLabel() const { return GetTitle(); }



    virtual void SetName( const wxString &name ) { m_windowName = name; }
    virtual wxString GetName() const { return m_windowName; }



    void SetId( wxWindowID id ) { m_windowId = id; }
    wxWindowID GetId() const { return m_windowId; }



    static int NewControlId() { return --ms_lastControlId; }


    static int NextControlId(int id) { return id - 1; }


    static int PrevControlId(int id) { return id + 1; }





    void SetSize( int x, int y, int width, int height,
                  int sizeFlags = (0x0001|0x0002) )
        { DoSetSize(x, y, width, height, sizeFlags); }

    void SetSize( int width, int height )
        { DoSetSize( -1, -1, width, height, 0x0000 ); }

    void SetSize( const wxSize& size )
        { SetSize( size.x, size.y); }

    void SetSize(const wxRect& rect, int sizeFlags = (0x0001|0x0002))
        { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); }

    void Move(int x, int y, int flags = 0x0000)
        { DoSetSize(x, y, -1, -1, flags); }

    void Move(const wxPoint& pt, int flags = 0x0000)
        { Move(pt.x, pt.y, flags); }


    virtual void Raise() = 0;
    virtual void Lower() = 0;


    void SetClientSize( int width, int height )
        { DoSetClientSize(width, height); }

    void SetClientSize( const wxSize& size )
        { DoSetClientSize(size.x, size.y); }

    void SetClientSize(const wxRect& rect)
        { SetClientSize( rect.width, rect.height ); }


    void GetPosition( int *x, int *y ) const { DoGetPosition(x, y); }
    wxPoint GetPosition() const
    {
        int w, h;
        DoGetPosition(&w, &h);

        return wxPoint(w, h);
    }

    void GetSize( int *w, int *h ) const { DoGetSize(w, h); }
    wxSize GetSize() const
    {
        int w, h;
        DoGetSize(& w, & h);
        return wxSize(w, h);
    }

    wxRect GetRect() const
    {
        int x, y, w, h;
        GetPosition(& x, & y);
        GetSize(& w, & h);

        return wxRect(x, y, w, h);
    }

    void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); }
    wxSize GetClientSize() const
    {
        int w, h;
        DoGetClientSize(& w, & h);

        return wxSize(w, h);
    }




    virtual wxPoint GetClientAreaOrigin() const;


    wxRect GetClientRect() const
    {
        return wxRect(GetClientAreaOrigin(), GetClientSize());
    }



    wxSize GetBestSize() const { return DoGetBestSize(); }
    void GetBestSize(int *w, int *h) const
    {
        wxSize s = DoGetBestSize();
        if ( w )
            *w = s.x;
        if ( h )
            *h = s.y;
    }






    wxSize GetAdjustedBestSize() const
    {
        wxSize s( DoGetBestSize() );
        return wxSize( (((s.x) > (GetMinWidth())) ? (s.x) : (GetMinWidth())), (((s.y) > (GetMinHeight())) ? (s.y) : (GetMinHeight())) );
    }




    void Centre( int direction = wxBOTH );
    void Center( int direction = wxBOTH ) { Centre(direction); }


    void CentreOnScreen(int dir = wxBOTH) { Centre(dir | 0x0002); }
    void CenterOnScreen(int dir = wxBOTH) { CentreOnScreen(dir); }


    void CentreOnParent(int dir = wxBOTH) { Centre(dir | 0x0000); }
    void CenterOnParent(int dir = wxBOTH) { CentreOnParent(dir); }


    virtual void Fit();


    virtual void FitInside();


    virtual void SetSizeHints( int minW, int minH,
                               int maxW = -1, int maxH = -1,
                               int incW = -1, int incH = -1 );

    virtual void SetVirtualSizeHints( int minW, int minH,
                                      int maxW = -1, int maxH = -1 );

    virtual int GetMinWidth() const { return m_minWidth; }
    virtual int GetMinHeight() const { return m_minHeight; }
    int GetMaxWidth() const { return m_maxWidth; }
    int GetMaxHeight() const { return m_maxHeight; }


    virtual wxSize GetMaxSize() const { return wxSize( m_maxWidth, m_maxHeight ); }







    void SetVirtualSize( const wxSize &size ) { DoSetVirtualSize( size.x, size.y ); }
    void SetVirtualSize( int x, int y ) { DoSetVirtualSize( x, y ); }

    wxSize GetVirtualSize() const { return DoGetVirtualSize(); }
    void GetVirtualSize( int *x, int *y ) const
    {
        wxSize s( DoGetVirtualSize() );

        if( x )
            *x = s.GetWidth();
        if( y )
            *y = s.GetHeight();
    }





    virtual void DoSetVirtualSize( int x, int y );
    virtual wxSize DoGetVirtualSize() const;




    virtual wxSize GetBestVirtualSize() const
    {
        wxSize client( GetClientSize() );
        wxSize best( GetBestSize() );

        return wxSize( (((client.x) > (best.x)) ? (client.x) : (best.x)), (((client.y) > (best.y)) ? (client.y) : (best.y)) );
    }






    virtual bool Show( bool show = ((bool)1) );
    bool Hide() { return Show(((bool)0)); }


    virtual bool Enable( bool enable = ((bool)1) );
    bool Disable() { return Enable(((bool)0)); }

    bool IsShown() const { return m_isShown; }
    bool IsEnabled() const { return m_isEnabled; }



    virtual void SetWindowStyleFlag( long style ) { m_windowStyle = style; }
    virtual long GetWindowStyleFlag() const { return m_windowStyle; }


    void SetWindowStyle( long style ) { SetWindowStyleFlag(style); }
    long GetWindowStyle() const { return GetWindowStyleFlag(); }

    bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; }
    virtual bool IsRetained() const { return HasFlag(0x00020000); }



    virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; }
    long GetExtraStyle() const { return m_exStyle; }


    virtual void MakeModal(bool modal = ((bool)1));

    virtual void SetThemeEnabled(bool enableTheme) { m_themeEnabled = enableTheme; }
    virtual bool GetThemeEnabled() const { return m_themeEnabled; }





    virtual void SetFocus() = 0;


    virtual void SetFocusFromKbd() { SetFocus(); }


    static wxWindow *FindFocus() ;


    virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }




    virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); }






    virtual wxWindow *GetDefaultItem() const { return __null; }


    virtual wxWindow *SetDefaultItem(wxWindow * )
        { return __null; }


    virtual void SetTmpDefaultItem(wxWindow * ) { }





    const wxWindowList& GetChildren() const { return m_children; }
    wxWindowList& GetChildren() { return m_children; }


    wxWindow *GetParent() const { return m_parent; }
    inline wxWindow *GetGrandParent() const;


    virtual bool IsTopLevel() const;


    void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; }


    virtual bool Reparent( wxWindowBase *newParent );


    virtual void AddChild( wxWindowBase *child );
    virtual void RemoveChild( wxWindowBase *child );






    wxWindow *FindWindow( long id );
    wxWindow *FindWindow( const wxString& name );


    static wxWindow *FindWindowById( long id, const wxWindow *parent = __null );
    static wxWindow *FindWindowByName( const wxString& name,
                                       const wxWindow *parent = __null );
    static wxWindow *FindWindowByLabel( const wxString& label,
                                        const wxWindow *parent = __null );





    wxEvtHandler *GetEventHandler() const { return m_eventHandler; }



    void SetEventHandler( wxEvtHandler *handler ) { m_eventHandler = handler; }



    void PushEventHandler( wxEvtHandler *handler );
    wxEvtHandler *PopEventHandler( bool deleteHandler = ((bool)0) );






    bool RemoveEventHandler(wxEvtHandler *handler);







    virtual void SetValidator( const wxValidator &validator );
    virtual wxValidator *GetValidator() { return m_windowValidator; }







    virtual bool Validate();


    virtual bool TransferDataToWindow();
    virtual bool TransferDataFromWindow();

    virtual void InitDialog();




    virtual void SetAcceleratorTable( const wxAcceleratorTable& accel )
        { m_acceleratorTable = accel; }
    wxAcceleratorTable *GetAcceleratorTable()
        { return &m_acceleratorTable; }





    wxPoint ConvertPixelsToDialog( const wxPoint& pt );
    wxPoint ConvertDialogToPixels( const wxPoint& pt );
    wxSize ConvertPixelsToDialog( const wxSize& sz )
    {
        wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y)));

        return wxSize(pt.x, pt.y);
    }

    wxSize ConvertDialogToPixels( const wxSize& sz )
    {
        wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y)));

        return wxSize(pt.x, pt.y);
    }





    virtual void WarpPointer(int x, int y) = 0;





    void CaptureMouse();
    void ReleaseMouse();


    static wxWindow *GetCapture();


    virtual bool HasCapture() const
        { return (wxWindow *)this == GetCapture(); }






    virtual void Refresh( bool eraseBackground = ((bool)1),
                          const wxRect *rect = (const wxRect *) __null ) = 0;


    void RefreshRect(const wxRect& rect) { Refresh(((bool)1), &rect); }


    virtual void Update() { }


    virtual void Clear() = 0;


    virtual void Freeze() { }


    virtual void Thaw() { }


    virtual void PrepareDC( wxDC & ) { }



    const wxRegion& GetUpdateRegion() const { return m_updateRegion; }
    wxRegion& GetUpdateRegion() { return m_updateRegion; }


    wxRect GetUpdateClientRect() const;



    bool IsExposed( int x, int y ) const;
    bool IsExposed( int x, int y, int w, int h ) const;

    bool IsExposed( const wxPoint& pt ) const
        { return IsExposed(pt.x, pt.y); }
    bool IsExposed( const wxRect& rect ) const
        { return IsExposed(rect.x, rect.y, rect.width, rect.height); }






    virtual bool SetBackgroundColour( const wxColour &colour );
    virtual bool SetForegroundColour( const wxColour &colour );

    wxColour GetBackgroundColour() const { return m_backgroundColour; }
    wxColour GetForegroundColour() const { return m_foregroundColour; }



    virtual bool SetCursor( const wxCursor &cursor );
    const wxCursor& GetCursor() const { return m_cursor; }
    wxCursor& GetCursor() { return m_cursor; }



    virtual bool SetFont( const wxFont &font ) = 0;
    const wxFont& GetFont() const { return m_font; }
    wxFont& GetFont() { return m_font; }



    void SetCaret(wxCaret *caret);

    wxCaret *GetCaret() const { return m_caret; }



    virtual int GetCharHeight() const = 0;
    virtual int GetCharWidth() const = 0;



    virtual void GetTextExtent(const wxString& string,
                               int *x, int *y,
                               int *descent = (int *) __null,
                               int *externalLeading = (int *) __null,
                               const wxFont *theFont = (const wxFont *) __null)
                               const = 0;





    void ClientToScreen( int *x, int *y ) const
        { DoClientToScreen(x, y); }
    void ScreenToClient( int *x, int *y ) const
        { DoScreenToClient(x, y); }


    wxPoint ClientToScreen(const wxPoint& pt) const
    {
        int x = pt.x, y = pt.y;
        DoClientToScreen(&x, &y);

        return wxPoint(x, y);
    }

    wxPoint ScreenToClient(const wxPoint& pt) const
    {
        int x = pt.x, y = pt.y;
        DoScreenToClient(&x, &y);

        return wxPoint(x, y);
    }


    wxHitTest HitTest(wxCoord x, wxCoord y) const
        { return DoHitTest(x, y); }

    wxHitTest HitTest(const wxPoint& pt) const
        { return DoHitTest(pt.x, pt.y); }






    wxBorder GetBorder() const;

    void UpdateWindowUI();


    bool PopupMenu( wxMenu *menu, const wxPoint& pos )
        { return DoPopupMenu(menu, pos.x, pos.y); }
    bool PopupMenu( wxMenu *menu, int x, int y )
        { return DoPopupMenu(menu, x, y); }






    bool HasScrollbar(int orient) const
    {
        return (m_windowStyle &
                (orient == wxHORIZONTAL ? 0x40000000 : 0x80000000)) != 0;
    }


    virtual void SetScrollbar( int orient,
                               int pos,
                               int thumbvisible,
                               int range,
                               bool refresh = ((bool)1) ) = 0;
    virtual void SetScrollPos( int orient, int pos, bool refresh = ((bool)1) ) = 0;
    virtual int GetScrollPos( int orient ) const = 0;
    virtual int GetScrollThumb( int orient ) const = 0;
    virtual int GetScrollRange( int orient ) const = 0;


    virtual void ScrollWindow( int dx, int dy,
                               const wxRect* rect = (wxRect *) __null ) = 0;




    virtual bool ScrollLines(int ) { return ((bool)0); }
    virtual bool ScrollPages(int ) { return ((bool)0); }


    bool LineUp() { return ScrollLines(-1); }
    bool LineDown() { return ScrollLines(1); }
    bool PageUp() { return ScrollPages(-1); }
    bool PageDown() { return ScrollPages(1); }
# 743 "/usr/include/wx/window.h" 3 4
    void SetHelpText(const wxString& text);


    void SetHelpTextForId(const wxString& text);

    wxString GetHelpText() const;







    void SetToolTip( const wxString &tip );

    void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); }

    wxToolTip* GetToolTip() const { return m_tooltip; }







    virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0;
    virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; }






    void SetConstraints( wxLayoutConstraints *constraints );
    wxLayoutConstraints *GetConstraints() const { return m_constraints; }


    void UnsetConstraints(wxLayoutConstraints *c);
    wxWindowList *GetConstraintsInvolvedIn() const
        { return m_constraintsInvolvedIn; }
    void AddConstraintReference(wxWindowBase *otherWin);
    void RemoveConstraintReference(wxWindowBase *otherWin);
    void DeleteRelatedConstraints();
    void ResetConstraints();


    virtual void SetConstraintSizes(bool recurse = ((bool)1));
    virtual bool LayoutPhase1(int *noChanges);
    virtual bool LayoutPhase2(int *noChanges);
    virtual bool DoPhase(int phase);


    virtual void SetSizeConstraint(int x, int y, int w, int h);
    virtual void MoveConstraint(int x, int y);
    virtual void GetSizeConstraint(int *w, int *h) const ;
    virtual void GetClientSizeConstraint(int *w, int *h) const ;
    virtual void GetPositionConstraint(int *x, int *y) const ;






    void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; }
    bool GetAutoLayout() const { return m_autoLayout; }


    virtual bool Layout();


    void SetSizer(wxSizer *sizer, bool deleteOld = ((bool)1) );
    void SetSizerAndFit( wxSizer *sizer, bool deleteOld = ((bool)1) );

    wxSizer *GetSizer() const { return m_windowSizer; }


    void SetContainingSizer(wxSizer* sizer) { m_containingSizer = sizer; }
    wxSizer *GetContainingSizer() const { return m_containingSizer; }
# 837 "/usr/include/wx/window.h" 3 4
    void OnSysColourChanged( wxSysColourChangedEvent& event );
    void OnInitDialog( wxInitDialogEvent &event );
    void OnMiddleClick( wxMouseEvent& event );

    void OnHelp(wxHelpEvent& event);





    virtual WXWidget GetHandle() const = 0;




    wxPalette GetPalette() const { return m_palette; }



    void SetPalette(const wxPalette& pal);


    bool HasCustomPalette() const { return m_hasCustomPalette; }


    wxWindow *GetAncestorWithCustomPalette() const;


protected:


    void SatisfyConstraints();




    wxWindowID m_windowId;



    wxWindow *m_parent;
    wxWindowList m_children;



    int m_minWidth,
                         m_minHeight,
                         m_maxWidth,
                         m_maxHeight;



    wxEvtHandler *m_eventHandler;



    wxValidator *m_windowValidator;



    wxDropTarget *m_dropTarget;



    wxCursor m_cursor;
    wxFont m_font;
    wxColour m_backgroundColour, m_foregroundColour;


    wxCaret *m_caret;



    wxRegion m_updateRegion;




    wxAcceleratorTable m_acceleratorTable;




    wxToolTip *m_tooltip;





    wxLayoutConstraints *m_constraints;


    wxWindowList *m_constraintsInvolvedIn;



    wxSizer *m_windowSizer;


    wxSizer *m_containingSizer;


    bool m_autoLayout:1;


    bool m_isShown:1;
    bool m_isEnabled:1;
    bool m_isBeingDeleted:1;


    bool m_hasBgCol:1;
    bool m_hasFgCol:1;
    bool m_hasFont:1;


    long m_windowStyle,
                         m_exStyle;
    wxString m_windowName;
    bool m_themeEnabled;


    wxPalette m_palette;
    bool m_hasCustomPalette;



    wxSize m_virtualSize;

    int m_minVirtualWidth;
    int m_minVirtualHeight;
    int m_maxVirtualWidth;
    int m_maxVirtualHeight;



    void InitBase();



    virtual wxBorder GetDefaultBorder() const;



    static int WidthDefault(int w) { return w == -1 ? 20 : w; }
    static int HeightDefault(int h) { return h == -1 ? 20 : h; }
# 991 "/usr/include/wx/window.h" 3 4
    void SetBestSize(const wxSize& size)
    {



        if ( size.x == -1 || size.y == -1 )
        {
            wxSize sizeBest = DoGetBestSize();
            if ( size.x != -1 )
                sizeBest.x = size.x;
            if ( size.y != -1 )
                sizeBest.y = size.y;

            SetSize(sizeBest);
        }
    }
# 1021 "/usr/include/wx/window.h" 3 4
    virtual void DoClientToScreen( int *x, int *y ) const = 0;
    virtual void DoScreenToClient( int *x, int *y ) const = 0;

    virtual wxHitTest DoHitTest(wxCoord x, wxCoord y) const;


    virtual void DoCaptureMouse() = 0;
    virtual void DoReleaseMouse() = 0;


    virtual void DoGetPosition( int *x, int *y ) const = 0;
    virtual void DoGetSize( int *width, int *height ) const = 0;
    virtual void DoGetClientSize( int *width, int *height ) const = 0;




    virtual wxSize DoGetBestSize() const;




    virtual void DoSetSize(int x, int y,
                           int width, int height,
                           int sizeFlags = (0x0001|0x0002)) = 0;


    virtual void DoSetClientSize(int width, int height) = 0;





    virtual void DoMoveWindow(int x, int y, int width, int height) = 0;


    virtual void DoSetToolTip( wxToolTip *tip );



    virtual bool DoPopupMenu( wxMenu *menu, int x, int y ) = 0;




    virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) const;


private:


    static int ms_lastControlId;


    static struct wxWindowNext *ms_winCaptureNext;

    public: static wxClassInfo sm_classwxWindowBase; virtual wxClassInfo *GetClassInfo() const { return &wxWindowBase::sm_classwxWindowBase; }
    private: wxWindowBase(const wxWindowBase&); wxWindowBase& operator=(const wxWindowBase&);
    private: static const wxEventTableEntry sm_eventTableEntries[]; protected: static const wxEventTable sm_eventTable; virtual const wxEventTable* GetEventTable() const;
};
# 1104 "/usr/include/wx/window.h" 3 4
# 1 "/usr/include/wx/gtk/window.h" 1 3 4
# 15 "/usr/include/wx/gtk/window.h" 3 4
#pragma interface






class wxWindow;
typedef void (*wxInsertChildFunction)( wxWindow*, wxWindow* );





class wxWindow : public wxWindowBase
{
public:


    wxWindow();
    wxWindow(wxWindow *parent,
                wxWindowID id,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = 0,
                const wxString& name = wxPanelNameStr);
    bool Create(wxWindow *parent,
                wxWindowID id,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = 0,
                const wxString& name = wxPanelNameStr);
    virtual ~wxWindow();




    virtual bool Destroy();

    virtual void Raise();
    virtual void Lower();

    virtual bool Show( bool show = ((bool)1) );
    virtual bool Enable( bool enable = ((bool)1) );

    virtual bool IsRetained() const;

    virtual void SetFocus();
    virtual bool AcceptsFocus() const;

    virtual bool Reparent( wxWindowBase *newParent );

    virtual void WarpPointer(int x, int y);

    virtual void Refresh( bool eraseBackground = ((bool)1),
                          const wxRect *rect = (const wxRect *) __null );
    virtual void Update();
    virtual void Clear();

    virtual bool SetBackgroundColour( const wxColour &colour );
    virtual bool SetForegroundColour( const wxColour &colour );
    virtual bool SetCursor( const wxCursor &cursor );
    virtual bool SetFont( const wxFont &font );

    virtual int GetCharHeight() const;
    virtual int GetCharWidth() const;
    virtual void GetTextExtent(const wxString& string,
                               int *x, int *y,
                               int *descent = (int *) __null,
                               int *externalLeading = (int *) __null,
                               const wxFont *theFont = (const wxFont *) __null)
                               const;


    virtual bool DoPopupMenu( wxMenu *menu, int x, int y );


    virtual void SetScrollbar( int orient, int pos, int thumbVisible,
                               int range, bool refresh = ((bool)1) );
    virtual void SetScrollPos( int orient, int pos, bool refresh = ((bool)1) );
    virtual int GetScrollPos( int orient ) const;
    virtual int GetScrollThumb( int orient ) const;
    virtual int GetScrollRange( int orient ) const;
    virtual void ScrollWindow( int dx, int dy,
                               const wxRect* rect = (wxRect *) __null );


    virtual void SetDropTarget( wxDropTarget *dropTarget );





    virtual WXWidget GetHandle() const { return m_widget; }




    virtual void OnInternalIdle();


    void GtkUpdate();


    void GtkSetBackgroundColour( const wxColour &colour );
    void GtkSetForegroundColour( const wxColour &colour );


    void OnIdle(wxIdleEvent& ) {}




    virtual void OnParentEnable( bool ) {}


    bool PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize &size );
    void PostCreation();




    void DoAddChild(wxWindow *child);






    void GtkSendPaintEvents();







    virtual GtkWidget* GetConnectWidget();
    virtual bool IsOwnGtkWindow( GdkWindow *window );
    void ConnectWidget( GtkWidget *widget );



    GtkStyle *GetWidgetStyle();



    PangoContext *GtkGetPangoDefaultContext();




    PangoContext *GtkGetPangoX11Context();
    PangoContext *m_x11Context;



    void SetWidgetStyle();


    virtual void ApplyWidgetStyle();


    virtual void ApplyToolTip( GtkTooltips *tips, const wxChar *tip );





    void GtkUpdateSize() { m_sizeSet = ((bool)0); }


    virtual void FixUpMouseEvent(GtkWidget * ,
                                 wxCoord& ,
                                 wxCoord& ) { }


    virtual bool IsTransparentForMouse() const { return ((bool)0); }


    virtual bool IsRadioButton() const { return ((bool)0); }


    int m_x, m_y;
    int m_width, m_height;
    int m_oldClientWidth,m_oldClientHeight;


    GtkWidget *m_widget;
    GtkWidget *m_wxwindow;


    GtkWidget *m_focusWidget;


    GtkIMMulticontext *m_imContext;
# 226 "/usr/include/wx/gtk/window.h" 3 4
    GtkAdjustment *m_hAdjust,*m_vAdjust;
    float m_oldHorizontalPos;
    float m_oldVerticalPos;


    bool m_needParent:1;
    bool m_noExpose:1;
    bool m_nativeSizeEvent:1;
    bool m_hasScrolling:1;
    bool m_hasVMT:1;
    bool m_sizeSet:1;
    bool m_resizing:1;
    bool m_acceptsFocus:1;
    bool m_hasFocus:1;
    bool m_isScrolling:1;
    bool m_clipPaintRegion:1;
    bool m_queuedFullRedraw:1;




    bool m_delayedForegroundColour:1;
    bool m_delayedBackgroundColour:1;





    GtkStyle *m_widgetStyle;




    wxInsertChildFunction m_insertCallback;


    virtual void DoClientToScreen( int *x, int *y ) const;
    virtual void DoScreenToClient( int *x, int *y ) const;
    virtual void DoGetPosition( int *x, int *y ) const;
    virtual void DoGetSize( int *width, int *height ) const;
    virtual void DoGetClientSize( int *width, int *height ) const;
    virtual void DoSetSize(int x, int y,
                           int width, int height,
                           int sizeFlags = (0x0001|0x0002));
    virtual void DoSetClientSize(int width, int height);
    virtual void DoMoveWindow(int x, int y, int width, int height);

    virtual void DoCaptureMouse();
    virtual void DoReleaseMouse();


    virtual void DoSetToolTip( wxToolTip *tip );


protected:

    void Init();

private:
    public: static wxClassInfo sm_classwxWindow; virtual wxClassInfo *GetClassInfo() const { return &wxWindow::sm_classwxWindow; }
    private: wxWindow(const wxWindow&); wxWindow& operator=(const wxWindow&);
};

extern wxWindow *wxFindFocusedChild(wxWindow *win);
# 1105 "/usr/include/wx/window.h" 2 3 4
# 1154 "/usr/include/wx/window.h" 3 4
inline wxWindow *wxWindowBase::GetGrandParent() const
{
    return m_parent ? m_parent->GetParent() : (wxWindow *)__null;
}







 extern wxWindow* wxFindWindowAtPointer(wxPoint& pt);


 extern wxPoint wxGetMousePosition();


 extern wxWindow *wxGetActiveWindow();


 wxWindow* wxGetTopLevelParent(wxWindow *win);


inline int NewControlId() { return wxWindowBase::NewControlId(); }
# 26 "/usr/include/wx/control.h" 2 3 4

extern const wxChar* wxControlNameStr;





class wxControlBase : public wxWindow
{
public:
    virtual ~wxControlBase();


    bool Create(wxWindow *parent, wxWindowID id,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = 0,
                const wxValidator& validator = wxDefaultValidator,
                const wxString& name = wxControlNameStr);



    virtual void Command(wxCommandEvent &event);


    int GetAlignment() const { return m_windowStyle & wxALIGN_MASK; }

protected:


    bool CreateControl(wxWindowBase *parent,
                       wxWindowID id,
                       const wxPoint& pos,
                       const wxSize& size,
                       long style,
                       const wxValidator& validator,
                       const wxString& name);


    void InheritAttributes();


    void InitCommandEvent(wxCommandEvent& event) const;
};
# 82 "/usr/include/wx/control.h" 3 4
# 1 "/usr/include/wx/gtk/control.h" 1 3 4
# 14 "/usr/include/wx/gtk/control.h" 3 4
#pragma interface
# 26 "/usr/include/wx/gtk/control.h" 3 4
class wxControl;





class wxControl : public wxControlBase
{
public:
    wxControl();
    wxControl(wxWindow *parent, wxWindowID id,
             const wxPoint& pos = wxDefaultPosition,
             const wxSize& size = wxDefaultSize, long style = 0,
             const wxValidator& validator = wxDefaultValidator,
             const wxString& name = wxControlNameStr)
    {
        Create(parent, id, pos, size, style, validator, name);
    }

    bool Create(wxWindow *parent, wxWindowID id,
            const wxPoint& pos = wxDefaultPosition,
            const wxSize& size = wxDefaultSize, long style = 0,
            const wxValidator& validator = wxDefaultValidator,
            const wxString& name = wxControlNameStr);



    virtual void SetLabel( const wxString &label );
    virtual wxString GetLabel() const;

protected:
    virtual wxSize DoGetBestSize() const;

    wxString PrepareLabelMnemonics( const wxString &label ) const;


    wxString m_label;
    char m_chAccel;

private:
    public: static wxClassInfo sm_classwxControl; virtual wxClassInfo *GetClassInfo() const { return &wxControl::sm_classwxControl; }
};
# 83 "/usr/include/wx/control.h" 2 3 4
# 37 "/usr/include/wx/button.h" 2 3 4

class wxBitmap;

extern const wxChar* wxButtonNameStr;





class wxButtonBase : public wxControl
{
public:

    virtual void SetImageLabel(const wxBitmap& ) { }


    virtual void SetImageMargins(wxCoord , wxCoord ) { }



    virtual void SetDefault() { }


    static wxSize GetDefaultSize();
};
# 70 "/usr/include/wx/button.h" 3 4
# 1 "/usr/include/wx/gtk/button.h" 1 3 4
# 14 "/usr/include/wx/gtk/button.h" 3 4
#pragma interface
# 26 "/usr/include/wx/gtk/button.h" 3 4
class wxButton;





extern const wxChar *wxButtonNameStr;





class wxButton: public wxControl
{
public:
    wxButton();
    wxButton(wxWindow *parent, wxWindowID id, const wxString& label,
           const wxPoint& pos = wxDefaultPosition,
           const wxSize& size = wxDefaultSize, long style = 0,
           const wxValidator& validator = wxDefaultValidator,
           const wxString& name = wxButtonNameStr)
    {
      Create(parent, id, label, pos, size, style, validator, name);
    }
    virtual ~wxButton();

    bool Create(wxWindow *parent, wxWindowID id, const wxString& label,
           const wxPoint& pos = wxDefaultPosition,
           const wxSize& size = wxDefaultSize, long style = 0,
           const wxValidator& validator = wxDefaultValidator,
           const wxString& name = wxButtonNameStr);

    virtual void SetDefault();
    virtual void SetLabel( const wxString &label );
    virtual bool Enable( bool enable = ((bool)1) );

    static wxSize GetDefaultSize();




    void ApplyWidgetStyle();
    bool IsOwnGtkWindow( GdkWindow *window );

protected:
    virtual wxSize DoGetBestSize() const;

private:
    public: static wxClassInfo sm_classwxButton; virtual wxClassInfo *GetClassInfo() const { return &wxButton::sm_classwxButton; }
};
# 71 "/usr/include/wx/button.h" 2 3 4
# 19 "/usr/include/wx/bmpbuttn.h" 2 3 4

extern const wxChar* wxButtonNameStr;






class wxBitmapButtonBase : public wxButton
{
public:
    wxBitmapButtonBase()
        : m_bmpNormal(), m_bmpSelected(), m_bmpFocus(), m_bmpDisabled()
        , m_marginX(0), m_marginY(0)
        { }


    void SetBitmapLabel(const wxBitmap& bitmap)
        { m_bmpNormal = bitmap; OnSetBitmap(); }
    void SetBitmapSelected(const wxBitmap& sel)
        { m_bmpSelected = sel; OnSetBitmap(); };
    void SetBitmapFocus(const wxBitmap& focus)
        { m_bmpFocus = focus; OnSetBitmap(); };
    void SetBitmapDisabled(const wxBitmap& disabled)
        { m_bmpDisabled = disabled; OnSetBitmap(); };
    void SetLabel(const wxBitmap& bitmap)
        { SetBitmapLabel(bitmap); }


    const wxBitmap& GetBitmapLabel() const { return m_bmpNormal; }
    const wxBitmap& GetBitmapSelected() const { return m_bmpSelected; }
    const wxBitmap& GetBitmapFocus() const { return m_bmpFocus; }
    const wxBitmap& GetBitmapDisabled() const { return m_bmpDisabled; }
    wxBitmap& GetBitmapLabel() { return m_bmpNormal; }
    wxBitmap& GetBitmapSelected() { return m_bmpSelected; }
    wxBitmap& GetBitmapFocus() { return m_bmpFocus; }
    wxBitmap& GetBitmapDisabled() { return m_bmpDisabled; }


    virtual void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
    int GetMarginX() const { return m_marginX; }
    int GetMarginY() const { return m_marginY; }

protected:

    virtual void OnSetBitmap() { }


    wxBitmap m_bmpNormal,
             m_bmpSelected,
             m_bmpFocus,
             m_bmpDisabled;


    int m_marginX,
        m_marginY;
private:

    void SetLabel(const wxString& rsLabel)
    { wxWindowBase::SetLabel(rsLabel); }
};
# 88 "/usr/include/wx/bmpbuttn.h" 3 4
# 1 "/usr/include/wx/gtk/bmpbuttn.h" 1 3 4
# 15 "/usr/include/wx/gtk/bmpbuttn.h" 3 4
#pragma interface






class wxBitmapButton: public wxBitmapButtonBase
{
public:
    wxBitmapButton() { Init(); }

    wxBitmapButton(wxWindow *parent,
                   wxWindowID id,
                   const wxBitmap& bitmap,
                   const wxPoint& pos = wxDefaultPosition,
                   const wxSize& size = wxDefaultSize,
                   long style = 0x0004,
                   const wxValidator& validator = wxDefaultValidator,
                   const wxString& name = wxButtonNameStr)
    {
        Init();

        Create(parent, id, bitmap, pos, size, style, validator, name);
    }

    bool Create(wxWindow *parent,
                wxWindowID id,
                const wxBitmap& bitmap,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = 0x0004,
                const wxValidator& validator = wxDefaultValidator,
                const wxString& name = wxButtonNameStr);

    void SetLabel( const wxString &label );
    wxString GetLabel() const;
    virtual void SetLabel( const wxBitmap& bitmap ) { SetBitmapLabel(bitmap); }

    virtual void SetDefault();
    virtual bool Enable(bool enable = ((bool)1));




    void HasFocus();
    void NotFocus();
    void StartSelect();
    void EndSelect();
    void ApplyWidgetStyle();

    bool m_hasFocus:1;
    bool m_isSelected:1;

protected:
    virtual void OnSetBitmap();

    void Init();

private:
    public: static wxClassInfo sm_classwxBitmapButton; virtual wxClassInfo *GetClassInfo() const { return &wxBitmapButton::sm_classwxBitmapButton; }
};
# 89 "/usr/include/wx/bmpbuttn.h" 2 3 4
# 24 "xh_bmpbt.cpp" 2

wxBitmapButtonXmlHandler::wxBitmapButtonXmlHandler()
: wxXmlResourceHandler()
{
    AddStyle("wxBU_AUTODRAW", 0x0004);
    AddStyle("wxBU_LEFT", 0x0040);
    AddStyle("wxBU_RIGHT", 0x0100);
    AddStyle("wxBU_TOP", 0x0080);
    AddStyle("wxBU_BOTTOM", 0x0200);
    AddWindowStyles();
}

wxObject *wxBitmapButtonXmlHandler::DoCreateResource()
{
    wxBitmapButton *button = __null; if (m_instance) button = ((wxBitmapButton *)(m_instance)); if (!button) button = new wxBitmapButton;

    button->Create(m_parentAsWindow,
                   GetID(),
                   GetBitmap("bitmap"),
                   GetPosition(), GetSize(),
                   GetStyle("style", 0x0004),
                   wxDefaultValidator,
                   GetName());
    if (GetBool("default", 0))
        button->SetDefault();
    SetupWindow(button);

    if (!GetParamValue("selected").IsEmpty())
        button->SetBitmapSelected(GetBitmap("selected"));
    if (!GetParamValue("focus").IsEmpty())
        button->SetBitmapFocus(GetBitmap("focus"));
    if (!GetParamValue("disabled").IsEmpty())
        button->SetBitmapDisabled(GetBitmap("disabled"));

    return button;
}

bool wxBitmapButtonXmlHandler::CanHandle(wxXmlNode *node)
{
    return IsOfClass(node, "wxBitmapButton");
}