This commit was manufactured by cvs2svn to create tag 'OLD_WXLIST'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/OLD_WXLIST@735 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/list.h

@@ -0,0 +1,148 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        list.h
+// Purpose:     wxList, wxStringList classes
+// Author:      Julian Smart
+// Modified by:
+// Created:     29/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 Julian Smart
+// Licence:   	wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_LISTH__
+#define _WX_LISTH__
+
+#ifdef __GNUG__
+#pragma interface "list.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/object.h"
+
+class WXDLLEXPORT wxList;
+
+#define wxKEY_NONE    0
+#define wxKEY_INTEGER 1
+#define wxKEY_STRING  2
+class WXDLLEXPORT wxNode: public wxObject
+{
+  DECLARE_DYNAMIC_CLASS(wxNode)
+ private:
+ 
+  wxObject *data;
+  wxNode *next;
+  wxNode *previous;
+
+ public:
+  wxList *list;
+
+  // Optional key stuff
+  union
+  {
+    long integer;
+    char *string;
+  } key;
+
+  wxNode(wxList *the_list = (wxList *) NULL, wxNode *last_one = (wxNode *) NULL, wxNode *next_one = (wxNode *) NULL, wxObject *object = (wxObject *) NULL);
+  wxNode(wxList *the_list, wxNode *last_one, wxNode *next_one,
+         wxObject *object, long the_key);
+  wxNode(wxList *the_list, wxNode *last_one, wxNode *next_one,
+         wxObject *object, const char *the_key);
+  ~wxNode(void);
+
+  inline wxNode *Next(void) const { return next; }
+  inline wxNode *Previous(void) const { return previous; }
+  inline wxObject *Data(void) const { return (wxObject *)data; }
+  inline void SetData(wxObject *the_data) { data = the_data; }
+};
+
+// type of compare function for list sort operation (as in 'qsort')
+typedef int (*wxSortCompareFunction)(const void *elem1, const void *elem2);
+typedef int (*wxListIterateFunction)(wxObject *o);
+
+class WXDLLEXPORT wxList: public wxObject
+{
+  DECLARE_DYNAMIC_CLASS(wxList)
+
+ public:
+  int n;
+  int destroy_data;
+  wxNode *first_node;
+  wxNode *last_node;
+  unsigned int key_type;
+
+  wxList(void);
+  wxList(const unsigned int the_key_type);
+  wxList(int N, wxObject *Objects[]);
+  wxList(wxObject *object, ...);
+  
+  ~wxList(void);
+
+  inline int Number(void) const { return n; }
+  inline int GetCount(void) const { return n; }
+
+  // Append to end of list
+  wxNode *Append(wxObject *object);
+
+  // Insert at front of list
+  wxNode *Insert(wxObject *object);
+
+  // Insert before given node
+  wxNode *Insert(wxNode *position, wxObject *object);
+
+  // Keyed append
+  wxNode *Append(long key, wxObject *object);
+  wxNode *Append(const char *key, wxObject *object);
+
+  bool DeleteNode(wxNode *node);
+  bool DeleteObject(wxObject *object);  // Finds object pointer and
+                                        // deletes node (and object if
+                                        // DeleteContents is on)
+  virtual void Clear(void);             // Delete all nodes
+
+  inline wxNode *First(void) const { return first_node; }
+  inline wxNode *Last(void) const { return last_node; }
+  wxNode *Nth(int i) const;                  // nth node counting from 0
+
+  // Keyed search
+  virtual wxNode *Find(long key) const;
+  virtual wxNode *Find(const char *key) const;
+
+  virtual wxNode *Member(wxObject *object) const;
+
+  inline void DeleteContents(int destroy) { destroy_data = destroy; }
+                                             // Instruct it to destroy user data
+                                             // when deleting nodes
+  // this function allows the sorting of arbitrary lists by giving
+  // a function to compare two list elements.
+  void Sort(const wxSortCompareFunction compfunc);
+
+  wxObject *FirstThat(wxListIterateFunction func);
+  void ForEach(wxListIterateFunction func);
+  wxObject *LastThat(wxListIterateFunction func);
+};
+
+// String list class. N.B. this always copies strings
+// with Add and deletes them itself.
+class WXDLLEXPORT wxStringList: public wxList
+{
+  DECLARE_DYNAMIC_CLASS(wxStringList)
+
+ public:
+  wxStringList(void);
+  wxStringList(const wxStringList& list);
+  wxStringList(const char *first ...);
+  ~wxStringList(void);
+
+  virtual wxNode *Add(const char *s);
+  virtual void Delete(const char *s);
+  virtual char **ListToArray(bool new_copies = FALSE) const;
+  virtual void Sort(void);
+  virtual bool Member(const char *s) const;
+  virtual void Clear(void);
+  void operator= (const wxStringList& list);
+  char* operator[] (int i) const;
+};
+
+#endif
+    // _WX_LISTH__

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/list.cpp

@@ -0,0 +1,639 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        list.cpp
+// Purpose:     wxList implementation
+// Author:      Julian Smart
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart and Markus Holzem
+// Licence:   	wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "list.h"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+#include "wx/defs.h"
+#include "wx/list.h"
+#include "wx/utils.h"
+#include <wx/intl.h>
+#endif
+
+// Sun CC compatibility (interference with xview/pkg.h, apparently...)
+#if defined(SUN_CC) && defined(__XVIEW__)
+#undef va_start
+#undef va_end
+#undef va_arg
+#undef va_list
+#endif
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxNode, wxObject)
+IMPLEMENT_DYNAMIC_CLASS(wxList, wxObject)
+IMPLEMENT_DYNAMIC_CLASS(wxStringList, wxList)
+#endif
+
+wxNode::wxNode (wxList * the_list, wxNode * last_one, wxNode * next_one,
+	wxObject * object)
+{
+  data = object;
+  previous = last_one;
+  next = next_one;
+  list = the_list;
+  key.string = (char *) NULL;
+
+  if (previous)
+    previous->next = this;
+
+  if (next)
+    next->previous = this;
+}
+
+// Keyed constructor
+wxNode::wxNode (wxList * the_list, wxNode * last_one, wxNode * next_one,
+	wxObject * object, long the_key)
+{
+  data = object;
+  previous = last_one;
+  next = next_one;
+  list = the_list;
+  key.integer = the_key;
+
+  if (previous)
+    previous->next = this;
+
+  if (next)
+    next->previous = this;
+}
+
+wxNode::wxNode (wxList * the_list, wxNode * last_one, wxNode * next_one,
+	wxObject * object, const char *the_key)
+{
+  data = object;
+  previous = last_one;
+  next = next_one;
+  list = the_list;
+  key.string = copystring (the_key);
+
+  if (previous)
+    previous->next = this;
+
+  if (next)
+    next->previous = this;
+}
+
+
+wxNode::~wxNode (void)
+{
+  if (list)
+    list->n--;
+
+  if (list && list->destroy_data)
+    delete data;
+
+  if (list && list->key_type == wxKEY_STRING && key.string)
+    delete[]key.string;
+
+  // Make next node point back to the previous node from here
+  if (next)
+    next->previous = previous;
+  else if (list)
+    // If there's a new end of list (deleting the last one)
+    // make sure the list knows about it.
+    list->last_node = previous;
+
+  // Make the previous node point to the next node from here
+  if (previous)
+    previous->next = next;
+
+  // Or if no previous node (start of list), make sure list points at
+  // the next node which becomes the first!.
+  else if (list)
+    list->first_node = next;
+}
+
+wxList::wxList (void)
+{
+  first_node = (wxNode *) NULL;
+  last_node = (wxNode *) NULL;
+  n = 0;
+  destroy_data = 0;
+  key_type = wxKEY_NONE;
+}
+
+wxList::wxList (int N, wxObject * Objects[])
+{
+  wxNode *last = (wxNode *) NULL;
+
+  int i;
+  for (i = 0; i < N; i++)
+    {
+      wxNode *next = new wxNode (this, last, (wxNode *) NULL, Objects[i]);
+      last = next;
+      if (i == 0)
+	first_node = next;
+    }
+  last_node = last;
+  n = N;
+  key_type = wxKEY_NONE;
+}
+
+wxList::wxList (const unsigned int the_key_type)
+{
+  n = 0;
+  destroy_data = 0;
+  first_node = (wxNode *) NULL;
+  last_node = (wxNode *) NULL;
+  key_type = the_key_type;
+}
+
+// Variable argument list, terminated by a zero
+wxList::wxList (wxObject * first_one...)
+{
+// #ifndef __SGI__
+  va_list ap;
+
+  va_start (ap, first_one);
+
+  wxNode *last = new wxNode (this, (wxNode *) NULL, (wxNode *) NULL, first_one);
+  first_node = last;
+  n = 1;
+
+  for (;;)
+    {
+      wxObject *object = va_arg (ap, wxObject *);
+//    if (object == NULL) // Doesn't work in Windows -- segment is non-zero for NULL!
+#ifdef __WXMSW__
+      if ((int) object == 0)
+#else
+      if ((long) object == 0)
+#endif
+	break;
+      else
+	{
+	  wxNode *node = new wxNode (this, last, (wxNode *) NULL, object);
+	  last = node;
+	  n++;
+	}
+    }
+  last_node = last;
+  va_end (ap);
+
+  destroy_data = 0;
+  key_type = wxKEY_NONE;
+/*
+#else
+  fprintf (stderr, "Error: cannot use variable-argument functions on SGI!\n");
+#endif
+*/
+}
+
+wxList::~wxList (void)
+{
+  wxNode *each = first_node;
+  while (each)
+    {
+      wxNode *next = each->Next ();
+      delete each;
+      each = next;
+    }
+}
+
+wxNode *wxList::Append(wxObject *object)
+{
+    wxNode *node = new wxNode(this, last_node, (wxNode *) NULL, object);
+    if (!first_node)
+      first_node = node;
+    last_node = node;
+    n ++;
+    return node;
+}
+
+wxNode *wxList::Nth (int i) const
+{
+  int j = 0;
+  for (wxNode * current = First (); current; current = current->Next ())
+    {
+      if (j++ == i)
+	return current;
+    }
+  return (wxNode *) NULL;			// No such element
+
+}
+
+wxNode *wxList::Find (long key) const
+{
+  wxNode *current = First();
+  while (current)
+  {
+    if (current->key.integer == key)
+      return current;
+    current = current->Next();
+  }
+    
+  return (wxNode *) NULL;			// Not found!
+}
+
+wxNode *wxList::Find (const char *key) const
+{
+  wxNode *current = First();
+  while (current)
+  {
+      if (!current->key.string)
+	{
+	  wxFatalError (_("wxList: string key not present, probably did not Append correctly!"));
+	  break;
+	}
+      if (strcmp (current->key.string, key) == 0)
+	return current;
+      current = current->Next();
+  }
+
+  return (wxNode *) NULL;			// Not found!
+
+}
+
+wxNode *wxList::Member (wxObject * object) const
+{
+  for (wxNode * current = First (); current; current = current->Next ())
+    {
+      wxObject *each = current->Data ();
+      if (each == object)
+	return current;
+    }
+  return (wxNode *) NULL;
+}
+
+bool wxList::DeleteNode (wxNode * node)
+{
+  if (node)
+    {
+      delete node;
+      return TRUE;
+    }
+  return FALSE;
+}
+
+bool wxList::DeleteObject (wxObject * object)
+{
+  // Search list for object
+  for (wxNode * current = first_node; current; current = current->Next ())
+    {
+      if (current->Data () == object)
+	{
+	  delete current;
+	  return TRUE;
+	}
+    }
+  return FALSE;			// Did not find the object
+
+}
+
+
+// Insert new node at front of list
+wxNode *wxList::Insert (wxObject * object)
+{
+  wxNode *node = new wxNode (this, (wxNode *) NULL, First (), object);
+  first_node = node;
+
+  if (!(node->Next ()))
+    last_node = node;
+
+  n++;
+  return node;
+}
+
+
+// Insert new node before given node.
+wxNode *wxList::Insert (wxNode * position, wxObject * object)
+{
+  wxNode *prev = (wxNode *) NULL;
+  if (position)
+    prev = position->Previous ();
+
+  wxNode *node = new wxNode (this, prev, position, object);
+  if (!first_node)
+    {
+      first_node = node;
+      last_node = node;
+    }
+  if (!prev)
+    first_node = node;
+
+  n++;
+  return node;
+}
+
+// Keyed append
+wxNode *wxList::Append (long key, wxObject * object)
+{
+  wxNode *node = new wxNode (this, last_node, (wxNode *) NULL, object, key);
+  if (!first_node)
+    first_node = node;
+  last_node = node;
+  n++;
+  return node;
+}
+
+wxNode *wxList::Append (const char *key, wxObject * object)
+{
+  wxNode *node = new wxNode (this, last_node, (wxNode *) NULL, object, key);
+  if (!first_node)
+    first_node = node;
+  last_node = node;
+  n++;
+  return node;
+}
+
+void wxList::Clear (void)
+{
+  wxNode *current = first_node;
+  while (current)
+    {
+      wxNode *next = current->Next ();
+      delete current;
+      current = next;
+    }
+  first_node = (wxNode *) NULL;
+  last_node = (wxNode *) NULL;
+  n = 0;
+}
+
+//Executes function F with all items present in the list
+void wxList::ForEach(wxListIterateFunction F)
+{
+  wxNode *each = first_node;
+  while (each)
+    { (*F)( each->Data ());
+      each = each->Next();
+    }
+}
+// Returns a pointer to the item which returns TRUE with function F
+// or NULL if no such item found
+wxObject *wxList::FirstThat(wxListIterateFunction F)
+{
+  wxNode *each = first_node;
+  while (each)
+    { if ((*F)( each->Data ())) return each->Data();
+      each = each->Next();
+    }
+  return (wxNode *) NULL;
+}
+// Like FirstThat, but proceeds from the end backward
+wxObject *wxList::LastThat(wxListIterateFunction F)
+{
+  wxNode *each = last_node;
+  while (each)
+    { if ((*F)( each->Data ())) return each->Data();
+      each = each->Previous();
+    }
+  return (wxNode *) NULL;
+}
+
+// (stefan.hammes@urz.uni-heidelberg.de)
+//
+// function for sorting lists. the concept is borrowed from 'qsort'.
+// by giving a sort function, arbitrary lists can be sorted.
+// method:
+// - put wxObject pointers into an array
+// - sort the array with qsort
+// - put back the sorted wxObject pointers into the list
+//
+// CAVE: the sort function receives pointers to wxObject pointers (wxObject **),
+//       so dereference right!
+// EXAMPLE:
+//   int listcompare(const void *arg1, const void *arg2)
+//   {
+//      return(compare(**(wxString **)arg1,
+//                     **(wxString **)arg2));
+//   }
+//
+//   void main()
+//   { 
+//     wxList list;
+//
+//     list.Append(new wxString("DEF"));
+//     list.Append(new wxString("GHI"));
+//     list.Append(new wxString("ABC"));
+//     list.Sort(listcompare);
+//   }
+
+void wxList::Sort(const wxSortCompareFunction compfunc)
+{
+  // allocate an array for the wxObject pointers of the list
+  const size_t num = Number();
+  wxObject **objArray = new wxObject *[num];
+  wxObject **objPtr = objArray;
+  
+  // go through the list and put the pointers into the array
+  wxNode *node = First();
+  while(node!=NULL){
+    *objPtr++ = node->Data();
+    node = node->Next();
+  }
+  // sort the array
+  qsort((void *)objArray,num,sizeof(wxObject *),compfunc);
+  // put the sorted pointers back into the list  
+  objPtr = objArray;
+  node = First();
+  while(node!=NULL){
+    node->SetData(*objPtr++);
+    node = node->Next();
+  }
+  // free the array
+  delete[] objArray;
+}
+
+/*
+ * String list
+ *
+ */
+
+wxStringList::wxStringList (void):
+wxList ()
+{
+}
+
+wxStringList::wxStringList (const wxStringList& list)
+{
+    (*this) = list;
+}
+
+// Variable argument list, terminated by a zero
+// Makes new storage for the strings
+wxStringList::wxStringList (const char *first...)
+{
+// #ifndef __SGI__
+  n = 0;
+  destroy_data = 0;
+  key_type = wxKEY_NONE;
+  first_node = (wxNode *) NULL;
+  last_node = (wxNode *) NULL;
+
+  if (!first)
+    return;
+
+  va_list ap;
+
+  va_start (ap, first);
+
+  wxNode *last = new wxNode (this, (wxNode *) NULL, (wxNode *) NULL, (wxObject *) copystring (first));
+  first_node = last;
+  n = 1;
+
+  for (;;)
+    {
+      char *s = va_arg (ap, char *);
+//    if (s == NULL)
+#ifdef __WXMSW__
+      if ((int) s == 0)
+#else
+      if ((long) s == 0)
+#endif
+	break;
+      else
+	{
+	  wxNode *node = new wxNode (this, last, (wxNode *) NULL, (wxObject *) copystring (s));
+	  last = node;
+	  n++;
+	}
+    }
+  last_node = last;
+  va_end (ap);
+/*
+#else
+  fprintf (stderr, "Error: cannot use variable-argument functions on SGI!\n");
+#endif
+*/
+}
+
+wxStringList::~wxStringList (void)
+{
+    Clear();
+}
+
+void wxStringList::Clear(void)
+{
+  wxNode *each = First();
+  while (each)
+    {
+      char *s = (char *) each->Data ();
+      delete[]s;
+      wxNode *next = each->Next ();
+      delete each;
+      each = next;
+    }
+  wxList::Clear();
+}
+
+wxNode *wxStringList::Add (const char *s)
+{
+  return Append ((wxObject *) (copystring (s)));
+}
+
+void wxStringList::Delete (const char *s)
+{
+  for (wxNode * node = First (); node; node = node->Next ())
+    {
+      char *string = (char *) node->Data ();
+      if (string == s || strcmp (string, s) == 0)
+	{
+	  delete[]string;
+	  delete node;
+	  break;		// Done!
+
+	}
+    }				// for
+
+}
+
+// Only makes new strings if arg is TRUE
+char **wxStringList::ListToArray (bool new_copies) const
+{
+  char **string_array = new char *[Number ()];
+  wxNode *node = First ();
+  int i;
+  for (i = 0; i < n; i++)
+    {
+      char *s = (char *) node->Data ();
+      if (new_copies)
+	string_array[i] = copystring (s);
+      else
+	string_array[i] = s;
+      node = node->Next ();
+    }
+  return string_array;
+}
+
+static int 
+wx_comparestrings (const void *arg1, const void *arg2)
+{
+  char **s1 = (char **) arg1;
+  char **s2 = (char **) arg2;
+
+  return strcmp (*s1, *s2);
+}
+
+// Sort a list of strings - deallocates old nodes, allocates new
+void wxStringList::Sort (void)
+{
+  size_t N = n;
+  char **array = new char *[N];
+
+  size_t i = 0;
+  for (wxNode * node = First (); node; node = node->Next ())
+    array[i++] = (char *) node->Data ();
+
+  qsort (array, N, sizeof (char *), wx_comparestrings);
+  Clear ();
+
+  for (i = 0; i < N; i++)
+    Append ((wxObject *) (array[i]));
+
+  delete[]array;
+}
+
+// Checks whether s is a member of the list
+bool wxStringList::Member (const char *s) const
+{
+  for (wxNode * node = First (); node; node = node->Next ())
+    {
+      const char *s1 = (const char *) node->Data ();
+      if (s == s1 || strcmp (s, s1) == 0)
+	return TRUE;
+    }
+  return FALSE;
+}
+
+void wxStringList::operator= (const wxStringList& list)
+{
+    Clear();
+
+    wxNode *node = list.First();
+    while (node)
+    {
+        char *s = (char *) node->Data ();
+        Add(s);
+        node = node->Next();
+    }
+}
+
+char* wxStringList::operator[] (int i) const
+{
+    wxASSERT_MSG( (i < Number()), "Invalid index for wxStringList" );
+
+    return (char*) (Nth(i)->Data());
+}
+

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