This commit was manufactured by cvs2svn to create tag

'WXDLLEXPORTLOCAL'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/WXDLLEXPORTLOCAL@2756 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/date.h

@@ -1,146 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        date.h
-// Purpose:     wxDate class
-// Author:      Julian Smart, Steve Marcus, Eric Simon, Chris Hill,
-//              Charles D. Price
-// Modified by:
-// Created:     01/02/97
-// RCS-ID:      $Id$
-// Copyright:   (c)
-// Licence:     wxWindows licence
-/////////////////////////////////////////////////////////////////////////////
-
-#ifndef _WX_DATE_H_
-#define _WX_DATE_H_
-
-#ifdef __GNUG__
-#pragma interface "date.h"
-#endif
-
-#include "wx/object.h"
-#include "wx/string.h"
-
-#if wxUSE_TIMEDATE
-// These lines necessary to stop VC++ 6 being confused about namespaces
-class WXDLLEXPORT wxDate;
-bool WXDLLEXPORT operator<(const wxDate &dt1, const wxDate &dt2);
-bool WXDLLEXPORT operator<(const wxDate &dt1, const wxDate &dt2);
-bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2);
-bool WXDLLEXPORT operator >  (const wxDate &dt1, const wxDate &dt2);
-bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2);
-bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2);
-bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2);
-
-enum wxdate_format_type {wxMDY, wxDAY, wxMONTH, wxFULL, wxEUROPEAN};
-
-#define wxNO_CENTURY  0x02
-#define wxDATE_ABBR   0x04
-
-class WXDLLEXPORT wxDate : public wxObject
-{
-DECLARE_DYNAMIC_CLASS(wxDate)
-
-protected:
-    unsigned long julian; // see julDate();  days since 1/1/4713 B.C.
-    int month;            // see NMonth()
-    int day;              // see Day()
-    int year;             // see NYear4()
-    int day_of_week;      // see NDOW();  1 = Sunday, ... 7 = Saturday
-
-private:
-    int       DisplayFormat;
-    unsigned char DisplayOptions;
-
-    void julian_to_mdy ();         // convert julian day to mdy
-    void julian_to_wday ();        // convert julian day to day_of_week
-    void mdy_to_julian ();         // convert mdy to julian day
-
-public:
-    wxDate ();
-    wxDate (long j);
-    wxDate (int m, int d, int y);
-    wxDate (const wxString& dat);
-    wxDate (const wxDate &dt);
-
-#ifndef __SALFORDC__
-    operator wxString  (void);
-#endif
-
-    void operator =   (const wxDate& date);
-    void operator =   (const wxString& date);
-
-    wxDate operator +  (long i);
-    wxDate operator +  (int  i);
-
-    wxDate operator -  (long i);
-    wxDate operator -  (int  i);
-
-    long operator -  (const wxDate &dt);
-
-    wxDate &operator += (long i);
-    wxDate &operator -= (long i);
-
-    wxDate &operator ++ ();     // Prefix increment
-    wxDate &operator ++ (int);  // Postfix increment
-    wxDate &operator -- ();     // Prefix decrement
-    wxDate &operator -- (int);  // Postfix decrement
-
-    friend bool WXDLLEXPORT operator <  (const wxDate &dt1, const wxDate &dt2);
-    friend bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2);
-    friend bool WXDLLEXPORT operator >  (const wxDate &dt1, const wxDate &dt2);
-    friend bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2);
-    friend bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2);
-    friend bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2);
-
-#if wxUSE_STD_IOSTREAM
-    friend ostream WXDLLEXPORT & operator << (ostream &os, const wxDate &dt);
-#endif
-
-    wxString FormatDate      (int type=-1) const;
-    void  SetFormat (int format);
-    int   SetOption (int option, bool enable=TRUE);
-
-    long  GetJulianDate() const;  // returns julian date
-    int   GetDayOfYear()  const;  // returns relative date since Jan. 1
-    bool  IsLeapYear()    const;  // returns TRUE if leap year, FALSE if not
-
-    // Version 4.0 Extension to Public Interface - CDP
-
-    // These 'Set's modify the date object and actually SET it
-    // They all return a reference to self (*this)
-
-    wxDate &Set();            // Sets to current system date
-    wxDate &Set(long lJulian);
-    wxDate &Set(int nMonth, int nDay, int nYear);
-
-    wxDate &AddWeeks(int nCount = 1);  //
-    wxDate &AddMonths(int nCount = 1); // May also pass neg# to decrement
-    wxDate &AddYears(int nCount = 1);  //
-
-    int   GetDay() const;      // Numeric Day of date object
-    int   GetDaysInMonth();    // Number of days in month (1..31)
-    int   GetFirstDayOfMonth() const; // First Day Of Month  (1..7)
-
-    wxString GetDayOfWeekName();       // Character Day Of Week ('Sunday'..'Saturday')
-    int   GetDayOfWeek() const;     // (1..7)
-
-    int   GetWeekOfMonth();            // Numeric Week Of Month  (1..6)
-    int   GetWeekOfYear();            // Numeric Week Of Year   (1..52)
-
-    wxString GetMonthName();            // Character Month name
-    int   GetMonth() const;          // Month Number (1..12)
-    wxDate  GetMonthStart();         // First Date Of Month
-    wxDate  GetMonthEnd();           // Last Date Of Month
-
-    int   GetYear() const;           // eg. 1992
-    wxDate  GetYearStart();          // First Date Of Year
-    wxDate  GetYearEnd();            // Last Date Of Year
-
-    bool IsBetween(const wxDate& first, const wxDate& second) const;
-
-    wxDate Previous(int dayOfWeek) const;
-};
-
-#endif // wxUSE_TIMEDATE
-#endif
-    // _WX_DATE_H_

include/wx/dynarray.h

@@ -0,0 +1,443 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        dynarray.h
+// Purpose:     auto-resizable (i.e. dynamic) array support
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     12.09.97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+// Licence:     wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef   _DYNARRAY_H
+#define   _DYNARRAY_H
+
+#ifdef __GNUG__
+#pragma interface "dynarray.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/debug.h"
+
+/** @name Dynamic arrays and object arrays (array which own their elements)
+    @memo Arrays which grow on demand and do range checking (only in debug)
+  */
+//@{
+
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+/**
+ the initial size by which an array grows when an element is added
+ default value avoids allocate one or two bytes when the array is created
+ which is rather inefficient
+*/
+#define   WX_ARRAY_DEFAULT_INITIAL_SIZE    (16)
+
+// ----------------------------------------------------------------------------
+// types
+// ----------------------------------------------------------------------------
+
+/**
+ callback compare function for quick sort
+ must return negative value, 0 or positive value if pItem1 <, = or > pItem2
+ */
+
+#ifdef  __VISUALC__
+  #define   CMPFUNC_CONV    _cdecl
+#else   // !Visual C++
+  #define   CMPFUNC_CONV
+#endif  // compiler
+typedef int (CMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);
+
+// ----------------------------------------------------------------------------
+/**
+ base class managing data having size of type 'long' (not used directly)
+
+ NB: for efficiency this often used class has no virtual functions (hence no
+     VTBL), even dtor is <B>not</B> virtual. If used as expected it won't
+     create any problems because ARRAYs from DEFINE_ARRAY have no dtor at all,
+     so it's not too important if it's not called (this happens when you cast
+     "SomeArray *" as "BaseArray *" and then delete it)
+
+  @memo Base class for template array classes
+*/
+// ----------------------------------------------------------------------------
+class WXDLLEXPORT wxBaseArray
+{
+public:
+  /** @name ctors and dtor */
+  //@{
+    /// default ctor
+  wxBaseArray();
+    /// copy ctor
+  wxBaseArray(const wxBaseArray& array);
+    /// assignment operator
+  wxBaseArray& operator=(const wxBaseArray& src);
+    /// not virtual, see above
+    /// EXCEPT for Gnu compiler to reduce warnings...
+#ifdef __GNUG__
+ virtual
+#endif
+  ~wxBaseArray();
+  //@}
+
+  /** @name memory management */
+  //@{
+    /// empties the array, but doesn't release memory
+  void Empty() { m_nCount = 0; }
+    /// empties the array and releases memory
+  void Clear();
+    /// preallocates memory for given number of items
+  void Alloc(size_t uiSize);
+    /// minimizes the memory used by the array (frees unused memory)
+  void Shrink();
+  //@}
+
+  /** @name simple accessors */
+  //@{
+    /// number of elements in the array
+  size_t  Count() const   { return m_nCount;      }
+  size_t  GetCount() const   { return m_nCount;      }
+    /// is it empty?
+  bool  IsEmpty() const { return m_nCount == 0; }
+  //@}
+
+protected:
+  // these methods are protected because if they were public one could
+  // mistakenly call one of them instead of DEFINE_ARRAY's or OBJARRAY's
+  // type safe methods
+
+  /** @name items access */
+  //@{
+    /// get item at position uiIndex (range checking is done in debug version)
+  long& Item(size_t uiIndex) const
+    { wxASSERT( uiIndex < m_nCount ); return m_pItems[uiIndex]; }
+    /// same as Item()
+  long& operator[](size_t uiIndex) const { return Item(uiIndex); }
+  //@}
+
+  /** @name item management */
+  //@{
+    /**
+      Search the element in the array, starting from the either side
+      @param bFromEnd if TRUE, start from the end
+      @return index of the first item matched or wxNOT_FOUND
+      @see wxNOT_FOUND
+     */
+  int Index(long lItem, bool bFromEnd = FALSE) const;
+    /// search for an item using binary search in a sorted array
+  int Index(long lItem, CMPFUNC fnCompare) const;
+    /// add new element at the end
+  void Add(long lItem);
+    /// add item assuming the array is sorted with fnCompare function
+  void Add(long lItem, CMPFUNC fnCompare);
+    /// add new element at given position (it becomes Item[uiIndex])
+  void Insert(long lItem, size_t uiIndex);
+    /// remove first item matching this value
+  void Remove(long lItem);
+    /// remove item by index
+  void Remove(size_t uiIndex);
+  //@}
+
+  /// sort array elements using given compare function
+  void Sort(CMPFUNC fnCompare);
+
+private:
+  void    Grow();     // makes array bigger if needed
+
+  size_t  m_nSize,    // current size of the array
+          m_nCount;   // current number of elements
+
+  long   *m_pItems;   // pointer to data
+};
+
+// ============================================================================
+// template classes
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// This macro generates a new array class. It is intended for storage of simple
+// types of sizeof()<=sizeof(long) or pointers if sizeof(pointer)<=sizeof(long)
+//
+// NB: it has only inline functions => takes no space at all
+// Mod by JACS: Salford C++ doesn't like 'var->operator=' syntax, as in:
+//    { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
+// so using a temporary variable instead.
+// ----------------------------------------------------------------------------
+#define  _WX_DEFINE_ARRAY(T, name)                                  \
+typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2);       \
+class WXDLLEXPORTLOCAL name : public wxBaseArray                                     \
+{                                                                   \
+public:                                                             \
+  name()                                                            \
+    { wxASSERT( sizeof(T) <= sizeof(long) ); }                      \
+                                                                    \
+  name& operator=(const name& src)                                  \
+    { wxBaseArray* temp = (wxBaseArray*) this;                      \
+      (*temp) = ((const wxBaseArray&)src);                          \
+      return *this; }                                               \
+                                                                    \
+  T& operator[](size_t uiIndex) const                               \
+    { return (T&)(wxBaseArray::Item(uiIndex)); }                    \
+  T& Item(size_t uiIndex) const                                     \
+    { return (T&)(wxBaseArray::Item(uiIndex)); }                    \
+  T& Last() const                                                   \
+    { return (T&)(wxBaseArray::Item(Count() - 1)); }                \
+                                                                    \
+  int Index(T Item, bool bFromEnd = FALSE) const                    \
+    { return wxBaseArray::Index((long)Item, bFromEnd); }            \
+                                                                    \
+  void Add(T Item)                                                  \
+    { wxBaseArray::Add((long)Item); }                               \
+  void Insert(T Item, size_t uiIndex)                               \
+    { wxBaseArray::Insert((long)Item, uiIndex) ; }                  \
+                                                                    \
+  void Remove(size_t uiIndex) { wxBaseArray::Remove(uiIndex); }     \
+  void Remove(T Item)                                               \
+    { int iIndex = Index(Item);                                     \
+      wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
+        _T("removing inexisting element in wxArray::Remove") );     \
+      wxBaseArray::Remove((size_t)iIndex); }                        \
+                                                                    \
+  void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); }  \
+}
+
+// ----------------------------------------------------------------------------
+// This is the same as the previous macro, but it defines a sorted array.
+// Differences:
+//  1) it must be given a COMPARE function in ctor which takes 2 items of type
+//     T* and should return -1, 0 or +1 if the first one is less/greater
+//     than/equal to the second one.
+//  2) the Add() method inserts the item in such was that the array is always
+//     sorted (it uses the COMPARE function)
+//  3) it has no Sort() method because it's always sorted
+//  4) Index() method is much faster (the sorted arrays use binary search
+//     instead of linear one), but Add() is slower.
+//
+// Summary: use this class when the speed of Index() function is important, use
+// the normal arrays otherwise.
+//
+// NB: it has only inline functions => takes no space at all
+// Mod by JACS: Salford C++ doesn't like 'var->operator=' syntax, as in:
+//    { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
+// so using a temporary variable instead.
+// ----------------------------------------------------------------------------
+#define  _WX_DEFINE_SORTED_ARRAY(T, name)                           \
+typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2);        \
+class WXDLLEXPORTLOCAL  name : public wxBaseArray                                     \
+{                                                                   \
+public:                                                             \
+  name(SCMPFUNC##T fn)                                              \
+    { wxASSERT( sizeof(T) <= sizeof(long) ); m_fnCompare = fn; }    \
+                                                                    \
+  name& operator=(const name& src)                                  \
+    { wxBaseArray* temp = (wxBaseArray*) this;                      \
+      (*temp) = ((const wxBaseArray&)src);                          \
+      m_fnCompare = src.m_fnCompare;                                \
+      return *this; }                                               \
+                                                                    \
+  T& operator[](size_t uiIndex) const                               \
+    { return (T&)(wxBaseArray::Item(uiIndex)); }                    \
+  T& Item(size_t uiIndex) const                                     \
+    { return (T&)(wxBaseArray::Item(uiIndex)); }                    \
+  T& Last() const                                                   \
+    { return (T&)(wxBaseArray::Item(Count() - 1)); }                \
+                                                                    \
+  int Index(T Item) const                                           \
+    { return wxBaseArray::Index((long)Item, (CMPFUNC)m_fnCompare); }\
+                                                                    \
+  void Add(T Item)                                                  \
+    { wxBaseArray::Add((long)Item, (CMPFUNC)m_fnCompare); }         \
+                                                                    \
+  void Remove(size_t uiIndex) { wxBaseArray::Remove(uiIndex); }     \
+  void Remove(T Item)                                               \
+    { int iIndex = Index(Item);                                     \
+      wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
+        _T("removing inexisting element in wxArray::Remove") );     \
+      wxBaseArray::Remove((size_t)iIndex); }                        \
+                                                                    \
+private:                                                            \
+  SCMPFUNC##T m_fnCompare;                                          \
+}
+
+// ----------------------------------------------------------------------------
+// see WX_DECLARE_OBJARRAY and WX_DEFINE_OBJARRAY
+// ----------------------------------------------------------------------------
+#define _WX_DECLARE_OBJARRAY(T, name)                               \
+typedef int (CMPFUNC_CONV *CMPFUNC##T)(T** pItem1, T** pItem2);     \
+class WXDLLEXPORTLOCAL name : public wxBaseArray                    \
+{                                                                   \
+public:                                                             \
+  name() { }                                                        \
+  name(const name& src);                                            \
+  name& operator=(const name& src);                                 \
+                                                                    \
+  ~name();                                                          \
+                                                                    \
+  T& operator[](size_t uiIndex) const                               \
+    { return *(T*)wxBaseArray::Item(uiIndex); }                     \
+  T& Item(size_t uiIndex) const                                     \
+    { return *(T*)wxBaseArray::Item(uiIndex); }                     \
+  T& Last() const                                                   \
+    { return *(T*)(wxBaseArray::Item(Count() - 1)); }               \
+                                                                    \
+  int Index(const T& Item, bool bFromEnd = FALSE) const;            \
+                                                                    \
+  void Add(const T& Item);                                          \
+  void Add(const T* pItem)                                          \
+    { wxBaseArray::Add((long)pItem); }                              \
+                                                                    \
+  void Insert(const T& Item,  size_t uiIndex);                      \
+  void Insert(const T* pItem, size_t uiIndex)                       \
+    { wxBaseArray::Insert((long)pItem, uiIndex); }                  \
+                                                                    \
+  void Empty();                                                     \
+                                                                    \
+  T*   Detach(size_t uiIndex)                                       \
+    { T* p = (T*)wxBaseArray::Item(uiIndex);                        \
+      wxBaseArray::Remove(uiIndex); return p; }                     \
+  void Remove(size_t uiIndex);                                      \
+                                                                    \
+  void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); }  \
+                                                                    \
+private:                                                            \
+  void DoCopy(const name& src);                                     \
+}
+
+// ----------------------------------------------------------------------------
+/** @name Macros for definition of dynamic arrays and objarrays
+
+  These macros are ugly (especially if you look in the sources ;-), but they
+  allow us to define 'template' classes without actually using templates.
+  <BR>
+  <BR>
+  Range checking is performed in debug build for both arrays and objarrays.
+  Type checking is done at compile-time. Warning: arrays <I>never</I> shrink,
+  they only grow, so loading 10 millions in an array only to delete them 2
+  lines below is <I>not</I> recommended. However, it does free memory when
+  it's destroyed, so if you destroy array also, it's ok.
+  */
+// ----------------------------------------------------------------------------
+
+//@{
+  /**
+   This macro generates a new array class. It is intended for storage of simple
+   types of sizeof()<=sizeof(long) or pointers if sizeof(pointer)<=sizeof(long)
+   <BR>
+   NB: it has only inline functions => takes no space at all
+   <BR>
+
+   @memo declare and define array class 'name' containing elements of type 'T'
+  */
+#define WX_DEFINE_ARRAY(T, name)  typedef T _A##name;                        \
+                                  _WX_DEFINE_ARRAY(_A##name, name)
+
+  /**
+   This macro does the same as WX_DEFINE_ARRAY except that the array will be
+   sorted with the specified compare function.
+   */
+#define WX_DEFINE_SORTED_ARRAY(T, name)  typedef T _A##name;                 \
+                                  _WX_DEFINE_SORTED_ARRAY(_A##name, name)
+
+  /**
+   This macro generates a new objarrays class which owns the objects it
+   contains, i.e. it will delete them when it is destroyed. An element is of
+   type T*, but arguments of type T& are taken (see below!) and T& is
+   returned. <BR>
+   Don't use this for simple types such as "int" or "long"!
+   You _may_ use it for "double" but it's awfully inefficient.
+   <BR>
+   <BR>
+   Note on Add/Insert functions:
+   <BR>
+    1) function(T*) gives the object to the array, i.e. it will delete the
+       object when it's removed or in the array's dtor
+   <BR>
+    2) function(T&) will create a copy of the object and work with it
+   <BR>
+   <BR>
+   Also:
+   <BR>
+    1) Remove() will delete the object after removing it from the array
+   <BR>
+    2) Detach() just removes the object from the array (returning pointer to it)
+   <BR>
+   <BR>
+   NB1: Base type T should have an accessible copy ctor  if  Add(T&) is used,
+   <BR>
+   NB2: Never ever cast a array to it's base type: as dtor is <B>not</B> virtual
+        it will provoke memory leaks
+   <BR>
+   <BR>
+   some functions of this class are not inline, so it takes some space to
+   define new class from this template.
+
+   @memo declare objarray class 'name' containing elements of type 'T'
+  */
+#define WX_DECLARE_OBJARRAY(T, name)  typedef T _L##name;                 \
+                                      _WX_DECLARE_OBJARRAY(_L##name, name)
+  /**
+    To use an objarray class you must
+    <ll>
+    <li>#include "dynarray.h"
+    <li>WX_DECLARE_OBJARRAY(element_type, list_class_name)
+    <li>#include "arrimpl.cpp"
+    <li>WX_DEFINE_OBJARRAY(list_class_name)   // same as above!
+    </ll>
+    <BR><BR>
+    This is necessary because at the moment of DEFINE_OBJARRAY class
+    element_type must be fully defined (i.e. forward declaration is not
+    enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
+    two allows to break cicrcular dependencies with classes which have member
+    variables of objarray type.
+
+    @memo define (must include arrimpl.cpp!) objarray class 'name'
+   */
+#define WX_DEFINE_OBJARRAY(name)       "don't forget to include arrimpl.cpp!"
+//@}
+
+// ----------------------------------------------------------------------------
+/** @name Some commonly used predefined arrays */
+// # overhead if not used?
+// ----------------------------------------------------------------------------
+
+#define WXDLLEXPORTLOCAL WXDLLEXPORT
+
+//@{
+  /** @name ArrayInt */
+WX_DEFINE_ARRAY(int,    wxArrayInt);
+  /** @name ArrayLong */
+WX_DEFINE_ARRAY(long,   wxArrayLong);
+  /** @name ArrayPtrVoid */
+WX_DEFINE_ARRAY(void *, wxArrayPtrVoid);
+//@}
+
+//@}
+
+#undef  WXDLLEXPORTLOCAL
+#define WXDLLEXPORTLOCAL
+
+// -----------------------------------------------------------------------------
+// convinience macros
+// -----------------------------------------------------------------------------
+
+// delete all array elements
+//
+// NB: the class declaration of the array elements must be visible from the
+//     place where you use this macro, otherwise the proper destructor may not
+//     be called (a decent compiler should give a warning about it, but don't
+//     count on it)!
+#define WX_CLEAR_ARRAY(array)                                                 \
+    {                                                                         \
+        size_t count = array.Count();                                         \
+        for ( size_t n = 0; n < count; n++ )                                  \
+        {                                                                     \
+            delete array[n];                                                  \
+        }                                                                     \
+                                                                              \
+        array.Empty();                                                        \
+    }
+#endif // _DYNARRAY_H
+

include/wx/msw/dcclient.h

@@ -0,0 +1,89 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dcclient.h
+// Purpose:     wxClientDC class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart and Markus Holzem
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DCCLIENT_H_
+#define _WX_DCCLIENT_H_
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma interface "dcclient.h"
+#endif
+
+#include "wx/dc.h"
+#include "wx/dynarray.h"
+
+// ----------------------------------------------------------------------------
+// array types
+// ----------------------------------------------------------------------------
+
+// this one if used by wxPaintDC only
+struct WXDLLEXPORT wxPaintDCInfo;
+
+#undef  WXDLLEXPORTLOCAL
+#define WXDLLEXPORTLOCAL WXDLLEXPORT
+WX_DECLARE_OBJARRAY(wxPaintDCInfo, wxArrayDCInfo);
+#undef  WXDLLEXPORTLOCAL
+#define WXDLLEXPORTLOCAL
+
+// ----------------------------------------------------------------------------
+// DC classes
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxWindowDC : public wxDC
+{
+    DECLARE_DYNAMIC_CLASS(wxWindowDC)
+
+public:
+    wxWindowDC();
+
+    // Create a DC corresponding to the whole window
+    wxWindowDC(wxWindow *win);
+
+    virtual ~wxWindowDC();
+};
+
+class WXDLLEXPORT wxClientDC : public wxWindowDC
+{
+    DECLARE_DYNAMIC_CLASS(wxClientDC)
+
+public:
+    wxClientDC();
+
+    // Create a DC corresponding to the client area of the window
+    wxClientDC(wxWindow *win);
+
+    virtual ~wxClientDC();
+};
+
+class WXDLLEXPORT wxPaintDC : public wxWindowDC
+{
+    DECLARE_DYNAMIC_CLASS(wxPaintDC)
+
+public:
+    wxPaintDC();
+
+    // Create a DC corresponding for painting the window in OnPaint()
+    wxPaintDC(wxWindow *win);
+
+    virtual ~wxPaintDC();
+
+protected:
+    static wxArrayDCInfo ms_cache;
+
+    // find the entry for this DC in the cache (keyed by the window)
+    wxPaintDCInfo *FindInCache(size_t *index = NULL) const;
+};
+
+#endif
+    // _WX_DCCLIENT_H_

include/wx/msw/listbox.h

@@ -0,0 +1,147 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        listbox.h
+// Purpose:     wxListBox class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_LISTBOX_H_
+#define _WX_LISTBOX_H_
+
+#ifdef __GNUG__
+#pragma interface "listbox.h"
+#endif
+
+#include "wx/control.h"
+
+WXDLLEXPORT_DATA(extern const wxChar*) wxListBoxNameStr;
+
+#if wxUSE_OWNER_DRAWN
+  class WXDLLEXPORT wxOwnerDrawn;
+
+  // define the array of list box items
+  #include  <wx/dynarray.h>
+
+  #undef WXDLLEXPORTLOCAL
+  #define WXDLLEXPORTLOCAL WXDLLEXPORT
+  WX_DEFINE_ARRAY(wxOwnerDrawn *, wxListBoxItemsArray);
+  #undef  WXDLLEXPORTLOCAL
+  #define WXDLLEXPORTLOCAL
+
+#endif
+
+// forward decl for GetSelections()
+class wxArrayInt;
+
+WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
+
+// List box item
+class WXDLLEXPORT wxListBox : public wxControl
+{
+    DECLARE_DYNAMIC_CLASS(wxListBox)
+
+public:
+    wxListBox();
+    wxListBox(wxWindow *parent, wxWindowID id,
+            const wxPoint& pos = wxDefaultPosition,
+            const wxSize& size = wxDefaultSize,
+            int n = 0, const wxString choices[] = NULL,
+            long style = 0,
+            const wxValidator& validator = wxDefaultValidator,
+            const wxString& name = wxListBoxNameStr)
+    {
+        Create(parent, id, pos, size, n, choices, style, validator, name);
+    }
+
+    bool Create(wxWindow *parent, wxWindowID id,
+            const wxPoint& pos = wxDefaultPosition,
+            const wxSize& size = wxDefaultSize,
+            int n = 0, const wxString choices[] = NULL,
+            long style = 0,
+            const wxValidator& validator = wxDefaultValidator,
+            const wxString& name = wxListBoxNameStr);
+
+    ~wxListBox();
+
+    bool MSWCommand(WXUINT param, WXWORD id);
+
+#if wxUSE_OWNER_DRAWN
+    bool MSWOnMeasure(WXMEASUREITEMSTRUCT *item);
+    bool MSWOnDraw(WXDRAWITEMSTRUCT *item);
+
+    // plug-in for derived classes
+    virtual wxOwnerDrawn *CreateItem(size_t n);
+
+    // allows to get the item and use SetXXX functions to set it's appearance
+    wxOwnerDrawn *GetItem(size_t n) const { return m_aItems[n]; }
+
+    // get the index of the given item
+    int GetItemIndex(wxOwnerDrawn *item) const { return m_aItems.Index(item); }
+#endif // wxUSE_OWNER_DRAWN
+
+    virtual void Append(const wxString& item);
+    virtual void Append(const wxString& item, void *clientData);
+    virtual void Set(int n, const wxString* choices, void **clientData = NULL);
+    virtual int FindString(const wxString& s) const ;
+    virtual void Clear();
+    virtual void SetSelection(int n, bool select = TRUE);
+
+    virtual void Deselect(int n);
+
+    // For single choice list item only
+    virtual int GetSelection() const ;
+    virtual void Delete(int n);
+    virtual void *GetClientData(int n) const ;
+    virtual void SetClientData(int n, void *clientData);
+    virtual void SetString(int n, const wxString& s);
+
+    // For single or multiple choice list item
+    virtual int GetSelections(wxArrayInt& aSelections) const;
+    virtual bool Selected(int n) const ;
+    virtual wxString GetString(int n) const ;
+
+    // Set the specified item at the first visible item
+    // or scroll to max range.
+    virtual void SetFirstItem(int n) ;
+    virtual void SetFirstItem(const wxString& s) ;
+
+    virtual void InsertItems(int nItems, const wxString items[], int pos);
+
+    virtual wxString GetStringSelection() const ;
+    virtual bool SetStringSelection(const wxString& s, bool flag = TRUE);
+    virtual int Number() const ;
+
+    void Command(wxCommandEvent& event);
+
+    // Windows-specific code to set the horizontal extent of
+    // the listbox, if necessary. If s is non-NULL, it's
+    // used to calculate the horizontal extent.
+    // Otherwise, all strings are used.
+    virtual void SetHorizontalExtent(const wxString& s = wxEmptyString);
+
+    virtual WXHBRUSH OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
+            WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
+
+    virtual long MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
+    virtual void SetupColours();
+
+protected:
+    int m_noItems;
+    int m_selected;
+
+#if wxUSE_OWNER_DRAWN
+    // control items
+    wxListBoxItemsArray m_aItems;
+#endif
+
+    virtual void DoSetSize(int x, int y,
+                           int width, int height,
+                           int sizeFlags = wxSIZE_AUTO);
+};
+
+#endif
+    // _WX_LISTBOX_H_

include/wx/msw/notebook.h

@@ -0,0 +1,173 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        msw/notebook.h
+// Purpose:     MSW/GTK compatible notebook (a.k.a. property sheet)
+// Author:      Robert Roebling
+// Modified by: Vadim Zeitlin for Windows version
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart and Markus Holzem
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _NOTEBOOK_H
+#define _NOTEBOOK_H
+
+#ifdef __GNUG__
+  #pragma interface "notebook.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+#ifndef   _DYNARRAY_H
+  #include <wx/dynarray.h>
+#endif  //_DYNARRAY_H
+
+// ----------------------------------------------------------------------------
+// types
+// ----------------------------------------------------------------------------
+
+// fwd declarations
+class WXDLLEXPORT wxImageList;
+class WXDLLEXPORT wxWindow;
+
+// array of notebook pages
+typedef wxWindow WXDLLEXPORT wxNotebookPage;  // so far, any window can be a page
+
+#undef WXDLLEXPORTLOCAL
+#define WXDLLEXPORTLOCAL WXDLLEXPORT
+
+WX_DEFINE_ARRAY(wxNotebookPage *, wxArrayPages);
+
+#undef  WXDLLEXPORTLOCAL
+#define WXDLLEXPORTLOCAL
+
+// ----------------------------------------------------------------------------
+// wxNotebook
+// ----------------------------------------------------------------------------
+
+// FIXME this class should really derive from wxTabCtrl, but the interface is not
+//       exactly the same, so I can't do it right now and instead we reimplement
+//       part of wxTabCtrl here
+class WXDLLEXPORT wxNotebook : public wxControl
+{
+public:
+  // ctors
+  // -----
+    // default for dynamic class
+  wxNotebook();
+    // the same arguments as for wxControl (@@@ any special styles?)
+  wxNotebook(wxWindow *parent,
+             wxWindowID id,
+             const wxPoint& pos = wxDefaultPosition,
+             const wxSize& size = wxDefaultSize,
+             long style = 0,
+             const wxString& name = "notebook");
+    // Create() function
+  bool Create(wxWindow *parent,
+              wxWindowID id,
+              const wxPoint& pos = wxDefaultPosition,
+              const wxSize& size = wxDefaultSize,
+              long style = 0,
+              const wxString& name = "notebook");
+    // dtor
+  ~wxNotebook();
+
+  // accessors
+  // ---------
+    // get number of pages in the dialog
+  int GetPageCount() const;
+
+    // set the currently selected page, return the index of the previously
+    // selected one (or -1 on error)
+    // NB: this function will _not_ generate wxEVT_NOTEBOOK_PAGE_xxx events
+  int SetSelection(int nPage);
+    // cycle thru the tabs
+  void AdvanceSelection(bool bForward = TRUE);
+    // get the currently selected page
+  int GetSelection() const { return m_nSelection; }
+
+    // set/get the title of a page
+  bool SetPageText(int nPage, const wxString& strText);
+  wxString GetPageText(int nPage) const;
+
+  // image list stuff: each page may have an image associated with it. All
+  // the images belong to an image list, so you have to
+  // 1) create an image list
+  // 2) associate it with the notebook
+  // 3) set for each page it's image
+    // associate image list with a control
+  void SetImageList(wxImageList* imageList);
+    // get pointer (may be NULL) to the associated image list
+  wxImageList* GetImageList() const { return m_pImageList; }
+
+    // sets/returns item's image index in the current image list
+  int  GetPageImage(int nPage) const;
+  bool SetPageImage(int nPage, int nImage);
+
+    // currently it's always 1 because wxGTK doesn't support multi-row
+    // tab controls
+  int GetRowCount() const;
+
+  // control the appearance of the notebook pages
+    // set the size (the same for all pages)
+  void SetPageSize(const wxSize& size);
+    // set the padding between tabs (in pixels)
+  void SetPadding(const wxSize& padding);
+
+  // operations
+  // ----------
+    // remove one page from the notebook
+  bool DeletePage(int nPage);
+    // remove one page from the notebook, without deleting
+  bool RemovePage(int nPage);
+    // remove all pages
+  bool DeleteAllPages();
+    // adds a new page to the notebook (it will be deleted ny the notebook,
+    // don't delete it yourself). If bSelect, this page becomes active.
+  bool AddPage(wxNotebookPage *pPage,
+               const wxString& strText,
+               bool bSelect = FALSE,
+               int imageId = -1);
+    // the same as AddPage(), but adds it at the specified position
+  bool InsertPage(int nPage,
+                  wxNotebookPage *pPage,
+                  const wxString& strText,
+                  bool bSelect = FALSE,
+                  int imageId = -1);
+    // get the panel which represents the given page
+  wxNotebookPage *GetPage(int nPage) { return m_aPages[nPage]; }
+
+    // Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH
+    // style.
+  void SetTabSize(const wxSize& sz);
+
+  // callbacks
+  // ---------
+  void OnSize(wxSizeEvent& event);
+  void OnSelChange(wxNotebookEvent& event);
+  void OnSetFocus(wxFocusEvent& event);
+  void OnNavigationKey(wxNavigationKeyEvent& event);
+
+  // base class virtuals
+  // -------------------
+  virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
+  virtual void SetConstraintSizes(bool recurse = TRUE);
+  virtual bool DoPhase(int nPhase);
+
+protected:
+  // common part of all ctors
+  void Init();
+
+  // helper functions
+  void ChangePage(int nOldSel, int nSel); // change pages
+
+  wxImageList  *m_pImageList; // we can have an associated image list
+  wxArrayPages  m_aPages;     // array of pages
+
+  int m_nSelection;           // the current selection (-1 if none)
+
+  DECLARE_DYNAMIC_CLASS(wxNotebook)
+  DECLARE_EVENT_TABLE()
+};
+
+#endif // _NOTEBOOK_H

include/wx/time.h

@@ -1,112 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        time.h
-// Purpose:     wxTime class, from NIHCL
-// Author:      Julian Smart, after K. E. Gorlen
-// Modified by:
-// Created:     01/02/97
-// RCS-ID:      $Id$
-// Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:     wxWindows licence
-/////////////////////////////////////////////////////////////////////////////
-
-#ifndef _WX_TIMEH__
-#define _WX_TIMEH__
-
-#include "wx/object.h"
-
-#if wxUSE_TIMEDATE
-
-#ifdef __GNUG__
-#pragma interface "time.h"
-#endif
-
-class WXDLLEXPORT wxDate;
-
-typedef unsigned short hourTy;
-typedef unsigned short minuteTy;
-typedef unsigned short secondTy;
-typedef unsigned long clockTy;
-
-class WXDLLEXPORT wxTime: public wxObject
-{
-        DECLARE_DYNAMIC_CLASS(wxTime)
-        
-public:                 // type definitions
-    enum tFormat { wx12h, wx24h };
-    enum tPrecision { wxStdMinSec, wxStdMin };
-private:
-    static tFormat      Format;
-    static tPrecision   Precision;
-
-    clockTy    sec;        /* seconds since 1/1/1901 */
-
-    bool IsDST() const;
-    wxTime GetLocalTime() const;
-private:        // static member functions
-    static wxTime GetLocalTime(const wxDate& date, hourTy h=0, minuteTy m=0, secondTy s=0);
-    static wxTime GetBeginDST(unsigned year);
-    static wxTime GetEndDST(unsigned year);
-public:
-    wxTime();             // current time 
-    wxTime(clockTy s)         { sec = s; }
-    void operator=(const wxTime& t)     { sec = t.sec; } // Ordering required for some compilers
-    wxTime(const wxTime& t)         { (*this) = t ; }
-    wxTime(hourTy h, minuteTy m, secondTy s =0, bool dst =FALSE);
-    wxTime(const wxDate&, hourTy h =0, minuteTy m =0, secondTy s=0, bool dst =FALSE);
-
-    // Convert to string
-#ifndef __SALFORDC__
-    operator wxChar * (void);
-    operator wxDate() const;
-#endif
-
-    bool operator<(const wxTime& t) const     { return sec < t.sec; }
-    bool operator<=(const wxTime& t) const    { return sec <= t.sec; }
-    bool operator>(const wxTime& t) const     { return sec > t.sec; }
-    bool operator>=(const wxTime& t) const    { return sec >= t.sec; }
-    bool operator==(const wxTime& t) const    { return sec == t.sec; }
-    bool operator!=(const wxTime& t) const    { return sec != t.sec; }
-    friend wxTime operator+(const wxTime& t, long s)    { return wxTime(t.sec+s); }
-    friend wxTime operator+(long s, const wxTime& t)    { return wxTime(t.sec+s); }
-    long operator-(const wxTime& t) const     { return sec - t.sec; }
-    wxTime operator-(long s) const    { return wxTime(sec-s); }
-    void operator+=(long s)     { sec += s; }
-    void operator-=(long s)     { sec -= s; }
-    bool IsBetween(const wxTime& a, const wxTime& b) const;
-
-    /// Get day
-    int GetDay() const;
-    /// Get month
-    int GetMonth() const;
-    /// Get year
-    int GetYear() const;
-    /// Get day of week (0=Sunday 6=Saturday)
-    int GetDayOfWeek() const;
-
-    hourTy GetHour() const;        // hour in local time
-    hourTy GetHourGMT() const;     // hour in GMT
-    minuteTy GetMinute() const;    // minute in local time
-    minuteTy GetMinuteGMT() const;     // minute in GMT
-    secondTy GetSecond() const;    // second in local time or GMT
-    clockTy GetSeconds() const     { return sec; }
-    secondTy GetSecondGMT() const ;
-    wxTime Max(const wxTime&) const;
-    wxTime Min(const wxTime&) const;
-    static void SetFormat(const tFormat lFormat = wx12h,
-                  const tPrecision lPrecision = wxStdMinSec);
-    wxChar *FormatTime() const;
-/*
-    virtual int compare(const Object&) const;
-    virtual void deepenShallowCopy();       // {}
-    virtual unsigned hash() const;
-    virtual bool isEqual(const Object&) const;
-    virtual void printOn(ostream& strm =cout) const;
-    virtual const Class* species() const;
-*/
-};
-
-#endif
-  // wxUSE_TIMEDATE
-#endif
-    // _WX_TIMEH__
-

src/common/date.cpp

@@ -1,656 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        date.cpp
-// Purpose:     wxDate class
-// Author:
-//    Originally inspired by Steve Marcus (CIS 72007,1233)  6/16/91
-//    Enhanced by Eric Simon (CIS 70540,1522)               6/29/91
-//    Further Enhanced by Chris Hill (CIS 72030,2606)       7/11/91
-//    Still Further Enhanced by Hill & Simon  v3.10         8/05/91
-//    Version 4 by Charles D. Price                         6/27/92
-//    Integrated into wxWindows by Julian Smart             9th July 1995
-// Modified by:
-// Created:     01/02/97
-// RCS-ID:      $Id$
-// Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:     wxWindows licence
-/////////////////////////////////////////////////////////////////////////////
-
-#ifdef __GNUG__
-#pragma implementation "date.h"
-#endif
-
-// For compilers that support precompilation, includes "wx.h".
-#include "wx/wxprec.h"
-
-#ifdef __BORLANDC__
-  #pragma hdrstop
-#endif
-
-#if wxUSE_TIMEDATE
-
-#include "wx/date.h"
-#include "wx/intl.h"
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include "wx/ioswrap.h"
-
-#include <time.h>
-#include <string.h>
-
-#define ABBR_LENGTH 3
-
-static const wxChar *dayname[] = {
-    wxT("Sunday"), wxT("Monday"), wxT("Tuesday"), wxT("Wednesday"),
-    wxT("Thursday"), wxT("Friday"), wxT("Saturday")
-};
-
-static const wxChar *mname[] = {
-    wxT("January"), wxT("February"), wxT("March"), wxT("April"), wxT("May"), wxT("June"),
-    wxT("July"), wxT("August"), wxT("September"), wxT("October"), wxT("November"), wxT("December")
-};
-
-static int GauDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-IMPLEMENT_DYNAMIC_CLASS(wxDate, wxObject)
-
-    ////////////////////////////////////////////////////////////
-    // Constructors
-    ////////////////////////////////////////////////////////////
-
-wxDate::wxDate()
-{
-    DisplayFormat=wxMDY;
-    DisplayOptions='\0';
-    month = day = year = day_of_week = 0;
-    julian = 0;
-}
-
-wxDate::wxDate (long j) : julian(j)
-{
-    DisplayFormat=wxMDY;
-    DisplayOptions='\0';
-    julian_to_mdy ();
-}
-
-wxDate::wxDate (int m, int d, int y) : month(m), day(d), year(y)
-{
-    DisplayFormat=wxMDY;
-    DisplayOptions='\0';
-    mdy_to_julian ();
-}
-
-wxDate::wxDate (const wxString& dat)
-{
-    DisplayFormat=wxMDY;
-    DisplayOptions='\0';
-    if (wxStrcmp(dat, wxT("TODAY")) == 0 || wxStrcmp(dat, wxT("today")) == 0)
-    {
-        // Sets the current date
-        Set();
-    }
-    else
-    {
-        wxChar buf[100];
-        wxStrcpy(buf, dat);
-
-        wxChar *save_ptr, *token = wxStrtok(buf,wxT("/-"),&save_ptr);
-        month = wxAtoi(token);
-        day   = wxAtoi(wxStrtok((wxChar *) NULL,wxT("/-"),&save_ptr));
-        year  = wxAtoi(wxStrtok((wxChar *) NULL,wxT(" "),&save_ptr));
-    }
-
-    mdy_to_julian ();
-}
-
-wxDate::wxDate (const wxDate &dt)
-{
-    DisplayFormat=dt.DisplayFormat;
-    DisplayOptions=dt.DisplayOptions;
-    month = dt.month;
-    day   = dt.day;
-    year  = dt.year;
-    mdy_to_julian ();
-}
-
-void wxDate::operator = (const wxDate &dt)
-{
-    DisplayFormat=dt.DisplayFormat;
-    DisplayOptions=dt.DisplayOptions;
-    month = dt.month;
-    day   = dt.day;
-    year  = dt.year;
-    mdy_to_julian (); // wxUSE_TIMEDATE
-}
-
-void wxDate::operator = (const wxString& dat)
-{
-    DisplayFormat=wxMDY;
-    DisplayOptions='\0';
-    if (wxStrcmp(dat, wxT("TODAY")) == 0 || wxStrcmp(dat, wxT("today")) == 0)
-    {
-        // Sets the current date
-        Set();
-    }
-    else
-    {
-        wxChar buf[100];
-        wxStrcpy(buf, dat);
-
-        wxChar *save_ptr, *token = wxStrtok(buf,wxT("/-"),&save_ptr);
-        month = wxAtoi(token);
-        day   = wxAtoi(wxStrtok((wxChar *) NULL,wxT("/-"),&save_ptr));
-        year  = wxAtoi(wxStrtok((wxChar *) NULL,wxT(" "),&save_ptr));
-    }
-
-    mdy_to_julian ();
-}
-
-//////////////////////////////////////////////////////////////
-// Conversion operations
-//////////////////////////////////////////////////////////////
-
-#ifndef __SALFORDC__
-wxDate::operator wxString( void )
-{
-    return FormatDate();
-}
-#endif
-
-//////////////////////////////////////////////////////////////
-// Date Arithmetic
-//////////////////////////////////////////////////////////////
-
-wxDate wxDate::operator + (long i)
-{
-    wxDate dp(julian + i);
-    return dp;
-}
-
-wxDate wxDate::operator + (int i)
-{
-    wxDate dp(julian + (long)i);
-    return dp;
-}
-
-wxDate wxDate::operator - (long i)
-{
-    wxDate dp(julian - i);
-    return dp;
-}
-
-wxDate wxDate::operator - (int i)
-{
-    wxDate dp(julian - (long)i);
-    return dp;
-}
-
-long wxDate::operator - (const wxDate &dt)
-{
-    return ( julian - dt.julian );
-}
-
-wxDate &wxDate::operator += (long i)
-{
-    julian += i;
-    julian_to_mdy();
-    return *this;
-}
-
-wxDate &wxDate::operator -= (long i)
-{
-    julian -= i;
-    julian_to_mdy();
-    return *this;
-}
-
-wxDate &wxDate::operator ++()
-{
-    julian++;
-    julian_to_mdy();
-    return *this;
-}
-
-wxDate &wxDate::operator ++(int)
-{
-    julian++;
-    julian_to_mdy();
-    return *this;
-}
-
-wxDate &wxDate::operator --()
-{
-    julian--;
-    julian_to_mdy();
-    return *this;
-}
-
-wxDate &wxDate::operator --(int)
-{
-    julian--;
-    julian_to_mdy();
-    return *this;
-}
-
-//////////////////////////////////////////////////////////////
-// Date comparison
-//////////////////////////////////////////////////////////////
-
-bool WXDLLEXPORT operator <  (const wxDate &dt1, const wxDate &dt2)
-{
-    return ( dt1.julian < dt2.julian );
-}
-
-bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2)
-{
-    return ( (dt1.julian == dt2.julian) || (dt1.julian < dt2.julian) );
-}
-
-bool WXDLLEXPORT operator >  (const wxDate &dt1, const wxDate &dt2)
-{
-    return ( dt1.julian > dt2.julian );
-}
-
-bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2)
-{
-    return ( (dt1.julian == dt2.julian) || (dt1.julian > dt2.julian) );
-}
-
-bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2)
-{
-    return ( dt1.julian == dt2.julian );
-}
-
-bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2)
-{
-    return ( dt1.julian != dt2.julian );
-}
-
-
-#if wxUSE_STD_IOSTREAM
-
-////////////////////////////////////////////////////////////////
-// Ostream operations
-////////////////////////////////////////////////////////////////
-
-ostream WXDLLEXPORT & operator << (ostream &os, const wxDate &dt)
-{
-    return os << dt.FormatDate().mb_str();
-}
-
-#endif
-
-//////////////////////////////////////////////////////////////
-// Conversion routines
-//////////////////////////////////////////////////////////////
-
-void wxDate::julian_to_wday (void)
-{
-    // Correction by Peter Stadel <peters@jetcity.com>
-    day_of_week = (int)((julian - 2) % 7L);
-/*
-    day_of_week = (int) ((julian + 2) % 7 + 1);
-*/
-}
-
-void wxDate::julian_to_mdy ()
-{
-    long a,b,c,d,e,z,alpha;
-    z = julian+1;
-    // dealing with Gregorian calendar reform
-    if (z < 2299161L)
-        a = z;
-    else {
-        alpha = (long) ((z-1867216.25) / 36524.25);
-        a = z + 1 + alpha - alpha/4;
-    }
-    b = ( a > 1721423 ? a + 1524 : a + 1158 );
-    c = (long) ((b - 122.1) / 365.25);
-    d = (long) (365.25 * c);
-    e = (long) ((b - d) / 30.6001);
-    day = (int)(b - d - (long)(30.6001 * e));
-    month = (int)((e < 13.5) ? e - 1 : e - 13);
-    year = (int)((month > 2.5 ) ? (c - 4716) : c - 4715);
-    julian_to_wday ();
-}
-
-void wxDate::mdy_to_julian (void)
-{
-    int a,b=0;
-    int work_month=month, work_day=day, work_year=year;
-    // correct for negative year
-    if (work_year < 0)
-        work_year++;
-    if (work_month <= 2)
-    { work_year--; work_month +=12; }
-
-    // deal with Gregorian calendar
-    if (work_year*10000. + work_month*100. + work_day >= 15821015.)
-    {
-        a = (int)(work_year/100.);
-        b = 2 - a + a/4;
-    }
-    julian = (long) (365.25*work_year) +
-        (long) (30.6001 * (work_month+1))  +  work_day + 1720994L + b;
-    julian_to_wday ();
-}
-
-////////////////////////////////////////////////////////////////
-// Format routine
-////////////////////////////////////////////////////////////////
-
-wxString wxDate::FormatDate (int type) const
-{
-    int actualType = type;
-    if (actualType == -1)
-        actualType = DisplayFormat;
-
-    wxChar buf[40];
-
-    memset( buf, '\0', sizeof(buf) );
-    switch ( actualType )
-    {
-        case wxDAY:
-            if ( (day_of_week < 1) || (day_of_week > 7) )
-                wxStrcpy(buf, _("invalid day"));
-            else
-                wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
-               (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
-            return wxString(buf);
-
-        case wxMONTH:
-            if ( (month < 1) || (month > 12) )
-                wxStrcpy(buf, _("invalid month"));
-            else
-                wxStrncpy( buf, wxGetTranslation(mname[month-1]),
-               (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
-            return wxString(buf);
-
-        case wxFULL:
-            if ( (month < 1) || (month > 12) || (day_of_week < 0) ||
-                    (day_of_week > 7) )
-            {
-                wxStrcpy(buf, _("invalid date"));
-                return wxString(buf);
-            }
-            wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
-               (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
-            wxStrcat( buf, wxT(", "));
-            wxStrncat( buf, wxGetTranslation(mname[month-1]),
-               (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
-            wxStrcat( buf, wxT(" "));
-            wxSprintf( buf+wxStrlen(buf), wxT("%d, %d"), day, abs(year) );
-            if (year < 0)
-                wxStrcat(buf,_(" B.C."));
-            return wxString(buf);
-
-        case wxEUROPEAN:
-            if ( (month < 1) || (month > 12) || (day_of_week < 0) ||
-                    (day_of_week > 7) )
-            {
-                wxStrcpy(buf, _("invalid date"));
-                return wxString(buf);
-            }
-            wxSprintf(buf,wxT("%d "),  day);
-            wxStrncat(buf, wxGetTranslation(mname[month-1]),
-                    (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
-            wxSprintf( buf+wxStrlen(buf), wxT(" %d"), abs(year) );
-            if (year < 0)
-                wxStrcat(buf, _(" B.C."));
-            return wxString(buf);
-
-        case wxMDY:
-        default:
-            if (day==0 || month==0 || year==0)
-                wxStrcpy(buf, _("invalid date"));
-            else
-                wxSprintf( buf+wxStrlen(buf), wxT("%1d/%1d/%02d"), month, day,
-               (DisplayOptions & wxNO_CENTURY) && (abs(year) > 1899)
-               ? (abs(year) - (abs(year) / 100 * 100))
-               : (abs(year))  );
-            return wxString(buf);
-    }
-}
-
-void wxDate::SetFormat( int format )
-{
-    DisplayFormat = format;
-}
-
-int wxDate::SetOption( int option, bool action )
-{
-    switch ( option )
-    {
-        case wxNO_CENTURY:
-            if ( action )
-                DisplayOptions |= wxNO_CENTURY;
-            else
-            {
-                DisplayOptions &= (~wxNO_CENTURY);
-            }
-            return 1;
-        case wxDATE_ABBR:
-            if ( action )
-                DisplayOptions |= wxDATE_ABBR;
-            else
-            {
-                DisplayOptions &= (~wxDATE_ABBR);
-            }
-            return 1;
-        default:
-            return 0;
-    }
-}
-
-///////////////////////////////////////////////////////////////
-//  Miscellaneous Routines
-///////////////////////////////////////////////////////////////
-
-long wxDate::GetJulianDate( void ) const
-{
-    return julian;
-}
-
-int wxDate::GetDayOfYear( void ) const
-{
-    wxDate temp( 1, 1, year );
-
-    return (int) (julian - temp.julian + 1);
-}
-
-
-bool wxDate::IsLeapYear( void ) const
-{
-    return  ( (year >= 1582) ?
-            (year % 4 == 0  &&  year % 100 != 0  ||  year % 400 == 0 ):
-            (year % 4 == 0) );
-}
-
-// Version 4.0 Extension to Public Interface - CDP
-
-wxDate& wxDate::Set()
-{
-    //#ifdef __WXMSW__
-#if 0
-    struct _dosdate_t sDate;
-    _dos_getdate(&sDate);
-
-    month = sDate.month;
-    day   = sDate.day;
-    year  = sDate.year;
-
-    mdy_to_julian();
-#else
-    time_t now = time((time_t *) NULL);
-    struct tm *localTime = localtime(&now);
-
-    month = localTime->tm_mon + 1;
-    day = localTime->tm_mday;
-    year = localTime->tm_year + 1900;
-
-    mdy_to_julian ();
-#endif
-    return *this;
-}
-
-wxDate& wxDate::Set(
-        int  nMonth,
-        int  nDay,
-        int  nYear)
-{
-    month = nMonth;
-    year  = nYear < 0 ? 9999 : nYear;
-    year  = nYear > 9999 ? 0 : nYear;
-    day   = nDay < GetDaysInMonth() ? nDay : GetDaysInMonth();
-
-    mdy_to_julian();
-    return *this;
-}
-
-wxDate &
-wxDate::Set(long j)
-{
-    julian = j;
-
-    julian_to_mdy();
-    return *this;
-}
-
-
-int wxDate::GetDaysInMonth()
-{
-    return GauDays[month-1] + (month==2 && IsLeapYear());
-}
-
-int wxDate::GetFirstDayOfMonth() const
-{
-    return wxDate(month, 1, year).GetDayOfWeek();
-}
-
-int wxDate::GetDay() const
-{
-    return day;
-}
-
-int wxDate::GetDayOfWeek() const
-{
-    return day_of_week;
-}
-
-int wxDate::GetYear() const
-{
-    return year;
-}
-
-int wxDate::GetMonth() const
-{
-    return month;
-}
-
-wxDate& wxDate::AddWeeks(int nCount)
-{
-    Set(julian + (long)nCount*7);
-    return *this;
-}
-
-wxDate& wxDate::AddMonths(int nCount)
-{
-    month += nCount;
-
-    if (month < 1) {
-        month = 12;
-        year--;
-    }
-
-    if (month > 12) {
-        month = 1;
-        year++;
-    }
-    mdy_to_julian();
-    return *this;
-}
-
-wxDate& wxDate::AddYears(int nCount)
-{
-    year += nCount;
-    mdy_to_julian();
-    return *this;
-}
-
-int wxDate::GetWeekOfMonth()
-{
-    // Abs day includes the days from previous month that fills up
-    // the begin. of the week.
-    int nAbsDay = day + GetFirstDayOfMonth()-1;
-    return (nAbsDay-GetDayOfWeek())/7 + 1;
-}
-
-int wxDate::GetWeekOfYear()
-{
-    wxDate   doTemp(1, 1, year);
-    return (int)(((julian - doTemp.julian+1)/7) + 1);
-}
-
-wxDate wxDate::GetMonthStart()
-{
-    return(wxDate(month, 1, year));
-}
-
-wxDate wxDate::GetMonthEnd()
-{
-    return(wxDate(month+1, 1, year)-1);
-}
-
-wxDate wxDate::GetYearStart()
-{
-    return(wxDate(1, 1, year));
-}
-
-wxDate wxDate::GetYearEnd()
-{
-    return(wxDate(1, 1, year+1)-1);
-}
-
-wxString wxDate::GetMonthName()
-{
-    return(FormatDate(wxMONTH));
-}
-
-wxString wxDate::GetDayOfWeekName()
-{
-    return(FormatDate(wxDAY));
-}
-
-bool wxDate::IsBetween(const wxDate& first, const wxDate& second) const
-{
-    return (julian >= first.julian && julian <= second.julian);
-}
-
-// This function is from NIHCL
-wxDate wxDate::Previous(int dayOfWeek) const
-{
-    int this_day_Of_Week, desired_day_Of_Week;
-    long j;
-
-    //      Set the desired and current day of week to start at 0 (Monday)
-    //      and end at 6 (Sunday).
-
-    desired_day_Of_Week = dayOfWeek - 1; // These functions return a value
-    this_day_Of_Week    = GetDayOfWeek() - 1;            // from 1-7.  Subtract 1 for 0-6.
-    j = julian;
-
-    //      Have to determine how many days difference from current day back to
-    //      desired, if any.  Special calculation under the 'if' statement to
-    //      effect the wraparound counting from Monday (0) back to Sunday (6).
-
-    if (desired_day_Of_Week > this_day_Of_Week)
-        this_day_Of_Week += 7 - desired_day_Of_Week;
-    else
-        this_day_Of_Week -= desired_day_Of_Week;
-    j -= this_day_Of_Week; // Adjust j to set it at the desired day of week.
-    return wxDate(j);
-}
-
-#endif

src/common/time.cpp

@@ -1,447 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        time.cpp
-// Purpose:     wxTime class, from NIHCL
-// Author:      Julian Smart, after K. E. Gorlen
-// Modified by:
-// Created:     04/01/98
-// RCS-ID:      $Id$
-// Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-#ifdef __GNUG__
-#pragma implementation "time.h"
-#endif
-
-/*
-Provides an object that represents a Time, stored as the number of
-seconds since January 1, 1901, GMT.
-*/
-
-// For compilers that support precompilation, includes "wx.h".
-#include "wx/wxprec.h"
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "wx/setup.h"
-
-#if wxUSE_TIMEDATE
-
-#include "wx/time.h"
-#include "wx/date.h"
-#include "wx/utils.h"
-#include "wx/intl.h"
-
-#if wxUSE_STD_IOSTREAM
-    #include "wx/ioswrap.h"
-    #if wxUSE_IOSTREAMH
-        #include <iomanip.h>
-    #else
-        #include <iomanip>
-    #endif
-#endif
-
-#include <string.h>
-#include <time.h>
-
-IMPLEMENT_DYNAMIC_CLASS(wxTime, wxObject)
-
-
-#ifndef WX_TIMEZONE
-    #define WX_TIMEZONE _timezone
-#endif
-
-extern long wxGetUTCTime(void);
-bool wxGetTZandDST(long *timeZone, int *dstObserved)
-{
-  time_t now;
-  struct tm *tm;
-
-  now = time((time_t *) NULL);
-
-  if (now != (time_t)-1)
-  {
-    tm = localtime(&now);
-
-    if ((tm) && (tm->tm_isdst > 0))
-      *dstObserved = 1;
-  }
-  *timeZone = WX_TIMEZONE;
-
-  return TRUE;
-}
-
-
-static long TIME_ZONE;          /* seconds west of GMT */
-static int DST_OBSERVED;        /* flags U.S. daylight saving time observed */
-
-static bool wxTimeInitialized = FALSE;
-
-wxTime::tFormat    wxTime::Format    = wxTime::wx12h;
-wxTime::tPrecision wxTime::Precision  = wxTime::wxStdMinSec;
-
-static const unsigned long seconds_in_day = 24*60*60L;
-static const wxDate refDate(1,1,1901);
-// static const wxDate maxDate(49709L);      /* ((2**32)-1)/seconds_in_day -1 */
-
-wxTime wxTime::GetLocalTime(const wxDate& date, hourTy h, minuteTy m, secondTy s)
-/*
-      Return a local wxTime for the specified Standard Time date, hour, minute,
-      and second.
-*/
-{
-  if (!wxTimeInitialized)
-  {
-   wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
-   wxTimeInitialized = TRUE;
-  }
-/*
-      if (!date.IsBetween(refDate,maxDate))
-           setError(NIHCL_DATERANGE,DEFAULT,
-                date.dayOfMonth(),date.nameOfMonth(),date.year());
-*/
-  // The following line causes an error in GCC 2.1
-//   long daysBetween = date-refDate;
-  // ... but this seems to get round it.
-  wxDate tmp1(date);
-  wxDate tmp2(refDate);
-  long daysBetween = tmp1 - tmp2;
-
-  return wxTime(seconds_in_day*daysBetween + 60*60L*h + 60*m + s);
-}
-
-wxTime::wxTime()
-/*
-      Construct a wxTime for this instant.
-*/
-{
-  if (!wxTimeInitialized)
-  {
-   wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
-   wxTimeInitialized = TRUE;
-  }
-  sec = wxGetUTCTime();
-#ifdef __SALFORDC__
-  sec += (unsigned long) 2177452800;     /* seconds from 1/1/01 to 1/1/70 */
-#else
-  sec += 2177452800UL;     /* seconds from 1/1/01 to 1/1/70 */
-#endif
-}
-
-wxTime::wxTime(hourTy h, minuteTy m, secondTy s, bool dst)
-/*
-      Construct a wxTime for today at the specified (local) hour, minute, and
-      second.
-*/
-{
-  if (!wxTimeInitialized)
-  {
-   wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
-   wxTimeInitialized = TRUE;
-  }
-
-  sec = wxTime(wxDate(),h,m,s,dst).sec;
-}
-
-
-wxTime::wxTime(const wxDate& date, hourTy h, minuteTy m, secondTy s, bool dst)
-/*
-        Construct a wxTime for the specified (local) Date, hour, minute, and
-        second.
-*/
-{
-  if (!wxTimeInitialized)
-  {
-    wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
-   wxTimeInitialized = TRUE;
-  }
-  sec = GetLocalTime(date,h,m,s).sec-3600;
-  if (IsDST())
-  {
-    sec += 3600;
-    if (IsDST() || dst) sec -= 3600;
-  }
-  else
-  {
-    sec += 3600;
-/*
-                if (IsDST()) setError(NIHCL_BADTIME,DEFAULT,
-                date.dayOfMonth(),date.nameOfMonth(),date.year(),
-                h,m,s,(dst?_("DST"):""));
-*/
-  }
-  sec += TIME_ZONE;                               // adjust to GMT
-}
-
-#ifndef __SALFORDC__
-wxTime::operator wxDate() const
-/*
-      Convert a wxTime to a local wxDate
-*/
-{
-//      return wxDate((int)(GetLocalTime().sec/seconds_in_day));     4.2 cc bug
-      long daycount = (long)(GetLocalTime().sec/seconds_in_day);
-
-        wxDate date(1,1,1901);
-        date += daycount;
-        return date;
-}
-#endif
-
-bool wxTime::IsBetween(const wxTime& a, const wxTime& b) const
-{
-        return *this >= a && *this <= b;
-}
-
-hourTy wxTime::GetHour() const
-/*
-      Return the hour of this wxTime in local time; i.e., adjust for
-        time zone and Daylight Savings Time.
-*/
-{
-      return GetLocalTime().GetHourGMT();
-}
-
-hourTy wxTime::GetHourGMT() const
-/*
-        Return the hour of this Time in GMT.
-*/
-{
-      return (hourTy)((sec % 86400) / 3600);
-}
-
-wxTime wxTime::GetBeginDST(unsigned year)
-/*
-      Return the local Standard Time at which Daylight Savings Time
-        begins in the specified year.
-*/
-{
-        // Previous Sunday
-        wxTime DSTtime(GetLocalTime(wxDate(3,31,year).Previous(1)+7,2));
-        if (year<=1986) {
-                // Previous Sunday
-           DSTtime = GetLocalTime(wxDate(4,30,year).Previous(1),2);
-           if (year==1974) DSTtime = GetLocalTime(wxDate(1,6,1974),2);
-                if (year==1975) DSTtime = GetLocalTime(wxDate(2,23,1975),2);
-        }
-        return DSTtime;
-}
-
-wxTime wxTime::GetEndDST(unsigned year)
-/*
-        Return the local Standard Time at which Daylight Savings Time
-        ends in the specified year.
-*/
-{
-      wxTime STDtime(GetLocalTime(wxDate(10,31,year).Previous(1),2-1));
-      return STDtime;
-}
-
-bool wxTime::IsDST() const
-/*
-        Return TRUE if this local Standard Time should be adjusted
-        for Daylight Savings Time.
-*/
-{
-        long daycount = (long)(sec/seconds_in_day);
-
-        // At this point, daycount is the number of days from 1/1/1901.
-      // Need to convert to julian date (which starts at 1/1/4713 B.C.)
-      wxDate date(1,1,1901);
-        date += daycount;
-
-        unsigned year = date.GetYear();
-      if (DST_OBSERVED)
-        {
-                if (*this >= GetBeginDST(year))
-                        if (*this < GetEndDST(year)) return TRUE;
-        }
-        return FALSE;
-}
-
-wxTime wxTime::GetLocalTime() const
-/*
-        Adjusts this GM Time for local time zone and Daylight Savings Time.
-*/
-{
-      wxTime local_time(sec-TIME_ZONE);
-        if (local_time.IsDST()) local_time.sec += 3600;
-        return local_time;
-}
-
-minuteTy wxTime::GetMinute() const
-/*
-        Return the minute of this wxTime in local time; i.e., adjust
-      for time zone and Daylight Savings Time.
-*/
-{
-        return GetLocalTime().GetMinuteGMT();
-}
-
-minuteTy wxTime::GetMinuteGMT() const
-/*
-        Return the minute of this wxTime in GMT.
-*/
-{
-      return (minuteTy)(((sec % 86400) % 3600) / 60);
-}
-
-secondTy wxTime::GetSecond() const
-/*
-        Return the second of this wxTime.
-*/
-{
-      return (secondTy)(((sec % 86400) % 3600) % 60);
-}
-
-secondTy wxTime::GetSecondGMT() const
-/*
-        Return the minute of this wxTime in GMT.
-*/
-{
-        return (secondTy)(((sec % 86400) % 3600) % 60);
-}
-
-int wxTime::GetDay() const
-{
-    wxDate da((wxDate) *this);
-    return da.GetDay();
-}
-
-int wxTime::GetDayOfWeek() const
-{
-    wxDate da((wxDate) *this);
-    return da.GetDayOfWeek();
-}
-
-int wxTime::GetMonth() const
-{
-    wxDate da((wxDate) *this);
-    return da.GetMonth();
-}
-
-int wxTime::GetYear() const
-{
-    wxDate da((wxDate) *this);
-    return da.GetYear();
-}
-
-wxTime wxTime::Max(const wxTime& t) const
-{
-        if (t < *this) return *this;
-        return t;
-}
-
-wxTime wxTime::Min(const wxTime& t) const
-{
-        if (t > *this) return *this;
-      return t;
-}
-
-#ifndef __SALFORDC__
-wxTime::operator wxChar *(void)
-{
-  return FormatTime();
-}
-#endif
-
-void wxTime::SetFormat(const wxTime::tFormat lFormat,
-                const wxTime::tPrecision lPrecision) {
-
-  wxTime::Format    = lFormat;
-  wxTime::Precision  = lPrecision;
-}
-
-wxChar *wxTime::FormatTime() const {
-  static wxChar  timeBuf[30];
-  unsigned    hh(GetHour());
-
-  switch (Format) {
-  case wx12h:
-    hh  -= 12;
-    break;
-  case wx24h:
-    break;
-  }
-
-  switch (Precision) {
-  case wxStdMinSec:
-    wxSprintf(timeBuf,wxT("%2d:%02d:%02d"),hh,GetMinute(),GetSecond());
-    break;
-  case wxStdMin:
-    wxSprintf(timeBuf,wxT("%2d:%02d"),hh,GetMinute());
-    break;
-  }
-
-  if (Format == wx12h)
-    if (GetHour() <= 12)
-      wxStrcat(timeBuf,_("am"));
-    else
-      wxStrcat(timeBuf,_("pm"));
-
-  return timeBuf;
-}
-
-/*
-int wxTime::compare(const Object& ob) const
-{
-      assertArgSpecies(ob,classDesc,"compare");
-        register clockTy t = castdown(ob).sec;
-        if (sec < t) return -1;
-        if (sec > t) return 1;
-        return 0;
-}
-
-void wxTime::deepenShallowCopy()  {}
-
-unsigned wxTime::hash() const     { return sec; }
-
-bool wxTime::isEqual(const Object& ob) const
-{
-        return ob.isSpecies(classDesc) && *this==castdown(ob);
-}
-
-const Class* wxTime::species() const { return &classDesc; }
-
-void wxTime::printOn(ostream& strm) const
-{
-        register unsigned hh = GetHour();
-        wxDate(*this).printOn(strm);
-        strm << ' ' << ((hh <= 12) ? hh : hh-12) << ':'
-             << setfill('0') << setw(2) << GetMinute() << ':'
-         << setfill('0') << setw(2) << GetSecond() << ' ';
-        if (hh < 12) strm << _("am");
-        else strm << _("pm");
-}
-
-wxTime::wxTime(OIOin& strm)
-      : BASE(strm)
-{
-      unsigned long usec;
-      strm >> sec >> usec;
-}
-
-void wxTime::storer(OIOout& strm) const
-{
-        BASE::storer(strm);
-        strm << sec << 0l;
-}
-
-
-wxTime::wxTime(OIOifd& fd)
-      : BASE(fd)
-{
-      unsigned long usec;
-      fd >> sec >> usec;
-}
-
-void wxTime::storer(OIOofd& fd) const
-{
-      BASE::storer(fd);
-      fd << sec << 0l;
-}
-*/
-
-#endif