diff --git a/contrib/include/wx/canvas/canvas.h b/contrib/include/wx/canvas/canvas.h new file mode 100644 index 0000000000..f1255760b3 --- /dev/null +++ b/contrib/include/wx/canvas/canvas.h @@ -0,0 +1,473 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: canvas.h +// Author: Robert Roebling +// Created: XX/XX/XX +// Copyright: 2000 (c) Robert Roebling +// Licence: wxWindows Licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef __WXCANVAS_H__ +#define __WXCANVAS_H__ + +#ifdef __GNUG__ + #pragma interface "canvas.cpp" +#endif + +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#include "wx/image.h" +#include "wx/txtstrm.h" +#include "wx/geometry.h" + + +//---------------------------------------------------------------------------- +// decls +//---------------------------------------------------------------------------- + +#define IMAGE_CANVAS 0 + +class wxCanvas; + +//---------------------------------------------------------------------------- +// wxCanvasObject +//---------------------------------------------------------------------------- + +class wxCanvasObject: public wxEvtHandler +{ +public: + wxCanvasObject(); + + // Area occupied by object. Used for clipping, intersection, + // mouse enter etc. Screen coordinates + void SetArea( int x, int y, int width, int height ); + void SetArea( wxRect rect ); + + // These are for screen output only therefore use + // int as coordinates. + virtual bool IsHit( int x, int y, int margin = 0 ); + virtual void Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ); + + // use doubles later + virtual void Move( int x, int y ); + + // Once we have world coordinates in doubles, this will get + // called for every object if the world coordinate system + // changes (zooming). + virtual void Recreate(); + + // Later... + virtual void WriteSVG( wxTextOutputStream &stream ); + + wxCanvas *GetOwner() { return m_owner; } + virtual void SetOwner( wxCanvas *owner ) { m_owner = owner; } + + bool IsControl() { return m_isControl; } + bool IsVector() { return m_isVector; } + bool IsImage() { return m_isImage; } + inline int GetX() { return m_area.x; } + inline int GetY() { return m_area.y; } + inline int GetWidth() { return m_area.width; } + inline int GetHeight() { return m_area.height; } + + void CaptureMouse(); + void ReleaseMouse(); + bool IsCapturedMouse(); + +protected: + wxCanvas *m_owner; + bool m_isControl; + bool m_isVector; + bool m_isImage; + + //relative boundingbox in parent in pixels + wxRect m_area; + + friend class wxCanvas; +}; + +//---------------------------------------------------------------------------- +// wxCanvasObjectGroup +//---------------------------------------------------------------------------- + +class wxCanvasObjectGroup +{ +public: + wxCanvasObjectGroup(); + virtual ~wxCanvasObjectGroup(); + + void SetOwner(wxCanvas* canvas); + wxCanvas *GetOwner() { return m_owner; } + + virtual void Prepend( wxCanvasObject* obj ); + virtual void Append( wxCanvasObject* obj ); + virtual void Insert( size_t before, wxCanvasObject* obj ); + virtual void Remove( wxCanvasObject* obj ); + + virtual void Recreate(); + void DeleteContents( bool ); + virtual void Render(int xabs, int yabs,int x, int y, int width, int height ); + virtual void WriteSVG( wxTextOutputStream &stream ); + virtual bool IsHit( int x, int y, int margin ); + virtual wxCanvasObject* IsHitObject( int x, int y, int margin ); + + void ExtendArea(double x, double y); + + inline double GetXMin() { return m_minx; } + inline double GetYMin() { return m_miny; } + inline double GetXMax() { return m_maxx; } + inline double GetYMax() { return m_maxy; } + +protected: + wxCanvas *m_owner; + + //bounding box + double m_minx; + double m_miny; + double m_maxx; + double m_maxy; + bool m_validbounds; + + wxList m_objects; + + friend class wxCanvas; +}; + +//---------------------------------------------------------------------------- +// wxCanvasObjectGroupRef +//---------------------------------------------------------------------------- + +class wxCanvasObjectGroupRef: public wxCanvasObject +{ +public: + wxCanvasObjectGroupRef(double x, double y,wxCanvasObjectGroup* group); + + void SetOwner(wxCanvas* canvas); + + virtual void Recreate(); + virtual void Render(int xabs, int yabs,int x, int y, int width, int height ); + virtual void WriteSVG( wxTextOutputStream &stream ); + virtual bool IsHit( int x, int y, int margin ); + void Move( int x, int y ); + + inline double GetPosX() { return m_x; } + inline double GetPosY() { return m_y; } + + void ExtendArea(double x, double y); + virtual wxCanvasObject* IsHitObject( int x, int y, int margin ); + +protected: + //position of the group + double m_x; + double m_y; + + //reference to the group + wxCanvasObjectGroup* m_group; + + //bounding box + double m_minx; + double m_miny; + double m_maxx; + double m_maxy; + bool m_validbounds; + +}; + +//---------------------------------------------------------------------------- +// wxCanvasPolygon +//---------------------------------------------------------------------------- + +class wxCanvasPolygon: public wxCanvasObject +{ +public: + wxCanvasPolygon( int n, wxPoint2DDouble points[] ); + ~wxCanvasPolygon(); + void SetBrush(wxBrush& brush) { m_brush = brush; }; + void SetPen(wxPen& pen) { m_pen = pen; }; + + virtual void Recreate(); + + virtual void Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ); + virtual void WriteSVG( wxTextOutputStream &stream ); + +private: + void ExtendArea(double x, double y); + + wxBrush m_brush; + wxPen m_pen; + + int m_n; + wxPoint2DDouble* m_points; + + //bounding box + double m_minx; + double m_miny; + double m_maxx; + double m_maxy; + bool m_validbounds; + +}; + +//---------------------------------------------------------------------------- +// wxCanvasPolyline +//---------------------------------------------------------------------------- + +class wxCanvasPolyline: public wxCanvasObject +{ +public: + wxCanvasPolyline(int n, wxPoint2DDouble points[]); + ~wxCanvasPolyline(); + void SetPen(wxPen& pen) { m_pen = pen; }; + + virtual void Recreate(); + + virtual void Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ); + virtual void WriteSVG( wxTextOutputStream &stream ); + +private: + void ExtendArea(double x, double y); + + wxPen m_pen; + + int m_n; + wxPoint2DDouble* m_points; + + //bounding box + double m_minx; + double m_miny; + double m_maxx; + double m_maxy; + bool m_validbounds; + +}; + + + +//---------------------------------------------------------------------------- +// wxCanvasRect +//---------------------------------------------------------------------------- + +class wxCanvasRect: public wxCanvasObject +{ +public: + wxCanvasRect( double x, double y, double w, double h ); + void SetBrush(wxBrush& brush) { m_brush = brush; }; + void SetPen(wxPen& pen) { m_pen = pen; }; + + virtual void Recreate(); + + virtual void Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ); + virtual void WriteSVG( wxTextOutputStream &stream ); + +private: + wxPen m_pen; + wxBrush m_brush; + + double m_x; + double m_y; + double m_width; + double m_height; +}; + +//---------------------------------------------------------------------------- +// wxCanvasLine +//---------------------------------------------------------------------------- + +class wxCanvasLine: public wxCanvasObject +{ +public: + wxCanvasLine( double x1, double y1, double x2, double y2 ); + void SetPen(wxPen& pen) { m_pen = pen; }; + + virtual void Recreate(); + + virtual void Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ); + virtual void WriteSVG( wxTextOutputStream &stream ); + +private: + wxPen m_pen; + + double m_x1; + double m_y1; + double m_x2; + double m_y2; +}; + +//---------------------------------------------------------------------------- +// wxCanvasImage +//---------------------------------------------------------------------------- + +class wxCanvasImage: public wxCanvasObject +{ +public: + wxCanvasImage( const wxImage &image, double x, double y, double w, double h ); + + virtual void Recreate(); + + virtual void Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ); + virtual void WriteSVG( wxTextOutputStream &stream ); + +private: + double m_x; + double m_y; + double m_width; + double m_height; + + wxImage m_image; +#if IMAGE_CANVAS + wxImage m_tmp; +#else + wxBitmap m_tmp; +#endif +}; + +//---------------------------------------------------------------------------- +// wxCanvasControl +//---------------------------------------------------------------------------- + +class wxCanvasControl: public wxCanvasObject +{ +public: + wxCanvasControl( wxWindow *control ); + ~wxCanvasControl(); + + virtual void Recreate(); + + virtual void Move( int x, int y ); + +private: + wxWindow *m_control; +}; + +//---------------------------------------------------------------------------- +// wxCanvasText +//---------------------------------------------------------------------------- + +class wxCanvasText: public wxCanvasObject +{ +public: + wxCanvasText( const wxString &text, double x, double y, const wxString &foneFile, int size ); + ~wxCanvasText(); + + void Recreate(); + + virtual void Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ); + virtual void WriteSVG( wxTextOutputStream &stream ); + + void SetRGB( unsigned char red, unsigned char green, unsigned char blue ); + void SetFlag( int flag ); + int GetFlag() { return m_flag; } + +private: + wxString m_text; + double m_x; + double m_y; + unsigned char *m_alpha; + void *m_faceData; + int m_flag; + int m_red; + int m_green; + int m_blue; + wxString m_fontFileName; + int m_size; +}; + +//---------------------------------------------------------------------------- +// wxCanvas +//---------------------------------------------------------------------------- + +class wxCanvas: public wxScrolledWindow +{ +public: + // constructors and destructors + wxCanvas( wxWindow *parent, wxWindowID id = -1, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxScrolledWindowStyle ); + virtual ~wxCanvas(); + + virtual void SetArea( int width, int height ); + virtual void SetColour( unsigned char red, unsigned char green, unsigned char blue ); + virtual void Update( int x, int y, int width, int height, bool blit = TRUE ); + virtual void UpdateNow(); + + virtual void Freeze(); + virtual void Thaw(); + + virtual void Prepend( wxCanvasObject* obj ); + virtual void Append( wxCanvasObject* obj ); + virtual void Insert( size_t before, wxCanvasObject* obj ); + virtual void Remove( wxCanvasObject* obj ); + + // override these to change your coordiate system ... + virtual int GetDeviceX( double x ); + virtual int GetDeviceY( double y ); + virtual int GetDeviceWidth( double width ); + virtual int GetDeviceHeight( double height ); + + // ... and call this to tell all objets to recreate then + virtual void Recreate(); + +#if IMAGE_CANVAS + inline wxImage *GetBuffer() { return &m_buffer; } +#else + inline wxBitmap *GetBuffer() { return &m_buffer; } + inline wxMemoryDC *GetDC() { return m_renderDC; } +#endif + inline int GetBufferX() { return m_bufferX; } + inline int GetBufferY() { return m_bufferY; } + inline int GetBufferWidth() { return m_buffer.GetWidth(); } + inline int GetBufferHeight() { return m_buffer.GetHeight(); } + + bool NeedUpdate() { return m_needUpdate; } + bool IsFrozen() { return m_frozen; } + + void BlitBuffer( wxDC &dc ); + + void SetCaptureMouse( wxCanvasObject *obj ); + + virtual void ScrollWindow( int dx, int dy, + const wxRect* rect = (wxRect *) NULL ); + +private: +#if IMAGE_CANVAS + wxImage m_buffer; +#else + wxBitmap m_buffer; + wxMemoryDC *m_renderDC; +#endif + int m_bufferX; + int m_bufferY; + bool m_needUpdate; + wxList m_updateRects; + wxCanvasObjectGroup* m_root; + + unsigned char m_green,m_red,m_blue; + bool m_frozen; + wxCanvasObject *m_lastMouse; + wxCanvasObject *m_captureMouse; + + int m_oldDeviceX,m_oldDeviceY; + + friend class wxCanvasObject; + +private: + void OnChar( wxKeyEvent &event ); + void OnPaint( wxPaintEvent &event ); + void OnMouse( wxMouseEvent &event ); + void OnSize( wxSizeEvent &event ); + void OnIdle( wxIdleEvent &event ); + void OnSetFocus( wxFocusEvent &event ); + void OnKillFocus( wxFocusEvent &event ); + void OnEraseBackground( wxEraseEvent &event ); + +private: + DECLARE_CLASS(wxCanvas) + DECLARE_EVENT_TABLE() +}; + + +#endif + // WXCANVAS + diff --git a/contrib/include/wx/xml/xh_all.h b/contrib/include/wx/xml/xh_all.h new file mode 100644 index 0000000000..39e0f77324 --- /dev/null +++ b/contrib/include/wx/xml/xh_all.h @@ -0,0 +1,47 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_all.h +// Purpose: includes all xh_*.h files +// Author: Vaclav Slavik +// Created: 2000/03/05 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_ALL_H_ +#define _WX_XH_ALL_H_ + + +// Existing handlers: + +#include "wx/xml/xh_menu.h" +#include "wx/xml/xh_panel.h" +#include "wx/xml/xh_dlg.h" +#include "wx/xml/xh_bttn.h" +#include "wx/xml/xh_chckb.h" +#include "wx/xml/xh_gauge.h" +#include "wx/xml/xh_html.h" +#include "wx/xml/xh_spin.h" +#include "wx/xml/xh_sttxt.h" +#include "wx/xml/xh_slidr.h" +#include "wx/xml/xh_radbt.h" +#include "wx/xml/xh_radbx.h" +#include "wx/xml/xh_combo.h" +#include "wx/xml/xh_chckl.h" +#include "wx/xml/xh_choic.h" +#include "wx/xml/xh_sizer.h" +#include "wx/xml/xh_stbmp.h" +#include "wx/xml/xh_notbk.h" +#include "wx/xml/xh_text.h" +#include "wx/xml/xh_listb.h" +#include "wx/xml/xh_toolb.h" +#include "wx/xml/xh_bmpbt.h" +#include "wx/xml/xh_stbox.h" +#include "wx/xml/xh_scrol.h" +#include "wx/xml/xh_tree.h" +#include "wx/xml/xh_cald.h" +#include "wx/xml/xh_listc.h" +#include "wx/xml/xh_stlin.h" +#include "wx/xml/xh_bmp.h" +#include "wx/xml/xh_unkwn.h" +#endif // _WX_XMLRES_H_ diff --git a/contrib/include/wx/xml/xh_bmp.h b/contrib/include/wx/xml/xh_bmp.h new file mode 100644 index 0000000000..3b19925bf9 --- /dev/null +++ b/contrib/include/wx/xml/xh_bmp.h @@ -0,0 +1,38 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_bmp.h +// Purpose: XML resource handler for wxBitmap and wxIcon +// Author: Vaclav Slavik +// Created: 2000/09/00 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_BMP_H_ +#define _WX_XH_BMP_H_ + +#ifdef __GNUG__ +#pragma interface "xh_bmp.h" +#endif + +#include "wx/xml/xmlres.h" + + +class WXDLLEXPORT wxBitmapXmlHandler : public wxXmlResourceHandler +{ + public: + wxBitmapXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + +class WXDLLEXPORT wxIconXmlHandler : public wxXmlResourceHandler +{ + public: + wxIconXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_BMP_H_ diff --git a/contrib/include/wx/xml/xh_bmpbt.h b/contrib/include/wx/xml/xh_bmpbt.h new file mode 100644 index 0000000000..7b12cc9719 --- /dev/null +++ b/contrib/include/wx/xml/xh_bmpbt.h @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_bmpbt.h +// Purpose: XML resource handler for bitmap buttons +// Author: Brian Gavin +// Created: 2000/03/05 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Brian Gavin +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_BMPBT_H_ +#define _WX_XH_BMPBT_H_ + +#ifdef __GNUG__ +#pragma interface "xh_bmpbt.h" +#endif + +#include "wx/xml/xmlres.h" + + +class WXDLLEXPORT wxBitmapButtonXmlHandler : public wxXmlResourceHandler +{ + public: + wxBitmapButtonXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_BMPBT_H_ diff --git a/contrib/include/wx/xml/xh_bttn.h b/contrib/include/wx/xml/xh_bttn.h new file mode 100644 index 0000000000..9a20c277ef --- /dev/null +++ b/contrib/include/wx/xml/xh_bttn.h @@ -0,0 +1,29 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_bttn.h +// Purpose: XML resource handler for buttons +// Author: Vaclav Slavik +// Created: 2000/03/05 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_BTTN_H_ +#define _WX_XH_BTTN_H_ + +#ifdef __GNUG__ +#pragma interface "xh_bttn.h" +#endif + +#include "wx/xml/xmlres.h" + +class WXDLLEXPORT wxButtonXmlHandler : public wxXmlResourceHandler +{ + public: + wxButtonXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_BTTN_H_ diff --git a/contrib/include/wx/xml/xh_cald.h b/contrib/include/wx/xml/xh_cald.h new file mode 100644 index 0000000000..adf0ecc7e3 --- /dev/null +++ b/contrib/include/wx/xml/xh_cald.h @@ -0,0 +1,29 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_cald.h +// Purpose: XML resource handler for wxCalendarCtrl +// Author: Brian Gavin +// Created: 2000/09/09 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Brian Gavin +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_CALD_H_ +#define _WX_XH_CALD_H_ + +#ifdef __GNUG__ +#pragma interface "xh_cald.h" +#endif + +#include "wx/xml/xmlres.h" + +class WXDLLEXPORT wxCalendarCtrlXmlHandler : public wxXmlResourceHandler +{ + public: + wxCalendarCtrlXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_CALD_H_ diff --git a/contrib/include/wx/xml/xh_chckb.h b/contrib/include/wx/xml/xh_chckb.h new file mode 100644 index 0000000000..e2c52a6c18 --- /dev/null +++ b/contrib/include/wx/xml/xh_chckb.h @@ -0,0 +1,35 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_chckb.h +// Purpose: XML resource handler for wxCheckBox +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell and Verant Interactive +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_CHCKB_H_ +#define _WX_XH_CHCKB_H_ + +#ifdef __GNUG__ +#pragma interface "xh_chckb.h" +#endif + +#include "wx/xml/xmlres.h" +#include "wx/defs.h" + +#if wxUSE_CHECKBOX + +class WXDLLEXPORT wxCheckBoxXmlHandler : public wxXmlResourceHandler +{ + public: + wxCheckBoxXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + +#endif + + +#endif // _WX_XH_CHECKBOX_H_ + diff --git a/contrib/include/wx/xml/xh_chckl.h b/contrib/include/wx/xml/xh_chckl.h new file mode 100644 index 0000000000..5e63ebf9e7 --- /dev/null +++ b/contrib/include/wx/xml/xh_chckl.h @@ -0,0 +1,33 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_chckl.h +// Purpose: XML resource handler for wxCheckListBox +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell and Verant Interactive +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_CHCKL_H_ +#define _WX_XH_CHCKL_H_ + +#ifdef __GNUG__ +#pragma interface "xh_chckl.h" +#endif + +#include "wx/xml/xmlres.h" + +class WXDLLEXPORT wxCheckListXmlHandler : public wxXmlResourceHandler +{ + public: + wxCheckListXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); + private: + bool m_InsideBox; + wxArrayString strList; +}; + + + +#endif // _WX_XH_CHECKLIST_H_ diff --git a/contrib/include/wx/xml/xh_choic.h b/contrib/include/wx/xml/xh_choic.h new file mode 100644 index 0000000000..a1db703507 --- /dev/null +++ b/contrib/include/wx/xml/xh_choic.h @@ -0,0 +1,32 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_choic.h +// Purpose: XML resource handler for wxChoice +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell and Verant Interactive +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_CHOIC_H_ +#define _WX_XH_CHOIC_H_ + +#ifdef __GNUG__ +#pragma interface "xh_choic.h" +#endif + +#include "wx/xml/xmlres.h" + +class WXDLLEXPORT wxChoiceXmlHandler : public wxXmlResourceHandler +{ + public: + wxChoiceXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); + private: + bool m_InsideBox; + wxArrayString strList; +}; + + +#endif // _WX_XH_CHOIC_H_ diff --git a/contrib/include/wx/xml/xh_combo.h b/contrib/include/wx/xml/xh_combo.h new file mode 100644 index 0000000000..02bc09da71 --- /dev/null +++ b/contrib/include/wx/xml/xh_combo.h @@ -0,0 +1,35 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_combo.h +// Purpose: XML resource handler for wxComboBox +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell and Verant Interactive +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_COMBO_H_ +#define _WX_XH_COMBO_H_ + +#ifdef __GNUG__ +#pragma interface "xh_combo.h" +#endif + +#include "wx/xml/xmlres.h" + +#if wxUSE_COMBOBOX + +class WXDLLEXPORT wxComboBoxXmlHandler : public wxXmlResourceHandler +{ + public: + wxComboBoxXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); + private: + bool m_InsideBox; + wxArrayString strList; +}; + +#endif + +#endif // _WX_XH_COMBO_H_ diff --git a/contrib/include/wx/xml/xh_dlg.h b/contrib/include/wx/xml/xh_dlg.h new file mode 100644 index 0000000000..2f59198c89 --- /dev/null +++ b/contrib/include/wx/xml/xh_dlg.h @@ -0,0 +1,29 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_dlg.h +// Purpose: XML resource handler for dialogs +// Author: Vaclav Slavik +// Created: 2000/03/05 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_DLG_H_ +#define _WX_XH_DLG_H_ + +#ifdef __GNUG__ +#pragma interface "xh_dlg.h" +#endif + +#include "wx/xml/xmlres.h" + +class WXDLLEXPORT wxDialogXmlHandler : public wxXmlResourceHandler +{ + public: + wxDialogXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_DLG_H_ diff --git a/contrib/include/wx/xml/xh_gauge.h b/contrib/include/wx/xml/xh_gauge.h new file mode 100644 index 0000000000..802b36f07a --- /dev/null +++ b/contrib/include/wx/xml/xh_gauge.h @@ -0,0 +1,40 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_gauge.h +// Purpose: XML resource handler for wxGauge +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell and Verant Interactive +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_GAUGE_H_ +#define _WX_XH_GAUGE_H_ + +#ifdef __GNUG__ +#pragma interface "xh_gauge.h" +#endif + +#include "wx/defs.h" + +#if wxUSE_GAUGE + +#include "wx/xml/xmlres.h" + + +class WXDLLEXPORT wxGaugeXmlHandler : public wxXmlResourceHandler +{ + enum + { + wxGAUGE_DEFAULT_RANGE = 100 + }; + + public: + wxGaugeXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + +#endif + +#endif // _WX_XH_GAUGE_H_ diff --git a/contrib/include/wx/xml/xh_html.h b/contrib/include/wx/xml/xh_html.h new file mode 100644 index 0000000000..e3f1bc26e1 --- /dev/null +++ b/contrib/include/wx/xml/xh_html.h @@ -0,0 +1,34 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_html.h +// Purpose: XML resource handler for wxHtmlWindow +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell and Verant Interactive +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_HTML_H_ +#define _WX_XH_HTML_H_ + +#ifdef __GNUG__ +#pragma interface "xh_html.h" +#endif + +#include "wx/xml/xmlres.h" + +#include "wx/defs.h" + +#if wxUSE_HTML + +class WXDLLEXPORT wxHtmlWindowXmlHandler : public wxXmlResourceHandler +{ + public: + wxHtmlWindowXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + +#endif + +#endif // _WX_XH_SLIDER_H_ diff --git a/contrib/include/wx/xml/xh_listb.h b/contrib/include/wx/xml/xh_listb.h new file mode 100644 index 0000000000..637d264efa --- /dev/null +++ b/contrib/include/wx/xml/xh_listb.h @@ -0,0 +1,35 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_listb.h +// Purpose: XML resource handler for wxListbox +// Author: Bob Mitchell & Vaclav Slavik +// Created: 2000/07/29 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell & Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_LISTB_H_ +#define _WX_XH_LISTB_H_ + +#ifdef __GNUG__ +#pragma interface "xh_listb.h" +#endif + +#include "wx/xml/xmlres.h" + +#if wxUSE_LISTBOX + +class WXDLLEXPORT wxListBoxXmlHandler : public wxXmlResourceHandler +{ + public: + wxListBoxXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); + private: + bool m_InsideBox; + wxArrayString strList; +}; + +#endif + +#endif // _WX_XH_LISTB_H_ diff --git a/contrib/include/wx/xml/xh_listc.h b/contrib/include/wx/xml/xh_listc.h new file mode 100644 index 0000000000..27de314e58 --- /dev/null +++ b/contrib/include/wx/xml/xh_listc.h @@ -0,0 +1,29 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_listc.h +// Purpose: XML resource handler for wxCalendarCtrl +// Author: Brian Gavin +// Created: 2000/09/09 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Brian Gavin +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_LISTC_H_ +#define _WX_XH_LISTC_H_ + +#ifdef __GNUG__ +#pragma interface "xh_listc.h" +#endif + +#include "wx/xml/xmlres.h" + +class WXDLLEXPORT wxListCtrlXmlHandler : public wxXmlResourceHandler +{ + public: + wxListCtrlXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_LISTC_H_ diff --git a/contrib/include/wx/xml/xh_menu.h b/contrib/include/wx/xml/xh_menu.h new file mode 100644 index 0000000000..9f5b741eb5 --- /dev/null +++ b/contrib/include/wx/xml/xh_menu.h @@ -0,0 +1,40 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_menu.h +// Purpose: XML resource handler for menus/menubars +// Author: Vaclav Slavik +// Created: 2000/03/05 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_MENU_H_ +#define _WX_XH_MENU_H_ + +#ifdef __GNUG__ +#pragma interface "xh_menu.h" +#endif + +#include "wx/xml/xmlres.h" + +class WXDLLEXPORT wxMenuXmlHandler : public wxXmlResourceHandler +{ + public: + wxMenuXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); + + private: + bool m_InsideMenu; +}; + +class WXDLLEXPORT wxMenuBarXmlHandler : public wxXmlResourceHandler +{ + public: + wxMenuBarXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_MENU_H_ diff --git a/contrib/include/wx/xml/xh_notbk.h b/contrib/include/wx/xml/xh_notbk.h new file mode 100644 index 0000000000..0ce4a64faa --- /dev/null +++ b/contrib/include/wx/xml/xh_notbk.h @@ -0,0 +1,37 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_notbk.h +// Purpose: XML resource handler for wxNotebook +// Author: Vaclav Slavik +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_NOTBK_H_ +#define _WX_XH_NOTBK_H_ + +#ifdef __GNUG__ +#pragma interface "xh_notbk.h" +#endif + +#include "wx/xml/xmlres.h" + +#if wxUSE_NOTEBOOK + +class WXDLLEXPORT wxNotebook; + +class WXDLLEXPORT wxNotebookXmlHandler : public wxXmlResourceHandler +{ + public: + wxNotebookXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); + + private: + bool m_IsInside; + wxNotebook *m_Notebook; +}; + +#endif + +#endif // _WX_XH_NOTBK_H_ diff --git a/contrib/include/wx/xml/xh_panel.h b/contrib/include/wx/xml/xh_panel.h new file mode 100644 index 0000000000..6ff056c7f7 --- /dev/null +++ b/contrib/include/wx/xml/xh_panel.h @@ -0,0 +1,29 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_panel.h +// Purpose: XML resource handler for panels +// Author: Vaclav Slavik +// Created: 2000/03/05 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_PANEL_H_ +#define _WX_XH_PANEL_H_ + +#ifdef __GNUG__ +#pragma interface "xh_panel.h" +#endif + +#include "wx/xml/xmlres.h" + +class WXDLLEXPORT wxPanelXmlHandler : public wxXmlResourceHandler +{ + public: + wxPanelXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_PANEL_H_ diff --git a/contrib/include/wx/xml/xh_radbt.h b/contrib/include/wx/xml/xh_radbt.h new file mode 100644 index 0000000000..0e621e4ea8 --- /dev/null +++ b/contrib/include/wx/xml/xh_radbt.h @@ -0,0 +1,33 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_radbt.h +// Purpose: XML resource handler for radio buttons +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell and Verant Interactive +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_RADBT_H_ +#define _WX_XH_RADBT_H_ + +#ifdef __GNUG__ +#pragma interface "xh_radbt.h" +#endif + +#include "wx/xml/xmlres.h" +#include "wx/defs.h" + +#if wxUSE_RADIOBOX + +class WXDLLEXPORT wxRadioButtonXmlHandler : public wxXmlResourceHandler +{ + public: + wxRadioButtonXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + +#endif + +#endif // _WX_XH_RADIOBUTTON_H_ diff --git a/contrib/include/wx/xml/xh_radbx.h b/contrib/include/wx/xml/xh_radbx.h new file mode 100644 index 0000000000..b2125502b7 --- /dev/null +++ b/contrib/include/wx/xml/xh_radbx.h @@ -0,0 +1,35 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_radbx.h +// Purpose: XML resource handler for radio box +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell and Verant Interactive +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_RADBX_H_ +#define _WX_XH_RADBX_H_ + +#ifdef __GNUG__ +#pragma interface "xh_radbx.h" +#endif + +#include "wx/xml/xmlres.h" + +#if wxUSE_RADIOBOX + +class WXDLLEXPORT wxRadioBoxXmlHandler : public wxXmlResourceHandler +{ + public: + wxRadioBoxXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); + private: + bool m_InsideBox; + wxArrayString strList; +}; + +#endif + +#endif // _WX_XH_RADBX_H_ diff --git a/contrib/include/wx/xml/xh_scrol.h b/contrib/include/wx/xml/xh_scrol.h new file mode 100644 index 0000000000..f5d2aec0b1 --- /dev/null +++ b/contrib/include/wx/xml/xh_scrol.h @@ -0,0 +1,39 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_scrol.h +// Purpose: XML resource handler for wxScrollBar +// Author: Brian Gavin +// Created: 2000/09/09 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Brian Gavin +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_SCROL_H_ +#define _WX_XH_SCROL_H_ + +#ifdef __GNUG__ +#pragma interface "xh_scrol.h" +#endif + +#include "wx/xml/xmlres.h" +#include "wx/defs.h" + + + +class WXDLLEXPORT wxScrollBarXmlHandler : public wxXmlResourceHandler +{ + enum + { + wxSL_DEFAULT_VALUE = 0, + wxSL_DEFAULT_MIN = 0, + wxSL_DEFAULT_MAX = 100 + }; + + public: + wxScrollBarXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_SCROL_H_ diff --git a/contrib/include/wx/xml/xh_sizer.h b/contrib/include/wx/xml/xh_sizer.h new file mode 100644 index 0000000000..2c3d1e960c --- /dev/null +++ b/contrib/include/wx/xml/xh_sizer.h @@ -0,0 +1,38 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_sizer.h +// Purpose: XML resource handler for wxBoxSizer +// Author: Vaclav Slavik +// Created: 2000/04/24 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_SIZER_H_ +#define _WX_XH_SIZER_H_ + +#ifdef __GNUG__ +#pragma interface "xh_sizer.h" +#endif + +#include "wx/xml/xmlres.h" + + +class WXDLLEXPORT wxSizer; + +class WXDLLEXPORT wxSizerXmlHandler : public wxXmlResourceHandler +{ + public: + wxSizerXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); + + private: + bool m_IsInside; + wxSizer *m_ParentSizer; + + bool IsSizerNode(wxXmlNode *node); +}; + + +#endif // _WX_XH_BOXSIZER_H_ diff --git a/contrib/include/wx/xml/xh_slidr.h b/contrib/include/wx/xml/xh_slidr.h new file mode 100644 index 0000000000..70df5f8a29 --- /dev/null +++ b/contrib/include/wx/xml/xh_slidr.h @@ -0,0 +1,40 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_slidr.h +// Purpose: XML resource handler for wxSlider +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell and Verant Interactive +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_SLIDR_H_ +#define _WX_XH_SLIDR_H_ + +#ifdef __GNUG__ +#pragma interface "xh_slidr.h" +#endif + +#include "wx/xml/xmlres.h" +#include "wx/defs.h" + +#if wxUSE_SLIDER + +class WXDLLEXPORT wxSliderXmlHandler : public wxXmlResourceHandler +{ + enum + { + wxSL_DEFAULT_VALUE = 0, + wxSL_DEFAULT_MIN = 0, + wxSL_DEFAULT_MAX = 100 + }; + + public: + wxSliderXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + +#endif + +#endif // _WX_XH_SLIDER_H_ diff --git a/contrib/include/wx/xml/xh_spin.h b/contrib/include/wx/xml/xh_spin.h new file mode 100644 index 0000000000..f01af65da0 --- /dev/null +++ b/contrib/include/wx/xml/xh_spin.h @@ -0,0 +1,55 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_spin.h +// Purpose: XML resource handler for wxSpinButton +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell and Verant Interactive +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_SPIN_H_ +#define _WX_XH_SPIN_H_ + +#ifdef __GNUG__ +#pragma interface "xh_spin.h" +#endif + +#include "wx/xml/xmlres.h" +#include "wx/defs.h" + +#if wxUSE_SPINBTN +class WXDLLEXPORT wxSpinButtonXmlHandler : public wxXmlResourceHandler +{ + enum + { + wxSP_DEFAULT_VALUE = 0, + wxSP_DEFAULT_MIN = 0, + wxSP_DEFAULT_MAX = 100 + }; + + public: + wxSpinButtonXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; +#endif + +#if wxUSE_SPINCTRL +class WXDLLEXPORT wxSpinCtrlXmlHandler : public wxXmlResourceHandler +{ + enum + { + wxSP_DEFAULT_VALUE = 0, + wxSP_DEFAULT_MIN = 0, + wxSP_DEFAULT_MAX = 100 + }; + + public: + wxSpinCtrlXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; +#endif + +#endif // _WX_XH_SPIN_H_ diff --git a/contrib/include/wx/xml/xh_stbmp.h b/contrib/include/wx/xml/xh_stbmp.h new file mode 100644 index 0000000000..cd31cbcc27 --- /dev/null +++ b/contrib/include/wx/xml/xh_stbmp.h @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_stbmp.h +// Purpose: XML resource handler for wxStaticBitmap +// Author: Vaclav Slavik +// Created: 2000/04/22 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_STBMP_H_ +#define _WX_XH_STBMP_H_ + +#ifdef __GNUG__ +#pragma interface "xh_stbmp.h" +#endif + +#include "wx/xml/xmlres.h" + + +class WXDLLEXPORT wxStaticBitmapXmlHandler : public wxXmlResourceHandler +{ + public: + wxStaticBitmapXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_STBMP_H_ diff --git a/contrib/include/wx/xml/xh_stbox.h b/contrib/include/wx/xml/xh_stbox.h new file mode 100644 index 0000000000..aae851cfc7 --- /dev/null +++ b/contrib/include/wx/xml/xh_stbox.h @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_stbox.h +// Purpose: XML resource handler for wxStaticBox +// Author: Brian Gavin +// Created: 2000/09/00 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Brian Gavin +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_STBOX_H_ +#define _WX_XH_STBOX_H_ + +#ifdef __GNUG__ +#pragma interface "xh_stbox.h" +#endif + +#include "wx/xml/xmlres.h" + + +class WXDLLEXPORT wxStaticBoxXmlHandler : public wxXmlResourceHandler +{ + public: + wxStaticBoxXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_STBOX_H_ diff --git a/contrib/include/wx/xml/xh_stlin.h b/contrib/include/wx/xml/xh_stlin.h new file mode 100644 index 0000000000..5a23c9dcd5 --- /dev/null +++ b/contrib/include/wx/xml/xh_stlin.h @@ -0,0 +1,32 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_stlin.h +// Purpose: XML resource handler for wxStaticLine +// Author: Vaclav Slavik +// Created: 2000/09/00 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_STLIN_H_ +#define _WX_XH_STLIN_H_ + +#ifdef __GNUG__ +#pragma interface "xh_stlin.h" +#endif + +#include "wx/xml/xmlres.h" + +#if wxUSE_STATLINE + +class WXDLLEXPORT wxStaticLineXmlHandler : public wxXmlResourceHandler +{ + public: + wxStaticLineXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + +#endif + +#endif // _WX_XH_STLIN_H_ diff --git a/contrib/include/wx/xml/xh_sttxt.h b/contrib/include/wx/xml/xh_sttxt.h new file mode 100644 index 0000000000..9a57c98ff0 --- /dev/null +++ b/contrib/include/wx/xml/xh_sttxt.h @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_sttxt.h +// Purpose: XML resource handler for wxStaticBitmap +// Author: Bob Mitchell +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Bob Mitchell +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_STTXT_H_ +#define _WX_XH_STTXT_H_ + +#ifdef __GNUG__ +#pragma interface "xh_sttxt.h" +#endif + +#include "wx/xml/xmlres.h" + + +class WXDLLEXPORT wxStaticTextXmlHandler : public wxXmlResourceHandler +{ + public: + wxStaticTextXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_STBMP_H_ diff --git a/contrib/include/wx/xml/xh_text.h b/contrib/include/wx/xml/xh_text.h new file mode 100644 index 0000000000..3e1c5899e7 --- /dev/null +++ b/contrib/include/wx/xml/xh_text.h @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_text.h +// Purpose: XML resource handler for wxTextCtrl +// Author: Aleksandras Gluchovas +// Created: 2000/03/21 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Aleksandras Gluchovas +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_TEXT_H_ +#define _WX_XH_TEXT_H_ + +#ifdef __GNUG__ +#pragma interface "xh_text.h" +#endif + +#include "wx/xml/xmlres.h" + + +class WXDLLEXPORT wxTextCtrlXmlHandler : public wxXmlResourceHandler +{ + public: + wxTextCtrlXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_TEXT_H_ diff --git a/contrib/include/wx/xml/xh_toolb.h b/contrib/include/wx/xml/xh_toolb.h new file mode 100644 index 0000000000..db79997ef2 --- /dev/null +++ b/contrib/include/wx/xml/xh_toolb.h @@ -0,0 +1,38 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_toolb.h +// Purpose: XML resource handler for wxBoxSizer +// Author: Vaclav Slavik +// Created: 2000/08/11 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_TOOLB_H_ +#define _WX_XH_TOOLB_H_ + +#ifdef __GNUG__ +#pragma interface "xh_toolb.h" +#endif + +#include "wx/xml/xmlres.h" + +#if wxUSE_TOOLBAR + +class WXDLLEXPORT wxToolBar; + +class WXDLLEXPORT wxToolBarXmlHandler : public wxXmlResourceHandler +{ + public: + wxToolBarXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); + + private: + bool m_IsInside; + wxToolBar *m_Toolbar; +}; + +#endif + +#endif // _WX_XH_TOOLBAR_H_ diff --git a/contrib/include/wx/xml/xh_tree.h b/contrib/include/wx/xml/xh_tree.h new file mode 100644 index 0000000000..e743380a15 --- /dev/null +++ b/contrib/include/wx/xml/xh_tree.h @@ -0,0 +1,29 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_tree.h +// Purpose: XML resource handler for wxTreeCtrl +// Author: Brian Gavin +// Created: 2000/09/09 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Brian Gavin +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_TREE_H_ +#define _WX_XH_TREE_H_ + +#ifdef __GNUG__ +#pragma interface "xh_tree.h" +#endif + +#include "wx/xml/xmlres.h" + +class WXDLLEXPORT wxTreeCtrlXmlHandler : public wxXmlResourceHandler +{ + public: + wxTreeCtrlXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_TREE_H_ diff --git a/contrib/include/wx/xml/xh_unkwn.h b/contrib/include/wx/xml/xh_unkwn.h new file mode 100644 index 0000000000..e0112369c7 --- /dev/null +++ b/contrib/include/wx/xml/xh_unkwn.h @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xh_unkwn.h +// Purpose: XML resource handler for unkown widget +// Author: Vaclav Slavik +// Created: 2000/03/05 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XH_UNKWN_H_ +#define _WX_XH_UNKWN_H_ + +#ifdef __GNUG__ +#pragma interface "xh_unkwn.h" +#endif + +#include "wx/xml/xmlres.h" + + +class WXDLLEXPORT wxUnknownWidgetXmlHandler : public wxXmlResourceHandler +{ + public: + wxUnknownWidgetXmlHandler(); + virtual wxObject *DoCreateResource(); + virtual bool CanHandle(wxXmlNode *node); +}; + + +#endif // _WX_XH_UNKWN_H_ diff --git a/contrib/include/wx/xml/xml.h b/contrib/include/wx/xml/xml.h new file mode 100644 index 0000000000..c9d8549ec3 --- /dev/null +++ b/contrib/include/wx/xml/xml.h @@ -0,0 +1,239 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xml.h +// Purpose: wxXmlDocument - XML parser & data holder class +// Author: Vaclav Slavik +// Created: 2000/03/05 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XML_H_ +#define _WX_XML_H_ + +#ifdef __GNUG__ +#pragma interface "xml.h" +#endif + +#include "wx/defs.h" +#include "wx/string.h" +#include "wx/object.h" +#include "wx/list.h" + + +class WXDLLEXPORT wxXmlNode; +class WXDLLEXPORT wxXmlProperty; +class WXDLLEXPORT wxXmlDocument; +class WXDLLEXPORT wxXmlIOHandler; +class WXDLLEXPORT wxInputStream; +class WXDLLEXPORT wxOutputStream; + + +// Represents XML node type. +enum wxXmlNodeType +{ + // note: values are synchronized with xmlElementType from libxml + wxXML_ELEMENT_NODE = 1, + wxXML_ATTRIBUTE_NODE = 2, + wxXML_TEXT_NODE = 3, + wxXML_CDATA_SECTION_NODE = 4, + wxXML_ENTITY_REF_NODE = 5, + wxXML_ENTITY_NODE = 6, + wxXML_PI_NODE = 7, + wxXML_COMMENT_NODE = 8, + wxXML_DOCUMENT_NODE = 9, + wxXML_DOCUMENT_TYPE_NODE = 10, + wxXML_DOCUMENT_FRAG_NODE = 11, + wxXML_NOTATION_NODE = 12, + wxXML_HTML_DOCUMENT_NODE = 13 +}; + + +// Types of XML files: + +enum wxXmlIOType +{ + wxXML_IO_AUTO = 0, // detect it automatically + wxXML_IO_LIBXML, // use libxml2 to parse/save XML document + wxXML_IO_BIN, // save in binary uncompressed proprietary format + wxXML_IO_BINZ // svae in binary zlib-compressed proprietary format +}; + + +// Represents node property(ies). +// Example: in "src" is property with value +// "hello.gif" and "id" is prop. with value "3". + +class WXDLLEXPORT wxXmlProperty +{ + public: + wxXmlProperty() : m_Next(NULL) {} + wxXmlProperty(const wxString& name, const wxString& value, wxXmlProperty *next) + : m_Name(name), m_Value(value), m_Next(next) {} + ~wxXmlProperty() { delete m_Next; } + + wxString GetName() const { return m_Name; } + wxString GetValue() const { return m_Value; } + wxXmlProperty *GetNext() const { return m_Next; } + + void SetName(const wxString& name) { m_Name = name; } + void SetValue(const wxString& value) { m_Value = value; } + void SetNext(wxXmlProperty *next) { m_Next = next; } + + private: + wxString m_Name; + wxString m_Value; + wxXmlProperty *m_Next; +}; + + + +// Represents node in XML document. Node has name and may have content +// and properties. Most common node types are wxXML_TEXT_NODE (name and props +// are irrelevant) and wxXML_ELEMENT_NODE (e.g. in hi there is +// element with name="title", irrelevant content and one child (wxXML_TEXT_NODE +// with content="hi"). + +class WXDLLEXPORT wxXmlNode +{ + public: + wxXmlNode() : m_Properties(NULL), m_Parent(NULL), + m_Children(NULL), m_Next(NULL) {} + wxXmlNode(wxXmlNode *parent,wxXmlNodeType type, + const wxString& name, const wxString& content, + wxXmlProperty *props, wxXmlNode *next); + ~wxXmlNode() { delete m_Properties; delete m_Next; delete m_Children; } + + // copy ctor & operator=. Note that this does NOT copy syblings + // and parent pointer, i.e. m_Parent and m_Next will be NULL + // after using copy ctor and are never unmodified by operator=. + // On the other hand, it DOES copy children and properties. + wxXmlNode(const wxXmlNode& node); + wxXmlNode& operator=(const wxXmlNode& node); + + // user-friendly creation: + wxXmlNode(wxXmlNodeType type, const wxString& name, + const wxString& content = wxEmptyString); + void AddChild(wxXmlNode *child); + void InsertChild(wxXmlNode *child, wxXmlNode *before_node); + bool RemoveChild(wxXmlNode *child); + void AddProperty(const wxString& name, const wxString& value); + bool DeleteProperty(const wxString& name); + + // access methods: + wxXmlNodeType GetType() const { return m_Type; } + wxString GetName() const { return m_Name; } + wxString GetContent() const { return m_Content; } + + wxXmlNode *GetParent() const { return m_Parent; } + wxXmlNode *GetNext() const { return m_Next; } + wxXmlNode *GetChildren() const { return m_Children; } + + wxXmlProperty *GetProperties() const { return m_Properties; } + bool GetPropVal(const wxString& propName, wxString *value) const; + wxString GetPropVal(const wxString& propName, const wxString& defaultVal) const; + bool HasProp(const wxString& propName) const; + + void SetType(wxXmlNodeType type) { m_Type = type; } + void SetName(const wxString& name) { m_Name = name; } + void SetContent(const wxString& con) { m_Content = con; } + + void SetParent(wxXmlNode *parent) { m_Parent = parent; } + void SetNext(wxXmlNode *next) { m_Next = next; } + void SetChildren(wxXmlNode *child) { m_Children = child; } + + void SetProperties(wxXmlProperty *prop) { m_Properties = prop; } + void AddProperty(wxXmlProperty *prop); + + private: + wxXmlNodeType m_Type; + wxString m_Name; + wxString m_Content; + wxXmlProperty *m_Properties; + wxXmlNode *m_Parent, *m_Children, *m_Next; + + void DoCopy(const wxXmlNode& node); +}; + + + + + + + +// This class holds XML data/document as parsed by libxml. Note that +// internal representation is independant on libxml and you can use +// it without libxml (see Load/SaveBinary). + +class WXDLLEXPORT wxXmlDocument : public wxObject +{ + public: + wxXmlDocument() : wxObject(), m_Version(_T("1.0")), m_Root(NULL) {} + wxXmlDocument(const wxString& filename, wxXmlIOType io_type = wxXML_IO_AUTO); + wxXmlDocument(wxInputStream& stream, wxXmlIOType io_type = wxXML_IO_AUTO); + ~wxXmlDocument() { delete m_Root; } + + wxXmlDocument(const wxXmlDocument& doc); + wxXmlDocument& operator=(const wxXmlDocument& doc); + + // Parses .xml file and loads data. Returns TRUE on success, FALSE + // otherwise. + // NOTE: Any call to this method will result into linking against libxml + // and app's binary size will grow by ca. 250kB + bool Load(const wxString& filename, wxXmlIOType io_type = wxXML_IO_AUTO); + bool Load(wxInputStream& stream, wxXmlIOType io_type = wxXML_IO_AUTO); + + // Saves document as .xml file. + bool Save(const wxString& filename, wxXmlIOType io_type) const; + bool Save(wxOutputStream& stream, wxXmlIOType io_type) const; + + // Returns root node of the document. + wxXmlNode *GetRoot() const { return m_Root; } + + // Returns version of document (may be empty). + wxString GetVersion() const { return m_Version; } + // Returns encoding of document (may be empty). + wxString GetEncoding() const { return m_Encoding; } + + // Write-access methods: + void SetRoot(wxXmlNode *node) { delete m_Root ; m_Root = node; } + void SetVersion(const wxString& version) { m_Version = version; } + void SetEncoding(const wxString& encoding) { m_Encoding = encoding; } + + static void AddHandler(wxXmlIOHandler *handler); + static void CleanUpHandlers(); + static void InitStandardHandlers(); + + protected: + static wxList *sm_Handlers; + + private: + wxString m_Version, m_Encoding; + wxXmlNode *m_Root; + + void DoCopy(const wxXmlDocument& doc); +}; + + + +// wxXmlIOHandler takes care of loading and/or saving XML data. +// see xmlio.h for available handlers + +class WXDLLEXPORT wxXmlIOHandler : public wxObject +{ + public: + wxXmlIOHandler() {} + + virtual wxXmlIOType GetType() = 0; + virtual bool CanLoad(wxInputStream& stream) = 0; + virtual bool CanSave() = 0; + + virtual bool Load(wxInputStream& stream, wxXmlDocument& doc) = 0; + virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc) = 0; +}; + + + + + +#endif // _WX_XML_H_ diff --git a/contrib/include/wx/xml/xmlio.h b/contrib/include/wx/xml/xmlio.h new file mode 100644 index 0000000000..3e336b46c9 --- /dev/null +++ b/contrib/include/wx/xml/xmlio.h @@ -0,0 +1,72 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xmlio.h +// Purpose: wxXmlIOHandler - XML I/O classes +// Author: Vaclav Slavik +// Created: 2000/07/24 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XMLIO_H_ +#define _WX_XMLIO_H_ + +#ifdef __GNUG__ +#pragma interface "xmlio.h" +#endif + +#include "wx/defs.h" +#include "wx/string.h" +#include "wx/xml/xml.h" + + +class WXDLLEXPORT wxXmlIOHandlerBin : public wxXmlIOHandler +{ + public: + wxXmlIOHandlerBin() {} + + virtual wxXmlIOType GetType() { return wxXML_IO_BIN; } + virtual bool CanLoad(wxInputStream& stream); + virtual bool CanSave() { return TRUE; } + + virtual bool Load(wxInputStream& stream, wxXmlDocument& doc); + virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc); + + protected: + wxString ReadHeader(wxInputStream& stream); + void WriteHeader(wxOutputStream& stream, const wxString& header); +}; + + + +#if wxUSE_ZLIB + +class WXDLLEXPORT wxXmlIOHandlerBinZ : public wxXmlIOHandlerBin +{ + public: + wxXmlIOHandlerBinZ() {} + + virtual wxXmlIOType GetType() { return wxXML_IO_BINZ; } + virtual bool CanLoad(wxInputStream& stream); + + virtual bool Load(wxInputStream& stream, wxXmlDocument& doc); + virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc); +}; + +#endif + + + +class WXDLLEXPORT wxXmlIOHandlerLibxml : public wxXmlIOHandler +{ + public: + virtual wxXmlIOType GetType() { return wxXML_IO_LIBXML; } + virtual bool CanLoad(wxInputStream& stream); + virtual bool CanSave(); + + virtual bool Load(wxInputStream& stream, wxXmlDocument& doc); + virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc); +}; + + +#endif // _WX_XMLIO_H_ diff --git a/contrib/include/wx/xml/xmlres.h b/contrib/include/wx/xml/xmlres.h new file mode 100644 index 0000000000..52c7f2a9ab --- /dev/null +++ b/contrib/include/wx/xml/xmlres.h @@ -0,0 +1,300 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xmlres.h +// Purpose: XML resources +// Author: Vaclav Slavik +// Created: 2000/03/05 +// RCS-ID: $Id$ +// Copyright: (c) 2000 Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_XMLRES_H_ +#define _WX_XMLRES_H_ + +#ifdef __GNUG__ +#pragma interface "xmlres.h" +#endif + +#include "wx/defs.h" +#include "wx/string.h" +#include "wx/dynarray.h" +#include "wx/datetime.h" +#include "wx/list.h" +#include "wx/gdicmn.h" +#include "wx/filesys.h" +#include "wx/bitmap.h" +#include "wx/icon.h" + +class WXDLLEXPORT wxMenu; +class WXDLLEXPORT wxMenuBar; +class WXDLLEXPORT wxDialog; +class WXDLLEXPORT wxPanel; +class WXDLLEXPORT wxWindow; +class WXDLLEXPORT wxToolBar; + +class WXDLLEXPORT wxXmlResourceHandler; + +#include "wx/xml/xml.h" + + +class WXDLLEXPORT wxXmlResourceDataRecord +{ + public: + wxXmlResourceDataRecord() : Doc(NULL), Time(wxDateTime::Now()) {} + ~wxXmlResourceDataRecord() {delete Doc;} + + wxString File; + wxXmlDocument *Doc; + wxDateTime Time; +}; + +WX_DECLARE_EXPORTED_OBJARRAY(wxXmlResourceDataRecord, wxXmlResourceDataRecords); + +// This class holds XML resources from one or more .xml files +// (or derived forms, either binary or zipped -- see manual for +// details). + +class WXDLLEXPORT wxXmlResource : public wxObject +{ + public: + // Ctor. If use_locale is TRUE, translatable strings are + // translated via _(). You can disable it by passing use_locale=FALSE + // (for example if you provide resource file for each locale) + wxXmlResource(bool use_locale = TRUE); + wxXmlResource(const wxString& filemask, bool use_locale = TRUE); + ~wxXmlResource(); + + // Loads resources from XML files that match given filemask. + // This method understands VFS (see filesys.h). + bool Load(const wxString& filemask); + + // Initialize handlers for all supported controls/windows. This will + // make the executable quite big because it forces linking against + // most of wxWin library + void InitAllHandlers(); + + // Initialize only specific handler (or custom handler). Convention says + // that handler name is equal to control's name plus 'XmlHandler', e.g. + // wxTextCtrlXmlHandler, wxHtmlWindowXmlHandler. XML resource compiler + // (xmlres) can create include file that contains initialization code for + // all controls used within the resource. + void AddHandler(wxXmlResourceHandler *handler); + + // Removes all handlers + void ClearHandlers(); + + // Loads menu from resource. Returns NULL on failure. + wxMenu *LoadMenu(const wxString& name); + + // Loads menubar from resource. Returns NULL on failure. + wxMenuBar *LoadMenuBar(const wxString& name); + +#if wxUSE_TOOLBAR + // Loads toolbar + wxToolBar *LoadToolBar(wxWindow *parent, const wxString& name); +#endif + + // Loads dialog. dlg points to parent window (if any). Second form + // is used to finish creation of already existing instance (main reason + // for this is that you may want to use derived class with new event table) + // Example (typical usage): + // MyDialog dlg; + // wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog"); + // dlg->ShowModal(); + wxDialog *LoadDialog(wxWindow *parent, const wxString& name); + bool LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name); + + // Loads panel. panel points to parent window (if any). Second form + // is used to finish creation of already existing instance. + wxPanel *LoadPanel(wxWindow *parent, const wxString& name); + bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name); + + // Loads bitmap or icon resource from file: + wxBitmap LoadBitmap(const wxString& name); + wxIcon LoadIcon(const wxString& name); + + // Returns numeric ID that is equivalent to string id used in XML + // resource. To be used in event tables + // Macro XMLID is provided for convenience + static int GetXMLID(const char *str_id); + + protected: + // Scans resources list for unloaded files and loads them. Also reloads + // files that have been modified since last loading. + void UpdateResources(); + + // Finds resource (calls UpdateResources) and returns node containing it + wxXmlNode *FindResource(const wxString& name, const wxString& classname); + + // Creates resource from info in given node: + wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent, wxObject *instance = NULL); + + // Remove nodes with property "platform" that does not + // match current platform + void ProcessPlatformProperty(wxXmlNode *node); + + bool GetUseLocale() { return m_UseLocale; } + + private: + bool m_UseLocale; + wxList m_Handlers; + wxXmlResourceDataRecords m_Data; +#if wxUSE_FILESYSTEM + wxFileSystem m_CurFileSystem; + wxFileSystem& GetCurFileSystem() { return m_CurFileSystem; } +#endif + + friend class wxXmlResourceHandler; +}; + + +// Global instance of resource class. For your convenience. +extern wxXmlResource *wxTheXmlResource; + +// This macro translates string identifier (as used in XML resource, +// e.g. ...) to integer id that is needed by +// wxWindows event tables. +// Example: +// BEGIN_EVENT_TABLE(MyFrame, wxFrame) +// EVT_MENU(XMLID("quit"), MyFrame::OnQuit) +// EVT_MENU(XMLID("about"), MyFrame::OnAbout) +// EVT_MENU(XMLID("new"), MyFrame::OnNew) +// EVT_MENU(XMLID("open"), MyFrame::OnOpen) +// END_EVENT_TABLE() + +#define XMLID(str_id) \ + wxXmlResource::GetXMLID(_T(str_id)) + + +// This macro returns pointer to particular control in dialog +// created using XML resources. You can use it to set/get values from +// controls. +// Example: +// wxDialog dlg; +// wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog"); +// XMLCTRL(dlg, "my_textctrl", wxTextCtrl)->SetValue(_T("default value")); + +#define XMLCTRL(window, id, type) \ + ((type*)((window).FindWindow(XMLID(id)))) + + + +class WXDLLEXPORT wxXmlResourceHandler : public wxObject +{ + public: + wxXmlResourceHandler(); + virtual ~wxXmlResourceHandler() {} + + // Creates object (menu, dialog, control, ...) from XML node. + // Should check for validity. + // parent is higher-level object (usually window, dialog or panel) + // that is often neccessary to create resource + // if instance != NULL it should not create new instance via 'new' but + // rather use this one and call its Create method + wxObject *CreateResource(wxXmlNode *node, wxObject *parent, wxObject *instance); + + // This one is called from CreateResource after variables + // were filled + virtual wxObject *DoCreateResource() = 0; + + // Returns TRUE if it understands this node and can create + // resource from it, FALSE otherwise. + virtual bool CanHandle(wxXmlNode *node) = 0; + + void SetParentResource(wxXmlResource *res) { m_Resource = res; } + + + protected: + + wxXmlResource *m_Resource; + wxArrayString m_StyleNames; + wxArrayInt m_StyleValues; + + // Variables (filled by CreateResource) + wxXmlNode *m_Node; + wxString m_Class; + wxObject *m_Parent, *m_Instance; + wxWindow *m_ParentAsWindow, *m_InstanceAsWindow; + + // --- Handy methods: + + // Returns true if the node has property class equal to classname, + // e.g. + bool IsOfClass(wxXmlNode *node, const wxString& classname) + { return node->GetPropVal(_T("class"), wxEmptyString) == classname; } + + // Gets node content from wxXML_ENTITY_NODE + // (the problem is, content is represented as + // wxXML_ENTITY_NODE name="tag", content="" + // |-- wxXML_TEXT_NODE or + // wxXML_CDATA_SECTION_NODE name="" content="content" + wxString GetNodeContent(wxXmlNode *node); + + // Check to see if a param exists + bool HasParam(const wxString& param); + + // Finds the node or returns NULL + wxXmlNode *GetParamNode(const wxString& param); + wxString GetParamValue(const wxString& param); + + // Add style flag (e.g. wxMB_DOCKABLE) to list of flags + // understood by this handler + void AddStyle(const wxString& name, int value); + + // Add styles common to all wxWindow-derived classes + void AddWindowStyles(); + + // Gets style flags from text in form "flag | flag2| flag3 |..." + // Only understads flags added with AddStyle + int GetStyle(const wxString& param = _T("style"), int defaults = 0); + + // Gets text from param and does some convertions: + // - replaces \n, \r, \t by respective chars (according to C syntax) + // - replaces $ by & and $$ by $ (needed for $File => &File because of XML) + // - calls wxGetTranslations (unless disabled in wxXmlResource) + wxString GetText(const wxString& param); + + // Return XMLID + int GetID(); + wxString GetName(); + + // Get bool flag (1,t,yes,on,true are TRUE, everything else is FALSE) + bool GetBool(const wxString& param, bool defaultv = FALSE); + + // Get integer value from param + long GetLong( const wxString& param, long defaultv = 0 ); + + // Get colour in HTML syntax (#RRGGBB) + wxColour GetColour(const wxString& param); + + // Get size/position (may be in dlg units): + wxSize GetSize(const wxString& param = _T("size")); + wxPoint GetPosition(const wxString& param = _T("pos")); + + // Get dimension (may be in dlg units): + wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0); + + // Get bitmap: + wxBitmap GetBitmap(const wxString& param = _T("bitmap"), wxSize size = wxDefaultSize); + wxIcon GetIcon(const wxString& param = _T("icon"), wxSize size = wxDefaultSize); + + // Get font: + wxFont GetFont(const wxString& param = _T("font")); + + // Sets common window options: + void SetupWindow(wxWindow *wnd); + + void CreateChildren(wxObject *parent, bool this_hnd_only = FALSE); + void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = NULL); + wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent, wxObject *instance = NULL) + { return m_Resource->CreateResFromNode(node, parent, instance); } + + // helper + wxFileSystem& GetCurFileSystem() { return m_Resource->GetCurFileSystem(); } +}; + +#define ADD_STYLE(style) AddStyle(_T(#style), style) + + + +#endif // _WX_XMLRES_H_ diff --git a/contrib/samples/canvas/Makefile.in b/contrib/samples/canvas/Makefile.in new file mode 100644 index 0000000000..bde66ce1ee --- /dev/null +++ b/contrib/samples/canvas/Makefile.in @@ -0,0 +1,10 @@ +# $Id$ + +CONTRIB_SAMPLES=test + +all: + @for d in $(CONTRIB_SAMPLES); do (cd $$d && $(MAKE)); done + +clean: + @for d in $(CONTRIB_SAMPLES); do (cd $$d && $(MAKE) clean); done + diff --git a/contrib/samples/canvas/test/Makefile.in b/contrib/samples/canvas/test/Makefile.in new file mode 100644 index 0000000000..bce306e5b6 --- /dev/null +++ b/contrib/samples/canvas/test/Makefile.in @@ -0,0 +1,23 @@ +# +# File: Makefile.in +# Author: Julian Smart +# Created: 2000 +# Updated: +# Copyright: (c) 2000 Julian Smart +# +# "%W% %G%" +# +# Makefile for the multicell example (UNIX). + +top_srcdir = @top_srcdir@/.. +top_builddir = ../../../.. +program_dir = contrib/samples/canvas/test + +PROGRAM=test + +OBJECTS=test.o + +APPEXTRALIBS=$(top_builddir)/lib/libcanvas.@WX_TARGET_LIBRARY_TYPE@ +APPEXTRADEFS=-I$(top_srcdir)/contrib/include + +include $(top_builddir)/src/makeprog.env diff --git a/contrib/samples/canvas/test/smile.xpm b/contrib/samples/canvas/test/smile.xpm new file mode 100644 index 0000000000..4773967aa8 --- /dev/null +++ b/contrib/samples/canvas/test/smile.xpm @@ -0,0 +1,42 @@ +/* XPM */ +static char * smile_xpm[] = { +/* width height ncolors chars_per_pixel */ +"32 32 4 1", +/* colors */ +" s None c None", +". c #000000", +"+ c #ff0000", +"@ c #ffff00", +/* pixels */ +" ........ ", +" ...@@@@@@@@... ", +" ..@@@@@@@@@@@@@@.. ", +" ..@@@@@@@@@@@@@@@@.. ", +" .@@@@@@@@@@@@@@@@@@@@. ", +" .@@@@@@@@@@@@@@@@@@@@@@. ", +" .@@@@@@@@@@@@@@@@@@@@@@@@. ", +" ..@@@@@@@@@@@@@@@@@@@@@@@@.. ", +" .@@@@@@@@ @@@@@@ @@@@@@@@. ", +" .@@@@@@@@ @@@@ @@@@@@@@. ", +" .@@@@@@@@ @@@@ @@@@@@@@. ", +" .@@@@@@@@ @@@@ @@@@@@@@. ", +".@@@@@@@@@ @@@@ @@@@@@@@@.", +".@@@@@@@@@ @@@@ @@@@@@@@@.", +".@@@@@@@@@@ @@@@@@ @@@@@@@@@@.", +".@@@@@@@.@@@@@@@@@@@@@@.@@@@@@@.", +".@@@@@@@.@@@@@@@@@@@@@@.@@@@@@@.", +".@@@@@@.@@@@@@@@@@@@@@@@.@@@@@@.", +".@@@....@@@@@@@@@@@@@@@@....@@@.", +".@@@@@@@.@@@@@@@@@@@@@@.@@@@@@@.", +" .@@@@@@@.@@@@@@@@@@@@.@@@@@@@. ", +" .@@@@@@@..@@@@@@@@@@..@@@@@@@. ", +" .@@@@@@@@...@@@@@@...@@@@@@@@. ", +" .@@@@@@@@.+......+.@@@@@@@@. ", +" ..@@@@@@@@.++++++.@@@@@@@@.. ", +" .@@@@@@@@@.++++.@@@@@@@@@. ", +" .@@@@@@@@@....@@@@@@@@@. ", +" .@@@@@@@@@@@@@@@@@@@@. ", +" ..@@@@@@@@@@@@@@@@.. ", +" ..@@@@@@@@@@@@@@.. ", +" ...@@@@@@@@... ", +" ........ "}; diff --git a/contrib/samples/canvas/test/test.cpp b/contrib/samples/canvas/test/test.cpp new file mode 100644 index 0000000000..d9e9199a98 --- /dev/null +++ b/contrib/samples/canvas/test/test.cpp @@ -0,0 +1,350 @@ +/* + * Program: canvas + * + * Author: Robert Roebling + * + * Copyright: (C) 1998, Robert Roebling + * + */ +// For compilers that support precompilation, includes "wx/wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +#ifndef WX_PRECOMP +#include "wx/wx.h" +#endif + +#include +#include +#include +#include +#include "wx/image.h" + + +#include "smile.xpm" + +#include "wx/canvas/canvas.h" + +// derived classes + + +class MywxCanvasImage: public wxCanvasImage +{ +public: + MywxCanvasImage( const wxImage &image, double x, double y, double w, double h ); + + void MywxCanvasImage::OnMouse(wxMouseEvent &event); + + DECLARE_EVENT_TABLE() +}; + +BEGIN_EVENT_TABLE(MywxCanvasImage,wxCanvasImage) + EVT_MOUSE_EVENTS( MywxCanvasImage::OnMouse ) +END_EVENT_TABLE() + +MywxCanvasImage::MywxCanvasImage( const wxImage &image, double x, double y, double w, double h ) + :wxCanvasImage( image, x, y, w, h ) +{ +} + +void MywxCanvasImage::OnMouse(wxMouseEvent &event) +{ + static int dx=0; + static int dy=0; + + int x = event.GetX(); + int y = event.GetY(); + if (event.LeftDown()) + { + dx=x; + dy=y; + CaptureMouse(); + } + else if (event.LeftUp()) + { + ReleaseMouse(); + } + else if (IsCapturedMouse()) + { + Move(m_area.x+x-dx,m_area.y+y-dy); + m_owner->UpdateNow(); + } +} + +class MywxCanvasObjectGroupRef: public wxCanvasObjectGroupRef +{ +public: + MywxCanvasObjectGroupRef(double x, double y, wxCanvasObjectGroup* group); + + void OnMouse(wxMouseEvent &event); + + DECLARE_EVENT_TABLE() +}; + +BEGIN_EVENT_TABLE(MywxCanvasObjectGroupRef,wxCanvasObjectGroupRef) + EVT_MOUSE_EVENTS( MywxCanvasObjectGroupRef::OnMouse ) +END_EVENT_TABLE() + +MywxCanvasObjectGroupRef::MywxCanvasObjectGroupRef(double x, double y,wxCanvasObjectGroup* group) + :wxCanvasObjectGroupRef(x,y,group) +{ +} + +void MywxCanvasObjectGroupRef::OnMouse(wxMouseEvent &event) +{ + static int dx=0; + static int dy=0; + + //new position of object + int x = m_owner->GetDeviceX( event.GetX()); + int y = m_owner->GetDeviceY( event.GetY()); + + if (event.LeftDown()) + { + dx=x; + dy=y; + CaptureMouse(); + } + else if (event.LeftUp()) + { + ReleaseMouse(); + } + else if (IsCapturedMouse()) + { + Move(m_x+x-dx,m_y+y-dy); + m_owner->UpdateNow(); + } +} + +class MyFrame; +class MyApp; + +// MyFrame + +class MyFrame: public wxFrame +{ +public: + MyFrame(); + ~MyFrame(); + + void OnAbout( wxCommandEvent &event ); + void OnNewFrame( wxCommandEvent &event ); + void OnQuit( wxCommandEvent &event ); + void OnTimer( wxTimerEvent &event ); + + wxCanvas *m_canvas; + wxCanvasObject *m_sm1; + wxCanvasObject *m_sm2; + wxCanvasObject *m_sm3; + wxCanvasObject *m_sm4; + + MywxCanvasObjectGroupRef *m_ref; + MywxCanvasObjectGroupRef *m_ref2; + + wxTimer *m_timer; + wxTextCtrl *m_log; + +private: + DECLARE_DYNAMIC_CLASS(MyFrame) + DECLARE_EVENT_TABLE() +}; + +// MyApp + +class MyApp: public wxApp +{ +public: + virtual bool OnInit(); + + const wxString& GetFontPath() const { return m_fontpath; } + +private: + wxString m_fontpath; +}; + +// main program + +IMPLEMENT_APP(MyApp) + +// MyFrame + +const int ID_QUIT = 108; +const int ID_ABOUT = 109; + +IMPLEMENT_DYNAMIC_CLASS( MyFrame, wxFrame ) + +BEGIN_EVENT_TABLE(MyFrame,wxFrame) + EVT_MENU (ID_ABOUT, MyFrame::OnAbout) + EVT_MENU (ID_QUIT, MyFrame::OnQuit) + EVT_TIMER (-1, MyFrame::OnTimer) +END_EVENT_TABLE() + +MyFrame::MyFrame() + : wxFrame( (wxFrame *)NULL, -1, "wxCanvas sample", + wxPoint(20,20), wxSize(470,460) ) +{ + wxMenu *file_menu = new wxMenu(); + file_menu->Append( ID_ABOUT, "&About..."); + file_menu->AppendSeparator(); + file_menu->Append( ID_QUIT, "E&xit"); + + wxMenuBar *menu_bar = new wxMenuBar(); + menu_bar->Append(file_menu, "&File"); + + SetMenuBar( menu_bar ); + + CreateStatusBar(2); + int widths[] = { -1, 100 }; + SetStatusWidths( 2, widths ); + + m_canvas = new wxCanvas( this, -1, wxPoint(0,0), wxSize(10,10) ); + + m_canvas->SetArea( 1000,1000 ); + m_canvas->SetColour( 255, 255, 255 ); + + + wxBitmap bitmap( smile_xpm ); + wxImage image( bitmap ); + + m_sm1 = new wxCanvasImage( image, 0,70,32,32 ); + m_canvas->Append( m_sm1 ); + + int i; + for (i = 10; i < 300; i+=10) + { + wxCanvasRect *r = new wxCanvasRect( i,50,3,140 ); + r->SetBrush( *wxRED_BRUSH ); + m_canvas->Append( r ); + } + + m_sm2 = new wxCanvasImage( image, 0,140,24,24 ); + m_canvas->Append( m_sm2 ); + + for (i = 15; i < 300; i+=10) + m_canvas->Append( new wxCanvasRect( i,50,3,140 ) ); + + wxButton *button = new wxButton( m_canvas, -1, "Hello", wxPoint(80,50) ); + m_canvas->Append( new wxCanvasControl( button ) ); + + m_canvas->Append( new wxCanvasText( "How are you?", 180, 10, + wxGetApp().GetFontPath() + "/times.ttf", 8 ) ); + + m_canvas->Append( new wxCanvasText( "How are you?", 180, 20, + wxGetApp().GetFontPath() + "/times.ttf", 10 ) ); + + m_canvas->Append( new wxCanvasText( "How are you?", 180, 30, + wxGetApp().GetFontPath() + "/times.ttf", 12 ) ); + + m_sm3 = new wxCanvasImage( image, 0,210,32,32 ); + m_canvas->Append( m_sm3 ); + + for (i = 10; i < 300; i+=10) + m_canvas->Append( new wxCanvasLine( 10,-15,i,300 ) ); + + m_sm4 = new MywxCanvasImage( image, 0,270,64,32 ); + m_canvas->Append( m_sm4 ); + + +// m_canvas->Append( new wxCanvasLine( 10,-1500e6,50,300000e6, 0,255,0 ) ); +// m_canvas->Append( new wxCanvasLine( 10,-150000,50,300000, 0,255,0 ) ); + +/* + //make a group of wxCanvasObjects + wxCanvasObjectGroup* group1 = new wxCanvasObjectGroup(); + group1->Prepend( new wxCanvasLine( 10,-35,50,190 ) ); + group1->Prepend( new wxCanvasImage( image, 4,38,32,32 ) ); + group1->Prepend( new wxCanvasRect(20,-20,50,170,0,20,240 ) ); + + //make another group of wxCanvasObjects + wxCanvasObjectGroup* group2 = new wxCanvasObjectGroup(); + group2->Prepend( new wxCanvasImage( image, 60,38,52,32 ) ); + group2->Prepend( new wxCanvasRect(10,20,104,52,10,40,10 ) ); + + //this a reference to group2 put into group1 + wxCanvasObjectGroupRef* m_subref = new wxCanvasObjectGroupRef(60,50, group2); + group1->Prepend( m_subref ); + + //now make two refrences to group1 into root group of the canvas + m_ref = new MywxCanvasObjectGroupRef(40,200, group1); + m_canvas->Prepend( m_ref ); + + m_ref2 = new MywxCanvasObjectGroupRef(80,350, group1); + m_canvas->Prepend( m_ref2 ); +*/ + + m_log = new wxTextCtrl( this, -1, "", wxPoint(0,0), wxSize(100,100), wxTE_MULTILINE ); + wxLog *old_log = wxLog::SetActiveTarget( new wxLogTextCtrl( m_log ) ); + delete old_log; + + wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL ); + + topsizer->Add( m_canvas, 1, wxEXPAND ); + topsizer->Add( m_log, 0, wxEXPAND ); + + SetAutoLayout( TRUE ); + SetSizer( topsizer ); + + m_timer = new wxTimer( this ); + m_timer->Start( 100, FALSE ); +} + +MyFrame::~MyFrame() +{ + delete m_timer; +} + +void MyFrame::OnQuit( wxCommandEvent &WXUNUSED(event) ) +{ + Close( TRUE ); +} + +void MyFrame::OnTimer( wxTimerEvent &WXUNUSED(event) ) +{ + m_sm1->Move( m_sm1->GetX()+1, m_sm1 ->GetY() ); + m_sm2->Move( m_sm2->GetX()+1, m_sm2->GetY() ); + m_sm3->Move( m_sm3->GetX()+1, m_sm3->GetY() ); + m_sm4->Move( m_sm4->GetX()+2, m_sm4->GetY() ); +/* + m_ref->Move( m_ref->GetPosX()+1, m_ref->GetPosY() ); + m_ref2->Move( m_ref2->GetPosX()+2, m_ref2->GetPosY() ); +*/ + + wxWakeUpIdle(); +} + +void MyFrame::OnAbout( wxCommandEvent &WXUNUSED(event) ) +{ + (void)wxMessageBox( "wxCanvas demo\n" + "Robert Roebling (c) 1998,2000", + "About wxCanvas Demo", wxICON_INFORMATION | wxOK ); +} + +//----------------------------------------------------------------------------- +// MyApp +//----------------------------------------------------------------------------- + +bool MyApp::OnInit() +{ + m_fontpath = getenv("TRUETYPE"); + if ( !m_fontpath ) + { + wxLogError("Please set env var TRUETYPE to the path where times.ttf lives."); + + return FALSE; + + } + +#if wxUSE_LIBPNG + wxImage::AddHandler( new wxPNGHandler ); +#endif + + wxFrame *frame = new MyFrame(); + frame->Show( TRUE ); + + return TRUE; +} + + diff --git a/contrib/samples/xml/Makefile.in b/contrib/samples/xml/Makefile.in new file mode 100644 index 0000000000..79cccd5622 --- /dev/null +++ b/contrib/samples/xml/Makefile.in @@ -0,0 +1,23 @@ +############################################################################### +# Purpose: Makefile.in for xml resources sample for Unix with autoconf +# Created: 17.09.00 +# Author: VS +# Version: $Id$ +############################################################################### + +top_srcdir = @top_srcdir@/.. +top_builddir = ../../.. +program_dir = contrib/samples/xml + +PROGRAM=xmldemo + +OBJECTS=$(PROGRAM).o + +APPEXTRALIBS=$(top_builddir)/lib/libwxxml.@WX_TARGET_LIBRARY_TYPE@ +APPEXTRADEFS=-I$(top_srcdir)/contrib/include + +DATADIRS = rc +DATAFILES = rc/resource.xml rc/fileopen.gif rc/filesave.gif rc/fuzzy.gif \ + rc/quotes.gif rc/scanning.gif rc/update.gif + +include $(top_builddir)/src/makeprog.env diff --git a/contrib/samples/xml/XmlDemoVC.dsp b/contrib/samples/xml/XmlDemoVC.dsp new file mode 100644 index 0000000000..cde0b5d6ab --- /dev/null +++ b/contrib/samples/xml/XmlDemoVC.dsp @@ -0,0 +1,175 @@ +# Microsoft Developer Studio Project File - Name="XmlDemoVC" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Application" 0x0101 + +CFG=XmlDemoVC - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "XmlDemoVC.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "XmlDemoVC.mak" CFG="XmlDemoVC - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "XmlDemoVC - Win32 Release" (based on "Win32 (x86) Application") +!MESSAGE "XmlDemoVC - Win32 Debug" (based on "Win32 (x86) Application") +!MESSAGE "XmlDemoVC - Win32 Debug DLL" (based on "Win32 (x86) Application") +!MESSAGE "XmlDemoVC - Win32 Release DLL" (based on "Win32 (x86) Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +MTL=midl.exe +RSC=rc.exe + +!IF "$(CFG)" == "XmlDemoVC - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c +# ADD CPP /nologo /MD /W3 /GX /O1 /Ob2 /I "../../../include" /I "../../../contrib/include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /FD /c +# SUBTRACT CPP /YX +# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32 +# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32 +# ADD BASE RSC /l 0x809 /d "NDEBUG" +# ADD RSC /l 0x809 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wx.lib xpm.lib png.lib zlib.lib jpeg.lib tiff.lib wxxml.lib /nologo /subsystem:windows /machine:I386 /nodefaultlib:"libc.lib" /nodefaultlib:"libci.lib" /nodefaultlib:"msvcrtd.lib" /out:"Release/xmldemo.exe" /libpath:"../../../lib" /libpath:"../../../contrib/lib" + +!ELSEIF "$(CFG)" == "XmlDemoVC - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c +# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../../../include" /I "../../../contrib/include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D DEBUG=1 /D "__WXDEBUG__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /Yu"wx/wxprec.h" /FD /c +# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32 +# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32 +# ADD BASE RSC /l 0x809 /d "_DEBUG" +# ADD RSC /l 0x809 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxd.lib xpmd.lib pngd.lib zlibd.lib jpegd.lib tiffd.lib wxxmld.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libcd.lib" /nodefaultlib:"libcid.lib" /nodefaultlib:"msvcrt.lib" /out:"Debug/xmldemo.exe" /pdbtype:sept /libpath:"../../../lib" /libpath:"../../../contrib/lib" + +!ELSEIF "$(CFG)" == "XmlDemoVC - Win32 Debug DLL" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "DebugDLL" +# PROP BASE Intermediate_Dir "DebugDLL" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "DebugDLL" +# PROP Intermediate_Dir "DebugDLL" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c +# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../../../include" /I "../../../contrib/include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D DEBUG=1 /D "__WXDEBUG__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /D WXUSINGDLL=1 /Yu"wx/wxprec.h" /FD /c +# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32 +# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32 +# ADD BASE RSC /l 0x809 /d "_DEBUG" +# ADD RSC /l 0x809 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxdlld.lib wxxmld.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libcd.lib" /nodefaultlib:"libcid.lib" /out:"DebugDLL/xmldemo.exe" /pdbtype:sept /libpath:"../../../lib" /libpath:"../../../contrib/lib" + +!ELSEIF "$(CFG)" == "XmlDemoVC - Win32 Release DLL" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "ReleaseDLL" +# PROP BASE Intermediate_Dir "ReleaseDLL" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "ReleaseDLL" +# PROP Intermediate_Dir "ReleaseDLL" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c +# ADD CPP /nologo /MD /W3 /GX /O1 /Ob2 /I "../../../include" /I "../../../contrib/include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /D WXUSINGDLL=1 /FD /c +# SUBTRACT CPP /YX +# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32 +# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32 +# ADD BASE RSC /l 0x809 /d "NDEBUG" +# ADD RSC /l 0x809 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib winmm.lib /nologo /subsystem:windows /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxdll.lib wxxml.lib /nologo /subsystem:windows /machine:I386 /nodefaultlib:"libc.lib" /nodefaultlib:"libci.lib" /out:"ReleaseDLL/xmldemo.exe" /libpath:"../../../lib" /libpath:"../../../contrib/lib" + +!ENDIF + +# Begin Target + +# Name "XmlDemoVC - Win32 Release" +# Name "XmlDemoVC - Win32 Debug" +# Name "XmlDemoVC - Win32 Debug DLL" +# Name "XmlDemoVC - Win32 Release DLL" +# Begin Source File + +SOURCE=.\xmldemo.cpp + +!IF "$(CFG)" == "XmlDemoVC - Win32 Release" + +!ELSEIF "$(CFG)" == "XmlDemoVC - Win32 Debug" + +# SUBTRACT CPP /YX /Yc /Yu + +!ELSEIF "$(CFG)" == "XmlDemoVC - Win32 Debug DLL" + +# SUBTRACT BASE CPP /YX /Yc /Yu +# SUBTRACT CPP /YX /Yc /Yu + +!ELSEIF "$(CFG)" == "XmlDemoVC - Win32 Release DLL" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=.\xmldemo.rc +# ADD BASE RSC /l 0x809 +# ADD RSC /l 0x809 /i "../../../include" /i "../../../contrib/include" +# End Source File +# End Target +# End Project diff --git a/contrib/samples/xml/XmlDemoVC.dsw b/contrib/samples/xml/XmlDemoVC.dsw new file mode 100644 index 0000000000..91323cfef4 --- /dev/null +++ b/contrib/samples/xml/XmlDemoVC.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! + +############################################################################### + +Project: "XmlDemoVC"=.\XmlDemoVC.dsp - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + diff --git a/contrib/samples/xml/makefile.b32 b/contrib/samples/xml/makefile.b32 new file mode 100644 index 0000000000..98340af6b7 --- /dev/null +++ b/contrib/samples/xml/makefile.b32 @@ -0,0 +1,18 @@ +# +# File: makefile.b32 +# Author: Julian Smart +# Created: 1999 +# Updated: +# Copyright: +# +# Makefile : Builds sample for 32-bit BC++ + +WXDIR = $(WXWIN) + +TARGET=xmldemo + +EXTRALIBS=$(WXDIR)\contrib\lib\wxxml.lib +OBJECTS = $(TARGET).obj + +!include $(WXDIR)\src\makeprog.b32 + diff --git a/contrib/samples/xml/makefile.g95 b/contrib/samples/xml/makefile.g95 new file mode 100644 index 0000000000..8377fef413 --- /dev/null +++ b/contrib/samples/xml/makefile.g95 @@ -0,0 +1,14 @@ +# File: makefile.g95 for stectrl +# Author: Robin Dunn +# Created: 1-Feb-2000 +# Updated: + +WXDIR = ../../.. + +TARGET = xmldemo +OBJECTS = $(TARGET).o +EXTRAINC = -I$(WXDIR)/contrib/include +EXTRALIBS = -lwxxml + +include $(WXDIR)/src/makeprog.g95 + diff --git a/contrib/samples/xml/makefile.vc b/contrib/samples/xml/makefile.vc new file mode 100644 index 0000000000..d10e084feb --- /dev/null +++ b/contrib/samples/xml/makefile.vc @@ -0,0 +1,14 @@ +# File: makefile.vc For stectrl +# Author: Robin Dunn +# Created: 1-Feb-2000 +# Updated: + +WXDIR = $(WXWIN) +PROGRAM = xmldemo + +OBJECTS = $(PROGRAM).obj +EXTRALIBS = $(WXDIR)\contrib\lib\wxxml$(LIBEXT).lib +EXTRAINC = -I$(WXDIR)\contrib\include + +!include $(WXDIR)\src\makeprog.vc + diff --git a/contrib/samples/xml/rc/appicon.ico b/contrib/samples/xml/rc/appicon.ico new file mode 100644 index 0000000000..6082b2fd0a Binary files /dev/null and b/contrib/samples/xml/rc/appicon.ico differ diff --git a/contrib/samples/xml/rc/appicon.xpm b/contrib/samples/xml/rc/appicon.xpm new file mode 100644 index 0000000000..948961fe5c --- /dev/null +++ b/contrib/samples/xml/rc/appicon.xpm @@ -0,0 +1,61 @@ +/* XPM */ +static char* appicon_xpm[]={ +"32 32 26 1", +"s c #000000", +"u c #ff8000", +"m c #ffc0ff", +"q c #400000", +". c None", +"t c #004040", +"d c #303030", +"n c #ffdca8", +"e c #c0c0c0", +"x c #808000", +"o c #c00000", +"c c #585858", +"b c #a0a0a4", +"f c #c000c0", +"# c #000000", +"i c #808080", +"p c #ffa858", +"v c #ffff00", +"k c #800000", +"w c #c0c000", +"r c #004000", +"h c #404000", +"j c #ffc0c0", +"a c #ffffff", +"l c #c05800", +"g c #ff0000", +".....#####...........##.........", +"...##abbccd........##c#.........", +"###aaaebfgh########abi#.........", +"#cbaaaejggkiibeeaaaeeic#........", +"#ieaaaefggldggfjmnaaeei#........", +"#ibeaajggggcggggfmaaabi#b.......", +"#iieaajggggolgggggmaaeec#.......", +"#cieaajgggggdgggggpmaeec#.......", +"#cieaajgggggqgggggggaabi#.......", +"#dieaajpgggcc##cggggaaebc###....", +"#ribaamecccccs##cgggaebccth##...", +"#dieaa#qtdcch###tcs#iichd####...", +"##cbea##dccccs##qhhccccct#####..", +"##iiea##rhccch##tsdtcccdh#####..", +"##cbea###tccookk#hrdhccccs####..", +"##ciea###koogookkddtcccch###q#..", +"##tiea##qoggggokkqhqccccckokkk#.", +"##hbeb#qkoogggookkqkoklkoookkk#.", +"###icb#kkooggggokkdkogggggookk#.", +"###d..#kkoogggouukqkooggggookk#.", +"##....#kkkoguvvvwuhkogggggooko#.", +"##....##kolwvvvvvulcllggggulll#.", +"##....##kuuvvvvvuvudwuuuuuvuuu#.", +"......##uuuuvvvvvuuqivvvvvvuuu#.", +"......##uuuvvwwiqcllhuvvvvvuuu#.", +"......##uuuwl##xuphdivvvvvvvul#.", +"......##uuu##e.#vltcuvuvvvvux#..", +"......##ux#e....###uuww######...", +"......##i#......bbb####.........", +"......###.......................", +"......##........................", +"......##........................"}; diff --git a/contrib/samples/xml/rc/fileopen.gif b/contrib/samples/xml/rc/fileopen.gif new file mode 100644 index 0000000000..a93ef2aab7 Binary files /dev/null and b/contrib/samples/xml/rc/fileopen.gif differ diff --git a/contrib/samples/xml/rc/filesave.gif b/contrib/samples/xml/rc/filesave.gif new file mode 100644 index 0000000000..7bd11de000 Binary files /dev/null and b/contrib/samples/xml/rc/filesave.gif differ diff --git a/contrib/samples/xml/rc/fuzzy.gif b/contrib/samples/xml/rc/fuzzy.gif new file mode 100644 index 0000000000..51683572a3 Binary files /dev/null and b/contrib/samples/xml/rc/fuzzy.gif differ diff --git a/contrib/samples/xml/rc/quotes.gif b/contrib/samples/xml/rc/quotes.gif new file mode 100644 index 0000000000..3ea61bde43 Binary files /dev/null and b/contrib/samples/xml/rc/quotes.gif differ diff --git a/contrib/samples/xml/rc/resource.xrc b/contrib/samples/xml/rc/resource.xrc new file mode 100644 index 0000000000..e031a548cd --- /dev/null +++ b/contrib/samples/xml/rc/resource.xrc @@ -0,0 +1,119 @@ + + + + + + + + + + filesave.gif + + + + + + + + + + + + + + + + + 2,2 + + fileopen.gif + Open catalog + + + filesave.gif + Save catalog + + + update.gif + Update catalog - synchronize it with sources + + + + quotes.gif + 1 + Display quotes around the string? + + + + fuzzy.gif + Toggled if selected string is fuzzy translation + 1 + + + + + + + fuzzy.gif + fileopen.gif + + + + + + + + + + wxALIGN_CENTER + + + + + + 10d + wxALL + + + + <h1>Hi,</h1>man + 100,45d + + + + + + + + + + Hello, we are inside a <u>NOTEBOOK</u>... + 50,50d + + + + + + + + + + + + + Hello, we are inside a <u>NOTEBOOK</u>... + 50,50d + + + + + + + 1 + + wxEXPAND + + wxVERTICAL + + + diff --git a/contrib/samples/xml/rc/scanning.gif b/contrib/samples/xml/rc/scanning.gif new file mode 100644 index 0000000000..c1b1e15caf Binary files /dev/null and b/contrib/samples/xml/rc/scanning.gif differ diff --git a/contrib/samples/xml/rc/update.gif b/contrib/samples/xml/rc/update.gif new file mode 100644 index 0000000000..d6ef70a421 Binary files /dev/null and b/contrib/samples/xml/rc/update.gif differ diff --git a/contrib/samples/xml/xmldemo.cpp b/contrib/samples/xml/xmldemo.cpp new file mode 100644 index 0000000000..9564d25abd --- /dev/null +++ b/contrib/samples/xml/xmldemo.cpp @@ -0,0 +1,168 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: xmldemo.cpp +// Purpose: XML resources sample +// Author: Vaclav Slavik +// RCS-ID: $Id$ +// Copyright: (c) Vaclav Slavik +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- +#ifdef __GNUG__ + #pragma implementation "xmldemo.cpp" + #pragma interface "xmldemo.cpp" +#endif + +// For compilers that support precompilation, includes "wx/wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ + #pragma hdrstop +#endif + +// for all others, include the necessary headers (this file is usually all you +// need because it includes almost all "standard" wxWindows headers) +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#include "wx/image.h" +#include "wx/xml/xmlres.h" + +// ---------------------------------------------------------------------------- +// resources +// ---------------------------------------------------------------------------- +// the application icon +#if defined(__WXGTK__) || defined(__WXMOTIF__) + #include "rc/appicon.xpm" +#endif + +// ---------------------------------------------------------------------------- +// private classes +// ---------------------------------------------------------------------------- + +// Define a new application type, each program should derive a class from wxApp +class MyApp : public wxApp +{ +public: + // override base class virtuals + // ---------------------------- + + // this one is called on application startup and is a good place for the app + // initialization (doing it here and not in the ctor allows to have an error + // return: if OnInit() returns false, the application terminates) + virtual bool OnInit(); +}; + +// Define a new frame type: this is going to be our main frame +class MyFrame : public wxFrame +{ +public: + // ctor(s) + MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size); + + // event handlers (these functions should _not_ be virtual) + void OnQuit(wxCommandEvent& event); + void OnAbout(wxCommandEvent& event); + void OnDlg1(wxCommandEvent& event); + void OnDlg2(wxCommandEvent& event); + +private: + // any class wishing to process wxWindows events must use this macro + DECLARE_EVENT_TABLE() +}; + +// ---------------------------------------------------------------------------- +// event tables and other macros for wxWindows +// ---------------------------------------------------------------------------- + +// the event tables connect the wxWindows events with the functions (event +// handlers) which process them. It can be also done at run-time, but for the +// simple menu events like this the static method is much simpler. +BEGIN_EVENT_TABLE(MyFrame, wxFrame) + EVT_MENU(XMLID("menu_quit"), MyFrame::OnQuit) + EVT_MENU(XMLID("menu_about"), MyFrame::OnAbout) + EVT_MENU(XMLID("menu_dlg1"), MyFrame::OnDlg1) + EVT_MENU(XMLID("menu_dlg2"), MyFrame::OnDlg2) +END_EVENT_TABLE() + +// Create a new application object: this macro will allow wxWindows to create +// the application object during program execution (it's better than using a +// static object for many reasons) and also declares the accessor function +// wxGetApp() which will return the reference of the right type (i.e. MyApp and +// not wxApp) +IMPLEMENT_APP(MyApp) + +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// the application class +// ---------------------------------------------------------------------------- + +// 'Main program' equivalent: the program execution "starts" here +bool MyApp::OnInit() +{ + wxImage::AddHandler(new wxGIFHandler); + wxTheXmlResource->InitAllHandlers(); + wxTheXmlResource->Load("rc/resource.xrc"); + + MyFrame *frame = new MyFrame("XML resources demo", + wxPoint(50, 50), wxSize(450, 340)); + frame->Show(TRUE); + return TRUE; +} + +// ---------------------------------------------------------------------------- +// main frame +// ---------------------------------------------------------------------------- + +// frame constructor +MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size) + : wxFrame((wxFrame *)NULL, -1, title, pos, size) +{ + SetIcon(wxICON(appicon)); + + SetMenuBar(wxTheXmlResource->LoadMenuBar("mainmenu")); + SetToolBar(wxTheXmlResource->LoadToolBar(this, "toolbar")); +} + + +// event handlers + +void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event)) +{ + // TRUE is to force the frame to close + Close(TRUE); +} + +void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event)) +{ + wxString msg; + msg.Printf( _T("This is the about dialog of XML resources demo.\n") + _T("Welcome to %s"), wxVERSION_STRING); + + wxMessageBox(msg, "About XML resources demo", wxOK | wxICON_INFORMATION, this); +} + +void MyFrame::OnDlg1(wxCommandEvent& WXUNUSED(event)) +{ + wxDialog dlg; + wxTheXmlResource->LoadDialog(&dlg, this, "dlg1"); + dlg.ShowModal(); +} + + +void MyFrame::OnDlg2(wxCommandEvent& WXUNUSED(event)) +{ + wxDialog dlg; + wxTheXmlResource->LoadDialog(&dlg, this, "dlg2"); + dlg.ShowModal(); +} diff --git a/contrib/samples/xml/xmldemo.rc b/contrib/samples/xml/xmldemo.rc new file mode 100644 index 0000000000..a5b2ce34e2 --- /dev/null +++ b/contrib/samples/xml/xmldemo.rc @@ -0,0 +1,2 @@ +appicon ICON "rc/appicon.ico" +#include "wx/msw/wx.rc" diff --git a/contrib/src/canvas/Makefile.in b/contrib/src/canvas/Makefile.in new file mode 100644 index 0000000000..3cf2445e2a --- /dev/null +++ b/contrib/src/canvas/Makefile.in @@ -0,0 +1,23 @@ +# $Id$ + +top_srcdir = @top_srcdir@/.. +top_builddir = ../../.. +libsrc_dir = contrib/src/canvas + +TARGET_LIBNAME=libcanvas + +LIBVERSION_CURRENT=1 +LIBVERSION_REVISION=0 +LIBVERSION_AGE=0 + +HEADER_PATH=$(top_srcdir)/contrib/include/wx +HEADER_SUBDIR=canvas + +HEADERS=canvas.h + +OBJECTS=canvas.o + +APPEXTRADEFS=-I$(top_srcdir)/contrib/include + +include $(top_builddir)/src/makelib.env + diff --git a/contrib/src/canvas/canvas.cpp b/contrib/src/canvas/canvas.cpp new file mode 100644 index 0000000000..1be997526a --- /dev/null +++ b/contrib/src/canvas/canvas.cpp @@ -0,0 +1,1827 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: canvas.cpp +// Author: Robert Roebling +// Created: XX/XX/XX +// Copyright: 2000 (c) Robert Roebling +// Licence: wxWindows Licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ + #pragma implementation "canvas.cpp" +#endif + +// For compilers that support precompilation, includes "wx/wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ + #pragma hdrstop +#endif + +#include "wx/canvas/canvas.h" + +#ifdef __WXGTK__ + #include + #include + #include "wx/gtk/win_gtk.h" +#endif + +#ifndef wxUSE_FREETYPE + #define wxUSE_FREETYPE 1 +#endif + +#if wxUSE_FREETYPE + #include +#endif + +//---------------------------------------------------------------------------- +// globals +//---------------------------------------------------------------------------- + +#if wxUSE_FREETYPE +FT_Library g_freetypeLibrary; +#endif + +//---------------------------------------------------------------------------- +// wxCanvasObject +//---------------------------------------------------------------------------- + +wxCanvasObject::wxCanvasObject() +{ + m_owner = NULL; + m_area.x = -1; + m_area.y = -1; + m_area.width = -1; + m_area.height = -1; + m_isControl = FALSE; + m_isVector = FALSE; + m_isImage = FALSE; +} + +void wxCanvasObject::SetArea( int x, int y, int width, int height ) +{ + m_area.x = x; + m_area.y = y; + m_area.width = width; + m_area.height = height; +} + +void wxCanvasObject::SetArea( wxRect rect ) +{ + m_area.x = rect.x; + m_area.y = rect.y; + m_area.width = rect.width; + m_area.height = rect.height; +} + +void wxCanvasObject::Move( int x, int y ) +{ + int old_x = m_area.x; + int old_y = m_area.y; + + m_area.x = x; + m_area.y = y; + + if (!m_isControl) + { + // TODO: sometimes faster to merge into 1 Update or + // to break up into four + m_owner->Update( old_x, old_y, m_area.width, m_area.height ); + m_owner->Update( x, y, m_area.width, m_area.height ); + } +} + +bool wxCanvasObject::IsHit( int x, int y, int margin ) +{ + return ((x >= m_area.x-margin) && + (x <= m_area.x+m_area.width+margin) && + (y >= m_area.y-margin) && + (y <= m_area.y+m_area.height+margin)); +} + +void wxCanvasObject::CaptureMouse() +{ + m_owner->SetCaptureMouse( this ); +} + +void wxCanvasObject::ReleaseMouse() +{ + m_owner->SetCaptureMouse( NULL ); +} + +bool wxCanvasObject::IsCapturedMouse() +{ + return m_owner->m_captureMouse==this; +} + + +void wxCanvasObject::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ) +{ +} + +void wxCanvasObject::Recreate() +{ +} + +void wxCanvasObject::WriteSVG( wxTextOutputStream &stream ) +{ +} + +//---------------------------------------------------------------------------- +// wxCanvasObjectGroup +//---------------------------------------------------------------------------- + +wxCanvasObjectGroup::wxCanvasObjectGroup() +{ + m_validbounds = FALSE; +} + +wxCanvasObjectGroup::~wxCanvasObjectGroup() +{ +} + +void wxCanvasObjectGroup::SetOwner(wxCanvas* canvas) +{ + m_owner=canvas; + wxNode *node = m_objects.First(); + while (node) + { + wxCanvasObject *obj = (wxCanvasObject*) node->Data(); + + obj->SetOwner(canvas); + + node = node->Next(); + } +} + +void wxCanvasObjectGroup::ExtendArea(double x, double y) +{ + if (m_validbounds) + { + if (x < m_minx) m_minx = x; + if (y < m_miny) m_miny = y; + if (x > m_maxx) m_maxx = x; + if (y > m_maxy) m_maxy = y; + } + else + { + m_validbounds = TRUE; + + m_minx = x; + m_miny = y; + m_maxx = x; + m_maxy = y; + } +} + +void wxCanvasObjectGroup::DeleteContents( bool flag) +{ + m_objects.DeleteContents( flag ); + m_validbounds = FALSE; +} + +void wxCanvasObjectGroup::Prepend( wxCanvasObject* obj ) +{ + m_objects.Insert( obj ); + m_validbounds = FALSE; +} + +void wxCanvasObjectGroup::Append( wxCanvasObject* obj ) +{ + m_objects.Append( obj ); + m_validbounds = FALSE; +} + +void wxCanvasObjectGroup::Insert( size_t before, wxCanvasObject* obj ) +{ + m_objects.Insert( before, obj ); + m_validbounds = FALSE; +} + +void wxCanvasObjectGroup::Remove( wxCanvasObject* obj ) +{ + m_objects.DeleteObject( obj ); + m_validbounds = FALSE; +} + +void wxCanvasObjectGroup::Recreate() +{ + m_validbounds = FALSE; + wxNode *node = m_objects.First(); + while (node) + { + wxCanvasObject *obj = (wxCanvasObject*) node->Data(); + + obj->Recreate(); + ExtendArea(obj->GetX(),obj->GetY()); + ExtendArea(obj->GetX()+obj->GetWidth(),obj->GetY()+obj->GetHeight()); + + node = node->Next(); + } +} + +void wxCanvasObjectGroup::Render(int xabs, int yabs, int x, int y, int width, int height ) +{ + // cycle through all objects + wxNode *node = m_objects.First(); + while (node) + { + wxCanvasObject *obj = (wxCanvasObject*) node->Data(); + + if (!obj->IsControl()) + { + // If we have 10.000 objects, we will go through + // this 10.000 times for each update, so we have + // to optimise carefully. + int clip_x = xabs + obj->GetX(); + int clip_width = obj->GetWidth(); + if (clip_x < x) + { + clip_width -= x-clip_x; + clip_x = x; + } + if (clip_width > 0) + { + if (clip_x + clip_width > x + width) + clip_width = x+width-clip_x; + + if (clip_width > 0) + { + int clip_y = yabs + obj->GetY(); + int clip_height = obj->GetHeight(); + if (clip_y < y) + { + clip_height -= y-clip_y; + clip_y = y; + } + if (clip_height > 0) + { + if (clip_y + clip_height > y + height) + clip_height = y+height-clip_y; + + if (clip_height > 0) + obj->Render(xabs,yabs, clip_x, clip_y, clip_width, clip_height ); + } + } + } + } + + node = node->Next(); + } +} + +void wxCanvasObjectGroup::WriteSVG( wxTextOutputStream &stream ) +{ +} + +bool wxCanvasObjectGroup::IsHit( int x, int y, int margin ) +{ + wxNode *node = m_objects.Last(); + while (node) + { + wxCanvasObject *obj = (wxCanvasObject*) node->Data(); + + if (!obj->IsControl()) + { + if (obj->IsHit(x,y,margin)) + { + return TRUE; + } + } + node = node->Previous(); + } + return FALSE; +} + +wxCanvasObject* wxCanvasObjectGroup::IsHitObject( int x, int y, int margin ) +{ + wxCanvasObject *obj=0; + wxNode *node = m_objects.Last(); + while (node) + { + obj=(wxCanvasObject*) node->Data(); + + if (!obj->IsControl()) + { + if (obj->IsHit(x,y,margin)) + { + return obj; + } + } + node = node->Previous(); + } + + return (wxCanvasObject*) NULL; +} + +//---------------------------------------------------------------------------- +// wxCanvasObjectGroupRef +//---------------------------------------------------------------------------- + +wxCanvasObjectGroupRef::wxCanvasObjectGroupRef(double x, double y, wxCanvasObjectGroup* group) + : wxCanvasObject() +{ + m_x = x; + m_y = y; + m_validbounds = FALSE; + m_group = group; +} + +void wxCanvasObjectGroupRef::SetOwner(wxCanvas* canvas) +{ + m_owner = canvas; + m_group->SetOwner(canvas); +} + +void wxCanvasObjectGroupRef::ExtendArea(double x, double y) +{ + if (m_validbounds) + { + if (x < m_minx) m_minx = x; + if (y < m_miny) m_miny = y; + if (x > m_maxx) m_maxx = x; + if (y > m_maxy) m_maxy = y; + } + else + { + m_validbounds = TRUE; + + m_minx = x; + m_miny = y; + m_maxx = x; + m_maxy = y; + } +} + +void wxCanvasObjectGroupRef::Recreate() +{ + m_validbounds = FALSE; + m_group->Recreate(); + ExtendArea(m_group->GetXMin(),m_group->GetYMin()); + ExtendArea(m_group->GetXMax(),m_group->GetYMax()); + + //set the area in pixels relative to the parent + SetArea( m_owner->GetDeviceX( m_x + m_minx ), + m_owner->GetDeviceY( m_y + m_miny ), + m_owner->GetDeviceWidth( m_maxx-m_minx ), + m_owner->GetDeviceHeight( m_maxy-m_miny ) ); +} + +void wxCanvasObjectGroupRef::Render(int xabs, int yabs, int x, int y, int width, int height ) +{ + xabs += m_area.x; + yabs += m_area.y; + + int clip_x = xabs + m_group->GetXMin(); + int clip_width = m_group->GetXMax()-m_group->GetXMin(); + if (clip_x < x) + { + clip_width -= x-clip_x; + clip_x = x; + } + if (clip_width > 0) + { + if (clip_x + clip_width > x + width) + clip_width = x+width-clip_x; + + if (clip_width > 0) + { + int clip_y = yabs + m_group->GetYMin(); + int clip_height = m_group->GetYMax()-m_group->GetYMin(); + if (clip_y < y) + { + clip_height -= y-clip_y; + clip_y = y; + } + if (clip_height > 0) + { + if (clip_y + clip_height > y + height) + clip_height = y+height-clip_y; + + if (clip_height > 0) + m_group->Render(xabs,yabs, clip_x, clip_y, clip_width, clip_height ); + } + } + } +} + +void wxCanvasObjectGroupRef::WriteSVG( wxTextOutputStream &stream ) +{ +} + +bool wxCanvasObjectGroupRef::IsHit( int x, int y, int margin ) +{ + return m_group->IsHit(x-GetPosX(),y-GetPosY(),margin); +} + +wxCanvasObject* wxCanvasObjectGroupRef::IsHitObject( int x, int y, int margin ) +{ + return m_group->IsHitObject(x-GetPosX(),y-GetPosY(),margin); +} + +void wxCanvasObjectGroupRef::Move( int x, int y ) +{ + m_x = x; + m_y = y; + + int old_area_x = m_area.x; + int old_area_y = m_area.y; + + m_area.x=m_owner->GetDeviceX( m_x + m_minx ); + m_area.y=m_owner->GetDeviceY( m_y + m_miny ); + + int leftu,rightu,bottomu,topu ; + leftu = wxMin (m_area.x, old_area_x ) ; + rightu = wxMax (old_area_x + m_area.width, m_area.x + m_area.width) ; + topu = wxMin (m_area.y,old_area_y) ; + bottomu = wxMax (old_area_y + m_area.height, m_area.y + m_area.height) ; + + if ( rightu - leftu < 2*m_area.width && bottomu - topu < 2*m_area.height ) + { + m_owner->Update(leftu,topu,rightu - leftu,bottomu - topu); + } + else + { + m_owner->Update(old_area_x, old_area_y, m_area.width, m_area.height ); + m_owner->Update( m_area.x, m_area.y, m_area.width, m_area.height ); + } +} + +//---------------------------------------------------------------------------- +// wxCanvasPolyline +//---------------------------------------------------------------------------- + +wxCanvasPolyline::wxCanvasPolyline( int n, wxPoint2DDouble points[]) + : wxCanvasObject() +{ + m_n = n; + m_points = points; + m_pen = *wxBLACK_PEN; +} + +wxCanvasPolyline::~wxCanvasPolyline() +{ + delete m_points; +} + +void wxCanvasPolyline::ExtendArea(double x, double y) +{ + if (m_validbounds) + { + if (x < m_minx) m_minx = x; + if (y < m_miny) m_miny = y; + if (x > m_maxx) m_maxx = x; + if (y > m_maxy) m_maxy = y; + } + else + { + m_validbounds = TRUE; + + m_minx = x; + m_miny = y; + m_maxx = x; + m_maxy = y; + } +} + +void wxCanvasPolyline::Recreate() +{ + + m_validbounds=FALSE; + int i; + for (i=0; i < m_n;i++) + { + ExtendArea(m_points[i].m_x,m_points[i].m_y); + } + + //include the pen width also + ExtendArea(m_minx -m_pen.GetWidth(),m_miny-m_pen.GetWidth()); + ExtendArea(m_maxx+m_pen.GetWidth()*2,m_maxy+m_pen.GetWidth()*2); + + //set the area in pixels relative to the parent + SetArea( m_owner->GetDeviceX(m_minx ), + m_owner->GetDeviceY(m_miny ), + m_owner->GetDeviceWidth( m_maxx-m_minx ), + m_owner->GetDeviceHeight( m_maxy-m_miny ) ); +} + +void wxCanvasPolyline::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ) +{ + int buffer_x = m_owner->GetBufferX(); + int buffer_y = m_owner->GetBufferY(); + + int start_y = clip_y - buffer_y; + int end_y = clip_y+clip_height - buffer_y; + + int start_x = clip_x - buffer_x; + int end_x = clip_x+clip_width - buffer_x; + +#if IMAGE_CANVAS +#else + wxPoint *cpoints = new wxPoint[m_n]; + int i; + for (i = 0; i < m_n; i++) + { + cpoints[i].x = m_owner->GetDeviceX(m_points[i].m_x+xabs); + cpoints[i].y = m_owner->GetDeviceY(m_points[i].m_y+yabs); + } + wxMemoryDC *dc = m_owner->GetDC(); + dc->SetClippingRegion(start_x,start_y,end_x-start_x,end_y-start_y); + dc->SetPen(m_pen); + dc->DrawLines(m_n, cpoints, 0,0); + delete [] cpoints; + dc->SetPen(wxNullPen); + dc->DestroyClippingRegion(); +#endif +} + +void wxCanvasPolyline::WriteSVG( wxTextOutputStream &stream ) +{ +} + +//---------------------------------------------------------------------------- +// wxCanvasPolygon +//---------------------------------------------------------------------------- + +wxCanvasPolygon::wxCanvasPolygon( int n, wxPoint2DDouble points[]) + : wxCanvasObject() +{ + m_n = n; + m_points = points; + m_brush = *wxBLACK_BRUSH; + m_pen = *wxTRANSPARENT_PEN; +} + +wxCanvasPolygon::~wxCanvasPolygon() +{ + delete m_points; +} + +void wxCanvasPolygon::ExtendArea(double x, double y) +{ + if (m_validbounds) + { + if (x < m_minx) m_minx = x; + if (y < m_miny) m_miny = y; + if (x > m_maxx) m_maxx = x; + if (y > m_maxy) m_maxy = y; + } + else + { + m_validbounds = TRUE; + + m_minx = x; + m_miny = y; + m_maxx = x; + m_maxy = y; + } +} + +void wxCanvasPolygon::Recreate() +{ + + m_validbounds=FALSE; + int i; + for (i=0; i < m_n;i++) + { + ExtendArea(m_points[i].m_x,m_points[i].m_y); + } + + //include the pen width also + ExtendArea(m_minx -m_pen.GetWidth(),m_miny-m_pen.GetWidth()); + ExtendArea(m_maxx+m_pen.GetWidth()*2,m_maxy+m_pen.GetWidth()*2); + + //set the area in pixels relative to the parent + SetArea( m_owner->GetDeviceX( m_minx ), + m_owner->GetDeviceY( m_miny ), + m_owner->GetDeviceWidth( m_maxx-m_minx ), + m_owner->GetDeviceHeight( m_maxy-m_miny ) ); +} + +void wxCanvasPolygon::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ) +{ + int buffer_x = m_owner->GetBufferX(); + int buffer_y = m_owner->GetBufferY(); + + int start_y = clip_y - buffer_y; + int end_y = clip_y+clip_height - buffer_y; + + int start_x = clip_x - buffer_x; + int end_x = clip_x+clip_width - buffer_x; + +#if IMAGE_CANVAS +#else + wxPoint *cpoints = new wxPoint[m_n]; + int i; + for (i = 0; i < m_n; i++) + { + cpoints[i].x = m_owner->GetDeviceX(m_points[i].m_x+xabs); + cpoints[i].y = m_owner->GetDeviceY(m_points[i].m_y+yabs); + } + wxMemoryDC *dc = m_owner->GetDC(); + dc->SetClippingRegion(start_x,start_y,end_x-start_x,end_y-start_y); + dc->SetBrush(m_brush); + dc->SetPen(m_pen); + dc->DrawPolygon(m_n, cpoints, 0,0,wxWINDING_RULE); + delete [] cpoints; + dc->SetBrush(wxNullBrush); + dc->SetPen(wxNullPen); + dc->DestroyClippingRegion(); +#endif +} + +void wxCanvasPolygon::WriteSVG( wxTextOutputStream &stream ) +{ +} + + + +//---------------------------------------------------------------------------- +// wxCanvasRect +//---------------------------------------------------------------------------- + +wxCanvasRect::wxCanvasRect( double x, double y, double w, double h ) + : wxCanvasObject() +{ + m_x = x; + m_y = y; + m_width = w; + m_height = h; + + m_brush = *wxBLACK_BRUSH; + m_pen = *wxTRANSPARENT_PEN; +} + +void wxCanvasRect::Recreate() +{ + SetArea( m_owner->GetDeviceX( m_x ), + m_owner->GetDeviceY( m_y ), + m_owner->GetDeviceWidth( m_width ), + m_owner->GetDeviceHeight( m_height ) ); +} + +void wxCanvasRect::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ) +{ + int buffer_x = m_owner->GetBufferX(); + int buffer_y = m_owner->GetBufferY(); + +#if IMAGE_CANVAS + wxImage *image = m_owner->GetBuffer(); + + int start_y = clip_y - buffer_y; + int end_y = clip_y+clip_height - buffer_y; + + int start_x = clip_x - buffer_x; + int end_x = clip_x+clip_width - buffer_x; + + // speed up later + for (int y = start_y; y < end_y; y++) + for (int x = start_x; x < end_x; x++) + image->SetRGB( x, y, m_red, m_green, m_blue ); +#else + wxMemoryDC *dc = m_owner->GetDC(); + dc->SetPen( m_pen ); + dc->SetBrush( m_brush ); + dc->DrawRectangle( clip_x-buffer_x, clip_y-buffer_y, clip_width, clip_height ); +#endif +} + +void wxCanvasRect::WriteSVG( wxTextOutputStream &stream ) +{ +} + +//---------------------------------------------------------------------------- +// wxCanvasLine +//---------------------------------------------------------------------------- + +wxCanvasLine::wxCanvasLine( double x1, double y1, double x2, double y2 ) + : wxCanvasObject() +{ + m_x1 = x1; + m_y1 = y1; + m_x2 = x2; + m_y2 = y2; + + m_pen = *wxBLACK_PEN; +} + +void wxCanvasLine::Recreate() +{ + int x1 = m_owner->GetDeviceX( m_x1 ); + int y1 = m_owner->GetDeviceY( m_y1 ); + int x2 = m_owner->GetDeviceX( m_x2 ); + int y2 = m_owner->GetDeviceY( m_y2 ); + if (x1 > x2) + { + int tmp = x1; + x1 = x2; + x2 = tmp; + } + if (y1 > y2) + { + int tmp = y1; + y1 = y2; + y2 = tmp; + } + SetArea( x1, y1, x2-x1+1, y2-y1+1 ); +} + +void wxCanvasLine::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ) +{ + int buffer_x = m_owner->GetBufferX(); + int buffer_y = m_owner->GetBufferY(); + + int x1 = xabs + m_owner->GetDeviceX( m_x1 ); + int y1 = yabs + m_owner->GetDeviceY( m_y1 ); + int x2 = xabs + m_owner->GetDeviceX( m_x2 ); + int y2 = yabs + m_owner->GetDeviceY( m_y2 ); + +#if IMAGE_CANVAS + wxImage *image = m_owner->GetBuffer(); + if ((m_area.width == 0) && (m_area.height == 0)) + { + image->SetRGB( m_area.x-buffer_x, m_area.y-buffer_y, m_red, m_green, m_blue ); + } + else + { + wxInt32 d, ii, jj, di, ai, si, dj, aj, sj; + di = x1 - x2; + ai = abs(di) << 1; + si = (di < 0)? -1 : 1; + dj = y1 - y2; + aj = abs(dj) << 1; + sj = (dj < 0)? -1 : 1; + + ii = x2; + jj = y2; + + if (ai > aj) + { + // iterate over i + d = aj - (ai >> 1); + + while (ii != x1) + { + if ((ii >= clip_x) && (ii < clip_x+clip_width) && + (jj >= clip_y) && (jj < clip_y+clip_height)) + { + image->SetRGB( ii-buffer_x, jj-buffer_y, m_red, m_blue, m_green ); + } + if (d >= 0) + { + jj += sj; + d -= ai; + } + ii += si; + d += aj; + } + } + else + { + // iterate over j + d = ai - (aj >> 1); + + while (jj != y1) + { + if ((ii >= clip_x) && (ii < clip_x+clip_width) && + (jj >= clip_y) && (jj < clip_y+clip_height)) + { + image->SetRGB( ii-buffer_x, jj-buffer_y, m_red, m_blue, m_green ); + } + if (d >= 0) + { + ii += si; + d -= aj; + } + jj += sj; + d += ai; + } + } + } +#else + wxMemoryDC *dc = m_owner->GetDC(); + dc->SetClippingRegion( clip_x-buffer_x, clip_y-buffer_y, clip_width, clip_height ); + dc->SetPen( m_pen ); + dc->DrawLine( x1-buffer_x, y1-buffer_y, x2-buffer_x, y2-buffer_y ); + + dc->DestroyClippingRegion(); +#endif +} + +void wxCanvasLine::WriteSVG( wxTextOutputStream &stream ) +{ + // no idea +} + +//---------------------------------------------------------------------------- +// wxCanvasImage +//---------------------------------------------------------------------------- + +wxCanvasImage::wxCanvasImage( const wxImage &image, double x, double y, double w, double h ) + : wxCanvasObject() +{ + m_x = x; + m_y = y; + m_width = w; + m_height = h; + + m_image = image; + m_isImage = TRUE; +} + +void wxCanvasImage::Recreate() +{ + SetArea( m_owner->GetDeviceX( m_x ), + m_owner->GetDeviceY( m_y ), + m_owner->GetDeviceWidth( m_width ), + m_owner->GetDeviceHeight( m_height ) ); + +#if IMAGE_CANVAS + if ((m_area.width == m_image.GetWidth()) && + (m_area.width == m_image.GetWidth())) + { + m_tmp = m_image; + } + else + { + m_tmp = m_image.Scale( m_area.width, m_area.height ); + } +#else + if ((m_area.width == m_image.GetWidth()) && + (m_area.width == m_image.GetWidth())) + { + m_tmp = m_image.ConvertToBitmap(); + } + else + { + wxImage tmp( m_image.Scale( m_area.width, m_area.height ) ); + m_tmp = tmp.ConvertToBitmap(); + } +#endif +} + +void wxCanvasImage::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ) +{ + int buffer_x = m_owner->GetBufferX(); + int buffer_y = m_owner->GetBufferY(); + +#if IMAGE_CANVAS + if ((clip_x == xabs + m_area.x) && + (clip_y == yabs + m_area.y) && + (clip_width == m_area.width) && + (clip_height == m_area.height)) + { + m_owner->GetBuffer()->Paste( m_tmp, clip_x-buffer_x, clip_y-buffer_y ); + } + else + { + // local coordinates + int start_x = clip_x - (xabs + m_area.x); + int start_y = clip_y - (yabs + m_area.y); + + wxRect rect( start_x, start_y, clip_width, clip_height ); + wxImage sub_image( m_tmp.GetSubImage( rect ) ); + m_owner->GetBuffer()->Paste( sub_image, clip_x-buffer_x, clip_y-buffer_y ); + } +#else + wxMemoryDC *dc = m_owner->GetDC(); + + if ((clip_x == xabs + m_area.x) && + (clip_y == yabs + m_area.y) && + (clip_width == m_area.width) && + (clip_height == m_area.height)) + { + dc->DrawBitmap( m_tmp, clip_x-buffer_x, clip_y-buffer_y, TRUE ); + } + else + { + // local coordinates + int start_x = clip_x - (xabs + m_area.x); + int start_y = clip_y - (yabs + m_area.y); + + // Clipping region faster ? + wxRect rect( start_x, start_y, clip_width, clip_height ); + wxBitmap sub_bitmap( m_tmp.GetSubBitmap( rect ) ); + dc->DrawBitmap( sub_bitmap, clip_x-buffer_x, clip_y-buffer_y, TRUE ); + } +#endif +} + +void wxCanvasImage::WriteSVG( wxTextOutputStream &stream ) +{ + // no idea +} + +//---------------------------------------------------------------------------- +// wxCanvasCtrl +//---------------------------------------------------------------------------- + +wxCanvasControl::wxCanvasControl( wxWindow *control ) + : wxCanvasObject() +{ + m_isControl = TRUE; + m_control = control; +} + +wxCanvasControl::~wxCanvasControl() +{ + m_control->Destroy(); +} + +void wxCanvasControl::Recreate() +{ + m_control->GetSize( &m_area.width, &m_area.height ); + m_control->GetPosition( &m_area.x, &m_area.y ); +} + +void wxCanvasControl::Move( int x, int y ) +{ + m_control->Move( x, y ); +} + +//---------------------------------------------------------------------------- +// wxCanvasText +//---------------------------------------------------------------------------- + +class wxFaceData +{ +public: +#if wxUSE_FREETYPE + FT_Face m_face; +#else + void *m_dummy; +#endif +}; + +wxCanvasText::wxCanvasText( const wxString &text, double x, double y, const wxString &fontFile, int size ) + : wxCanvasObject() +{ + m_text = text; + m_fontFileName = fontFile; + m_size = size; + + m_red = 0; + m_green = 0; + m_blue = 0; + + m_alpha = NULL; + + m_x = x; + m_y = y; + +#if wxUSE_FREETYPE + wxFaceData *data = new wxFaceData; + m_faceData = data; + + int error = FT_New_Face( g_freetypeLibrary, + m_fontFileName, + 0, + &(data->m_face) ); + + error = FT_Set_Char_Size( data->m_face, + 0, + m_size*64, + 96, // screen dpi + 96 ); +#endif +} + +wxCanvasText::~wxCanvasText() +{ +#if wxUSE_FREETYPE + wxFaceData *data = (wxFaceData*) m_faceData; + delete data; +#endif + + if (m_alpha) delete [] m_alpha; +} + +void wxCanvasText::SetRGB( unsigned char red, unsigned char green, unsigned char blue ) +{ + m_red = red; + m_green = green; + m_blue = blue; +} + +void wxCanvasText::SetFlag( int flag ) +{ + m_flag = flag; +} + +void wxCanvasText::Render(int xabs, int yabs, int clip_x, int clip_y, int clip_width, int clip_height ) +{ + if (!m_alpha) return; + + int buffer_x = m_owner->GetBufferX(); + int buffer_y = m_owner->GetBufferY(); + +#if IMAGE_CANVAS + wxImage *image = m_owner->GetBuffer(); + + // local coordinates + int start_x = clip_x - m_area.x; + int end_x = clip_width + start_x; + int start_y = clip_y - m_area.y; + int end_y = clip_height + start_y; + + for (int y = start_y; y < end_y; y++) + for (int x = start_x; x < end_x; x++) + { + int alpha = m_alpha[y*m_area.width + x]; + if (alpha) + { + int image_x = m_area.x+x - buffer_x; + int image_y = m_area.y+y - buffer_y; + if (alpha == 255) + { + image->SetRGB( image_x, image_y, m_red, m_green, m_blue ); + continue; + } + int red1 = (m_red * alpha) / 255; + int green1 = (m_green * alpha) / 255; + int blue1 = (m_blue * alpha) / 255; + + alpha = 255-alpha; + int red2 = image->GetRed( image_x, image_y ); + int green2 = image->GetGreen( image_x, image_y ); + int blue2 = image->GetBlue( image_x, image_y ); + red2 = (red2 * alpha) / 255; + green2 = (green2 * alpha) / 255; + blue2 = (blue2 * alpha) / 255; + + image->SetRGB( image_x, image_y, red1+red2, green1+green2, blue1+blue2 ); + } + } +#else + wxBitmap *bitmap = m_owner->GetBuffer(); + wxRect sub_rect( clip_x-buffer_x, clip_y-buffer_y, clip_width, clip_height ); + wxBitmap sub_bitmap( bitmap->GetSubBitmap( sub_rect ) ); + + wxImage image( sub_bitmap ); + + // local coordinates + int start_x = clip_x - m_area.x; + int end_x = clip_width + start_x; + int start_y = clip_y - m_area.y; + int end_y = clip_height + start_y; + + for (int y = start_y; y < end_y; y++) + for (int x = start_x; x < end_x; x++) + { + int alpha = m_alpha[y*m_area.width + x]; + if (alpha) + { + int image_x = x - start_x; + int image_y = y - start_y; + if (alpha == 255) + { + image.SetRGB( image_x, image_y, m_red, m_green, m_blue ); + continue; + } + int red1 = (m_red * alpha) / 255; + int green1 = (m_green * alpha) / 255; + int blue1 = (m_blue * alpha) / 255; + + alpha = 255-alpha; + int red2 = image.GetRed( image_x, image_y ); + int green2 = image.GetGreen( image_x, image_y ); + int blue2 = image.GetBlue( image_x, image_y ); + red2 = (red2 * alpha) / 255; + green2 = (green2 * alpha) / 255; + blue2 = (blue2 * alpha) / 255; + + image.SetRGB( image_x, image_y, red1+red2, green1+green2, blue1+blue2 ); + } + } + + sub_bitmap = image.ConvertToBitmap(); + + wxMemoryDC *dc = m_owner->GetDC(); + dc->DrawBitmap( sub_bitmap, clip_x-buffer_x, clip_y-buffer_y ); +#endif +} + +void wxCanvasText::WriteSVG( wxTextOutputStream &stream ) +{ +} + +void wxCanvasText::Recreate() +{ + if (m_alpha) delete [] m_alpha; + + m_area.x = m_owner->GetDeviceX( m_x ); + m_area.y = m_owner->GetDeviceY( m_y ); + + m_area.width = 100; // TODO calculate length + m_area.height = m_size + (m_size/2); // TODO space for sub-baseline (pgypq) + m_alpha = new unsigned char[m_area.width*m_area.height]; + memset( m_alpha, 0, m_area.width*m_area.height ); + +#if wxUSE_FREETYPE + FT_Face face = ((wxFaceData*)m_faceData)->m_face; + FT_GlyphSlot slot = face->glyph; + int pen_x = 0; + int pen_y = m_size; + + for (int n = 0; n < (int)m_text.Len(); n++) + { + FT_UInt index = FT_Get_Char_Index( face, m_text[n] ); + + int error = FT_Load_Glyph( face, index, FT_LOAD_DEFAULT ); + if (error) continue; + + error = FT_Render_Glyph( face->glyph, ft_render_mode_normal ); + if (error) continue; + + FT_Bitmap *bitmap = &slot->bitmap; + unsigned char* buffer = bitmap->buffer; + for (int y = 0; y < bitmap->rows; y++) + for (int x = 0; x < bitmap->width; x++) + { + unsigned char alpha = buffer[ y*bitmap->pitch + x ]; + if (alpha == 0) continue; + + int xx = pen_x + slot->bitmap_left + x; + int yy = pen_y - slot->bitmap_top + y; + m_alpha[ yy * m_area.width + xx ] = alpha; + } + + pen_x += slot->advance.x >> 6; + pen_y += slot->advance.y >> 6; + } +#endif +} + +//---------------------------------------------------------------------------- +// wxCanvas +//---------------------------------------------------------------------------- + +IMPLEMENT_CLASS(wxCanvas,wxScrolledWindow) + +BEGIN_EVENT_TABLE(wxCanvas,wxScrolledWindow) + EVT_CHAR( wxCanvas::OnChar ) + EVT_PAINT( wxCanvas::OnPaint ) + EVT_SIZE( wxCanvas::OnSize ) + EVT_IDLE( wxCanvas::OnIdle ) + EVT_MOUSE_EVENTS( wxCanvas::OnMouse ) + EVT_SET_FOCUS( wxCanvas::OnSetFocus ) + EVT_KILL_FOCUS( wxCanvas::OnKillFocus ) + EVT_ERASE_BACKGROUND( wxCanvas::OnEraseBackground ) +END_EVENT_TABLE() + +wxCanvas::wxCanvas( wxWindow *parent, wxWindowID id, + const wxPoint &position, const wxSize& size, long style ) : + wxScrolledWindow( parent, id, position, size, style ) +{ + m_bufferX = 0; + m_bufferY = 0; + m_needUpdate = FALSE; + m_red = 0; + m_green = 0; + m_blue = 0; + m_lastMouse = (wxCanvasObject*)NULL; + m_captureMouse = (wxCanvasObject*)NULL; + m_frozen = TRUE; + m_oldDeviceX = 0; + m_oldDeviceY = 0; + + //root group always at 0,0 + m_root = new wxCanvasObjectGroup(); + m_root->DeleteContents( TRUE ); + m_root->SetOwner(this); +} + +wxCanvas::~wxCanvas() +{ + wxNode *node = m_updateRects.First(); + while (node) + { + wxRect *rect = (wxRect*) node->Data(); + delete rect; + m_updateRects.DeleteNode( node ); + node = m_updateRects.First(); + } +} + +void wxCanvas::SetArea( int width, int height ) +{ + SetScrollbars( 10, 10, width/10, height/10 ); +} + +void wxCanvas::SetColour( unsigned char red, unsigned char green, unsigned char blue ) +{ + m_red = red; + m_green = green; + m_blue = blue; + + SetBackgroundColour( wxColour( red, green, blue ) ); + + if (m_frozen) return; + +#if IMAGE_CANVAS + unsigned char *data = m_buffer.GetData(); + + for (int y = 0; y < m_buffer.GetHeight(); y++) + for (int x = 0; x < m_buffer.GetWidth(); x++) + { + data[0] = red; + data++; + data[0] = green; + data++; + data[0] = blue; + data++; + } +#else + wxMemoryDC dc; + dc.SelectObject( m_buffer ); + dc.SetPen( *wxTRANSPARENT_PEN ); + wxBrush brush( wxColour( red,green,blue), wxSOLID ); + dc.SetBrush( brush ); + dc.DrawRectangle( 0, 0, m_buffer.GetWidth(), m_buffer.GetHeight() ); + dc.SelectObject( wxNullBitmap ); +#endif +} + +void wxCanvas::SetCaptureMouse( wxCanvasObject *obj ) +{ + if (obj) + { + wxWindow::CaptureMouse(); + m_captureMouse = obj; + } + else + { + wxWindow::ReleaseMouse(); + m_captureMouse = NULL; + } +} + +void wxCanvas::Freeze() +{ + m_frozen = TRUE; +} + +void wxCanvas::Thaw() +{ + wxNode *node = m_updateRects.First(); + while (node) + { + wxRect *rect = (wxRect*) node->Data(); + delete rect; + m_updateRects.DeleteNode( node ); + node = m_updateRects.First(); + } + + m_frozen = FALSE; + + if (m_buffer.Ok()) + Update( m_bufferX, m_bufferY, m_buffer.GetWidth(), m_buffer.GetHeight() ); +} + +void wxCanvas::Update( int x, int y, int width, int height, bool blit ) +{ + CalcScrolledPosition( 0, 0, &m_oldDeviceX, &m_oldDeviceY ); + + if (m_frozen) return; + + // clip to buffer + if (x < m_bufferX) + { + width -= m_bufferX-x; + x = m_bufferX; + } + if (width <= 0) return; + + if (y < m_bufferY) + { + height -= m_bufferY-y; + y = m_bufferY; + } + if (height <= 0) return; + + if (x+width > m_bufferX+m_buffer.GetWidth()) + { + width = m_bufferX+m_buffer.GetWidth() - x; + } + if (width <= 0) return; + + if (y+height > m_bufferY+m_buffer.GetHeight()) + { + height = m_bufferY+m_buffer.GetHeight() - y; + } + if (height <= 0) return; + + // update is within the buffer + m_needUpdate = TRUE; + + // has to be blitted to screen later + if (blit) + { + m_updateRects.Append( + (wxObject*) new wxRect( x,y,width,height ) ); + } + +#if IMAGE_CANVAS + // speed up with direct access, maybe add wxImage::Clear(x,y,w,h,r,g,b) + int start_y = y - m_bufferY; + int end_y = y+height - m_bufferY; + int start_x = x - m_bufferX; + int end_x = x+width - m_bufferX; + for (int yy = start_y; yy < end_y; yy++) + for (int xx = start_x; xx < end_x; xx++) + m_buffer.SetRGB( xx, yy, m_red, m_green, m_blue ); + + m_root->Render(0,0, x, y, width, height ); +#else + wxMemoryDC dc; + dc.SelectObject( m_buffer ); + dc.SetPen( *wxTRANSPARENT_PEN ); + wxBrush brush( wxColour( m_red,m_green,m_blue), wxSOLID ); + dc.SetBrush( brush ); + dc.DrawRectangle( x-m_bufferX, y-m_bufferY, width, height ); + + m_renderDC = &dc; + m_root->Render(0,0, x, y, width, height ); + + dc.SelectObject( wxNullBitmap ); +#endif +} + +void wxCanvas::BlitBuffer( wxDC &dc ) +{ + wxNode *node = m_updateRects.First(); + while (node) + { + wxRect *rect = (wxRect*) node->Data(); + + wxRect sub_rect( *rect ); + sub_rect.x -= m_bufferX; + sub_rect.y -= m_bufferY; + +#if IMAGE_CANVAS + + wxImage sub_image( m_buffer.GetSubImage( sub_rect ) ); +#ifdef __WXGTK__ + int bpp = wxDisplayDepth(); + if (bpp > 8) + { + // the init code is doubled in wxImage + static bool s_hasInitialized = FALSE; + + if (!s_hasInitialized) + { + gdk_rgb_init(); + s_hasInitialized = TRUE; + } + + gdk_draw_rgb_image( GTK_PIZZA(m_wxwindow)->bin_window, + m_wxwindow->style->black_gc, + sub_rect.x, sub_rect.y, + sub_image.GetWidth(), sub_image.GetHeight(), + GDK_RGB_DITHER_NONE, + sub_image.GetData(), + sub_image.GetWidth()*3 ); + } + else + { + wxBitmap bitmap( sub_image.ConvertToBitmap() ); + dc.DrawBitmap( bitmap, rect->x, rect->y ); + } +#else + wxBitmap bitmap( sub_image.ConvertToBitmap() ); + dc.DrawBitmap( bitmap, rect->x, rect->y ); +#endif + +#else // IMAGE_CANVAS + + // Maybe clipping use SetClipping() is faster than + // getting the subrect first and drawing it then? + wxBitmap sub_bitmap( m_buffer.GetSubBitmap( sub_rect ) ); + dc.DrawBitmap( sub_bitmap, rect->x, rect->y ); + +#endif + delete rect; + m_updateRects.DeleteNode( node ); + node = m_updateRects.First(); + } + + m_needUpdate = FALSE; +} + +void wxCanvas::UpdateNow() +{ + if (m_frozen) return; + + if (!m_needUpdate) return; + + wxClientDC dc( this ); + PrepareDC( dc ); + + BlitBuffer( dc ); +} + +int wxCanvas::GetDeviceX( double x ) +{ + return (int) x; +} + +int wxCanvas::GetDeviceY( double y ) +{ + return (int) y; +} + +int wxCanvas::GetDeviceWidth( double width ) +{ + return (int) width; +} + +int wxCanvas::GetDeviceHeight( double height ) +{ + return (int) height; +} + +void wxCanvas::Recreate() +{ + m_root->Recreate(); +} + +void wxCanvas::Prepend( wxCanvasObject* obj ) +{ + m_root->Prepend( obj ); + obj->SetOwner(this); + + m_root->Recreate(); + + if (!obj->IsControl()) + Update( obj->GetX(), obj->GetY(), obj->GetWidth(), obj->GetHeight() ); +} + +void wxCanvas::Append( wxCanvasObject* obj ) +{ + m_root->Append( obj ); + obj->SetOwner(this); + + m_root->Recreate(); + + if (!obj->IsControl()) + Update( obj->GetX(), obj->GetY(), obj->GetWidth(), obj->GetHeight() ); +} + +void wxCanvas::Insert( size_t before, wxCanvasObject* obj ) +{ + m_root->Insert( before, obj ); + obj->SetOwner(this); + + m_root->Recreate(); + + if (!obj->IsControl()) + Update( obj->GetX(), obj->GetY(), obj->GetWidth(), obj->GetHeight() ); +} + +void wxCanvas::Remove( wxCanvasObject* obj ) +{ + int x = obj->GetX(); + int y = obj->GetY(); + int w = obj->GetWidth(); + int h = obj->GetHeight(); + bool ic = obj->IsControl(); + + m_root->Remove( obj ); + + if (!ic) + Update( x, y, w, h ); +} + +void wxCanvas::OnPaint(wxPaintEvent &event) +{ + wxPaintDC dc(this); + PrepareDC( dc ); + + if (!m_buffer.Ok()) return; + + if (m_frozen) return; + + m_needUpdate = TRUE; + + wxRegionIterator it( GetUpdateRegion() ); + while (it) + { + int x = it.GetX(); + int y = it.GetY(); + + int w = it.GetWidth(); + int h = it.GetHeight(); + + if (x+w > m_buffer.GetWidth()) + w = m_buffer.GetWidth() - x; + if (y+h > m_buffer.GetHeight()) + h = m_buffer.GetHeight() - y; + + if ((w > 0) && (h > 0)) + { + CalcUnscrolledPosition( x, y, &x, &y ); + m_updateRects.Append( (wxObject*) new wxRect( x, y, w, h ) ); + } + + it++; + } + + BlitBuffer( dc ); +} + +void wxCanvas::ScrollWindow( int dx, int dy, const wxRect* rect ) +{ + // If any updates are pending, do them now since they will + // expect the previous m_bufferX and m_bufferY as well as + // the previous device origin values. + wxClientDC dc( this ); + dc.SetDeviceOrigin( m_oldDeviceX, m_oldDeviceY ); + BlitBuffer( dc ); + + // The buffer always starts at the top left corner of the + // client area. Indeed, it is the client area. + CalcUnscrolledPosition( 0, 0, &m_bufferX, &m_bufferY ); + +#if IMAGE_CANVAS + unsigned char* data = m_buffer.GetData(); + + if (dy != 0) + { + if (dy > 0) + { + unsigned char *source = data; + unsigned char *dest = data + (dy * m_buffer.GetWidth() * 3); + size_t count = (size_t) (m_buffer.GetWidth() * 3 * (m_buffer.GetHeight()-dy)); + memmove( dest, source, count ); + + // We update the new buffer area, but there is no need to + // blit (last param FALSE) since the ensuing paint event will + // do that anyway. + Update( m_bufferX, m_bufferY, m_buffer.GetWidth(), dy, FALSE ); + } + else + { + unsigned char *dest = data; + unsigned char *source = data + (-dy * m_buffer.GetWidth() * 3); + size_t count = (size_t) (m_buffer.GetWidth() * 3 * (m_buffer.GetHeight()+dy)); + memmove( dest, source, count ); + + // We update the new buffer area, but there is no need to + // blit (last param FALSE) since the ensuing paint event will + // do that anyway. + Update( m_bufferX, m_bufferY+m_buffer.GetHeight()+dy, m_buffer.GetWidth(), -dy, FALSE ); + } + } + + if (dx != 0) + { + if (dx > 0) + { + unsigned char *source = data; + for (int y = 0; y < m_buffer.GetHeight(); y++) + { + unsigned char *dest = source + dx*3; + memmove( dest, source, (m_buffer.GetWidth()-dx) * 3 ); + source += m_buffer.GetWidth()*3; + } + + // We update the new buffer area, but there is no need to + // blit (last param FALSE) since the ensuing paint event will + // do that anyway. + Update( m_bufferX, m_bufferY, dx, m_buffer.GetHeight(), FALSE ); + } + else + { + unsigned char *dest = data; + for (int y = 0; y < m_buffer.GetHeight(); y++) + { + unsigned char *source = dest - dx*3; + memmove( dest, source, (m_buffer.GetWidth()+dx) * 3 ); + dest += m_buffer.GetWidth()*3; + } + + // We update the new buffer area, but there is no need to + // blit (last param FALSE) since the ensuing paint event will + // do that anyway. + Update( m_bufferX+m_buffer.GetWidth()+dx, m_bufferY, -dx, m_buffer.GetHeight(), FALSE ); + } + } +#else + // Update everything, TODO: scrolling + Update( m_bufferX, m_bufferY, m_buffer.GetWidth(), m_buffer.GetHeight(), FALSE ); +#endif + + wxWindow::ScrollWindow( dx, dy, rect ); +} + +void wxCanvas::OnMouse(wxMouseEvent &event) +{ + int x = event.GetX(); + int y = event.GetY(); + CalcUnscrolledPosition( x, y, &x, &y ); + + if (event.GetEventType() == wxEVT_MOTION) + { + if (m_captureMouse) //no matter what go to this one + { + wxMouseEvent child_event( wxEVT_MOTION ); + child_event.SetEventObject(m_captureMouse); + child_event.m_x = x - m_captureMouse->GetX(); + child_event.m_y = y - m_captureMouse->GetY(); + child_event.m_leftDown = event.m_leftDown; + child_event.m_rightDown = event.m_rightDown; + child_event.m_middleDown = event.m_middleDown; + child_event.m_controlDown = event.m_controlDown; + child_event.m_shiftDown = event.m_shiftDown; + child_event.m_altDown = event.m_altDown; + child_event.m_metaDown = event.m_metaDown; + + m_captureMouse->ProcessEvent( child_event ); + return; + } + else + { + wxCanvasObject *obj = m_root->IsHitObject(x,y,0); + + if (obj && !obj->IsControl()) + { + wxMouseEvent child_event( wxEVT_MOTION ); + child_event.SetEventObject( obj ); + child_event.m_x = x - obj->GetX(); + child_event.m_y = y - obj->GetY(); + child_event.m_leftDown = event.m_leftDown; + child_event.m_rightDown = event.m_rightDown; + child_event.m_middleDown = event.m_middleDown; + child_event.m_controlDown = event.m_controlDown; + child_event.m_shiftDown = event.m_shiftDown; + child_event.m_altDown = event.m_altDown; + child_event.m_metaDown = event.m_metaDown; + + if ((obj != m_lastMouse) && (m_lastMouse != NULL)) + { + child_event.SetEventType( wxEVT_LEAVE_WINDOW ); + child_event.SetEventObject( m_lastMouse ); + child_event.m_x = x - m_lastMouse->GetX(); + child_event.m_y = y - m_lastMouse->GetY(); + m_lastMouse->ProcessEvent( child_event ); + + m_lastMouse = obj; + child_event.SetEventType( wxEVT_ENTER_WINDOW ); + child_event.SetEventObject( m_lastMouse ); + child_event.m_x = x - m_lastMouse->GetX(); + child_event.m_y = y - m_lastMouse->GetY(); + m_lastMouse->ProcessEvent( child_event ); + + child_event.SetEventType( wxEVT_MOTION ); + child_event.SetEventObject( obj ); + } + + obj->ProcessEvent( child_event ); + return; + } + } + if (m_lastMouse) + { + wxMouseEvent child_event( wxEVT_LEAVE_WINDOW ); + child_event.SetEventObject( m_lastMouse ); + child_event.m_x = x - m_lastMouse->GetX(); + child_event.m_y = y - m_lastMouse->GetY(); + child_event.m_leftDown = event.m_leftDown; + child_event.m_rightDown = event.m_rightDown; + child_event.m_middleDown = event.m_middleDown; + child_event.m_controlDown = event.m_controlDown; + child_event.m_shiftDown = event.m_shiftDown; + child_event.m_altDown = event.m_altDown; + child_event.m_metaDown = event.m_metaDown; + m_lastMouse->ProcessEvent( child_event ); + + m_lastMouse = (wxCanvasObject*) NULL; + return; + } + } + else + { + if (m_captureMouse) //no matter what go to this one + { + wxMouseEvent child_event( event.GetEventType() ); + child_event.SetEventObject(m_captureMouse); + child_event.m_x = x - m_captureMouse->GetX(); + child_event.m_y = y - m_captureMouse->GetY(); + child_event.m_leftDown = event.m_leftDown; + child_event.m_rightDown = event.m_rightDown; + child_event.m_middleDown = event.m_middleDown; + child_event.m_controlDown = event.m_controlDown; + child_event.m_shiftDown = event.m_shiftDown; + child_event.m_altDown = event.m_altDown; + child_event.m_metaDown = event.m_metaDown; + m_captureMouse->ProcessEvent( child_event ); + } + else + { + wxCanvasObject *obj = m_root->IsHitObject(x,y,0); + + if (obj && !obj->IsControl()) + { + wxMouseEvent child_event( event.GetEventType() ); + child_event.SetEventObject( obj ); + child_event.m_x = x - obj->GetX(); + child_event.m_y = y - obj->GetY(); + child_event.m_leftDown = event.m_leftDown; + child_event.m_rightDown = event.m_rightDown; + child_event.m_middleDown = event.m_middleDown; + child_event.m_controlDown = event.m_controlDown; + child_event.m_shiftDown = event.m_shiftDown; + child_event.m_altDown = event.m_altDown; + child_event.m_metaDown = event.m_metaDown; + + obj->ProcessEvent( child_event ); + return; + } + } + } + + event.Skip(); +} + +void wxCanvas::OnSize(wxSizeEvent &event) +{ + int w,h; + GetClientSize( &w, &h ); +#if IMAGE_CANVAS + m_buffer = wxImage( w, h ); +#else + m_buffer = wxBitmap( w, h ); +#endif + + CalcUnscrolledPosition( 0, 0, &m_bufferX, &m_bufferY ); + + wxNode *node = m_updateRects.First(); + while (node) + { + wxRect *rect = (wxRect*) node->Data(); + delete rect; + m_updateRects.DeleteNode( node ); + node = m_updateRects.First(); + } + + m_frozen = FALSE; + + Update( m_bufferX, m_bufferY, m_buffer.GetWidth(), m_buffer.GetHeight(), FALSE ); + + event.Skip(); +} + +void wxCanvas::OnIdle(wxIdleEvent &event) +{ + UpdateNow(); + event.Skip(); +} + +void wxCanvas::OnSetFocus(wxFocusEvent &event) +{ +} + +void wxCanvas::OnKillFocus(wxFocusEvent &event) +{ +} + +void wxCanvas::OnChar(wxKeyEvent &event) +{ + event.Skip(); +} + +void wxCanvas::OnEraseBackground(wxEraseEvent &event) +{ +} + +//-------------------------------------------------------------------- +// wxCanvasModule +//-------------------------------------------------------------------- + +class wxCanvasModule : public wxModule +{ +public: + virtual bool OnInit(); + virtual void OnExit(); + +private: + DECLARE_DYNAMIC_CLASS(wxCanvasModule) +}; + +IMPLEMENT_DYNAMIC_CLASS(wxCanvasModule, wxModule) + +bool wxCanvasModule::OnInit() +{ +#if wxUSE_FREETYPE + int error = FT_Init_FreeType( &g_freetypeLibrary ); + if (error) return FALSE; +#endif + + return TRUE; +} + +void wxCanvasModule::OnExit() +{ +#if wxUSE_FREETYPE + FT_Done_FreeType( g_freetypeLibrary ); +#endif +} diff --git a/contrib/src/stc/scintilla/include/PosRegExp.h b/contrib/src/stc/scintilla/include/PosRegExp.h new file mode 100644 index 0000000000..b915b1ed49 --- /dev/null +++ b/contrib/src/stc/scintilla/include/PosRegExp.h @@ -0,0 +1,138 @@ +#ifndef POSREGEXP_H +#define POSREGEXP_H + +#define MatchesNum 0x10 + +enum EOps +{ + ReBlockOps = 0x1000, + ReMul, // * + RePlus, // + + ReQuest, // ? + ReNGMul, // *? + ReNGPlus, // +? + ReNGQuest, // ?? + ReRangeN, // {n,} + ReRangeNM, // {n,m} + ReNGRangeN, // {n,}? + ReNGRangeNM, // {n,m}? + ReOr, // | + ReBehind = 0x1100, // ?#n + ReNBehind = 0x1200, // ?~n + ReAhead = 0x1300, // ?= + ReNAhead = 0x1400, // ?! + + ReSymbolOps = 0x2000, + ReEmpty, + ReSymb, // a b \W \s ... + ReEnum, // [] + ReNEnum, // [^] + ReBrackets, // (...) + ReBkTrace = 0x2100, // \yN + ReBkBrack = 0x2200 // \N +}; + +enum ESymbols +{ + ReAnyChr = 0x4000, // . + ReSoL, // ^ + ReEoL, // $ + ReDigit, // \d + ReNDigit, // \D + ReWordSymb, // \w + ReNWordSymb, // \W + ReWSpace, // \s + ReNWSpace, // \S + ReUCase, // \u + ReNUCase , // \l + ReWBound, // \b + ReNWBound, // \B + RePreNW, // \c + ReStart, // \m + ReEnd, // \M + + ReChr = 0x0 // Char in Lower Byte +}; +enum ETempSymb +{ + ReTemp = 0x7000, + ReLBrack, ReRBrack, + ReEnumS, ReEnumE, ReNEnumS, + ReRangeS, ReRangeE, ReNGRangeE, ReFrToEnum +}; + +#define BackSlash '\\' + +typedef union SCharData +{ + int IArr[8]; + char CArr[32]; + void SetBit(unsigned char Bit); + void ClearBit(unsigned char Bit); + bool GetBit(unsigned char Bit); +} *PCharData; + +typedef struct SRegInfo +{ + SRegInfo(); + ~SRegInfo(); + + EOps Op; + union{ + SRegInfo *Param; + int Symb; + PCharData ChrClass; + }un; + int s,e; + SRegInfo *Parent; + SRegInfo *Next; +} *PRegInfo; + +typedef struct SMatches +{ + int s[MatchesNum]; + int e[MatchesNum]; + int CurMatch; +} *PMatches; + +typedef class PosRegExp +{ + PRegInfo Info; + PMatches BkTrace; + bool NoCase,Extend,NoMoves; + bool Error; + int *Exprn; + int posParse; + int posEnd,posStart; + int posBkStr; + int FirstChar; + + bool SetExprLow(const char *Expr); + bool SetStructs(PRegInfo &Info,int st,int end); + void Optimize(); + bool CheckSymb(int Symb,bool Inc); + bool LowParse(PRegInfo Re); + bool LowParseRe(PRegInfo &Next); + bool LowCheckNext(PRegInfo Re); + bool ParseRe(int posStr); + bool QuickCheck(); +public: + PMatches Matches; + int Ok, CurMatch; + + void *param; + char (*CharAt)(int pos, void *param); + + PosRegExp(); + ~PosRegExp(); + + bool isok(); + bool SetNoMoves(bool Moves); + bool SetBkTrace(int posStr,PMatches Trace); + bool SetExpr(const char *Expr); + bool Parse(int posStr, int posStop, PMatches Mtch); + bool Parse(int posStr,int posSol, int posEol, PMatches Mtch, int Moves = -1); + bool Evaluate(char *Expr, int posStr, PMatches Mtch, char **Res); +} *PPosRegExp; + +#endif /* POSREGEXP_H */ diff --git a/contrib/src/stc/scintilla/include/WinDefs.h b/contrib/src/stc/scintilla/include/WinDefs.h new file mode 100644 index 0000000000..c56f02d810 --- /dev/null +++ b/contrib/src/stc/scintilla/include/WinDefs.h @@ -0,0 +1,183 @@ +// Scintilla source code edit control +// WinDefs.h - the subset of definitions from Windows needed by Scintilla for GTK+ +// Copyright 1998-2000 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef WINDEFS_H +#define WINDEFS_H + +#define WORD short +#define WPARAM unsigned long +#define LPARAM long +#define LRESULT long +#define DWORD long + +#define UINT unsigned int +#define LPSTR char * +#define LONG long + +//#if 0 +/* RTF control */ +#define EM_CANPASTE (1074) +#define EM_CANUNDO (198) +#define EM_CHARFROMPOS (215) +#define EM_EMPTYUNDOBUFFER (205) +#define EM_EXGETSEL (1076) +#define EM_EXLINEFROMCHAR (1078) +#define EM_EXSETSEL (1079) +#define EM_FINDTEXT (1080) +#define EM_FINDTEXTEX (1103) +#define EM_FORMATRANGE (1081) +#define EM_GETFIRSTVISIBLELINE (206) +#define EM_GETLINE (196) +#define EM_GETLINECOUNT (186) +#define EM_GETMARGINS (212) +#define EM_GETMODIFY (184) +#define EM_GETRECT (178) +#define EM_GETSEL (176) +#define EM_GETSELTEXT (1086) +#define EM_GETTEXTRANGE (1099) +#define EM_HIDESELECTION (1087) +#define EM_LINEFROMCHAR (201) +#define EM_LINEINDEX (187) +#define EM_LINELENGTH (193) +#define EM_LINESCROLL (182) +#define EM_POSFROMCHAR (214) +#define EM_REPLACESEL (194) +#define EM_SCROLLCARET (183) +#define EM_SELECTIONTYPE (1090) +#define EM_SETMARGINS (211) +#define EM_SETREADONLY (207) +#define EM_SETSEL (177) +#define EM_UNDO (199) + +#define WM_NULL (0) +#define WM_CLEAR (771) +#define WM_COPY (769) +#define WM_CUT (768) +#define WM_GETTEXT (13) +#define WM_GETTEXTLENGTH (14) +#define WM_PASTE (770) +#define WM_SETTEXT (12) +#define WM_UNDO (772) + +#define EN_CHANGE (768) +#define EN_KILLFOCUS (512) +#define EN_SETFOCUS (256) + +#define EC_LEFTMARGIN 1 +#define EC_RIGHTMARGIN 2 +#define EC_USEFONTINFO 0xffff + +//#endif + +#if 0 +#if PLAT_GTK +#define VK_DOWN GDK_Down +#define VK_UP GDK_Up +#define VK_LEFT GDK_Left +#define VK_RIGHT GDK_Right +#define VK_HOME GDK_Home +#define VK_END GDK_End +#define VK_PRIOR GDK_Page_Up +#define VK_NEXT GDK_Page_Down +#define VK_DELETE GDK_Delete +#define VK_INSERT GDK_Insert +#define VK_ESCAPE GDK_Escape +#define VK_BACK GDK_BackSpace +#define VK_TAB GDK_Tab +#define VK_RETURN GDK_Return +#define VK_ADD GDK_KP_Add +#define VK_SUBTRACT GDK_KP_Subtract +#define VK_DIVIDE GDK_KP_Divide +#endif + +#if PLAT_WX +#define VK_DOWN WXK_DOWN +#define VK_UP WXK_UP +#define VK_LEFT WXK_LEFT +#define VK_RIGHT WXK_RIGHT +#define VK_HOME WXK_HOME +#define VK_END WXK_END +#define VK_PRIOR WXK_PRIOR +#define VK_NEXT WXK_NEXT +#define VK_DELETE WXK_DELETE +#define VK_INSERT WXK_INSERT +#define VK_ESCAPE WXK_ESCAPE +#define VK_BACK WXK_BACK +#define VK_TAB WXK_TAB +#define VK_RETURN WXK_RETURN +#define VK_ADD WXK_ADD +#define VK_SUBTRACT WXK_SUBTRACT +//TODO: +#define VK_DIVIDE WXK_DIVIDE +#endif + +#define SHIFT_PRESSED 1 +#define LEFT_CTRL_PRESSED 2 +#define LEFT_ALT_PRESSED 4 + +// Are these needed any more +#define LPSTR char * +#define LONG long +#define LPDWORD (long *) + +/* SELCHANGE structure */ +#define SEL_EMPTY (0) +#define SEL_TEXT (1) +#define SEL_OBJECT (2) +#define SEL_MULTICHAR (4) +#define SEL_MULTIOBJECT (8) + +struct RECT { + LONG left; + LONG top; + LONG right; + LONG bottom; +}; + +/* FINDREPLACE structure */ + +#define FR_MATCHCASE (0x4) +#define FR_WHOLEWORD (0x2) +#define FR_DOWN (0x1) + +#endif + +#if 0 +struct CHARRANGE { + LONG cpMin; + LONG cpMax; +}; + +struct TEXTRANGE { + CHARRANGE chrg; + LPSTR lpstrText; +}; + +struct FINDTEXTEX { + CHARRANGE chrg; + LPSTR lpstrText; + CHARRANGE chrgText; +}; + +struct NMHDR { + WindowID hwndFrom; + UINT idFrom; + UINT code; +}; + +struct FORMATRANGE { + SurfaceID hdc; + SurfaceID hdcTarget; + RECT rc; + RECT rcPage; + CHARRANGE chrg; +}; +#endif + +//#define MAKELONG(a, b) ((a) | ((b) << 16)) +//#define LOWORD(x) (x & 0xffff) +//#define HIWORD(x) (x >> 16) + +#endif diff --git a/contrib/src/stc/scintilla/src/PosRegExp.cxx b/contrib/src/stc/scintilla/src/PosRegExp.cxx new file mode 100644 index 0000000000..ea719b7c28 --- /dev/null +++ b/contrib/src/stc/scintilla/src/PosRegExp.cxx @@ -0,0 +1,1181 @@ +#include +#include +#include +#include + +#include "PosRegExp.h" + +//Up: /[A-Z \x80-\x9f \xf0 ]/x +//Lo: /[a-z \xa0-\xaf \xe0-\xef \xf1 ]/x +//Wd: /[\d _ A-Z a-z \xa0-\xaf \xe0-\xf1 \x80-\x9f]/x +//* // Dos866 +SCharData UCData = {0x0, 0x0, 0x7fffffe, 0x0, 0xffffffff, 0x0, 0x0, 0x10000}, + LCData = {0x0, 0x0, 0x0, 0x7fffffe, 0x0, 0xffff, 0x0, 0x2ffff}, + WdData = {0x0, 0x3ff0000, 0x87fffffe, 0x7fffffe, 0xffffffff, 0xffff, 0x0, 0x3ffff}, + DigData = {0x0, 0x3ff0000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; +/*/ // cp1251 +SCharData UCData = {0x0, 0x0, 0x7fffffe, 0x0, 0x0, 0x0, 0xffffffff, 0x0}, + LCData = {0x0, 0x0, 0x0, 0x7fffffe, 0x0, 0x0, 0x0, 0xffffffff}, + WdData = {0x0, 0x3ff0000, 0x87fffffe, 0x7fffffe, 0x0, 0x0, 0xffffffff, 0xffffffff}, + DigData = {0x0, 0x3ff0000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; +//*/ + +/////////////////////////////////////////////// + +int GetNumber(int *str,int s,int e) { + int r = 1, num = 0; + if (e < s) return -1; + for(int i = e-1; i >= s; i--) { + if (str[i] > '9' || str[i] < '0') return -1; + num += (str[i] - 0x30)*r; + r *= 10; + }; + return num; + /* + char tmp[20]; + double Res; + if (e == s) return -1; + for (int i = s;i < e;i++) + tmp[i-s] = (char)Str[i]; + tmp[e-s] = 0; + GetNumber(tmp,&Res); + return (int)Res; + */ +}; + +bool IsDigit(char Symb) { + return DigData.GetBit(Symb); +}; +bool IsWord(char Symb) { + return WdData.GetBit(Symb); +}; +bool IsUpperCase(char Symb) { + return UCData.GetBit(Symb); +}; +bool IsLowerCase(char Symb) { + return LCData.GetBit(Symb); +}; +char LowCase(char Chr) { + if (UCData.GetBit(Chr)) + return Chr+0x20; + return Chr; +}; + +/////////////////////////////////////////////// + +SRegInfo::SRegInfo() { + Next = Parent = 0; + un.Param = 0; + Op = ReEmpty; +}; +SRegInfo::~SRegInfo() { + if (Next) delete Next; + if (un.Param) + switch(Op) { + case ReEnum: + case ReNEnum: + delete un.ChrClass; + break; + default: + if (Op > ReBlockOps && Op < ReSymbolOps || Op == ReBrackets) + delete un.Param; + break; + }; +}; + +/////////////////////////////////////////////// + +void SCharData::SetBit(unsigned char Bit) { + int p = Bit/8; + CArr[p] |= (1 << Bit%8); +}; +void SCharData::ClearBit(unsigned char Bit) { + int p = Bit/8; + CArr[p] &= ~(1 << Bit%8); +}; +bool SCharData::GetBit(unsigned char Bit) { + int p = (unsigned char)Bit/8; + return (CArr[p] & (1 << Bit%8))!=0; +}; + +///////////////////////////////////////////////////////////////// +////////////////////// RegExp Class /////////////////////////// +///////////////////////////////////////////////////////////////// + +PosRegExp::PosRegExp() { + Info = 0; + Exprn = 0; + NoMoves = false; + Error = true; + FirstChar = 0; + CurMatch = 0; +}; +PosRegExp::~PosRegExp() { + if (Info) delete Info; +}; + +bool PosRegExp::SetExpr(const char *Expr) { + if (!this) return false; + Error = true; + CurMatch = 0; + if (SetExprLow(Expr)) Error = false; + return !Error; +}; +bool PosRegExp::isok() { + return !Error; +}; + + +bool PosRegExp::SetExprLow(const char *Expr) { + int Len = strlen(Expr); + bool Ok = false; + int i,j,s = 0,pos,tmp; + int EnterBr = 0,EnterGr = 0,EnterFg = 0; + + if (Info) delete Info; + Info = new SRegInfo; + Exprn = new int[Len]; + + NoCase = false; + Extend = false; + if (Expr[0] == '/') s++; + else return false; + + for (i = Len; i > 0 && !Ok;i--) + if (Expr[i] == '/') { + Len = i-s; + Ok = true; + for (int j = i+1; Expr[j]; j++) { + if (Expr[j] == 'i') NoCase = true; + if (Expr[j] == 'x') Extend = true; + }; + }; + if (!Ok) return false; + + //////////////////////////////// + for (j = 0,pos = 0; j < Len; j++,pos++) { + if (Extend && Expr[j+s] == ' ') { + pos--; + continue; + }; + + Exprn[pos] = (int)(unsigned char)Expr[j+s]; + + if (Expr[j+s] == BackSlash) { + switch (Expr[j+s+1]) { + case 'd': + Exprn[pos] = ReDigit; + break; + case 'D': + Exprn[pos] = ReNDigit; + break; + case 'w': + Exprn[pos] = ReWordSymb; + break; + case 'W': + Exprn[pos] = ReNWordSymb; + break; + case 's': + Exprn[pos] = ReWSpace; + break; + case 'S': + Exprn[pos] = ReNWSpace; + break; + case 'u': + Exprn[pos] = ReUCase; + break; + case 'l': + Exprn[pos] = ReNUCase; + break; + case 't': + Exprn[pos] = '\t'; + break; + case 'n': + Exprn[pos] = '\n'; + break; + case 'r': + Exprn[pos] = '\r'; + break; + case 'b': + Exprn[pos] = ReWBound; + break; + case 'B': + Exprn[pos] = ReNWBound; + break; + case 'c': + Exprn[pos] = RePreNW; + break; + case 'm': + Exprn[pos] = ReStart; + break; + case 'M': + Exprn[pos] = ReEnd; + break; + case 'x': + tmp = toupper(Expr[j+s+2])-0x30; + tmp = (tmp>9?tmp-7:tmp)<<4; + tmp += (toupper(Expr[j+s+3])-0x30)>9?toupper(Expr[j+s+3])-0x37:(toupper(Expr[j+s+3])-0x30); + Exprn[pos] = tmp; + j+=2; + break; + case 'y': + tmp = Expr[j+s+2] - 0x30; + if (tmp >= 0 && tmp <= 9) { + if (tmp == 1) { + tmp = 10 + Expr[j+s+3] - 0x30; + if (tmp >= 10 && tmp <= 19) j++; + else tmp = 1; + }; + Exprn[pos] = ReBkTrace + tmp; + j++; + break; + }; + default: + tmp = Expr[j+s+1] - 0x30; + if (tmp >= 0 && tmp <= 9) { + if (tmp == 1) { + tmp = 10 + Expr[j+s+2] - 0x30; + if (tmp >= 10 && tmp <= 19) j++; + else tmp = 1; + }; + Exprn[pos] = ReBkBrack + tmp; + break; + } else + Exprn[pos] = Expr[j+s+1]; + break; + }; + j++; + continue; + }; + if (Expr[j+s] == ']') { + Exprn[pos] = ReEnumE; + if (EnterFg || !EnterGr) return false; + EnterGr--; + }; + if (Expr[j+s] == '-' && EnterGr) Exprn[pos] = ReFrToEnum; + + if (EnterGr) continue; + + if (Expr[j+s] == '[' && Expr[j+s+1] == '^') { + Exprn[pos] = ReNEnumS; + if (EnterFg) return false; + EnterGr++; + j++; + continue; + }; + if (Expr[j+s] == '*' && Expr[j+s+1] == '?') { + Exprn[pos] = ReNGMul; + j++; + continue; + }; + if (Expr[j+s] == '+' && Expr[j+s+1] == '?') { + Exprn[pos] = ReNGPlus; + j++; + continue; + }; + if (Expr[j+s] == '?' && Expr[j+s+1] == '?') { + Exprn[pos] = ReNGQuest; + j++; + continue; + }; + if (Expr[j+s] == '?' && Expr[j+s+1] == '#' && + Expr[j+s+2]>='0' && Expr[j+s+2]<='9') { + Exprn[pos] = ReBehind+Expr[j+s+2]-0x30; + j+=2; + continue; + }; + if (Expr[j+s] == '?' && Expr[j+s+1] == '~' && + Expr[j+s+2]>='0' && Expr[j+s+2]<='9') { + Exprn[pos] = ReNBehind+Expr[j+s+2]-0x30; + j+=2; + continue; + }; + if (Expr[j+s] == '?' && Expr[j+s+1] == '=') { + Exprn[pos] = ReAhead; + j++; + continue; + }; + if (Expr[j+s] == '?' && Expr[j+s+1] == '!') { + Exprn[pos] = ReNAhead; + j++; + continue; + }; + + if (Expr[j+s] == '(') { + Exprn[pos] = ReLBrack; + if (EnterFg) return false; + EnterBr++; + }; + if (Expr[j+s] == ')') { + Exprn[pos] = ReRBrack; + if (!EnterBr || EnterFg) return false; + EnterBr--; + }; + if (Expr[j+s] == '[') { + Exprn[pos] = ReEnumS; + if (EnterFg) return false; + EnterGr++; + }; + if (Expr[j+s] == '{') { + Exprn[pos] = ReRangeS; + if (EnterFg) return false; + EnterFg++; + }; + if (Expr[j+s] == '}' && Expr[j+s+1] == '?') { + Exprn[pos] = ReNGRangeE; + if (!EnterFg) return false; + EnterFg--; + j++; + continue; + }; + if (Expr[j+s] == '}') { + Exprn[pos] = ReRangeE; + if (!EnterFg) return false; + EnterFg--; + }; + + if (Expr[j+s] == '^') Exprn[pos] = ReSoL; + if (Expr[j+s] == '$') Exprn[pos] = ReEoL; + if (Expr[j+s] == '.') Exprn[pos] = ReAnyChr; + if (Expr[j+s] == '*') Exprn[pos] = ReMul; + if (Expr[j+s] == '+') Exprn[pos] = RePlus; + if (Expr[j+s] == '?') Exprn[pos] = ReQuest; + if (Expr[j+s] == '|') Exprn[pos] = ReOr; + }; + if (EnterGr || EnterBr || EnterFg) return false; + + Info->Op = ReBrackets; + Info->un.Param = new SRegInfo; + Info->s = CurMatch++; + + if (!SetStructs(Info->un.Param,0,pos)) return false; + Optimize(); + delete Exprn; + return true; +}; + +void PosRegExp::Optimize() { + PRegInfo Next = Info; + FirstChar = 0; + while(Next) { + if (Next->Op == ReBrackets || Next->Op == RePlus || Next->Op == ReNGPlus) { + Next = Next->un.Param; + continue; + }; + if (Next->Op == ReSymb) { + if (Next->un.Symb & 0xFF00 && Next->un.Symb != ReSoL && Next->un.Symb != ReWBound) + break; + FirstChar = Next->un.Symb; + break; + }; + break; + }; +}; + +bool PosRegExp::SetStructs(PRegInfo &re,int start,int end) { + PRegInfo Next,Prev,Prev2; + int comma,st,en,ng,i, j,k; + int EnterBr; + bool Add; + + if (end - start < 0) return false; + Next = re; + for (i = start; i < end; i++) { + Add = false; + // Ops + if (Exprn[i] > ReBlockOps && Exprn[i] < ReSymbolOps) { + Next->un.Param = 0; + Next->Op = (EOps)Exprn[i]; + Add = true; + }; + // {n,m} + if (Exprn[i] == ReRangeS) { + st = i; + en = -1; + comma = -1; + ng = 0; + for (j = i;j < end;j++) { + if (Exprn[j] == ReNGRangeE) { + en = j; + ng = 1; + break; + }; + if (Exprn[j] == ReRangeE) { + en = j; + break; + }; + if ((char)Exprn[j] == ',') + comma = j; + }; + if (en == -1) return false; + if (comma == -1) comma = en; + Next->s = (char)GetNumber(Exprn,st+1,comma); + if (comma != en) + Next->e = (char)GetNumber(Exprn,comma+1,en); + else + Next->e = Next->s; + Next->un.Param = 0; + Next->Op = ng?ReNGRangeNM:ReRangeNM; + if (en-comma == 1) { + Next->e = -1; + Next->Op = ng?ReNGRangeN:ReRangeN; + }; + i=j; + Add = true; + }; + // [] [^] + if (Exprn[i] == ReEnumS || Exprn[i] == ReNEnumS) { + Next->Op = (Exprn[i] == ReEnumS)?ReEnum:ReNEnum; + for (j = i+1;j < end;j++) { + if (Exprn[j] == ReEnumE) + break; + }; + if (j == end) return false; + Next->un.ChrClass = new SCharData; + memset(Next->un.ChrClass, 0, 32); + for (j = i+1;Exprn[j] != ReEnumE;j++) { + if (Exprn[j+1] == ReFrToEnum) { + for (i = (Exprn[j]&0xFF); i < (Exprn[j+2]&0xFF);i++) + Next->un.ChrClass->SetBit(i&0xFF); + j++; + continue; + }; + switch(Exprn[j]) { + case ReDigit: + for (k = 0x30;k < 0x40;k++) + if (IsDigit((char)k)) + Next->un.ChrClass->SetBit(k); + break; + case ReNDigit: + for (k = 0x30;k < 0x40;k++) + if (!IsDigit((char)k)) + Next->un.ChrClass->SetBit(k); + Next->un.ChrClass->ClearBit(0x0a); + Next->un.ChrClass->ClearBit(0x0d); + break; + case ReWordSymb: + for (k = 0;k < 256;k++) + if (IsWord((char)k)) + Next->un.ChrClass->SetBit(k); + break; + case ReNWordSymb: + for (k = 0;k < 256;k++) + if (!IsWord((char)k)) + Next->un.ChrClass->SetBit(k); + Next->un.ChrClass->ClearBit(0x0a); + Next->un.ChrClass->ClearBit(0x0d); + break; + case ReWSpace: + Next->un.ChrClass->SetBit(0x20); + Next->un.ChrClass->SetBit(0x09); + break; + case ReNWSpace: + memset(Next->un.ChrClass->IArr, 0xFF, 32); + Next->un.ChrClass->ClearBit(0x20); + Next->un.ChrClass->ClearBit(0x09); + Next->un.ChrClass->ClearBit(0x0a); + Next->un.ChrClass->ClearBit(0x0d); + break; + default: + if (!(Exprn[j]&0xFF00)) + Next->un.ChrClass->SetBit(Exprn[j]&0xFF); + break; + }; + }; + Add = true; + i=j; + }; + // ( ... ) + if (Exprn[i] == ReLBrack) { + EnterBr = 1; + for (j = i+1;j < end;j++) { + if (Exprn[j] == ReLBrack) EnterBr++; + if (Exprn[j] == ReRBrack) EnterBr--; + if (!EnterBr) break; + }; + if (EnterBr) return false; + Next->Op = ReBrackets; + Next->un.Param = new SRegInfo; + Next->un.Param->Parent = Next; + Next->s = CurMatch++; + if (CurMatch > MatchesNum) CurMatch = MatchesNum; + if (!SetStructs(Next->un.Param,i+1,j)) return false; + Add = true; + i=j; + }; + if ((Exprn[i]&0xFF00) == ReBkTrace) { + Next->Op = ReBkTrace; + Next->un.Symb = Exprn[i]&0xFF; + Add = true; + }; + if ((Exprn[i]&0xFF00) == ReBkBrack) { + Next->Op = ReBkBrack; + Next->un.Symb = Exprn[i]&0xFF; + Add = true; + }; + if ((Exprn[i]&0xFF00) == ReBehind) { + Next->Op = ReBehind; + Next->s = Exprn[i]&0xFF; + Add = true; + }; + if ((Exprn[i]&0xFF00) == ReNBehind) { + Next->Op = ReNBehind; + Next->s = Exprn[i]&0xFF; + Add = true; + }; + // Chars + if (Exprn[i] >= ReAnyChr && Exprn[i] < ReTemp || Exprn[i] < 0x100) { + Next->Op = ReSymb; + Next->un.Symb = Exprn[i]; + Add = true; + }; + // Next + if (Add && i != end-1) { + Next->Next = new SRegInfo; + Next->Next->Parent = Next->Parent; + Next = Next->Next; + }; + }; + Next = re; + Prev = Prev2 = 0; + while(Next) { + if (Next->Op > ReBlockOps && Next->Op < ReSymbolOps) { + if (!Prev) return false; + if (!Prev2) re = Next; + else Prev2->Next = Next; + //if (Prev->Op > ReBlockOps && Prev->Op < ReSymbolOps) return false; + Prev->Parent = Next; + Prev->Next = 0; + Next->un.Param = Prev; + Prev = Prev2; + }; + Prev2 = Prev; + Prev = Next; + Next = Next->Next; + }; + + return true; +}; + +///////////////////////////////////////////////////////////////// +///////////////////////// Parsing ///////////////////////////// +///////////////////////////////////////////////////////////////// + +bool PosRegExp::CheckSymb(int Symb,bool Inc) { + bool Res; + char ch; + switch(Symb) { + case ReAnyChr: + if (posParse >= posEnd) return false; + ch = CharAt(posParse,param); + Res = ch != '\r' && ch != '\n'; + if (Res && Inc) posParse++; + return Res; + case ReSoL: + if (posStart == posParse) + return true; + ch = CharAt(posParse-1,param); + return ch == '\n' || ch == '\r'; + case ReEoL: + if (posEnd == posParse) + return true; + ch = CharAt(posParse,param); + return ch == '\n' || ch == '\r'; + case ReDigit: + if (posParse >= posEnd) return false; + ch = CharAt(posParse,param); + Res = (ch >= 0x30 && ch <= 0x39); + if (Res && Inc) posParse++; + return Res; + case ReNDigit: + if (posParse >= posEnd) return false; + ch = CharAt(posParse,param); + Res = !(ch >= 0x30 && ch <= 0x39) && ch != '\r' && ch != '\n'; + if (Res && Inc) posParse++; + return Res; + case ReWordSymb: + if (posParse >= posEnd) return false; + Res = IsWord(CharAt(posParse,param)); + if (Res && Inc) posParse++; + return Res; + case ReNWordSymb: + if (posParse >= posEnd) return false; + ch = CharAt(posParse,param); + Res = !IsWord(ch) && ch != '\r' && ch != '\n'; + if (Res && Inc) posParse++; + return Res; + case ReWSpace: + if (posParse >= posEnd) return false; + ch = CharAt(posParse,param); + Res = (ch == 0x20 || ch == '\t'); + if (Res && Inc) posParse++; + return Res; + case ReNWSpace: + if (posParse >= posEnd) return false; + ch = CharAt(posParse,param); + Res = !(ch == 0x20 || ch == '\t') && ch != '\r' && ch != '\n'; + if (Res && Inc) posParse++; + return Res; + case ReUCase: + if (posParse >= posEnd) return false; + Res = IsUpperCase(CharAt(posParse,param)); + if (Res && Inc) posParse++; + return Res; + case ReNUCase: + if (posParse >= posEnd) return false; + Res = IsLowerCase(CharAt(posParse,param)); + if (Res && Inc) posParse++; + return Res; + case ReWBound: + if (posParse >= posEnd) return true; + ch = CharAt(posParse,param); + return IsWord(CharAt(posParse,param)) && (posParse == posStart || !IsWord(CharAt(posParse-1,param))); + case ReNWBound: + if (posParse >= posEnd) return true; + return !IsWord(CharAt(posParse,param)) && IsWord(CharAt(posParse-1,param)); + case RePreNW: + if (posParse >= posEnd) return true; + return (posParse == posStart || !IsWord(CharAt(posParse-1,param))); + case ReStart: + Matches->s[0] = (posParse-posStart); + return true; + case ReEnd: + Matches->e[0] = (posParse-posStart); + return true; + default: + if ((Symb & 0xFF00) || posParse >= posEnd) return false; + if (NoCase) { + if (LowCase(CharAt(posParse,param)) != LowCase((char)Symb&0xFF)) return false; + } else + if (CharAt(posParse,param) != (char)(Symb&0xFF)) return false; + if (Inc) posParse++; + return true; + }; +} + +bool PosRegExp::LowParseRe(PRegInfo &Next) { + PRegInfo OrNext; + int i,match,sv; + int posStr; + + switch(Next->Op) { + case ReSymb: + if (!CheckSymb(Next->un.Symb,true)) return false; + break; + case ReEmpty: + break; + case ReBkTrace: + if (!posBkStr | !BkTrace) return false; + sv = Next->un.Symb; + posStr = posParse; + for (i = BkTrace->s[sv]; i < BkTrace->e[sv]; i++) { + if (CharAt(posStr,param) != CharAt(posBkStr+i,param) || posEnd == posStr) return false; + posStr++; + }; + posParse = posStr; + break; + case ReBkBrack: + sv = Next->un.Symb; + posStr = posParse; + if (Matches->s[sv] == -1 || Matches->e[sv] == -1) return false; + for (i = Matches->s[sv]; i < Matches->e[sv]; i++) { + if (CharAt(posStr,param) != CharAt(posStart+i,param) || posEnd == posStr) return false; + posStr++; + }; + posParse = posStr; + break; + case ReBehind: + sv = Next->s; + posStr = posParse; + posParse -= sv; + if (!LowParse(Next->un.Param)) return false; + posParse = posStr; + break; + case ReNBehind: + sv = Next->s; + posStr = posParse; + posParse -= sv; + if (LowParse(Next->un.Param)) return false; + posParse = posStr; + break; + case ReAhead: + posStr = posParse; + if (!LowParse(Next->un.Param)) return false; + posParse = posStr; + break; + case ReNAhead: + posStr = posParse; + if (LowParse(Next->un.Param)) return false; + posParse = posStr; + break; + case ReEnum: + if (posParse >= posEnd) return false; + if (!Next->un.ChrClass->GetBit(CharAt(posParse,param))) return false; + posParse++; + break; + case ReNEnum: + if (posParse >= posEnd) return false; + if (Next->un.ChrClass->GetBit(CharAt(posParse,param))) return false; + posParse++; + break; + case ReBrackets: + match = Next->s; + sv = posParse-posStart; + posStr = posParse; + if (LowParse(Next->un.Param)) { + if (match || (Matches->s[match] == -1)) + Matches->s[match] = sv; + if (match || (Matches->e[match] == -1)) + Matches->e[match] = posParse-posStart; + return true; + }; + posParse = posStr; + return false; + case ReMul: + posStr = posParse; + while (LowParse(Next->un.Param)); + while(!LowCheckNext(Next) && posStr < posParse) posParse--; + break; + case ReNGMul: + do { + if (LowCheckNext(Next)) break; + } while (LowParse(Next->un.Param)); + break; + case RePlus: + posStr = posParse; + match = false; + while (LowParse(Next->un.Param)) + match = true; + if (!match) return false; + while(!LowCheckNext(Next) && posStr < posParse) posParse--; + break; + case ReNGPlus: + if (!LowParse(Next->un.Param)) return false; + do { + if (LowCheckNext(Next)) break; + } while (LowParse(Next->un.Param)); + break; + case ReQuest: + LowParse(Next->un.Param); + break; + case ReNGQuest: + if (LowCheckNext(Next)) break; + if (!LowParse(Next->un.Param)) return false; + break; + case ReOr: + OrNext = Next; + // posStr = posParse; + if (LowParse(Next->un.Param)) { + while (OrNext && OrNext->Op == ReOr) + OrNext = OrNext->Next; + /*if (!LowCheckNext(OrNext)){ + posParse = posStr; + OrNext = Next; + };*/ + }; + Next = OrNext; + break; + case ReRangeN: + posStr = posParse; + i = 0; + while (LowParse(Next->un.Param)) i++; // ??? + do { + if (i < Next->s) { + posParse = posStr; + return false; + }; + i--; + } while(!LowCheckNext(Next) && posStr < posParse--); + break; + case ReNGRangeN: + posStr = posParse; + i = 0; + while (LowParse(Next->un.Param)) { + i++; + if (i >= Next->s && LowCheckNext(Next)) // ??? + break; + }; + if (i < Next->s) { + posParse = posStr; + return false; + }; + break; + case ReRangeNM: + posStr = posParse; + i = 0; + while (i < Next->s && LowParse(Next->un.Param)) // ??? + i++; + if (i < Next->s) { + posParse = posStr; + return false; + }; + while (i < Next->e && LowParse(Next->un.Param)) // ??? + i++; + + while(!LowCheckNext(Next)) { + i--; + posParse--; + if (i < Next->s) { + posParse = posStr; + return false; + }; + }; + break; + case ReNGRangeNM: + posStr = posParse; + i = 0; + while (i < Next->s && LowParse(Next->un.Param)) // ??? + i++; + if (i < Next->s) { + posParse = posStr; + return false; + }; + while(!LowCheckNext(Next)) { + i++; + if (!LowParse(Next->un.Param) || i > Next->e) { // ??? + posParse = posStr; + return false; + }; + }; + break; + }; + return true; +}; + +bool PosRegExp::LowCheckNext(PRegInfo Re) { + PRegInfo Next; + int tmp = posParse; + Next = Re; + do { + if (Next && Next->Op == ReOr) + while (Next && Next->Op == ReOr) + Next = Next->Next; + if (Next->Next && !LowParse(Next->Next)) { + posParse = tmp; + Ok = false; + return false; + }; + Next = Next->Parent; + } while(Next); + posParse = tmp; + if (Ok != false) Ok = true; + return true; +}; + +bool PosRegExp::LowParse(PRegInfo Re) { + while(Re && posParse <= posEnd) { + if (!LowParseRe(Re)) return false; + if (Re) Re = Re->Next; + }; + return true; +}; + +bool PosRegExp::QuickCheck() { + if (!NoMoves || !FirstChar) + return true; + switch(FirstChar) { + case ReSoL: + if (posParse != posStart) return false; + return true; + case ReWBound: + return IsWord(CharAt(posParse,param)) && (posParse == posStart || !IsWord(CharAt(posParse-1,param))); + default: + if (NoCase && LowCase(CharAt(posParse,param)) != LowCase(FirstChar)) return false; + if (!NoCase && CharAt(posParse,param) != (char)FirstChar) return false; + return true; + }; +}; + +bool PosRegExp::ParseRe(int posStr) { + if (Error) return false; + + posParse = posStr; + if (!QuickCheck()) return false; + + for (int i = 0; i < MatchesNum; i++) + Matches->s[i] = Matches->e[i] = -1; + Matches->CurMatch = CurMatch; + + Ok = -1; + //try{ + do { + if (!LowParse(Info)) { + if (NoMoves) return false; + } else + return true; + posParse = ++posStr; + } while(posParse != posEnd+1); + return false; + //}__except(){ + // return true; + //}; +} +; + +bool PosRegExp::Parse(int posStr,int posSol, int posEol, PMatches Mtch, int Moves) { + if (!this) return false; + + bool s = NoMoves; + if (Moves != -1) NoMoves = Moves!=0; + posStart = posSol; + posEnd = posEol; + Matches = Mtch; + bool r = ParseRe(posStr); + NoMoves = s; + return r; +}; + +bool PosRegExp::Parse(int posStr, int posStop, PMatches Mtch) { + if (!this) return false; + posStart = posStr; + posEnd = posStop; + Matches = Mtch; + return ParseRe(posStr); +}; + +bool PosRegExp::SetNoMoves(bool Moves) { + NoMoves = Moves; + return true; +}; + +bool PosRegExp::SetBkTrace(int posStr,PMatches Trace) { + BkTrace = Trace; + posBkStr = posStr; + return true; +}; + +#define EVAL_MATCHES 16 +#define EVAL_CHUNKSIZE 256 + +#define EVAL_LOWERCASE 1 +#define EVAL_UPPERCASE 2 +#define EVAL_LOWERCASE_NEXT 4 +#define EVAL_UPPERCASE_NEXT 8 + +bool PosRegExp::Evaluate(char *Expr, int posStr, PMatches Mtch, char **Res) { + int length, + newlength, + chunklength, + value, + size, + src, + end; + unsigned flag; + char ch, + *dest, + *pool; + + size = EVAL_CHUNKSIZE; + pool = (char*) malloc (size); + dest = pool; + length = 0; + flag = 0; + while (*Expr) { + switch (ch = *Expr++) { + case '\\': + switch (ch = *Expr++) { + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + ch -= ('A' - '0'); + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + value = ch - '0'; + if (Mtch->s[value] != -1 && value < EVAL_MATCHES) { + chunklength = Mtch->e[value] - Mtch->s[value]; + if (chunklength) { + newlength = chunklength + length; + if (newlength > size) { + do + size += EVAL_CHUNKSIZE; + while (size < newlength); + pool = (char*) realloc (pool, size); + dest = pool + length; + } + length = newlength; + src = posStr + Mtch->s[value]; + end = posStr + Mtch->e[value]; + if (flag & EVAL_UPPERCASE) { + if (flag & EVAL_LOWERCASE_NEXT) { + *dest++ = tolower (CharAt(src++,param)); + flag &= ~EVAL_LOWERCASE_NEXT; + } + while (src < end) + *dest++ = toupper (CharAt(src++,param)); + } else if (flag & EVAL_LOWERCASE) { + if (flag & EVAL_UPPERCASE_NEXT) { + *dest++ = toupper (CharAt(src++,param)); + flag &= ~EVAL_UPPERCASE_NEXT; + } + while (src < end) + *dest++ = tolower (CharAt(src++,param)); + } else { + if (flag & EVAL_LOWERCASE_NEXT) { + *dest++ = tolower (CharAt(src++,param)); + flag &= ~EVAL_LOWERCASE_NEXT; + } else if (flag & EVAL_UPPERCASE_NEXT) { + *dest++ = toupper (CharAt(src++,param)); + flag &= ~EVAL_UPPERCASE_NEXT; + } + while (src < end) + *dest++ = CharAt(src++,param); + } + } + } else + goto error; + continue; + case '\0': + goto error; + case 'r': + ch = '\r'; + break; + case 'n': + ch = '\n'; + break; + case 'b': + ch = '\b'; + break; + case 'a': + ch = '\a'; + break; + case 't': + ch = '\t'; + break; + case 'U': + flag |= EVAL_UPPERCASE; + continue; + case 'u': + flag |= EVAL_UPPERCASE_NEXT; + continue; + case 'L': + flag |= EVAL_LOWERCASE; + continue; + case 'l': + flag |= EVAL_LOWERCASE_NEXT; + continue; + case 'Q': + case 'q': + flag &= ~(EVAL_UPPERCASE | EVAL_LOWERCASE); + continue; + case 'x': + { + if (!*Expr) + goto error; + value = toupper (*Expr) - '0'; + if (value > 9) + value = value + '0' - 'A' + 10; + if (value > 15) + goto error; + ch = value << 4; + Expr++; + if (!*Expr) + goto error; + value = toupper (*Expr) - '0'; + if (value > 9) + value = value + '0' - 'A' + 10; + if (value > 15) + goto error; + Expr++; + ch |= value; + break; + } + case 'd': + { + if (!*Expr) + goto error; + value = toupper (*Expr) - '0'; + if (value > 9) + goto error; + ch = value * 100; + Expr++; + if (!*Expr) + goto error; + value = toupper (*Expr) - '0'; + if (value > 9) + goto error; + ch += value * 10; + Expr++; + if (!*Expr) + goto error; + value = toupper (*Expr) - '0'; + if (value > 9) + goto error; + ch += value; + Expr++; + break; + } + case 'o': + { + if (!*Expr) + goto error; + value = toupper (*Expr) - '0'; + if (value > 9) + goto error; + ch = value << 6; + Expr++; + if (!*Expr) + goto error; + value = toupper (*Expr) - '0'; + if (value > 9) + goto error; + ch += value << 3; + Expr++; + if (!*Expr) + goto error; + value = toupper (*Expr) - '0'; + if (value > 9) + goto error; + ch |= value; + Expr++; + /* break; */ + } + /* default: + break; */ + } + default: + if (++length > size) { + do + size += EVAL_CHUNKSIZE; + while (size < length); + pool = (char*) realloc (pool, size); + dest = pool + length - 1; + } + if (flag & EVAL_LOWERCASE_NEXT) { + *dest++ = tolower (ch); + flag &= ~EVAL_LOWERCASE_NEXT; + } else if (flag & EVAL_UPPERCASE_NEXT) { + *dest++ = toupper (ch); + flag &= ~EVAL_UPPERCASE_NEXT; + } else if (flag & EVAL_UPPERCASE) + *dest++ = toupper (ch); + else if (flag & EVAL_LOWERCASE) + *dest++ = tolower (ch); + else + *dest++ = ch; + } + } + if (++length > size) { + do + size += EVAL_CHUNKSIZE; + while (size < length); + pool = (char*) realloc (pool, size); + dest = pool + length - 1; + } + *dest = '\0'; + *Res = pool; + return true; +error: + free (pool); + return false; +} diff --git a/contrib/src/xml/FORMAT.txt b/contrib/src/xml/FORMAT.txt new file mode 100644 index 0000000000..6d93b5d28b --- /dev/null +++ b/contrib/src/xml/FORMAT.txt @@ -0,0 +1,324 @@ + + XML resources file format + =============================== + + 1. Basics +----------- + +XML resource is well-formed XML document, i.e. all tags are paired +and there is only one root node, which is always . + +In the following text, I will use standard XML terminology: + + + + + +Here, tag_one is a node (the word 'tag' refers to the type of the node), +prop1 and prop2 are properties and tag_two is a child node of tag_one. +Property's default value is the value that will be assigned to the property +if you do not specify it explicitly. + +I will use the term "primary node" to refer to nodes than represent controls, +dialogs etc. "Secondary nodes" are nodes used to store data: + + primary + Demo Dialog... secondary + 100,200d secondary + secondary + + + + +In the example above,