http://code.google.com/p/rpcs3/source/detail?r=44

wxWidgets/include/wx/generic/aboutdlgg.h

@@ -0,0 +1,87 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/aboutdlgg.h
+// Purpose:     generic wxAboutBox() implementation
+// Author:      Vadim Zeitlin
+// Created:     2006-10-07
+// RCS-ID:      $Id: aboutdlgg.h 49804 2007-11-10 01:09:42Z VZ $
+// Copyright:   (c) 2006 Vadim Zeitlin <vadim@wxwindows.org>
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_ABOUTDLGG_H_
+#define _WX_GENERIC_ABOUTDLGG_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_ABOUTDLG
+
+#include "wx/dialog.h"
+
+class WXDLLIMPEXP_FWD_ADV wxAboutDialogInfo;
+class WXDLLIMPEXP_FWD_CORE wxSizer;
+class WXDLLIMPEXP_FWD_CORE wxSizerFlags;
+
+// ----------------------------------------------------------------------------
+// wxGenericAboutDialog: generic "About" dialog implementation
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxGenericAboutDialog : public wxDialog
+{
+public:
+    // constructors and Create() method
+    // --------------------------------
+
+    // default ctor, you must use Create() to really initialize the dialog
+    wxGenericAboutDialog() { Init(); }
+
+    // ctor which fully initializes the object
+    wxGenericAboutDialog(const wxAboutDialogInfo& info)
+    {
+        Init();
+
+        (void)Create(info);
+    }
+
+    // this method must be called if and only if the default ctor was used
+    bool Create(const wxAboutDialogInfo& info);
+
+protected:
+    // this virtual method may be overridden to add some more controls to the
+    // dialog
+    //
+    // notice that for this to work you must call Create() from the derived
+    // class ctor and not use the base class ctor directly as otherwise the
+    // virtual function of the derived class wouldn't be called
+    virtual void DoAddCustomControls() { }
+
+    // add arbitrary control to the text sizer contents with the specified
+    // flags
+    void AddControl(wxWindow *win, const wxSizerFlags& flags);
+
+    // add arbitrary control to the text sizer contents and center it
+    void AddControl(wxWindow *win);
+
+    // add the text, if it's not empty, to the text sizer contents
+    void AddText(const wxString& text);
+
+#if wxUSE_COLLPANE
+    // add a wxCollapsiblePane containing the given text
+    void AddCollapsiblePane(const wxString& title, const wxString& text);
+#endif // wxUSE_COLLPANE
+
+private:
+    // common part of all ctors
+    void Init() { m_sizerText = NULL; }
+
+
+    wxSizer *m_sizerText;
+};
+
+// unlike wxAboutBox which can show either the native or generic about dialog,
+// this function always shows the generic one
+WXDLLIMPEXP_ADV void wxGenericAboutBox(const wxAboutDialogInfo& info);
+
+#endif // wxUSE_ABOUTDLG
+
+#endif // _WX_GENERIC_ABOUTDLGG_H_
+

wxWidgets/include/wx/generic/accel.h

@@ -0,0 +1,50 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/accel.h
+// Purpose:     wxAcceleratorTable class
+// Author:      Robert Roebling
+// RCS-ID:      $Id: accel.h 42752 2006-10-30 19:26:48Z VZ $
+// Copyright:   (c) Robert Roebling
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_ACCEL_H_
+#define _WX_GENERIC_ACCEL_H_
+
+class WXDLLEXPORT wxKeyEvent;
+
+// ----------------------------------------------------------------------------
+// wxAcceleratorTable
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxAcceleratorTable : public wxObject
+{
+public:
+    wxAcceleratorTable();
+    wxAcceleratorTable(int n, const wxAcceleratorEntry entries[]);
+    virtual ~wxAcceleratorTable();
+
+    bool Ok() const { return IsOk(); }
+    bool IsOk() const;
+
+    void Add(const wxAcceleratorEntry& entry);
+    void Remove(const wxAcceleratorEntry& entry);
+
+    // implementation
+    // --------------
+
+    wxMenuItem *GetMenuItem(const wxKeyEvent& event) const;
+    int GetCommand(const wxKeyEvent& event) const;
+
+    const wxAcceleratorEntry *GetEntry(const wxKeyEvent& event) const;
+
+protected:
+    // ref counting code
+    virtual wxObjectRefData *CreateRefData() const;
+    virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxAcceleratorTable)
+};
+
+#endif // _WX_GENERIC_ACCEL_H_
+

wxWidgets/include/wx/generic/animate.h

@@ -0,0 +1,178 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/animate.h
+// Purpose:     wxAnimation and wxAnimationCtrl
+// Author:      Julian Smart and Guillermo Rodriguez Garcia
+// Modified by: Francesco Montorsi
+// Created:     13/8/99
+// RCS-ID:      $Id: animate.h 58350 2009-01-24 10:00:38Z FM $
+// Copyright:   (c) Julian Smart and Guillermo Rodriguez Garcia
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_ANIMATEH__
+#define _WX_GENERIC_ANIMATEH__
+
+#include "wx/bitmap.h"
+
+// ----------------------------------------------------------------------------
+// wxAnimation
+// ----------------------------------------------------------------------------
+
+WX_DECLARE_LIST_WITH_DECL(wxAnimationDecoder, wxAnimationDecoderList, class WXDLLIMPEXP_ADV);
+
+class WXDLLIMPEXP_ADV wxAnimation : public wxAnimationBase
+{
+public:
+#if wxABI_VERSION >= 20810
+    wxAnimation() {}
+    wxAnimation(const wxString &name, wxAnimationType type = wxANIMATION_TYPE_ANY)
+        { LoadFile(name, type); }
+#endif
+    virtual bool IsOk() const
+        { return m_refData != NULL; }
+
+    virtual unsigned int GetFrameCount() const;
+    virtual int GetDelay(unsigned int i) const;
+    virtual wxImage GetFrame(unsigned int i) const;
+    virtual wxSize GetSize() const;
+
+    virtual bool LoadFile(const wxString& filename,
+                          wxAnimationType type = wxANIMATION_TYPE_ANY);
+    virtual bool Load(wxInputStream& stream,
+                      wxAnimationType type = wxANIMATION_TYPE_ANY);
+
+    // extended interface used by the generic implementation of wxAnimationCtrl
+    wxPoint GetFramePosition(unsigned int frame) const;
+    wxSize GetFrameSize(unsigned int frame) const;
+    wxAnimationDisposal GetDisposalMethod(unsigned int frame) const;
+    wxColour GetTransparentColour(unsigned int frame) const;
+    wxColour GetBackgroundColour() const;
+
+protected:
+    static wxAnimationDecoderList sm_handlers;
+
+public:
+    static inline wxAnimationDecoderList& GetHandlers() { return sm_handlers; }
+    static void AddHandler(wxAnimationDecoder *handler);
+    static void InsertHandler(wxAnimationDecoder *handler);
+    static const wxAnimationDecoder *FindHandler( wxAnimationType animType );
+
+    static void CleanUpHandlers();
+    static void InitStandardHandlers();
+
+    DECLARE_DYNAMIC_CLASS(wxAnimation)
+};
+
+
+// ----------------------------------------------------------------------------
+// wxAnimationCtrl
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxAnimationCtrl: public wxAnimationCtrlBase
+{
+public:
+    wxAnimationCtrl() { Init(); }
+    wxAnimationCtrl(wxWindow *parent,
+            wxWindowID id,
+            const wxAnimation& anim = wxNullAnimation,
+            const wxPoint& pos = wxDefaultPosition,
+            const wxSize& size = wxDefaultSize,
+            long style = wxAC_DEFAULT_STYLE,
+            const wxString& name = wxAnimationCtrlNameStr)
+    {
+        Init();
+
+        Create(parent, id, anim, pos, size, style, name);
+    }
+
+    void Init();
+
+    bool Create(wxWindow *parent, wxWindowID id,
+                const wxAnimation& anim = wxNullAnimation,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxAC_DEFAULT_STYLE,
+                const wxString& name = wxAnimationCtrlNameStr);
+
+    ~wxAnimationCtrl();
+
+public:
+    virtual bool LoadFile(const wxString& filename, wxAnimationType type = wxANIMATION_TYPE_ANY);
+
+    virtual void Stop();
+    virtual bool Play()
+        { return Play(true /* looped */); }
+    virtual bool IsPlaying() const
+        { return m_isPlaying; }
+
+    void SetAnimation(const wxAnimation &animation);
+    wxAnimation GetAnimation() const
+        { return m_animation; }
+
+    virtual void SetInactiveBitmap(const wxBitmap &bmp);
+
+    // override base class method
+    virtual bool SetBackgroundColour(const wxColour& col);
+
+public:     // event handlers
+
+    void OnPaint(wxPaintEvent& event);
+    void OnTimer(wxTimerEvent& event);
+    void OnSize(wxSizeEvent& event);
+
+public:     // extended API specific to this implementation of wxAnimateCtrl
+
+    // Specify whether the animation's background colour is to be shown (the default),
+    // or whether the window background should show through
+    void SetUseWindowBackgroundColour(bool useWinBackground = true)
+        { m_useWinBackgroundColour = useWinBackground; }
+    bool IsUsingWindowBackgroundColour() const
+        { return m_useWinBackgroundColour; }
+
+    // This overload of Play() lets you specify if the animation must loop or not
+    bool Play(bool looped);
+
+    // Draw the current frame of the animation into given DC.
+    // This is fast as current frame is always cached.
+    void DrawCurrentFrame(wxDC& dc);
+
+    // Returns a wxBitmap with the current frame drawn in it
+    wxBitmap& GetBackingStore()
+        { return m_backingStore; }
+
+protected:      // internal utilities
+
+    // resize this control to fit m_animation
+    void FitToAnimation();
+
+    // Draw the background; use this when e.g. previous frame had wxANIM_TOBACKGROUND disposal.
+    void DisposeToBackground();
+    void DisposeToBackground(wxDC& dc);
+    void DisposeToBackground(wxDC& dc, const wxPoint &pos, const wxSize &sz);
+
+    void IncrementalUpdateBackingStore();
+    bool RebuildBackingStoreUpToFrame(unsigned int);
+    void DrawFrame(wxDC &dc, unsigned int);
+
+    virtual void DisplayStaticImage();
+    virtual wxSize DoGetBestSize() const;
+
+protected:
+    unsigned int  m_currentFrame;     // Current frame
+    bool          m_looped;           // Looped, or not
+    wxTimer       m_timer;            // The timer
+    wxAnimation   m_animation;        // The animation
+
+    bool          m_isPlaying;        // Is the animation playing?
+    bool          m_useWinBackgroundColour; // Use animation bg colour or window bg colour?
+
+    wxBitmap      m_backingStore;     // The frames are drawn here and then blitted
+                                      // on the screen
+
+private:
+    typedef wxAnimationCtrlBase base_type;
+    DECLARE_DYNAMIC_CLASS(wxAnimationCtrl)
+    DECLARE_EVENT_TABLE()
+};
+
+#endif // _WX_GENERIC_ANIMATEH__

wxWidgets/include/wx/generic/bmpcbox.h

@@ -0,0 +1,170 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/bmpcbox.h
+// Purpose:     wxBitmapComboBox
+// Author:      Jaakko Salli
+// Modified by:
+// Created:     Aug-30-2006
+// RCS-ID:      $Id: bmpcbox.h 42046 2006-10-16 09:30:01Z ABX $
+// Copyright:   (c) Jaakko Salli
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_BMPCBOX_H_
+#define _WX_GENERIC_BMPCBOX_H_
+
+
+#define wxGENERIC_BITMAPCOMBOBOX     1
+
+#include "wx/odcombo.h"
+
+// ----------------------------------------------------------------------------
+// wxBitmapComboBox: a wxComboBox that allows images to be shown
+// in front of string items.
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxBitmapComboBox : public wxOwnerDrawnComboBox,
+                                         public wxBitmapComboBoxBase
+{
+public:
+
+    // ctors and such
+    wxBitmapComboBox() : wxOwnerDrawnComboBox(), wxBitmapComboBoxBase()
+    {
+        Init();
+    }
+
+    wxBitmapComboBox(wxWindow *parent,
+                     wxWindowID id = wxID_ANY,
+                     const wxString& value = wxEmptyString,
+                     const wxPoint& pos = wxDefaultPosition,
+                     const wxSize& size = wxDefaultSize,
+                     int n = 0,
+                     const wxString choices[] = NULL,
+                     long style = 0,
+                     const wxValidator& validator = wxDefaultValidator,
+                     const wxString& name = wxBitmapComboBoxNameStr)
+        : wxOwnerDrawnComboBox(),
+          wxBitmapComboBoxBase()
+    {
+        Init();
+
+        (void)Create(parent, id, value, pos, size, n,
+                     choices, style, validator, name);
+    }
+
+    wxBitmapComboBox(wxWindow *parent,
+                     wxWindowID id,
+                     const wxString& value,
+                     const wxPoint& pos,
+                     const wxSize& size,
+                     const wxArrayString& choices,
+                     long style,
+                     const wxValidator& validator = wxDefaultValidator,
+                     const wxString& name = wxBitmapComboBoxNameStr);
+
+    bool Create(wxWindow *parent,
+                wxWindowID id,
+                const wxString& value,
+                const wxPoint& pos,
+                const wxSize& size,
+                int n,
+                const wxString choices[],
+                long style = 0,
+                const wxValidator& validator = wxDefaultValidator,
+                const wxString& name = wxBitmapComboBoxNameStr);
+
+    bool Create(wxWindow *parent,
+                wxWindowID id,
+                const wxString& value,
+                const wxPoint& pos,
+                const wxSize& size,
+                const wxArrayString& choices,
+                long style = 0,
+                const wxValidator& validator = wxDefaultValidator,
+                const wxString& name = wxBitmapComboBoxNameStr);
+
+    virtual ~wxBitmapComboBox();
+
+    // Adds item with image to the end of the combo box.
+    int Append(const wxString& item, const wxBitmap& bitmap = wxNullBitmap)
+        { return DoAppendWithImage(item, bitmap); }
+
+    int Append(const wxString& item, const wxBitmap& bitmap, void *clientData)
+        { int n = DoAppendWithImage(item, bitmap); SetClientData(n, clientData); return n; }
+    int Append(const wxString& item, const wxBitmap& bitmap, wxClientData *clientData)
+        { int n = DoAppendWithImage(item, bitmap); SetClientObject(n, clientData); return n; }
+
+    // Returns size of image used in list.
+    virtual wxSize GetBitmapSize() const
+    {
+        return m_usedImgSize;
+    }
+
+    // Returns the image of the item with the given index.
+    virtual wxBitmap GetItemBitmap(unsigned int n) const;
+
+    // Inserts item with image into the list before pos. Not valid for wxCB_SORT or wxCB_SORT
+    // styles, use Append instead.
+    int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int pos)
+        { return DoInsertWithImage(item, bitmap, pos); }
+
+    int Insert(const wxString& item, const wxBitmap& bitmap,
+               unsigned int pos, void *clientData);
+    int Insert(const wxString& item, const wxBitmap& bitmap,
+               unsigned int pos, wxClientData *clientData);
+
+    // Sets the image for the given item.
+    virtual void SetItemBitmap(unsigned int n, const wxBitmap& bitmap);
+
+    virtual void Clear();
+    virtual void Delete(unsigned int n);
+
+protected:
+
+    virtual void OnDrawBackground(wxDC& dc, const wxRect& rect, int item, int flags) const;
+    virtual void OnDrawItem(wxDC& dc, const wxRect& rect, int item, int flags) const;
+    virtual wxCoord OnMeasureItem(size_t item) const;
+    virtual wxCoord OnMeasureItemWidth(size_t item) const;
+
+    virtual int DoAppendWithImage(const wxString& item, const wxBitmap& bitmap);
+    virtual int DoInsertWithImage(const wxString& item, const wxBitmap& bitmap,
+                                  unsigned int pos);
+
+    virtual int DoAppend(const wxString& item);
+    virtual int DoInsert(const wxString& item, unsigned int pos);
+
+    virtual bool SetFont(const wxFont& font);
+
+    virtual wxSize DoGetBestSize() const;
+
+    // Event handlers
+    void OnSize(wxSizeEvent& event);
+
+    // Recalculates amount of empty space needed in front of
+    // text in control itself.
+    void DetermineIndent();
+
+    bool OnAddBitmap(const wxBitmap& bitmap);
+
+    // Adds image to position - called in Append/Insert before
+    // string is added.
+    bool DoInsertBitmap(const wxBitmap& image, unsigned int pos);
+
+
+    wxArrayPtrVoid      m_bitmaps;  // Images associated with items
+    wxSize              m_usedImgSize;  // Size of bitmaps
+
+private:
+    int                 m_imgAreaWidth;  // Width and height of area next to text field
+    int                 m_fontHeight;
+    bool                m_inResize;
+
+    void Init();
+    void PostCreate();
+
+    DECLARE_EVENT_TABLE()
+
+    DECLARE_DYNAMIC_CLASS(wxBitmapComboBox)
+};
+
+#endif // _WX_GENERIC_BMPCBOX_H_

wxWidgets/include/wx/generic/busyinfo.h

@@ -0,0 +1,42 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/busyinfo.h
+// Purpose:     Information window (when app is busy)
+// Author:      Vaclav Slavik
+// Copyright:   (c) 1999 Vaclav Slavik
+// RCS-ID:      $Id: busyinfo.h 49804 2007-11-10 01:09:42Z VZ $
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __BUSYINFO_H__
+#define __BUSYINFO_H__
+
+#include "wx/defs.h"
+
+#if wxUSE_BUSYINFO
+
+class WXDLLIMPEXP_FWD_CORE wxFrame;
+class WXDLLIMPEXP_FWD_CORE wxWindow;
+
+//--------------------------------------------------------------------------------
+// wxBusyInfo
+//                  Displays progress information
+//                  Can be used in exactly same way as wxBusyCursor
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxBusyInfo : public wxObject
+{
+public:
+    wxBusyInfo(const wxString& message, wxWindow *parent = NULL);
+
+    virtual ~wxBusyInfo();
+
+private:
+    wxFrame *m_InfoFrame;
+
+    DECLARE_NO_COPY_CLASS(wxBusyInfo)
+};
+
+
+#endif // wxUSE_BUSYINFO
+
+#endif // __BUSYINFO_H__

wxWidgets/include/wx/generic/buttonbar.h

@@ -0,0 +1,123 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/buttonbar.h
+// Purpose:     wxButtonToolBar declaration
+// Author:      Julian Smart, after Robert Roebling, Vadim Zeitlin, SciTech
+// Modified by:
+// Created:     2006-04-13
+// Id:          $Id: buttonbar.h 38714 2006-04-14 15:49:57Z JS $
+// Copyright:   (c) Julian Smart, Robert Roebling, Vadim Zeitlin,
+//              SciTech Software, Inc. 
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_BUTTONBAR_H_
+#define _WX_BUTTONBAR_H_
+
+#include "wx/bmpbuttn.h"
+#include "wx/toolbar.h"
+
+class WXDLLEXPORT wxButtonToolBarTool;
+
+// ----------------------------------------------------------------------------
+// wxButtonToolBar
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxButtonToolBar : public wxToolBarBase
+{    
+public:
+    // construction/destruction
+    wxButtonToolBar() { Init(); }
+    wxButtonToolBar(wxWindow *parent,
+              wxWindowID id,
+              const wxPoint& pos = wxDefaultPosition,
+              const wxSize& size = wxDefaultSize,
+              long style = 0,
+              const wxString& name = wxToolBarNameStr)
+    {
+        Init();
+
+        Create(parent, id, pos, size, style, name);
+    }
+
+    bool Create( wxWindow *parent,
+                 wxWindowID id,
+                 const wxPoint& pos = wxDefaultPosition,
+                 const wxSize& size = wxDefaultSize,
+                 long style = 0,
+                 const wxString& name = wxToolBarNameStr );
+                 
+    virtual ~wxButtonToolBar();
+
+    virtual bool Realize();
+
+    virtual void SetToolShortHelp(int id, const wxString& helpString);
+    virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const;
+
+protected:
+    // common part of all ctors
+    void Init();
+
+    // implement base class pure virtuals
+    virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool);
+    virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool);
+
+    virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable);
+    virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle);
+    virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle);
+
+    virtual wxToolBarToolBase *CreateTool(int id,
+                                          const wxString& label,
+                                          const wxBitmap& bmpNormal,
+                                          const wxBitmap& bmpDisabled,
+                                          wxItemKind kind,
+                                          wxObject *clientData,
+                                          const wxString& shortHelp,
+                                          const wxString& longHelp);
+    virtual wxToolBarToolBase *CreateTool(wxControl *control);
+
+    virtual wxSize DoGetBestClientSize() const;
+
+    // calculate layout
+    void DoLayout();
+
+    // get the bounding rect for the given tool
+    wxRect GetToolRect(wxToolBarToolBase *tool) const;
+
+    // get the rect limits depending on the orientation: top/bottom for a
+    // vertical toolbar, left/right for a horizontal one
+    void GetRectLimits(const wxRect& rect, wxCoord *start, wxCoord *end) const;
+
+    // receives button commands
+    void OnCommand(wxCommandEvent& event);
+
+    // paints a border
+    void OnPaint(wxPaintEvent& event);
+
+    // detects mouse clicks outside buttons
+    void OnLeftUp(wxMouseEvent& event);
+
+private:
+    // have we calculated the positions of our tools?
+    bool m_needsLayout;
+
+    // the width of a separator
+    wxCoord m_widthSeparator;
+
+    // the total size of all toolbar elements
+    wxCoord m_maxWidth,
+            m_maxHeight;
+
+    // the height of a label
+    int m_labelHeight;
+
+    // the space above the label
+    int m_labelMargin;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxButtonToolBar)
+    DECLARE_EVENT_TABLE()
+};
+
+#endif
+ // _WX_BUTTONBAR_H_
+

wxWidgets/include/wx/generic/calctrl.h

@@ -0,0 +1,324 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        generic/calctrl.h
+// Purpose:     generic implementation of date-picker control
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     29.12.99
+// RCS-ID:      $Id: calctrl.h 61872 2009-09-09 22:37:05Z VZ $
+// Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_CALCTRL_H
+#define _WX_GENERIC_CALCTRL_H
+
+#include "wx/control.h"         // the base class
+#include "wx/dcclient.h"        // for wxPaintDC
+
+class WXDLLIMPEXP_FWD_CORE wxComboBox;
+class WXDLLIMPEXP_FWD_CORE wxStaticText;
+class WXDLLIMPEXP_FWD_CORE wxSpinCtrl;
+
+#define wxCalendarNameStr wxT("CalendarCtrl")
+
+// ----------------------------------------------------------------------------
+// wxCalendarCtrl: a control allowing the user to pick a date interactively
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxCalendarCtrl : public wxControl
+{
+public:
+    // construction
+    wxCalendarCtrl() { Init(); }
+    wxCalendarCtrl(wxWindow *parent,
+                   wxWindowID id,
+                   const wxDateTime& date = wxDefaultDateTime,
+                   const wxPoint& pos = wxDefaultPosition,
+                   const wxSize& size = wxDefaultSize,
+                   long style = wxCAL_SHOW_HOLIDAYS | wxWANTS_CHARS,
+                   const wxString& name = wxCalendarNameStr);
+
+    bool Create(wxWindow *parent,
+                wxWindowID id,
+                const wxDateTime& date = wxDefaultDateTime,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxCAL_SHOW_HOLIDAYS | wxWANTS_CHARS,
+                const wxString& name = wxCalendarNameStr);
+
+    virtual ~wxCalendarCtrl();
+
+    virtual bool Destroy();
+
+    // set/get the current date
+    // ------------------------
+
+    bool SetDate(const wxDateTime& date); // we need to be able to control if the event should be sent in SetDateAndNotify(...)
+    const wxDateTime& GetDate() const { return m_date; }
+
+    // set/get the range in which selection can occur
+    // ---------------------------------------------
+
+    bool SetLowerDateLimit(const wxDateTime& date = wxDefaultDateTime);
+    const wxDateTime& GetLowerDateLimit() const { return m_lowdate; }
+    bool SetUpperDateLimit(const wxDateTime& date = wxDefaultDateTime);
+    const wxDateTime& GetUpperDateLimit() const { return m_highdate; }
+
+    bool SetDateRange(const wxDateTime& lowerdate = wxDefaultDateTime, const wxDateTime& upperdate = wxDefaultDateTime);
+
+    // calendar mode
+    // -------------
+
+    // some calendar styles can't be changed after the control creation by
+    // just using SetWindowStyle() and Refresh() and the functions below
+    // should be used instead for them
+
+    // corresponds to wxCAL_NO_YEAR_CHANGE bit
+    void EnableYearChange(bool enable = true);
+
+    // corresponds to wxCAL_NO_MONTH_CHANGE bit
+    void EnableMonthChange(bool enable = true);
+
+    // corresponds to wxCAL_SHOW_HOLIDAYS bit
+    void EnableHolidayDisplay(bool display = true);
+
+    // customization
+    // -------------
+
+    // header colours are used for painting the weekdays at the top
+    void SetHeaderColours(const wxColour& colFg, const wxColour& colBg)
+    {
+        m_colHeaderFg = colFg;
+        m_colHeaderBg = colBg;
+    }
+
+    const wxColour& GetHeaderColourFg() const { return m_colHeaderFg; }
+    const wxColour& GetHeaderColourBg() const { return m_colHeaderBg; }
+
+    // highlight colour is used for the currently selected date
+    void SetHighlightColours(const wxColour& colFg, const wxColour& colBg)
+    {
+        m_colHighlightFg = colFg;
+        m_colHighlightBg = colBg;
+    }
+
+    const wxColour& GetHighlightColourFg() const { return m_colHighlightFg; }
+    const wxColour& GetHighlightColourBg() const { return m_colHighlightBg; }
+
+    // holiday colour is used for the holidays (if style & wxCAL_SHOW_HOLIDAYS)
+    void SetHolidayColours(const wxColour& colFg, const wxColour& colBg)
+    {
+        m_colHolidayFg = colFg;
+        m_colHolidayBg = colBg;
+    }
+
+    const wxColour& GetHolidayColourFg() const { return m_colHolidayFg; }
+    const wxColour& GetHolidayColourBg() const { return m_colHolidayBg; }
+
+    // an item without custom attributes is drawn with the default colours and
+    // font and without border, setting custom attributes allows to modify this
+    //
+    // the day parameter should be in 1..31 range, for days 29, 30, 31 the
+    // corresponding attribute is just unused if there is no such day in the
+    // current month
+
+    wxCalendarDateAttr *GetAttr(size_t day) const
+    {
+        wxCHECK_MSG( day > 0 && day < 32, NULL, wxT("invalid day") );
+
+        return m_attrs[day - 1];
+    }
+
+    void SetAttr(size_t day, wxCalendarDateAttr *attr)
+    {
+        wxCHECK_RET( day > 0 && day < 32, wxT("invalid day") );
+
+        delete m_attrs[day - 1];
+        m_attrs[day - 1] = attr;
+    }
+
+    void SetHoliday(size_t day);
+
+    void ResetAttr(size_t day) { SetAttr(day, (wxCalendarDateAttr *)NULL); }
+
+    // returns one of wxCAL_HITTEST_XXX constants and fills either date or wd
+    // with the corresponding value (none for NOWHERE, the date for DAY and wd
+    // for HEADER)
+    wxCalendarHitTestResult HitTest(const wxPoint& pos,
+                                    wxDateTime *date = NULL,
+                                    wxDateTime::WeekDay *wd = NULL);
+
+    // implementation only from now on
+    // -------------------------------
+
+    // forward these functions to all subcontrols
+    virtual bool Enable(bool enable = true);
+    virtual bool Show(bool show = true);
+
+    virtual void SetWindowStyleFlag(long style);
+
+    virtual wxVisualAttributes GetDefaultAttributes() const
+        { return GetClassDefaultAttributes(GetWindowVariant()); }
+
+    static wxVisualAttributes
+    GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
+
+    void OnSysColourChanged(wxSysColourChangedEvent& event);
+
+protected:
+    // override some base class virtuals
+    virtual wxSize DoGetBestSize() const;
+    virtual void DoGetPosition(int *x, int *y) const;
+    virtual void DoGetSize(int *width, int *height) const;
+    virtual void DoSetSize(int x, int y, int width, int height, int sizeFlags);
+    virtual void DoMoveWindow(int x, int y, int width, int height);
+
+private:
+    // common part of all ctors
+    void Init();
+
+    // startup colours and reinitialization after colour changes in system
+    void InitColours();
+
+    // event handlers
+    void OnPaint(wxPaintEvent& event);
+    void OnClick(wxMouseEvent& event);
+    void OnDClick(wxMouseEvent& event);
+    void OnChar(wxKeyEvent& event);
+    void OnMonthChange(wxCommandEvent& event);
+    void OnYearChange(wxCommandEvent& event);
+    void OnYearTextChange(wxCommandEvent& event);
+
+    // (re)calc m_widthCol and m_heightRow
+    void RecalcGeometry();
+
+    // set the date and send the notification
+    void SetDateAndNotify(const wxDateTime& date);
+
+    // get the week (row, in range 1..6) for the given date
+    size_t GetWeek(const wxDateTime& date) const;
+
+    // get the date from which we start drawing days
+    wxDateTime GetStartDate() const;
+
+    // is this date shown?
+    bool IsDateShown(const wxDateTime& date) const;
+
+    // is this date in the given range?
+    bool IsDateInRange(const wxDateTime& date) const;
+
+    // range helpers
+    bool ChangeYear(wxDateTime* target) const;
+    bool ChangeMonth(wxDateTime* target) const;
+
+    // redraw the given date
+    void RefreshDate(const wxDateTime& date);
+
+    // change the date inside the same month/year
+    void ChangeDay(const wxDateTime& date);
+
+    // set the attributes for the holidays if needed
+    void SetHolidayAttrs();
+
+    // reset all holidays
+    void ResetHolidayAttrs();
+
+    // generate the given calendar event(s)
+    void GenerateEvent(wxEventType type)
+    {
+        wxCalendarEvent event(this, type);
+        (void)GetEventHandler()->ProcessEvent(event);
+    }
+
+    void GenerateEvents(wxEventType type1, wxEventType type2)
+    {
+        GenerateEvent(type1);
+        GenerateEvent(type2);
+    }
+
+    // do we allow changing the month/year?
+    bool AllowMonthChange() const
+    {
+        return (GetWindowStyle() & wxCAL_NO_MONTH_CHANGE)
+                != wxCAL_NO_MONTH_CHANGE;
+    }
+    bool AllowYearChange() const
+    {
+        return !(GetWindowStyle() & wxCAL_NO_YEAR_CHANGE);
+    }
+
+    // show the correct controls
+    void ShowCurrentControls();
+
+    // create the month combo and year spin controls
+    void CreateMonthComboBox();
+    void CreateYearSpinCtrl();
+
+public:
+    // get the currently shown control for month/year
+    wxControl *GetMonthControl() const;
+    wxControl *GetYearControl() const;
+
+private:
+    // OnPaint helper-methods
+
+    // Highlight the [fromdate : todate] range using pen and brush
+    void HighlightRange(wxPaintDC* dc, const wxDateTime& fromdate, const wxDateTime& todate, const wxPen* pen, const wxBrush* brush);
+
+    // Get the "coordinates" for the date relative to the month currently displayed.
+    // using (day, week): upper left coord is (1, 1), lower right coord is (7, 6)
+    // if the date isn't visible (-1, -1) is put in (day, week) and false is returned
+    bool GetDateCoord(const wxDateTime& date, int *day, int *week) const;
+
+    // Set the flag for SetDate(): otherwise it would overwrite the year
+    // typed in by the user
+    void SetUserChangedYear() { m_userChangedYear = true; }
+
+    // the subcontrols
+    wxStaticText *m_staticMonth;
+    wxComboBox *m_comboMonth;
+
+    wxStaticText *m_staticYear;
+    wxSpinCtrl *m_spinYear;
+
+    // the current selection
+    wxDateTime m_date;
+
+    // the date-range
+    wxDateTime m_lowdate;
+    wxDateTime m_highdate;
+
+    // default attributes
+    wxColour m_colHighlightFg,
+             m_colHighlightBg,
+             m_colHolidayFg,
+             m_colHolidayBg,
+             m_colHeaderFg,
+             m_colHeaderBg,
+             m_colBackground,
+             m_colSorrounding;
+
+    // the attributes for each of the month days
+    wxCalendarDateAttr *m_attrs[31];
+
+    // the width and height of one column/row in the calendar
+    wxCoord m_widthCol,
+            m_heightRow,
+            m_rowOffset;
+
+    wxRect m_leftArrowRect,
+           m_rightArrowRect;
+
+    // the week day names
+    wxString m_weekdays[7];
+
+    // true if SetDate() is being called as the result of changing the year in
+    // the year control
+    bool m_userChangedYear;
+
+    DECLARE_DYNAMIC_CLASS(wxCalendarCtrl)
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxCalendarCtrl)
+};
+
+#endif // _WX_GENERIC_CALCTRL_H

wxWidgets/include/wx/generic/caret.h

@@ -0,0 +1,95 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        generic/caret.h
+// Purpose:     generic wxCaret class
+// Author:      Vadim Zeitlin (original code by Robert Roebling)
+// Modified by:
+// Created:     25.05.99
+// RCS-ID:      $Id: caret.h 42397 2006-10-25 12:12:56Z VS $
+// Copyright:   (c) wxWidgets team
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_CARET_H_
+#define _WX_CARET_H_
+
+#include "wx/timer.h"
+#include "wx/dc.h"
+#include "wx/overlay.h"
+
+#ifdef wxHAS_NATIVE_OVERLAY
+    #define wxHAS_CARET_USING_OVERLAYS
+#endif
+
+class WXDLLIMPEXP_CORE wxCaret;
+
+class WXDLLEXPORT wxCaretTimer : public wxTimer
+{
+public:
+    wxCaretTimer(wxCaret *caret);
+    virtual void Notify();
+
+private:
+    wxCaret *m_caret;
+};
+
+class WXDLLIMPEXP_CORE wxCaret : public wxCaretBase
+{
+public:
+    // ctors
+    // -----
+        // default - use Create()
+    wxCaret() : m_timer(this) { InitGeneric(); }
+        // creates a block caret associated with the given window
+    wxCaret(wxWindowBase *window, int width, int height)
+        : wxCaretBase(window, width, height), m_timer(this) { InitGeneric(); }
+    wxCaret(wxWindowBase *window, const wxSize& size)
+        : wxCaretBase(window, size), m_timer(this) { InitGeneric(); }
+
+    virtual ~wxCaret();
+
+    // implementation
+    // --------------
+
+    // called by wxWindow (not using the event tables)
+    virtual void OnSetFocus();
+    virtual void OnKillFocus();
+
+    // called by wxCaretTimer
+    void OnTimer();
+
+protected:
+    virtual void DoShow();
+    virtual void DoHide();
+    virtual void DoMove();
+    virtual void DoSize();
+
+    // blink the caret once
+    void Blink();
+
+    // refresh the caret
+    void Refresh();
+
+    // draw the caret on the given DC
+    void DoDraw(wxDC *dc);
+
+private:
+    // GTK specific initialization
+    void InitGeneric();
+
+#ifdef wxHAS_CARET_USING_OVERLAYS
+    // the overlay for displaying the caret
+    wxOverlay   m_overlay;
+#else
+    // the bitmap holding the part of window hidden by the caret when it was
+    // at (m_xOld, m_yOld)
+    wxBitmap      m_bmpUnderCaret;
+    int           m_xOld,
+                  m_yOld;
+#endif
+
+    wxCaretTimer  m_timer;
+    bool          m_blinkedOut,     // true => caret hidden right now
+                  m_hasFocus;       // true => our window has focus
+};
+
+#endif // _WX_CARET_H_

wxWidgets/include/wx/generic/choicdgg.h

@@ -0,0 +1,320 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/choicdgg.h
+// Purpose:     Generic choice dialogs
+// Author:      Julian Smart
+// Modified by: 03.11.00: VZ to add wxArrayString and multiple sel functions
+// Created:     01/02/97
+// RCS-ID:      $Id: choicdgg.h 49563 2007-10-31 20:46:21Z VZ $
+// Copyright:   (c) wxWidgets team
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_CHOICDGG_H_
+#define _WX_GENERIC_CHOICDGG_H_
+
+#include "wx/dynarray.h"
+#include "wx/dialog.h"
+
+class WXDLLIMPEXP_FWD_CORE wxListBoxBase;
+
+// ----------------------------------------------------------------------------
+// some (ugly...) constants
+// ----------------------------------------------------------------------------
+
+#define wxCHOICE_HEIGHT 150
+#define wxCHOICE_WIDTH 200
+
+#ifdef __WXWINCE__
+#define wxCHOICEDLG_STYLE \
+    (wxDEFAULT_DIALOG_STYLE | wxOK | wxCANCEL | wxCENTRE)
+#else
+#define wxCHOICEDLG_STYLE \
+    (wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxOK | wxCANCEL | wxCENTRE)
+#endif
+
+// ----------------------------------------------------------------------------
+// wxAnyChoiceDialog: a base class for dialogs containing a listbox
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxAnyChoiceDialog : public wxDialog
+{
+public:
+    wxAnyChoiceDialog() { }
+
+    wxAnyChoiceDialog(wxWindow *parent,
+                      const wxString& message,
+                      const wxString& caption,
+                      int n, const wxString *choices,
+                      long styleDlg = wxCHOICEDLG_STYLE,
+                      const wxPoint& pos = wxDefaultPosition,
+                      long styleLbox = wxLB_ALWAYS_SB)
+    {
+        (void)Create(parent, message, caption, n, choices,
+                     styleDlg, pos, styleLbox);
+    }
+    wxAnyChoiceDialog(wxWindow *parent,
+                      const wxString& message,
+                      const wxString& caption,
+                      const wxArrayString& choices,
+                      long styleDlg = wxCHOICEDLG_STYLE,
+                      const wxPoint& pos = wxDefaultPosition,
+                      long styleLbox = wxLB_ALWAYS_SB)
+    {
+        (void)Create(parent, message, caption, choices,
+                     styleDlg, pos, styleLbox);
+    }
+
+    bool Create(wxWindow *parent,
+                const wxString& message,
+                const wxString& caption,
+                int n, const wxString *choices,
+                long styleDlg = wxCHOICEDLG_STYLE,
+                const wxPoint& pos = wxDefaultPosition,
+                long styleLbox = wxLB_ALWAYS_SB);
+    bool Create(wxWindow *parent,
+                const wxString& message,
+                const wxString& caption,
+                const wxArrayString& choices,
+                long styleDlg = wxCHOICEDLG_STYLE,
+                const wxPoint& pos = wxDefaultPosition,
+                long styleLbox = wxLB_ALWAYS_SB);
+
+protected:
+    wxListBoxBase *m_listbox;
+
+    virtual wxListBoxBase *CreateList(int n,
+                                      const wxString *choices,
+                                      long styleLbox);
+
+    DECLARE_NO_COPY_CLASS(wxAnyChoiceDialog)
+};
+
+// ----------------------------------------------------------------------------
+// wxSingleChoiceDialog: a dialog with single selection listbox
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxSingleChoiceDialog : public wxAnyChoiceDialog
+{
+public:
+    wxSingleChoiceDialog()
+    {
+        m_selection = -1;
+    }
+
+    wxSingleChoiceDialog(wxWindow *parent,
+                         const wxString& message,
+                         const wxString& caption,
+                         int n,
+                         const wxString *choices,
+                         char **clientData = (char **)NULL,
+                         long style = wxCHOICEDLG_STYLE,
+                         const wxPoint& pos = wxDefaultPosition);
+    wxSingleChoiceDialog(wxWindow *parent,
+                         const wxString& message,
+                         const wxString& caption,
+                         const wxArrayString& choices,
+                         char **clientData = (char **)NULL,
+                         long style = wxCHOICEDLG_STYLE,
+                         const wxPoint& pos = wxDefaultPosition);
+
+    bool Create(wxWindow *parent,
+                const wxString& message,
+                const wxString& caption,
+                int n,
+                const wxString *choices,
+                char **clientData = (char **)NULL,
+                long style = wxCHOICEDLG_STYLE,
+                const wxPoint& pos = wxDefaultPosition);
+    bool Create(wxWindow *parent,
+                const wxString& message,
+                const wxString& caption,
+                const wxArrayString& choices,
+                char **clientData = (char **)NULL,
+                long style = wxCHOICEDLG_STYLE,
+                const wxPoint& pos = wxDefaultPosition);
+
+    void SetSelection(int sel);
+    int GetSelection() const { return m_selection; }
+    wxString GetStringSelection() const { return m_stringSelection; }
+
+    // obsolete function (NB: no need to make it return wxChar, it's untyped)
+    char *GetSelectionClientData() const { return (char *)m_clientData; }
+
+    // implementation from now on
+    void OnOK(wxCommandEvent& event);
+#ifndef __SMARTPHONE__
+    void OnListBoxDClick(wxCommandEvent& event);
+#endif
+#ifdef __WXWINCE__
+    void OnJoystickButtonDown(wxJoystickEvent& event);
+#endif
+
+protected:
+    int         m_selection;
+    wxString    m_stringSelection;
+
+    void DoChoice();
+
+private:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxSingleChoiceDialog)
+    DECLARE_EVENT_TABLE()
+};
+
+// ----------------------------------------------------------------------------
+// wxMultiChoiceDialog: a dialog with multi selection listbox
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxMultiChoiceDialog : public wxAnyChoiceDialog
+{
+public:
+    wxMultiChoiceDialog() { }
+
+    wxMultiChoiceDialog(wxWindow *parent,
+                        const wxString& message,
+                        const wxString& caption,
+                        int n,
+                        const wxString *choices,
+                        long style = wxCHOICEDLG_STYLE,
+                        const wxPoint& pos = wxDefaultPosition)
+    {
+        (void)Create(parent, message, caption, n, choices, style, pos);
+    }
+    wxMultiChoiceDialog(wxWindow *parent,
+                        const wxString& message,
+                        const wxString& caption,
+                        const wxArrayString& choices,
+                        long style = wxCHOICEDLG_STYLE,
+                        const wxPoint& pos = wxDefaultPosition)
+    {
+        (void)Create(parent, message, caption, choices, style, pos);
+    }
+
+    bool Create(wxWindow *parent,
+                const wxString& message,
+                const wxString& caption,
+                int n,
+                const wxString *choices,
+                long style = wxCHOICEDLG_STYLE,
+                const wxPoint& pos = wxDefaultPosition);
+    bool Create(wxWindow *parent,
+                const wxString& message,
+                const wxString& caption,
+                const wxArrayString& choices,
+                long style = wxCHOICEDLG_STYLE,
+                const wxPoint& pos = wxDefaultPosition);
+
+    void SetSelections(const wxArrayInt& selections);
+    wxArrayInt GetSelections() const { return m_selections; }
+
+    // implementation from now on
+    virtual bool TransferDataFromWindow();
+
+protected:
+#if wxUSE_CHECKLISTBOX
+    virtual wxListBoxBase *CreateList(int n,
+                                      const wxString *choices,
+                                      long styleLbox);
+#endif // wxUSE_CHECKLISTBOX
+
+    wxArrayInt m_selections;
+
+private:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxMultiChoiceDialog)
+};
+
+// ----------------------------------------------------------------------------
+// wrapper functions which can be used to get selection(s) from the user
+// ----------------------------------------------------------------------------
+
+// get the user selection as a string
+WXDLLEXPORT wxString wxGetSingleChoice(const wxString& message,
+                                       const wxString& caption,
+                                       const wxArrayString& choices,
+                                       wxWindow *parent = NULL,
+                                       int x = wxDefaultCoord,
+                                       int y = wxDefaultCoord,
+                                       bool centre = true,
+                                       int width = wxCHOICE_WIDTH,
+                                       int height = wxCHOICE_HEIGHT);
+
+WXDLLEXPORT wxString wxGetSingleChoice(const wxString& message,
+                                       const wxString& caption,
+                                       int n, const wxString *choices,
+                                       wxWindow *parent = NULL,
+                                       int x = wxDefaultCoord,
+                                       int y = wxDefaultCoord,
+                                       bool centre = true,
+                                       int width = wxCHOICE_WIDTH,
+                                       int height = wxCHOICE_HEIGHT);
+
+// Same as above but gets position in list of strings, instead of string,
+// or -1 if no selection
+WXDLLEXPORT int wxGetSingleChoiceIndex(const wxString& message,
+                                       const wxString& caption,
+                                       const wxArrayString& choices,
+                                       wxWindow *parent = NULL,
+                                       int x = wxDefaultCoord,
+                                       int y = wxDefaultCoord,
+                                       bool centre = true,
+                                       int width = wxCHOICE_WIDTH,
+                                       int height = wxCHOICE_HEIGHT);
+
+WXDLLEXPORT int wxGetSingleChoiceIndex(const wxString& message,
+                                       const wxString& caption,
+                                       int n, const wxString *choices,
+                                       wxWindow *parent = NULL,
+                                       int x = wxDefaultCoord,
+                                       int y = wxDefaultCoord,
+                                       bool centre = true,
+                                       int width = wxCHOICE_WIDTH,
+                                       int height = wxCHOICE_HEIGHT);
+
+// Return client data instead or NULL if cancelled
+WXDLLEXPORT void* wxGetSingleChoiceData(const wxString& message,
+                                        const wxString& caption,
+                                        const wxArrayString& choices,
+                                        void **client_data,
+                                        wxWindow *parent = NULL,
+                                        int x = wxDefaultCoord,
+                                        int y = wxDefaultCoord,
+                                        bool centre = true,
+                                        int width = wxCHOICE_WIDTH,
+                                        int height = wxCHOICE_HEIGHT);
+
+WXDLLEXPORT void* wxGetSingleChoiceData(const wxString& message,
+                                        const wxString& caption,
+                                        int n, const wxString *choices,
+                                        void **client_data,
+                                        wxWindow *parent = NULL,
+                                        int x = wxDefaultCoord,
+                                        int y = wxDefaultCoord,
+                                        bool centre = true,
+                                        int width = wxCHOICE_WIDTH,
+                                        int height = wxCHOICE_HEIGHT);
+
+// fill the array with the indices of the chosen items, it will be empty
+// if no items were selected or Cancel was pressed - return the number of
+// selections
+WXDLLEXPORT size_t wxGetMultipleChoices(wxArrayInt& selections,
+                                        const wxString& message,
+                                        const wxString& caption,
+                                        int n, const wxString *choices,
+                                        wxWindow *parent = NULL,
+                                        int x = wxDefaultCoord,
+                                        int y = wxDefaultCoord,
+                                        bool centre = true,
+                                        int width = wxCHOICE_WIDTH,
+                                        int height = wxCHOICE_HEIGHT);
+
+WXDLLEXPORT size_t wxGetMultipleChoices(wxArrayInt& selections,
+                                        const wxString& message,
+                                        const wxString& caption,
+                                        const wxArrayString& choices,
+                                        wxWindow *parent = NULL,
+                                        int x = wxDefaultCoord,
+                                        int y = wxDefaultCoord,
+                                        bool centre = true,
+                                        int width = wxCHOICE_WIDTH,
+                                        int height = wxCHOICE_HEIGHT);
+
+#endif // _WX_GENERIC_CHOICDGG_H_

wxWidgets/include/wx/generic/clrpickerg.h

@@ -0,0 +1,98 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/clrpickerg.h
+// Purpose:     wxGenericColourButton header
+// Author:      Francesco Montorsi (based on Vadim Zeitlin's code)
+// Modified by:
+// Created:     14/4/2006
+// Copyright:   (c) Vadim Zeitlin, Francesco Montorsi
+// RCS-ID:      $Id: clrpickerg.h 58967 2009-02-17 13:31:28Z SC $
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_CLRPICKER_H_
+#define _WX_CLRPICKER_H_
+
+#include "wx/button.h"
+#include "wx/cmndata.h"
+
+//-----------------------------------------------------------------------------
+// wxGenericColourButton: a button which brings up a wxColourDialog
+//-----------------------------------------------------------------------------
+
+// show the colour in HTML form (#AABBCC) as colour button label
+#define wxCLRBTN_SHOW_LABEL     100
+
+// the default style
+#define wxCLRBTN_DEFAULT_STYLE  (wxCLRBTN_SHOW_LABEL)
+
+#ifndef wxCLRBTN_USES_BMP_BUTTON
+    #define wxCLRBTN_USES_BMP_BUTTON 0
+#endif
+
+#if wxCLRBTN_USES_BMP_BUTTON
+    #include "wx/bmpbutton.h"
+    #define wxCLRBTN_BASE_CLASS wxBitmapButton
+#else
+     #define wxCLRBTN_BASE_CLASS wxButton
+#endif
+                                               
+class WXDLLIMPEXP_CORE wxGenericColourButton : public wxCLRBTN_BASE_CLASS,
+                                               public wxColourPickerWidgetBase
+{
+public:
+    wxGenericColourButton() {}
+    wxGenericColourButton(wxWindow *parent,
+                          wxWindowID id,
+                          const wxColour& col = *wxBLACK,
+                          const wxPoint& pos = wxDefaultPosition,
+                          const wxSize& size = wxDefaultSize,
+                          long style = wxCLRBTN_DEFAULT_STYLE,
+                          const wxValidator& validator = wxDefaultValidator,
+                          const wxString& name = wxColourPickerWidgetNameStr)
+    {
+        Create(parent, id, col, pos, size, style, validator, name);
+    }
+
+    virtual ~wxGenericColourButton() {}
+
+
+public:     // API extensions specific for wxGenericColourButton
+
+    // user can override this to init colour data in a different way
+    virtual void InitColourData();
+
+    // returns the colour data shown in wxColourDialog
+    wxColourData *GetColourData() { return &ms_data; }
+
+
+public:
+
+    bool Create(wxWindow *parent,
+                wxWindowID id,
+                const wxColour& col = *wxBLACK,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxCLRBTN_DEFAULT_STYLE,
+                const wxValidator& validator = wxDefaultValidator,
+                const wxString& name = wxColourPickerWidgetNameStr);
+
+    void OnButtonClick(wxCommandEvent &);
+
+
+protected:
+
+    wxSize DoGetBestSize() const;
+
+    void UpdateColour();
+
+    // the colour data shown in wxColourPickerCtrlGeneric
+    // controls. This member is static so that all colour pickers
+    // in the program share the same set of custom colours.
+    static wxColourData ms_data;
+
+private:
+   DECLARE_DYNAMIC_CLASS(wxGenericColourButton)
+};
+
+
+#endif // _WX_CLRPICKER_H_

wxWidgets/include/wx/generic/collpaneg.h

@@ -0,0 +1,105 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/collpaneg.h
+// Purpose:     wxGenericCollapsiblePane
+// Author:      Francesco Montorsi
+// Modified by:
+// Created:     8/10/2006
+// RCS-ID:      $Id: collpaneg.h 49804 2007-11-10 01:09:42Z VZ $
+// Copyright:   (c) Francesco Montorsi
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_COLLAPSABLE_PANE_H_GENERIC_
+#define _WX_COLLAPSABLE_PANE_H_GENERIC_
+
+// forward declared
+class WXDLLIMPEXP_FWD_CORE wxButton;
+class WXDLLIMPEXP_FWD_CORE wxStaticLine;
+
+// class name
+extern WXDLLIMPEXP_DATA_CORE(const wxChar) wxCollapsiblePaneNameStr[];
+
+// ----------------------------------------------------------------------------
+// wxGenericCollapsiblePane
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxGenericCollapsiblePane : public wxCollapsiblePaneBase
+{
+public:
+    wxGenericCollapsiblePane() { Init(); }
+
+    wxGenericCollapsiblePane(wxWindow *parent,
+                        wxWindowID winid,
+                        const wxString& label,
+                        const wxPoint& pos = wxDefaultPosition,
+                        const wxSize& size = wxDefaultSize,
+                        long style = wxCP_DEFAULT_STYLE,
+                        const wxValidator& val = wxDefaultValidator,
+                        const wxString& name = wxCollapsiblePaneNameStr)
+    {
+        Init();
+
+        Create(parent, winid, label, pos, size, style, val, name);
+    }
+
+    void Init()
+    {
+        m_pButton = NULL;
+        m_pPane = NULL;
+        m_pStaticLine = NULL;
+        m_sz = NULL;
+    }
+
+    ~wxGenericCollapsiblePane();
+
+    bool Create(wxWindow *parent,
+                wxWindowID winid,
+                const wxString& label,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxCP_DEFAULT_STYLE,
+                const wxValidator& val = wxDefaultValidator,
+                const wxString& name = wxCollapsiblePaneNameStr);
+
+    // public wxCollapsiblePane API
+    virtual void Collapse(bool collapse = true);
+    virtual void SetLabel(const wxString &label);
+
+    virtual bool IsCollapsed() const
+        { return m_pPane==NULL || !m_pPane->IsShown(); }
+    virtual wxWindow *GetPane() const
+        { return m_pPane; }
+    virtual wxString GetLabel() const
+        { return m_strLabel; }
+
+    virtual bool Layout();
+
+    // implementation only, don't use
+    void OnStateChange(const wxSize& sizeNew);
+
+protected:
+    // overridden methods
+    virtual wxSize DoGetBestSize() const;
+
+    wxString GetBtnLabel() const;
+    int GetBorder() const;
+
+    // child controls
+    wxButton *m_pButton;
+    wxStaticLine *m_pStaticLine;
+    wxWindow *m_pPane;
+    wxSizer *m_sz;
+
+    // the button label without ">>" or "<<"
+    wxString m_strLabel;
+
+private:
+    // event handlers
+    void OnButton(wxCommandEvent &ev);
+    void OnSize(wxSizeEvent &ev);
+
+    DECLARE_DYNAMIC_CLASS(wxGenericCollapsiblePane)
+    DECLARE_EVENT_TABLE()
+};
+
+#endif // _WX_COLLAPSABLE_PANE_H_GENERIC_

wxWidgets/include/wx/generic/colour.h

@@ -0,0 +1,75 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/colour.h
+// Purpose:     wxColour class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: colour.h 41751 2006-10-08 21:56:55Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_COLOUR_H_
+#define _WX_GENERIC_COLOUR_H_
+
+#include "wx/object.h"
+
+// Colour
+class WXDLLEXPORT wxColour: public wxColourBase
+{
+public:
+    // constructors
+    // ------------
+
+    // default
+    wxColour();
+    DEFINE_STD_WXCOLOUR_CONSTRUCTORS
+
+    // copy ctors and assignment operators
+    wxColour(const wxColour& col);
+    wxColour& operator=(const wxColour& col);
+
+    // dtor
+    virtual ~wxColour();
+
+    // accessors
+    bool Ok() const { return IsOk(); }
+    bool IsOk() const { return m_isInit; }
+
+    unsigned char Red() const { return m_red; }
+    unsigned char Green() const { return m_green; }
+    unsigned char Blue() const { return m_blue; }
+    unsigned char Alpha() const { return m_alpha; }
+
+    // comparison
+    bool operator==(const wxColour& colour) const
+    {
+        return (m_red == colour.m_red &&
+                m_green == colour.m_green &&
+                m_blue == colour.m_blue &&
+                m_alpha == colour.m_alpha &&
+                m_isInit == colour.m_isInit);
+    }
+
+    bool operator!=(const wxColour& colour) const { return !(*this == colour); }
+
+protected:
+
+    // Helper function
+    void Init();
+
+    virtual void
+    InitRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
+
+private:
+    bool m_isInit;
+    unsigned char m_red;
+    unsigned char m_blue;
+    unsigned char m_green;
+    unsigned char m_alpha;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxColour)
+};
+
+#endif // _WX_GENERIC_COLOUR_H_

wxWidgets/include/wx/generic/colrdlgg.h

@@ -0,0 +1,120 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/colrdlgg.h
+// Purpose:     wxGenericColourDialog
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: colrdlgg.h 37164 2006-01-26 17:20:50Z ABX $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __COLORDLGH_G__
+#define __COLORDLGH_G__
+
+#include "wx/defs.h"
+#include "wx/gdicmn.h"
+#include "wx/dialog.h"
+#include "wx/cmndata.h"
+
+#define wxID_ADD_CUSTOM     3000
+
+#if wxUSE_SLIDER
+
+    #define wxID_RED_SLIDER     3001
+    #define wxID_GREEN_SLIDER   3002
+    #define wxID_BLUE_SLIDER    3003
+
+    class WXDLLEXPORT wxSlider;
+
+#endif // wxUSE_SLIDER
+
+class WXDLLEXPORT wxGenericColourDialog : public wxDialog
+{
+public:
+    wxGenericColourDialog();
+    wxGenericColourDialog(wxWindow *parent,
+                          wxColourData *data = (wxColourData *) NULL);
+    virtual ~wxGenericColourDialog();
+
+    bool Create(wxWindow *parent, wxColourData *data = (wxColourData *) NULL);
+
+    wxColourData &GetColourData() { return colourData; }
+
+    virtual int ShowModal();
+
+    // Internal functions
+    void OnMouseEvent(wxMouseEvent& event);
+    void OnPaint(wxPaintEvent& event);
+
+    virtual void CalculateMeasurements();
+    virtual void CreateWidgets();
+    virtual void InitializeColours();
+
+    virtual void PaintBasicColours(wxDC& dc);
+    virtual void PaintCustomColours(wxDC& dc);
+    virtual void PaintCustomColour(wxDC& dc);
+    virtual void PaintHighlight(wxDC& dc, bool draw);
+
+    virtual void OnBasicColourClick(int which);
+    virtual void OnCustomColourClick(int which);
+
+    void OnAddCustom(wxCommandEvent& event);
+
+#if wxUSE_SLIDER
+    void OnRedSlider(wxCommandEvent& event);
+    void OnGreenSlider(wxCommandEvent& event);
+    void OnBlueSlider(wxCommandEvent& event);
+#endif // wxUSE_SLIDER
+
+    void OnCloseWindow(wxCloseEvent& event);
+
+protected:
+    wxColourData colourData;
+    wxWindow *dialogParent;
+
+    // Area reserved for grids of colours
+    wxRect standardColoursRect;
+    wxRect customColoursRect;
+    wxRect singleCustomColourRect;
+
+    // Size of each colour rectangle
+    wxPoint smallRectangleSize;
+
+    // For single customizable colour
+    wxPoint customRectangleSize;
+
+    // Grid spacing (between rectangles)
+    int gridSpacing;
+
+    // Section spacing (between left and right halves of dialog box)
+    int sectionSpacing;
+
+    // 48 'standard' colours
+    wxColour standardColours[48];
+
+    // 16 'custom' colours
+    wxColour customColours[16];
+
+    // Which colour is selected? An index into one of the two areas.
+    int colourSelection;
+    int whichKind; // 1 for standard colours, 2 for custom colours,
+
+#if wxUSE_SLIDER
+    wxSlider *redSlider;
+    wxSlider *greenSlider;
+    wxSlider *blueSlider;
+#endif // wxUSE_SLIDER
+
+    int buttonY;
+
+    int okButtonX;
+    int customButtonX;
+
+    //  static bool colourDialogCancelled;
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS(wxGenericColourDialog)
+};
+
+#endif

wxWidgets/include/wx/generic/combo.h

@@ -0,0 +1,140 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/combo.h
+// Purpose:     Generic wxComboCtrl
+// Author:      Jaakko Salli
+// Modified by:
+// Created:     Apr-30-2006
+// RCS-ID:      $Id: combo.h 61872 2009-09-09 22:37:05Z VZ $
+// Copyright:   (c) Jaakko Salli
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_COMBOCTRL_H_
+#define _WX_GENERIC_COMBOCTRL_H_
+
+#if wxUSE_COMBOCTRL
+
+// Only define generic if native doesn't have all the features
+#if !defined(wxCOMBOCONTROL_FULLY_FEATURED)
+
+// ----------------------------------------------------------------------------
+// Generic wxComboCtrl
+// ----------------------------------------------------------------------------
+
+#if defined(__WXUNIVERSAL__)
+
+// all actions of single line text controls are supported
+
+// popup/dismiss the choice window
+#define wxACTION_COMBOBOX_POPUP     wxT("popup")
+#define wxACTION_COMBOBOX_DISMISS   wxT("dismiss")
+
+#endif
+
+extern WXDLLIMPEXP_DATA_CORE(const wxChar) wxComboBoxNameStr[];
+
+class WXDLLEXPORT wxGenericComboCtrl : public wxComboCtrlBase
+{
+public:
+    // ctors and such
+    wxGenericComboCtrl() : wxComboCtrlBase() { Init(); }
+
+    wxGenericComboCtrl(wxWindow *parent,
+                       wxWindowID id = wxID_ANY,
+                       const wxString& value = wxEmptyString,
+                       const wxPoint& pos = wxDefaultPosition,
+                       const wxSize& size = wxDefaultSize,
+                       long style = 0,
+                       const wxValidator& validator = wxDefaultValidator,
+                       const wxString& name = wxComboBoxNameStr)
+        : wxComboCtrlBase()
+    {
+        Init();
+
+        (void)Create(parent, id, value, pos, size, style, validator, name);
+    }
+
+    bool Create(wxWindow *parent,
+                wxWindowID id = wxID_ANY,
+                const wxString& value = wxEmptyString,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = 0,
+                const wxValidator& validator = wxDefaultValidator,
+                const wxString& name = wxComboBoxNameStr);
+
+    virtual ~wxGenericComboCtrl();
+
+    void SetCustomPaintWidth( int width );
+
+    virtual bool IsKeyPopupToggle(const wxKeyEvent& event) const;
+
+    static int GetFeatures() { return wxComboCtrlFeatures::All; }
+
+#if defined(__WXUNIVERSAL__)
+    // we have our own input handler and our own actions
+    virtual bool PerformAction(const wxControlAction& action,
+                               long numArg = 0l,
+                               const wxString& strArg = wxEmptyString);
+#endif
+
+protected:
+
+    // Mandatory virtuals
+    virtual void OnResize();
+
+    // Event handlers
+    void OnPaintEvent( wxPaintEvent& event );
+    void OnMouseEvent( wxMouseEvent& event );
+
+private:
+    void Init();
+
+    DECLARE_EVENT_TABLE()
+
+    DECLARE_DYNAMIC_CLASS(wxGenericComboCtrl)
+};
+
+
+#ifndef _WX_COMBOCONTROL_H_
+
+// If native wxComboCtrl was not defined, then prepare a simple
+// front-end so that wxRTTI works as expected.
+
+class WXDLLEXPORT wxComboCtrl : public wxGenericComboCtrl
+{
+public:
+    wxComboCtrl() : wxGenericComboCtrl() {}
+
+    wxComboCtrl(wxWindow *parent,
+                wxWindowID id = wxID_ANY,
+                const wxString& value = wxEmptyString,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = 0,
+                const wxValidator& validator = wxDefaultValidator,
+                const wxString& name = wxComboBoxNameStr)
+        : wxGenericComboCtrl()
+    {
+        (void)Create(parent, id, value, pos, size, style, validator, name);
+    }
+
+    virtual ~wxComboCtrl() {}
+
+protected:
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxComboCtrl)
+};
+
+#endif // _WX_COMBOCONTROL_H_
+
+#else
+
+#define wxGenericComboCtrl   wxComboCtrl
+
+#endif // !defined(wxCOMBOCONTROL_FULLY_FEATURED)
+
+#endif // wxUSE_COMBOCTRL
+#endif
+    // _WX_GENERIC_COMBOCTRL_H_

wxWidgets/include/wx/generic/dataview.h

@@ -0,0 +1,311 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/dataview.h
+// Purpose:     wxDataViewCtrl generic implementation header
+// Author:      Robert Roebling
+// Id:          $Id: dataview.h 53135 2008-04-12 02:31:04Z VZ $
+// Copyright:   (c) 1998 Robert Roebling
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __GENERICDATAVIEWCTRLH__
+#define __GENERICDATAVIEWCTRLH__
+
+#include "wx/defs.h"
+#include "wx/object.h"
+#include "wx/list.h"
+#include "wx/control.h"
+#include "wx/scrolwin.h"
+#include "wx/icon.h"
+
+// ---------------------------------------------------------
+// classes
+// ---------------------------------------------------------
+
+class WXDLLIMPEXP_FWD_ADV wxDataViewCtrl;
+class WXDLLIMPEXP_FWD_ADV wxDataViewMainWindow;
+class WXDLLIMPEXP_FWD_ADV wxDataViewHeaderWindow;
+
+// ---------------------------------------------------------
+// wxDataViewRenderer
+// ---------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxDataViewRenderer: public wxDataViewRendererBase
+{
+public:
+    wxDataViewRenderer( const wxString &varianttype, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT );
+    virtual ~wxDataViewRenderer();
+
+    virtual bool Render( wxRect cell, wxDC *dc, int state ) = 0;
+    virtual wxSize GetSize() = 0;
+
+    virtual bool Activate( wxRect WXUNUSED(cell),
+                           wxDataViewListModel *WXUNUSED(model),
+                           unsigned int WXUNUSED(col),
+                           unsigned int WXUNUSED(row) )
+                           { return false; }
+
+    virtual bool LeftClick( wxPoint WXUNUSED(cursor),
+                            wxRect WXUNUSED(cell),
+                            wxDataViewListModel *WXUNUSED(model),
+                            unsigned int WXUNUSED(col),
+                            unsigned int WXUNUSED(row) )
+                            { return false; }
+    virtual bool RightClick( wxPoint WXUNUSED(cursor),
+                             wxRect WXUNUSED(cell),
+                             wxDataViewListModel *WXUNUSED(model),
+                             unsigned int WXUNUSED(col),
+                             unsigned int WXUNUSED(row) )
+                             { return false; }
+    virtual bool StartDrag( wxPoint WXUNUSED(cursor),
+                            wxRect WXUNUSED(cell),
+                            wxDataViewListModel *WXUNUSED(model),
+                            unsigned int WXUNUSED(col),
+                            unsigned int WXUNUSED(row) )
+                            { return false; }
+
+    // Create DC on request
+    virtual wxDC *GetDC();
+
+private:
+    wxDC        *m_dc;
+
+protected:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewRenderer)
+};
+
+// ---------------------------------------------------------
+// wxDataViewCustomRenderer
+// ---------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxDataViewCustomRenderer: public wxDataViewRenderer
+{
+public:
+    wxDataViewCustomRenderer( const wxString &varianttype = wxT("string"),
+                              wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT );
+
+protected:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewCustomRenderer)
+};
+
+// ---------------------------------------------------------
+// wxDataViewTextRenderer
+// ---------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxDataViewTextRenderer: public wxDataViewCustomRenderer
+{
+public:
+    wxDataViewTextRenderer( const wxString &varianttype = wxT("string"),
+                            wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT );
+
+    bool SetValue( const wxVariant &value );
+    bool GetValue( wxVariant &value );
+
+    bool Render( wxRect cell, wxDC *dc, int state );
+    wxSize GetSize();
+
+private:
+    wxString m_text;
+
+protected:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewTextRenderer)
+};
+
+// ---------------------------------------------------------
+// wxDataViewBitmapRenderer
+// ---------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxDataViewBitmapRenderer: public wxDataViewCustomRenderer
+{
+public:
+    wxDataViewBitmapRenderer( const wxString &varianttype = wxT("wxBitmap"),
+                              wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT );
+
+    bool SetValue( const wxVariant &value );
+    bool GetValue( wxVariant &value );
+
+    bool Render( wxRect cell, wxDC *dc, int state );
+    wxSize GetSize();
+
+private:
+    wxIcon m_icon;
+    wxBitmap m_bitmap;
+
+protected:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewBitmapRenderer)
+};
+
+// ---------------------------------------------------------
+// wxDataViewToggleRenderer
+// ---------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxDataViewToggleRenderer: public wxDataViewCustomRenderer
+{
+public:
+    wxDataViewToggleRenderer( const wxString &varianttype = wxT("bool"),
+                              wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT );
+
+    bool SetValue( const wxVariant &value );
+    bool GetValue( wxVariant &value );
+
+    bool Render( wxRect cell, wxDC *dc, int state );
+    bool Activate( wxRect cell, wxDataViewListModel *model, unsigned int col, unsigned int row );
+    wxSize GetSize();
+
+private:
+    bool    m_toggle;
+
+protected:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewToggleRenderer)
+};
+
+// ---------------------------------------------------------
+// wxDataViewProgressRenderer
+// ---------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxDataViewProgressRenderer: public wxDataViewCustomRenderer
+{
+public:
+    wxDataViewProgressRenderer( const wxString &label = wxEmptyString,
+                                const wxString &varianttype = wxT("long"),
+                                wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT );
+    virtual ~wxDataViewProgressRenderer();
+
+    bool SetValue( const wxVariant &value );
+
+    virtual bool Render( wxRect cell, wxDC *dc, int state );
+    virtual wxSize GetSize();
+
+private:
+    wxString    m_label;
+    int         m_value;
+
+protected:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewProgressRenderer)
+};
+
+// ---------------------------------------------------------
+// wxDataViewDateRenderer
+// ---------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxDataViewDateRenderer: public wxDataViewCustomRenderer
+{
+public:
+    wxDataViewDateRenderer( const wxString &varianttype = wxT("datetime"),
+                            wxDataViewCellMode mode = wxDATAVIEW_CELL_ACTIVATABLE );
+
+    bool SetValue( const wxVariant &value );
+
+    virtual bool Render( wxRect cell, wxDC *dc, int state );
+    virtual wxSize GetSize();
+    virtual bool Activate( wxRect cell,
+                           wxDataViewListModel *model, unsigned int col, unsigned int row );
+
+private:
+    wxDateTime    m_date;
+
+protected:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewDateRenderer)
+};
+
+// ---------------------------------------------------------
+// wxDataViewColumn
+// ---------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxDataViewColumn: public wxDataViewColumnBase
+{
+public:
+    wxDataViewColumn( const wxString &title, wxDataViewRenderer *renderer, unsigned int model_column, 
+        int width = 80, int flags = wxDATAVIEW_COL_RESIZABLE );
+    wxDataViewColumn( const wxBitmap &bitmap, wxDataViewRenderer *renderer, unsigned int model_column,
+        int width = 80, int flags = wxDATAVIEW_COL_RESIZABLE );
+    virtual ~wxDataViewColumn();
+
+    virtual void SetTitle( const wxString &title );
+    virtual void SetBitmap( const wxBitmap &bitmap );
+    
+    virtual void SetAlignment( wxAlignment align );
+    
+    virtual void SetSortable( bool sortable );
+    virtual bool GetSortable();
+    virtual void SetSortOrder( bool ascending );
+    virtual bool IsSortOrderAscending();
+
+    virtual int GetWidth();
+
+private:
+    int                      m_width;
+    int                      m_fixedWidth;
+
+protected:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewColumn)
+};
+
+// ---------------------------------------------------------
+// wxDataViewCtrl
+// ---------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxDataViewCtrl: public wxDataViewCtrlBase,
+                                       public wxScrollHelperNative
+{
+public:
+    wxDataViewCtrl() : wxScrollHelperNative(this)
+    {
+        Init();
+    }
+
+    wxDataViewCtrl( wxWindow *parent, wxWindowID id,
+           const wxPoint& pos = wxDefaultPosition,
+           const wxSize& size = wxDefaultSize, long style = 0,
+           const wxValidator& validator = wxDefaultValidator )
+             : wxScrollHelperNative(this)
+    {
+        Create(parent, id, pos, size, style, validator );
+    }
+
+    virtual ~wxDataViewCtrl();
+
+    void Init();
+
+    bool Create(wxWindow *parent, wxWindowID id,
+           const wxPoint& pos = wxDefaultPosition,
+           const wxSize& size = wxDefaultSize, long style = 0,
+           const wxValidator& validator = wxDefaultValidator );
+
+    virtual bool AssociateModel( wxDataViewListModel *model );
+    virtual bool AppendColumn( wxDataViewColumn *col );
+
+    virtual void SetSelection( int row ); // -1 for unselect
+    virtual void SetSelectionRange( unsigned int from, unsigned int to );
+    virtual void SetSelections( const wxArrayInt& aSelections);
+    virtual void Unselect( unsigned int row );
+    
+    virtual bool IsSelected( unsigned int row ) const;
+    virtual int GetSelection() const;
+    virtual int GetSelections(wxArrayInt& aSelections) const;
+
+private:
+    friend class wxDataViewMainWindow;
+    friend class wxDataViewHeaderWindow;
+    wxDataViewListModelNotifier *m_notifier;
+    wxDataViewMainWindow        *m_clientArea;
+    wxDataViewHeaderWindow      *m_headerArea;
+
+private:
+    void OnSize( wxSizeEvent &event );
+
+    // we need to return a special WM_GETDLGCODE value to process just the
+    // arrows but let the other navigation characters through
+#ifdef __WXMSW__
+    virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
+#endif // __WXMSW__
+
+    WX_FORWARD_TO_SCROLL_HELPER()
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxDataViewCtrl)
+    DECLARE_NO_COPY_CLASS(wxDataViewCtrl)
+    DECLARE_EVENT_TABLE()
+};
+
+
+#endif // __GENERICDATAVIEWCTRLH__

wxWidgets/include/wx/generic/datectrl.h

@@ -0,0 +1,91 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        generic/datectrl.h
+// Purpose:     generic wxDatePickerCtrl implementation
+// Author:      Andreas Pflug
+// Modified by:
+// Created:     2005-01-19
+// RCS-ID:      $Id: datectrl.h 42539 2006-10-27 18:02:21Z RR $
+// Copyright:   (c) 2005 Andreas Pflug <pgadmin@pse-consulting.de>
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_DATECTRL_H_
+#define _WX_GENERIC_DATECTRL_H_
+
+class WXDLLIMPEXP_ADV wxCalendarDateAttr;
+class WXDLLIMPEXP_ADV wxCalendarCtrl;
+class WXDLLIMPEXP_ADV wxCalendarEvent;
+class WXDLLIMPEXP_ADV wxComboCtrl;
+class WXDLLIMPEXP_ADV wxCalendarComboPopup;
+
+class WXDLLIMPEXP_ADV wxDatePickerCtrlGeneric : public wxDatePickerCtrlBase
+{
+public:
+    // creating the control
+    wxDatePickerCtrlGeneric() { Init(); }
+    virtual ~wxDatePickerCtrlGeneric();
+    wxDatePickerCtrlGeneric(wxWindow *parent,
+                            wxWindowID id,
+                            const wxDateTime& date = wxDefaultDateTime,
+                            const wxPoint& pos = wxDefaultPosition,
+                            const wxSize& size = wxDefaultSize,
+                            long style = wxDP_DEFAULT | wxDP_SHOWCENTURY,
+                            const wxValidator& validator = wxDefaultValidator,
+                            const wxString& name = wxDatePickerCtrlNameStr)
+    {
+        Init();
+
+        (void)Create(parent, id, date, pos, size, style, validator, name);
+    }
+
+    bool Create(wxWindow *parent,
+                wxWindowID id,
+                const wxDateTime& date = wxDefaultDateTime,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxDP_DEFAULT | wxDP_SHOWCENTURY,
+                const wxValidator& validator = wxDefaultValidator,
+                const wxString& name = wxDatePickerCtrlNameStr);
+
+    // wxDatePickerCtrl methods
+    void SetValue(const wxDateTime& date);
+    wxDateTime GetValue() const;
+
+    bool GetRange(wxDateTime *dt1, wxDateTime *dt2) const;
+    void SetRange(const wxDateTime &dt1, const wxDateTime &dt2);
+
+    bool SetDateRange(const wxDateTime& lowerdate = wxDefaultDateTime,
+                      const wxDateTime& upperdate = wxDefaultDateTime);
+
+    // extra methods available only in this (generic) implementation
+    bool SetFormat(const wxChar *fmt);
+    wxCalendarCtrl *GetCalendar() const { return m_cal; }
+
+
+    // implementation only from now on
+    // -------------------------------
+
+    // overridden base class methods
+    virtual bool Destroy();
+
+protected:
+    virtual wxSize DoGetBestSize() const;
+
+private:
+    void Init();
+
+    void OnText(wxCommandEvent &event);
+    void OnSize(wxSizeEvent& event);
+    void OnFocus(wxFocusEvent& event);
+
+    wxCalendarCtrl *m_cal;
+    wxComboCtrl* m_combo;
+    wxCalendarComboPopup* m_popup;
+
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxDatePickerCtrlGeneric)
+};
+
+#endif // _WX_GENERIC_DATECTRL_H_
+

wxWidgets/include/wx/generic/dcpsg.h

@@ -0,0 +1,154 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/dcps.h
+// Purpose:     wxPostScriptDC class
+// Author:      Julian Smart and others
+// Modified by:
+// RCS-ID:      $Id: dcpsg.h 41751 2006-10-08 21:56:55Z VZ $
+// Copyright:   (c) Julian Smart and Robert Roebling
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DCPSG_H_
+#define _WX_DCPSG_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_PRINTING_ARCHITECTURE
+
+#if wxUSE_POSTSCRIPT
+
+#include "wx/dc.h"
+#include "wx/dialog.h"
+#include "wx/module.h"
+#include "wx/cmndata.h"
+
+extern WXDLLIMPEXP_DATA_CORE(int) wxPageNumber;
+
+//-----------------------------------------------------------------------------
+// classes
+//-----------------------------------------------------------------------------
+
+class wxPostScriptDC;
+
+//-----------------------------------------------------------------------------
+// wxPostScriptDC
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxPostScriptDC: public wxDC
+{
+public:
+    wxPostScriptDC();
+
+    // Recommended constructor
+    wxPostScriptDC(const wxPrintData& printData);
+
+    // Recommended destructor :-)
+    virtual ~wxPostScriptDC();
+
+  virtual bool Ok() const { return IsOk(); }
+  virtual bool IsOk() const;
+
+  bool CanDrawBitmap() const { return true; }
+
+  void Clear();
+  void SetFont( const wxFont& font );
+  void SetPen( const wxPen& pen );
+  void SetBrush( const wxBrush& brush );
+  void SetLogicalFunction( int function );
+  void SetBackground( const wxBrush& brush );
+
+  void DestroyClippingRegion();
+
+  bool StartDoc(const wxString& message);
+  void EndDoc();
+  void StartPage();
+  void EndPage();
+
+  wxCoord GetCharHeight() const;
+  wxCoord GetCharWidth() const;
+  bool CanGetTextExtent() const { return true; }
+
+  // Resolution in pixels per logical inch
+  wxSize GetPPI() const;
+
+  void SetAxisOrientation( bool xLeftRight, bool yBottomUp );
+  void SetDeviceOrigin( wxCoord x, wxCoord y );
+
+  void SetBackgroundMode(int WXUNUSED(mode)) { }
+  void SetPalette(const wxPalette& WXUNUSED(palette)) { }
+
+  wxPrintData& GetPrintData() { return m_printData; }
+  void SetPrintData(const wxPrintData& data) { m_printData = data; }
+
+  virtual int GetDepth() const { return 24; }
+
+  static void SetResolution(int ppi);
+  static int GetResolution();
+
+  void PsPrintf( const wxChar* fmt, ... );
+  void PsPrint( const char* psdata );
+  void PsPrint( int ch );
+
+#if wxUSE_UNICODE
+  void PsPrint( const wxChar* psdata ) { PsPrint( wxConvUTF8.cWX2MB( psdata ) ); }
+#endif
+
+private:
+    static float ms_PSScaleFactor;
+
+protected:
+    bool DoFloodFill(wxCoord x1, wxCoord y1, const wxColour &col, int style = wxFLOOD_SURFACE);
+    bool DoGetPixel(wxCoord x1, wxCoord y1, wxColour *col) const;
+    void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
+    void DoCrossHair(wxCoord x, wxCoord y) ;
+    void DoDrawArc(wxCoord x1,wxCoord y1,wxCoord x2,wxCoord y2,wxCoord xc,wxCoord yc);
+    void DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea);
+    void DoDrawPoint(wxCoord x, wxCoord y);
+    void DoDrawLines(int n, wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0);
+    void DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, int fillStyle = wxODDEVEN_RULE);
+    void DoDrawPolyPolygon(int n, int count[], wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, int fillStyle = wxODDEVEN_RULE);
+    void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
+    void DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius = 20);
+    void DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
+#if wxUSE_SPLINES
+    void DoDrawSpline(wxList *points);
+#endif // wxUSE_SPLINES
+    bool DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
+                wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop = wxCOPY, bool useMask = false,
+                wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord);
+    void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
+    void DoDrawBitmap(const wxBitmap& bitmap, wxCoord x, wxCoord y, bool useMask = false);
+    void DoDrawText(const wxString& text, wxCoord x, wxCoord y);
+    void DoDrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);
+    void DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
+    void DoSetClippingRegionAsRegion( const wxRegion &WXUNUSED(clip)) { }
+    void DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
+                         wxCoord *descent = NULL,
+                         wxCoord *externalLeading = NULL,
+                         wxFont *theFont = NULL) const;
+    void DoGetSize(int* width, int* height) const;
+    void DoGetSizeMM(int *width, int *height) const;
+
+    FILE*             m_pstream;    // PostScript output stream
+    wxString          m_title;
+    unsigned char     m_currentRed;
+    unsigned char     m_currentGreen;
+    unsigned char     m_currentBlue;
+    int               m_pageNumber;
+    bool              m_clipping;
+    double            m_underlinePosition;
+    double            m_underlineThickness;
+    wxPrintData       m_printData;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxPostScriptDC)
+};
+
+#endif
+    // wxUSE_POSTSCRIPT
+
+#endif
+    // wxUSE_PRINTING_ARCHITECTURE
+
+#endif
+        // _WX_DCPSG_H_

wxWidgets/include/wx/generic/dirctrlg.h

@@ -0,0 +1,295 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dirctrlg.h
+// Purpose:     wxGenericDirCtrl class
+//              Builds on wxDirCtrl class written by Robert Roebling for the
+//              wxFile application, modified by Harm van der Heijden.
+//              Further modified for Windows.
+// Author:      Robert Roebling, Harm van der Heijden, Julian Smart et al
+// Modified by:
+// Created:     21/3/2000
+// RCS-ID:      $Id: dirctrlg.h 53135 2008-04-12 02:31:04Z VZ $
+// Copyright:   (c) Robert Roebling, Harm van der Heijden, Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DIRCTRL_H_
+#define _WX_DIRCTRL_H_
+
+#if wxUSE_DIRDLG || wxUSE_FILEDLG
+    #include "wx/imaglist.h"
+#endif
+
+#if wxUSE_DIRDLG
+
+#include "wx/treectrl.h"
+#include "wx/dialog.h"
+#include "wx/dirdlg.h"
+#include "wx/choice.h"
+
+//-----------------------------------------------------------------------------
+// classes
+//-----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
+class WXDLLIMPEXP_FWD_CORE wxImageList;
+class WXDLLIMPEXP_FWD_BASE wxHashTable;
+
+//-----------------------------------------------------------------------------
+// Extra styles for wxGenericDirCtrl
+//-----------------------------------------------------------------------------
+
+enum
+{
+    // Only allow directory viewing/selection, no files
+    wxDIRCTRL_DIR_ONLY       = 0x0010,
+    // When setting the default path, select the first file in the directory
+    wxDIRCTRL_SELECT_FIRST   = 0x0020,
+    // Show the filter list
+    wxDIRCTRL_SHOW_FILTERS   = 0x0040,
+    // Use 3D borders on internal controls
+    wxDIRCTRL_3D_INTERNAL    = 0x0080,
+    // Editable labels
+    wxDIRCTRL_EDIT_LABELS    = 0x0100
+};
+
+//-----------------------------------------------------------------------------
+// wxDirItemData
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxDirItemData : public wxTreeItemData
+{
+public:
+    wxDirItemData(const wxString& path, const wxString& name, bool isDir);
+    virtual ~wxDirItemData(){}
+    void SetNewDirName(const wxString& path);
+
+    bool HasSubDirs() const;
+    bool HasFiles(const wxString& spec = wxEmptyString) const;
+
+    wxString m_path, m_name;
+    bool m_isHidden;
+    bool m_isExpanded;
+    bool m_isDir;
+};
+
+//-----------------------------------------------------------------------------
+// wxDirCtrl
+//-----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_FWD_CORE wxDirFilterListCtrl;
+
+class WXDLLEXPORT wxGenericDirCtrl: public wxControl
+{
+public:
+    wxGenericDirCtrl();
+    wxGenericDirCtrl(wxWindow *parent, const wxWindowID id = wxID_ANY,
+              const wxString &dir = wxDirDialogDefaultFolderStr,
+              const wxPoint& pos = wxDefaultPosition,
+              const wxSize& size = wxDefaultSize,
+              long style = wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER,
+              const wxString& filter = wxEmptyString,
+              int defaultFilter = 0,
+              const wxString& name = wxTreeCtrlNameStr )
+    {
+        Init();
+        Create(parent, id, dir, pos, size, style, filter, defaultFilter, name);
+    }
+
+    bool Create(wxWindow *parent, const wxWindowID id = wxID_ANY,
+              const wxString &dir = wxDirDialogDefaultFolderStr,
+              const wxPoint& pos = wxDefaultPosition,
+              const wxSize& size = wxDefaultSize,
+              long style = wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER,
+              const wxString& filter = wxEmptyString,
+              int defaultFilter = 0,
+              const wxString& name = wxTreeCtrlNameStr );
+
+    virtual void Init();
+
+    virtual ~wxGenericDirCtrl();
+
+    void OnExpandItem(wxTreeEvent &event );
+    void OnCollapseItem(wxTreeEvent &event );
+    void OnBeginEditItem(wxTreeEvent &event );
+    void OnEndEditItem(wxTreeEvent &event );
+    void OnSize(wxSizeEvent &event );
+
+    // Try to expand as much of the given path as possible.
+    virtual bool ExpandPath(const wxString& path);
+    // collapse the path
+    virtual bool CollapsePath(const wxString& path);
+
+    // Accessors
+
+    virtual inline wxString GetDefaultPath() const { return m_defaultPath; }
+    virtual void SetDefaultPath(const wxString& path) { m_defaultPath = path; }
+
+    // Get dir or filename
+    virtual wxString GetPath() const;
+
+    // Get selected filename path only (else empty string).
+    // I.e. don't count a directory as a selection
+    virtual wxString GetFilePath() const;
+    virtual void SetPath(const wxString& path);
+
+    virtual void ShowHidden( bool show );
+    virtual bool GetShowHidden() { return m_showHidden; }
+
+    virtual wxString GetFilter() const { return m_filter; }
+    virtual void SetFilter(const wxString& filter);
+
+    virtual int GetFilterIndex() const { return m_currentFilter; }
+    virtual void SetFilterIndex(int n);
+
+    virtual wxTreeItemId GetRootId() { return m_rootId; }
+
+    virtual wxTreeCtrl* GetTreeCtrl() const { return m_treeCtrl; }
+    virtual wxDirFilterListCtrl* GetFilterListCtrl() const { return m_filterListCtrl; }
+
+    // Helper
+    virtual void SetupSections();
+
+#if WXWIN_COMPATIBILITY_2_4
+    // Parse the filter into an array of filters and an array of descriptions
+    virtual int ParseFilter(const wxString& filterStr, wxArrayString& filters, wxArrayString& descriptions);
+#endif // WXWIN_COMPATIBILITY_2_4
+
+    // Find the child that matches the first part of 'path'.
+    // E.g. if a child path is "/usr" and 'path' is "/usr/include"
+    // then the child for /usr is returned.
+    // If the path string has been used (we're at the leaf), done is set to true
+    virtual wxTreeItemId FindChild(wxTreeItemId parentId, const wxString& path, bool& done);
+
+    // Resize the components of the control
+    virtual void DoResize();
+
+    // Collapse & expand the tree, thus re-creating it from scratch:
+    virtual void ReCreateTree();
+
+    // Collapse the entire tree
+    virtual void CollapseTree();
+
+protected:
+    virtual void ExpandRoot();
+    virtual void ExpandDir(wxTreeItemId parentId);
+    virtual void CollapseDir(wxTreeItemId parentId);
+    virtual const wxTreeItemId AddSection(const wxString& path, const wxString& name, int imageId = 0);
+    virtual wxTreeItemId AppendItem (const wxTreeItemId & parent,
+                const wxString & text,
+                int image = -1, int selectedImage = -1,
+                wxTreeItemData * data = NULL);
+    //void FindChildFiles(wxTreeItemId id, int dirFlags, wxArrayString& filenames);
+    virtual wxTreeCtrl* CreateTreeCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long treeStyle);
+
+    // Extract description and actual filter from overall filter string
+    bool ExtractWildcard(const wxString& filterStr, int n, wxString& filter, wxString& description);
+
+private:
+    bool            m_showHidden;
+    wxTreeItemId    m_rootId;
+    wxString        m_defaultPath; // Starting path
+    long            m_styleEx; // Extended style
+    wxString        m_filter;  // Wildcards in same format as per wxFileDialog
+    int             m_currentFilter; // The current filter index
+    wxString        m_currentFilterStr; // Current filter string
+    wxTreeCtrl*     m_treeCtrl;
+    wxDirFilterListCtrl* m_filterListCtrl;
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS(wxGenericDirCtrl)
+    DECLARE_NO_COPY_CLASS(wxGenericDirCtrl)
+};
+
+//-----------------------------------------------------------------------------
+// wxDirFilterListCtrl
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxDirFilterListCtrl: public wxChoice
+{
+public:
+    wxDirFilterListCtrl() { Init(); }
+    wxDirFilterListCtrl(wxGenericDirCtrl* parent, const wxWindowID id = wxID_ANY,
+              const wxPoint& pos = wxDefaultPosition,
+              const wxSize& size = wxDefaultSize,
+              long style = 0)
+    {
+        Init();
+        Create(parent, id, pos, size, style);
+    }
+
+    bool Create(wxGenericDirCtrl* parent, const wxWindowID id = wxID_ANY,
+              const wxPoint& pos = wxDefaultPosition,
+              const wxSize& size = wxDefaultSize,
+              long style = 0);
+
+    void Init();
+
+    virtual ~wxDirFilterListCtrl() {}
+
+    //// Operations
+    void FillFilterList(const wxString& filter, int defaultFilter);
+
+    //// Events
+    void OnSelFilter(wxCommandEvent& event);
+
+protected:
+    wxGenericDirCtrl*    m_dirCtrl;
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_CLASS(wxDirFilterListCtrl)
+    DECLARE_NO_COPY_CLASS(wxDirFilterListCtrl)
+};
+
+#if !defined(__WXMSW__) && !defined(__WXMAC__) && !defined(__WXPM__)
+    #define wxDirCtrl wxGenericDirCtrl
+#endif
+
+// Symbols for accessing individual controls
+#define wxID_TREECTRL          7000
+#define wxID_FILTERLISTCTRL    7001
+
+#endif // wxUSE_DIRDLG
+
+//-------------------------------------------------------------------------
+// wxFileIconsTable - use wxTheFileIconsTable which is created as necessary
+//-------------------------------------------------------------------------
+
+#if wxUSE_DIRDLG || wxUSE_FILEDLG
+
+class WXDLLEXPORT wxFileIconsTable
+{
+public:
+    wxFileIconsTable();
+    ~wxFileIconsTable();
+
+    enum iconId_Type
+    {
+        folder,
+        folder_open,
+        computer,
+        drive,
+        cdrom,
+        floppy,
+        removeable,
+        file,
+        executable
+    };
+
+    int GetIconID(const wxString& extension, const wxString& mime = wxEmptyString);
+    wxImageList *GetSmallImageList();
+
+protected:
+    void Create();  // create on first use
+
+    wxImageList *m_smallImageList;
+    wxHashTable *m_HashTable;
+};
+
+// The global fileicons table
+extern WXDLLEXPORT_DATA(wxFileIconsTable *) wxTheFileIconsTable;
+
+#endif // wxUSE_DIRDLG || wxUSE_FILEDLG
+
+#endif
+    // _WX_DIRCTRLG_H_

wxWidgets/include/wx/generic/dirdlgg.h

@@ -0,0 +1,89 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/dirdlgg.h
+// Purpose:     wxGenericDirCtrl class
+//              Builds on wxDirCtrl class written by Robert Roebling for the
+//              wxFile application, modified by Harm van der Heijden.
+//              Further modified for Windows.
+// Author:      Robert Roebling, Harm van der Heijden, Julian Smart et al
+// Modified by:
+// Created:     21/3/2000
+// RCS-ID:      $Id: dirdlgg.h 39402 2006-05-28 23:32:12Z VZ $
+// Copyright:   (c) Robert Roebling, Harm van der Heijden, Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DIRDLGG_H_
+#define _WX_DIRDLGG_H_
+
+class WXDLLEXPORT wxGenericDirCtrl;
+class WXDLLEXPORT wxTextCtrl;
+class WXDLLEXPORT wxTreeEvent;
+
+// we may be included directly as well as from wx/dirdlg.h (FIXME)
+extern WXDLLEXPORT_DATA(const wxChar) wxDirDialogNameStr[];
+extern WXDLLEXPORT_DATA(const wxChar) wxDirSelectorPromptStr[];
+
+#ifndef wxDD_DEFAULT_STYLE
+#ifdef __WXWINCE__
+    #define wxDD_DEFAULT_STYLE      wxDEFAULT_DIALOG_STYLE
+#else
+    #define wxDD_DEFAULT_STYLE      (wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER)
+#endif
+#endif
+
+#include "wx/dialog.h"
+
+//-----------------------------------------------------------------------------
+// wxGenericDirDialog
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericDirDialog : public wxDirDialogBase
+{
+public:
+    wxGenericDirDialog() : wxDirDialogBase() { }
+
+    wxGenericDirDialog(wxWindow* parent,
+                       const wxString& title = wxDirSelectorPromptStr,
+                       const wxString& defaultPath = wxEmptyString,
+                       long style = wxDD_DEFAULT_STYLE,
+                       const wxPoint& pos = wxDefaultPosition,
+                       const wxSize& sz = wxDefaultSize,//Size(450, 550),
+                       const wxString& name = wxDirDialogNameStr);
+
+    bool Create(wxWindow* parent,
+                const wxString& title = wxDirSelectorPromptStr,
+                const wxString& defaultPath = wxEmptyString,
+                long style = wxDD_DEFAULT_STYLE,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& sz = wxDefaultSize,//Size(450, 550),
+                       const wxString& name = wxDirDialogNameStr);
+
+    //// Accessors
+    void SetPath(const wxString& path);
+    wxString GetPath() const;
+
+    //// Overrides
+    virtual int ShowModal();
+    virtual void EndModal(int retCode);
+
+    // this one is specific to wxGenericDirDialog
+    wxTextCtrl* GetInputCtrl() const { return m_input; }
+
+protected:
+    //// Event handlers
+    void OnCloseWindow(wxCloseEvent& event);
+    void OnOK(wxCommandEvent& event);
+    void OnTreeSelected(wxTreeEvent &event);
+    void OnTreeKeyDown(wxTreeEvent &event);
+    void OnNew(wxCommandEvent& event);
+    void OnGoHome(wxCommandEvent& event);
+    void OnShowHidden(wxCommandEvent& event);
+
+    wxGenericDirCtrl* m_dirCtrl;
+    wxTextCtrl*       m_input;
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS(wxGenericDirDialog)
+};
+
+#endif // _WX_DIRDLGG_H_

wxWidgets/include/wx/generic/dragimgg.h

@@ -0,0 +1,271 @@
+//////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/dragimgg.h
+// Purpose:     wxDragImage class: a kind of a cursor, that can cope
+//              with more sophisticated images
+// Author:      Julian Smart
+// Modified by:
+// Created:     29/2/2000
+// RCS-ID:      $Id: dragimgg.h 42397 2006-10-25 12:12:56Z VS $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DRAGIMGG_H_
+#define _WX_DRAGIMGG_H_
+
+#include "wx/bitmap.h"
+#include "wx/icon.h"
+#include "wx/cursor.h"
+#include "wx/treectrl.h"
+#include "wx/listctrl.h"
+#include "wx/log.h"
+#include "wx/overlay.h"
+
+/*
+  To use this class, create a wxDragImage when you start dragging, for example:
+
+  void MyTreeCtrl::OnBeginDrag(wxTreeEvent& event)
+  {
+#ifdef __WXMSW__
+    ::UpdateWindow((HWND) GetHWND()); // We need to implement this in wxWidgets
+#endif
+
+    CaptureMouse();
+
+    m_dragImage = new wxDragImage(* this, itemId);
+    m_dragImage->BeginDrag(wxPoint(0, 0), this);
+    m_dragImage->Move(pt, this);
+    m_dragImage->Show(this);
+    ...
+  }
+
+  In your OnMouseMove function, hide the image, do any display updating required,
+  then move and show the image again:
+
+  void MyTreeCtrl::OnMouseMove(wxMouseEvent& event)
+  {
+    if (m_dragMode == MY_TREE_DRAG_NONE)
+    {
+        event.Skip();
+        return;
+    }
+
+    // Prevent screen corruption by hiding the image
+    if (m_dragImage)
+        m_dragImage->Hide(this);
+
+    // Do some updating of the window, such as highlighting the drop target
+    ...
+
+#ifdef __WXMSW__
+    if (updateWindow)
+        ::UpdateWindow((HWND) GetHWND());
+#endif
+
+    // Move and show the image again
+    m_dragImage->Move(event.GetPosition(), this);
+    m_dragImage->Show(this);
+ }
+
+ Eventually we end the drag and delete the drag image.
+
+ void MyTreeCtrl::OnLeftUp(wxMouseEvent& event)
+ {
+    ...
+
+    // End the drag and delete the drag image
+    if (m_dragImage)
+    {
+        m_dragImage->EndDrag(this);
+        delete m_dragImage;
+        m_dragImage = NULL;
+    }
+    ReleaseMouse();
+ }
+*/
+
+/*
+ * wxGenericDragImage
+ */
+
+class WXDLLEXPORT wxGenericDragImage: public wxObject
+{
+public:
+
+    // Ctors & dtor
+    ////////////////////////////////////////////////////////////////////////////
+
+    wxGenericDragImage(const wxCursor& cursor = wxNullCursor)
+    {
+        Init();
+        Create(cursor);
+    }
+
+    wxGenericDragImage(const wxBitmap& image, const wxCursor& cursor = wxNullCursor)
+    {
+        Init();
+
+        Create(image, cursor);
+    }
+
+    wxGenericDragImage(const wxIcon& image, const wxCursor& cursor = wxNullCursor)
+    {
+        Init();
+
+        Create(image, cursor);
+    }
+
+    wxGenericDragImage(const wxString& str, const wxCursor& cursor = wxNullCursor)
+    {
+        Init();
+
+        Create(str, cursor);
+    }
+
+#if WXWIN_COMPATIBILITY_2_6
+    // don't use in new code, use versions without hot spot parameter
+    wxDEPRECATED( wxGenericDragImage(const wxCursor& cursor, const wxPoint& cursorHotspot) );
+    wxDEPRECATED( wxGenericDragImage(const wxBitmap& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
+    wxDEPRECATED( wxGenericDragImage(const wxIcon& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
+    wxDEPRECATED( wxGenericDragImage(const wxString& str, const wxCursor& cursor, const wxPoint& cursorHotspot) );
+    wxDEPRECATED( bool Create(const wxCursor& cursor, const wxPoint& cursorHotspot) );
+    wxDEPRECATED( bool Create(const wxBitmap& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
+    wxDEPRECATED( bool Create(const wxIcon& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
+    wxDEPRECATED( bool Create(const wxString& str, const wxCursor& cursor, const wxPoint& cursorHotspot) );
+#endif // WXWIN_COMPATIBILITY_2_6
+
+#if wxUSE_TREECTRL
+    wxGenericDragImage(const wxTreeCtrl& treeCtrl, wxTreeItemId& id)
+    {
+        Init();
+
+        Create(treeCtrl, id);
+    }
+#endif
+
+#if wxUSE_LISTCTRL
+    wxGenericDragImage(const wxListCtrl& listCtrl, long id)
+    {
+        Init();
+
+        Create(listCtrl, id);
+    }
+#endif
+
+    virtual ~wxGenericDragImage();
+
+    // Attributes
+    ////////////////////////////////////////////////////////////////////////////
+
+    // For efficiency, tell wxGenericDragImage to use a bitmap that's already
+    // created (e.g. from last drag)
+    void SetBackingBitmap(wxBitmap* bitmap) { 
+#ifndef wxHAS_NATIVE_OVERLAY
+        m_pBackingBitmap = bitmap; 
+#endif
+    }
+
+    // Operations
+    ////////////////////////////////////////////////////////////////////////////
+
+    // Create a drag image with a virtual image (need to override DoDrawImage, GetImageRect)
+    bool Create(const wxCursor& cursor = wxNullCursor);
+
+    // Create a drag image from a bitmap and optional cursor
+    bool Create(const wxBitmap& image, const wxCursor& cursor = wxNullCursor);
+
+    // Create a drag image from an icon and optional cursor
+    bool Create(const wxIcon& image, const wxCursor& cursor = wxNullCursor);
+
+    // Create a drag image from a string and optional cursor
+    bool Create(const wxString& str, const wxCursor& cursor = wxNullCursor);
+
+#if wxUSE_TREECTRL
+    // Create a drag image for the given tree control item
+    bool Create(const wxTreeCtrl& treeCtrl, wxTreeItemId& id);
+#endif
+
+#if wxUSE_LISTCTRL
+    // Create a drag image for the given list control item
+    bool Create(const wxListCtrl& listCtrl, long id);
+#endif
+
+    // Begin drag. hotspot is the location of the drag position relative to the upper-left
+    // corner of the image.
+    bool BeginDrag(const wxPoint& hotspot, wxWindow* window, bool fullScreen = false, wxRect* rect = (wxRect*) NULL);
+
+    // Begin drag. hotspot is the location of the drag position relative to the upper-left
+    // corner of the image. This is full screen only. fullScreenRect gives the
+    // position of the window on the screen, to restrict the drag to.
+    bool BeginDrag(const wxPoint& hotspot, wxWindow* window, wxWindow* fullScreenRect);
+
+    // End drag
+    bool EndDrag();
+
+    // Move the image: call from OnMouseMove. Pt is in window client coordinates if window
+    // is non-NULL, or in screen coordinates if NULL.
+    bool Move(const wxPoint& pt);
+
+    // Show the image
+    bool Show();
+
+    // Hide the image
+    bool Hide();
+
+    // Implementation
+    ////////////////////////////////////////////////////////////////////////////
+
+    void Init();
+
+    // Override this if you are using a virtual image (drawing your own image)
+    virtual wxRect GetImageRect(const wxPoint& pos) const;
+
+    // Override this if you are using a virtual image (drawing your own image)
+    virtual bool DoDrawImage(wxDC& dc, const wxPoint& pos) const;
+
+    // Override this if you wish to draw the window contents to the backing bitmap
+    // yourself. This can be desirable if you wish to avoid flicker by not having to
+    // redraw the window itself before dragging in order to be graphic-minus-dragged-objects.
+    // Instead, paint the drag image's backing bitmap to be correct, and leave the window
+    // to be updated only when dragging the objects away (thus giving a smoother appearance).
+    virtual bool UpdateBackingFromWindow(wxDC& windowDC, wxMemoryDC& destDC,
+                                         const wxRect& sourceRect, const wxRect& destRect) const;
+
+    // Erase and redraw simultaneously if possible
+    virtual bool RedrawImage(const wxPoint& oldPos, const wxPoint& newPos, bool eraseOld, bool drawNew);
+
+protected:
+    wxBitmap        m_bitmap;
+    wxIcon          m_icon;
+    wxCursor        m_cursor;
+    wxCursor        m_oldCursor;
+//    wxPoint         m_hotspot;
+    wxPoint         m_offset; // The hostpot value passed to BeginDrag
+    wxPoint         m_position;
+    bool            m_isDirty;
+    bool            m_isShown;
+    wxWindow*       m_window;
+    wxDC*           m_windowDC;
+
+#ifdef wxHAS_NATIVE_OVERLAY
+    wxOverlay       m_overlay;
+    wxDCOverlay*     m_dcOverlay;
+#else
+    // Stores the window contents while we're dragging the image around
+    wxBitmap        m_backingBitmap;
+    wxBitmap*       m_pBackingBitmap; // Pointer to existing backing bitmap
+                                      // (pass to wxGenericDragImage as an efficiency measure)
+    // A temporary bitmap for repairing/redrawing
+    wxBitmap        m_repairBitmap;
+#endif // !wxHAS_NATIVE_OVERLAY
+
+    wxRect          m_boundingRect;
+    bool            m_fullScreen;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxGenericDragImage)
+    DECLARE_NO_COPY_CLASS(wxGenericDragImage)
+};
+
+#endif
+    // _WX_DRAGIMGG_H_

wxWidgets/include/wx/generic/fdrepdlg.h

@@ -0,0 +1,71 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/msw/fdrepdlg.h
+// Purpose:     wxGenericFindReplaceDialog class
+// Author:      Markus Greither
+// Modified by:
+// Created:     25/05/2001
+// RCS-ID:
+// Copyright:   (c) wxWidgets team
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_FDREPDLG_H_
+#define _WX_GENERIC_FDREPDLG_H_
+
+class WXDLLEXPORT wxCheckBox;
+class WXDLLEXPORT wxRadioBox;
+class WXDLLEXPORT wxTextCtrl;
+
+// ----------------------------------------------------------------------------
+// wxGenericFindReplaceDialog: dialog for searching / replacing text
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericFindReplaceDialog : public wxFindReplaceDialogBase
+{
+public:
+    wxGenericFindReplaceDialog() { Init(); }
+
+    wxGenericFindReplaceDialog(wxWindow *parent,
+                               wxFindReplaceData *data,
+                               const wxString& title,
+                               int style = 0)
+    {
+        Init();
+
+        (void)Create(parent, data, title, style);
+    }
+
+    bool Create(wxWindow *parent,
+                wxFindReplaceData *data,
+                const wxString& title,
+                int style = 0);
+
+protected:
+    void Init();
+
+    void SendEvent(const wxEventType& evtType);
+
+    void OnFind(wxCommandEvent& event);
+    void OnReplace(wxCommandEvent& event);
+    void OnReplaceAll(wxCommandEvent& event);
+    void OnCancel(wxCommandEvent& event);
+
+    void OnUpdateFindUI(wxUpdateUIEvent& event);
+
+    void OnCloseWindow(wxCloseEvent& event);
+
+    wxCheckBox *m_chkCase,
+               *m_chkWord;
+
+    wxRadioBox *m_radioDir;
+
+    wxTextCtrl *m_textFind,
+               *m_textRepl;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxGenericFindReplaceDialog)
+
+    DECLARE_EVENT_TABLE()
+};
+
+#endif // _WX_GENERIC_FDREPDLG_H_

wxWidgets/include/wx/generic/filedlgg.h

@@ -0,0 +1,307 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/filedlgg.h
+// Purpose:     wxGenericFileDialog
+// Author:      Robert Roebling
+// Modified by:
+// Created:     8/17/99
+// Copyright:   (c) Robert Roebling
+// RCS-ID:      $Id: filedlgg.h 39631 2006-06-08 10:05:42Z RR $
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_FILEDLGG_H_
+#define _WX_FILEDLGG_H_
+
+#include "wx/listctrl.h"
+#include "wx/datetime.h"
+#include "wx/filefn.h"
+#include "wx/filedlg.h"
+
+//-----------------------------------------------------------------------------
+// classes
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxBitmapButton;
+class WXDLLEXPORT wxCheckBox;
+class WXDLLEXPORT wxChoice;
+class WXDLLEXPORT wxFileData;
+class WXDLLEXPORT wxFileCtrl;
+class WXDLLEXPORT wxGenericFileDialog;
+class WXDLLEXPORT wxListEvent;
+class WXDLLEXPORT wxListItem;
+class WXDLLEXPORT wxStaticText;
+class WXDLLEXPORT wxTextCtrl;
+
+//-------------------------------------------------------------------------
+// wxGenericFileDialog
+//-------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericFileDialog: public wxFileDialogBase
+{
+public:
+    wxGenericFileDialog() : wxFileDialogBase() { Init(); }
+
+    wxGenericFileDialog(wxWindow *parent,
+                        const wxString& message = wxFileSelectorPromptStr,
+                        const wxString& defaultDir = wxEmptyString,
+                        const wxString& defaultFile = wxEmptyString,
+                        const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
+                        long style = wxFD_DEFAULT_STYLE,
+                        const wxPoint& pos = wxDefaultPosition,
+                        const wxSize& sz = wxDefaultSize,
+                        const wxString& name = wxFileDialogNameStr,
+                        bool bypassGenericImpl = false );
+
+    bool Create( wxWindow *parent,
+                 const wxString& message = wxFileSelectorPromptStr,
+                 const wxString& defaultDir = wxEmptyString,
+                 const wxString& defaultFile = wxEmptyString,
+                 const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
+                 long style = wxFD_DEFAULT_STYLE,
+                 const wxPoint& pos = wxDefaultPosition,
+                 const wxSize& sz = wxDefaultSize,
+                 const wxString& name = wxFileDialogNameStr,
+                 bool bypassGenericImpl = false );
+
+    virtual ~wxGenericFileDialog();
+
+    virtual void SetMessage(const wxString& message) { SetTitle(message); }
+    virtual void SetPath(const wxString& path);
+    virtual void SetFilterIndex(int filterIndex);
+    virtual void SetWildcard(const wxString& wildCard);
+
+    // for multiple file selection
+    virtual void GetPaths(wxArrayString& paths) const;
+    virtual void GetFilenames(wxArrayString& files) const;
+
+    // implementation only from now on
+    // -------------------------------
+
+    virtual int ShowModal();
+    virtual bool Show( bool show = true );
+
+    void OnSelected( wxListEvent &event );
+    void OnActivated( wxListEvent &event );
+    void OnList( wxCommandEvent &event );
+    void OnReport( wxCommandEvent &event );
+    void OnUp( wxCommandEvent &event );
+    void OnHome( wxCommandEvent &event );
+    void OnListOk( wxCommandEvent &event );
+    void OnNew( wxCommandEvent &event );
+    void OnChoiceFilter( wxCommandEvent &event );
+    void OnTextEnter( wxCommandEvent &event );
+    void OnTextChange( wxCommandEvent &event );
+    void OnCheck( wxCommandEvent &event );
+
+    virtual void HandleAction( const wxString &fn );
+
+    virtual void UpdateControls();
+
+private:
+    // Don't use this implementation at all :-)
+    bool m_bypassGenericImpl;
+
+protected:
+    // use the filter with the given index
+    void DoSetFilterIndex(int filterindex);
+
+    wxString       m_filterExtension;
+    wxChoice      *m_choice;
+    wxTextCtrl    *m_text;
+    wxFileCtrl    *m_list;
+    wxCheckBox    *m_check;
+    wxStaticText  *m_static;
+    wxBitmapButton *m_upDirButton;
+    wxBitmapButton *m_newDirButton;
+
+private:
+    void Init();
+    DECLARE_DYNAMIC_CLASS(wxGenericFileDialog)
+    DECLARE_EVENT_TABLE()
+
+    // these variables are preserved between wxGenericFileDialog calls
+    static long ms_lastViewStyle;     // list or report?
+    static bool ms_lastShowHidden;    // did we show hidden files?
+};
+
+#ifdef wxUSE_GENERIC_FILEDIALOG
+
+class WXDLLEXPORT wxFileDialog: public wxGenericFileDialog
+{
+public:
+     wxFileDialog() {}
+
+    wxFileDialog(wxWindow *parent,
+                 const wxString& message = wxFileSelectorPromptStr,
+                 const wxString& defaultDir = wxEmptyString,
+                 const wxString& defaultFile = wxEmptyString,
+                 const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
+                 long style = 0,
+                 const wxPoint& pos = wxDefaultPosition)
+          :wxGenericFileDialog(parent, message, defaultDir, defaultFile, wildCard, style, pos)
+     {
+     }
+
+private:
+     DECLARE_DYNAMIC_CLASS(wxFileDialog)
+};
+
+#endif // wxUSE_GENERIC_FILEDIALOG
+
+//-----------------------------------------------------------------------------
+//  wxFileData - a class to hold the file info for the wxFileCtrl
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxFileData
+{
+public:
+    enum fileType
+    {
+        is_file  = 0x0000,
+        is_dir   = 0x0001,
+        is_link  = 0x0002,
+        is_exe   = 0x0004,
+        is_drive = 0x0008
+    };
+
+    wxFileData() { Init(); }
+    // Full copy constructor
+    wxFileData( const wxFileData& fileData ) { Copy(fileData); }
+    // Create a filedata from this information
+    wxFileData( const wxString &filePath, const wxString &fileName,
+                fileType type, int image_id );
+
+    // make a full copy of the other wxFileData
+    void Copy( const wxFileData &other );
+
+    // (re)read the extra data about the file from the system
+    void ReadData();
+
+    // get the name of the file, dir, drive
+    wxString GetFileName() const { return m_fileName; }
+    // get the full path + name of the file, dir, path
+    wxString GetFilePath() const { return m_filePath; }
+    // Set the path + name and name of the item
+    void SetNewName( const wxString &filePath, const wxString &fileName );
+
+    // Get the size of the file in bytes
+    wxFileOffset GetSize() const { return m_size; }
+    // Get the type of file, either file extension or <DIR>, <LINK>, <DRIVE>
+    wxString GetFileType() const;
+    // get the last modification time
+    wxDateTime GetDateTime() const { return m_dateTime; }
+    // Get the time as a formatted string
+    wxString GetModificationTime() const;
+    // in UNIX get rwx for file, in MSW get attributes ARHS
+    wxString GetPermissions() const { return m_permissions; }
+    // Get the id of the image used in a wxImageList
+    int GetImageId() const { return m_image; }
+
+    bool IsFile() const  { return !IsDir() && !IsLink() && !IsDrive(); }
+    bool IsDir() const   { return (m_type & is_dir  ) != 0; }
+    bool IsLink() const  { return (m_type & is_link ) != 0; }
+    bool IsExe() const   { return (m_type & is_exe  ) != 0; }
+    bool IsDrive() const { return (m_type & is_drive) != 0; }
+
+    // Get/Set the type of file, file/dir/drive/link
+    int GetType() const { return m_type; }
+
+    // the wxFileCtrl fields in report view
+    enum fileListFieldType
+    {
+        FileList_Name,
+        FileList_Size,
+        FileList_Type,
+        FileList_Time,
+#if defined(__UNIX__) || defined(__WIN32__)
+        FileList_Perm,
+#endif // defined(__UNIX__) || defined(__WIN32__)
+        FileList_Max
+    };
+
+    // Get the entry for report view of wxFileCtrl
+    wxString GetEntry( fileListFieldType num ) const;
+
+    // Get a string representation of the file info
+    wxString GetHint() const;
+    // initialize a wxListItem attributes
+    void MakeItem( wxListItem &item );
+
+    // operators
+    wxFileData& operator = (const wxFileData& fd) { Copy(fd); return *this; }
+
+protected:
+    wxString m_fileName;
+    wxString   m_filePath;
+    wxFileOffset m_size;
+    wxDateTime m_dateTime;
+    wxString m_permissions;
+    int      m_type;
+    int      m_image;
+
+private:
+    void Init();
+};
+
+//-----------------------------------------------------------------------------
+//  wxFileCtrl
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxFileCtrl : public wxListCtrl
+{
+public:
+    wxFileCtrl();
+    wxFileCtrl( wxWindow *win,
+                wxWindowID id,
+                const wxString &wild,
+                bool showHidden,
+                const wxPoint &pos = wxDefaultPosition,
+                const wxSize &size = wxDefaultSize,
+                long style = wxLC_LIST,
+                const wxValidator &validator = wxDefaultValidator,
+                const wxString &name = wxT("filelist") );
+    virtual ~wxFileCtrl();
+
+    virtual void ChangeToListMode();
+    virtual void ChangeToReportMode();
+    virtual void ChangeToSmallIconMode();
+    virtual void ShowHidden( bool show = true );
+    bool GetShowHidden() const { return m_showHidden; }
+
+    virtual long Add( wxFileData *fd, wxListItem &item );
+    virtual void UpdateItem(const wxListItem &item);
+    virtual void UpdateFiles();
+    virtual void MakeDir();
+    virtual void GoToParentDir();
+    virtual void GoToHomeDir();
+    virtual void GoToDir( const wxString &dir );
+    virtual void SetWild( const wxString &wild );
+    wxString GetWild() const { return m_wild; }
+    wxString GetDir() const { return m_dirName; }
+
+    void OnListDeleteItem( wxListEvent &event );
+    void OnListDeleteAllItems( wxListEvent &event );
+    void OnListEndLabelEdit( wxListEvent &event );
+    void OnListColClick( wxListEvent &event );
+
+    virtual void SortItems(wxFileData::fileListFieldType field, bool foward);
+    bool GetSortDirection() const { return m_sort_foward; }
+    wxFileData::fileListFieldType GetSortField() const { return m_sort_field; }
+
+protected:
+    void FreeItemData(wxListItem& item);
+    void FreeAllItemsData();
+
+    wxString      m_dirName;
+    bool          m_showHidden;
+    wxString      m_wild;
+
+    bool m_sort_foward;
+    wxFileData::fileListFieldType m_sort_field;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxFileCtrl)
+    DECLARE_EVENT_TABLE()
+};
+
+#endif // _WX_FILEDLGG_H_

wxWidgets/include/wx/generic/filepickerg.h

@@ -0,0 +1,213 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/filepickerg.h
+// Purpose:     wxGenericFileDirButton, wxGenericFileButton, wxGenericDirButton
+// Author:      Francesco Montorsi
+// Modified by:
+// Created:     14/4/2006
+// Copyright:   (c) Francesco Montorsi
+// RCS-ID:      $Id: filepickerg.h 40100 2006-07-15 15:13:04Z VS $
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_FILEDIRPICKER_H_
+#define _WX_FILEDIRPICKER_H_
+
+#include "wx/button.h"
+#include "wx/filedlg.h"
+#include "wx/dirdlg.h"
+
+
+extern WXDLLEXPORT_DATA(const wxEventType) wxEVT_COMMAND_DIRPICKER_CHANGED;
+extern WXDLLEXPORT_DATA(const wxEventType) wxEVT_COMMAND_FILEPICKER_CHANGED;
+
+
+//-----------------------------------------------------------------------------
+// wxGenericFileDirButton: a button which brings up a wx{File|Dir}Dialog
+//-----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxGenericFileDirButton : public wxButton,
+                                                public wxFileDirPickerWidgetBase
+{
+public:
+    wxGenericFileDirButton() { }
+    wxGenericFileDirButton(wxWindow *parent,
+                           wxWindowID id,
+                           const wxString& label = wxFilePickerWidgetLabel,
+                           const wxString& path = wxEmptyString,
+                           const wxString &message = wxFileSelectorPromptStr,
+                           const wxString &wildcard = wxFileSelectorDefaultWildcardStr,
+                           const wxPoint& pos = wxDefaultPosition,
+                           const wxSize& size = wxDefaultSize,
+                           long style = 0,
+                           const wxValidator& validator = wxDefaultValidator,
+                           const wxString& name = wxFilePickerWidgetNameStr)
+    {
+        Create(parent, id, label, path, message, wildcard,
+               pos, size, style, validator, name);
+    }
+
+    virtual ~wxGenericFileDirButton() {}
+
+    virtual wxControl *AsControl() { return this; }
+
+public:     // overrideable
+
+    virtual wxDialog *CreateDialog() = 0;
+
+    virtual wxWindow *GetDialogParent()
+        { return GetParent(); }
+
+    virtual wxEventType GetEventType() const = 0;
+
+public:
+
+    bool Create(wxWindow *parent, wxWindowID id,
+           const wxString& label = wxFilePickerWidgetLabel,
+           const wxString& path = wxEmptyString,
+           const wxString &message = wxFileSelectorPromptStr,
+           const wxString &wildcard = wxFileSelectorDefaultWildcardStr,
+           const wxPoint& pos = wxDefaultPosition,
+           const wxSize& size = wxDefaultSize,
+           long style = 0,
+           const wxValidator& validator = wxDefaultValidator,
+           const wxString& name = wxFilePickerWidgetNameStr);
+
+    // event handler for the click
+    void OnButtonClick(wxCommandEvent &);
+
+protected:
+    wxString m_message, m_wildcard;
+};
+
+
+//-----------------------------------------------------------------------------
+// wxGenericFileButton: a button which brings up a wxFileDialog
+//-----------------------------------------------------------------------------
+
+#define wxFILEBTN_DEFAULT_STYLE                     (wxFLP_OPEN)
+
+class WXDLLIMPEXP_CORE wxGenericFileButton : public wxGenericFileDirButton
+{
+public:
+    wxGenericFileButton() {}
+    wxGenericFileButton(wxWindow *parent,
+                        wxWindowID id,
+                        const wxString& label = wxFilePickerWidgetLabel,
+                        const wxString& path = wxEmptyString,
+                        const wxString &message = wxFileSelectorPromptStr,
+                        const wxString &wildcard = wxFileSelectorDefaultWildcardStr,
+                        const wxPoint& pos = wxDefaultPosition,
+                        const wxSize& size = wxDefaultSize,
+                        long style = wxFILEBTN_DEFAULT_STYLE,
+                        const wxValidator& validator = wxDefaultValidator,
+                        const wxString& name = wxFilePickerWidgetNameStr)
+    {
+        Create(parent, id, label, path, message, wildcard,
+               pos, size, style, validator, name);
+    }
+
+public:     // overrideable
+
+    virtual long GetDialogStyle() const
+    {
+        long filedlgstyle = 0;
+
+        if (this->HasFlag(wxFLP_OPEN))
+            filedlgstyle |= wxFD_OPEN;
+        if (this->HasFlag(wxFLP_SAVE))
+            filedlgstyle |= wxFD_SAVE;
+        if (this->HasFlag(wxFLP_OVERWRITE_PROMPT))
+            filedlgstyle |= wxFD_OVERWRITE_PROMPT;
+        if (this->HasFlag(wxFLP_FILE_MUST_EXIST))
+            filedlgstyle |= wxFD_FILE_MUST_EXIST;
+        if (this->HasFlag(wxFLP_CHANGE_DIR))
+            filedlgstyle |= wxFD_CHANGE_DIR;
+
+        return filedlgstyle;
+    }
+
+    virtual wxDialog *CreateDialog()
+    {
+        wxFileDialog *p = new wxFileDialog(GetDialogParent(), m_message,
+                                    wxEmptyString, wxEmptyString,
+                                    m_wildcard, GetDialogStyle());
+
+        // this sets both the default folder and the default file of the dialog
+        p->SetPath(m_path);
+        return p;
+    }
+
+    wxEventType GetEventType() const
+        { return wxEVT_COMMAND_FILEPICKER_CHANGED; }
+
+protected:
+    void UpdateDialogPath(wxDialog *p)
+        { wxStaticCast(p, wxFileDialog)->SetPath(m_path); }
+    void UpdatePathFromDialog(wxDialog *p)
+        { m_path = wxStaticCast(p, wxFileDialog)->GetPath(); }
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxGenericFileButton)
+};
+
+
+//-----------------------------------------------------------------------------
+// wxGenericDirButton: a button which brings up a wxDirDialog
+//-----------------------------------------------------------------------------
+
+#define wxDIRBTN_DEFAULT_STYLE                     0
+
+class WXDLLIMPEXP_CORE wxGenericDirButton : public wxGenericFileDirButton
+{
+public:
+    wxGenericDirButton() {}
+    wxGenericDirButton(wxWindow *parent,
+                       wxWindowID id,
+                       const wxString& label = wxDirPickerWidgetLabel,
+                       const wxString& path = wxEmptyString,
+                       const wxString &message = wxDirSelectorPromptStr,
+                       const wxPoint& pos = wxDefaultPosition,
+                       const wxSize& size = wxDefaultSize,
+                       long style = wxDIRBTN_DEFAULT_STYLE,
+                       const wxValidator& validator = wxDefaultValidator,
+                       const wxString& name = wxDirPickerWidgetNameStr)
+    {
+        Create(parent, id, label, path, message, wxEmptyString,
+               pos, size, style, validator, name);
+    }
+
+public:     // overrideable
+
+    virtual long GetDialogStyle() const
+    {
+        long dirdlgstyle = wxDD_DEFAULT_STYLE;
+
+        if (this->HasFlag(wxDIRP_DIR_MUST_EXIST))
+            dirdlgstyle |= wxDD_DIR_MUST_EXIST;
+        if (this->HasFlag(wxDIRP_CHANGE_DIR))
+            dirdlgstyle |= wxDD_CHANGE_DIR;
+
+        return dirdlgstyle;
+    }
+
+    virtual wxDialog *CreateDialog()
+    {
+        return new wxDirDialog(GetDialogParent(), m_message, m_path,
+                                   GetDialogStyle());
+    }
+
+    wxEventType GetEventType() const
+        { return wxEVT_COMMAND_DIRPICKER_CHANGED; }
+
+protected:
+    void UpdateDialogPath(wxDialog *p)
+        { wxStaticCast(p, wxDirDialog)->SetPath(m_path); }
+    void UpdatePathFromDialog(wxDialog *p)
+        { m_path = wxStaticCast(p, wxDirDialog)->GetPath(); }
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxGenericDirButton)
+};
+
+
+#endif // _WX_FILEDIRPICKER_H_

wxWidgets/include/wx/generic/fontdlgg.h

@@ -0,0 +1,120 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/fontdlgg.h
+// Purpose:     wxGenericFontDialog
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: fontdlgg.h 39286 2006-05-23 11:16:47Z JS $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_FONTDLGG_H
+#define _WX_GENERIC_FONTDLGG_H
+
+#include "wx/defs.h"
+#include "wx/gdicmn.h"
+#include "wx/font.h"
+#include "wx/dialog.h"
+#include "wx/cmndata.h"
+
+#ifdef __WXWINCE__
+#define USE_SPINCTRL_FOR_POINT_SIZE 1
+class WXDLLEXPORT wxSpinEvent;
+#else
+#define USE_SPINCTRL_FOR_POINT_SIZE 0
+#endif
+
+/*
+ * FONT DIALOG
+ */
+
+class WXDLLEXPORT wxChoice;
+class WXDLLEXPORT wxText;
+class WXDLLEXPORT wxCheckBox;
+class WXDLLEXPORT wxFontPreviewer;
+
+enum
+{
+    wxID_FONT_UNDERLINE = 3000,
+    wxID_FONT_STYLE,
+    wxID_FONT_WEIGHT,
+    wxID_FONT_FAMILY,
+    wxID_FONT_COLOUR,
+    wxID_FONT_SIZE
+};
+
+class WXDLLEXPORT wxGenericFontDialog : public wxFontDialogBase
+{
+public:
+    wxGenericFontDialog() { Init(); }
+    wxGenericFontDialog(wxWindow *parent)
+        : wxFontDialogBase(parent) { Init(); }
+    wxGenericFontDialog(wxWindow *parent, const wxFontData& data)
+        : wxFontDialogBase(parent, data) { Init(); }
+    virtual ~wxGenericFontDialog();
+
+    virtual int ShowModal();
+
+#if WXWIN_COMPATIBILITY_2_6
+    // deprecated, for backwards compatibility only
+    wxDEPRECATED( wxGenericFontDialog(wxWindow *parent, const wxFontData *data) );
+#endif // WXWIN_COMPATIBILITY_2_6
+
+    // Internal functions
+    void OnCloseWindow(wxCloseEvent& event);
+
+    virtual void CreateWidgets();
+    virtual void InitializeFont();
+
+    void OnChangeFont(wxCommandEvent& event);
+
+#if USE_SPINCTRL_FOR_POINT_SIZE
+    void OnChangeSize(wxSpinEvent& event);
+#endif
+
+protected:
+
+    virtual bool DoCreate(wxWindow *parent);
+
+private:
+
+    // common part of all ctors
+    void Init();
+
+    void DoChangeFont();
+
+    wxFont m_dialogFont;
+
+    wxChoice *m_familyChoice;
+    wxChoice *m_styleChoice;
+    wxChoice *m_weightChoice;
+    wxChoice *m_colourChoice;
+    wxCheckBox *m_underLineCheckBox;
+
+#if !USE_SPINCTRL_FOR_POINT_SIZE
+    wxChoice   *m_pointSizeChoice;
+#endif
+
+    wxFontPreviewer *m_previewer;
+    bool       m_useEvents;
+
+    //  static bool fontDialogCancelled;
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS(wxGenericFontDialog)
+};
+
+WXDLLEXPORT const wxChar *wxFontFamilyIntToString(int family);
+WXDLLEXPORT const wxChar *wxFontWeightIntToString(int weight);
+WXDLLEXPORT const wxChar *wxFontStyleIntToString(int style);
+WXDLLEXPORT int wxFontFamilyStringToInt(wxChar *family);
+WXDLLEXPORT int wxFontWeightStringToInt(wxChar *weight);
+WXDLLEXPORT int wxFontStyleStringToInt(wxChar *style);
+
+#if WXWIN_COMPATIBILITY_2_6
+    // deprecated, for backwards compatibility only
+inline wxGenericFontDialog::wxGenericFontDialog(wxWindow *parent, const wxFontData *data)
+                           :wxFontDialogBase(parent) { Init(); InitFontData(data); Create(parent); }
+#endif // WXWIN_COMPATIBILITY_2_6
+
+#endif // _WX_GENERIC_FONTDLGG_H

wxWidgets/include/wx/generic/fontpickerg.h

@@ -0,0 +1,82 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/fontpickerg.h
+// Purpose:     wxGenericFontButton header
+// Author:      Francesco Montorsi
+// Modified by:
+// Created:     14/4/2006
+// Copyright:   (c) Francesco Montorsi
+// RCS-ID:      $Id: fontpickerg.h 42999 2006-11-03 21:54:13Z VZ $
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_FONTPICKER_H_
+#define _WX_FONTPICKER_H_
+
+#include "wx/button.h"
+#include "wx/cmndata.h"
+
+//-----------------------------------------------------------------------------
+// wxGenericFontButton: a button which brings up a wxColourDialog
+//-----------------------------------------------------------------------------
+
+#define wxFONTBTN_DEFAULT_STYLE \
+    (wxFNTP_FONTDESC_AS_LABEL | wxFNTP_USEFONT_FOR_LABEL)
+
+class WXDLLIMPEXP_CORE wxGenericFontButton : public wxButton,
+                                             public wxFontPickerWidgetBase
+{
+public:
+    wxGenericFontButton() {}
+    wxGenericFontButton(wxWindow *parent,
+                        wxWindowID id,
+                        const wxFont &initial = wxNullFont,
+                        const wxPoint& pos = wxDefaultPosition,
+                        const wxSize& size = wxDefaultSize,
+                        long style = wxFONTBTN_DEFAULT_STYLE,
+                        const wxValidator& validator = wxDefaultValidator,
+                        const wxString& name = wxFontPickerWidgetNameStr)
+    {
+        Create(parent, id, initial, pos, size, style, validator, name);
+    }
+
+    virtual ~wxGenericFontButton() {}
+
+
+public:     // API extensions specific for wxGenericFontButton
+
+    // user can override this to init font data in a different way
+    virtual void InitFontData();
+
+    // returns the font data shown in wxColourDialog
+    wxFontData *GetFontData() { return &ms_data; }
+
+
+public:
+
+    bool Create(wxWindow *parent,
+                wxWindowID id,
+                const wxFont &initial = *wxNORMAL_FONT,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxFONTBTN_DEFAULT_STYLE,
+                const wxValidator& validator = wxDefaultValidator,
+                const wxString& name = wxFontPickerWidgetNameStr);
+
+    void OnButtonClick(wxCommandEvent &);
+
+
+protected:
+
+    void UpdateFont();
+
+    // the colour data shown in wxColourPickerCtrlGeneric
+    // controls. This member is static so that all colour pickers
+    // in the program share the same set of custom colours.
+    static wxFontData ms_data;
+
+private:
+   DECLARE_DYNAMIC_CLASS(wxGenericFontButton)
+};
+
+
+#endif // _WX_FONTPICKER_H_

wxWidgets/include/wx/generic/gridctrl.h

@@ -0,0 +1,158 @@
+///////////////////////////////////////////////////////////////////////////
+// Name:        generic/gridctrl.h
+// Purpose:     wxGrid controls
+// Author:      Paul Gammans, Roger Gammans
+// Modified by:
+// Created:     11/04/2001
+// RCS-ID:      $Id: gridctrl.h 61872 2009-09-09 22:37:05Z VZ $
+// Copyright:   (c) The Computer Surgery (paul@compsurg.co.uk)
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_GRIDCTRL_H_
+#define _WX_GENERIC_GRIDCTRL_H_
+
+#include "wx/grid.h"
+
+#if wxUSE_GRID
+
+#define wxGRID_VALUE_CHOICEINT    wxT("choiceint")
+#define wxGRID_VALUE_DATETIME     wxT("datetime")
+
+#if wxUSE_DATETIME
+
+#include "wx/datetime.h"
+
+// the default renderer for the cells containing Time and dates..
+class WXDLLIMPEXP_ADV wxGridCellDateTimeRenderer : public wxGridCellStringRenderer
+{
+public:
+    wxGridCellDateTimeRenderer(const wxString& outformat = wxDefaultDateTimeFormat,
+                               const wxString& informat = wxDefaultDateTimeFormat);
+
+    // draw the string right aligned
+    virtual void Draw(wxGrid& grid,
+                      wxGridCellAttr& attr,
+                      wxDC& dc,
+                      const wxRect& rect,
+                      int row, int col,
+                      bool isSelected);
+
+    virtual wxSize GetBestSize(wxGrid& grid,
+                               wxGridCellAttr& attr,
+                               wxDC& dc,
+                               int row, int col);
+
+    virtual wxGridCellRenderer *Clone() const;
+
+    // parameters string format is "width[,precision]"
+    virtual void SetParameters(const wxString& params);
+
+protected:
+    wxString GetString(const wxGrid& grid, int row, int col);
+
+    wxString m_iformat;
+    wxString m_oformat;
+    wxDateTime m_dateDef;
+    wxDateTime::TimeZone m_tz;
+};
+
+#endif // wxUSE_DATETIME
+
+// the default renderer for the cells containing Time and dates..
+class WXDLLIMPEXP_ADV wxGridCellEnumRenderer : public wxGridCellStringRenderer
+{
+public:
+    wxGridCellEnumRenderer( const wxString& choices = wxEmptyString );
+
+    // draw the string right aligned
+    virtual void Draw(wxGrid& grid,
+                      wxGridCellAttr& attr,
+                      wxDC& dc,
+                      const wxRect& rect,
+                      int row, int col,
+                      bool isSelected);
+
+    virtual wxSize GetBestSize(wxGrid& grid,
+                               wxGridCellAttr& attr,
+                               wxDC& dc,
+                               int row, int col);
+
+    virtual wxGridCellRenderer *Clone() const;
+
+    // parameters string format is "item1[,item2[...,itemN]]"
+    virtual void SetParameters(const wxString& params);
+
+protected:
+    wxString GetString(const wxGrid& grid, int row, int col);
+
+    wxArrayString m_choices;
+};
+
+
+#if wxUSE_COMBOBOX
+
+class WXDLLIMPEXP_ADV wxGridCellEnumEditor : public wxGridCellChoiceEditor
+{
+public:
+    wxGridCellEnumEditor( const wxString& choices = wxEmptyString );
+    virtual ~wxGridCellEnumEditor() {}
+
+    virtual wxGridCellEditor*  Clone() const;
+
+    virtual bool EndEdit(int row, int col, wxGrid* grid);
+    virtual void BeginEdit(int row, int col, wxGrid* grid);
+
+private:
+    long int   m_startint;
+
+    DECLARE_NO_COPY_CLASS(wxGridCellEnumEditor)
+};
+
+#endif // wxUSE_COMBOBOX
+
+class WXDLLIMPEXP_ADV wxGridCellAutoWrapStringEditor : public wxGridCellTextEditor
+{
+public:
+    wxGridCellAutoWrapStringEditor() : wxGridCellTextEditor() { }
+    virtual void Create(wxWindow* parent,
+                        wxWindowID id,
+                        wxEvtHandler* evtHandler);
+
+    virtual wxGridCellEditor *Clone() const
+        { return new wxGridCellAutoWrapStringEditor; }
+
+    DECLARE_NO_COPY_CLASS(wxGridCellAutoWrapStringEditor)
+};
+
+class WXDLLIMPEXP_ADV wxGridCellAutoWrapStringRenderer : public wxGridCellStringRenderer
+{
+public:
+    wxGridCellAutoWrapStringRenderer() : wxGridCellStringRenderer() { }
+
+    virtual void Draw(wxGrid& grid,
+                      wxGridCellAttr& attr,
+                      wxDC& dc,
+                      const wxRect& rect,
+                      int row, int col,
+                      bool isSelected);
+
+    virtual wxSize GetBestSize(wxGrid& grid,
+                               wxGridCellAttr& attr,
+                               wxDC& dc,
+                               int row, int col);
+
+    virtual wxGridCellRenderer *Clone() const
+        { return new wxGridCellAutoWrapStringRenderer; }
+
+private:
+    wxArrayString GetTextLines( wxGrid& grid,
+                                wxDC& dc,
+                                const wxGridCellAttr& attr,
+                                const wxRect& rect,
+                                int row, int col);
+
+};
+
+#endif  // wxUSE_GRID
+#endif // _WX_GENERIC_GRIDCTRL_H_

wxWidgets/include/wx/generic/gridsel.h

@@ -0,0 +1,88 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/gridsel.h
+// Purpose:     wxGridSelection
+// Author:      Stefan Neis
+// Modified by:
+// Created:     20/02/2000
+// RCS-ID:      $$
+// Copyright:   (c) Stefan Neis
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_GRIDSEL_H_
+#define _WX_GENERIC_GRIDSEL_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_GRID
+
+#include "wx/grid.h"
+
+class WXDLLIMPEXP_ADV wxGridSelection
+{
+public:
+    wxGridSelection( wxGrid * grid, wxGrid::wxGridSelectionModes sel =
+                     wxGrid::wxGridSelectCells );
+    bool IsSelection();
+    bool IsInSelection ( int row, int col );
+    void SetSelectionMode(wxGrid::wxGridSelectionModes selmode);
+    wxGrid::wxGridSelectionModes GetSelectionMode() { return m_selectionMode; }
+    void SelectRow( int row,
+                    bool ControlDown = false,  bool ShiftDown = false,
+                    bool AltDown = false, bool MetaDown = false );
+    void SelectCol( int col,
+                    bool ControlDown = false,  bool ShiftDown = false,
+                    bool AltDown = false, bool MetaDown = false );
+    void SelectBlock( int topRow, int leftCol,
+                      int bottomRow, int rightCol,
+                      bool ControlDown = false,  bool ShiftDown = false,
+                      bool AltDown = false, bool MetaDown = false,
+                      bool sendEvent = true );
+    void SelectCell( int row, int col,
+                     bool ControlDown = false,  bool ShiftDown = false,
+                     bool AltDown = false, bool MetaDown = false,
+                     bool sendEvent = true );
+    void ToggleCellSelection( int row, int col,
+                              bool ControlDown = false,
+                              bool ShiftDown = false,
+                              bool AltDown = false, bool MetaDown = false );
+    void ClearSelection();
+
+    void UpdateRows( size_t pos, int numRows );
+    void UpdateCols( size_t pos, int numCols );
+
+private:
+    int BlockContain( int topRow1, int leftCol1,
+                       int bottomRow1, int rightCol1,
+                       int topRow2, int leftCol2,
+                       int bottomRow2, int rightCol2 );
+      // returns 1, if Block1 contains Block2,
+      //        -1, if Block2 contains Block1,
+      //         0, otherwise
+
+    int BlockContainsCell( int topRow, int leftCol,
+                           int bottomRow, int rightCol,
+                           int row, int col )
+      // returns 1, if Block contains Cell,
+      //         0, otherwise
+    {
+        return ( topRow <= row && row <= bottomRow &&
+                 leftCol <= col && col <= rightCol );
+    }
+
+    wxGridCellCoordsArray               m_cellSelection;
+    wxGridCellCoordsArray               m_blockSelectionTopLeft;
+    wxGridCellCoordsArray               m_blockSelectionBottomRight;
+    wxArrayInt                          m_rowSelection;
+    wxArrayInt                          m_colSelection;
+
+    wxGrid                              *m_grid;
+    wxGrid::wxGridSelectionModes        m_selectionMode;
+
+    friend class WXDLLIMPEXP_FWD_ADV wxGrid;
+
+    DECLARE_NO_COPY_CLASS(wxGridSelection)
+};
+
+#endif  // wxUSE_GRID
+#endif  // _WX_GENERIC_GRIDSEL_H_

wxWidgets/include/wx/generic/helpext.h

@@ -0,0 +1,166 @@
+/*-*- c++ -*-********************************************************
+ * helpext.h - an external help controller for wxWidgets            *
+ *                                                                  *
+ * (C) 1998 by Karsten Ballueder (Ballueder@usa.net)                 *
+ * License: wxWindows licence                                       *
+ *                                                                  *
+ * $Id: helpext.h 50711 2007-12-15 02:57:58Z VZ $
+ *******************************************************************/
+
+#ifndef __WX_HELPEXT_H_
+#define __WX_HELPEXT_H_
+
+#if wxUSE_HELP
+
+#include "wx/helpbase.h"
+
+/**
+   This class implements help via an external browser.
+   It requires the name of a directory containing the documentation
+   and a file mapping numerical Section numbers to relative URLS.
+
+   The map file contains two or three fields per line:
+   numeric_id  relative_URL  [; comment/documentation]
+
+   The numeric_id is the id used to look up the entry in
+   DisplaySection()/DisplayBlock(). The relative_URL is a filename of
+   an html file, relative to the help directory. The optional
+   comment/documentation field (after a ';') is used for keyword
+   searches, so some meaningful text here does not hurt.
+   If the documentation itself contains a ';', only the part before
+   that will be displayed in the listbox, but all of it used for search.
+
+   Lines starting with ';' will be ignored.
+*/
+
+class WXDLLIMPEXP_ADV wxExtHelpController : public wxHelpControllerBase
+{
+public:
+   wxExtHelpController(wxWindow* parentWindow = NULL);
+   virtual ~wxExtHelpController();
+
+   /** Tell it which browser to use.
+       The Netscape support will check whether Netscape is already
+       running (by looking at the .netscape/lock file in the user's
+       home directory) and tell it to load the page into the existing
+       window.
+       @param browsername The command to call a browser/html viewer.
+       @param isNetscape Set this to true if the browser is some variant of Netscape.
+   */
+   void SetBrowser(const wxString& browsername = wxEmptyString,
+                   bool isNetscape = false);
+
+  // Set viewer: new name for SetBrowser
+  virtual void SetViewer(const wxString& viewer = wxEmptyString,
+                         long flags = wxHELP_NETSCAPE);
+
+   /** This must be called to tell the controller where to find the
+       documentation.
+       If a locale is set, look in file/localename, i.e.
+       If passed "/usr/local/myapp/help" and the current wxLocale is
+       set to be "de", then look in "/usr/local/myapp/help/de/"
+       first and fall back to "/usr/local/myapp/help" if that
+       doesn't exist.
+
+       @param file - NOT a filename, but a directory name.
+       @return true on success
+   */
+   virtual bool Initialize(const wxString& dir, int WXUNUSED(server))
+      { return Initialize(dir); }
+
+   /** This must be called to tell the controller where to find the
+       documentation.
+       If a locale is set, look in file/localename, i.e.
+       If passed "/usr/local/myapp/help" and the current wxLocale is
+       set to be "de", then look in "/usr/local/myapp/help/de/"
+       first and fall back to "/usr/local/myapp/help" if that
+       doesn't exist.
+       @param dir - directory name where to fine the help files
+       @return true on success
+   */
+   virtual bool Initialize(const wxString& dir);
+
+   /** If file is "", reloads file given in Initialize.
+       @file Name of help directory.
+       @return true on success
+   */
+   virtual bool LoadFile(const wxString& file = wxEmptyString);
+
+   /** Display list of all help entries.
+       @return true on success
+   */
+   virtual bool DisplayContents(void);
+   /** Display help for id sectionNo.
+       @return true on success
+   */
+   virtual bool DisplaySection(int sectionNo);
+   /** Display help for id sectionNo -- identical with DisplaySection().
+       @return true on success
+   */
+   virtual bool DisplaySection(const wxString& section);
+   /** Display help for URL (using DisplayHelp) or keyword (using KeywordSearch)
+       @return true on success
+   */
+   virtual bool DisplayBlock(long blockNo);
+   /** Search comment/documentation fields in map file and present a
+       list to chose from.
+       @key k string to search for, empty string will list all entries
+       @return true on success
+   */
+   virtual bool KeywordSearch(const wxString& k,
+                              wxHelpSearchMode mode = wxHELP_SEARCH_ALL);
+
+   /// does nothing
+   virtual bool Quit(void);
+   /// does nothing
+   virtual void OnQuit(void);
+
+   /// Call the browser using a relative URL.
+   virtual bool DisplayHelp(const wxString &) ;
+
+   /// Allows one to override the default settings for the help frame.
+   virtual void SetFrameParameters(const wxString& WXUNUSED(title),
+                                   const wxSize& WXUNUSED(size),
+                                   const wxPoint& WXUNUSED(pos) = wxDefaultPosition,
+                                   bool WXUNUSED(newFrameEachTime) = false)
+      {
+         // does nothing by default
+      }
+   /// Obtains the latest settings used by the help frame and the help
+   /// frame.
+   virtual wxFrame *GetFrameParameters(wxSize *WXUNUSED(size) = NULL,
+                                   wxPoint *WXUNUSED(pos) = NULL,
+                                   bool *WXUNUSED(newFrameEachTime) = NULL)
+      {
+         return (wxFrame*) NULL;// does nothing by default
+      }
+
+protected:
+   /// Filename of currently active map file.
+   wxString         m_helpDir;
+   /// How many entries do we have in the map file?
+   int              m_NumOfEntries;
+   /// A list containing all id,url,documentation triples.
+   wxList          *m_MapList;
+
+private:
+   // parse a single line of the map file (called by LoadFile())
+   //
+   // return true if the line was valid or false otherwise
+   bool ParseMapFileLine(const wxString& line);
+
+   /// Deletes the list and all objects.
+   void DeleteList(void);
+
+
+   /// How to call the html viewer.
+   wxString         m_BrowserName;
+   /// Is the viewer a variant of netscape?
+   bool             m_BrowserIsNetscape;
+
+    DECLARE_CLASS(wxExtHelpController)
+};
+
+#endif // wxUSE_HELP
+
+#endif // __WX_HELPEXT_H_

wxWidgets/include/wx/generic/icon.h

@@ -0,0 +1,56 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/icon.h
+// Purpose:     wxIcon implementation for ports where it's same as wxBitmap
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id: icon.h 42752 2006-10-30 19:26:48Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_ICON_H_
+#define _WX_GENERIC_ICON_H_
+
+#include "wx/bitmap.h"
+
+//-----------------------------------------------------------------------------
+// wxIcon
+//-----------------------------------------------------------------------------
+
+#ifndef wxICON_DEFAULT_BITMAP_TYPE
+#define wxICON_DEFAULT_BITMAP_TYPE wxBITMAP_TYPE_XPM
+#endif
+
+class WXDLLIMPEXP_CORE wxIcon: public wxBitmap
+{
+public:
+    wxIcon();
+
+    wxIcon( const char **bits, int width=-1, int height=-1 );
+    wxIcon( char **bits, int width=-1, int height=-1 );
+
+    // For compatibility with wxMSW where desired size is sometimes required to
+    // distinguish between multiple icons in a resource.
+    wxIcon( const wxString& filename,
+            wxBitmapType type = wxICON_DEFAULT_BITMAP_TYPE,
+            int WXUNUSED(desiredWidth)=-1, int WXUNUSED(desiredHeight)=-1 ) :
+        wxBitmap(filename, type)
+    {
+    }
+
+    wxIcon(const wxIconLocation& loc)
+        : wxBitmap(loc.GetFileName(), wxBITMAP_TYPE_ANY)
+    {
+    }
+
+    // create from bitmap (which should have a mask unless it's monochrome):
+    // there shouldn't be any implicit bitmap -> icon conversion (i.e. no
+    // ctors, assignment operators...), but it's ok to have such function
+    void CopyFromBitmap(const wxBitmap& bmp);
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxIcon)
+};
+
+#endif // _WX_GENERIC_ICON_H_

wxWidgets/include/wx/generic/imaglist.h

@@ -0,0 +1,82 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/imaglist.h
+// Purpose:
+// Author:      Robert Roebling
+// Created:     01/02/97
+// Id:
+// Copyright:   (c) 1998 Robert Roebling and Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __IMAGELISTH_G__
+#define __IMAGELISTH_G__
+
+#include "wx/defs.h"
+#include "wx/list.h"
+#include "wx/icon.h"
+
+class WXDLLEXPORT wxDC;
+class WXDLLEXPORT wxBitmap;
+class WXDLLEXPORT wxColour;
+
+
+class WXDLLEXPORT wxGenericImageList: public wxObject
+{
+public:
+    wxGenericImageList() { m_width = m_height = 0; }
+    wxGenericImageList( int width, int height, bool mask = true, int initialCount = 1 );
+    virtual ~wxGenericImageList();
+    bool Create( int width, int height, bool mask = true, int initialCount = 1 );
+    bool Create();
+
+    virtual int GetImageCount() const;
+    virtual bool GetSize( int index, int &width, int &height ) const;
+
+    int Add( const wxBitmap& bitmap );
+    int Add( const wxBitmap& bitmap, const wxBitmap& mask );
+    int Add( const wxBitmap& bitmap, const wxColour& maskColour );
+    wxBitmap GetBitmap(int index) const;
+    wxIcon GetIcon(int index) const;
+    bool Replace( int index, const wxBitmap &bitmap );
+    bool Replace( int index, const wxBitmap &bitmap, const wxBitmap& mask );
+    bool Remove( int index );
+    bool RemoveAll();
+
+    virtual bool Draw(int index, wxDC& dc, int x, int y,
+              int flags = wxIMAGELIST_DRAW_NORMAL,
+              bool solidBackground = false);
+
+    // Internal use only
+    const wxBitmap *GetBitmapPtr(int index) const;
+private:
+    wxList  m_images;
+
+    int     m_width;
+    int     m_height;
+
+    DECLARE_DYNAMIC_CLASS(wxGenericImageList)
+};
+
+#ifndef wxHAS_NATIVE_IMAGELIST
+
+/*
+ * wxImageList has to be a real class or we have problems with
+ * the run-time information.
+ */
+
+class WXDLLEXPORT wxImageList: public wxGenericImageList
+{
+    DECLARE_DYNAMIC_CLASS(wxImageList)
+
+public:
+    wxImageList() {}
+
+    wxImageList( int width, int height, bool mask = true, int initialCount = 1 )
+        : wxGenericImageList(width, height, mask, initialCount)
+    {
+    }
+};
+#endif // !wxHAS_NATIVE_IMAGELIST
+
+#endif  // __IMAGELISTH_G__
+

wxWidgets/include/wx/generic/laywin.h

@@ -0,0 +1,222 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        laywin.h
+// Purpose:     Implements a simple layout algorithm, plus
+//              wxSashLayoutWindow which is an example of a window with
+//              layout-awareness (via event handlers). This is suited to
+//              IDE-style window layout.
+// Author:      Julian Smart
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id: laywin.h 49563 2007-10-31 20:46:21Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_LAYWIN_H_G_
+#define _WX_LAYWIN_H_G_
+
+#if wxUSE_SASH
+    #include "wx/sashwin.h"
+#endif // wxUSE_SASH
+
+#include "wx/event.h"
+
+BEGIN_DECLARE_EVENT_TYPES()
+    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_QUERY_LAYOUT_INFO, 1500)
+    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_CALCULATE_LAYOUT, 1501)
+END_DECLARE_EVENT_TYPES()
+
+enum wxLayoutOrientation
+{
+    wxLAYOUT_HORIZONTAL,
+    wxLAYOUT_VERTICAL
+};
+
+enum wxLayoutAlignment
+{
+    wxLAYOUT_NONE,
+    wxLAYOUT_TOP,
+    wxLAYOUT_LEFT,
+    wxLAYOUT_RIGHT,
+    wxLAYOUT_BOTTOM
+};
+
+// Not sure this is necessary
+// Tell window which dimension we're sizing on
+#define wxLAYOUT_LENGTH_Y       0x0008
+#define wxLAYOUT_LENGTH_X       0x0000
+
+// Use most recently used length
+#define wxLAYOUT_MRU_LENGTH     0x0010
+
+// Only a query, so don't actually move it.
+#define wxLAYOUT_QUERY          0x0100
+
+/*
+ * This event is used to get information about window alignment,
+ * orientation and size.
+ */
+
+class WXDLLIMPEXP_ADV wxQueryLayoutInfoEvent: public wxEvent
+{
+public:
+    wxQueryLayoutInfoEvent(wxWindowID id = 0)
+    {
+        SetEventType(wxEVT_QUERY_LAYOUT_INFO);
+        m_requestedLength = 0;
+        m_flags = 0;
+        m_id = id;
+        m_alignment = wxLAYOUT_TOP;
+        m_orientation = wxLAYOUT_HORIZONTAL;
+    }
+
+    // Read by the app
+    void SetRequestedLength(int length) { m_requestedLength = length; }
+    int GetRequestedLength() const { return m_requestedLength; }
+
+    void SetFlags(int flags) { m_flags = flags; }
+    int GetFlags() const { return m_flags; }
+
+    // Set by the app
+    void SetSize(const wxSize& size) { m_size = size; }
+    wxSize GetSize() const { return m_size; }
+
+    void SetOrientation(wxLayoutOrientation orient) { m_orientation = orient; }
+    wxLayoutOrientation GetOrientation() const { return m_orientation; }
+
+    void SetAlignment(wxLayoutAlignment align) { m_alignment = align; }
+    wxLayoutAlignment GetAlignment() const { return m_alignment; }
+
+    virtual wxEvent *Clone() const { return new wxQueryLayoutInfoEvent(*this); }
+
+protected:
+    int                     m_flags;
+    int                     m_requestedLength;
+    wxSize                  m_size;
+    wxLayoutOrientation     m_orientation;
+    wxLayoutAlignment       m_alignment;
+
+private:
+    DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxQueryLayoutInfoEvent)
+};
+
+typedef void (wxEvtHandler::*wxQueryLayoutInfoEventFunction)(wxQueryLayoutInfoEvent&);
+
+#define EVT_QUERY_LAYOUT_INFO(func) \
+    DECLARE_EVENT_TABLE_ENTRY( wxEVT_QUERY_LAYOUT_INFO, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxQueryLayoutInfoEventFunction, & func ), NULL ),
+
+/*
+ * This event is used to take a bite out of the available client area.
+ */
+
+class WXDLLIMPEXP_ADV wxCalculateLayoutEvent: public wxEvent
+{
+public:
+    wxCalculateLayoutEvent(wxWindowID id = 0)
+    {
+        SetEventType(wxEVT_CALCULATE_LAYOUT);
+        m_flags = 0;
+        m_id = id;
+    }
+
+    // Read by the app
+    void SetFlags(int flags) { m_flags = flags; }
+    int GetFlags() const { return m_flags; }
+
+    // Set by the app
+    void SetRect(const wxRect& rect) { m_rect = rect; }
+    wxRect GetRect() const { return m_rect; }
+
+    virtual wxEvent *Clone() const { return new wxCalculateLayoutEvent(*this); }
+
+protected:
+    int                     m_flags;
+    wxRect                  m_rect;
+
+private:
+    DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxCalculateLayoutEvent)
+};
+
+typedef void (wxEvtHandler::*wxCalculateLayoutEventFunction)(wxCalculateLayoutEvent&);
+
+#define EVT_CALCULATE_LAYOUT(func) \
+    DECLARE_EVENT_TABLE_ENTRY( wxEVT_CALCULATE_LAYOUT, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxCalculateLayoutEventFunction, & func ), NULL ),
+
+#if wxUSE_SASH
+
+// This is window that can remember alignment/orientation, does its own layout,
+// and can provide sashes too. Useful for implementing docked windows with sashes in
+// an IDE-style interface.
+class WXDLLIMPEXP_ADV wxSashLayoutWindow: public wxSashWindow
+{
+public:
+    wxSashLayoutWindow()
+    {
+        Init();
+    }
+
+    wxSashLayoutWindow(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize, long style = wxSW_3D|wxCLIP_CHILDREN, const wxString& name = wxT("layoutWindow"))
+    {
+        Create(parent, id, pos, size, style, name);
+    }
+
+    bool Create(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize, long style = wxSW_3D|wxCLIP_CHILDREN, const wxString& name = wxT("layoutWindow"));
+
+// Accessors
+    inline wxLayoutAlignment GetAlignment() const { return m_alignment; }
+    inline wxLayoutOrientation GetOrientation() const { return m_orientation; }
+
+    inline void SetAlignment(wxLayoutAlignment align) { m_alignment = align; }
+    inline void SetOrientation(wxLayoutOrientation orient) { m_orientation = orient; }
+
+    // Give the window default dimensions
+    inline void SetDefaultSize(const wxSize& size) { m_defaultSize = size; }
+
+// Event handlers
+    // Called by layout algorithm to allow window to take a bit out of the
+    // client rectangle, and size itself if not in wxLAYOUT_QUERY mode.
+    void OnCalculateLayout(wxCalculateLayoutEvent& event);
+
+    // Called by layout algorithm to retrieve information about the window.
+    void OnQueryLayoutInfo(wxQueryLayoutInfoEvent& event);
+
+private:
+    void Init();
+
+    wxLayoutAlignment           m_alignment;
+    wxLayoutOrientation         m_orientation;
+    wxSize                      m_defaultSize;
+
+private:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxSashLayoutWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+#endif // wxUSE_SASH
+
+class WXDLLIMPEXP_FWD_CORE wxMDIParentFrame;
+class WXDLLIMPEXP_FWD_CORE wxFrame;
+
+// This class implements the layout algorithm
+class WXDLLIMPEXP_ADV wxLayoutAlgorithm: public wxObject
+{
+public:
+    wxLayoutAlgorithm() {}
+
+#if wxUSE_MDI_ARCHITECTURE
+    // The MDI client window is sized to whatever's left over.
+    bool LayoutMDIFrame(wxMDIParentFrame* frame, wxRect* rect = (wxRect*) NULL);
+#endif // wxUSE_MDI_ARCHITECTURE
+
+    // mainWindow is sized to whatever's left over. This function for backward
+    // compatibility; use LayoutWindow.
+    bool LayoutFrame(wxFrame* frame, wxWindow* mainWindow = (wxWindow*) NULL);
+
+    // mainWindow is sized to whatever's left over.
+    bool LayoutWindow(wxWindow* frame, wxWindow* mainWindow = (wxWindow*) NULL);
+};
+
+#endif
+    // _WX_LAYWIN_H_G_

wxWidgets/include/wx/generic/listctrl.h

@@ -0,0 +1,280 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/listctrl.h
+// Purpose:     Generic list control
+// Author:      Robert Roebling
+// Created:     01/02/97
+// RCS-ID:      $Id: listctrl.h 62158 2009-09-26 17:47:23Z JS $
+// Copyright:   (c) 1998 Robert Roebling and Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_LISTCTRL_H_
+#define _WX_GENERIC_LISTCTRL_H_
+
+#include "wx/textctrl.h"
+
+class WXDLLIMPEXP_CORE wxImageList;
+
+#if wxUSE_DRAG_AND_DROP
+class WXDLLEXPORT wxDropTarget;
+#endif
+
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+
+//-----------------------------------------------------------------------------
+// internal classes
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxListHeaderWindow;
+class WXDLLEXPORT wxListMainWindow;
+
+//-----------------------------------------------------------------------------
+// wxListCtrl
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericListCtrl: public wxControl
+{
+public:
+
+    wxGenericListCtrl();
+    wxGenericListCtrl( wxWindow *parent,
+                wxWindowID winid = wxID_ANY,
+                const wxPoint &pos = wxDefaultPosition,
+                const wxSize &size = wxDefaultSize,
+                long style = wxLC_ICON,
+                const wxValidator& validator = wxDefaultValidator,
+                const wxString &name = wxListCtrlNameStr)
+    {
+        Create(parent, winid, pos, size, style, validator, name);
+    }
+    virtual ~wxGenericListCtrl();
+
+    bool Create( wxWindow *parent,
+                 wxWindowID winid = wxID_ANY,
+                 const wxPoint &pos = wxDefaultPosition,
+                 const wxSize &size = wxDefaultSize,
+                 long style = wxLC_ICON,
+                 const wxValidator& validator = wxDefaultValidator,
+                 const wxString &name = wxListCtrlNameStr);
+
+    bool GetColumn( int col, wxListItem& item ) const;
+    bool SetColumn( int col, wxListItem& item );
+    int GetColumnWidth( int col ) const;
+    bool SetColumnWidth( int col, int width);
+    int GetCountPerPage() const; // not the same in wxGLC as in Windows, I think
+    wxRect GetViewRect() const;
+
+    bool GetItem( wxListItem& info ) const;
+    bool SetItem( wxListItem& info ) ;
+    long SetItem( long index, int col, const wxString& label, int imageId = -1 );
+    int  GetItemState( long item, long stateMask ) const;
+    bool SetItemState( long item, long state, long stateMask);
+    bool SetItemImage( long item, int image, int selImage = -1 );
+    bool SetItemColumnImage( long item, long column, int image );
+    wxString GetItemText( long item ) const;
+    void SetItemText( long item, const wxString& str );
+    wxUIntPtr GetItemData( long item ) const;
+#if wxABI_VERSION >= 20804
+    bool SetItemPtrData(long item, wxUIntPtr data);
+#endif // wxABI 2.8.4+
+    bool SetItemData(long item, long data);
+    bool GetItemRect( long item, wxRect& rect, int code = wxLIST_RECT_BOUNDS ) const;
+    bool GetItemPosition( long item, wxPoint& pos ) const;
+    bool SetItemPosition( long item, const wxPoint& pos ); // not supported in wxGLC
+    int GetItemCount() const;
+    int GetColumnCount() const;
+    void SetItemSpacing( int spacing, bool isSmall = false );
+    wxSize GetItemSpacing() const;
+    void SetItemTextColour( long item, const wxColour& col);
+    wxColour GetItemTextColour( long item ) const;
+    void SetItemBackgroundColour( long item, const wxColour &col);
+    wxColour GetItemBackgroundColour( long item ) const;
+    void SetItemFont( long item, const wxFont &f);
+    wxFont GetItemFont( long item ) const;
+    int GetSelectedItemCount() const;
+    wxColour GetTextColour() const;
+    void SetTextColour(const wxColour& col);
+    long GetTopItem() const;
+
+    void SetSingleStyle( long style, bool add = true ) ;
+    void SetWindowStyleFlag( long style );
+    void RecreateWindow() {}
+    long GetNextItem( long item, int geometry = wxLIST_NEXT_ALL, int state = wxLIST_STATE_DONTCARE ) const;
+    wxImageList *GetImageList( int which ) const;
+    void SetImageList( wxImageList *imageList, int which );
+    void AssignImageList( wxImageList *imageList, int which );
+    bool Arrange( int flag = wxLIST_ALIGN_DEFAULT ); // always wxLIST_ALIGN_LEFT in wxGLC
+
+    void ClearAll();
+    bool DeleteItem( long item );
+    bool DeleteAllItems();
+    bool DeleteAllColumns();
+    bool DeleteColumn( int col );
+
+    void SetItemCount(long count);
+
+    wxTextCtrl *EditLabel(long item,
+                          wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl));
+    wxTextCtrl* GetEditControl() const;
+    void Edit( long item ) { EditLabel(item); }
+
+    bool EnsureVisible( long item );
+    long FindItem( long start, const wxString& str, bool partial = false );
+    long FindItem( long start, wxUIntPtr data );
+    long FindItem( long start, const wxPoint& pt, int direction ); // not supported in wxGLC
+    long HitTest( const wxPoint& point, int& flags, long *pSubItem = NULL ) const;
+    long InsertItem(wxListItem& info);
+    long InsertItem( long index, const wxString& label );
+    long InsertItem( long index, int imageIndex );
+    long InsertItem( long index, const wxString& label, int imageIndex );
+    long InsertColumn( long col, wxListItem& info );
+    long InsertColumn( long col, const wxString& heading,
+                       int format = wxLIST_FORMAT_LEFT, int width = -1 );
+    bool ScrollList( int dx, int dy );
+    bool SortItems( wxListCtrlCompare fn, long data );
+    bool Update( long item );
+    virtual void Update();
+
+    // are we in report mode?
+    bool InReportView() const { return HasFlag(wxLC_REPORT); }
+
+    // are we in virtual report mode?
+    bool IsVirtual() const { return HasFlag(wxLC_VIRTUAL); }
+
+    // do we have a header window?
+    bool HasHeader() const
+        { return InReportView() && !HasFlag(wxLC_NO_HEADER); }
+
+    // refresh items selectively (only useful for virtual list controls)
+    void RefreshItem(long item);
+    void RefreshItems(long itemFrom, long itemTo);
+
+#if WXWIN_COMPATIBILITY_2_6
+    // obsolete, don't use
+    wxDEPRECATED( int GetItemSpacing( bool isSmall ) const );
+#endif // WXWIN_COMPATIBILITY_2_6
+
+    virtual wxVisualAttributes GetDefaultAttributes() const
+    {
+        return GetClassDefaultAttributes(GetWindowVariant());
+    }
+
+    static wxVisualAttributes
+    GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
+
+    // implementation only from now on
+    // -------------------------------
+
+    void OnInternalIdle( );
+    void OnSize( wxSizeEvent &event );
+
+    // We have to hand down a few functions
+    virtual void Refresh(bool eraseBackground = true,
+                         const wxRect *rect = NULL);
+
+    virtual void Freeze();
+    virtual void Thaw();
+
+    virtual bool SetBackgroundColour( const wxColour &colour );
+    virtual bool SetForegroundColour( const wxColour &colour );
+    virtual wxColour GetBackgroundColour() const;
+    virtual wxColour GetForegroundColour() const;
+    virtual bool SetFont( const wxFont &font );
+    virtual bool SetCursor( const wxCursor &cursor );
+
+    virtual int GetScrollPos(int orient) const;
+    virtual void SetScrollPos(int orient, int pos, bool refresh = true); 
+
+#if wxUSE_DRAG_AND_DROP
+    virtual void SetDropTarget( wxDropTarget *dropTarget );
+    virtual wxDropTarget *GetDropTarget() const;
+#endif
+
+    virtual bool ShouldInheritColours() const { return false; }
+    virtual void SetFocus();
+
+    // implementation
+    // --------------
+
+    wxImageList         *m_imageListNormal;
+    wxImageList         *m_imageListSmall;
+    wxImageList         *m_imageListState;  // what's that ?
+    bool                 m_ownsImageListNormal,
+                         m_ownsImageListSmall,
+                         m_ownsImageListState;
+    wxListHeaderWindow  *m_headerWin;
+    wxListMainWindow    *m_mainWin;
+    wxCoord              m_headerHeight;
+
+protected:
+    virtual bool DoPopupMenu( wxMenu *menu, int x, int y );
+
+    // take into account the coordinates difference between the container
+    // window and the list control window itself here
+    virtual void DoClientToScreen( int *x, int *y ) const;
+    virtual void DoScreenToClient( int *x, int *y ) const;
+
+    virtual wxSize DoGetBestSize() const;
+
+    // return the text for the given column of the given item
+    virtual wxString OnGetItemText(long item, long column) const;
+
+    // return the icon for the given item. In report view, OnGetItemImage will
+    // only be called for the first column. See OnGetItemColumnImage for
+    // details.
+    virtual int OnGetItemImage(long item) const;
+
+    // return the icon for the given item and column.
+    virtual int OnGetItemColumnImage(long item, long column) const;
+
+    // return the attribute for the item (may return NULL if none)
+    virtual wxListItemAttr *OnGetItemAttr(long item) const;
+
+    // it calls our OnGetXXX() functions
+    friend class WXDLLEXPORT wxListMainWindow;
+
+private:
+    // create the header window
+    void CreateHeaderWindow();
+
+    // calculate and set height of the header
+    void CalculateAndSetHeaderHeight();
+
+    // reposition the header and the main window in the report view depending
+    // on whether it should be shown or not
+    void ResizeReportView(bool showHeader);
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS(wxGenericListCtrl)
+};
+
+#if (!defined(__WXMSW__) || defined(__WXUNIVERSAL__)) && (!defined(__WXMAC__) || defined(__WXUNIVERSAL__))
+/*
+ * wxListCtrl has to be a real class or we have problems with
+ * the run-time information.
+ */
+
+class WXDLLEXPORT wxListCtrl: public wxGenericListCtrl
+{
+    DECLARE_DYNAMIC_CLASS(wxListCtrl)
+
+public:
+    wxListCtrl() {}
+
+    wxListCtrl(wxWindow *parent, wxWindowID winid = wxID_ANY,
+               const wxPoint& pos = wxDefaultPosition,
+               const wxSize& size = wxDefaultSize,
+               long style = wxLC_ICON,
+               const wxValidator &validator = wxDefaultValidator,
+               const wxString &name = wxListCtrlNameStr)
+    : wxGenericListCtrl(parent, winid, pos, size, style, validator, name)
+    {
+    }
+    
+};
+#endif // !__WXMSW__ || __WXUNIVERSAL__
+
+#endif // _WX_GENERIC_LISTCTRL_H_

wxWidgets/include/wx/generic/logg.h

@@ -0,0 +1,129 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/logg.h
+// Purpose:     Assorted wxLogXXX functions, and wxLog (sink for logs)
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     29/01/98
+// RCS-ID:      $Id: logg.h 41020 2006-09-05 20:47:48Z VZ $
+// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef   _WX_LOGG_H_
+#define   _WX_LOGG_H_
+
+#if wxUSE_GUI
+
+// ----------------------------------------------------------------------------
+// the following log targets are only compiled in if the we're compiling the
+// GUI part (andnot just the base one) of the library, they're implemented in
+// src/generic/logg.cpp *and not src/common/log.cpp unlike all the rest)
+// ----------------------------------------------------------------------------
+
+#if wxUSE_TEXTCTRL
+
+// log everything to a text window (GUI only of course)
+class WXDLLEXPORT wxLogTextCtrl : public wxLog
+{
+public:
+    wxLogTextCtrl(wxTextCtrl *pTextCtrl);
+
+protected:
+    // implement sink function
+    virtual void DoLogString(const wxChar *szString, time_t t);
+
+private:
+    // the control we use
+    wxTextCtrl *m_pTextCtrl;
+
+    DECLARE_NO_COPY_CLASS(wxLogTextCtrl)
+};
+
+#endif // wxUSE_TEXTCTRL
+
+// ----------------------------------------------------------------------------
+// GUI log target, the default one for wxWidgets programs
+// ----------------------------------------------------------------------------
+
+#if wxUSE_LOGGUI
+
+class WXDLLEXPORT wxLogGui : public wxLog
+{
+public:
+    // ctor
+    wxLogGui();
+
+    // show all messages that were logged since the last Flush()
+    virtual void Flush();
+
+protected:
+    virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t);
+
+    // empty everything
+    void Clear();
+
+    wxArrayString m_aMessages;      // the log message texts
+    wxArrayInt    m_aSeverity;      // one of wxLOG_XXX values
+    wxArrayLong   m_aTimes;         // the time of each message
+    bool          m_bErrors,        // do we have any errors?
+                  m_bWarnings,      // any warnings?
+                  m_bHasMessages;   // any messages at all?
+
+};
+
+#endif // wxUSE_LOGGUI
+
+// ----------------------------------------------------------------------------
+// (background) log window: this class forwards all log messages to the log
+// target which was active when it was instantiated, but also collects them
+// to the log window. This window has it's own menu which allows the user to
+// close it, clear the log contents or save it to the file.
+// ----------------------------------------------------------------------------
+
+#if wxUSE_LOGWINDOW
+
+class WXDLLEXPORT wxLogWindow : public wxLogPassThrough
+{
+public:
+    wxLogWindow(wxWindow *pParent,         // the parent frame (can be NULL)
+                const wxChar *szTitle,    // the title of the frame
+                bool bShow = true,        // show window immediately?
+                bool bPassToOld = true);  // pass messages to the old target?
+
+    virtual ~wxLogWindow();
+
+    // window operations
+        // show/hide the log window
+    void Show(bool bShow = true);
+        // retrieve the pointer to the frame
+    wxFrame *GetFrame() const;
+
+    // overridables
+        // called immediately after the log frame creation allowing for
+        // any extra initializations
+    virtual void OnFrameCreate(wxFrame *frame);
+        // called if the user closes the window interactively, will not be
+        // called if it is destroyed for another reason (such as when program
+        // exits) - return true from here to allow the frame to close, false
+        // to prevent this from happening
+    virtual bool OnFrameClose(wxFrame *frame);
+        // called right before the log frame is going to be deleted: will
+        // always be called unlike OnFrameClose()
+    virtual void OnFrameDelete(wxFrame *frame);
+
+protected:
+    virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t);
+    virtual void DoLogString(const wxChar *szString, time_t t);
+
+private:
+    wxLogFrame *m_pLogFrame;      // the log frame
+
+    DECLARE_NO_COPY_CLASS(wxLogWindow)
+};
+
+#endif // wxUSE_LOGWINDOW
+
+#endif // wxUSE_GUI
+
+#endif  // _WX_LOGG_H_
+

wxWidgets/include/wx/generic/mask.h

@@ -0,0 +1,54 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/mask.h
+// Purpose:     generic implementation of wxMask
+// Author:      Vadim Zeitlin
+// Created:     2006-09-28
+// RCS-ID:      $Id: mask.h 41495 2006-09-28 23:02:39Z VZ $
+// Copyright:   (c) 2006 Vadim Zeitlin <vadim@wxwindows.org>
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_MASKG_H_
+#define _WX_GENERIC_MASKG_H_
+
+// ----------------------------------------------------------------------------
+// generic wxMask implementation
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxMask : public wxMaskBase
+{
+public:
+    wxMask() { }
+    wxMask(const wxBitmap& bitmap, const wxColour& colour)
+    {
+        InitFromColour(bitmap, colour);
+    }
+
+#if wxUSE_PALETTE
+    wxMask(const wxBitmap& bitmap, int paletteIndex)
+    {
+        Create(bitmap, paletteIndex);
+    }
+#endif // wxUSE_PALETTE
+
+    wxMask(const wxBitmap& bitmap)
+    {
+        InitFromMonoBitmap(bitmap);
+    }
+
+    // implementation-only from now on
+    wxBitmap GetBitmap() const { return m_bitmap; }
+
+private:
+    // implement wxMaskBase pure virtuals
+    virtual void FreeData();
+    virtual bool InitFromColour(const wxBitmap& bitmap, const wxColour& colour);
+    virtual bool InitFromMonoBitmap(const wxBitmap& bitmap);
+
+    wxBitmap m_bitmap;
+
+    DECLARE_DYNAMIC_CLASS(wxMask)
+};
+
+#endif // _WX_GENERIC_MASKG_H_
+

wxWidgets/include/wx/generic/mdig.h

@@ -0,0 +1,335 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/mdig.h
+// Purpose:     Generic MDI (Multiple Document Interface) classes
+// Author:      Hans Van Leemputten
+// Modified by:
+// Created:     29/07/2002
+// RCS-ID:      $Id: mdig.h 41223 2006-09-14 17:36:18Z PC $
+// Copyright:   (c) Hans Van Leemputten
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_MDIG_H_
+#define _WX_MDIG_H_
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/frame.h"
+#include "wx/panel.h"
+#include "wx/notebook.h"
+
+extern WXDLLEXPORT_DATA(const wxChar) wxStatusLineNameStr[];
+
+
+//-----------------------------------------------------------------------------
+// classes
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericMDIParentFrame;
+class WXDLLEXPORT wxGenericMDIClientWindow;
+class WXDLLEXPORT wxGenericMDIChildFrame;
+
+//-----------------------------------------------------------------------------
+// wxGenericMDIParentFrame
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericMDIParentFrame: public wxFrame
+{
+public:
+    wxGenericMDIParentFrame();
+    wxGenericMDIParentFrame(wxWindow *parent,
+                     wxWindowID winid,
+                     const wxString& title,
+                     const wxPoint& pos = wxDefaultPosition,
+                     const wxSize& size = wxDefaultSize,
+                     long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
+                     const wxString& name = wxFrameNameStr);
+
+    virtual ~wxGenericMDIParentFrame();
+    bool Create( wxWindow *parent,
+                 wxWindowID winid,
+                 const wxString& title,
+                 const wxPoint& pos = wxDefaultPosition,
+                 const wxSize& size = wxDefaultSize,
+                 long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
+                 const wxString& name = wxFrameNameStr );
+
+#if wxUSE_MENUS
+    wxMenu* GetWindowMenu() const { return m_pWindowMenu; };
+    void SetWindowMenu(wxMenu* pMenu);
+
+    virtual void SetMenuBar(wxMenuBar *pMenuBar);
+#endif // wxUSE_MENUS
+
+    void SetChildMenuBar(wxGenericMDIChildFrame *pChild);
+
+    virtual bool ProcessEvent(wxEvent& event);
+
+    wxGenericMDIChildFrame *GetActiveChild() const;
+    inline void SetActiveChild(wxGenericMDIChildFrame* pChildFrame);
+
+    wxGenericMDIClientWindow *GetClientWindow() const;
+    virtual wxGenericMDIClientWindow *OnCreateClient();
+
+    virtual void Cascade() { /* Has no effect */ }
+    virtual void Tile(wxOrientation WXUNUSED(orient) = wxHORIZONTAL) { }
+    virtual void ArrangeIcons() { /* Has no effect */ }
+    virtual void ActivateNext();
+    virtual void ActivatePrevious();
+
+protected:
+    wxGenericMDIClientWindow   *m_pClientWindow;
+    wxGenericMDIChildFrame     *m_pActiveChild;
+#if wxUSE_MENUS
+    wxMenu              *m_pWindowMenu;
+    wxMenuBar           *m_pMyMenuBar;
+#endif // wxUSE_MENUS
+
+protected:
+    void Init();
+
+#if wxUSE_MENUS
+    void RemoveWindowMenu(wxMenuBar *pMenuBar);
+    void AddWindowMenu(wxMenuBar *pMenuBar);
+
+    void DoHandleMenu(wxCommandEvent &event);
+#endif // wxUSE_MENUS
+
+    virtual void DoGetClientSize(int *width, int *height) const;
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS(wxGenericMDIParentFrame)
+};
+
+//-----------------------------------------------------------------------------
+// wxGenericMDIChildFrame
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericMDIChildFrame: public wxPanel
+{
+public:
+    wxGenericMDIChildFrame();
+    wxGenericMDIChildFrame( wxGenericMDIParentFrame *parent,
+                     wxWindowID winid,
+                     const wxString& title,
+                     const wxPoint& pos = wxDefaultPosition,
+                     const wxSize& size = wxDefaultSize,
+                     long style = wxDEFAULT_FRAME_STYLE,
+                     const wxString& name = wxFrameNameStr );
+
+    virtual ~wxGenericMDIChildFrame();
+    bool Create( wxGenericMDIParentFrame *parent,
+                 wxWindowID winid,
+                 const wxString& title,
+                 const wxPoint& pos = wxDefaultPosition,
+                 const wxSize& size = wxDefaultSize,
+                 long style = wxDEFAULT_FRAME_STYLE,
+                 const wxString& name = wxFrameNameStr );
+
+#if wxUSE_MENUS
+    virtual void SetMenuBar( wxMenuBar *menu_bar );
+    virtual wxMenuBar *GetMenuBar() const;
+#endif // wxUSE_MENUS
+
+    virtual void SetTitle(const wxString& title);
+    virtual wxString GetTitle() const;
+
+    virtual void Activate();
+
+#if wxUSE_STATUSBAR
+    // no status bars
+    virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number) = 1,
+                                        long WXUNUSED(style) = 1,
+                                        wxWindowID WXUNUSED(winid) = 1,
+                                        const wxString& WXUNUSED(name) = wxEmptyString)
+      { return (wxStatusBar*)NULL; }
+
+    virtual wxStatusBar *GetStatusBar() const { return (wxStatusBar*)NULL; }
+    virtual void SetStatusText( const wxString &WXUNUSED(text), int WXUNUSED(number)=0 ) {}
+    virtual void SetStatusWidths( int WXUNUSED(n), const int WXUNUSED(widths_field)[] ) {}
+#endif
+
+    // no size hints
+    virtual void DoSetSizeHints( int WXUNUSED(minW),
+                               int WXUNUSED(minH),
+                               int WXUNUSED(maxW) = wxDefaultCoord,
+                               int WXUNUSED(maxH) = wxDefaultCoord,
+                               int WXUNUSED(incW) = wxDefaultCoord,
+                               int WXUNUSED(incH) = wxDefaultCoord) {}
+
+#if wxUSE_TOOLBAR
+    // no toolbar bars
+    virtual wxToolBar* CreateToolBar( long WXUNUSED(style),
+                                       wxWindowID WXUNUSED(winid),
+                                       const wxString& WXUNUSED(name) )
+        { return (wxToolBar*)NULL; }
+    virtual wxToolBar *GetToolBar() const { return (wxToolBar*)NULL; }
+#endif
+
+    // no icon
+    void SetIcon( const wxIcon& WXUNUSED(icon) ) { }
+    void SetIcons( const wxIconBundle& WXUNUSED(icons) ) { }
+
+    // no maximize etc
+    virtual void Maximize( bool WXUNUSED(maximize) = true) { /* Has no effect */ }
+    virtual void Restore() { /* Has no effect */ }
+    virtual void Iconize(bool WXUNUSED(iconize)  = true) { /* Has no effect */ }
+    virtual bool IsMaximized() const { return true; }
+    virtual bool IsIconized() const { return false; }
+    virtual bool ShowFullScreen(bool WXUNUSED(show), long WXUNUSED(style)) { return false; }
+    virtual bool IsFullScreen() const { return false; }
+
+    virtual bool IsTopLevel() const { return false; }
+
+    void OnMenuHighlight(wxMenuEvent& event);
+    void OnActivate(wxActivateEvent& event);
+
+    // The next 2 are copied from top level...
+    void OnCloseWindow(wxCloseEvent& event);
+    void OnSize(wxSizeEvent& event);
+
+    void SetMDIParentFrame(wxGenericMDIParentFrame* parentFrame);
+    wxGenericMDIParentFrame* GetMDIParentFrame() const;
+
+protected:
+    wxGenericMDIParentFrame *m_pMDIParentFrame;
+    wxRect            m_MDIRect;
+    wxString          m_Title;
+
+#if wxUSE_MENUS
+    wxMenuBar        *m_pMenuBar;
+#endif // wxUSE_MENUS
+
+protected:
+    void Init();
+
+    virtual void DoMoveWindow(int x, int y, int width, int height);
+
+    // This function needs to be called when a size change is confirmed,
+    // we needed this function to prevent any body from the outside
+    // changing the panel... it messes the UI layout when we would allow it.
+    void ApplyMDIChildFrameRect();
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxGenericMDIChildFrame)
+    DECLARE_EVENT_TABLE()
+
+    friend class wxGenericMDIClientWindow;
+};
+
+//-----------------------------------------------------------------------------
+// wxGenericMDIClientWindow
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericMDIClientWindow: public wxNotebook
+{
+public:
+    wxGenericMDIClientWindow();
+    wxGenericMDIClientWindow( wxGenericMDIParentFrame *parent, long style = 0 );
+    virtual ~wxGenericMDIClientWindow();
+    virtual bool CreateClient( wxGenericMDIParentFrame *parent, long style = wxVSCROLL | wxHSCROLL );
+
+    virtual int SetSelection(size_t nPage);
+
+protected:
+    void PageChanged(int OldSelection, int newSelection);
+
+    void OnPageChanged(wxNotebookEvent& event);
+    void OnSize(wxSizeEvent& event);
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxGenericMDIClientWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+
+/*
+ * Define normal wxMDI classes based on wxGenericMDI
+ */
+
+#ifndef wxUSE_GENERIC_MDI_AS_NATIVE
+#if defined(__WXUNIVERSAL__) || defined(__WXPM__) || defined(__WXCOCOA__)
+#define wxUSE_GENERIC_MDI_AS_NATIVE   1
+#else
+#define wxUSE_GENERIC_MDI_AS_NATIVE   0
+#endif
+#endif // wxUSE_GENERIC_MDI_AS_NATIVE
+
+#if wxUSE_GENERIC_MDI_AS_NATIVE
+
+class wxMDIChildFrame ;
+
+//-----------------------------------------------------------------------------
+// wxMDIParentFrame
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxMDIParentFrame: public wxGenericMDIParentFrame
+{
+public:
+    wxMDIParentFrame() {}
+    wxMDIParentFrame(wxWindow *parent,
+                     wxWindowID winid,
+                     const wxString& title,
+                     const wxPoint& pos = wxDefaultPosition,
+                     const wxSize& size = wxDefaultSize,
+                     long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
+                     const wxString& name = wxFrameNameStr)
+         :wxGenericMDIParentFrame(parent, winid, title, pos, size, style, name)
+     {
+     }
+
+    wxMDIChildFrame * GetActiveChild() const ;
+
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxMDIParentFrame)
+};
+
+//-----------------------------------------------------------------------------
+// wxMDIChildFrame
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxMDIChildFrame: public wxGenericMDIChildFrame
+{
+public:
+    wxMDIChildFrame() {}
+
+    wxMDIChildFrame( wxGenericMDIParentFrame *parent,
+                     wxWindowID winid,
+                     const wxString& title,
+                     const wxPoint& pos = wxDefaultPosition,
+                     const wxSize& size = wxDefaultSize,
+                     long style = wxDEFAULT_FRAME_STYLE,
+                     const wxString& name = wxFrameNameStr )
+         :wxGenericMDIChildFrame(parent, winid, title, pos, size, style, name)
+     {
+     }
+private:
+    DECLARE_DYNAMIC_CLASS(wxMDIChildFrame)
+};
+
+//-----------------------------------------------------------------------------
+// wxMDIClientWindow
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxMDIClientWindow: public wxGenericMDIClientWindow
+{
+public:
+    wxMDIClientWindow() {}
+
+    wxMDIClientWindow( wxGenericMDIParentFrame *parent, long style = 0 )
+        :wxGenericMDIClientWindow(parent, style)
+    {
+    }
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxMDIClientWindow)
+};
+
+#endif
+
+#endif
+    // _WX_MDIG_H_

wxWidgets/include/wx/generic/msgdlgg.h

@@ -0,0 +1,44 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/msgdlgg.h
+// Purpose:     Generic wxMessageDialog
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: msgdlgg.h 49765 2007-11-09 18:32:38Z DE $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __MSGDLGH_G__
+#define __MSGDLGH_G__
+
+#include "wx/defs.h"
+#include "wx/dialog.h"
+
+// type is an 'or' (|) of wxOK, wxCANCEL, wxYES_NO
+// Returns wxYES/NO/OK/CANCEL
+
+extern WXDLLEXPORT_DATA(const wxChar) wxMessageBoxCaptionStr[];
+
+class WXDLLEXPORT wxGenericMessageDialog: public wxDialog, public wxMessageDialogBase
+{
+DECLARE_DYNAMIC_CLASS(wxGenericMessageDialog)
+
+public:
+    wxGenericMessageDialog(wxWindow *parent, const wxString& message,
+        const wxString& caption = wxMessageBoxCaptionStr,
+        long style = wxOK|wxCENTRE, const wxPoint& pos = wxDefaultPosition);
+
+    void OnYes(wxCommandEvent& event);
+    void OnNo(wxCommandEvent& event);
+    void OnCancel(wxCommandEvent& event);
+
+private:
+    DECLARE_EVENT_TABLE()
+};
+
+#if (!defined( __WXMSW__ ) && !defined( __WXMAC__) && !defined(__WXPM__) && !defined(__WXCOCOA__)) || defined(__WXUNIVERSAL__)
+#define wxMessageDialog wxGenericMessageDialog
+#endif
+
+#endif // __MSGDLGH_G__

wxWidgets/include/wx/generic/notebook.h

@@ -0,0 +1,160 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        notebook.h
+// Purpose:     wxNotebook class (a.k.a. property sheet, tabbed dialog)
+// Author:      Julian Smart
+// Modified by:
+// RCS-ID:      $Id: notebook.h 41738 2006-10-08 17:37:23Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_NOTEBOOK_H_
+#define _WX_NOTEBOOK_H_
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+#include "wx/event.h"
+#include "wx/control.h"
+
+// ----------------------------------------------------------------------------
+// types
+// ----------------------------------------------------------------------------
+
+// fwd declarations
+class WXDLLEXPORT wxImageList;
+class WXDLLEXPORT wxWindow;
+class WXDLLEXPORT wxTabView;
+
+// ----------------------------------------------------------------------------
+// wxNotebook
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxNotebook : public wxNotebookBase
+{
+public:
+  // ctors
+  // -----
+    // default for dynamic class
+  wxNotebook();
+    // the same arguments as for wxControl (@@@ any special styles?)
+  wxNotebook(wxWindow *parent,
+             wxWindowID id,
+             const wxPoint& pos = wxDefaultPosition,
+             const wxSize& size = wxDefaultSize,
+             long style = 0,
+             const wxString& name = wxNotebookNameStr);
+    // Create() function
+  bool Create(wxWindow *parent,
+              wxWindowID id,
+              const wxPoint& pos = wxDefaultPosition,
+              const wxSize& size = wxDefaultSize,
+              long style = 0,
+              const wxString& name = wxNotebookNameStr);
+    // dtor
+  virtual ~wxNotebook();
+
+  // accessors
+  // ---------
+  // Find the position of the wxNotebookPage, -1 if not found.
+  int FindPagePosition(wxNotebookPage* page) const;
+
+    // set the currently selected page, return the index of the previously
+    // selected one (or -1 on error)
+    // NB: this function will _not_ generate wxEVT_NOTEBOOK_PAGE_xxx events
+  int SetSelection(size_t nPage);
+    // cycle thru the tabs
+  //  void AdvanceSelection(bool bForward = true);
+    // get the currently selected page
+  int GetSelection() const { return m_nSelection; }
+
+    // changes selected page without sending events
+  int ChangeSelection(size_t nPage);
+
+    // set/get the title of a page
+  bool SetPageText(size_t nPage, const wxString& strText);
+  wxString GetPageText(size_t nPage) const;
+
+  // get the number of rows for a control with wxNB_MULTILINE style (not all
+  // versions support it - they will always return 1 then)
+  virtual int GetRowCount() const ;
+
+    // sets/returns item's image index in the current image list
+  int  GetPageImage(size_t nPage) const;
+  bool SetPageImage(size_t nPage, int nImage);
+
+  // control the appearance of the notebook pages
+    // set the size (the same for all pages)
+  void SetPageSize(const wxSize& size);
+    // set the padding between tabs (in pixels)
+  void SetPadding(const wxSize& padding);
+
+    // Sets the size of the tabs (assumes all tabs are the same size)
+  void SetTabSize(const wxSize& sz);
+
+  // operations
+  // ----------
+    // remove one page from the notebook, and delete the page.
+  bool DeletePage(size_t nPage);
+  bool DeletePage(wxNotebookPage* page);
+    // remove one page from the notebook, without deleting the page.
+  bool RemovePage(size_t nPage);
+  bool RemovePage(wxNotebookPage* page);
+  virtual wxWindow* DoRemovePage(size_t nPage);
+
+    // remove all pages
+  bool DeleteAllPages();
+    // the same as AddPage(), but adds it at the specified position
+  bool InsertPage(size_t nPage,
+                  wxNotebookPage *pPage,
+                  const wxString& strText,
+                  bool bSelect = false,
+                  int imageId = -1);
+
+  // callbacks
+  // ---------
+  void OnSize(wxSizeEvent& event);
+  void OnInternalIdle();
+  void OnSelChange(wxNotebookEvent& event);
+  void OnSetFocus(wxFocusEvent& event);
+  void OnNavigationKey(wxNavigationKeyEvent& event);
+
+  // base class virtuals
+  // -------------------
+  virtual void Command(wxCommandEvent& event);
+  virtual void SetConstraintSizes(bool recurse = true);
+  virtual bool DoPhase(int nPhase);
+
+  virtual wxSize CalcSizeFromPage(const wxSize& sizePage) const;
+
+  // Implementation
+
+  // wxNotebook on Motif uses a generic wxTabView to implement itself.
+  wxTabView *GetTabView() const { return m_tabView; }
+  void SetTabView(wxTabView *v) { m_tabView = v; }
+
+  void OnMouseEvent(wxMouseEvent& event);
+  void OnPaint(wxPaintEvent& event);
+
+  virtual wxRect GetAvailableClientSize();
+
+  // Implementation: calculate the layout of the view rect
+  // and resize the children if required
+  bool RefreshLayout(bool force = true);
+
+protected:
+  // common part of all ctors
+  void Init();
+
+  // helper functions
+  void ChangePage(int nOldSel, int nSel); // change pages
+
+  int m_nSelection;           // the current selection (-1 if none)
+
+  wxTabView*   m_tabView;
+
+  DECLARE_DYNAMIC_CLASS(wxNotebook)
+  DECLARE_EVENT_TABLE()
+};
+
+#endif // _WX_NOTEBOOK_H_

wxWidgets/include/wx/generic/numdlgg.h

@@ -0,0 +1,79 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/numdlgg.h
+// Purpose:     wxNumberEntryDialog class
+// Author:      John Labenski
+// Modified by:
+// Created:     07.02.04 (extracted from textdlgg.cpp)
+// RCS-ID:      $Id: numdlgg.h 49563 2007-10-31 20:46:21Z VZ $
+// Copyright:   (c) wxWidgets team
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __NUMDLGH_G__
+#define __NUMDLGH_G__
+
+#include "wx/defs.h"
+
+#if wxUSE_NUMBERDLG
+
+#include "wx/dialog.h"
+
+#if wxUSE_SPINCTRL
+    class WXDLLIMPEXP_FWD_CORE wxSpinCtrl;
+#else
+    class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
+#endif // wxUSE_SPINCTRL
+
+// ----------------------------------------------------------------------------
+// wxNumberEntryDialog: a dialog with spin control, [ok] and [cancel] buttons
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxNumberEntryDialog : public wxDialog
+{
+public:
+    wxNumberEntryDialog(wxWindow *parent,
+                        const wxString& message,
+                        const wxString& prompt,
+                        const wxString& caption,
+                        long value, long min, long max,
+                        const wxPoint& pos = wxDefaultPosition);
+
+    long GetValue() const { return m_value; }
+
+    // implementation only
+    void OnOK(wxCommandEvent& event);
+    void OnCancel(wxCommandEvent& event);
+
+protected:
+
+#if wxUSE_SPINCTRL
+    wxSpinCtrl *m_spinctrl;
+#else
+    wxTextCtrl *m_spinctrl;
+#endif // wxUSE_SPINCTRL
+
+    long m_value, m_min, m_max;
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS(wxNumberEntryDialog)
+    DECLARE_NO_COPY_CLASS(wxNumberEntryDialog)
+};
+
+// ----------------------------------------------------------------------------
+// function to get a number from user
+// ----------------------------------------------------------------------------
+
+long WXDLLEXPORT
+wxGetNumberFromUser(const wxString& message,
+                    const wxString& prompt,
+                    const wxString& caption,
+                    long value = 0,
+                    long min = 0,
+                    long max = 100,
+                    wxWindow *parent = (wxWindow *)NULL,
+                    const wxPoint& pos = wxDefaultPosition);
+
+#endif // wxUSE_NUMBERDLG
+
+#endif // __NUMDLGH_G__

wxWidgets/include/wx/generic/paletteg.h

@@ -0,0 +1,49 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/paletteg.h
+// Purpose:
+// Author:      Robert Roebling
+// Created:     01/02/97
+// RCS-ID:      $Id: paletteg.h 42752 2006-10-30 19:26:48Z VZ $
+// Copyright:   (c) 1998 Robert Roebling and Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef __WX_PALETTEG_H__
+#define __WX_PALETTEG_H__
+
+#include "wx/defs.h"
+#include "wx/object.h"
+#include "wx/gdiobj.h"
+#include "wx/gdicmn.h"
+
+//-----------------------------------------------------------------------------
+// classes
+//-----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxPalette;
+
+//-----------------------------------------------------------------------------
+// wxPalette
+//-----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxPalette: public wxPaletteBase
+{
+public:
+    wxPalette();
+    wxPalette( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue );
+    virtual ~wxPalette();
+    virtual bool Ok() const { return IsOk(); }
+    virtual bool IsOk() const;
+
+    bool Create( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
+    int GetPixel( unsigned char red, unsigned char green, unsigned char blue ) const;
+    bool GetRGB( int pixel, unsigned char *red, unsigned char *green, unsigned char *blue ) const;
+
+    virtual int GetColoursCount() const;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxPalette)
+};
+
+#endif // __WX_PALETTEG_H__

wxWidgets/include/wx/generic/panelg.h

@@ -0,0 +1,95 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/panelg.h
+// Purpose:     wxPanel: a container for child controls
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: panelg.h 49563 2007-10-31 20:46:21Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_PANEL_H_
+#define _WX_GENERIC_PANEL_H_
+
+// ----------------------------------------------------------------------------
+// headers and forward declarations
+// ----------------------------------------------------------------------------
+
+#include "wx/window.h"
+#include "wx/containr.h"
+
+class WXDLLIMPEXP_FWD_CORE wxControlContainer;
+
+extern WXDLLEXPORT_DATA(const wxChar) wxPanelNameStr[];
+
+// ----------------------------------------------------------------------------
+// wxPanel contains other controls and implements TAB traversal between them
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxPanel : public wxWindow
+{
+public:
+    wxPanel() { Init(); }
+
+    // Old-style constructor (no default values for coordinates to avoid
+    // ambiguity with the new one)
+    wxPanel(wxWindow *parent,
+            int x, int y, int width, int height,
+            long style = wxTAB_TRAVERSAL | wxNO_BORDER,
+            const wxString& name = wxPanelNameStr)
+    {
+        Init();
+
+        Create(parent, wxID_ANY, wxPoint(x, y), wxSize(width, height), style, name);
+    }
+
+    // Constructor
+    wxPanel(wxWindow *parent,
+            wxWindowID winid = wxID_ANY,
+            const wxPoint& pos = wxDefaultPosition,
+            const wxSize& size = wxDefaultSize,
+            long style = wxTAB_TRAVERSAL | wxNO_BORDER,
+            const wxString& name = wxPanelNameStr)
+    {
+        Init();
+
+        Create(parent, winid, pos, size, style, name);
+    }
+
+    // Pseudo ctor
+    bool Create(wxWindow *parent,
+                wxWindowID winid = wxID_ANY,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxTAB_TRAVERSAL | wxNO_BORDER,
+                const wxString& name = wxPanelNameStr);
+
+    virtual ~wxPanel();
+
+    // implementation from now on
+    // --------------------------
+
+        // calls layout for layout constraints and sizers
+    void OnSize(wxSizeEvent& event);
+
+    virtual void InitDialog();
+
+#ifdef __WXUNIVERSAL__
+    virtual bool IsCanvasWindow() const { return true; }
+#endif
+
+
+    WX_DECLARE_CONTROL_CONTAINER();
+
+protected:
+    // common part of all ctors
+    void Init();
+
+private:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxPanel)
+    DECLARE_EVENT_TABLE()
+};
+
+#endif
+    // _WX_GENERIC_PANEL_H_

wxWidgets/include/wx/generic/printps.h

@@ -0,0 +1,68 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        printps.h
+// Purpose:     wxPostScriptPrinter, wxPostScriptPrintPreview
+//              wxGenericPageSetupDialog
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: printps.h 35650 2005-09-23 12:56:45Z MR $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __PRINTPSH__
+#define __PRINTPSH__
+
+#include "wx/prntbase.h"
+
+#if wxUSE_PRINTING_ARCHITECTURE && wxUSE_POSTSCRIPT
+
+// ----------------------------------------------------------------------------
+// Represents the printer: manages printing a wxPrintout object
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxPostScriptPrinter : public wxPrinterBase
+{
+public:
+    wxPostScriptPrinter(wxPrintDialogData *data = (wxPrintDialogData *) NULL);
+    virtual ~wxPostScriptPrinter();
+
+    virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = true);
+    virtual wxDC* PrintDialog(wxWindow *parent);
+    virtual bool Setup(wxWindow *parent);
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxPostScriptPrinter)
+};
+
+// ----------------------------------------------------------------------------
+// wxPrintPreview: programmer creates an object of this class to preview a
+// wxPrintout.
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxPostScriptPrintPreview : public wxPrintPreviewBase
+{
+public:
+    wxPostScriptPrintPreview(wxPrintout *printout,
+                             wxPrintout *printoutForPrinting = (wxPrintout *) NULL,
+                             wxPrintDialogData *data = (wxPrintDialogData *) NULL);
+    wxPostScriptPrintPreview(wxPrintout *printout,
+                             wxPrintout *printoutForPrinting,
+                             wxPrintData *data);
+
+    virtual ~wxPostScriptPrintPreview();
+
+    virtual bool Print(bool interactive);
+    virtual void DetermineScaling();
+
+private:
+    void Init(wxPrintout *printout, wxPrintout *printoutForPrinting);
+
+private:
+    DECLARE_CLASS(wxPostScriptPrintPreview)
+};
+
+#endif
+
+#endif
+// __PRINTPSH__

wxWidgets/include/wx/generic/prntdlgg.h

@@ -0,0 +1,256 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        prntdlgg.h
+// Purpose:     wxGenericPrintDialog, wxGenericPrintSetupDialog,
+//              wxGenericPageSetupDialog
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: prntdlgg.h 49804 2007-11-10 01:09:42Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __PRINTDLGH_G_
+#define __PRINTDLGH_G_
+
+#include "wx/defs.h"
+
+#if wxUSE_PRINTING_ARCHITECTURE
+
+#include "wx/dialog.h"
+#include "wx/cmndata.h"
+#include "wx/prntbase.h"
+#include "wx/printdlg.h"
+#include "wx/listctrl.h"
+
+#if wxUSE_POSTSCRIPT
+    #include "wx/dcps.h"
+#endif
+
+class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
+class WXDLLIMPEXP_FWD_CORE wxButton;
+class WXDLLIMPEXP_FWD_CORE wxCheckBox;
+class WXDLLIMPEXP_FWD_CORE wxComboBox;
+class WXDLLIMPEXP_FWD_CORE wxStaticText;
+class WXDLLIMPEXP_FWD_CORE wxRadioBox;
+class WXDLLIMPEXP_FWD_CORE wxPageSetupData;
+
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+// This is not clear why all these enums start with 10 or 30 but do not change it
+// without good reason to avoid some subtle backwards compatibility breakage
+
+enum
+{
+    wxPRINTID_STATIC = 10,
+    wxPRINTID_RANGE,
+    wxPRINTID_FROM,
+    wxPRINTID_TO,
+    wxPRINTID_COPIES,
+    wxPRINTID_PRINTTOFILE,
+    wxPRINTID_SETUP
+};
+
+enum
+{
+    wxPRINTID_LEFTMARGIN = 30,
+    wxPRINTID_RIGHTMARGIN,
+    wxPRINTID_TOPMARGIN,
+    wxPRINTID_BOTTOMMARGIN
+};
+
+enum
+{
+    wxPRINTID_PRINTCOLOUR = 10,
+    wxPRINTID_ORIENTATION,
+    wxPRINTID_COMMAND,
+    wxPRINTID_OPTIONS,
+    wxPRINTID_PAPERSIZE,
+    wxPRINTID_PRINTER
+};
+
+#if wxUSE_POSTSCRIPT
+
+//----------------------------------------------------------------------------
+// wxPostScriptNativeData
+//----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxPostScriptPrintNativeData: public wxPrintNativeDataBase
+{
+public:
+    wxPostScriptPrintNativeData();
+    virtual ~wxPostScriptPrintNativeData();
+
+    virtual bool TransferTo( wxPrintData &data );
+    virtual bool TransferFrom( const wxPrintData &data );
+
+    virtual bool Ok() const { return IsOk(); }
+    virtual bool IsOk() const { return true; }
+
+    const wxString& GetPrinterCommand() const { return m_printerCommand; }
+    const wxString& GetPrinterOptions() const { return m_printerOptions; }
+    const wxString& GetPreviewCommand() const { return m_previewCommand; }
+    const wxString& GetFontMetricPath() const { return m_afmPath; }
+    double GetPrinterScaleX() const { return m_printerScaleX; }
+    double GetPrinterScaleY() const { return m_printerScaleY; }
+    long GetPrinterTranslateX() const { return m_printerTranslateX; }
+    long GetPrinterTranslateY() const { return m_printerTranslateY; }
+
+    void SetPrinterCommand(const wxString& command) { m_printerCommand = command; }
+    void SetPrinterOptions(const wxString& options) { m_printerOptions = options; }
+    void SetPreviewCommand(const wxString& command) { m_previewCommand = command; }
+    void SetFontMetricPath(const wxString& path) { m_afmPath = path; }
+    void SetPrinterScaleX(double x) { m_printerScaleX = x; }
+    void SetPrinterScaleY(double y) { m_printerScaleY = y; }
+    void SetPrinterScaling(double x, double y) { m_printerScaleX = x; m_printerScaleY = y; }
+    void SetPrinterTranslateX(long x) { m_printerTranslateX = x; }
+    void SetPrinterTranslateY(long y) { m_printerTranslateY = y; }
+    void SetPrinterTranslation(long x, long y) { m_printerTranslateX = x; m_printerTranslateY = y; }
+
+#if wxUSE_STREAMS
+    wxOutputStream *GetOutputStream() { return m_outputStream; }
+    void SetOutputStream( wxOutputStream *output ) { m_outputStream = output; }
+#endif
+
+private:
+    wxString        m_printerCommand;
+    wxString        m_previewCommand;
+    wxString        m_printerOptions;
+    wxString        m_afmPath;
+    double          m_printerScaleX;
+    double          m_printerScaleY;
+    long            m_printerTranslateX;
+    long            m_printerTranslateY;
+#if wxUSE_STREAMS
+    wxOutputStream *m_outputStream;
+#endif
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxPostScriptPrintNativeData)
+};
+
+// ----------------------------------------------------------------------------
+// Simulated Print and Print Setup dialogs for non-Windows platforms (and
+// Windows using PostScript print/preview)
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericPrintDialog : public wxPrintDialogBase
+{
+public:
+    wxGenericPrintDialog(wxWindow *parent,
+                         wxPrintDialogData* data = (wxPrintDialogData*)NULL);
+    wxGenericPrintDialog(wxWindow *parent, wxPrintData* data);
+
+    virtual ~wxGenericPrintDialog();
+
+    void OnSetup(wxCommandEvent& event);
+    void OnRange(wxCommandEvent& event);
+    void OnOK(wxCommandEvent& event);
+
+    virtual bool TransferDataFromWindow();
+    virtual bool TransferDataToWindow();
+
+    virtual int ShowModal();
+
+    wxPrintData& GetPrintData()
+        { return m_printDialogData.GetPrintData(); }
+
+    wxPrintDialogData& GetPrintDialogData() { return m_printDialogData; }
+    wxDC *GetPrintDC();
+
+public:
+//    wxStaticText*       m_printerMessage;
+    wxButton*           m_setupButton;
+//    wxButton*           m_helpButton;
+    wxRadioBox*         m_rangeRadioBox;
+    wxTextCtrl*         m_fromText;
+    wxTextCtrl*         m_toText;
+    wxTextCtrl*         m_noCopiesText;
+    wxCheckBox*         m_printToFileCheckBox;
+//    wxCheckBox*         m_collateCopiesCheckBox;
+
+    wxPrintDialogData   m_printDialogData;
+
+protected:
+    void Init(wxWindow *parent);
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS(wxGenericPrintDialog)
+};
+
+class WXDLLEXPORT wxGenericPrintSetupDialog : public wxDialog
+{
+public:
+    // There are no configuration options for the dialog, so we
+    // just pass the wxPrintData object (no wxPrintSetupDialogData class needed)
+    wxGenericPrintSetupDialog(wxWindow *parent, wxPrintData* data);
+    virtual ~wxGenericPrintSetupDialog();
+
+    void Init(wxPrintData* data);
+
+    void OnPrinter(wxListEvent& event);
+
+    virtual bool TransferDataFromWindow();
+    virtual bool TransferDataToWindow();
+
+    virtual wxComboBox *CreatePaperTypeChoice();
+
+public:
+    wxListCtrl*         m_printerListCtrl;
+    wxRadioBox*         m_orientationRadioBox;
+    wxTextCtrl*         m_printerCommandText;
+    wxTextCtrl*         m_printerOptionsText;
+    wxCheckBox*         m_colourCheckBox;
+    wxComboBox*         m_paperTypeChoice;
+
+    wxPrintData         m_printData;
+    wxPrintData&        GetPrintData() { return m_printData; }
+
+    // After pressing OK, write data here.
+    wxPrintData*        m_targetData;
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_CLASS(wxGenericPrintSetupDialog)
+};
+#endif
+    // wxUSE_POSTSCRIPT
+
+class WXDLLEXPORT wxGenericPageSetupDialog : public wxPageSetupDialogBase
+{
+public:
+    wxGenericPageSetupDialog(wxWindow *parent = NULL,
+                             wxPageSetupDialogData* data = NULL);
+    virtual ~wxGenericPageSetupDialog();
+
+    virtual bool TransferDataFromWindow();
+    virtual bool TransferDataToWindow();
+
+    virtual wxPageSetupDialogData& GetPageSetupDialogData();
+
+    void OnPrinter(wxCommandEvent& event);
+    wxComboBox *CreatePaperTypeChoice(int* x, int* y);
+
+public:
+    wxButton*       m_printerButton;
+    wxRadioBox*     m_orientationRadioBox;
+    wxTextCtrl*     m_marginLeftText;
+    wxTextCtrl*     m_marginTopText;
+    wxTextCtrl*     m_marginRightText;
+    wxTextCtrl*     m_marginBottomText;
+    wxComboBox*       m_paperTypeChoice;
+
+    wxPageSetupDialogData m_pageData;
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxGenericPageSetupDialog)
+};
+
+#endif
+
+#endif
+// __PRINTDLGH_G_

wxWidgets/include/wx/generic/progdlgg.h

@@ -0,0 +1,172 @@
+////////////////////////////////////////////////////
+// Name:        progdlgg.h
+// Purpose:     wxProgressDialog class
+// Author:      Karsten Ballueder
+// Modified by:
+// Created:     09.05.1999
+// RCS-ID:      $Id: progdlgg.h 50711 2007-12-15 02:57:58Z VZ $
+// Copyright:   (c) Karsten Ballueder
+// Licence:     wxWindows licence
+////////////////////////////////////////////////////
+
+#ifndef __PROGDLGH_G__
+#define __PROGDLGH_G__
+
+#include "wx/defs.h"
+#include "wx/progdlg.h"
+
+#if wxUSE_PROGRESSDLG
+
+#include "wx/dialog.h"
+
+class WXDLLIMPEXP_FWD_CORE wxButton;
+class WXDLLIMPEXP_FWD_CORE wxGauge;
+class WXDLLIMPEXP_FWD_CORE wxStaticText;
+
+/* Progress dialog which shows a moving progress bar.
+    Taken from the Mahogany project.*/
+
+class WXDLLEXPORT wxProgressDialog : public wxDialog
+{
+DECLARE_DYNAMIC_CLASS(wxProgressDialog)
+public:
+   /* Creates and displays dialog, disables event handling for other
+       frames or parent frame to avoid recursion problems.
+       @param title title for window
+       @param message message to display in window
+       @param maximum value for status bar, if <= 0, no bar is shown
+       @param parent window or NULL
+       @param style is the bit mask of wxPD_XXX constants from wx/defs.h
+   */
+   wxProgressDialog(const wxString &title, wxString const &message,
+                    int maximum = 100,
+                    wxWindow *parent = NULL,
+                    int style = wxPD_APP_MODAL | wxPD_AUTO_HIDE);
+   /* Destructor.
+       Re-enables event handling for other windows.
+   */
+   virtual ~wxProgressDialog();
+
+   /* Update the status bar to the new value.
+       @param value new value
+       @param newmsg if used, new message to display
+       @returns true if ABORT button has not been pressed
+   */
+   virtual bool Update(int value, const wxString& newmsg = wxEmptyString, bool *skip = NULL);
+
+    /* Switches the dialog to use a gauge in indeterminate mode and calls
+       wxGauge::Pulse() to show to the user a bit of progress */
+    virtual bool Pulse(const wxString& newmsg = wxEmptyString, bool *skip = NULL);
+
+    // Must provide overload to avoid hiding it (and warnings about it)
+    virtual void Update() { wxDialog::Update(); }
+
+   /* Can be called to continue after the cancel button has been pressed, but
+       the program decided to continue the operation (e.g., user didn't
+       confirm it)
+   */
+   void Resume();
+
+   virtual bool Show( bool show = true );
+
+protected:
+   // callback for optional abort button
+   void OnCancel(wxCommandEvent& event);
+
+   // callback for optional skip button
+   void OnSkip(wxCommandEvent& event);
+
+   // callback to disable "hard" window closing
+   void OnClose(wxCloseEvent& event);
+
+   // must be called to reenable the other windows temporarily disabled while
+   // the dialog was shown
+   void ReenableOtherWindows();
+
+private:
+   // create the label with given text and another one to show the time nearby
+   // as the next windows in the sizer, returns the created control
+   wxStaticText *CreateLabel(const wxString& text, wxSizer *sizer);
+
+    // updates the label message
+   void UpdateMessage(const wxString &newmsg);
+
+   // common part of Update() and Pulse(), returns true if not cancelled
+   bool DoAfterUpdate(bool *skip);
+
+   // shortcuts for enabling buttons
+   void EnableClose();
+   void EnableSkip(bool enable=true);
+   void EnableAbort(bool enable=true);
+   inline void DisableSkip() { EnableSkip(false); }
+   inline void DisableAbort() { EnableAbort(false); }
+
+   // the status bar
+   wxGauge *m_gauge;
+   // the message displayed
+   wxStaticText *m_msg;
+   // displayed elapsed, estimated, remaining time
+   class wxStaticText *m_elapsed,
+                      *m_estimated,
+                      *m_remaining;
+   // time when the dialog was created
+   unsigned long m_timeStart;
+   // time when the dialog was closed or cancelled
+   unsigned long m_timeStop;
+   // time between the moment the dialog was closed/cancelled and resume
+   unsigned long m_break;
+
+   // parent top level window (may be NULL)
+   wxWindow *m_parentTop;
+
+    // continue processing or not (return value for Update())
+    enum
+    {
+        Uncancelable = -1,   // dialog can't be canceled
+        Canceled,            // can be cancelled and, in fact, was
+        Continue,            // can be cancelled but wasn't
+        Finished             // finished, waiting to be removed from screen
+    } m_state;
+
+    // skip some portion
+    bool m_skip;
+
+#if !defined(__SMARTPHONE__)
+    // the abort and skip buttons (or NULL if none)
+    wxButton *m_btnAbort;
+    wxButton *m_btnSkip;
+#endif
+
+    // the maximum value
+    int m_maximum;
+
+    // saves the time when elapsed time was updated so there is only one
+    // update per second
+    unsigned long m_last_timeupdate;
+    // tells how often a change of the estimated time has to be confirmed
+    // before it is actually displayed - this reduces the frequence of updates
+    // of estimated and remaining time
+    const int m_delay;
+    // counts the confirmations
+    int m_ctdelay;
+    unsigned long m_display_estimated;
+
+    bool m_hasAbortButton,
+         m_hasSkipButton;
+
+#if defined(__WXMSW__ ) || defined(__WXPM__)
+    // the factor we use to always keep the value in 16 bit range as the native
+    // control only supports ranges from 0 to 65,535
+    size_t m_factor;
+#endif // __WXMSW__
+
+    // for wxPD_APP_MODAL case
+    class WXDLLIMPEXP_FWD_CORE wxWindowDisabler *m_winDisabler;
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxProgressDialog)
+};
+
+#endif // wxUSE_PROGRESSDLG
+
+#endif // __PROGDLGH_G__

wxWidgets/include/wx/generic/propdlg.h

@@ -0,0 +1,163 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/propdlg.h
+// Purpose:     wxPropertySheetDialog
+// Author:      Julian Smart
+// Modified by:
+// Created:     2005-03-12
+// RCS-ID:      $Id: propdlg.h 49804 2007-11-10 01:09:42Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_PROPDLG_H_
+#define _WX_PROPDLG_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_BOOKCTRL
+
+#include "wx/dialog.h"
+
+class WXDLLIMPEXP_FWD_CORE wxBookCtrlBase;
+
+//-----------------------------------------------------------------------------
+// wxPropertySheetDialog
+// A platform-independent properties dialog.
+//
+//   * on PocketPC, a flat-look 'property sheet' notebook will be used, with
+//     no OK/Cancel/Help buttons
+//   * on other platforms, a normal notebook will be used, with standard buttons
+//
+// To use this class, call Create from your derived class.
+// Then create pages and add to the book control. Finally call CreateButtons and
+// LayoutDialog.
+//
+// For example:
+//
+// MyPropertySheetDialog::Create(...)
+// {
+//     wxPropertySheetDialog::Create(...);
+//
+//     // Add page
+//     wxPanel* panel = new wxPanel(GetBookCtrl(), ...);
+//     GetBookCtrl()->AddPage(panel, wxT("General"));
+//
+//     CreateButtons();
+//     LayoutDialog();
+// }
+//
+// Override CreateBookCtrl and AddBookCtrl to create and add a different
+// kind of book control.
+//-----------------------------------------------------------------------------
+
+// Use the platform default
+#define wxPROPSHEET_DEFAULT         0x0001
+
+// Use a notebook
+#define wxPROPSHEET_NOTEBOOK        0x0002
+
+// Use a toolbook
+#define wxPROPSHEET_TOOLBOOK        0x0004
+
+// Use a choicebook
+#define wxPROPSHEET_CHOICEBOOK      0x0008
+
+// Use a listbook
+#define wxPROPSHEET_LISTBOOK        0x0010
+
+// Use a wxButtonToolBar toolbook
+#define wxPROPSHEET_BUTTONTOOLBOOK  0x0020
+
+// Use a treebook
+#define wxPROPSHEET_TREEBOOK        0x0040
+
+// Shrink dialog to fit current page
+#define wxPROPSHEET_SHRINKTOFIT     0x0100
+
+class WXDLLIMPEXP_ADV wxPropertySheetDialog : public wxDialog
+{
+public:
+    wxPropertySheetDialog() : wxDialog() { Init(); }
+
+    wxPropertySheetDialog(wxWindow* parent, wxWindowID id,
+                       const wxString& title,
+                       const wxPoint& pos = wxDefaultPosition,
+                       const wxSize& sz = wxDefaultSize,
+                       long style = wxDEFAULT_DIALOG_STYLE,
+                       const wxString& name = wxDialogNameStr)
+    {
+        Init();
+        Create(parent, id, title, pos, sz, style, name);
+    }
+
+    bool Create(wxWindow* parent, wxWindowID id,
+                       const wxString& title,
+                       const wxPoint& pos = wxDefaultPosition,
+                       const wxSize& sz = wxDefaultSize,
+                       long style = wxDEFAULT_DIALOG_STYLE,
+                       const wxString& name = wxDialogNameStr);
+
+//// Accessors
+
+    // Set and get the notebook
+    void SetBookCtrl(wxBookCtrlBase* book) { m_bookCtrl = book; }
+    wxBookCtrlBase* GetBookCtrl() const { return m_bookCtrl; }
+
+    // Set and get the inner sizer
+    void SetInnerSize(wxSizer* sizer) { m_innerSizer = sizer; }
+    wxSizer* GetInnerSizer() const { return m_innerSizer ; }
+
+    // Set and get the book style
+    void SetSheetStyle(long sheetStyle) { m_sheetStyle = sheetStyle; }
+    long GetSheetStyle() const { return m_sheetStyle ; }
+
+    // Set and get the border around the whole dialog
+    void SetSheetOuterBorder(int border) { m_sheetOuterBorder = border; }
+    int GetSheetOuterBorder() const { return m_sheetOuterBorder ; }
+
+    // Set and get the border around the book control only
+    void SetSheetInnerBorder(int border) { m_sheetInnerBorder = border; }
+    int GetSheetInnerBorder() const { return m_sheetInnerBorder ; }
+
+/// Operations
+
+    // Creates the buttons (none on PocketPC)
+    virtual void CreateButtons(int flags = wxOK|wxCANCEL);
+
+    // Lay out the dialog, to be called after pages have been created
+    virtual void LayoutDialog(int centreFlags = wxBOTH);
+
+/// Implementation
+
+    // Creates the book control. If you want to use a different kind of
+    // control, override.
+    virtual wxBookCtrlBase* CreateBookCtrl();
+
+    // Adds the book control to the inner sizer.
+    virtual void AddBookCtrl(wxSizer* sizer);
+
+    // Set the focus
+    void OnActivate(wxActivateEvent& event);
+
+    // Resize dialog if necessary
+    void OnIdle(wxIdleEvent& event);
+
+private:
+    void Init();
+
+protected:
+    wxBookCtrlBase* m_bookCtrl;
+    wxSizer*        m_innerSizer; // sizer for extra space
+    long            m_sheetStyle;
+    int             m_sheetOuterBorder;
+    int             m_sheetInnerBorder;
+    int             m_selectedPage;
+
+    DECLARE_DYNAMIC_CLASS(wxPropertySheetDialog)
+    DECLARE_EVENT_TABLE()
+};
+
+#endif // wxUSE_BOOKCTRL
+
+#endif // _WX_PROPDLG_H_
+

wxWidgets/include/wx/generic/region.h

@@ -0,0 +1,79 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/region.h
+// Purpose:     generic wxRegion class
+// Author:      David Elliott
+// Modified by:
+// Created:     2004/04/12
+// RCS-ID:      $Id: region.h 41429 2006-09-25 11:47:23Z VZ $
+// Copyright:   (c) 2004 David Elliott
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_REGION_H__
+#define _WX_GENERIC_REGION_H__
+
+class WXDLLEXPORT wxRegionGeneric : public wxRegionBase
+{
+public:
+    wxRegionGeneric(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
+    wxRegionGeneric(const wxPoint& topLeft, const wxPoint& bottomRight);
+    wxRegionGeneric(const wxRect& rect);
+    wxRegionGeneric();
+    virtual ~wxRegionGeneric();
+
+    // wxRegionBase pure virtuals
+    virtual void Clear();
+    virtual bool IsEmpty() const;
+
+protected:
+    virtual wxObjectRefData *CreateRefData() const;
+    virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+
+    // wxRegionBase pure virtuals
+    virtual bool DoIsEqual(const wxRegion& region) const;
+    virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const;
+    virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const;
+    virtual wxRegionContain DoContainsRect(const wxRect& rect) const;
+
+    virtual bool DoOffset(wxCoord x, wxCoord y);
+    virtual bool DoUnionWithRect(const wxRect& rect);
+    virtual bool DoUnionWithRegion(const wxRegion& region);
+    virtual bool DoIntersect(const wxRegion& region);
+    virtual bool DoSubtract(const wxRegion& region);
+    virtual bool DoXor(const wxRegion& region);
+
+    friend class WXDLLEXPORT wxRegionIteratorGeneric;
+};
+
+class WXDLLEXPORT wxRegionIteratorGeneric : public wxObject
+{
+public:
+    wxRegionIteratorGeneric();
+    wxRegionIteratorGeneric(const wxRegionGeneric& region);
+    wxRegionIteratorGeneric(const wxRegionIteratorGeneric& iterator);
+    virtual ~wxRegionIteratorGeneric();
+
+    wxRegionIteratorGeneric& operator=(const wxRegionIteratorGeneric& iterator);
+
+    void Reset() { m_current = 0; }
+    void Reset(const wxRegionGeneric& region);
+
+    operator bool () const { return HaveRects(); }
+    bool HaveRects() const;
+
+    wxRegionIteratorGeneric& operator++();
+    wxRegionIteratorGeneric operator++(int);
+
+    long GetX() const;
+    long GetY() const;
+    long GetW() const;
+    long GetWidth() const { return GetW(); }
+    long GetH() const;
+    long GetHeight() const { return GetH(); }
+    wxRect GetRect() const;
+private:
+    long     m_current;
+    wxRegionGeneric m_region;
+};
+
+#endif // _WX_GENERIC_REGION_H__

wxWidgets/include/wx/generic/sashwin.h

@@ -0,0 +1,261 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        sashwin.h
+// Purpose:     wxSashWindow implementation. A sash window has an optional
+//              sash on each edge, allowing it to be dragged. An event
+//              is generated when the sash is released.
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: sashwin.h 41020 2006-09-05 20:47:48Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_SASHWIN_H_G_
+#define _WX_SASHWIN_H_G_
+
+#if wxUSE_SASH
+
+#include "wx/defs.h"
+#include "wx/window.h"
+#include "wx/string.h"
+
+#define wxSASH_DRAG_NONE       0
+#define wxSASH_DRAG_DRAGGING   1
+#define wxSASH_DRAG_LEFT_DOWN  2
+
+enum wxSashEdgePosition {
+    wxSASH_TOP = 0,
+    wxSASH_RIGHT,
+    wxSASH_BOTTOM,
+    wxSASH_LEFT,
+    wxSASH_NONE = 100
+};
+
+/*
+ * wxSashEdge represents one of the four edges of a window.
+ */
+
+class WXDLLIMPEXP_ADV wxSashEdge
+{
+public:
+    wxSashEdge()
+    { m_show = false;
+#if WXWIN_COMPATIBILITY_2_6
+      m_border = false;
+#endif
+      m_margin = 0; }
+
+    bool    m_show;     // Is the sash showing?
+#if WXWIN_COMPATIBILITY_2_6
+    bool    m_border;   // Do we draw a border?
+#endif
+    int     m_margin;   // The margin size
+};
+
+/*
+ * wxSashWindow flags
+ */
+
+#define wxSW_NOBORDER         0x0000
+//#define wxSW_3D               0x0010
+#define wxSW_BORDER           0x0020
+#define wxSW_3DSASH           0x0040
+#define wxSW_3DBORDER         0x0080
+#define wxSW_3D (wxSW_3DSASH | wxSW_3DBORDER)
+
+/*
+ * wxSashWindow allows any of its edges to have a sash which can be dragged
+ * to resize the window. The actual content window will be created as a child
+ * of wxSashWindow.
+ */
+
+class WXDLLIMPEXP_ADV wxSashWindow: public wxWindow
+{
+public:
+    // Default constructor
+    wxSashWindow()
+    {
+        Init();
+    }
+
+    // Normal constructor
+    wxSashWindow(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize, long style = wxSW_3D|wxCLIP_CHILDREN, const wxString& name = wxT("sashWindow"))
+    {
+        Init();
+        Create(parent, id, pos, size, style, name);
+    }
+
+    virtual ~wxSashWindow();
+
+    bool Create(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
+        const wxSize& size = wxDefaultSize, long style = wxSW_3D|wxCLIP_CHILDREN, const wxString& name = wxT("sashWindow"));
+
+    // Set whether there's a sash in this position
+    void SetSashVisible(wxSashEdgePosition edge, bool sash);
+
+    // Get whether there's a sash in this position
+    bool GetSashVisible(wxSashEdgePosition edge) const { return m_sashes[edge].m_show; }
+
+#if WXWIN_COMPATIBILITY_2_6
+    // Set whether there's a border in this position
+    // This value is unused in wxSashWindow.
+    void SetSashBorder(wxSashEdgePosition edge, bool border) { m_sashes[edge].m_border = border; }
+
+    // Get whether there's a border in this position
+    // This value is unused in wxSashWindow.
+    bool HasBorder(wxSashEdgePosition edge) const { return m_sashes[edge].m_border; }
+#endif
+
+    // Get border size
+    int GetEdgeMargin(wxSashEdgePosition edge) const { return m_sashes[edge].m_margin; }
+
+    // Sets the default sash border size
+    void SetDefaultBorderSize(int width) { m_borderSize = width; }
+
+    // Gets the default sash border size
+    int GetDefaultBorderSize() const { return m_borderSize; }
+
+    // Sets the addition border size between child and sash window
+    void SetExtraBorderSize(int width) { m_extraBorderSize = width; }
+
+    // Gets the addition border size between child and sash window
+    int GetExtraBorderSize() const { return m_extraBorderSize; }
+
+    virtual void SetMinimumSizeX(int min) { m_minimumPaneSizeX = min; }
+    virtual void SetMinimumSizeY(int min) { m_minimumPaneSizeY = min; }
+    virtual int GetMinimumSizeX() const { return m_minimumPaneSizeX; }
+    virtual int GetMinimumSizeY() const { return m_minimumPaneSizeY; }
+
+    virtual void SetMaximumSizeX(int max) { m_maximumPaneSizeX = max; }
+    virtual void SetMaximumSizeY(int max) { m_maximumPaneSizeY = max; }
+    virtual int GetMaximumSizeX() const { return m_maximumPaneSizeX; }
+    virtual int GetMaximumSizeY() const { return m_maximumPaneSizeY; }
+
+////////////////////////////////////////////////////////////////////////////
+// Implementation
+
+    // Paints the border and sash
+    void OnPaint(wxPaintEvent& event);
+
+    // Handles mouse events
+    void OnMouseEvent(wxMouseEvent& ev);
+
+    // Adjusts the panes
+    void OnSize(wxSizeEvent& event);
+
+#if defined(__WXMSW__) || defined(__WXMAC__)
+    // Handle cursor correctly
+    void OnSetCursor(wxSetCursorEvent& event);
+#endif // wxMSW
+
+    // Draws borders
+    void DrawBorders(wxDC& dc);
+
+    // Draws the sashes
+    void DrawSash(wxSashEdgePosition edge, wxDC& dc);
+
+    // Draws the sashes
+    void DrawSashes(wxDC& dc);
+
+    // Draws the sash tracker (for whilst moving the sash)
+    void DrawSashTracker(wxSashEdgePosition edge, int x, int y);
+
+    // Tests for x, y over sash
+    wxSashEdgePosition SashHitTest(int x, int y, int tolerance = 2);
+
+    // Resizes subwindows
+    void SizeWindows();
+
+    // Initialize colours
+    void InitColours();
+
+private:
+    void Init();
+
+    wxSashEdge  m_sashes[4];
+    int         m_dragMode;
+    wxSashEdgePosition m_draggingEdge;
+    int         m_oldX;
+    int         m_oldY;
+    int         m_borderSize;
+    int         m_extraBorderSize;
+    int         m_firstX;
+    int         m_firstY;
+    int         m_minimumPaneSizeX;
+    int         m_minimumPaneSizeY;
+    int         m_maximumPaneSizeX;
+    int         m_maximumPaneSizeY;
+    wxCursor*   m_sashCursorWE;
+    wxCursor*   m_sashCursorNS;
+    wxColour    m_lightShadowColour;
+    wxColour    m_mediumShadowColour;
+    wxColour    m_darkShadowColour;
+    wxColour    m_hilightColour;
+    wxColour    m_faceColour;
+    bool        m_mouseCaptured;
+    wxCursor*   m_currentCursor;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxSashWindow)
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxSashWindow)
+};
+
+BEGIN_DECLARE_EVENT_TYPES()
+    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV,
+                                wxEVT_SASH_DRAGGED, wxEVT_FIRST + 1200)
+END_DECLARE_EVENT_TYPES()
+
+enum wxSashDragStatus
+{
+    wxSASH_STATUS_OK,
+    wxSASH_STATUS_OUT_OF_RANGE
+};
+
+class WXDLLIMPEXP_ADV wxSashEvent: public wxCommandEvent
+{
+public:
+    wxSashEvent(int id = 0, wxSashEdgePosition edge = wxSASH_NONE)
+    {
+        m_eventType = (wxEventType) wxEVT_SASH_DRAGGED;
+        m_id = id;
+        m_edge = edge;
+    }
+
+    void SetEdge(wxSashEdgePosition edge) { m_edge = edge; }
+    wxSashEdgePosition GetEdge() const { return m_edge; }
+
+    //// The rectangle formed by the drag operation
+    void SetDragRect(const wxRect& rect) { m_dragRect = rect; }
+    wxRect GetDragRect() const { return m_dragRect; }
+
+    //// Whether the drag caused the rectangle to be reversed (e.g.
+    //// dragging the top below the bottom)
+    void SetDragStatus(wxSashDragStatus status) { m_dragStatus = status; }
+    wxSashDragStatus GetDragStatus() const { return m_dragStatus; }
+
+private:
+    wxSashEdgePosition  m_edge;
+    wxRect              m_dragRect;
+    wxSashDragStatus    m_dragStatus;
+
+private:
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxSashEvent)
+};
+
+typedef void (wxEvtHandler::*wxSashEventFunction)(wxSashEvent&);
+
+#define wxSashEventHandler(func) \
+    (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxSashEventFunction, &func)
+
+#define EVT_SASH_DRAGGED(id, fn) \
+    wx__DECLARE_EVT1(wxEVT_SASH_DRAGGED, id, wxSashEventHandler(fn))
+#define EVT_SASH_DRAGGED_RANGE(id1, id2, fn) \
+    wx__DECLARE_EVT2(wxEVT_SASH_DRAGGED, id1, id2, wxSashEventHandler(fn))
+
+#endif // wxUSE_SASH
+
+#endif
+  // _WX_SASHWIN_H_G_

wxWidgets/include/wx/generic/scrolwin.h

@@ -0,0 +1,27 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/scrolwin.h
+// Purpose:     wxGenericScrolledWindow class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: scrolwin.h 35875 2005-10-10 18:24:27Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_SCROLLWIN_H_
+#define _WX_GENERIC_SCROLLWIN_H_
+
+// ----------------------------------------------------------------------------
+// headers and constants
+// ----------------------------------------------------------------------------
+
+#include "wx/window.h"
+#include "wx/panel.h"
+
+// ----------------------------------------------------------------------------
+// wxGenericScrolledWindow
+// ----------------------------------------------------------------------------
+
+#endif // _WX_GENERIC_SCROLLWIN_H_
+

wxWidgets/include/wx/generic/spinctlg.h

@@ -0,0 +1,183 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/spinctlg.h
+// Purpose:     generic wxSpinCtrl class
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     28.10.99
+// RCS-ID:      $Id: spinctlg.h 61872 2009-09-09 22:37:05Z VZ $
+// Copyright:   (c) Vadim Zeitlin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_SPINCTRL_H_
+#define _WX_GENERIC_SPINCTRL_H_
+
+// ----------------------------------------------------------------------------
+// wxSpinCtrl is a combination of wxSpinButton and wxTextCtrl, so if
+// wxSpinButton is available, this is what we do - but if it isn't, we still
+// define wxSpinCtrl class which then has the same appearance as wxTextCtrl but
+// the different interface. This allows to write programs using wxSpinCtrl
+// without tons of #ifdefs.
+// ----------------------------------------------------------------------------
+
+#if wxUSE_SPINBTN
+
+class WXDLLEXPORT wxSpinButton;
+class WXDLLEXPORT wxTextCtrl;
+
+// ----------------------------------------------------------------------------
+// wxSpinCtrl is a combination of wxTextCtrl and wxSpinButton
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxSpinCtrl : public wxControl
+{
+public:
+    wxSpinCtrl() { Init(); }
+
+    wxSpinCtrl(wxWindow *parent,
+               wxWindowID id = wxID_ANY,
+               const wxString& value = wxEmptyString,
+               const wxPoint& pos = wxDefaultPosition,
+               const wxSize& size = wxDefaultSize,
+               long style = wxSP_ARROW_KEYS,
+               int min = 0, int max = 100, int initial = 0,
+               const wxString& name = wxT("wxSpinCtrl"))
+    {
+        Init();
+        Create(parent, id, value, pos, size, style, min, max, initial, name);
+    }
+
+    bool Create(wxWindow *parent,
+                wxWindowID id = wxID_ANY,
+                const wxString& value = wxEmptyString,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxSP_ARROW_KEYS,
+                int min = 0, int max = 100, int initial = 0,
+                const wxString& name = wxT("wxSpinCtrl"));
+
+    virtual ~wxSpinCtrl();
+
+    // operations
+    void SetValue(int val);
+    void SetValue(const wxString& text);
+    void SetRange(int min, int max);
+    void SetSelection(long from, long to);
+
+    // accessors
+    int GetValue() const;
+    int GetMin() const;
+    int GetMax() const;
+
+    // implementation from now on
+
+    // forward these functions to all subcontrols
+    virtual bool Enable(bool enable = true);
+    virtual bool Show(bool show = true);
+    virtual bool Reparent(wxWindow *newParent);
+
+    // get the subcontrols
+    wxTextCtrl *GetText() const { return m_text; }
+    wxSpinButton *GetSpinButton() const { return m_btn; }
+
+    // set the value of the text (only)
+    void SetTextValue(int val);
+
+    // put the numeric value of the string in the text ctrl into val and return
+    // true or return false if the text ctrl doesn't contain a number or if the
+    // number is out of range
+    bool GetTextValue(int *val) const;
+
+protected:
+    // override the base class virtuals involved into geometry calculations
+    virtual wxSize DoGetBestSize() const;
+    virtual void DoMoveWindow(int x, int y, int width, int height);
+
+    // common part of all ctors
+    void Init();
+
+private:
+    // the subcontrols
+    wxTextCtrl *m_text;
+    wxSpinButton *m_btn;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxSpinCtrl)
+};
+
+#else // !wxUSE_SPINBTN
+
+// ----------------------------------------------------------------------------
+// wxSpinCtrl is just a text control
+// ----------------------------------------------------------------------------
+
+#include "wx/textctrl.h"
+
+class WXDLLEXPORT wxSpinCtrl : public wxTextCtrl
+{
+public:
+    wxSpinCtrl() { Init(); }
+
+    wxSpinCtrl(wxWindow *parent,
+               wxWindowID id = wxID_ANY,
+               const wxString& value = wxEmptyString,
+               const wxPoint& pos = wxDefaultPosition,
+               const wxSize& size = wxDefaultSize,
+               long style = wxSP_ARROW_KEYS,
+               int min = 0, int max = 100, int initial = 0,
+               const wxString& name = wxT("wxSpinCtrl"))
+    {
+        Create(parent, id, value, pos, size, style, min, max, initial, name);
+    }
+
+    bool Create(wxWindow *parent,
+                wxWindowID id = wxID_ANY,
+                const wxString& value = wxEmptyString,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxSP_ARROW_KEYS,
+                int min = 0, int max = 100, int initial = 0,
+                const wxString& name = wxT("wxSpinCtrl"))
+    {
+        SetRange(min, max);
+
+        bool ok = wxTextCtrl::Create(parent, id, value, pos, size, style,
+                                     wxDefaultValidator, name);
+        SetValue(initial);
+
+        return ok;
+    }
+
+    // accessors
+    int GetValue(int WXUNUSED(dummy) = 1) const
+    {
+        int n;
+        if ( (wxSscanf(wxTextCtrl::GetValue(), wxT("%d"), &n) != 1) )
+            n = INT_MIN;
+
+        return n;
+    }
+
+    int GetMin() const { return m_min; }
+    int GetMax() const { return m_max; }
+
+    // operations
+    void SetValue(const wxString& value) { wxTextCtrl::SetValue(value); }
+    void SetValue(int val) { wxString s; s << val; wxTextCtrl::SetValue(s); }
+    void SetRange(int min, int max) { m_min = min; m_max = max; }
+
+protected:
+    // initialize m_min/max with the default values
+    void Init() { SetRange(0, 100); }
+
+    int   m_min;
+    int   m_max;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxSpinCtrl)
+};
+
+#endif // wxUSE_SPINBTN/!wxUSE_SPINBTN
+
+#endif // _WX_GENERIC_SPINCTRL_H_
+

wxWidgets/include/wx/generic/splash.h

@@ -0,0 +1,92 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        splash.h
+// Purpose:     Splash screen class
+// Author:      Julian Smart
+// Modified by:
+// Created:     28/6/2000
+// RCS-ID:      $Id: splash.h 53135 2008-04-12 02:31:04Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_SPLASH_H_
+#define _WX_SPLASH_H_
+
+#include "wx/bitmap.h"
+#include "wx/timer.h"
+#include "wx/frame.h"
+
+
+/*
+ * A window for displaying a splash screen
+ */
+
+#define wxSPLASH_CENTRE_ON_PARENT   0x01
+#define wxSPLASH_CENTRE_ON_SCREEN   0x02
+#define wxSPLASH_NO_CENTRE          0x00
+#define wxSPLASH_TIMEOUT            0x04
+#define wxSPLASH_NO_TIMEOUT         0x00
+
+class WXDLLIMPEXP_FWD_ADV wxSplashScreenWindow;
+
+/*
+ * wxSplashScreen
+ */
+
+class WXDLLIMPEXP_ADV wxSplashScreen: public wxFrame
+{
+public:
+    // for RTTI macros only
+    wxSplashScreen() {}
+    wxSplashScreen(const wxBitmap& bitmap, long splashStyle, int milliseconds,
+                   wxWindow* parent, wxWindowID id,
+                   const wxPoint& pos = wxDefaultPosition,
+                   const wxSize& size = wxDefaultSize,
+                   long style = wxSIMPLE_BORDER|wxFRAME_NO_TASKBAR|wxSTAY_ON_TOP);
+    virtual ~wxSplashScreen();
+
+    void OnCloseWindow(wxCloseEvent& event);
+    void OnNotify(wxTimerEvent& event);
+
+    long GetSplashStyle() const { return m_splashStyle; }
+    wxSplashScreenWindow* GetSplashWindow() const { return m_window; }
+    int GetTimeout() const { return m_milliseconds; }
+
+protected:
+    wxSplashScreenWindow*   m_window;
+    long                    m_splashStyle;
+    int                     m_milliseconds;
+    wxTimer                 m_timer;
+
+    DECLARE_DYNAMIC_CLASS(wxSplashScreen)
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxSplashScreen)
+};
+
+/*
+ * wxSplashScreenWindow
+ */
+
+class WXDLLIMPEXP_ADV wxSplashScreenWindow: public wxWindow
+{
+public:
+    wxSplashScreenWindow(const wxBitmap& bitmap, wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxNO_BORDER);
+
+    void OnPaint(wxPaintEvent& event);
+    void OnEraseBackground(wxEraseEvent& event);
+    void OnMouseEvent(wxMouseEvent& event);
+    void OnChar(wxKeyEvent& event);
+
+    void SetBitmap(const wxBitmap& bitmap) { m_bitmap = bitmap; }
+    wxBitmap& GetBitmap() { return m_bitmap; }
+
+protected:
+    wxBitmap    m_bitmap;
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxSplashScreenWindow)
+};
+
+
+#endif
+    // _WX_SPLASH_H_

wxWidgets/include/wx/generic/splitter.h

@@ -0,0 +1,406 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/splitter.h
+// Purpose:     wxSplitterWindow class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: splitter.h 61872 2009-09-09 22:37:05Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_SPLITTER_H_
+#define _WX_GENERIC_SPLITTER_H_
+
+#include "wx/window.h"                      // base class declaration
+#include "wx/containr.h"                    // wxControlContainer
+
+class WXDLLIMPEXP_FWD_CORE wxSplitterEvent;
+
+// ---------------------------------------------------------------------------
+// splitter constants
+// ---------------------------------------------------------------------------
+
+enum wxSplitMode
+{
+    wxSPLIT_HORIZONTAL = 1,
+    wxSPLIT_VERTICAL
+};
+
+enum
+{
+    wxSPLIT_DRAG_NONE,
+    wxSPLIT_DRAG_DRAGGING,
+    wxSPLIT_DRAG_LEFT_DOWN
+};
+
+// ---------------------------------------------------------------------------
+// wxSplitterWindow maintains one or two panes, with
+// an optional vertical or horizontal split which
+// can be used with the mouse or programmatically.
+// ---------------------------------------------------------------------------
+
+// TODO:
+// 1) Perhaps make the borders sensitive to dragging in order to create a split.
+//    The MFC splitter window manages scrollbars as well so is able to
+//    put sash buttons on the scrollbars, but we probably don't want to go down
+//    this path.
+// 2) for wxWidgets 2.0, we must find a way to set the WS_CLIPCHILDREN style
+//    to prevent flickering. (WS_CLIPCHILDREN doesn't work in all cases so can't be
+//    standard).
+
+class WXDLLEXPORT wxSplitterWindow: public wxWindow
+{
+public:
+
+////////////////////////////////////////////////////////////////////////////
+// Public API
+
+    // Default constructor
+    wxSplitterWindow()
+    {
+        Init();
+    }
+
+    // Normal constructor
+    wxSplitterWindow(wxWindow *parent, wxWindowID id = wxID_ANY,
+                     const wxPoint& pos = wxDefaultPosition,
+                     const wxSize& size = wxDefaultSize,
+                     long style = wxSP_3D,
+                     const wxString& name = wxT("splitter"))
+    {
+        Init();
+        Create(parent, id, pos, size, style, name);
+    }
+
+    virtual ~wxSplitterWindow();
+
+    bool Create(wxWindow *parent, wxWindowID id = wxID_ANY,
+                     const wxPoint& pos = wxDefaultPosition,
+                     const wxSize& size = wxDefaultSize,
+                     long style = wxSP_3D,
+                     const wxString& name = wxT("splitter"));
+
+    // Gets the only or left/top pane
+    wxWindow *GetWindow1() const { return m_windowOne; }
+
+    // Gets the right/bottom pane
+    wxWindow *GetWindow2() const { return m_windowTwo; }
+
+    // Sets the split mode
+    void SetSplitMode(int mode)
+    {
+        wxASSERT_MSG( mode == wxSPLIT_VERTICAL || mode == wxSPLIT_HORIZONTAL,
+                      wxT("invalid split mode") );
+
+        m_splitMode = (wxSplitMode)mode;
+    }
+
+    // Gets the split mode
+    wxSplitMode GetSplitMode() const { return m_splitMode; }
+
+    // Initialize with one window
+    void Initialize(wxWindow *window);
+
+    // Associates the given window with window 2, drawing the appropriate sash
+    // and changing the split mode.
+    // Does nothing and returns false if the window is already split.
+    // A sashPosition of 0 means choose a default sash position,
+    // negative sashPosition specifies the size of right/lower pane as it's
+    // absolute value rather than the size of left/upper pane.
+    virtual bool SplitVertically(wxWindow *window1,
+                                 wxWindow *window2,
+                                 int sashPosition = 0)
+        { return DoSplit(wxSPLIT_VERTICAL, window1, window2, sashPosition); }
+    virtual bool SplitHorizontally(wxWindow *window1,
+                                   wxWindow *window2,
+                                   int sashPosition = 0)
+        { return DoSplit(wxSPLIT_HORIZONTAL, window1, window2, sashPosition); }
+
+    // Removes the specified (or second) window from the view
+    // Doesn't actually delete the window.
+    bool Unsplit(wxWindow *toRemove = (wxWindow *) NULL);
+
+    // Replaces one of the windows with another one (neither old nor new
+    // parameter should be NULL)
+    bool ReplaceWindow(wxWindow *winOld, wxWindow *winNew);
+
+    // Make sure the child window sizes are updated. This is useful
+    // for reducing flicker by updating the sizes before a
+    // window is shown, if you know the overall size is correct.
+    void UpdateSize();
+
+    // Is the window split?
+    bool IsSplit() const { return (m_windowTwo != NULL); }
+
+    // Sets the sash size
+    void SetSashSize(int width) { m_sashSize = width; }
+
+    // Sets the border size
+    void SetBorderSize(int WXUNUSED(width)) { }
+
+    // Gets the sash size
+    int GetSashSize() const;
+
+    // Gets the border size
+    int GetBorderSize() const;
+
+    // Set the sash position
+    void SetSashPosition(int position, bool redraw = true);
+
+    // Gets the sash position
+    int GetSashPosition() const { return m_sashPosition; }
+
+    // Set the sash gravity
+    void SetSashGravity(double gravity);
+
+    // Gets the sash gravity
+    double GetSashGravity() const { return m_sashGravity; }
+
+    // If this is zero, we can remove panes by dragging the sash.
+    void SetMinimumPaneSize(int min);
+    int GetMinimumPaneSize() const { return m_minimumPaneSize; }
+
+    // NB: the OnXXX() functions below are for backwards compatibility only,
+    //     don't use them in new code but handle the events instead!
+
+    // called when the sash position is about to change, may return a new value
+    // for the sash or -1 to prevent the change from happening at all
+    virtual int OnSashPositionChanging(int newSashPosition);
+
+    // Called when the sash position is about to be changed, return
+    // false from here to prevent the change from taking place.
+    // Repositions sash to minimum position if pane would be too small.
+    // newSashPosition here is always positive or zero.
+    virtual bool OnSashPositionChange(int newSashPosition);
+
+    // If the sash is moved to an extreme position, a subwindow
+    // is removed from the splitter window, and the app is
+    // notified. The app should delete or hide the window.
+    virtual void OnUnsplit(wxWindow *removed);
+
+    // Called when the sash is double-clicked.
+    // The default behaviour is to remove the sash if the
+    // minimum pane size is zero.
+    virtual void OnDoubleClickSash(int x, int y);
+
+////////////////////////////////////////////////////////////////////////////
+// Implementation
+
+    // Paints the border and sash
+    void OnPaint(wxPaintEvent& event);
+
+    // Handles mouse events
+    void OnMouseEvent(wxMouseEvent& ev);
+
+    // Adjusts the panes
+    void OnSize(wxSizeEvent& event);
+
+    // In live mode, resize child windows in idle time
+    void OnInternalIdle();
+
+    // Draws the sash
+    virtual void DrawSash(wxDC& dc);
+
+    // Draws the sash tracker (for whilst moving the sash)
+    virtual void DrawSashTracker(int x, int y);
+
+    // Tests for x, y over sash
+    virtual bool SashHitTest(int x, int y, int tolerance = 5);
+
+    // Resizes subwindows
+    virtual void SizeWindows();
+
+    void SetNeedUpdating(bool needUpdating) { m_needUpdating = needUpdating; }
+    bool GetNeedUpdating() const { return m_needUpdating ; }
+
+#ifdef __WXMAC__
+    virtual bool MacClipGrandChildren() const { return true ; }
+#endif
+
+protected:
+    // event handlers
+#if defined(__WXMSW__) || defined(__WXMAC__)
+    void OnSetCursor(wxSetCursorEvent& event);
+#endif // wxMSW
+
+    // send the given event, return false if the event was processed and vetoed
+    // by the user code
+    bool DoSendEvent(wxSplitterEvent& event);
+
+    // common part of all ctors
+    void Init();
+
+    // common part of SplitVertically() and SplitHorizontally()
+    bool DoSplit(wxSplitMode mode,
+                 wxWindow *window1, wxWindow *window2,
+                 int sashPosition);
+
+    // adjusts sash position with respect to min. pane and window sizes
+    int AdjustSashPosition(int sashPos) const;
+
+    // get either width or height depending on the split mode
+    int GetWindowSize() const;
+
+    // convert the user specified sash position which may be > 0 (as is), < 0
+    // (specifying the size of the right pane) or 0 (use default) to the real
+    // position to be passed to DoSetSashPosition()
+    int ConvertSashPosition(int sashPos) const;
+
+    // set the real sash position, sashPos here must be positive
+    //
+    // returns true if the sash position has been changed, false otherwise
+    bool DoSetSashPosition(int sashPos);
+
+    // set the sash position and send an event about it having been changed
+    void SetSashPositionAndNotify(int sashPos);
+
+    // callbacks executed when we detect that the mouse has entered or left
+    // the sash
+    virtual void OnEnterSash();
+    virtual void OnLeaveSash();
+
+    // set the cursor appropriate for the current split mode
+    void SetResizeCursor();
+
+    // redraw the splitter if its "hotness" changed if necessary
+    void RedrawIfHotSensitive(bool isHot);
+
+    // return the best size of the splitter equal to best sizes of its
+    // subwindows
+    virtual wxSize DoGetBestSize() const;
+
+
+    wxSplitMode m_splitMode;
+    wxWindow*   m_windowOne;
+    wxWindow*   m_windowTwo;
+    int         m_dragMode;
+    int         m_oldX;
+    int         m_oldY;
+    int         m_sashPosition; // Number of pixels from left or top
+    double      m_sashGravity;
+    int         m_sashSize;
+    wxSize      m_lastSize;
+    int         m_requestedSashPosition;
+    int         m_sashPositionCurrent; // while dragging
+    int         m_firstX;
+    int         m_firstY;
+    int         m_minimumPaneSize;
+    wxCursor    m_sashCursorWE;
+    wxCursor    m_sashCursorNS;
+    wxPen      *m_sashTrackerPen;
+
+    // when in live mode, set this to true to resize children in idle
+    bool        m_needUpdating:1;
+    bool        m_permitUnsplitAlways:1;
+    bool        m_isHot:1;
+    bool        m_checkRequestedSashPosition:1;
+
+private:
+    WX_DECLARE_CONTROL_CONTAINER();
+
+    DECLARE_DYNAMIC_CLASS(wxSplitterWindow)
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxSplitterWindow)
+};
+
+// ----------------------------------------------------------------------------
+// event class and macros
+// ----------------------------------------------------------------------------
+
+// we reuse the same class for all splitter event types because this is the
+// usual wxWin convention, but the three event types have different kind of
+// data associated with them, so the accessors can be only used if the real
+// event type matches with the one for which the accessors make sense
+class WXDLLEXPORT wxSplitterEvent : public wxNotifyEvent
+{
+public:
+    wxSplitterEvent(wxEventType type = wxEVT_NULL,
+                    wxSplitterWindow *splitter = (wxSplitterWindow *)NULL)
+        : wxNotifyEvent(type)
+    {
+        SetEventObject(splitter);
+        if (splitter) m_id = splitter->GetId();
+    }
+
+    // SASH_POS_CHANGED methods
+
+    // setting the sash position to -1 prevents the change from taking place at
+    // all
+    void SetSashPosition(int pos)
+    {
+        wxASSERT( GetEventType() == wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED
+                || GetEventType() == wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING);
+
+        m_data.pos = pos;
+    }
+
+    int GetSashPosition() const
+    {
+        wxASSERT( GetEventType() == wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED
+                || GetEventType() == wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING);
+
+        return m_data.pos;
+    }
+
+    // UNSPLIT event methods
+    wxWindow *GetWindowBeingRemoved() const
+    {
+        wxASSERT( GetEventType() == wxEVT_COMMAND_SPLITTER_UNSPLIT );
+
+        return m_data.win;
+    }
+
+    // DCLICK event methods
+    int GetX() const
+    {
+        wxASSERT( GetEventType() == wxEVT_COMMAND_SPLITTER_DOUBLECLICKED );
+
+        return m_data.pt.x;
+    }
+
+    int GetY() const
+    {
+        wxASSERT( GetEventType() == wxEVT_COMMAND_SPLITTER_DOUBLECLICKED );
+
+        return m_data.pt.y;
+    }
+
+private:
+    friend class WXDLLIMPEXP_FWD_CORE wxSplitterWindow;
+
+    // data for the different types of event
+    union
+    {
+        int pos;            // position for SASH_POS_CHANGED event
+        wxWindow *win;      // window being removed for UNSPLIT event
+        struct
+        {
+            int x, y;
+        } pt;               // position of double click for DCLICK event
+    } m_data;
+
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxSplitterEvent)
+};
+
+typedef void (wxEvtHandler::*wxSplitterEventFunction)(wxSplitterEvent&);
+
+#define wxSplitterEventHandler(func) \
+    (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxSplitterEventFunction, &func)
+
+#define wx__DECLARE_SPLITTEREVT(evt, id, fn) \
+    wx__DECLARE_EVT1(wxEVT_COMMAND_SPLITTER_ ## evt, id, wxSplitterEventHandler(fn))
+
+#define EVT_SPLITTER_SASH_POS_CHANGED(id, fn) \
+    wx__DECLARE_SPLITTEREVT(SASH_POS_CHANGED, id, fn)
+
+#define EVT_SPLITTER_SASH_POS_CHANGING(id, fn) \
+    wx__DECLARE_SPLITTEREVT(SASH_POS_CHANGING, id, fn)
+
+#define EVT_SPLITTER_DCLICK(id, fn) \
+    wx__DECLARE_SPLITTEREVT(DOUBLECLICKED, id, fn)
+
+#define EVT_SPLITTER_UNSPLIT(id, fn) \
+    wx__DECLARE_SPLITTEREVT(UNSPLIT, id, fn)
+
+#endif // _WX_GENERIC_SPLITTER_H_

wxWidgets/include/wx/generic/srchctlg.h

@@ -0,0 +1,275 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/srchctlg.h
+// Purpose:     generic wxSearchCtrl class
+// Author:      Vince Harron
+// Created:     2006-02-19
+// RCS-ID:      $Id: srchctlg.h 53135 2008-04-12 02:31:04Z VZ $
+// Copyright:   Vince Harron
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_SEARCHCTRL_H_
+#define _WX_GENERIC_SEARCHCTRL_H_
+
+#if wxUSE_SEARCHCTRL
+
+#include "wx/bitmap.h"
+
+class WXDLLIMPEXP_FWD_CORE wxSearchButton;
+class WXDLLIMPEXP_FWD_CORE wxSearchTextCtrl;
+
+// ----------------------------------------------------------------------------
+// wxSearchCtrl is a combination of wxTextCtrl and wxSearchButton
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxSearchCtrl : public wxSearchCtrlBase
+{
+public:
+    // creation
+    // --------
+
+    wxSearchCtrl();
+    wxSearchCtrl(wxWindow *parent, wxWindowID id,
+               const wxString& value = wxEmptyString,
+               const wxPoint& pos = wxDefaultPosition,
+               const wxSize& size = wxDefaultSize,
+               long style = 0,
+               const wxValidator& validator = wxDefaultValidator,
+               const wxString& name = wxSearchCtrlNameStr);
+
+    virtual ~wxSearchCtrl();
+
+    bool Create(wxWindow *parent, wxWindowID id,
+                const wxString& value = wxEmptyString,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = 0,
+                const wxValidator& validator = wxDefaultValidator,
+                const wxString& name = wxSearchCtrlNameStr);
+
+#if wxUSE_MENUS
+    // get/set search button menu
+    // --------------------------
+    virtual void SetMenu( wxMenu* menu );
+    virtual wxMenu* GetMenu();
+#endif // wxUSE_MENUS
+
+    // get/set search options
+    // ----------------------
+    virtual void ShowSearchButton( bool show );
+    virtual bool IsSearchButtonVisible() const;
+
+    virtual void ShowCancelButton( bool show );
+    virtual bool IsCancelButtonVisible() const;
+
+#if wxABI_VERSION >= 20802
+    // TODO: In 2.9 these should probably be virtual, and declared in the base class...
+    void SetDescriptiveText(const wxString& text);
+    wxString GetDescriptiveText() const;
+#endif
+
+    // accessors
+    // ---------
+
+    virtual wxString GetValue() const;
+    virtual void SetValue(const wxString& value);
+
+    virtual wxString GetRange(long from, long to) const;
+
+    virtual int GetLineLength(long lineNo) const;
+    virtual wxString GetLineText(long lineNo) const;
+    virtual int GetNumberOfLines() const;
+
+    virtual bool IsModified() const;
+    virtual bool IsEditable() const;
+
+    // more readable flag testing methods
+    virtual bool IsSingleLine() const;
+    virtual bool IsMultiLine() const;
+
+    // If the return values from and to are the same, there is no selection.
+    virtual void GetSelection(long* from, long* to) const;
+
+    virtual wxString GetStringSelection() const;
+
+    // operations
+    // ----------
+
+    // editing
+    virtual void Clear();
+    virtual void Replace(long from, long to, const wxString& value);
+    virtual void Remove(long from, long to);
+
+    // load/save the controls contents from/to the file
+    virtual bool LoadFile(const wxString& file);
+    virtual bool SaveFile(const wxString& file = wxEmptyString);
+
+    // sets/clears the dirty flag
+    virtual void MarkDirty();
+    virtual void DiscardEdits();
+
+    // set the max number of characters which may be entered in a single line
+    // text control
+    virtual void SetMaxLength(unsigned long WXUNUSED(len));
+
+    // writing text inserts it at the current position, appending always
+    // inserts it at the end
+    virtual void WriteText(const wxString& text);
+    virtual void AppendText(const wxString& text);
+
+    // insert the character which would have resulted from this key event,
+    // return true if anything has been inserted
+    virtual bool EmulateKeyPress(const wxKeyEvent& event);
+
+    // text control under some platforms supports the text styles: these
+    // methods allow to apply the given text style to the given selection or to
+    // set/get the style which will be used for all appended text
+    virtual bool SetStyle(long start, long end, const wxTextAttr& style);
+    virtual bool GetStyle(long position, wxTextAttr& style);
+    virtual bool SetDefaultStyle(const wxTextAttr& style);
+    virtual const wxTextAttr& GetDefaultStyle() const;
+
+    // translate between the position (which is just an index in the text ctrl
+    // considering all its contents as a single strings) and (x, y) coordinates
+    // which represent column and line.
+    virtual long XYToPosition(long x, long y) const;
+    virtual bool PositionToXY(long pos, long *x, long *y) const;
+
+    virtual void ShowPosition(long pos);
+
+    // find the character at position given in pixels
+    //
+    // NB: pt is in device coords (not adjusted for the client area origin nor
+    //     scrolling)
+    virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const;
+    virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
+                                            wxTextCoord *col,
+                                            wxTextCoord *row) const;
+
+    // Clipboard operations
+    virtual void Copy();
+    virtual void Cut();
+    virtual void Paste();
+
+    virtual bool CanCopy() const;
+    virtual bool CanCut() const;
+    virtual bool CanPaste() const;
+
+    // Undo/redo
+    virtual void Undo();
+    virtual void Redo();
+
+    virtual bool CanUndo() const;
+    virtual bool CanRedo() const;
+
+    // Insertion point
+    virtual void SetInsertionPoint(long pos);
+    virtual void SetInsertionPointEnd();
+    virtual long GetInsertionPoint() const;
+    virtual wxTextPos GetLastPosition() const;
+
+    virtual void SetSelection(long from, long to);
+    virtual void SelectAll();
+    virtual void SetEditable(bool editable);
+
+#if 0
+
+    // override streambuf method
+#if wxHAS_TEXT_WINDOW_STREAM
+    int overflow(int i);
+#endif // wxHAS_TEXT_WINDOW_STREAM
+
+    // stream-like insertion operators: these are always available, whether we
+    // were, or not, compiled with streambuf support
+    wxTextCtrl& operator<<(const wxString& s);
+    wxTextCtrl& operator<<(int i);
+    wxTextCtrl& operator<<(long i);
+    wxTextCtrl& operator<<(float f);
+    wxTextCtrl& operator<<(double d);
+    wxTextCtrl& operator<<(const wxChar c);
+#endif
+
+    // do the window-specific processing after processing the update event
+    virtual void DoUpdateWindowUI(wxUpdateUIEvent& event);
+
+    virtual bool ShouldInheritColours() const;
+
+    // wxWindow overrides
+    virtual bool SetFont(const wxFont& font);
+
+    // search control generic only
+    void SetSearchBitmap( const wxBitmap& bitmap );
+    void SetCancelBitmap( const wxBitmap& bitmap );
+#if wxUSE_MENUS
+    void SetSearchMenuBitmap( const wxBitmap& bitmap );
+#endif // wxUSE_MENUS
+
+protected:
+    virtual void DoSetValue(const wxString& value, int flags = 0);
+
+    // override the base class virtuals involved into geometry calculations
+    virtual wxSize DoGetBestSize() const;
+    virtual void DoMoveWindow(int x, int y, int width, int height);
+    virtual void LayoutControls(int x, int y, int width, int height);
+
+    virtual void RecalcBitmaps();
+
+    void Init();
+
+    virtual wxBitmap RenderSearchBitmap( int x, int y, bool renderDrop );
+    virtual wxBitmap RenderCancelBitmap( int x, int y );
+
+    virtual void OnSearchButton( wxCommandEvent& event );
+
+    void OnSetFocus( wxFocusEvent& event );
+    void OnSize( wxSizeEvent& event );
+
+    bool HasMenu() const
+    {
+#if wxUSE_MENUS
+        return m_menu != NULL;
+#else // !wxUSE_MENUS
+        return false;
+#endif // wxUSE_MENUS/!wxUSE_MENUS
+    }
+
+private:
+    friend class wxSearchButton;
+
+#if wxUSE_MENUS
+    void PopupSearchMenu();
+#endif // wxUSE_MENUS
+
+    // the subcontrols
+    wxSearchTextCtrl *m_text;
+    wxSearchButton *m_searchButton;
+    wxSearchButton *m_cancelButton;
+#if wxUSE_MENUS
+    wxMenu *m_menu;
+#endif // wxUSE_MENUS
+
+    bool m_searchButtonVisible;
+    bool m_cancelButtonVisible;
+
+    bool m_searchBitmapUser;
+    bool m_cancelBitmapUser;
+#if wxUSE_MENUS
+    bool m_searchMenuBitmapUser;
+#endif // wxUSE_MENUS
+
+    wxBitmap m_searchBitmap;
+    wxBitmap m_cancelBitmap;
+#if wxUSE_MENUS
+    wxBitmap m_searchMenuBitmap;
+#endif // wxUSE_MENUS
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxSearchCtrl)
+
+    DECLARE_EVENT_TABLE()
+};
+
+#endif // wxUSE_SEARCHCTRL
+
+#endif // _WX_GENERIC_SEARCHCTRL_H_
+

wxWidgets/include/wx/generic/statline.h

@@ -0,0 +1,62 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        generic/statline.h
+// Purpose:     a generic wxStaticLine class
+// Author:      Vadim Zeitlin
+// Created:     28.06.99
+// Version:     $Id: statline.h 43874 2006-12-09 14:52:59Z VZ $
+// Copyright:   (c) 1998 Vadim Zeitlin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_STATLINE_H_
+#define _WX_GENERIC_STATLINE_H_
+
+class wxStaticBox;
+
+// ----------------------------------------------------------------------------
+// wxStaticLine
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStaticLine : public wxStaticLineBase
+{
+    DECLARE_DYNAMIC_CLASS(wxStaticLine)
+
+public:
+    // constructors and pseudo-constructors
+    wxStaticLine() { m_statbox = NULL; }
+
+    wxStaticLine( wxWindow *parent,
+                  wxWindowID id = wxID_ANY,
+                  const wxPoint &pos = wxDefaultPosition,
+                  const wxSize &size = wxDefaultSize,
+                  long style = wxLI_HORIZONTAL,
+                  const wxString &name = wxStaticLineNameStr )
+    {
+        Create(parent, id, pos, size, style, name);
+    }
+
+    virtual ~wxStaticLine();
+
+    bool Create( wxWindow *parent,
+                 wxWindowID id = wxID_ANY,
+                 const wxPoint &pos = wxDefaultPosition,
+                 const wxSize &size = wxDefaultSize,
+                 long style = wxLI_HORIZONTAL,
+                 const wxString &name = wxStaticLineNameStr );
+
+    // it's necessary to override this wxWindow function because we
+    // will want to return the main widget for m_statbox
+    //
+    WXWidget GetMainWidget() const;
+
+    // override wxWindow methods to make things work
+    virtual void DoSetSize(int x, int y, int width, int height,
+                           int sizeFlags = wxSIZE_AUTO);
+    virtual void DoMoveWindow(int x, int y, int width, int height);
+protected:
+    // we implement the static line using a static box
+    wxStaticBox *m_statbox;
+};
+
+#endif // _WX_GENERIC_STATLINE_H_
+

wxWidgets/include/wx/generic/statusbr.h

@@ -0,0 +1,107 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/statusbr.h
+// Purpose:     wxStatusBarGeneric class
+// Author:      Julian Smart
+// Modified by: VZ at 05.02.00 to derive from wxStatusBarBase
+// Created:     01/02/97
+// RCS-ID:      $Id: statusbr.h 41200 2006-09-13 19:10:31Z ABX $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_STATUSBR_H_
+#define _WX_GENERIC_STATUSBR_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_STATUSBAR
+
+#include "wx/pen.h"
+#include "wx/arrstr.h"
+
+class WXDLLEXPORT wxStatusBarGeneric : public wxStatusBarBase
+{
+public:
+    wxStatusBarGeneric() { Init(); }
+    wxStatusBarGeneric(wxWindow *parent,
+                       wxWindowID winid = wxID_ANY,
+                       long style = wxST_SIZEGRIP,
+                       const wxString& name = wxStatusBarNameStr)
+    {
+        Init();
+
+        Create(parent, winid, style, name);
+    }
+
+    virtual ~wxStatusBarGeneric();
+
+    bool Create(wxWindow *parent, wxWindowID winid = wxID_ANY,
+                long style = wxST_SIZEGRIP,
+                const wxString& name = wxStatusBarNameStr);
+
+    // Create status line
+    virtual void SetFieldsCount(int number = 1,
+                                const int *widths = (const int *) NULL);
+
+    // Set status line text
+    virtual void SetStatusText(const wxString& text, int number = 0);
+    virtual wxString GetStatusText(int number = 0) const;
+
+    // Set status line widths
+    virtual void SetStatusWidths(int n, const int widths_field[]);
+
+    // Get the position and size of the field's internal bounding rectangle
+    virtual bool GetFieldRect(int i, wxRect& rect) const;
+
+    // sets the minimal vertical size of the status bar
+    virtual void SetMinHeight(int height);
+
+    virtual int GetBorderX() const { return m_borderX; }
+    virtual int GetBorderY() const { return m_borderY; }
+
+    ////////////////////////////////////////////////////////////////////////
+    // Implementation
+
+    virtual void DrawFieldText(wxDC& dc, int i);
+    virtual void DrawField(wxDC& dc, int i);
+
+    void SetBorderX(int x);
+    void SetBorderY(int y);
+
+    void OnPaint(wxPaintEvent& event);
+
+    void OnLeftDown(wxMouseEvent& event);
+    void OnRightDown(wxMouseEvent& event);
+
+    virtual void InitColours();
+
+    // Responds to colour changes
+    void OnSysColourChanged(wxSysColourChangedEvent& event);
+
+protected:
+    // common part of all ctors
+    void Init();
+
+    wxArrayString     m_statusStrings;
+
+    // the last known width of the client rect (used to rebuild cache)
+    int               m_lastClientWidth;
+    // the widths of the status bar panes in pixels
+    wxArrayInt        m_widthsAbs;
+
+    int               m_borderX;
+    int               m_borderY;
+    wxPen             m_mediumShadowPen;
+    wxPen             m_hilightPen;
+
+    virtual wxSize DoGetBestSize() const;
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxStatusBarGeneric)
+};
+
+#endif // wxUSE_STATUSBAR
+
+#endif
+    // _WX_GENERIC_STATUSBR_H_

wxWidgets/include/wx/generic/tabg.h

@@ -0,0 +1,363 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        tabg.h
+// Purpose:     Generic tabbed dialogs
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: tabg.h 41020 2006-09-05 20:47:48Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __TABGH_G__
+#define __TABGH_G__
+
+#define WXTAB_VERSION   1.1
+
+#include "wx/hashmap.h"
+#include "wx/string.h"
+#include "wx/dialog.h"
+#include "wx/panel.h"
+#include "wx/list.h"
+
+class WXDLLEXPORT wxTabView;
+
+/*
+ * A wxTabControl is the internal and visual representation
+ * of the tab.
+ */
+
+class WXDLLEXPORT wxTabControl: public wxObject
+{
+DECLARE_DYNAMIC_CLASS(wxTabControl)
+public:
+    wxTabControl(wxTabView *v = (wxTabView *) NULL);
+    virtual ~wxTabControl(void);
+
+    virtual void OnDraw(wxDC& dc, bool lastInRow);
+    void SetLabel(const wxString& str) { m_controlLabel = str; }
+    wxString GetLabel(void) const { return m_controlLabel; }
+
+    void SetFont(const wxFont& f) { m_labelFont = f; }
+    wxFont *GetFont(void) const { return (wxFont*) & m_labelFont; }
+
+    void SetSelected(bool sel) { m_isSelected = sel; }
+    bool IsSelected(void) const { return m_isSelected; }
+
+    void SetPosition(int x, int y) { m_offsetX = x; m_offsetY = y; }
+    void SetSize(int x, int y) { m_width = x; m_height = y; }
+
+    void SetRowPosition(int r) { m_rowPosition = r; }
+    int GetRowPosition() const { return m_rowPosition; }
+    void SetColPosition(int c) { m_colPosition = c; }
+    int GetColPosition() const { return m_colPosition; }
+
+    int GetX(void) const { return m_offsetX; }
+    int GetY(void) const { return m_offsetY; }
+    int GetWidth(void) const { return m_width; }
+    int GetHeight(void) const { return m_height; }
+
+    int GetId(void) const { return m_id; }
+    void SetId(int i) { m_id = i; }
+
+    virtual bool HitTest(int x, int y) const ;
+
+protected:
+    wxTabView*      m_view;
+    wxString        m_controlLabel;
+    bool            m_isSelected;
+    wxFont          m_labelFont;
+    int             m_offsetX; // Offsets from top-left of tab view area (the area below the tabs)
+    int             m_offsetY;
+    int             m_width;
+    int             m_height;
+    int             m_id;
+    int             m_rowPosition; // Position in row from 0
+    int             m_colPosition; // Position in col from 0
+};
+
+/*
+ * Each wxTabLayer is a list of tabs. E.g. there
+ * are 3 layers in the MS Word Options dialog.
+ */
+
+class WXDLLEXPORT wxTabLayer: public wxList
+{
+};
+
+/*
+ * The wxTabView controls and draws the tabbed object
+ */
+
+WX_DECLARE_LIST(wxTabLayer, wxTabLayerList);
+
+#define wxTAB_STYLE_DRAW_BOX         1   // Draws 3D boxes round tab layers
+#define wxTAB_STYLE_COLOUR_INTERIOR  2   // Colours interior of tabs, otherwise draws outline
+
+class WXDLLEXPORT wxTabView: public wxObject
+{
+DECLARE_DYNAMIC_CLASS(wxTabView)
+public:
+  wxTabView(long style = wxTAB_STYLE_DRAW_BOX | wxTAB_STYLE_COLOUR_INTERIOR);
+  virtual ~wxTabView();
+
+  inline int GetNumberOfLayers() const { return m_layers.GetCount(); }
+#if WXWIN_COMPATIBILITY_2_4
+  inline wxList& GetLayers() { return *(wxList *)&m_layers; }
+#else
+  inline wxTabLayerList& GetLayers() { return m_layers; }
+#endif
+
+  inline void SetWindow(wxWindow* wnd) { m_window = wnd; }
+  inline wxWindow* GetWindow(void) const { return m_window; }
+
+  // Automatically positions tabs
+  wxTabControl *AddTab(int id, const wxString& label, wxTabControl *existingTab = (wxTabControl *) NULL);
+
+  // Remove the tab without deleting the window
+  bool RemoveTab(int id);
+
+  void ClearTabs(bool deleteTabs = true);
+
+  bool SetTabText(int id, const wxString& label);
+  wxString GetTabText(int id) const;
+
+  // Layout tabs (optional, e.g. if resizing window)
+  void LayoutTabs();
+
+  // Draw all tabs
+  virtual void Draw(wxDC& dc);
+
+  // Process mouse event, return false if we didn't process it
+  virtual bool OnEvent(wxMouseEvent& event);
+
+  // Called when a tab is activated
+  virtual void OnTabActivate(int activateId, int deactivateId);
+  // Allows vetoing
+  virtual bool OnTabPreActivate(int WXUNUSED(activateId), int WXUNUSED(deactivateId) ) { return true; };
+
+  // Allows use of application-supplied wxTabControl classes.
+  virtual wxTabControl *OnCreateTabControl(void) { return new wxTabControl(this); }
+
+  void SetHighlightColour(const wxColour& col);
+  void SetShadowColour(const wxColour& col);
+  void SetBackgroundColour(const wxColour& col);
+  inline void SetTextColour(const wxColour& col) { m_textColour = col; }
+
+  inline wxColour GetHighlightColour(void) const { return m_highlightColour; }
+  inline wxColour GetShadowColour(void) const { return m_shadowColour; }
+  inline wxColour GetBackgroundColour(void) const { return m_backgroundColour; }
+  inline wxColour GetTextColour(void) const { return m_textColour; }
+  inline const wxPen *GetHighlightPen(void) const { return m_highlightPen; }
+  inline const wxPen *GetShadowPen(void) const { return m_shadowPen; }
+  inline const wxPen *GetBackgroundPen(void) const { return m_backgroundPen; }
+  inline const wxBrush *GetBackgroundBrush(void) const { return m_backgroundBrush; }
+
+  inline void SetViewRect(const wxRect& rect) { m_tabViewRect = rect; }
+  inline wxRect GetViewRect(void) const { return m_tabViewRect; }
+
+  // Calculate tab width to fit to view, and optionally adjust the view
+  // to fit the tabs exactly.
+  int CalculateTabWidth(int noTabs, bool adjustView = false);
+
+  inline void SetTabStyle(long style) { m_tabStyle = style; }
+  inline long GetTabStyle(void) const { return m_tabStyle; }
+
+  inline void SetTabSize(int w, int h) { m_tabWidth = w; m_tabHeight = h; }
+  inline int GetTabWidth(void) const { return m_tabWidth; }
+  inline int GetTabHeight(void) const { return m_tabHeight; }
+  inline void SetTabSelectionHeight(int h) { m_tabSelectionHeight = h; }
+  inline int GetTabSelectionHeight(void) const { return m_tabSelectionHeight; }
+
+  // Returns the total height of the tabs component -- this may be several
+  // times the height of a tab, if there are several tab layers (rows).
+  int GetTotalTabHeight();
+
+  inline int GetTopMargin(void) const { return m_topMargin; }
+  inline void SetTopMargin(int margin) { m_topMargin = margin; }
+
+  void SetTabSelection(int sel, bool activateTool = true);
+  inline int GetTabSelection() const { return m_tabSelection; }
+
+  // Find tab control for id
+  wxTabControl *FindTabControlForId(int id) const ;
+
+  // Find tab control for layer, position (starting from zero)
+  wxTabControl *FindTabControlForPosition(int layer, int position) const ;
+
+  inline int GetHorizontalTabOffset() const { return m_tabHorizontalOffset; }
+  inline int GetHorizontalTabSpacing() const { return m_tabHorizontalSpacing; }
+  inline void SetHorizontalTabOffset(int sp) { m_tabHorizontalOffset = sp; }
+  inline void SetHorizontalTabSpacing(int sp) { m_tabHorizontalSpacing = sp; }
+
+  inline void SetVerticalTabTextSpacing(int s) { m_tabVerticalTextSpacing = s; }
+  inline int GetVerticalTabTextSpacing() const { return m_tabVerticalTextSpacing; }
+
+  inline wxFont *GetTabFont() const { return (wxFont*) & m_tabFont; }
+  inline void SetTabFont(const wxFont& f) { m_tabFont = f; }
+
+  inline wxFont *GetSelectedTabFont() const { return (wxFont*) & m_tabSelectedFont; }
+  inline void SetSelectedTabFont(const wxFont& f) { m_tabSelectedFont = f; }
+  // Find the node and the column at which this control is positioned.
+  wxList::compatibility_iterator FindTabNodeAndColumn(wxTabControl *control, int *col) const ;
+
+  // Do the necessary to change to this tab
+  virtual bool ChangeTab(wxTabControl *control);
+
+  // Move the selected tab to the bottom layer, if necessary,
+  // without calling app activation code
+  bool MoveSelectionTab(wxTabControl *control);
+
+  inline int GetNumberOfTabs() const { return m_noTabs; }
+
+protected:
+   // List of layers, from front to back.
+   wxTabLayerList   m_layers;
+
+   // Selected tab
+   int              m_tabSelection;
+
+   // Usual tab height
+   int              m_tabHeight;
+
+   // The height of the selected tab
+   int              m_tabSelectionHeight;
+
+   // Usual tab width
+   int              m_tabWidth;
+
+   // Space between tabs
+   int              m_tabHorizontalSpacing;
+
+   // Space between top of normal tab and text
+   int              m_tabVerticalTextSpacing;
+
+   // Horizontal offset of each tab row above the first
+   int              m_tabHorizontalOffset;
+
+   // The distance between the bottom of the first tab row
+   // and the top of the client area (i.e. the margin)
+   int              m_topMargin;
+
+   // The position and size of the view above which the tabs are placed.
+   // I.e., the internal client area of the sheet.
+   wxRect           m_tabViewRect;
+
+   // Bitlist of styles
+   long             m_tabStyle;
+
+   // Colours
+   wxColour         m_highlightColour;
+   wxColour         m_shadowColour;
+   wxColour         m_backgroundColour;
+   wxColour         m_textColour;
+
+   // Pen and brush cache
+   const wxPen*     m_highlightPen;
+   const wxPen*     m_shadowPen;
+   const wxPen*     m_backgroundPen;
+   const wxBrush*   m_backgroundBrush;
+
+   wxFont           m_tabFont;
+   wxFont           m_tabSelectedFont;
+
+   int              m_noTabs;
+
+   wxWindow*        m_window;
+};
+
+/*
+ * A dialog box class that is tab-friendly
+ */
+
+class WXDLLEXPORT wxTabbedDialog : public wxDialog
+{
+    DECLARE_DYNAMIC_CLASS(wxTabbedDialog)
+
+public:
+    wxTabbedDialog(wxWindow *parent,
+                   wxWindowID id,
+                   const wxString& title,
+                   const wxPoint& pos = wxDefaultPosition,
+                   const wxSize& size = wxDefaultSize,
+                   long windowStyle = wxDEFAULT_DIALOG_STYLE,
+                   const wxString& name = wxDialogNameStr);
+    virtual ~wxTabbedDialog();
+
+    wxTabView *GetTabView() const { return m_tabView; }
+    void SetTabView(wxTabView *v) { m_tabView = v; }
+
+    void OnCloseWindow(wxCloseEvent& event);
+    void OnMouseEvent(wxMouseEvent& event);
+    void OnPaint(wxPaintEvent& event);
+
+protected:
+    wxTabView*   m_tabView;
+
+private:
+    DECLARE_EVENT_TABLE()
+};
+
+/*
+ * A panel class that is tab-friendly
+ */
+
+class WXDLLEXPORT wxTabbedPanel : public wxPanel
+{
+    DECLARE_DYNAMIC_CLASS(wxTabbedPanel)
+
+public:
+    wxTabbedPanel(wxWindow *parent,
+                  wxWindowID id,
+                  const wxPoint& pos = wxDefaultPosition,
+                  const wxSize& size = wxDefaultSize,
+                  long windowStyle = 0,
+                  const wxString& name = wxPanelNameStr);
+    virtual ~wxTabbedPanel();
+
+    wxTabView *GetTabView() const { return m_tabView; }
+    void SetTabView(wxTabView *v) { m_tabView = v; }
+
+    void OnMouseEvent(wxMouseEvent& event);
+    void OnPaint(wxPaintEvent& event);
+
+protected:
+    wxTabView*   m_tabView;
+
+private:
+    DECLARE_EVENT_TABLE()
+};
+
+WX_DECLARE_HASH_MAP(int, wxWindow*, wxIntegerHash, wxIntegerEqual,
+                    wxIntToWindowHashMap);
+
+class WXDLLEXPORT wxPanelTabView : public wxTabView
+{
+    DECLARE_DYNAMIC_CLASS(wxPanelTabView)
+
+public:
+    wxPanelTabView(wxPanel *pan, long style = wxTAB_STYLE_DRAW_BOX | wxTAB_STYLE_COLOUR_INTERIOR);
+    virtual ~wxPanelTabView(void);
+
+    // Called when a tab is activated
+    virtual void OnTabActivate(int activateId, int deactivateId);
+
+    // Specific to this class
+    void AddTabWindow(int id, wxWindow *window);
+    wxWindow *GetTabWindow(int id) const ;
+    void ClearWindows(bool deleteWindows = true);
+    wxWindow *GetCurrentWindow() const { return m_currentWindow; }
+
+    void ShowWindowForTab(int id);
+    // wxList& GetWindows() const { return (wxList&) m_tabWindows; }
+
+protected:
+    // List of panels, one for each tab. Indexed
+    // by tab ID.
+    wxIntToWindowHashMap m_tabWindows;
+    wxWindow*            m_currentWindow;
+    wxPanel*             m_panel;
+};
+
+#endif
+

wxWidgets/include/wx/generic/textdlgg.h

@@ -0,0 +1,113 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        textdlgg.h
+// Purpose:     wxTextEntryDialog class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: textdlgg.h 49563 2007-10-31 20:46:21Z VZ $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __TEXTDLGH_G__
+#define __TEXTDLGH_G__
+
+#include "wx/defs.h"
+
+#if wxUSE_TEXTDLG
+
+#include "wx/dialog.h"
+
+#if wxUSE_VALIDATORS
+#include "wx/valtext.h"
+#endif
+
+class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
+
+extern WXDLLEXPORT_DATA(const wxChar) wxGetTextFromUserPromptStr[];
+extern WXDLLEXPORT_DATA(const wxChar) wxGetPasswordFromUserPromptStr[];
+
+#define wxTextEntryDialogStyle (wxOK | wxCANCEL | wxCENTRE | wxWS_EX_VALIDATE_RECURSIVELY)
+
+// ----------------------------------------------------------------------------
+// wxTextEntryDialog: a dialog with text control, [ok] and [cancel] buttons
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxTextEntryDialog : public wxDialog
+{
+public:
+    wxTextEntryDialog(wxWindow *parent,
+                      const wxString& message,
+                      const wxString& caption = wxGetTextFromUserPromptStr,
+                      const wxString& value = wxEmptyString,
+                      long style = wxTextEntryDialogStyle,
+                      const wxPoint& pos = wxDefaultPosition);
+
+    void SetValue(const wxString& val);
+    wxString GetValue() const { return m_value; }
+
+#if wxUSE_VALIDATORS
+    void SetTextValidator( const wxTextValidator& validator );
+    void SetTextValidator( long style = wxFILTER_NONE );
+    wxTextValidator* GetTextValidator() { return (wxTextValidator*)m_textctrl->GetValidator(); }
+#endif
+  // wxUSE_VALIDATORS
+
+    // implementation only
+    void OnOK(wxCommandEvent& event);
+
+protected:
+    wxTextCtrl *m_textctrl;
+    wxString    m_value;
+    long        m_dialogStyle;
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS(wxTextEntryDialog)
+    DECLARE_NO_COPY_CLASS(wxTextEntryDialog)
+};
+
+// ----------------------------------------------------------------------------
+// wxPasswordEntryDialog: dialog with password control, [ok] and [cancel]
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxPasswordEntryDialog : public wxTextEntryDialog
+{
+public:
+    wxPasswordEntryDialog(wxWindow *parent,
+                      const wxString& message,
+                      const wxString& caption = wxGetPasswordFromUserPromptStr,
+                      const wxString& value = wxEmptyString,
+                      long style = wxTextEntryDialogStyle,
+                      const wxPoint& pos = wxDefaultPosition);
+private:
+    DECLARE_DYNAMIC_CLASS(wxPasswordEntryDialog)
+    DECLARE_NO_COPY_CLASS(wxPasswordEntryDialog)
+};
+
+// ----------------------------------------------------------------------------
+// function to get a string from user
+// ----------------------------------------------------------------------------
+
+wxString WXDLLEXPORT
+wxGetTextFromUser(const wxString& message,
+                  const wxString& caption = wxGetTextFromUserPromptStr,
+                  const wxString& default_value = wxEmptyString,
+                  wxWindow *parent = (wxWindow *) NULL,
+                  wxCoord x = wxDefaultCoord,
+                  wxCoord y = wxDefaultCoord,
+                  bool centre = true);
+
+wxString WXDLLEXPORT
+wxGetPasswordFromUser(const wxString& message,
+                      const wxString& caption = wxGetPasswordFromUserPromptStr,
+                      const wxString& default_value = wxEmptyString,
+                      wxWindow *parent = (wxWindow *) NULL,
+                      wxCoord x = wxDefaultCoord,
+                      wxCoord y = wxDefaultCoord,
+                      bool centre = true);
+
+#endif
+    // wxUSE_TEXTDLG
+#endif
+    // __TEXTDLGH_G__

wxWidgets/include/wx/generic/timer.h

@@ -0,0 +1,45 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        timer.h
+// Purpose:     Generic implementation of wxTimer class
+// Author:      Vaclav Slavik
+// Id:          $Id: timer.h 41020 2006-09-05 20:47:48Z VZ $
+// Copyright:   (c) Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef __WX_TIMER_H__
+#define __WX_TIMER_H__
+
+//-----------------------------------------------------------------------------
+// wxTimer
+//-----------------------------------------------------------------------------
+
+class wxTimerDesc;
+
+class WXDLLEXPORT wxTimer : public wxTimerBase
+{
+public:
+    wxTimer() { Init(); }
+    wxTimer(wxEvtHandler *owner, int timerid = -1) : wxTimerBase(owner, timerid)
+        { Init(); }
+    virtual ~wxTimer();
+
+    virtual bool Start(int millisecs = -1, bool oneShot = false);
+    virtual void Stop();
+
+    virtual bool IsRunning() const;
+
+    // implementation
+    static void NotifyTimers();
+
+protected:
+    void Init();
+
+private:
+    wxTimerDesc *m_desc;
+
+    DECLARE_ABSTRACT_CLASS(wxTimer)
+};
+
+#endif // __WX_TIMER_H__

wxWidgets/include/wx/generic/treectlg.h

@@ -0,0 +1,383 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/treectlg.h
+// Purpose:     wxTreeCtrl class
+// Author:      Robert Roebling
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id: treectlg.h 49804 2007-11-10 01:09:42Z VZ $
+// Copyright:   (c) 1997,1998 Robert Roebling
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _GENERIC_TREECTRL_H_
+#define _GENERIC_TREECTRL_H_
+
+#if wxUSE_TREECTRL
+
+#include "wx/scrolwin.h"
+#include "wx/pen.h"
+
+// -----------------------------------------------------------------------------
+// forward declaration
+// -----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_FWD_CORE wxGenericTreeItem;
+
+class WXDLLIMPEXP_FWD_CORE wxTreeItemData;
+
+class WXDLLIMPEXP_FWD_CORE wxTreeRenameTimer;
+class WXDLLIMPEXP_FWD_CORE wxTreeFindTimer;
+class WXDLLIMPEXP_FWD_CORE wxTreeTextCtrl;
+class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
+
+// -----------------------------------------------------------------------------
+// wxGenericTreeCtrl - the tree control
+// -----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericTreeCtrl : public wxTreeCtrlBase,
+                                      public wxScrollHelper
+{
+public:
+    // creation
+    // --------
+
+    wxGenericTreeCtrl() : wxTreeCtrlBase(), wxScrollHelper(this) { Init(); }
+
+    wxGenericTreeCtrl(wxWindow *parent, wxWindowID id = wxID_ANY,
+               const wxPoint& pos = wxDefaultPosition,
+               const wxSize& size = wxDefaultSize,
+               long style = wxTR_DEFAULT_STYLE,
+               const wxValidator &validator = wxDefaultValidator,
+               const wxString& name = wxTreeCtrlNameStr)
+        : wxTreeCtrlBase(),
+          wxScrollHelper(this)
+    {
+        Init();
+        Create(parent, id, pos, size, style, validator, name);
+    }
+
+    virtual ~wxGenericTreeCtrl();
+
+    bool Create(wxWindow *parent, wxWindowID id = wxID_ANY,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxTR_DEFAULT_STYLE,
+                const wxValidator &validator = wxDefaultValidator,
+                const wxString& name = wxTreeCtrlNameStr);
+
+
+    // implement base class pure virtuals
+    // ----------------------------------
+
+    virtual unsigned int GetCount() const;
+
+    virtual unsigned int GetIndent() const { return m_indent; }
+    virtual void SetIndent(unsigned int indent);
+
+
+    virtual void SetImageList(wxImageList *imageList);
+    virtual void SetStateImageList(wxImageList *imageList);
+
+    virtual wxString GetItemText(const wxTreeItemId& item) const;
+    virtual int GetItemImage(const wxTreeItemId& item,
+                     wxTreeItemIcon which = wxTreeItemIcon_Normal) const;
+    virtual wxTreeItemData *GetItemData(const wxTreeItemId& item) const;
+    virtual wxColour GetItemTextColour(const wxTreeItemId& item) const;
+    virtual wxColour GetItemBackgroundColour(const wxTreeItemId& item) const;
+    virtual wxFont GetItemFont(const wxTreeItemId& item) const;
+
+    virtual void SetItemText(const wxTreeItemId& item, const wxString& text);
+    virtual void SetItemImage(const wxTreeItemId& item,
+                              int image,
+                              wxTreeItemIcon which = wxTreeItemIcon_Normal);
+    virtual void SetItemData(const wxTreeItemId& item, wxTreeItemData *data);
+
+    virtual void SetItemHasChildren(const wxTreeItemId& item, bool has = true);
+    virtual void SetItemBold(const wxTreeItemId& item, bool bold = true);
+    virtual void SetItemDropHighlight(const wxTreeItemId& item, bool highlight = true);
+    virtual void SetItemTextColour(const wxTreeItemId& item, const wxColour& col);
+    virtual void SetItemBackgroundColour(const wxTreeItemId& item, const wxColour& col);
+    virtual void SetItemFont(const wxTreeItemId& item, const wxFont& font);
+
+    virtual bool IsVisible(const wxTreeItemId& item) const;
+    virtual bool ItemHasChildren(const wxTreeItemId& item) const;
+    virtual bool IsExpanded(const wxTreeItemId& item) const;
+    virtual bool IsSelected(const wxTreeItemId& item) const;
+    virtual bool IsBold(const wxTreeItemId& item) const;
+
+    virtual size_t GetChildrenCount(const wxTreeItemId& item,
+                                    bool recursively = true) const;
+
+    // navigation
+    // ----------
+
+    virtual wxTreeItemId GetRootItem() const { return m_anchor; }
+    virtual wxTreeItemId GetSelection() const { return m_current; }
+    virtual size_t GetSelections(wxArrayTreeItemIds&) const;
+
+    virtual wxTreeItemId GetItemParent(const wxTreeItemId& item) const;
+    virtual wxTreeItemId GetFirstChild(const wxTreeItemId& item,
+                                       wxTreeItemIdValue& cookie) const;
+    virtual wxTreeItemId GetNextChild(const wxTreeItemId& item,
+                                      wxTreeItemIdValue& cookie) const;
+    virtual wxTreeItemId GetLastChild(const wxTreeItemId& item) const;
+    virtual wxTreeItemId GetNextSibling(const wxTreeItemId& item) const;
+    virtual wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const;
+
+    virtual wxTreeItemId GetFirstVisibleItem() const;
+    virtual wxTreeItemId GetNextVisible(const wxTreeItemId& item) const;
+    virtual wxTreeItemId GetPrevVisible(const wxTreeItemId& item) const;
+
+
+    // operations
+    // ----------
+
+    virtual wxTreeItemId AddRoot(const wxString& text,
+                         int image = -1, int selectedImage = -1,
+                         wxTreeItemData *data = NULL);
+
+    virtual void Delete(const wxTreeItemId& item);
+    virtual void DeleteChildren(const wxTreeItemId& item);
+    virtual void DeleteAllItems();
+
+    virtual void Expand(const wxTreeItemId& item);
+    virtual void Collapse(const wxTreeItemId& item);
+    virtual void CollapseAndReset(const wxTreeItemId& item);
+    virtual void Toggle(const wxTreeItemId& item);
+
+    virtual void Unselect();
+    virtual void UnselectAll();
+    virtual void SelectItem(const wxTreeItemId& item, bool select = true);
+
+    virtual void EnsureVisible(const wxTreeItemId& item);
+    virtual void ScrollTo(const wxTreeItemId& item);
+
+    virtual wxTextCtrl *EditLabel(const wxTreeItemId& item,
+                          wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
+    virtual wxTextCtrl *GetEditControl() const;
+    virtual void EndEditLabel(const wxTreeItemId& item,
+                              bool discardChanges = false);
+
+    virtual void SortChildren(const wxTreeItemId& item);
+
+    // items geometry
+    // --------------
+
+    virtual bool GetBoundingRect(const wxTreeItemId& item,
+                                 wxRect& rect,
+                                 bool textOnly = false) const;
+
+
+    // this version specific methods
+    // -----------------------------
+
+    wxImageList *GetButtonsImageList() const { return m_imageListButtons; }
+    void SetButtonsImageList(wxImageList *imageList);
+    void AssignButtonsImageList(wxImageList *imageList);
+
+    void SetDropEffectAboveItem( bool above = false ) { m_dropEffectAboveItem = above; }
+    bool GetDropEffectAboveItem() const { return m_dropEffectAboveItem; }
+
+    wxTreeItemId GetNext(const wxTreeItemId& item) const;
+
+#if WXWIN_COMPATIBILITY_2_6
+    // use EditLabel() instead
+    void Edit( const wxTreeItemId& item ) { EditLabel(item); }
+#endif // WXWIN_COMPATIBILITY_2_6
+
+#if WXWIN_COMPATIBILITY_2_4
+    // deprecated functions: use Set/GetItemImage directly
+    wxDEPRECATED( int GetItemSelectedImage(const wxTreeItemId& item) const );
+    wxDEPRECATED( void SetItemSelectedImage(const wxTreeItemId& item, int image) );
+
+    // use the versions taking wxTreeItemIdValue cookies (note that
+    // GetNextChild() is not inside wxDEPRECATED on purpose, as otherwise we
+    // get twice as many warnings without any added benefit: it is always used
+    // with GetFirstChild() anyhow)
+    wxDEPRECATED( wxTreeItemId GetFirstChild(const wxTreeItemId& item,
+                                             long& cookie) const );
+    wxTreeItemId GetNextChild(const wxTreeItemId& item,
+                              long& cookie) const;
+#endif // WXWIN_COMPATIBILITY_2_4
+
+    // implementation only from now on
+
+    // overridden base class virtuals
+    virtual bool SetBackgroundColour(const wxColour& colour);
+    virtual bool SetForegroundColour(const wxColour& colour);
+
+    virtual void Freeze();
+    virtual void Thaw();
+    virtual void Refresh(bool eraseBackground = true, const wxRect *rect = NULL);
+
+    virtual bool SetFont( const wxFont &font );
+    virtual void SetWindowStyle(const long styles);
+
+    // callbacks
+    void OnPaint( wxPaintEvent &event );
+    void OnSetFocus( wxFocusEvent &event );
+    void OnKillFocus( wxFocusEvent &event );
+    void OnChar( wxKeyEvent &event );
+    void OnMouse( wxMouseEvent &event );
+    void OnGetToolTip( wxTreeEvent &event );
+    void OnSize( wxSizeEvent &event );
+    void OnInternalIdle( );
+
+    virtual wxVisualAttributes GetDefaultAttributes() const
+    {
+        return GetClassDefaultAttributes(GetWindowVariant());
+    }
+
+    static wxVisualAttributes
+    GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
+
+    // implementation helpers
+    void AdjustMyScrollbars();
+
+    WX_FORWARD_TO_SCROLL_HELPER()
+
+protected:
+    friend class wxGenericTreeItem;
+    friend class wxTreeRenameTimer;
+    friend class wxTreeFindTimer;
+    friend class wxTreeTextCtrl;
+
+    wxFont               m_normalFont;
+    wxFont               m_boldFont;
+
+    wxGenericTreeItem   *m_anchor;
+    wxGenericTreeItem   *m_current,
+                        *m_key_current,
+                        // A hint to select a parent item after deleting a child
+                        *m_select_me;
+    unsigned short       m_indent;
+    int                  m_lineHeight;
+    wxPen                m_dottedPen;
+    wxBrush             *m_hilightBrush,
+                        *m_hilightUnfocusedBrush;
+    bool                 m_hasFocus;
+    bool                 m_dirty;
+    bool                 m_ownsImageListButtons;
+    bool                 m_isDragging; // true between BEGIN/END drag events
+    bool                 m_lastOnSame;  // last click on the same item as prev
+    wxImageList         *m_imageListButtons;
+
+    int                  m_freezeCount;
+    int                  m_dragCount;
+    wxPoint              m_dragStart;
+    wxGenericTreeItem   *m_dropTarget;
+    wxCursor             m_oldCursor;  // cursor is changed while dragging
+    wxGenericTreeItem   *m_oldSelection;
+    wxGenericTreeItem   *m_underMouse; // for visual effects
+    wxTreeTextCtrl      *m_textCtrl;
+
+    wxTimer             *m_renameTimer;
+
+    // incremental search data
+    wxString             m_findPrefix;
+    wxTimer             *m_findTimer;
+
+    bool                 m_dropEffectAboveItem;
+
+    // the common part of all ctors
+    void Init();
+
+    // misc helpers
+    void SendDeleteEvent(wxGenericTreeItem *itemBeingDeleted);
+
+    void DrawBorder(const wxTreeItemId& item);
+    void DrawLine(const wxTreeItemId& item, bool below);
+    void DrawDropEffect(wxGenericTreeItem *item);
+
+    void DoSelectItem(const wxTreeItemId& id,
+                      bool unselect_others = true,
+                      bool extended_select = false);
+
+    virtual wxTreeItemId DoInsertItem(const wxTreeItemId& parent,
+                                      size_t previous,
+                                      const wxString& text,
+                                      int image,
+                                      int selectedImage,
+                                      wxTreeItemData *data);
+    virtual wxTreeItemId DoInsertAfter(const wxTreeItemId& parent,
+                                       const wxTreeItemId& idPrevious,
+                                       const wxString& text,
+                                       int image = -1, int selImage = -1,
+                                       wxTreeItemData *data = NULL);
+    virtual wxTreeItemId DoTreeHitTest(const wxPoint& point, int& flags) const;
+
+    // called by wxTextTreeCtrl when it marks itself for deletion
+    void ResetTextControl();
+
+    // find the first item starting with the given prefix after the given item
+    wxTreeItemId FindItem(const wxTreeItemId& id, const wxString& prefix) const;
+
+    bool HasButtons() const { return HasFlag(wxTR_HAS_BUTTONS); }
+
+    void CalculateLineHeight();
+    int  GetLineHeight(wxGenericTreeItem *item) const;
+    void PaintLevel( wxGenericTreeItem *item, wxDC& dc, int level, int &y );
+    void PaintItem( wxGenericTreeItem *item, wxDC& dc);
+
+    void CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y );
+    void CalculatePositions();
+    void CalculateSize( wxGenericTreeItem *item, wxDC &dc );
+
+    void RefreshSubtree( wxGenericTreeItem *item );
+    void RefreshLine( wxGenericTreeItem *item );
+
+    // redraw all selected items
+    void RefreshSelected();
+
+    // RefreshSelected() recursive helper
+    void RefreshSelectedUnder(wxGenericTreeItem *item);
+
+    void OnRenameTimer();
+    bool OnRenameAccept(wxGenericTreeItem *item, const wxString& value);
+    void OnRenameCancelled(wxGenericTreeItem *item);
+
+    void FillArray(wxGenericTreeItem*, wxArrayTreeItemIds&) const;
+    void SelectItemRange( wxGenericTreeItem *item1, wxGenericTreeItem *item2 );
+    bool TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select);
+    bool TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select);
+    void UnselectAllChildren( wxGenericTreeItem *item );
+    void ChildrenClosing(wxGenericTreeItem* item);
+
+    void DoDirtyProcessing();
+
+    virtual wxSize DoGetBestSize() const;
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS(wxGenericTreeCtrl)
+    DECLARE_NO_COPY_CLASS(wxGenericTreeCtrl)
+};
+
+#if !defined(__WXMSW__) || defined(__WXUNIVERSAL__)
+/*
+ * wxTreeCtrl has to be a real class or we have problems with
+ * the run-time information.
+ */
+
+class WXDLLEXPORT wxTreeCtrl: public wxGenericTreeCtrl
+{
+    DECLARE_DYNAMIC_CLASS(wxTreeCtrl)
+
+public:
+    wxTreeCtrl() {}
+
+    wxTreeCtrl(wxWindow *parent, wxWindowID id = wxID_ANY,
+               const wxPoint& pos = wxDefaultPosition,
+               const wxSize& size = wxDefaultSize,
+               long style = wxTR_DEFAULT_STYLE,
+               const wxValidator &validator = wxDefaultValidator,
+               const wxString& name = wxTreeCtrlNameStr)
+    : wxGenericTreeCtrl(parent, id, pos, size, style, validator, name)
+    {
+    }
+};
+#endif // !__WXMSW__ || __WXUNIVERSAL__
+
+#endif // wxUSE_TREECTRL
+
+#endif // _GENERIC_TREECTRL_H_

wxWidgets/include/wx/generic/wizard.h

@@ -0,0 +1,142 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/wizard.h
+// Purpose:     declaration of generic wxWizard class
+// Author:      Vadim Zeitlin
+// Modified by: Robert Vazan (sizers)
+// Created:     28.09.99
+// RCS-ID:      $Id: wizard.h 49563 2007-10-31 20:46:21Z VZ $
+// Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_WIZARD_H_
+#define _WX_GENERIC_WIZARD_H_
+
+// ----------------------------------------------------------------------------
+// wxWizard
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_FWD_CORE wxButton;
+class WXDLLIMPEXP_FWD_CORE wxStaticBitmap;
+class WXDLLIMPEXP_FWD_ADV wxWizardEvent;
+class WXDLLIMPEXP_FWD_CORE wxBoxSizer;
+class WXDLLIMPEXP_FWD_ADV wxWizardSizer;
+
+class WXDLLIMPEXP_ADV wxWizard : public wxWizardBase
+{
+public:
+    // ctor
+    wxWizard() { Init(); }
+    wxWizard(wxWindow *parent,
+             int id = wxID_ANY,
+             const wxString& title = wxEmptyString,
+             const wxBitmap& bitmap = wxNullBitmap,
+             const wxPoint& pos = wxDefaultPosition,
+             long style = wxDEFAULT_DIALOG_STYLE)
+    {
+        Init();
+        Create(parent, id, title, bitmap, pos, style);
+    }
+    bool Create(wxWindow *parent,
+             int id = wxID_ANY,
+             const wxString& title = wxEmptyString,
+             const wxBitmap& bitmap = wxNullBitmap,
+             const wxPoint& pos = wxDefaultPosition,
+             long style = wxDEFAULT_DIALOG_STYLE);
+    void Init();
+
+#if wxABI_VERSION >= 20804
+    virtual ~wxWizard();
+#endif
+
+    // implement base class pure virtuals
+    virtual bool RunWizard(wxWizardPage *firstPage);
+    virtual wxWizardPage *GetCurrentPage() const;
+    virtual void SetPageSize(const wxSize& size);
+    virtual wxSize GetPageSize() const;
+    virtual void FitToPage(const wxWizardPage *firstPage);
+    virtual wxSizer *GetPageAreaSizer() const;
+    virtual void SetBorder(int border);
+
+    /// set/get bitmap
+#if wxABI_VERSION >= 20805
+    const wxBitmap& GetBitmap() const { return m_bitmap; }
+    void SetBitmap(const wxBitmap& bitmap);
+#endif
+
+    // implementation only from now on
+    // -------------------------------
+
+    // is the wizard running?
+    bool IsRunning() const { return m_page != NULL; }
+
+    // show the prev/next page, but call TransferDataFromWindow on the current
+    // page first and return false without changing the page if
+    // TransferDataFromWindow() returns false - otherwise, returns true
+    bool ShowPage(wxWizardPage *page, bool goingForward = true);
+
+    // do fill the dialog with controls
+    // this is app-overridable to, for example, set help and tooltip text
+    virtual void DoCreateControls();
+
+protected:
+    // for compatibility only, doesn't do anything any more
+    void FinishLayout() { }
+
+private:
+    // was the dialog really created?
+    bool WasCreated() const { return m_btnPrev != NULL; }
+
+    // event handlers
+    void OnCancel(wxCommandEvent& event);
+    void OnBackOrNext(wxCommandEvent& event);
+    void OnHelp(wxCommandEvent& event);
+
+    void OnWizEvent(wxWizardEvent& event);
+
+    void AddBitmapRow(wxBoxSizer *mainColumn);
+    void AddStaticLine(wxBoxSizer *mainColumn);
+    void AddBackNextPair(wxBoxSizer *buttonRow);
+    void AddButtonRow(wxBoxSizer *mainColumn);
+
+    // the page size requested by user
+    wxSize m_sizePage;
+
+    // the dialog position from the ctor
+    wxPoint m_posWizard;
+
+    // wizard state
+    wxWizardPage *m_page;       // the current page or NULL
+    wxBitmap      m_bitmap;     // the default bitmap to show
+
+    // wizard controls
+    wxButton    *m_btnPrev,     // the "<Back" button
+                *m_btnNext;     // the "Next>" or "Finish" button
+    wxStaticBitmap *m_statbmp;  // the control for the bitmap
+
+    // Border around page area sizer requested using SetBorder()
+    int m_border;
+
+    // Whether RunWizard() was called
+    bool m_started;
+
+    // Whether was modal (modeless has to be destroyed on finish or cancel)
+    bool m_wasModal;
+
+    // True if pages are laid out using the sizer
+    bool m_usingSizer;
+
+    // Page area sizer will be inserted here with padding
+    wxBoxSizer *m_sizerBmpAndPage;
+
+    // Actual position and size of pages
+    wxWizardSizer *m_sizerPage;
+
+    friend class wxWizardSizer;
+
+    DECLARE_DYNAMIC_CLASS(wxWizard)
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxWizard)
+};
+
+#endif // _WX_GENERIC_WIZARD_H_