Compare commits

..

1 Commits

Author SHA1 Message Date
Bryan Petty
ce3bd20052 This commit was manufactured by cvs2svn to create tag
'OLD_DATE_AND_TIME'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/OLD_DATE_AND_TIME@5023 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1999-12-17 18:36:45 +00:00
13 changed files with 1361 additions and 18684 deletions

View File

@@ -1,347 +0,0 @@
\section{\class{wxMouseEvent}}\label{wxmouseevent}
This event class contains information about mouse events.
See \helpref{wxWindow::OnMouseEvent}{wxwindowonmouseevent}.
{\bf NB: } Note that under Windows mouse enter and leave events are not natively supported
by the system but are generated by wxWindows itself. This has several
drawbacks: the LEAVE\_WINDOW event might be received some time after the mouse
left the window and the state variables for it may have changed during this
time.
{\bf NB: } Note the difference between methods like
\helpref{LeftDown}{wxmouseeventleftdown} and
\helpref{LeftIsDown}{wxmouseeventleftisdown}: the formet returns {\tt TRUE}
when the event corresponds to the left mouse button click while the latter
returns {\tt TRUE} if the left mouse button is currently being pressed. For
example, when the user is dragging the mouse you can use
\helpref{LeftIsDown}{wxmouseeventleftisdown} to test
whether the left mouse button is (still) depressed. Also, by convention, if
\helpref{LeftDown}{wxmouseeventleftdown} returns {\tt TRUE},
\helpref{LeftIsDown}{wxmouseeventleftisdown} will also return {\tt TRUE} in
wxWindows whatever the underlying GUI behaviour is (which is
platform-dependent). The same applies, of course, to other mouse buttons as
well.
\wxheading{Derived from}
\helpref{wxEvent}{wxevent}
\wxheading{Include files}
<wx/event.h>
\wxheading{Event table macros}
To process a mouse event, use these event handler macros to direct input to member
functions that take a wxMouseEvent argument.
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf EVT\_LEFT\_DOWN(func)}}{Process a wxEVT\_LEFT\_DOWN event.}
\twocolitem{{\bf EVT\_LEFT\_UP(func)}}{Process a wxEVT\_LEFT\_UP event.}
\twocolitem{{\bf EVT\_LEFT\_DCLICK(func)}}{Process a wxEVT\_LEFT\_DCLICK event.}
\twocolitem{{\bf EVT\_MIDDLE\_DOWN(func)}}{Process a wxEVT\_MIDDLE\_DOWN event.}
\twocolitem{{\bf EVT\_MIDDLE\_UP(func)}}{Process a wxEVT\_MIDDLE\_UP event.}
\twocolitem{{\bf EVT\_MIDDLE\_DCLICK(func)}}{Process a wxEVT\_MIDDLE\_DCLICK event.}
\twocolitem{{\bf EVT\_RIGHT\_DOWN(func)}}{Process a wxEVT\_RIGHT\_DOWN event.}
\twocolitem{{\bf EVT\_RIGHT\_UP(func)}}{Process a wxEVT\_RIGHT\_UP event.}
\twocolitem{{\bf EVT\_RIGHT\_DCLICK(func)}}{Process a wxEVT\_RIGHT\_DCLICK event.}
\twocolitem{{\bf EVT\_MOTION(func)}}{Process a wxEVT\_MOTION event.}
\twocolitem{{\bf EVT\_ENTER\_WINDOW(func)}}{Process a wxEVT\_ENTER\_WINDOW event.}
\twocolitem{{\bf EVT\_LEAVE\_WINDOW(func)}}{Process a wxEVT\_LEAVE\_WINDOW event.}
\twocolitem{{\bf EVT\_MOUSE\_EVENTS(func)}}{Process all mouse events.}
\end{twocollist}%
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxMouseEvent::m\_altDown}
\member{bool}{m\_altDown}
TRUE if the Alt key is pressed down.
\membersection{wxMouseEvent::m\_controlDown}
\member{bool}{m\_controlDown}
TRUE if control key is pressed down.
\membersection{wxMouseEvent::m\_leftDown}
\member{bool}{m\_leftDown}
TRUE if the left mouse button is currently pressed down.
\membersection{wxMouseEvent::m\_middleDown}
\member{bool}{m\_middleDown}
TRUE if the middle mouse button is currently pressed down.
\membersection{wxMouseEvent::m\_rightDown}
\member{bool}{m\_rightDown}
TRUE if the right mouse button is currently pressed down.
\membersection{wxMouseEvent::m\_leftDown}
\member{bool}{m\_leftDown}
TRUE if the left mouse button is currently pressed down.
\membersection{wxMouseEvent::m\_metaDown}
\member{bool}{m\_metaDown}
TRUE if the Meta key is pressed down.
\membersection{wxMouseEvent::m\_shiftDown}
\member{bool}{m\_shiftDown}
TRUE if shift is pressed down.
\membersection{wxMouseEvent::m\_x}
\member{long}{m\_x}
X-coordinate of the event.
\membersection{wxMouseEvent::m\_y}
\member{long}{m\_y}
Y-coordinate of the event.
\membersection{wxMouseEvent::wxMouseEvent}
\func{}{wxMouseEvent}{\param{WXTYPE}{ mouseEventType = 0}, \param{int}{ id = 0}}
Constructor. Valid event types are:
\begin{itemize}
\itemsep=0pt
\item {\bf wxEVT\_ENTER\_WINDOW}
\item {\bf wxEVT\_LEAVE\_WINDOW}
\item {\bf wxEVT\_LEFT\_DOWN}
\item {\bf wxEVT\_LEFT\_UP}
\item {\bf wxEVT\_LEFT\_DCLICK}
\item {\bf wxEVT\_MIDDLE\_DOWN}
\item {\bf wxEVT\_MIDDLE\_UP}
\item {\bf wxEVT\_MIDDLE\_DCLICK}
\item {\bf wxEVT\_RIGHT\_DOWN}
\item {\bf wxEVT\_RIGHT\_UP}
\item {\bf wxEVT\_RIGHT\_DCLICK}
\item {\bf wxEVT\_MOTION}
\end{itemize}
\membersection{wxMouseEvent::AltDown}
\func{bool}{AltDown}{\void}
Returns TRUE if the Alt key was down at the time of the event.
\membersection{wxMouseEvent::Button}
\func{bool}{Button}{\param{int}{ button}}
Returns TRUE if the identified mouse button is changing state. Valid
values of {\it button} are 1, 2 or 3 for left, middle and right
buttons respectively.
Not all mice have middle buttons so a portable application should avoid
this one.
\membersection{wxMouseEvent::ButtonDClick}\label{buttondclick}
\func{bool}{ButtonDClick}{\param{int}{ but = -1}}
If the argument is omitted, this returns TRUE if the event was a mouse
double click event. Otherwise the argument specifies which double click event
was generated (1, 2 or 3 for left, middle and right buttons respectively).
\membersection{wxMouseEvent::ButtonDown}
\func{bool}{ButtonDown}{\param{int}{ but = -1}}
If the argument is omitted, this returns TRUE if the event was a mouse
button down event. Otherwise the argument specifies which button-down event
was generated (1, 2 or 3 for left, middle and right buttons respectively).
\membersection{wxMouseEvent::ButtonUp}
\func{bool}{ButtonUp}{\param{int}{ but = -1}}
If the argument is omitted, this returns TRUE if the event was a mouse
button up event. Otherwise the argument specifies which button-up event
was generated (1, 2 or 3 for left, middle and right buttons respectively).
\membersection{wxMouseEvent::ControlDown}
\func{bool}{ControlDown}{\void}
Returns TRUE if the control key was down at the time of the event.
\membersection{wxMouseEvent::Dragging}
\func{bool}{Dragging}{\void}
Returns TRUE if this was a dragging event (motion while a button is depressed).
\membersection{wxMouseEvent::Entering}\label{wxmouseevententering}
\func{bool}{Entering}{\void}
Returns TRUE if the mouse was entering the window.
See also \helpref{wxMouseEvent::Leaving}{wxmouseeventleaving}.
\membersection{wxMouseEvent::GetPosition}\label{wxmouseeventgetposition}
\constfunc{wxPoint}{GetPosition}{\void}
\constfunc{void}{GetPosition}{\param{wxCoord*}{ x}, \param{wxCoord*}{ y}}
\constfunc{void}{GetPosition}{\param{long*}{ x}, \param{long*}{ y}}
Sets *x and *y to the position at which the event occurred.
Returns the physical mouse position in pixels.
\membersection{wxMouseEvent::GetLogicalPosition}\label{wxmouseeventgetlogicalposition}
\constfunc{wxPoint}{GetLogicalPosition}{\param{const wxDC\&}{ dc}}
Returns the logical mouse position in pixels (i.e. translated according to the
translation set for the DC, which usually indicates that the window has been scrolled).
\membersection{wxMouseEvent::GetX}\label{wxmouseeventgetx}
\constfunc{long}{GetX}{\void}
Returns X coordinate of the physical mouse event position.
\membersection{wxMouseEvent::GetY}\label{wxmouseeventgety}
\func{long}{GetY}{\void}
Returns Y coordinate of the physical mouse event position.
\membersection{wxMouseEvent::IsButton}
\constfunc{bool}{IsButton}{\void}
Returns TRUE if the event was a mouse button event (not necessarily a button down event -
that may be tested using {\it ButtonDown}).
\membersection{wxMouseEvent::Leaving}\label{wxmouseeventleaving}
\constfunc{bool}{Leaving}{\void}
Returns TRUE if the mouse was leaving the window.
See also \helpref{wxMouseEvent::Entering}{wxmouseevententering}.
\membersection{wxMouseEvent::LeftDClick}
\constfunc{bool}{LeftDClick}{\void}
Returns TRUE if the event was a left double click.
\membersection{wxMouseEvent::LeftDown}\label{wxmouseeventleftdown}
\constfunc{bool}{LeftDown}{\void}
Returns TRUE if the left mouse button changed to down.
\membersection{wxMouseEvent::LeftIsDown}\label{wxmouseeventleftisdown}
\constfunc{bool}{LeftIsDown}{\void}
Returns TRUE if the left mouse button is currently down, independent
of the current event type.
Please notice that it is {\bf not} the same as
\helpref{LeftDown}{wxmouseeventleftdown} which returns TRUE if the left mouse
button was just pressed. Rather, it describes the state of the mouse button
before the event happened.
This event is usually used in the mouse event handlers which process "move
mouse" messages to determine whether the user is (still) dragging the mouse.
\membersection{wxMouseEvent::LeftUp}
\constfunc{bool}{LeftUp}{\void}
Returns TRUE if the left mouse button changed to up.
\membersection{wxMouseEvent::MetaDown}
\constfunc{bool}{MetaDown}{\void}
Returns TRUE if the Meta key was down at the time of the event.
\membersection{wxMouseEvent::MiddleDClick}
\constfunc{bool}{MiddleDClick}{\void}
Returns TRUE if the event was a middle double click.
\membersection{wxMouseEvent::MiddleDown}
\constfunc{bool}{MiddleDown}{\void}
Returns TRUE if the middle mouse button changed to down.
\membersection{wxMouseEvent::MiddleIsDown}\label{wxmouseeventmiddleisdown}
\constfunc{bool}{MiddleIsDown}{\void}
Returns TRUE if the middle mouse button is currently down, independent
of the current event type.
\membersection{wxMouseEvent::MiddleUp}
\constfunc{bool}{MiddleUp}{\void}
Returns TRUE if the middle mouse button changed to up.
\membersection{wxMouseEvent::Moving}
\constfunc{bool}{Moving}{\void}
Returns TRUE if this was a motion event (no buttons depressed).
\membersection{wxMouseEvent::RightDClick}
\constfunc{bool}{RightDClick}{\void}
Returns TRUE if the event was a right double click.
\membersection{wxMouseEvent::RightDown}
\constfunc{bool}{RightDown}{\void}
Returns TRUE if the right mouse button changed to down.
\membersection{wxMouseEvent::RightIsDown}\label{wxmouseeventrightisdown}
\constfunc{bool}{RightIsDown}{\void}
Returns TRUE if the right mouse button is currently down, independent
of the current event type.
\membersection{wxMouseEvent::RightUp}
\constfunc{bool}{RightUp}{\void}
Returns TRUE if the right mouse button changed to up.
\membersection{wxMouseEvent::ShiftDown}
\constfunc{bool}{ShiftDown}{\void}
Returns TRUE if the shift key was down at the time of the event.

146
include/wx/date.h Normal file
View File

@@ -0,0 +1,146 @@
/////////////////////////////////////////////////////////////////////////////
// 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_

File diff suppressed because it is too large Load Diff

View File

@@ -1,154 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/scrolwin.h
// Purpose: wxScrolledWindow 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_GENERIC_SCROLLWIN_H_
#define _WX_GENERIC_SCROLLWIN_H_
#ifdef __GNUG__
#pragma interface "scrolwin.h"
#endif
// ----------------------------------------------------------------------------
// headers and constants
// ----------------------------------------------------------------------------
#include "wx/window.h"
#include "wx/panel.h"
WXDLLEXPORT_DATA(extern const wxChar*) wxPanelNameStr;
// default scrolled window style
#ifndef wxScrolledWindowStyle
#define wxScrolledWindowStyle (wxHSCROLL | wxVSCROLL)
#endif
// ----------------------------------------------------------------------------
// wxGenericScrolledWindow
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxGenericScrolledWindow : public wxPanel
{
public:
wxGenericScrolledWindow();
wxGenericScrolledWindow(wxWindow *parent,
wxWindowID id = -1,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxScrolledWindowStyle,
const wxString& name = wxPanelNameStr)
{
Create(parent, id, pos, size, style, name);
}
~wxGenericScrolledWindow();
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxScrolledWindowStyle,
const wxString& name = wxPanelNameStr);
// Normally the wxGenericScrolledWindow will scroll itself, but in
// some rare occasions you might want it to scroll another
// window (e.g. a child of it in order to scroll only a portion
// the area between the scrollbars (spreadsheet: only cell area
// will move).
virtual void SetTargetWindow( wxWindow *target );
virtual wxWindow *GetTargetWindow();
// Number of pixels per user unit (0 or -1 for no scrollbar)
// Length of virtual canvas in user units
// Length of page in user units
virtual void SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
int noUnitsX, int noUnitsY,
int xPos = 0, int yPos = 0,
bool noRefresh = FALSE );
// Physically scroll the window
virtual void Scroll(int x_pos, int y_pos);
#if WXWIN_COMPATIBILITY
virtual void GetScrollUnitsPerPage(int *x_page, int *y_page) const;
virtual void CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const;
#endif
int GetScrollPageSize(int orient) const;
void SetScrollPageSize(int orient, int pageSize);
virtual void GetScrollPixelsPerUnit(int *x_unit, int *y_unit) const;
// Enable/disable Windows scrolling in either direction.
// If TRUE, wxWindows scrolls the canvas and only a bit of
// the canvas is invalidated; no Clear() is necessary.
// If FALSE, the whole canvas is invalidated and a Clear() is
// necessary. Disable for when the scroll increment is used
// to actually scroll a non-constant distance
virtual void EnableScrolling(bool x_scrolling, bool y_scrolling);
// Get the view start
virtual void GetViewStart(int *x, int *y) const;
// Compatibility
void ViewStart(int *x, int *y) const
{ GetViewStart( x, y ); }
// Actual size in pixels when scrolling is taken into account
virtual void GetVirtualSize(int *x, int *y) const;
// Set the scale factor, used in PrepareDC
void SetScale(double xs, double ys) { m_scaleX = xs; m_scaleY = ys; }
double GetScaleX() const { return m_scaleX; }
double GetScaleY() const { return m_scaleY; }
virtual void CalcScrolledPosition(int x, int y, int *xx, int *yy) const;
virtual void CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const;
// Adjust the scrollbars
virtual void AdjustScrollbars(void);
// Override this function to draw the graphic (or just process EVT_PAINT)
virtual void OnDraw(wxDC& WXUNUSED(dc)) {};
// Override this function if you don't want to have wxGenericScrolledWindow
// automatically change the origin according to the scroll position.
virtual void PrepareDC(wxDC& dc);
// implementation from now on
void OnScroll(wxScrollWinEvent& event);
void OnSize(wxSizeEvent& event);
void OnPaint(wxPaintEvent& event);
void OnChar(wxKeyEvent& event);
// Calculate scroll increment
virtual int CalcScrollInc(wxScrollWinEvent& event);
protected:
wxWindow *m_targetWindow;
int m_xScrollPixelsPerLine;
int m_yScrollPixelsPerLine;
bool m_xScrollingEnabled;
bool m_yScrollingEnabled;
int m_xScrollPosition;
int m_yScrollPosition;
int m_xScrollLines;
int m_yScrollLines;
int m_xScrollLinesPerPage;
int m_yScrollLinesPerPage;
double m_scaleX;
double m_scaleY;
private:
DECLARE_EVENT_TABLE()
DECLARE_ABSTRACT_CLASS(wxGenericScrolledWindow)
};
#endif
// _WX_GENERIC_SCROLLWIN_H_

View File

@@ -1,936 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/setup.h
// Purpose: Configuration for the library
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SETUP_H_
#define _WX_SETUP_H_
// ----------------------------------------------------------------------------
// global settings
// ----------------------------------------------------------------------------
// define this to 0 when building wxBase library - this can also be done from
// makefile/project file overriding the value here
#ifndef wxUSE_GUI
#define wxUSE_GUI 1
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
// compatibility settings
// ----------------------------------------------------------------------------
// This setting determines the compatibility with 1.68 API:
// Level 0: no backward compatibility, all new features
// Level 1: some extra methods are defined for compatibility.
//
// Default is 0.
//
// Recommended setting: 0 (in fact the compatibility code is now very minimal
// so there is little advantage to setting it to 1.
#define WXWIN_COMPATIBILITY 0
// in wxMSW version 2.1.11 and earlier, wxIcon always derives from wxBitmap,
// but this is very dangerous because you can mistakenly pass an icon instead
// of a bitmap to a function taking "const wxBitmap&" - which will *not* work
// because an icon is not a valid bitmap
//
// Starting from 2.1.12, you have the choice under this backwards compatible
// behaviour (your code will still compile, but probably won't behave as
// expected!) and not deriving wxIcon class from wxBitmap, but providing a
// conversion ctor wxBitmap(const wxIcon&) instead.
//
// Recommended setting: 0
#define wxICON_IS_BITMAP 0
// Define as 1 for font size to be backward compatible to 1.63 and earlier.
// 1.64 and later define point sizes to be compatible with Windows.
//
// Default is 0
//
// Recommended setting: 0
#define wxFONT_SIZE_COMPATIBILITY 0
// Set to 0 for accurate dialog units, else 1 to be as per 2.1.16 and before.
// If migrating between versions, your dialogs may seem to shrink.
//
// Default is 1
//
// Recommended setting: 0 (the new calculations are more correct!)
#define wxDIALOG_UNIT_COMPATIBILITY 1
// ----------------------------------------------------------------------------
// debugging settings
// ----------------------------------------------------------------------------
// Generic comment about debugging settings: they are very useful if you don't
// use any other memory leak detection tools such as Purify/BoundsChecker, but
// are probably redundant otherwise. Also, Visual C++ CRT has the same features
// as wxWindows memory debugging subsystem built in since version 5.0 and you
// may prefer to use it instead of built in memory debugging code because it is
// faster and more fool proof.
//
// Using VC++ CRT memory debugging is enabled by default in debug mode
// (__WXDEBUG__) if wxUSE_GLOBAL_MEMORY_OPERATORS is *not* enabled (i.e. is 0)
// and if __NO_VC_CRTDBG__ is not defined.
// If 1, enables wxDebugContext, for writing error messages to file, etc. If
// __WXDEBUG__ is not defined, will still use normal memory operators. It's
// recommended to set this to 1, since you may well need to output an error log
// in a production version (or non-debugging beta).
//
// Default is 1.
//
// Recommended setting: 1 but see comment above
#define wxUSE_DEBUG_CONTEXT 1
// If 1, enables debugging versions of wxObject::new and wxObject::delete *IF*
// __WXDEBUG__ is also defined.
//
// WARNING: this code may not work with all architectures, especially if
// alignment is an issue. This switch is currently ignored for mingw / cygwin
//
// Default is 1
//
// Recommended setting: 1 but see comment in the beginning of this section
#define wxUSE_MEMORY_TRACING 1
// In debug mode, cause new and delete to be redefined globally.
// If this causes problems (e.g. link errors), set this to 0.
// This switch is currently ignored for mingw / cygwin
//
// Default is 1
//
// Recommended setting: 1 but see comment in the beginning of this section
#define wxUSE_GLOBAL_MEMORY_OPERATORS 1
// In debug mode, causes new to be defined to be WXDEBUG_NEW (see object.h). If
// this causes problems (e.g. link errors), set this to 0. You may need to set
// this to 0 if using templates (at least for VC++). This switch is currently
// ignored for mingw / cygwin
//
// Default is 1
//
// Recommended setting: 1 but see comment in the beginning of this section
#define wxUSE_DEBUG_NEW_ALWAYS 1
// wxHandleFatalExceptions() may be used to catch the program faults at run
// time and, instead of terminating the program with a usual GPF message box,
// call the user-defined wxApp::OnFatalException() function. If you set
// wxUSE_ON_FATAL_EXCEPTION to 0, wxHandleFatalExceptions() will not work.
//
// This setting is for Win32 only and can only be enabled if your compiler
// supports Win32 structured exception handling (currently only VC++ does)
//
// Default is 1
//
// Recommended setting: 1 if your compiler supports it.
#ifdef _MSC_VER
#define wxUSE_ON_FATAL_EXCEPTION 1
#else
#define wxUSE_ON_FATAL_EXCEPTION 0
#endif
// ----------------------------------------------------------------------------
// Unicode support
// ----------------------------------------------------------------------------
// Set wxUSE_UNICODE to 1 to compile wxWindows in Unicode mode: wxChar will be
// defined as wchar_t, wxString will use Unicode internally. If you set this
// to 1, you must use wxT() macro for all literal strings in the program.
//
// Unicode is currently only fully supported under Windows NT/2000 (Windows 9x
// doesn't support it and the programs compiled in Unicode mode will not run
// under 9x).
//
// Default is 0
//
// Recommended setting: 0 (unless you only plan to use Windows NT/2000)
#define wxUSE_UNICODE 0
// Setting wxUSE_WCHAR_T to 1 gives you some degree of Unicode support without
// compiling the program in Unicode mode. More precisely, it will be possible
// to construct wxString from a wide (Unicode) string and convert any wxString
// to Unicode.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_WCHAR_T 1
// ----------------------------------------------------------------------------
// global features
// ----------------------------------------------------------------------------
// Support for message/error logging. This includes wxLogXXX() functions and
// wxLog and derived classes. Don't set this to 0 unless you really know what
// you are doing.
//
// Default is 1
//
// Recommended setting: 1 (always)
#define wxUSE_LOG 1
// Support for multithreaded applications: if 1, compile in thread classes
// (thread.h) and make the library a bit more thread safe. Although thread
// support is quite stable by now, you may still consider recompiling the
// library without it if you have no use for it - this will result in a
// somewhat smaller and faster operation.
//
// This is ignored under Win16, threads are only supported under Win32.
//
// Default is 1
//
// Recommended setting: 0 unless you do plan to develop MT applications
#define wxUSE_THREADS 1
// If enabled (1), compiles wxWindows streams classes
#define wxUSE_STREAMS 1
// Use standard C++ streams if 1. If 0, use wxWin streams implementation.
#define wxUSE_STD_IOSTREAM 0
// Use serialization (requires utils/serialize)
#define wxUSE_SERIAL 0
// ----------------------------------------------------------------------------
// non GUI features selection
// ----------------------------------------------------------------------------
// Set wxUSE_LONGLONG to 1 to compile the wxLongLong class. This is a 64 bit
// integer which is implemented in terms of native 64 bit integers if any or
// uses emulation otherwise.
//
// This class is required by wxDateTime and so you should enable it if you want
// to use wxDateTime. For most modern platforms, it will use the native 64 bit
// integers in which case (almost) all of its functions are inline and it
// almost does not take any space, so there should be no reason to switch it
// off.
//
// Recommended setting: 1
#define wxUSE_LONGLONG 1
// Set wxUSE_TIMEDATE to 1 to compile the wxDateTime and related classes which
// allow to manipulate dates, times and time intervals. wxDateTime replaces the
// old wxTime and wxDate classes which are still provided for backwards
// compatibility (and implemented in terms of wxDateTime).
//
// Note that this class is relatively new and is still officially in alpha
// stage because some features are not yet (fully) implemented. It is already
// quite useful though and should only be disabled if you are aiming at
// absolutely minimal version of the library.
//
// Requires: wxUSE_LONGLONG
//
// Recommended setting: 1
#define wxUSE_TIMEDATE 1
// Setting wxUSE_CONFIG to 1 enables the use of wxConfig and related classes
// which allow the application to store its settings in the persistent
// storage. Setting this to 1 will also enable on-demand creation of the
// global config object in wxApp.
//
// See also wxUSE_CONFIG_NATIVE below.
//
// Recommended setting: 1
#define wxUSE_CONFIG 1
// If wxUSE_CONFIG is 1, you may choose to use either the native config
// classes under Windows (using .INI files under Win16 and the registry under
// Win32) or the portable text file format used by the config classes under
// Unix.
//
// Default is 1 to use native classes. Note that you may still use
// wxFileConfig even if you set this to 1 - just the config object created by
// default for the applications needs will be a wxRegConfig or wxIniConfig and
// not wxFileConfig.
//
// Recommended setting: 1
#define wxUSE_CONFIG_NATIVE 1
// If wxUSE_DIALUP_MANAGER is 1, compile in wxDialUpManager class which allows
// to connect/disconnect from the network and be notified whenever the dial-up
// network connection is established/terminated. Requires wxUSE_DYNLIB_CLASS.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DIALUP_MANAGER 1
// Compile in wxLibrary class for run-time DLL loading and function calling.
// Required by wxUSE_DIALUP_MANAGER.
//
// This setting is for Win32 only
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DYNLIB_CLASS 1
// Set to 1 to use socket classes
#define wxUSE_SOCKETS 1
// Set to 1 to enable virtual file systems (required by wxHTML)
#define wxUSE_FILESYSTEM 1
// Set to 1 to enable virtual ZIP filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ZIP 1
// Set to 1 to enable virtual Internet filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_INET 1
// Set to 1 to compile wxZipInput/OutputStream classes.
#define wxUSE_ZIPSTREAM 1
// Set to 1 to compile wxZlibInput/OutputStream classes. Also required by
// wxUSE_LIBPNG.
#define wxUSE_ZLIB 1
// If enabled, the code written by Apple will be used to write, in a portable
// way, float on the disk. See extended.c for the license which is different
// from wxWindows one.
//
// Default is 1.
//
// Recommended setting: 1 unless you don't like the license terms (unlikely)
#define wxUSE_APPLE_IEEE 1
// Use wxFile class.
//
// Default is 1.
//
// Recommended setting: 1 (highly recommended, required i18n code, wxConfig...)
#define wxUSE_FILE 1
// use wxTextFile class: requires wxFile, required by wxFileConfig
#define wxUSE_TEXTFILE 1
// i18n support: _() macro, wxLocale class. Requires wxTextFile.
#define wxUSE_INTL 1
// ----------------------------------------------------------------------------
// Optional controls
// ----------------------------------------------------------------------------
// wxToolBar related settings: if wxUSE_TOOLBAR is 0, don't compile any toolbar
// classes at all. Otherwise, use the native toolbar class unless
// wxUSE_TOOLBAR_NATIVE is 0. Additionally, the generic toolbar class which
// supports some features which might not be supported by the native wxToolBar
// class may be compiled in if wxUSE_TOOLBAR_SIMPLE is 1.
//
// Default is 1 for all settings.
//
// Recommended setting: 1 for wxUSE_TOOLBAR and wxUSE_TOOLBAR_NATIVE and 0 for
// wxUSE_TOOLBAR_SIMPLE (the default is 1 mainly for backwards compatibility).
#define wxUSE_TOOLBAR 1
#define wxUSE_TOOLBAR_NATIVE 1
#define wxUSE_TOOLBAR_SIMPLE 1
// wxNotebook is a control with several "tabs" located on one of its sides. It
// may be used ot logically organise the data presented to the user instead of
// putting everything in one huge dialog. It replaces wxTabControl and related
// classes of wxWin 1.6x.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTEBOOK 1
// The corresponding controls will be compiled in if wxUSE_<CONTROL> is set to
// 1 and not compiled into the library otherwise.
//
// Default is 1 for everything.
//
// Recommended setting: 1 (library might fail to compile for some combinations
// of disabled controls)
#define wxUSE_CARET 1
#define wxUSE_CHECKBOX 1
#define wxUSE_CHECKLISTBOX 1 // requires wxUSE_OWNER_DRAWN
#define wxUSE_CHOICE 1
#define wxUSE_COMBOBOX 1
#define wxUSE_GAUGE 1
#define wxUSE_LISTBOX 1
#define wxUSE_RADIOBOX 1
#define wxUSE_RADIOBTN 1
#define wxUSE_SASH 1 // wxSashWindow
#define wxUSE_SCROLLBAR 1
#define wxUSE_SLIDER 1
#define wxUSE_SPINBTN 1
#define wxUSE_SPINCTRL 1
#define wxUSE_STATLINE 1
#define wxUSE_STATUSBAR 1
#define wxUSE_TOGGLEBTN 1 // requires wxButton
#define wxUSE_TOOLTIPS 1 // wxToolTip and wxWindow::SetToolTip()
// Two status bar implementations are available under Win32: the generic one
// or the wrapper around native control. For native look and feel the native
// version should be used.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NATIVE_STATUSBAR 1
// this setting is obsolete, value is ignored
#define wxUSE_BUTTONBAR 1
// wxGrid class comes in two flavours: the original (pre wxWin 2.2) one and
// the new, much imporved and enhanced version. The new version is backwards
// compatible with the old one and should be used whenever possible, i.e. if
// you set wxUSE_GRID to 1, set wxUSE_NEW_GRID to 1 too.
//
// Default is 1 for both options.
//
// Recommended setting: 1 for wxUSE_NEW_GRID, 0 if you have an old code using
// wxGrid and 100% backwards compatibality (with all old wxGrid quirks) is
// essential.
//
// WIN16/BC++ resets wxUSE_NEW_GRID to 0 because it exceeds the data limit.
#define wxUSE_GRID 1
#define wxUSE_NEW_GRID 1
// wxValidator class and related methods
#define wxUSE_VALIDATORS 1
// wxAcceleratorTable/Entry classes and support for them in wxMenu(Bar)
#define wxUSE_ACCEL 1
// ----------------------------------------------------------------------------
// common dialogs
// ----------------------------------------------------------------------------
// Define 1 to use generic dialogs in Windows, even though they duplicate
// native common dialog (e.g. wxColourDialog). This is mainly useful for
// testing.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_GENERIC_DIALOGS_IN_MSW 0
// On rare occasions (e.g. using DJGPP) may want to omit common dialogs (e.g.
// file selector, printer dialog). Switching this off also switches off the
// printing architecture and interactive wxPrinterDC.
//
// Default is 1
//
// Recommended setting: 1 (unless it really doesn't work)
#define wxUSE_COMMON_DIALOGS 1
// text entry dialog and wxGetTextFromUser function
#define wxUSE_TEXTDLG 1
// progress dialog class for lengthy operations
#define wxUSE_PROGRESSDLG 1
// wxBusyInfo displays window with message when app is busy. Works in same way
// as wxBusyCursor
#define wxUSE_BUSYINFO 1
// wxDirDlg class for getting a directory name from user
#define wxUSE_DIRDLG 1
// support for startup tips (wxShowTip &c)
#define wxUSE_STARTUP_TIPS 1
// ----------------------------------------------------------------------------
// Metafiles support
// ----------------------------------------------------------------------------
// Windows supports the graphics format known as metafile which is, though not
// portable, is widely used under Windows and so is supported by wxWin (under
// Windows only, of course). Win16 (Win3.1) used the so-called "Window
// MetaFiles" or WMFs which were replaced with "Enhanced MetaFiles" or EMFs in
// Win32 (Win9x, NT, 2000). Both of these are supported in wxWin and, by
// default, WMFs will be used under Win16 and EMFs under Win32. This may be
// changed by setting wxUSE_WIN_METAFILES_ALWAYS to 1 and/or setting
// wxUSE_ENH_METAFILE to 0. You may also set wxUSE_METAFILE to 0 to not compile
// in any metafile related classes at all.
//
// Default is 1 for wxUSE_ENH_METAFILE and 0 for wxUSE_WIN_METAFILES_ALWAYS.
//
// Recommended setting: default or 0 for everything for portable programs.
#define wxUSE_METAFILE 1
#define wxUSE_ENH_METAFILE 1
#define wxUSE_WIN_METAFILES_ALWAYS 0
// ----------------------------------------------------------------------------
// Big GUI components
// ----------------------------------------------------------------------------
// Set to 0 to disable document/view architecture
#define wxUSE_DOC_VIEW_ARCHITECTURE 1
// Set to 0 to disable MDI document/view architecture
#define wxUSE_MDI_ARCHITECTURE 1
// Set to 0 to disable print/preview architecture code
#define wxUSE_PRINTING_ARCHITECTURE 1
// wxHTML sublibrary allows to display HTML in wxWindow programs and much,
// much more.
//
// Default is 1.
//
// Recommended setting: 1 (wxHTML is great!), set to 0 if you want compile a
// smaller library.
#define wxUSE_HTML 1
// wxPlot is a class to display functions plots in wxWindow.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_PLOT 1
// OpenGL canvas
#define wxUSE_GLCANVAS 0
// wxTreeLayout class
#define wxUSE_TREELAYOUT 1
// ----------------------------------------------------------------------------
// miscellaneous settings
// ----------------------------------------------------------------------------
#define wxUSE_IPC 1
// 0 for no interprocess comms
#define wxUSE_HELP 1
// 0 for no help facility
#define wxUSE_MS_HTML_HELP 0
// 0 for no MS HTML Help
#define wxUSE_RESOURCES 1
// 0 for no wxGetResource/wxWriteResource
#define wxUSE_CONSTRAINTS 1
// 0 for no window layout constraint system
#define wxUSE_CLIPBOARD 1
// 0 for no clipboard functions
#define wxUSE_SPLINES 1
// 0 for no splines
#define wxUSE_DRAG_AND_DROP 1
// 0 for no drag and drop
#define wxUSE_XPM_IN_MSW 1
// 0 for no XPM support in wxBitmap.
// Default is 1, as XPM is now fully
// supported this makes easier the issue
// of portable icons and bitmaps.
#define wxUSE_IMAGE_LOADING_IN_MSW 1
// Use dynamic DIB loading/saving code in utils/dib under MSW.
#define wxUSE_RESOURCE_LOADING_IN_MSW 1
// Use dynamic icon/cursor loading/saving code
// under MSW.
#define wxUSE_WX_RESOURCES 1
// Use .wxr resource mechanism (requires PrologIO library)
// ----------------------------------------------------------------------------
// postscript support settings
// ----------------------------------------------------------------------------
// Set to 1 for PostScript device context.
#define wxUSE_POSTSCRIPT 0
// Set to 1 to use font metric files in GetTextExtent
#define wxUSE_AFM_FOR_POSTSCRIPT 0
// Set to 0 to disable PostScript print/preview architecture code under Windows
// (just use Windows printing).
#define wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW 1
// ----------------------------------------------------------------------------
// database classes
// ----------------------------------------------------------------------------
// Define 1 to use ODBC classes
#define wxUSE_ODBC 0
// For backward compatibility reasons, this parameter now only controls the
// default scrolling method used by cursors. This default behavior can be
// overriden by setting the second param of wxDB::wxDbGetConnection() or
// wxDb() constructor to indicate whether the connection (and any wxDbTable()s
// that use the connection) should support forward only scrolling of cursors,
// or both forward and backward support for backward scrolling cursors is
// dependent on the data source as well as the ODBC driver being used.
#define wxODBC_FWD_ONLY_CURSORS 1
// Default is 0. Set to 1 to use the deprecated classes, enum types, function,
// member variables. With a setting of 1, full backward compatability with the
// 2.0.x release is possible. It is STRONGLY recommended that this be set to 0,
// as future development will be done only on the non-deprecated
// functions/classes/member variables/etc.
#define wxODBC_BACKWARD_COMPATABILITY 0
// ----------------------------------------------------------------------------
// other compiler (mis)features
// ----------------------------------------------------------------------------
// Set this to 0 if your compiler can't cope with omission of prototype
// parameters.
//
// Default is 1.
//
// Recommended setting: 1 (should never need to set this to 0)
#define REMOVE_UNUSED_ARG 1
// VC++ 4.2 and above allows <iostream> and <iostream.h> but you can't mix
// them. Set to 1 for <iostream.h>, 0 for <iostream>
//
// Default is 1.
//
// Recommended setting: whatever your compiler likes more
#define wxUSE_IOSTREAMH 1
// ----------------------------------------------------------------------------
// image format support
// ----------------------------------------------------------------------------
// wxImage supports many different image formats which can be configured at
// compile-time. BMP is always supported, others are optional and can be safely
// disabled if you don't plan to use images in such format sometimes saving
// substantial amount of code in the final library.
//
// Some formats require an extra library which is included in wxWin sources
// which is mentioned if it is the case.
// Set to 1 for wxImage support (recommended).
#define wxUSE_IMAGE 1
// Set to 1 for PNG format support (requires libpng). Also requires wxUSE_ZLIB.
#define wxUSE_LIBPNG 1
// Set to 1 for JPEG format support (requires libjpeg)
#define wxUSE_LIBJPEG 1
// Set to 1 for TIFF format support (requires libtiff)
#define wxUSE_LIBTIFF 1
// Set to 1 for GIF format support
#define wxUSE_GIF 1
// Set to 1 for PNM format support
#define wxUSE_PNM 1
// Set to 1 for PCX format support
#define wxUSE_PCX 1
// Set to 1 for XPM format support
#define wxUSE_XPM 1
// ----------------------------------------------------------------------------
// Windows-only settings
// ----------------------------------------------------------------------------
// Set this to 1 if you want to use wxWindows and MFC in the same program. This
// will override some other settings (see below)
//
// Default is 0.
//
// Recommended setting: 0 unless you really have to use MFC
#define wxUSE_MFC 0
// Set this to 1 for generic OLE support: this is required for drag-and-drop,
// clipboard, OLE Automation. Only set it to 0 if your compiler is very old and
// can't compile/doesn't have the OLE headers.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_OLE 1
// Set this to 1 to use Microsoft CTL3D library for "3D-look" under Win16 or NT
// 3.x. This setting is ignored under Win9x and NT 4.0+.
//
// Default is 0 for (most) Win32 (systems), 1 for Win16
//
// Recommended setting: same as default
#if defined(__WIN95__)
#define wxUSE_CTL3D 0
#else
#define wxUSE_CTL3D 1
#endif
// Define as 1 to use Microsoft's ItsyBitsy small title bar library, for
// wxMiniFrame. This setting is only used for Win3.1; Win9x and NT use native
// miniframes support instead.
//
// Default is 0 for (most) Win32 (systems), 1 for Win16
//
// Recommended setting: same as default
#if defined(__WIN95__)
#define wxUSE_ITSY_BITSY 0
#else
#define wxUSE_ITSY_BITSY 1
#endif
// Set this to 1 to use RICHEDIT controls for wxTextCtrl with style wxTE_RICH
// which allows to put more than ~32Kb of text in it even under Win9x (NT
// doesn't have such limitation).
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1, only set it to 0 if your compiler doesn't have
// or can't compile <richedit.h>
#if defined(__WIN95__) && !defined(__TWIN32__) && !defined(__GNUWIN32_OLD__)
#define wxUSE_RICHEDIT 1
#else
#define wxUSE_RICHEDIT 0
#endif
// Set this to 1 to enable support for the owner-drawn menu and listboxes. This
// is required by wxUSE_CHECKLISTBOX.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 for a small library size reduction
#define wxUSE_OWNER_DRAWN 1
// ----------------------------------------------------------------------------
// obsolete settings
// ----------------------------------------------------------------------------
// NB: all settings in this section are obsolete and should not be used/changed
// at all, they will disappear
// Set to 1 to use PenWindows
#define wxUSE_PENWINDOWS 0
// Define 1 to use bitmap messages.
#define wxUSE_BITMAP_MESSAGE 1
// If 1, enables provision of run-time type information.
// NOW MANDATORY: don't change.
#define wxUSE_DYNAMIC_CLASSES 1
// ----------------------------------------------------------------------------
// disable the settings which don't work for some compilers
// ----------------------------------------------------------------------------
#ifndef wxUSE_NORLANDER_HEADERS
#if (defined(__MINGW32__) || defined(__CYGWIN__)) && ((__GNUC__>2) ||((__GNUC__==2) && (__GNUC_MINOR__>=95)))
# define wxUSE_NORLANDER_HEADERS 1
#else
# define wxUSE_NORLANDER_HEADERS 0
#endif
#endif
#if defined(__GNUWIN32__)
// These don't work as expected for mingw32 and cygwin32
#undef wxUSE_MEMORY_TRACING
#define wxUSE_MEMORY_TRACING 0
#undef wxUSE_GLOBAL_MEMORY_OPERATORS
#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
#undef wxUSE_DEBUG_NEW_ALWAYS
#define wxUSE_DEBUG_NEW_ALWAYS 0
#undef wxUSE_MS_HTML_HELP
#define wxUSE_MS_HTML_HELP 0
// Cygwin betas don't have wcslen
#if defined(__CYGWIN__) || defined(__CYGWIN32__)
# if ! ((__GNUC__>2) ||((__GNUC__==2) && (__GNUC_MINOR__>=95)))
# undef wxUSE_WCHAR_T
# define wxUSE_WCHAR_T 0
# endif
#endif
#endif // __GNUWIN32__
// MFC duplicates these operators
#if wxUSE_MFC
#undef wxUSE_GLOBAL_MEMORY_OPERATORS
#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
#undef wxUSE_DEBUG_NEW_ALWAYS
#define wxUSE_DEBUG_NEW_ALWAYS 0
#endif // wxUSE_MFC
// ODBC classes aren't Unicode-compatible yet
#if wxUSE_UNICODE
#undef wxUSE_ODBC
#define wxUSE_ODBC 0
#endif
#if (!defined(WIN32) && !defined(__WIN32__)) || (defined(__GNUWIN32__) && !wxUSE_NORLANDER_HEADERS)
// Can't use OLE drag and drop in Windows 3.1 because we don't know how
// to implement UUIDs
// GnuWin32 doesn't have appropriate headers for e.g. IUnknown.
#undef wxUSE_DRAG_AND_DROP
#define wxUSE_DRAG_AND_DROP 0
#endif
// Only WIN32 supports wxStatusBar95
#if !defined(__WIN32__) && wxUSE_NATIVE_STATUSBAR
#undef wxUSE_NATIVE_STATUSBAR
#define wxUSE_NATIVE_STATUSBAR 0
#endif
#if !wxUSE_OWNER_DRAWN
#undef wxUSE_CHECKLISTBOX
#define wxUSE_CHECKLISTBOX 0
#endif
// Salford C++ doesn't like some of the memory operator definitions
#ifdef __SALFORDC__
#undef wxUSE_MEMORY_TRACING
#define wxUSE_MEMORY_TRACING 0
#undef wxUSE_GLOBAL_MEMORY_OPERATORS
#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
#undef wxUSE_DEBUG_NEW_ALWAYS
#define wxUSE_DEBUG_NEW_ALWAYS 0
#undef wxUSE_THREADS
#define wxUSE_THREADS 0
#undef wxUSE_OWNER_DRAWN
#define wxUSE_OWNER_DRAWN 0
#endif // __SALFORDC__
#ifdef __TWIN32__
#undef wxUSE_THREADS
#define wxUSE_THREADS 0
#undef wxUSE_ODBC
#define wxUSE_ODBC 0
#endif // __TWIN32__
// BC++/Win16 can't cope with the amount of data in resource.cpp
#if defined(__WIN16__) && defined(__BORLANDC__)
#undef wxUSE_WX_RESOURCES
#define wxUSE_WX_RESOURCES 0
#undef wxUSE_ODBC
#define wxUSE_ODBC 0
#undef wxUSE_NEW_GRID
#define wxUSE_NEW_GRID 0
#endif
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
// BC++ 4.0 can't compile JPEG library
#undef wxUSE_LIBJPEG
#define wxUSE_LIBJPEG 0
#endif
#if defined(__BORLANDC__)
// Need a BC++-specific htmlhelp.lib before we can enable this
#undef wxUSE_MS_HTML_HELP
#define wxUSE_MS_HTML_HELP 0
#endif
// wxUSE_DEBUG_NEW_ALWAYS = 1 not compatible with BC++ in DLL mode
#if defined(__BORLANDC__) && (defined(WXMAKINGDLL) || defined(WXUSINGDLL))
#undef wxUSE_DEBUG_NEW_ALWAYS
#define wxUSE_DEBUG_NEW_ALWAYS 0
#endif
#if defined(__WXMSW__) && defined(__WATCOMC__)
/*
#undef wxUSE_GLCANVAS
#define wxUSE_GLCANVAS 0
*/
#undef wxUSE_MS_HTML_HELP
#define wxUSE_MS_HTML_HELP 0
#undef wxUSE_WCHAR_T
#define wxUSE_WCHAR_T 0
#endif
#if defined(__WXMSW__) && !defined(__WIN32__)
#undef wxUSE_SOCKETS
#define wxUSE_SOCKETS 0
#undef wxUSE_THREADS
#define wxUSE_THREADS 0
#undef wxUSE_TOOLTIPS
#define wxUSE_TOOLTIPS 0
#undef wxUSE_SPINCTRL
#define wxUSE_SPINCTRL 0
#undef wxUSE_SPINBTN
#define wxUSE_SPINBTN 0
#undef wxUSE_LIBPNG
#define wxUSE_LIBPNG 0
#undef wxUSE_LIBJPEG
#define wxUSE_LIBJPEG 0
#undef wxUSE_LIBTIFF
#define wxUSE_LIBTIFF 0
#undef wxUSE_GIF
#define wxUSE_GIF 0
#undef wxUSE_PNM
#define wxUSE_PNM 0
#undef wxUSE_PCX
#define wxUSE_PCX 0
#undef wxUSE_GLCANVAS
#define wxUSE_GLCANVAS 0
#undef wxUSE_MS_HTML_HELP
#define wxUSE_MS_HTML_HELP 0
#undef wxUSE_WCHAR_T
#define wxUSE_WCHAR_T 0
#endif // Win16
// ----------------------------------------------------------------------------
// undef the things which don't make sense for wxBase build
// ----------------------------------------------------------------------------
#if !wxUSE_GUI
#undef wxUSE_HTML
#define wxUSE_HTML 0
#endif // !wxUSE_GUI
// ----------------------------------------------------------------------------
// check the settings consistency: do it here to abort compilation immediately
// and not almost in the very end when the relevant file fails to compile and
// you need to modify setup.h and rebuild everything
// ----------------------------------------------------------------------------
#if wxUSE_TIMEDATE && !wxUSE_LONGLONG
#error wxDateTime requires wxLongLong
#endif
#if wxUSE_TEXTFILE && !wxUSE_FILE
#error You cannot compile wxTextFile without wxFile
#endif
#if wxUSE_FILESYSTEM && !wxUSE_STREAMS
#error You cannot compile virtual file systems without wxUSE_STREAMS
#endif
#if wxUSE_HTML && !wxUSE_FILESYSTEM
#error You cannot compile wxHTML without virtual file systems
#endif
// add more tests here...
#endif
// _WX_SETUP_H_

View File

@@ -1,451 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: window.h
// Purpose: wxWindow class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WINDOW_H_
#define _WX_WINDOW_H_
// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------
#ifdef __GNUG__
#pragma interface "window.h"
#endif
// #include "wx/msw/winundef.h"
// VZ: apparently some version of Windows send extra mouse move messages after
// a mouse click. My tests under NT 4.0 and 95 didn't show it so I'm
// tempted to think that it was just an effect of a poor mouse and so the
// code to work around this is currently disabled - just define this as 1
// to reenable it
#define wxUSE_MOUSEEVENT_HACK 0
// ---------------------------------------------------------------------------
// forward declarations
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxButton;
// ---------------------------------------------------------------------------
// constants
// ---------------------------------------------------------------------------
// FIXME does anybody use those? they're unused by wxWindows...
enum
{
wxKEY_SHIFT = 1,
wxKEY_CTRL = 2
};
// ---------------------------------------------------------------------------
// wxWindow declaration for MSW
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxWindow : public wxWindowBase
{
public:
wxWindow() { Init(); }
wxWindow(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
virtual ~wxWindow();
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
// implement base class pure virtuals
virtual void SetTitle( const wxString& title);
virtual wxString GetTitle() const;
virtual void Raise();
virtual void Lower();
virtual bool Show( bool show = TRUE );
virtual bool Enable( bool enable = TRUE );
virtual void SetFocus();
virtual bool Reparent( wxWindowBase *newParent );
virtual void WarpPointer(int x, int y);
virtual void CaptureMouse();
virtual void ReleaseMouse();
virtual void Refresh( bool eraseBackground = TRUE,
const wxRect *rect = (const wxRect *) NULL );
virtual void Clear();
virtual bool SetCursor( const wxCursor &cursor );
virtual bool SetFont( const wxFont &font );
virtual int GetCharHeight() const;
virtual int GetCharWidth() const;
virtual void GetTextExtent(const wxString& string,
int *x, int *y,
int *descent = (int *) NULL,
int *externalLeading = (int *) NULL,
const wxFont *theFont = (const wxFont *) NULL)
const;
virtual bool DoPopupMenu( wxMenu *menu, int x, int y );
virtual void SetScrollbar( int orient, int pos, int thumbVisible,
int range, bool refresh = TRUE );
virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE );
virtual int GetScrollPos( int orient ) const;
virtual int GetScrollThumb( int orient ) const;
virtual int GetScrollRange( int orient ) const;
virtual void ScrollWindow( int dx, int dy,
const wxRect* rect = (wxRect *) NULL );
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget );
#endif // wxUSE_DRAG_AND_DROP
// Accept files for dragging
virtual void DragAcceptFiles(bool accept);
#if WXWIN_COMPATIBILITY
// Set/get scroll attributes
virtual void SetScrollRange(int orient, int range, bool refresh = TRUE);
virtual void SetScrollPage(int orient, int page, bool refresh = TRUE);
virtual int OldGetScrollRange(int orient) const;
virtual int GetScrollPage(int orient) const;
// event handlers
// Handle a control command
virtual void OnCommand(wxWindow& win, wxCommandEvent& event);
// Override to define new behaviour for default action (e.g. double
// clicking on a listbox)
virtual void OnDefaultAction(wxControl * WXUNUSED(initiatingItem)) { }
#endif // WXWIN_COMPATIBILITY
#if wxUSE_CARET && WXWIN_COMPATIBILITY
// caret manipulation (old MSW only functions, see wxCaret class for the
// new API)
void CreateCaret(int w, int h);
void CreateCaret(const wxBitmap *bitmap);
void DestroyCaret();
void ShowCaret(bool show);
void SetCaretPos(int x, int y);
void GetCaretPos(int *x, int *y) const;
#endif // wxUSE_CARET
// Native resource loading (implemented in src/msw/nativdlg.cpp)
// FIXME: should they really be all virtual?
virtual bool LoadNativeDialog(wxWindow* parent, wxWindowID& id);
virtual bool LoadNativeDialog(wxWindow* parent, const wxString& name);
wxWindow* GetWindowChild1(wxWindowID id);
wxWindow* GetWindowChild(wxWindowID id);
// a MSW only function which sends a size event to the window using its
// current size - this has an effect of refreshing the window layout
/*
FUNCTION IS NOW A MEMBER OF wxFrame - gt
void SendSizeEvent();
*/
// implementation from now on
// --------------------------
// simple accessors
// ----------------
WXHWND GetHWND() const { return m_hWnd; }
void SetHWND(WXHWND hWnd) { m_hWnd = hWnd; }
virtual WXWidget GetHandle() const { return GetHWND(); }
bool GetUseCtl3D() const { return m_useCtl3D; }
bool GetTransparentBackground() const { return m_backgroundTransparent; }
void SetTransparent(bool t = TRUE) { m_backgroundTransparent = t; }
// event handlers
// --------------
void OnSetFocus(wxFocusEvent& event);
void OnEraseBackground(wxEraseEvent& event);
void OnIdle(wxIdleEvent& event);
void OnPaint(wxPaintEvent& event);
public:
// For implementation purposes - sometimes decorations make the client area
// smaller
virtual wxPoint GetClientAreaOrigin() const;
// Makes an adjustment to the window position (for example, a frame that has
// a toolbar that it manages itself).
virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags);
// Windows subclassing
void SubclassWin(WXHWND hWnd);
void UnsubclassWin();
WXFARPROC MSWGetOldWndProc() const { return m_oldWndProc; }
void MSWSetOldWndProc(WXFARPROC proc) { m_oldWndProc = proc; }
wxWindow *FindItem(long id) const;
wxWindow *FindItemByHWND(WXHWND hWnd, bool controlOnly = FALSE) const;
// Make a Windows extended style from the given wxWindows window style
static WXDWORD MakeExtendedStyle(long style,
bool eliminateBorders = FALSE);
// Determine whether 3D effects are wanted
WXDWORD Determine3DEffects(WXDWORD defaultBorderStyle, bool *want3D) const;
// MSW only: TRUE if this control is part of the main control
virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return FALSE; };
// returns TRUE if the window has been created
bool MSWCreate(int id,
wxWindow *parent,
const wxChar *wclass,
wxWindow *wx_win,
const wxChar *title,
int x, int y, int width, int height,
WXDWORD style,
const wxChar *dialog_template = NULL,
WXDWORD exendedStyle = 0);
virtual bool MSWCommand(WXUINT param, WXWORD id);
#if WXWIN_COMPATIBILITY
wxObject *GetChild(int number) const;
virtual void MSWDeviceToLogical(float *x, float *y) const;
#endif // WXWIN_COMPATIBILITY
// Create an appropriate wxWindow from a HWND
virtual wxWindow* CreateWindowFromHWND(wxWindow* parent, WXHWND hWnd);
// Make sure the window style reflects the HWND style (roughly)
virtual void AdoptAttributesFromHWND();
// Setup background and foreground colours correctly
virtual void SetupColours();
// ------------------------------------------------------------------------
// helpers for message handlers: these perform the same function as the
// message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into
// the correct parameters
// ------------------------------------------------------------------------
void UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *id, WXHWND *hwnd, WXWORD *cmd);
void UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *state, WXWORD *minimized, WXHWND *hwnd);
void UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *code, WXWORD *pos, WXHWND *hwnd);
void UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd);
void UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *item, WXWORD *flags, WXHMENU *hmenu);
// ------------------------------------------------------------------------
// internal handlers for MSW messages: all handlers return a boolean value:
// TRUE means that the handler processed the event and FALSE that it didn't
// ------------------------------------------------------------------------
// there are several cases where we have virtual functions for Windows
// message processing: this is because these messages often require to be
// processed in a different manner in the derived classes. For all other
// messages, however, we do *not* have corresponding MSWOnXXX() function
// and if the derived class wants to process them, it should override
// MSWWindowProc() directly.
// scroll event (both horizontal and vertical)
virtual bool MSWOnScroll(int orientation, WXWORD nSBCode,
WXWORD pos, WXHWND control);
// child control notifications
#ifdef __WIN95__
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
#endif // __WIN95__
// owner-drawn controls need to process these messages
virtual bool MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *item);
virtual bool MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *item);
// the rest are not virtual
bool HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate);
bool HandleInitDialog(WXHWND hWndFocus);
bool HandleDestroy();
bool HandlePaint();
bool HandleEraseBkgnd(WXHDC pDC);
bool HandleMinimize();
bool HandleMaximize();
bool HandleSize(int x, int y, WXUINT flag);
bool HandleGetMinMaxInfo(void *mmInfo);
bool HandleShow(bool show, int status);
bool HandleActivate(int flag, bool minimized, WXHWND activate);
bool HandleCommand(WXWORD id, WXWORD cmd, WXHWND control);
bool HandleSysCommand(WXWPARAM wParam, WXLPARAM lParam);
bool HandleCtlColor(WXHBRUSH *hBrush,
WXHDC hdc,
WXHWND hWnd,
WXUINT nCtlColor,
WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam);
bool HandlePaletteChanged(WXHWND hWndPalChange);
bool HandleQueryNewPalette();
bool HandleSysColorChange();
bool HandleQueryEndSession(long logOff, bool *mayEnd);
bool HandleEndSession(bool endSession, long logOff);
bool HandleSetFocus(WXHWND wnd);
bool HandleKillFocus(WXHWND wnd);
bool HandleDropFiles(WXWPARAM wParam);
bool HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags);
bool HandleMouseMove(int x, int y, WXUINT flags);
bool HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII = FALSE);
bool HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam);
bool HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam);
bool HandleQueryDragIcon(WXHICON *hIcon);
bool HandleSetCursor(WXHWND hWnd, short nHitTest, int mouseMsg);
// Window procedure
virtual long MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
// Calls an appropriate default window procedure
virtual long MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
virtual bool MSWProcessMessage(WXMSG* pMsg);
virtual bool MSWTranslateMessage(WXMSG* pMsg);
virtual void MSWDestroyWindow();
// Detach "Window" menu from menu bar so it doesn't get deleted
void MSWDetachWindowMenu();
// this function should return the brush to paint the window background
// with or 0 for the default brush
virtual WXHBRUSH OnCtlColor(WXHDC hDC,
WXHWND hWnd,
WXUINT nCtlColor,
WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam);
#if WXWIN_COMPATIBILITY
void SetShowing(bool show) { (void)Show(show); }
bool IsUserEnabled() const { return IsEnabled(); }
#endif // WXWIN_COMPATIBILITY
// Responds to colour changes: passes event on to children.
void OnSysColourChanged(wxSysColourChangedEvent& event);
// initialize various fields of wxMouseEvent (common part of MSWOnMouseXXX)
void InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags);
protected:
// the window handle
WXHWND m_hWnd;
// the old window proc (we subclass all windows)
WXFARPROC m_oldWndProc;
// additional (MSW specific) flags
bool m_useCtl3D:1; // Using CTL3D for this control
bool m_backgroundTransparent:1;
bool m_mouseInWindow:1;
bool m_doubleClickAllowed:1;
bool m_winCaptured:1;
// the size of one page for scrolling
int m_xThumbSize;
int m_yThumbSize;
#if wxUSE_MOUSEEVENT_HACK
// the coordinates of the last mouse event and the type of it
long m_lastMouseX,
m_lastMouseY;
int m_lastMouseEvent;
#endif // wxUSE_MOUSEEVENT_HACK
WXHMENU m_hMenu; // Menu, if any
// the return value of WM_GETDLGCODE handler
long m_lDlgCode;
// implement the base class pure virtuals
virtual void DoClientToScreen( int *x, int *y ) const;
virtual void DoScreenToClient( int *x, int *y ) const;
virtual void DoGetPosition( int *x, int *y ) const;
virtual void DoGetSize( int *width, int *height ) const;
virtual void DoGetClientSize( int *width, int *height ) const;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
virtual void DoSetClientSize(int width, int height);
// move the window to the specified location and resize it: this is called
// from both DoSetSize() and DoSetClientSize() and would usually just call
// ::MoveWindow() except for composite controls which will want to arrange
// themselves inside the given rectangle
virtual void DoMoveWindow(int x, int y, int width, int height);
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip );
#endif // wxUSE_TOOLTIPS
private:
// common part of all ctors
void Init();
// the (non-virtual) handlers for the events
bool HandleMove(int x, int y);
bool HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags);
#ifdef __WIN95__
bool HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
#endif // __WIN95__
// the helper functions used by HandleChar/KeyXXX methods
wxKeyEvent CreateKeyEvent(wxEventType evType, int id, WXLPARAM lp) const;
DECLARE_DYNAMIC_CLASS(wxWindow);
DECLARE_NO_COPY_CLASS(wxWindow);
DECLARE_EVENT_TABLE()
};
// ---------------------------------------------------------------------------
// global functions
// ---------------------------------------------------------------------------
// kbd code translation
WXDLLEXPORT int wxCharCodeMSWToWX(int keySym);
WXDLLEXPORT int wxCharCodeWXToMSW(int id, bool *IsVirtual);
#endif
// _WX_WINDOW_H_

112
include/wx/time.h Normal file
View File

@@ -0,0 +1,112 @@
/////////////////////////////////////////////////////////////////////////////
// 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__

656
src/common/date.cpp Normal file
View File

@@ -0,0 +1,656 @@
/////////////////////////////////////////////////////////////////////////////
// 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

File diff suppressed because it is too large Load Diff

447
src/common/time.cpp Normal file
View File

@@ -0,0 +1,447 @@
/////////////////////////////////////////////////////////////////////////////
// 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

File diff suppressed because it is too large Load Diff

View File

@@ -1,704 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: generic/scrolwin.cpp
// Purpose: wxGenericScrolledWindow implementation
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "scrolwin.h"
#endif
#ifdef __VMS
#define XtDisplay XTDISPLAY
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#include "wx/utils.h"
#include "wx/dcclient.h"
#include "wx/generic/scrolwin.h"
#include "wx/panel.h"
#ifdef __WXMSW__
#include "windows.h"
#endif
#ifdef __WXMOTIF__
// For wxRETAINED implementation
#ifdef __VMS__ //VMS's Xm.h is not (yet) compatible with C++
//This code switches off the compiler warnings
# pragma message disable nosimpint
#endif
#include <Xm/Xm.h>
#ifdef __VMS__
# pragma message enable nosimpint
#endif
#endif
#ifndef __WXGTK__
#include "wx/scrolwin.h"
IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow)
#endif
// ----------------------------------------------------------------------------
// event tables
// ----------------------------------------------------------------------------
BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel)
EVT_SCROLLWIN(wxGenericScrolledWindow::OnScroll)
EVT_SIZE(wxGenericScrolledWindow::OnSize)
EVT_PAINT(wxGenericScrolledWindow::OnPaint)
EVT_CHAR(wxGenericScrolledWindow::OnChar)
END_EVENT_TABLE()
IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel)
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxGenericScrolledWindow creation
// ----------------------------------------------------------------------------
wxGenericScrolledWindow::wxGenericScrolledWindow()
{
m_xScrollPixelsPerLine = 0;
m_yScrollPixelsPerLine = 0;
m_xScrollingEnabled = TRUE;
m_yScrollingEnabled = TRUE;
m_xScrollPosition = 0;
m_yScrollPosition = 0;
m_xScrollLines = 0;
m_yScrollLines = 0;
m_xScrollLinesPerPage = 0;
m_yScrollLinesPerPage = 0;
m_scaleX = 1.0;
m_scaleY = 1.0;
m_targetWindow = (wxWindow*) NULL;
}
bool wxGenericScrolledWindow::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
m_xScrollPixelsPerLine = 0;
m_yScrollPixelsPerLine = 0;
m_xScrollingEnabled = TRUE;
m_yScrollingEnabled = TRUE;
m_xScrollPosition = 0;
m_yScrollPosition = 0;
m_xScrollLines = 0;
m_yScrollLines = 0;
m_xScrollLinesPerPage = 0;
m_yScrollLinesPerPage = 0;
m_scaleX = 1.0;
m_scaleY = 1.0;
m_targetWindow = this;
bool ok = wxPanel::Create(parent, id, pos, size, style, name);
#ifdef __WXMSW__
// we need to process arrows ourselves for scrolling
m_lDlgCode |= DLGC_WANTARROWS;
#endif // __WXMSW__
return ok;
}
wxGenericScrolledWindow::~wxGenericScrolledWindow()
{
}
// ----------------------------------------------------------------------------
// setting scrolling parameters
// ----------------------------------------------------------------------------
/*
* pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
* noUnitsX/noUnitsY: : no. units per scrollbar
*/
void wxGenericScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
int noUnitsX, int noUnitsY,
int xPos, int yPos, bool noRefresh )
{
int xpos, ypos;
CalcUnscrolledPosition(xPos, yPos, &xpos, &ypos);
bool do_refresh =
(
(noUnitsX != 0 && m_xScrollLines == 0) ||
(noUnitsX < m_xScrollLines && xpos > pixelsPerUnitX*noUnitsX) ||
(noUnitsY != 0 && m_yScrollLines == 0) ||
(noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY*noUnitsY) ||
(xPos != m_xScrollPosition) ||
(yPos != m_yScrollPosition)
// (pixelsPerUnitX != m_xScrollPixelsPerLine) ||
// (pixelsPerUnitY != m_yScrollPixelsPerLine)
);
m_xScrollPixelsPerLine = pixelsPerUnitX;
m_yScrollPixelsPerLine = pixelsPerUnitY;
m_xScrollPosition = xPos;
m_yScrollPosition = yPos;
m_xScrollLines = noUnitsX;
m_yScrollLines = noUnitsY;
#ifdef __WXMOTIF__
// Sorry, some Motif-specific code to implement a backing pixmap
// for the wxRETAINED style. Implementing a backing store can't
// be entirely generic because it relies on the wxWindowDC implementation
// to duplicate X drawing calls for the backing pixmap.
if ((m_windowStyle & wxRETAINED) == wxRETAINED)
{
Display* dpy = XtDisplay((Widget) GetMainWidget());
int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine;
int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine;
if (m_backingPixmap &&
!((m_pixmapWidth == totalPixelWidth) &&
(m_pixmapHeight == totalPixelHeight)))
{
XFreePixmap (dpy, (Pixmap) m_backingPixmap);
m_backingPixmap = (WXPixmap) 0;
}
if (!m_backingPixmap &&
(noUnitsX != 0) && (noUnitsY != 0))
{
int depth = wxDisplayDepth();
m_pixmapWidth = totalPixelWidth;
m_pixmapHeight = totalPixelHeight;
m_backingPixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
m_pixmapWidth, m_pixmapHeight, depth);
}
}
#endif // Motif
AdjustScrollbars();
if (do_refresh && !noRefresh)
m_targetWindow->Refresh();
#ifdef __WXMSW__
// GRG: if this turns out to be really necessary, we could
// at least move it to the above if { ... } so that it is
// only done if noRefresh = FALSE (the default). OTOH, if
// this doesn't break anything, which seems to be the
// case, we could just leave it out.
// Necessary?
// UpdateWindow ((HWND) m_targetWindow->GetHWND());
#endif
#ifdef __WXMAC__
m_targetWindow->MacUpdateImmediately() ;
#endif
}
// ----------------------------------------------------------------------------
// target window handling
// ----------------------------------------------------------------------------
void wxGenericScrolledWindow::SetTargetWindow( wxWindow *target )
{
wxASSERT_MSG( target, wxT("target window must not be NULL") );
m_targetWindow = target;
}
wxWindow *wxGenericScrolledWindow::GetTargetWindow()
{
return m_targetWindow;
}
// ----------------------------------------------------------------------------
// scrolling implementation itself
// ----------------------------------------------------------------------------
void wxGenericScrolledWindow::OnScroll(wxScrollWinEvent& event)
{
int orient = event.GetOrientation();
int nScrollInc = CalcScrollInc(event);
if (nScrollInc == 0) return;
if (orient == wxHORIZONTAL)
{
int newPos = m_xScrollPosition + nScrollInc;
SetScrollPos(wxHORIZONTAL, newPos, TRUE );
}
else
{
int newPos = m_yScrollPosition + nScrollInc;
SetScrollPos(wxVERTICAL, newPos, TRUE );
}
if (orient == wxHORIZONTAL)
{
m_xScrollPosition += nScrollInc;
}
else
{
m_yScrollPosition += nScrollInc;
}
if (orient == wxHORIZONTAL)
{
if (m_xScrollingEnabled)
m_targetWindow->ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, (const wxRect *) NULL);
else
m_targetWindow->Refresh();
}
else
{
if (m_yScrollingEnabled)
m_targetWindow->ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, (const wxRect *) NULL);
else
m_targetWindow->Refresh();
}
#ifdef __WXMAC__
m_targetWindow->MacUpdateImmediately() ;
#endif
}
int wxGenericScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
{
int pos = event.GetPosition();
int orient = event.GetOrientation();
int nScrollInc = 0;
if (event.GetEventType() == wxEVT_SCROLLWIN_TOP)
{
if (orient == wxHORIZONTAL)
nScrollInc = - m_xScrollPosition;
else
nScrollInc = - m_yScrollPosition;
} else
if (event.GetEventType() == wxEVT_SCROLLWIN_BOTTOM)
{
if (orient == wxHORIZONTAL)
nScrollInc = m_xScrollLines - m_xScrollPosition;
else
nScrollInc = m_yScrollLines - m_yScrollPosition;
} else
if (event.GetEventType() == wxEVT_SCROLLWIN_LINEUP)
{
nScrollInc = -1;
} else
if (event.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN)
{
nScrollInc = 1;
} else
if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEUP)
{
if (orient == wxHORIZONTAL)
nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
else
nScrollInc = -GetScrollPageSize(wxVERTICAL);
} else
if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEDOWN)
{
if (orient == wxHORIZONTAL)
nScrollInc = GetScrollPageSize(wxHORIZONTAL);
else
nScrollInc = GetScrollPageSize(wxVERTICAL);
} else
if ((event.GetEventType() == wxEVT_SCROLLWIN_THUMBTRACK) ||
(event.GetEventType() == wxEVT_SCROLLWIN_THUMBRELEASE))
{
if (orient == wxHORIZONTAL)
nScrollInc = pos - m_xScrollPosition;
else
nScrollInc = pos - m_yScrollPosition;
}
if (orient == wxHORIZONTAL)
{
if (m_xScrollPixelsPerLine > 0)
{
int w, h;
m_targetWindow->GetClientSize(&w, &h);
int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 );
if (noPositions < 0)
noPositions = 0;
if ( (m_xScrollPosition + nScrollInc) < 0 )
nScrollInc = -m_xScrollPosition; // As -ve as we can go
else if ( (m_xScrollPosition + nScrollInc) > noPositions )
nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
}
else
m_targetWindow->Refresh();
}
else
{
if (m_yScrollPixelsPerLine > 0)
{
int w, h;
m_targetWindow->GetClientSize(&w, &h);
int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
int noPositions = (int) ( ((nMaxHeight - h)/(double)m_yScrollPixelsPerLine) + 0.5 );
if (noPositions < 0)
noPositions = 0;
if ( (m_yScrollPosition + nScrollInc) < 0 )
nScrollInc = -m_yScrollPosition; // As -ve as we can go
else if ( (m_yScrollPosition + nScrollInc) > noPositions )
nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go
}
else
m_targetWindow->Refresh();
}
return nScrollInc;
}
// Adjust the scrollbars - new version.
void wxGenericScrolledWindow::AdjustScrollbars()
{
int w, h;
m_targetWindow->GetClientSize(&w, &h);
int oldXScroll = m_xScrollPosition;
int oldYScroll = m_yScrollPosition;
if (m_xScrollLines > 0)
{
// Calculate page size i.e. number of scroll units you get on the
// current client window
int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
if (noPagePositions < 1) noPagePositions = 1;
// Correct position if greater than extent of canvas minus
// the visible portion of it or if below zero
m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition);
m_xScrollPosition = wxMax( 0, m_xScrollPosition );
SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);
// The amount by which we scroll when paging
SetScrollPageSize(wxHORIZONTAL, noPagePositions);
}
else
{
m_xScrollPosition = 0;
SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);
}
if (m_yScrollLines > 0)
{
// Calculate page size i.e. number of scroll units you get on the
// current client window
int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
if (noPagePositions < 1) noPagePositions = 1;
// Correct position if greater than extent of canvas minus
// the visible portion of it or if below zero
m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
m_yScrollPosition = wxMax( 0, m_yScrollPosition );
SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines);
// The amount by which we scroll when paging
SetScrollPageSize(wxVERTICAL, noPagePositions);
}
else
{
m_yScrollPosition = 0;
SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE);
}
if (oldXScroll != m_xScrollPosition)
{
if (m_xScrollingEnabled)
m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll-m_xScrollPosition), 0, (const wxRect *) NULL );
else
m_targetWindow->Refresh();
}
if (oldYScroll != m_yScrollPosition)
{
if (m_yScrollingEnabled)
m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), (const wxRect *) NULL );
else
m_targetWindow->Refresh();
}
}
// Override this function if you don't want to have wxGenericScrolledWindow
// automatically change the origin according to the scroll position.
void wxGenericScrolledWindow::PrepareDC(wxDC& dc)
{
dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine,
-m_yScrollPosition * m_yScrollPixelsPerLine );
dc.SetUserScale( m_scaleX, m_scaleY );
}
#if WXWIN_COMPATIBILITY
void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const
{
*x_page = GetScrollPageSize(wxHORIZONTAL);
*y_page = GetScrollPageSize(wxVERTICAL);
}
void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const
{
if ( xx )
*xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine);
if ( yy )
*yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine);
}
#endif // WXWIN_COMPATIBILITY
void wxGenericScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
{
if ( x_unit )
*x_unit = m_xScrollPixelsPerLine;
if ( y_unit )
*y_unit = m_yScrollPixelsPerLine;
}
int wxGenericScrolledWindow::GetScrollPageSize(int orient) const
{
if ( orient == wxHORIZONTAL )
return m_xScrollLinesPerPage;
else
return m_yScrollLinesPerPage;
}
void wxGenericScrolledWindow::SetScrollPageSize(int orient, int pageSize)
{
if ( orient == wxHORIZONTAL )
m_xScrollLinesPerPage = pageSize;
else
m_yScrollLinesPerPage = pageSize;
}
/*
* Scroll to given position (scroll position, not pixel position)
*/
void wxGenericScrolledWindow::Scroll( int x_pos, int y_pos )
{
if (!m_targetWindow)
return;
if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
int w, h;
m_targetWindow->GetClientSize(&w, &h);
if ((x_pos != -1) && (m_xScrollPixelsPerLine))
{
int old_x = m_xScrollPosition;
m_xScrollPosition = x_pos;
// Calculate page size i.e. number of scroll units you get on the
// current client window
int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
if (noPagePositions < 1) noPagePositions = 1;
// Correct position if greater than extent of canvas minus
// the visible portion of it or if below zero
m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
m_xScrollPosition = wxMax( 0, m_xScrollPosition );
if (old_x != m_xScrollPosition) {
m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE );
m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0 );
}
}
if ((y_pos != -1) && (m_yScrollPixelsPerLine))
{
int old_y = m_yScrollPosition;
m_yScrollPosition = y_pos;
// Calculate page size i.e. number of scroll units you get on the
// current client window
int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
if (noPagePositions < 1) noPagePositions = 1;
// Correct position if greater than extent of canvas minus
// the visible portion of it or if below zero
m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
m_yScrollPosition = wxMax( 0, m_yScrollPosition );
if (old_y != m_yScrollPosition) {
m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition, TRUE );
m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine );
}
}
#ifdef __WXMAC__
m_targetWindow->MacUpdateImmediately();
#endif
}
void wxGenericScrolledWindow::EnableScrolling (bool x_scroll, bool y_scroll)
{
m_xScrollingEnabled = x_scroll;
m_yScrollingEnabled = y_scroll;
}
void wxGenericScrolledWindow::GetVirtualSize (int *x, int *y) const
{
if ( x )
*x = m_xScrollPixelsPerLine * m_xScrollLines;
if ( y )
*y = m_yScrollPixelsPerLine * m_yScrollLines;
}
// Where the current view starts from
void wxGenericScrolledWindow::GetViewStart (int *x, int *y) const
{
if ( x )
*x = m_xScrollPosition;
if ( y )
*y = m_yScrollPosition;
}
void wxGenericScrolledWindow::CalcScrolledPosition(int x, int y, int *xx, int *yy) const
{
if ( xx )
*xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
if ( yy )
*yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
}
void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
{
if ( xx )
*xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
if ( yy )
*yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
}
// ----------------------------------------------------------------------------
// event handlers
// ----------------------------------------------------------------------------
// Default OnSize resets scrollbars, if any
void wxGenericScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
{
#if wxUSE_CONSTRAINTS
if (GetAutoLayout())
Layout();
#endif
AdjustScrollbars();
}
// This calls OnDraw, having adjusted the origin according to the current
// scroll position
void wxGenericScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
{
wxPaintDC dc(this);
PrepareDC(dc);
OnDraw(dc);
}
// kbd handling: notice that we use OnChar() and not OnKeyDown() for
// compatibility here - if we used OnKeyDown(), the programs which process
// arrows themselves in their OnChar() would never get the message and like
// this they always have the priority
void wxGenericScrolledWindow::OnChar(wxKeyEvent& event)
{
int stx, sty, // view origin
szx, szy, // view size (total)
clix, cliy; // view size (on screen)
ViewStart(&stx, &sty);
GetClientSize(&clix, &cliy);
GetVirtualSize(&szx, &szy);
if( m_xScrollPixelsPerLine )
{
clix /= m_xScrollPixelsPerLine;
szx /= m_xScrollPixelsPerLine;
}
else
{
clix = 0;
szx = -1;
}
if( m_yScrollPixelsPerLine )
{
cliy /= m_yScrollPixelsPerLine;
szy /= m_yScrollPixelsPerLine;
}
else
{
cliy = 0;
szy = -1;
}
int dsty;
switch ( event.KeyCode() )
{
case WXK_PAGEUP:
case WXK_PRIOR:
dsty = sty - (5 * cliy / 6);
Scroll(-1, (dsty == -1) ? 0 : dsty);
break;
case WXK_PAGEDOWN:
case WXK_NEXT:
Scroll(-1, sty + (5 * cliy / 6));
break;
case WXK_HOME:
Scroll(0, event.ControlDown() ? 0 : -1);
break;
case WXK_END:
Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1);
break;
case WXK_UP:
Scroll(-1, sty - 1);
break;
case WXK_DOWN:
Scroll(-1, sty + 1);
break;
case WXK_LEFT:
Scroll(stx - 1, -1);
break;
case WXK_RIGHT:
Scroll(stx + 1, -1);
break;
default:
// not for us
event.Skip();
}
}

File diff suppressed because it is too large Load Diff