Compare commits
1 Commits
OLD_DATE_A
...
WXDLLEXPOR
Author | SHA1 | Date | |
---|---|---|---|
|
7b858cfd3d |
@@ -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_
|
443
include/wx/dynarray.h
Normal file
443
include/wx/dynarray.h
Normal file
@@ -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
|
||||
|
89
include/wx/msw/dcclient.h
Normal file
89
include/wx/msw/dcclient.h
Normal file
@@ -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_
|
147
include/wx/msw/listbox.h
Normal file
147
include/wx/msw/listbox.h
Normal file
@@ -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_
|
173
include/wx/msw/notebook.h
Normal file
173
include/wx/msw/notebook.h
Normal file
@@ -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
|
@@ -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__
|
||||
|
@@ -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
|
@@ -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
|
Reference in New Issue
Block a user