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

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/UNDO@6999 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

contrib/src/stc/Makefile.in

@@ -0,0 +1,47 @@
+###############################################################################
+# Purpose: Makefile.in for STC contrib for Unix with autoconf
+# Created: 14.03.00
+# Author:  VZ
+# Version: $Id$
+###############################################################################
+
+top_srcdir = @top_srcdir@
+top_builddir = ../../..
+
+this_dir = $(top_srcdir)/src/stc
+scintilla_dir=$(this_dir)/scintilla
+VPATH=$(this_dir)@PATH_IFS@$(scintilla_dir)/src # ':' for autoconf
+
+TARGET_LIBNAME=libstc
+
+LIBVERSION_CURRENT=1
+LIBVERSION_REVISION=0
+LIBVERSION_AGE=0
+
+OBJECTS=PlatWX.o ScintillaWX.o stc.o \
+        Accessor.o	        \
+        AutoComplete.o	    \
+        CallTip.o	        \
+        CellBuffer.o	    \
+        ContractionState.o  \
+        Document.o	        \
+        Editor.o		    \
+        Indicator.o	        \
+        KeyMap.o		    \
+        KeyWords.o	        \
+	LexCPP.o		\
+	LexHTML.o		\
+	LexOthers.o		\
+	LexPerl.o		\
+	LexPython.o		\
+	LexSQL.o		\
+	LexVB.o			\
+        LineMarker.o	    \
+        PropSet.o	        \
+        ScintillaBase.o	    \
+        Style.o		        \
+        ViewStyle.o
+        
+APPEXTRADEFS=-D__WX__ -DSCI_LEXER -I$(scintilla_dir)/src -I$(scintilla_dir)/include -I$(top_srcdir)/include
+
+include $(top_builddir)/src/makelib.env

contrib/src/stc/PlatWX.cpp

@@ -0,0 +1,597 @@
+// Scintilla source code edit control
+// PlatWX.cxx - implementation of platform facilities on wxWindows
+// Copyright 1998-1999 by Neil Hodgson <neilh@scintilla.org>
+//                        Robin Dunn <robin@aldunn.com>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <ctype.h>
+
+#include "Platform.h"
+#include "wx/stc/stc.h"
+
+Point Point::FromLong(long lpoint) {
+    return Point(lpoint & 0xFFFF, lpoint >> 32);
+}
+
+wxRect wxRectFromPRectangle(PRectangle prc) {
+    wxRect rc(prc.left, prc.top,
+              prc.right-prc.left+1, prc.bottom-prc.top+1);
+    return rc;
+}
+
+PRectangle PRectangleFromwxRect(wxRect rc) {
+    return PRectangle(rc.GetLeft(), rc.GetTop(), rc.GetRight(), rc.GetBottom());
+}
+
+Colour::Colour(long lcol) {
+    co.Set(lcol & 0xff, (lcol >> 8) & 0xff, (lcol >> 16) & 0xff);
+}
+
+Colour::Colour(unsigned int red, unsigned int green, unsigned int blue) {
+    co.Set(red, green, blue);
+}
+
+bool Colour::operator==(const Colour &other) const {
+    return co == other.co;
+}
+
+long Colour::AsLong() const {
+    return (((long)co.Blue()  << 16) |
+            ((long)co.Green() <<  8) |
+            ((long)co.Red()));
+}
+
+unsigned int Colour::GetRed() {
+    return co.Red();
+}
+
+unsigned int Colour::GetGreen() {
+    return co.Green();
+}
+
+unsigned int Colour::GetBlue() {
+    return co.Blue();
+}
+
+Palette::Palette() {
+    used = 0;
+    allowRealization = false;
+}
+
+Palette::~Palette() {
+    Release();
+}
+
+void Palette::Release() {
+    used = 0;
+}
+
+// This method either adds a colour to the list of wanted colours (want==true)
+// or retrieves the allocated colour back to the ColourPair.
+// This is one method to make it easier to keep the code for wanting and retrieving in sync.
+void Palette::WantFind(ColourPair &cp, bool want) {
+    if (want) {
+        for (int i=0; i < used; i++) {
+            if (entries[i].desired == cp.desired)
+                return;
+        }
+
+        if (used < numEntries) {
+            entries[used].desired = cp.desired;
+            entries[used].allocated = cp.desired;
+            used++;
+        }
+    } else {
+        for (int i=0; i < used; i++) {
+            if (entries[i].desired == cp.desired) {
+                cp.allocated = entries[i].allocated;
+                return;
+            }
+        }
+        cp.allocated = cp.desired;
+    }
+}
+
+void Palette::Allocate(Window &) {
+    if (allowRealization) {
+    }
+}
+
+
+Font::Font() {
+    id = 0;
+    ascent = 0;
+}
+
+Font::~Font() {
+}
+
+void Font::Create(const char *faceName, int size, bool bold, bool italic) {
+    Release();
+    id = new wxFont(size,
+                    wxDEFAULT,
+                    italic ? wxITALIC :  wxNORMAL,
+                    bold ? wxBOLD : wxNORMAL,
+                    false,
+                    faceName);
+}
+
+
+void Font::Release() {
+    if (id)
+        delete id;
+    id = 0;
+}
+
+
+Surface::Surface() :
+    hdc(0), hdcOwned(0), bitmap(0),
+    x(0), y(0) {
+}
+
+Surface::~Surface() {
+    Release();
+}
+
+void Surface::Release() {
+    if (bitmap) {
+        ((wxMemoryDC*)hdc)->SelectObject(wxNullBitmap);
+        delete bitmap;
+        bitmap = 0;
+    }
+    if (hdcOwned) {
+        delete hdc;
+        hdc = 0;
+        hdcOwned = false;
+    }
+}
+
+
+bool Surface::Initialised() {
+    return hdc != 0;
+}
+
+void Surface::Init() {
+    Release();
+    hdc = new wxMemoryDC();
+    hdcOwned = true;
+    // **** ::SetTextAlign(hdc, TA_BASELINE);
+}
+
+void Surface::Init(SurfaceID hdc_) {
+    Release();
+    hdc = hdc_;
+    // **** ::SetTextAlign(hdc, TA_BASELINE);
+}
+
+void Surface::InitPixMap(int width, int height, Surface *surface_) {
+    Release();
+    hdc = new wxMemoryDC(surface_->hdc);
+    hdcOwned = true;
+    bitmap = new wxBitmap(width, height);
+    ((wxMemoryDC*)hdc)->SelectObject(*bitmap);
+    // **** ::SetTextAlign(hdc, TA_BASELINE);
+}
+
+void Surface::PenColour(Colour fore) {
+    hdc->SetPen(wxPen(fore.co, 1, wxSOLID));
+}
+
+void Surface::BrushColor(Colour back) {
+    hdc->SetBrush(wxBrush(back.co, wxSOLID));
+}
+
+void Surface::SetFont(Font &font_) {
+
+  // I think the following check is valid.  
+  // It eliminates a crash for me.  -- eric@sourcegear.com
+
+  if (font_.GetID())
+    {
+      hdc->SetFont(*font_.GetID());
+    }
+}
+
+int Surface::LogPixelsY() {
+    return hdc->GetPPI().y;
+}
+
+void Surface::MoveTo(int x_, int y_) {
+    x = x_;
+    y = y_;
+}
+
+void Surface::LineTo(int x_, int y_) {
+    hdc->DrawLine(x,y, x_,y_);
+    x = x_;
+    y = y_;
+}
+
+void Surface::Polygon(Point *pts, int npts, Colour fore,
+                      Colour back) {
+    PenColour(fore);
+    BrushColor(back);
+    hdc->DrawPolygon(npts, (wxPoint*)pts);
+}
+
+void Surface::RectangleDraw(PRectangle rc, Colour fore, Colour back) {
+    PenColour(fore);
+    BrushColor(back);
+    hdc->DrawRectangle(wxRectFromPRectangle(rc));
+}
+
+void Surface::FillRectangle(PRectangle rc, Colour back) {
+    BrushColor(back);
+    hdc->SetPen(*wxTRANSPARENT_PEN);
+    hdc->DrawRectangle(wxRectFromPRectangle(rc));
+}
+
+void Surface::FillRectangle(PRectangle rc, Surface &surfacePattern) {
+    wxBrush br;
+    if (surfacePattern.bitmap)
+        br = wxBrush(*surfacePattern.bitmap);
+    else    // Something is wrong so display in red
+        br = wxBrush(*wxRED, wxSOLID);
+    hdc->SetPen(*wxTRANSPARENT_PEN);
+    hdc->SetBrush(br);
+    hdc->DrawRectangle(wxRectFromPRectangle(rc));
+}
+
+void Surface::RoundedRectangle(PRectangle rc, Colour fore, Colour back) {
+    PenColour(fore);
+    BrushColor(back);
+    hdc->DrawRoundedRectangle(wxRectFromPRectangle(rc), 8);
+}
+
+void Surface::Ellipse(PRectangle rc, Colour fore, Colour back) {
+    PenColour(fore);
+    BrushColor(back);
+    hdc->DrawEllipse(wxRectFromPRectangle(rc));
+}
+
+void Surface::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
+    hdc->Blit(rc.left, rc.top, rc.Width(), rc.Height(),
+              surfaceSource.hdc, from.x, from.y, wxCOPY);
+}
+
+void Surface::DrawText(PRectangle rc, Font &font, int ybase,
+                       const char *s, int len, Colour fore, Colour back) {
+    SetFont(font);
+    hdc->SetTextForeground(fore.co);
+    hdc->SetTextBackground(back.co);
+    FillRectangle(rc, back);
+
+    // ybase is where the baseline should be, but wxWin uses the upper left
+    // corner, so I need to calculate the real position for the text...
+    hdc->DrawText(wxString(s, len), rc.left, ybase - font.ascent);
+}
+
+void Surface::DrawTextClipped(PRectangle rc, Font &font, int ybase, const char *s, int len, Colour fore, Colour back) {
+    SetFont(font);
+    hdc->SetTextForeground(fore.co);
+    hdc->SetTextBackground(back.co);
+    FillRectangle(rc, back);
+    hdc->SetClippingRegion(wxRectFromPRectangle(rc));
+
+    // see comments above
+    hdc->DrawText(wxString(s, len), rc.left, ybase - font.ascent);
+    hdc->DestroyClippingRegion();
+}
+
+int Surface::WidthText(Font &font, const char *s, int len) {
+    SetFont(font);
+    int w;
+    int h;
+    hdc->GetTextExtent(wxString(s, len), &w, &h);
+    return w;
+}
+
+void Surface::MeasureWidths(Font &font, const char *s, int len, int *positions) {
+    SetFont(font);
+    int totalWidth = 0;
+    for (int i=0; i<len; i++) {
+        int w;
+        int h;
+        hdc->GetTextExtent(s[i], &w, &h);
+        totalWidth += w;
+        positions[i] = totalWidth;
+    }
+}
+
+int Surface::WidthChar(Font &font, char ch) {
+    SetFont(font);
+    int w;
+    int h;
+    hdc->GetTextExtent(ch, &w, &h);
+    return w;
+}
+
+#define EXTENT_TEST " `~!@#$%^&*()-_=+\\|[]{};:\"\'<,>.?/1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+int Surface::Ascent(Font &font) {
+    SetFont(font);
+    int w, h, d, e;
+    hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e);
+    font.ascent = h - d;
+    return font.ascent;
+}
+
+int Surface::Descent(Font &font) {
+    SetFont(font);
+    int w, h, d, e;
+    hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e);
+    return d;
+}
+
+int Surface::InternalLeading(Font &font) {
+    return 0;
+}
+
+int Surface::ExternalLeading(Font &font) {
+    SetFont(font);
+    int w, h, d, e;
+    hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e);
+    return e;
+}
+
+int Surface::Height(Font &font) {
+    SetFont(font);
+    return hdc->GetCharHeight();
+}
+
+int Surface::AverageCharWidth(Font &font) {
+    SetFont(font);
+    return hdc->GetCharWidth();
+}
+
+int Surface::SetPalette(Palette *pal, bool inBackGround) {
+    return 0;  // **** figure out what to do with palettes...
+}
+
+void Surface::SetClip(PRectangle rc) {
+    hdc->SetClippingRegion(wxRectFromPRectangle(rc));
+}
+
+void Surface::FlushCachedState() {
+  // TODO Is there anything we need to do here? eric@sourcegear.com
+  // TODO I had to add this method when I merged new Scintilla code
+  // TODO from Neil.
+}
+
+Window::~Window() {
+}
+
+void Window::Destroy() {
+    if (id)
+        id->Destroy();
+    id = 0;
+}
+
+bool Window::HasFocus() {
+    return wxWindow::FindFocus() == id;
+}
+
+PRectangle Window::GetPosition() {
+    wxRect rc(id->GetPosition(), id->GetSize());
+    return PRectangleFromwxRect(rc);
+}
+
+void Window::SetPosition(PRectangle rc) {
+    id->SetSize(rc.left, rc.top, rc.Width(), rc.Height());
+}
+
+void Window::SetPositionRelative(PRectangle rc, Window) {
+    SetPosition(rc);  // ????
+}
+
+PRectangle Window::GetClientPosition() {
+    wxSize sz = id->GetClientSize();
+    return  PRectangle(0, 0, sz.x - 1, sz.y - 1);
+}
+
+void Window::Show(bool show) {
+    id->Show(show);
+}
+
+void Window::InvalidateAll() {
+    id->Refresh(false);
+}
+
+void Window::InvalidateRectangle(PRectangle rc) {
+    id->Refresh(false, &wxRectFromPRectangle(rc));
+}
+
+void Window::SetFont(Font &font) {
+    id->SetFont(*font.GetID());
+}
+
+void Window::SetCursor(Cursor curs) {
+    int cursorId;
+
+    switch (curs) {
+    case cursorText:
+        cursorId = wxCURSOR_IBEAM;
+        break;
+    case cursorArrow:
+        cursorId = wxCURSOR_ARROW;
+        break;
+    case cursorUp:
+        cursorId = wxCURSOR_ARROW; // ** no up arrow...  wxCURSOR_UPARROW;
+        break;
+    case cursorWait:
+        cursorId = wxCURSOR_WAIT;
+        break;
+    case cursorHoriz:
+        cursorId = wxCURSOR_SIZEWE;
+        break;
+    case cursorVert:
+        cursorId = wxCURSOR_SIZENS;
+        break;
+    case cursorReverseArrow:
+        cursorId = wxCURSOR_POINT_RIGHT;
+        break;
+    default:
+        cursorId = wxCURSOR_ARROW;
+        break;
+    }
+
+    id->SetCursor(wxCursor(cursorId));
+}
+
+
+void Window::SetTitle(const char *s) {
+    id->SetTitle(s);
+}
+
+
+
+ListBox::ListBox() {
+}
+
+ListBox::~ListBox() {
+}
+
+void ListBox::Create(Window &parent, int ctrlID) {
+    id = new wxListBox(parent.id, ctrlID, wxDefaultPosition, wxDefaultSize,
+                       0, NULL, wxLB_SINGLE | wxLB_SORT);
+}
+
+void ListBox::Clear() {
+    ((wxListBox*)id)->Clear();
+}
+
+void ListBox::Append(char *s) {
+    ((wxListBox*)id)->Append(s);
+}
+
+int ListBox::Length() {
+    return ((wxListBox*)id)->Number();
+}
+
+void ListBox::Select(int n) {
+    ((wxListBox*)id)->SetSelection(n);
+}
+
+int ListBox::GetSelection() {
+    return ((wxListBox*)id)->GetSelection();
+}
+
+int ListBox::Find(const char *prefix) {
+    return ((wxListBox*)id)->FindString(prefix);
+}
+
+void ListBox::GetValue(int n, char *value, int len) {
+    wxString text = ((wxListBox*)id)->GetString(n);
+    strncpy(value, text.c_str(), len);
+    value[len-1] = '\0';
+}
+
+void ListBox::Sort() {
+    // wxWindows keeps sorted so no need to sort
+}
+
+
+Menu::Menu() : id(0) {
+}
+
+void Menu::CreatePopUp() {
+    Destroy();
+    id = new wxMenu();
+}
+
+void Menu::Destroy() {
+    if (id)
+        delete id;
+    id = 0;
+}
+
+void Menu::Show(Point pt, Window &w) {
+    w.GetID()->PopupMenu(id, pt.x - 4, pt.y);
+    Destroy();
+}
+
+
+Colour Platform::Chrome() {
+    wxColour c;
+    c = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
+    return Colour(c.Red(), c.Green(), c.Blue());
+}
+
+Colour Platform::ChromeHighlight() {
+    wxColour c;
+    c = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DHIGHLIGHT);
+    return Colour(c.Red(), c.Green(), c.Blue());
+}
+
+const char *Platform::DefaultFont() {
+    return wxNORMAL_FONT->GetFaceName();
+}
+
+int Platform::DefaultFontSize() {
+    return 8;
+}
+
+unsigned int Platform::DoubleClickTime() {
+    return 500;   // **** ::GetDoubleClickTime();
+}
+
+void Platform::DebugDisplay(const char *s) {
+    wxLogDebug(s);
+}
+
+bool Platform::IsKeyDown(int key) {
+    return false;  // I don't think we'll need this.
+}
+
+long Platform::SendScintilla(WindowID w,
+                             unsigned int msg,
+                             unsigned long wParam,
+                             long lParam) {
+
+    wxStyledTextCtrl* stc = (wxStyledTextCtrl*)w;
+    return stc->SendMsg(msg, wParam, lParam);
+}
+
+
+// These are utility functions not really tied to a platform
+
+int Platform::Minimum(int a, int b) {
+    if (a < b)
+        return a;
+    else
+        return b;
+}
+
+int Platform::Maximum(int a, int b) {
+    if (a > b)
+        return a;
+    else
+        return b;
+}
+
+#define TRACE
+
+void Platform::DebugPrintf(const char *format, ...) {
+#ifdef TRACE
+    char buffer[2000];
+    va_list pArguments;
+    va_start(pArguments, format);
+    vsprintf(buffer,format,pArguments);
+    va_end(pArguments);
+    Platform::DebugDisplay(buffer);
+#endif
+}
+
+int Platform::Clamp(int val, int minVal, int maxVal) {
+    if (val > maxVal)
+        val = maxVal;
+    if (val < minVal)
+        val = minVal;
+    return val;
+}
+
+
+
+
+
+

contrib/src/stc/README.txt

@@ -0,0 +1,47 @@
+This contrib is the wxStyledTextCtrl, which is a wrapper around the
+Scintilla edit control.  (See www.scintilla.org)
+
+There is still VERY MUCH to be done, most notable of which is a more
+advanced sample that exercises more of the code.  (I havn't tested
+AutoComplete or CallTips, or most of the event types at all yet.)  And
+also documentation, adding wrappers for some new scintilla
+functionality, building and testing on wxGTK, etc.  Be patient, it all
+will get there soon.
+
+
+
+Let me describe a bit about the architecture I am implementing...
+Obviously there is the Platform layer which implements the varioius
+platform classes by using wxWindows classes and filling in where
+needed.  Then there is a ScintillaWX class that is derived from
+ScintillaBase and implements the necessary virtual methods that
+Scintilla needs to fully funciton.  This class however is not meant to
+ever be used directly by wx programmers.  I call it one end of the
+bridge between the wx and Scintilla worlds.  The other end of the
+bridge is a class called wxStyledTextCtrl that looks, feels and acts
+like other classes in wxWindows.  Here is a diagram:
+
+
+ +------------------+          +-------------------+
+ | wxStyledTextCtrl |--bridge--|    ScintillaWX    |
+ +------------------+          +-------------------+
+                               |   ScintillaBase   |
+                               +-------------------+
+                               |       Editor      |
+                               +-------------------+
+                               |     PlatWX        |
+                               +-------------------+
+
+
+wxStyledTextCtrl derives from wxControl so it has a window that can be
+drawn upon.  When a wxStyledTextCtrl is constructed it constructs a
+ScintillaWX for itself and passes itself to the scintilla object to be
+set as the wMain and wDraw attributes.  All method calls on the STC
+are sent over the bridge in the form of calls to ScintiallWX::WndProc.
+All notifications are sent back over the bridge and turned into
+wxEvents.
+
+
+Robin
+
+

contrib/src/stc/ScintillaWX.cpp

@@ -0,0 +1,460 @@
+////////////////////////////////////////////////////////////////////////////
+// Name:        ScintillaWX.cxx
+// Purpose:     A wxWindows implementation of Scintilla.  A class derived
+//              from ScintillaBase that uses the "wx platform" defined in
+//              PlatformWX.cxx  This class is one end of a bridge between
+//              the wx world and the Scintilla world.  It needs a peer
+//              object of type wxStyledTextCtrl to function.
+//
+// Author:      Robin Dunn
+//
+// Created:     13-Jan-2000
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#include <ctype.h>
+
+#include "ScintillaWX.h"
+#include "wx/stc/stc.h"
+
+
+//----------------------------------------------------------------------
+
+const int H_SCROLL_MAX  = 2000;
+const int H_SCROLL_STEP = 20;
+const int H_SCROLL_PAGE = 200;
+
+//----------------------------------------------------------------------
+// Helper classes
+
+class wxSTCTimer : public wxTimer {
+public:
+    wxSTCTimer(ScintillaWX* swx) {
+        this->swx = swx;
+    }
+
+    void Notify() {
+        swx->DoTick();
+    }
+
+private:
+    ScintillaWX* swx;
+};
+
+
+
+bool wxSTCDropTarget::OnDropText(wxCoord x, wxCoord y, const wxString& data) {
+    return swx->DoDropText(x, y, data);
+}
+
+wxDragResult  wxSTCDropTarget::OnEnter(wxCoord x, wxCoord y, wxDragResult def) {
+    return swx->DoDragEnter(x, y, def);
+}
+
+wxDragResult  wxSTCDropTarget::OnDragOver(wxCoord x, wxCoord y, wxDragResult def) {
+    return swx->DoDragOver(x, y, def);
+}
+
+void  wxSTCDropTarget::OnLeave() {
+    swx->DoDragLeave();
+}
+
+
+
+//----------------------------------------------------------------------
+// Constructor/Destructor
+
+
+ScintillaWX::ScintillaWX(wxStyledTextCtrl* win) {
+    capturedMouse = false;
+    wMain = win;
+    wDraw = win;
+    stc   = win;
+    Initialise();
+}
+
+
+ScintillaWX::~ScintillaWX() {
+    SetTicking(false);
+}
+
+//----------------------------------------------------------------------
+// base class virtuals
+
+
+void ScintillaWX::Initialise() {
+    //ScintillaBase::Initialise();
+    dropTarget = new wxSTCDropTarget;
+    dropTarget->SetScintilla(this);
+    stc->SetDropTarget(dropTarget);
+}
+
+
+void ScintillaWX::Finalise() {
+    ScintillaBase::Finalise();
+}
+
+
+void ScintillaWX::StartDrag() {
+    wxDropSource        source(wMain.GetID());
+    wxTextDataObject    data(dragChars);
+    wxDragResult        result;
+
+    source.SetData(data);
+    result = source.DoDragDrop(TRUE);
+    if (result == wxDragMove && dropWentOutside)
+        ClearSelection();
+    inDragDrop = FALSE;
+    SetDragPosition(invalidPosition);
+}
+
+
+void ScintillaWX::SetTicking(bool on) {
+    wxSTCTimer* steTimer;
+    if (timer.ticking != on) {
+        timer.ticking = on;
+        if (timer.ticking) {
+            steTimer = new wxSTCTimer(this);
+            steTimer->Start(timer.tickSize);
+            timer.tickerID = (int)steTimer;
+        } else {
+            steTimer = (wxSTCTimer*)timer.tickerID;
+            steTimer->Stop();
+            delete steTimer;
+            timer.tickerID = 0;
+        }
+    }
+    timer.ticksToWait = caret.period;
+}
+
+
+void ScintillaWX::SetMouseCapture(bool on) {
+    if (on && !capturedMouse)
+        wMain.GetID()->CaptureMouse();
+    else if (!on && capturedMouse)
+        wMain.GetID()->ReleaseMouse();
+    capturedMouse = on;
+}
+
+
+bool ScintillaWX::HaveMouseCapture() {
+    return capturedMouse;
+}
+
+
+void ScintillaWX::ScrollText(int linesToMove) {
+    int dy = vs.lineHeight * (linesToMove);
+    // TODO: calculate the rectangle to refreshed...
+    wMain.GetID()->ScrollWindow(0, dy);
+}
+
+void ScintillaWX::SetVerticalScrollPos() {
+    wMain.GetID()->SetScrollPos(wxVERTICAL, topLine);
+}
+
+void ScintillaWX::SetHorizontalScrollPos() {
+    wMain.GetID()->SetScrollPos(wxHORIZONTAL, xOffset);
+}
+
+
+bool ScintillaWX::ModifyScrollBars(int nMax, int nPage) {
+    bool modified = false;
+    int  sbMax    = wMain.GetID()->GetScrollRange(wxVERTICAL);
+    int  sbThumb  = wMain.GetID()->GetScrollThumb(wxVERTICAL);
+    int  sbPos    = wMain.GetID()->GetScrollPos(wxVERTICAL);
+
+
+    if (sbMax != nMax || sbThumb != nPage) {
+        wMain.GetID()->SetScrollbar(wxVERTICAL, sbPos, nPage, nMax);
+        modified = true;
+    }
+
+    sbMax    = wMain.GetID()->GetScrollRange(wxHORIZONTAL);
+    sbThumb  = wMain.GetID()->GetScrollThumb(wxHORIZONTAL);
+    if ((sbMax != H_SCROLL_MAX) || (sbThumb != H_SCROLL_STEP)) {
+        wMain.GetID()->SetScrollbar(wxHORIZONTAL, 0, H_SCROLL_STEP, H_SCROLL_MAX);
+        modified = true;
+    }
+    return modified;
+}
+
+
+void ScintillaWX::NotifyChange() {
+    stc->NotifyChange();
+}
+
+
+void ScintillaWX::NotifyParent(SCNotification scn) {
+    stc->NotifyParent(&scn);
+}
+
+
+
+void ScintillaWX::Copy() {
+    if (currentPos != anchor) {
+        char* text = CopySelectionRange();
+        textDO.SetText(text);
+        wxTheClipboard->Open();
+        wxTheClipboard->SetData(&textDO);
+        wxTheClipboard->Close();
+    }
+}
+
+
+void ScintillaWX::Paste() {
+    pdoc->BeginUndoAction();
+    ClearSelection();
+
+    wxTextDataObject data;
+    bool canPaste;
+
+    wxTheClipboard->Open();
+    canPaste = wxTheClipboard->GetData(data);
+    wxTheClipboard->Close();
+    if (canPaste) {
+        wxString str = data.GetText();
+        int      len = str.Length();
+        pdoc->InsertString(currentPos, str.c_str(), len);
+        SetEmptySelection(currentPos + len);
+    }
+
+    pdoc->EndUndoAction();
+    NotifyChange();
+    Redraw();
+}
+
+
+bool ScintillaWX::CanPaste() {
+    wxTextDataObject data;
+    bool canPaste;
+
+    wxTheClipboard->Open();
+    canPaste = wxTheClipboard->GetData(data);
+    wxTheClipboard->Close();
+
+    return canPaste;
+}
+
+void ScintillaWX::CreateCallTipWindow(PRectangle) {
+    ct.wCallTip = new wxWindow(wDraw.GetID(), -1);
+    ct.wDraw = ct.wCallTip;
+}
+
+
+void ScintillaWX::AddToPopUp(const char *label, int cmd, bool enabled) {
+    if (!label[0])
+        popup.GetID()->AppendSeparator();
+    else
+        popup.GetID()->Append(cmd, label);
+
+    if (!enabled)
+        popup.GetID()->Enable(cmd, enabled);
+
+    // TODO:  need to create event handler mappings for the cmd ID
+}
+
+
+void ScintillaWX::ClaimSelection() {
+
+}
+
+
+LRESULT ScintillaWX::DefWndProc(UINT /*iMessage*/, WPARAM /*wParam*/, LPARAM /*lParam*/) {
+    return 0;
+}
+
+LRESULT ScintillaWX::WndProc(UINT iMessage, WPARAM wParam, LPARAM lParam) {
+    switch (iMessage) {
+    case EM_CANPASTE:
+        return CanPaste();
+    default:
+        return ScintillaBase::WndProc(iMessage, wParam, lParam);
+    }
+    return 0;
+}
+
+
+
+//----------------------------------------------------------------------
+// Event delegates
+
+void ScintillaWX::DoPaint(wxDC* dc, wxRect rect) {
+
+    paintState = painting;
+    Surface surfaceWindow;
+    surfaceWindow.Init(dc);
+    PRectangle rcPaint = PRectangleFromwxRect(rect);
+    dc->BeginDrawing();
+    Paint(&surfaceWindow, rcPaint);
+    dc->EndDrawing();
+    surfaceWindow.Release();
+    if (paintState == paintAbandoned) {
+        // Painting area was insufficient to cover new styling or brace highlight positions
+        FullPaint();
+    }
+    paintState = notPainting;
+}
+
+
+void ScintillaWX::DoHScroll(int type, int pos) {
+    int xPos = xOffset;
+    switch (type) {
+    case wxEVT_SCROLLWIN_LINEUP:
+        xPos -= H_SCROLL_STEP;
+        break;
+    case wxEVT_SCROLLWIN_LINEDOWN:
+        xPos += H_SCROLL_STEP;
+        break;
+    case wxEVT_SCROLLWIN_PAGEUP:
+        xPos -= H_SCROLL_PAGE;
+        break;
+    case wxEVT_SCROLLWIN_PAGEDOWN:
+        xPos += H_SCROLL_PAGE;
+        break;
+    case wxEVT_SCROLLWIN_TOP:
+        xPos = 0;
+        break;
+    case wxEVT_SCROLLWIN_BOTTOM:
+        xPos = H_SCROLL_MAX;
+        break;
+    case wxEVT_SCROLLWIN_THUMBTRACK:
+        xPos = pos;
+        break;
+    }
+    HorizontalScrollTo(xPos);
+}
+
+void ScintillaWX::DoVScroll(int type, int pos) {
+    int topLineNew = topLine;
+    switch (type) {
+    case wxEVT_SCROLLWIN_LINEUP:
+        topLineNew -= 1;
+        break;
+    case wxEVT_SCROLLWIN_LINEDOWN:
+        topLineNew += 1;
+        break;
+    case wxEVT_SCROLLWIN_PAGEUP:
+        topLineNew -= LinesToScroll();
+        break;
+    case wxEVT_SCROLLWIN_PAGEDOWN:
+        topLineNew += LinesToScroll();
+        break;
+    case wxEVT_SCROLLWIN_TOP:
+        topLineNew = 0;
+        break;
+    case wxEVT_SCROLLWIN_BOTTOM:
+        topLineNew = MaxScrollPos();
+        break;
+    case wxEVT_SCROLLWIN_THUMBTRACK:
+        topLineNew = pos;
+        break;
+    }
+    ScrollTo(topLineNew);
+}
+
+void ScintillaWX::DoSize(int width, int height) {
+    PRectangle rcClient(0,0,width,height);
+    SetScrollBarsTo(rcClient);
+    DropGraphics();
+}
+
+void ScintillaWX::DoLoseFocus(){
+    DropCaret();
+}
+
+void ScintillaWX::DoGainFocus(){
+    ShowCaretAtCurrentPosition();
+}
+
+void ScintillaWX::DoSysColourChange() {
+    InvalidateStyleData();
+}
+
+void ScintillaWX::DoButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) {
+    ButtonDown(pt, curTime, shift, ctrl, alt);
+}
+
+void ScintillaWX::DoButtonUp(Point pt, unsigned int curTime, bool ctrl) {
+    ButtonUp(pt, curTime, ctrl);
+}
+
+void ScintillaWX::DoButtonMove(Point pt) {
+    ButtonMove(pt);
+}
+
+
+void ScintillaWX::DoAddChar(char ch) {
+    AddChar(ch);
+}
+
+int  ScintillaWX::DoKeyDown(int key, bool shift, bool ctrl, bool alt) {
+    return KeyDown(key, shift, ctrl, alt);
+}
+
+
+void ScintillaWX::DoCommand(int ID) {
+    Command(ID);
+}
+
+
+void ScintillaWX::DoContextMenu(Point pt) {
+    ContextMenu(pt);
+}
+
+
+//----------------------------------------------------------------------
+
+bool ScintillaWX::DoDropText(long x, long y, const wxString& data) {
+    SetDragPosition(invalidPosition);
+    int movePos = PositionFromLocation(Point(x,y));
+    DropAt(movePos, data, dragResult == wxDragMove, FALSE); // TODO: rectangular?
+    return TRUE;
+}
+
+
+wxDragResult ScintillaWX::DoDragEnter(wxCoord x, wxCoord y, wxDragResult def) {
+    return def;
+}
+
+
+wxDragResult ScintillaWX::DoDragOver(wxCoord x, wxCoord y, wxDragResult def) {
+    SetDragPosition(PositionFromLocation(Point(x, y)));
+    dragResult = def;
+    return def;
+}
+
+
+void ScintillaWX::DoDragLeave() {
+    SetDragPosition(invalidPosition);
+}
+
+//----------------------------------------------------------------------
+
+// Redraw all of text area. This paint will not be abandoned.
+void ScintillaWX::FullPaint() {
+    paintState = painting;
+    rcPaint = GetTextRectangle();
+    wxClientDC dc(wMain.GetID());
+    Surface surfaceWindow;
+    surfaceWindow.Init(&dc);
+    Paint(&surfaceWindow, rcPaint);
+    surfaceWindow.Release();
+    paintState = notPainting;
+}
+
+
+void ScintillaWX::DoScrollToLine(int line) {
+    ScrollTo(line);
+}
+
+
+void ScintillaWX::DoScrollToColumn(int column) {
+    HorizontalScrollTo(column * vs.spaceWidth);
+}
+
+
+
+//----------------------------------------------------------------------
+//----------------------------------------------------------------------

contrib/src/stc/ScintillaWX.h

@@ -0,0 +1,148 @@
+////////////////////////////////////////////////////////////////////////////
+// Name:        ScintillaWX.h
+// Purpose:     A wxWindows implementation of Scintilla.  A class derived
+//              from ScintillaBase that uses the "wx platform" defined in
+//              PlatWX.cpp.  This class is one end of a bridge between
+//              the wx world and the Scintilla world.  It needs a peer
+//              object of type wxStyledTextCtrl to function.
+//
+// Author:      Robin Dunn
+//
+// Created:     13-Jan-2000
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __ScintillaWX_h__
+#define __ScintillaWX_h__
+
+//----------------------------------------------------------------------
+
+#include "Platform.h"
+
+#include "Scintilla.h"
+#ifdef SCI_LEXER
+#include "SciLexer.h"
+#include "PropSet.h"
+#include "Accessor.h"
+#include "KeyWords.h"
+#endif
+#include "ContractionState.h"
+#include "SVector.h"
+#include "CellBuffer.h"
+#include "CallTip.h"
+#include "KeyMap.h"
+#include "Indicator.h"
+#include "LineMarker.h"
+#include "Style.h"
+#include "ViewStyle.h"
+#include "AutoComplete.h"
+#include "Document.h"
+#include "Editor.h"
+#include "ScintillaBase.h"
+
+#include <wx/wx.h>
+#include <wx/dataobj.h>
+#include <wx/clipbrd.h>
+#include <wx/dnd.h>
+
+//----------------------------------------------------------------------
+
+class wxStyledTextCtrl;           // forward
+class ScintillaWX;
+
+
+//----------------------------------------------------------------------
+// Helper classes
+
+class wxSTCDropTarget : public wxTextDropTarget {
+public:
+    void SetScintilla(ScintillaWX* swx) {
+        this->swx = swx;
+    }
+
+    bool OnDropText(wxCoord x, wxCoord y, const wxString& data);
+    wxDragResult OnEnter(wxCoord x, wxCoord y, wxDragResult def);
+    wxDragResult OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
+    void OnLeave();
+
+private:
+    ScintillaWX* swx;
+};
+
+
+//----------------------------------------------------------------------
+
+class ScintillaWX : public ScintillaBase {
+public:
+
+    ScintillaWX(wxStyledTextCtrl* win);
+    ~ScintillaWX();
+
+    // base class virtuals
+    virtual void Initialise();
+    virtual void Finalise();
+    virtual void StartDrag();
+    virtual void SetTicking(bool on);
+    virtual void SetMouseCapture(bool on);
+    virtual bool HaveMouseCapture();
+    virtual void ScrollText(int linesToMove);
+    virtual void SetVerticalScrollPos();
+    virtual void SetHorizontalScrollPos();
+    virtual bool ModifyScrollBars(int nMax, int nPage);
+    virtual void Copy();
+    virtual void Paste();
+    virtual void CreateCallTipWindow(PRectangle rc);
+    virtual void AddToPopUp(const char *label, int cmd = 0, bool enabled = true);
+    virtual void ClaimSelection();
+
+    virtual LRESULT DefWndProc(UINT iMessage, WPARAM wParam, LPARAM lParam);
+    virtual LRESULT WndProc(UINT iMessage, WPARAM wParam, LPARAM lParam);
+
+    virtual void NotifyChange();
+    virtual void NotifyParent(SCNotification scn);
+
+
+    // Event delegates
+    void DoPaint(wxDC* dc, wxRect rect);
+    void DoHScroll(int type, int pos);
+    void DoVScroll(int type, int pos);
+    void DoSize(int width, int height);
+    void DoLoseFocus();
+    void DoGainFocus();
+    void DoSysColourChange();
+    void DoButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt);
+    void DoButtonUp(Point pt, unsigned int curTime, bool ctrl);
+    void DoButtonMove(Point pt);
+    void DoAddChar(char ch);
+    int  DoKeyDown(int key, bool shift, bool ctrl, bool alt);
+    void DoTick() { Tick(); }
+
+    bool DoDropText(long x, long y, const wxString& data);
+    wxDragResult DoDragEnter(wxCoord x, wxCoord y, wxDragResult def);
+    wxDragResult DoDragOver(wxCoord x, wxCoord y, wxDragResult def);
+    void DoDragLeave();
+
+    void DoCommand(int ID);
+    void DoContextMenu(Point pt);
+
+
+    // helpers
+    void FullPaint();
+    bool CanPaste();
+    bool GetHideSelection() { return hideSelection; }
+    void DoScrollToLine(int line);
+    void DoScrollToColumn(int column);
+
+private:
+    bool                capturedMouse;
+    wxStyledTextCtrl*   stc;
+
+    wxTextDataObject    textDO;
+    wxSTCDropTarget*    dropTarget;
+    wxDragResult        dragResult;
+};
+
+//----------------------------------------------------------------------
+#endif

contrib/src/stc/StcVC.dsp

@@ -0,0 +1,250 @@
+# Microsoft Developer Studio Project File - Name="StcVC" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=StcVC - 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 "StcVC.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 "StcVC.mak" CFG="StcVC - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "StcVC - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "StcVC - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+
+!IF  "$(CFG)" == "StcVC - 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 Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x809
+# ADD RSC /l 0x809
+# 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 "../../include" /I "scintilla/include" /I "scintilla/src" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /D "__WX__" /D "SCI_LEXER" /FD /c
+# SUBTRACT CPP /YX
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\..\lib\stc.lib"
+
+!ELSEIF  "$(CFG)" == "StcVC - 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 Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x809
+# ADD RSC /l 0x809
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /GX /Z7 /Od /I "../../../include" /I "../../include" /I "scintilla/include" /I "scintilla/src" /D "_DEBUG" /D DEBUG=1 /D "__WXDEBUG__" /D "WIN32" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /D "__WX__" /D "SCI_LEXER" /FD /c
+# SUBTRACT CPP /YX
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\..\lib\stcd.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "StcVC - Win32 Release"
+# Name "StcVC - Win32 Debug"
+# Begin Group "Stc"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\PlatWX.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ScintillaWX.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ScintillaWX.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\stc.cpp
+# End Source File
+# End Group
+# Begin Group "Scintilla"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\scintilla\src\Accessor.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\AutoComplete.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\AutoComplete.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\CallTip.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\CallTip.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\CellBuffer.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\CellBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\ContractionState.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\ContractionState.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\Document.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\Document.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\Editor.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\Editor.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\Indicator.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\Indicator.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\KeyMap.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\KeyMap.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\KeyWords.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\LexCPP.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\LexHTML.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\LexOthers.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\LexPerl.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\LexPython.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\LexSQL.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\LexVB.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\LineMarker.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\LineMarker.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\PropSet.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\ScintillaBase.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\ScintillaBase.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\Style.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\Style.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\SVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\ViewStyle.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\scintilla\src\ViewStyle.h
+# End Source File
+# End Group
+# End Target
+# End Project

contrib/src/stc/StcVC.dsw

@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "StcVC"=.\StcVC.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

contrib/src/stc/makefile.b32

@@ -0,0 +1,79 @@
+#
+# File:		makefile.b32
+# Author:	Julian Smart
+# Created:	1999
+# Updated:	
+# Copyright:
+#
+# Makefile : Builds wxMMedia library for 32-bit BC++
+
+# N.B. use:
+# make -f makefile.b32 stc.cfg
+# make -f makefile.b32
+
+WXDIR = $(WXWIN)
+
+SCINTILLA=.\scintilla
+S=$(SCINTILLA)\src
+
+STCEXTRACPPFLAGS=-D__WX__ -DSCI_LEXER -I$(SCINTILLA)/include -I$(S)
+
+LIBTARGET=$(WXDIR)\contrib\lib\stc.lib
+
+OBJECTS = \
+	Accessor.obj	\
+	AutoComplete.obj	\
+	CallTip.obj	\
+	CellBuffer.obj	\
+	ContractionState.obj\
+	Document.obj	\
+	Editor.obj		\
+	Indicator.obj	\
+	KeyMap.obj		\
+	KeyWords.obj	\
+	LineMarker.obj	\
+	PropSet.obj	\
+	ScintillaBase.obj	\
+	Style.obj		\
+	ViewStyle.obj	\
+				\
+	PlatWX.obj		\
+	ScintillaWX.obj	\
+	stc.obj		\
+
+!include $(WXDIR)\src\makelib.b32
+
+CFG = stc.cfg
+CPPFLAGS=$(DLL_FLAGS) $(EXTRACPPFLAGS) @$(CFG)
+
+{$(S)}.cxx.obj:
+	bcc32 $(CPPFLAGS) -P -c {$< }
+
+$(CFG): makefile.b32
+	copy &&!
+-H=$(WXDIR)\src\msw\wx32.csm
+-3
+-d
+-a1 # byte alignment
+-R-
+-X
+-w-par
+-w-aus
+-w-hid # virtual function A hides virtual function B
+-WE
+-tWM
+
+-I$(WXINC);$(BCCDIR)\include;$(WXDIR)/src/generic;$(WXDIR)/src/png;$(WXDIR)/src/jpeg;$(WXDIR)/src/zlib;$(WXDIR)/src/xpm;$(WXDIR)/src/tiff
+-I$(WXDIR)\include\wx\msw\gnuwin32
+
+-L$(BCCDIR)\lib
+-D__WXWIN__
+-D__WXMSW__
+-D__WINDOWS__
+-DWIN32
+$(OPT)
+$(DEBUG_FLAGS)
+$(WIN95FLAG)
+$(STCEXTRACPPFLAGS)
+! $(CFG)
+

contrib/src/stc/makefile.g95

@@ -0,0 +1,34 @@
+# File:		makefile.g95  For stectrl
+# Author:	Robin Dunn
+# Created:	1-Feb-2000
+# Updated:
+
+WXDIR = ../../..
+
+SCINTILLA=$(WXDIR)/contrib/src/stc/scintilla
+S=$(SCINTILLA)/src
+EXTRAINC=-D__WX__ -DSCI_LEXER -I$(SCINTILLA)/include -I$(S) -I. -I$(WXDIR)/contrib/include
+
+OBJECTS = \
+	$(S)/Accessor.$(OBJSUFF) \
+	$(S)/AutoComplete.$(OBJSUFF) \
+	$(S)/CallTip.$(OBJSUFF) \
+	$(S)/CellBuffer.$(OBJSUFF) \
+	$(S)/ContractionState.$(OBJSUFF)\
+	$(S)/Document.$(OBJSUFF) \
+	$(S)/Editor.$(OBJSUFF) \
+	$(S)/Indicator.$(OBJSUFF) \
+	$(S)/KeyMap.$(OBJSUFF) \
+	$(S)/KeyWords.$(OBJSUFF) \
+	$(S)/LineMarker.$(OBJSUFF) \
+	$(S)/PropSet.$(OBJSUFF) \
+	$(S)/ScintillaBase.$(OBJSUFF) \
+	$(S)/Style.$(OBJSUFF) \
+	$(S)/ViewStyle.$(OBJSUFF) \
+	PlatWX.$(OBJSUFF) \
+	ScintillaWX.$(OBJSUFF) \
+	stc.$(OBJSUFF)
+
+LIBTARGET = $(WXDIR)/contrib/lib/libstc.a
+
+include $(WXDIR)/src/makelib.g95

contrib/src/stc/makefile.vc

@@ -0,0 +1,94 @@
+# File:		makefile.vc  For stectrl
+# Author:	Robin Dunn
+# Created:	1-Feb-2000
+# Updated:
+
+
+
+# Set WXDIR for your system
+WXDIR = $(WXWIN)
+SCINTILLA=.\scintilla
+S=$(SCINTILLA)\src
+EXTRAINC=-D__WX__ -DSCI_LEXER -I$(SCINTILLA)/include -I$(S) -I. -I$(WXDIR)\contrib\include
+NOPCH=1
+
+!include $(WXDIR)\src\makevc.env
+
+OBJECTS = \
+	$(D)\Accessor.obj	\
+	$(D)\AutoComplete.obj	\
+	$(D)\CallTip.obj	\
+	$(D)\CellBuffer.obj	\
+	$(D)\ContractionState.obj\
+	$(D)\Document.obj	\
+	$(D)\Editor.obj		\
+	$(D)\Indicator.obj	\
+	$(D)\KeyMap.obj		\
+	$(D)\KeyWords.obj	\
+	$(D)\LineMarker.obj	\
+	$(D)\PropSet.obj	\
+	$(D)\ScintillaBase.obj	\
+	$(D)\Style.obj		\
+	$(D)\ViewStyle.obj	\
+				\
+	$(D)\PlatWX.obj		\
+	$(D)\ScintillaWX.obj	\
+	$(D)\stc.obj		\
+
+
+
+
+LIBTARGET = $(WXDIR)\contrib\lib\stc$(LIBEXT).lib
+
+all:    $(D) $(LIBTARGET)
+
+$(D) :
+	mkdir $(D)
+
+wx:
+        cd $(WXDIR)\src\msw
+        nmake -f makefile.vc FINAL=$(FINAL)
+        cd $(THISDIR)
+
+wxclean:
+        cd $(WXDIR)\src\msw
+        nmake -f makefile.vc clean
+        cd $(THISDIR)
+
+
+
+
+$(LIBTARGET): $(OBJECTS)
+	-erase $(LIBTARGET)
+	$(implib) @<<
+-out:$(LIBTARGET)
+-machine:$(CPU)
+$(OBJECTS)
+<<
+
+
+
+{$(S)}.cxx{$(D)}.obj:
+	$(cc) @<<
+$(CPPFLAGS) /c /Fo$@ /Tp $<
+<<
+
+{}.cpp{$(D)}.obj:
+	$(cc) @<<
+$(CPPFLAGS) /c /Fo$@ /Tp $<
+<<
+
+
+show:
+	@echo $(CPPFLAGS)
+
+
+clean:
+        -erase $(D)\*.obj
+        -erase *.sbr
+        -erase *.exe
+        -erase *.res
+        -erase *.map
+        -erase *.pdb
+        -erase $(LIBTARGET)
+

contrib/src/stc/scintilla/README.txt

@@ -0,0 +1,7 @@
+This directory contains copies of the scintilla/src and
+scintilla/include directories from the Scintilla/SCiTE source
+distribution.  All other code needed to implement Scintilla on top of
+wxWindows is located in the directory above this one.
+
+The current version of the Scintilla code is somewhere between 1.22
+and 1.23, (from their CVS.)

contrib/src/stc/scintilla/include/Accessor.h

@@ -0,0 +1,88 @@
+// SciTE - Scintilla based Text Editor
+// Accessor.h - rapid easy access to contents of a Scintilla
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+enum { wsSpace = 1, wsTab = 2, wsSpaceTab = 4, wsInconsistent=8};
+
+class Accessor {
+protected:
+	// bufferSize is a trade off between time taken to copy the characters and SendMessage overhead
+	// slopSize positions the buffer before the desired position in case there is some backtracking
+	enum {bufferSize=4000, slopSize=bufferSize/8};
+	char buf[bufferSize+1];
+	WindowID id;
+	PropSet &props;
+	int startPos;
+	int endPos;
+	int lenDoc;
+	int offset;	// Optional but including an offset makes GCC generate better code 
+	int codePage;	
+	bool InternalIsLeadByte(char ch);
+	void Fill(int position);
+public:
+	Accessor(WindowID id_, PropSet &props_, int offset_=0) : 
+			id(id_), props(props_), startPos(0x7FFFFFFF), endPos(0), 
+			lenDoc(-1), offset(offset_), codePage(0) {
+	}
+	void SetCodePage(int codePage_) { codePage = codePage_; }
+	char operator[](int position) {
+		position += offset;
+		if (position < startPos || position >= endPos) {
+			Fill(position);
+		}
+		return buf[position - startPos];
+	}
+	char SafeGetCharAt(int position, char chDefault=' ') {
+		// Safe version of operator[], returning a defined value for invalid position 
+		position += offset;
+		if (position < startPos || position >= endPos) {
+			Fill(position);
+			if (position < startPos || position >= endPos) {
+				// Position is outside range of document 
+				return chDefault;
+			}
+		}
+		return buf[position - startPos];
+	}
+	bool IsLeadByte(char ch) {
+		return codePage && InternalIsLeadByte(ch);
+	}
+	char StyleAt(int position);
+	int GetLine(int position);
+	int LineStart(int line);
+	int LevelAt(int line);
+	int Length();
+	void Flush() {
+		startPos = 0x7FFFFFFF;
+		lenDoc = -1;
+	}
+	int GetLineState(int line);
+	int SetLineState(int line, int state);
+	PropSet &GetPropSet() { return props; }
+};
+
+class StylingContext;
+
+typedef bool (*PFNIsCommentLeader)(StylingContext &styler, int pos, int len);
+
+class StylingContext : public Accessor {
+	char styleBuf[bufferSize];
+	int validLen;
+	char chFlags;
+	char chWhile;
+	unsigned int startSeg;
+public:
+	StylingContext(WindowID id_, PropSet &props_, int offset_=0) : 
+		Accessor(id_,props_,offset_), validLen(0), chFlags(0) {}
+	void StartAt(unsigned int start, char chMask=31);
+	void SetFlags(char chFlags_, char chWhile_) {chFlags = chFlags_; chWhile = chWhile_; };
+	unsigned int GetStartSegment() { return startSeg; }
+	void StartSegment(unsigned int pos);
+	void ColourTo(unsigned int pos, int chAttr);
+	int GetLine(int position);
+	void SetLevel(int line, int level);
+	void Flush();
+	int IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0);
+};
+

contrib/src/stc/scintilla/include/KeyWords.h

@@ -0,0 +1,41 @@
+// SciTE - Scintilla based Text Editor
+// KeyWords.h - colourise for particular languages
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+typedef void (*LexerFunction)(unsigned int startPos, int lengthDoc, int initStyle,
+                  WordList *keywordlists[], StylingContext &styler);
+                  
+class LexerModule {
+	static LexerModule *base;
+	LexerModule *next;
+	int language;
+	LexerFunction fn;
+public:
+	LexerModule(int language_, LexerFunction fn_);
+	static void Colourise(unsigned int startPos, int lengthDoc, int initStyle,
+                  int language, WordList *keywordlists[], StylingContext &styler);
+};
+
+inline bool iswordchar(char ch) {
+	return isalnum(ch) || ch == '.' || ch == '_';
+}
+
+inline bool iswordstart(char ch) {
+	return isalnum(ch) || ch == '_';
+}
+
+inline bool isoperator(char ch) {
+	if (isalnum(ch))
+		return false;
+	// '.' left out as it is used to make up numbers
+	if (ch == '%' || ch == '^' || ch == '&' || ch == '*' ||
+	        ch == '(' || ch == ')' || ch == '-' || ch == '+' ||
+	        ch == '=' || ch == '|' || ch == '{' || ch == '}' ||
+	        ch == '[' || ch == ']' || ch == ':' || ch == ';' ||
+	        ch == '<' || ch == '>' || ch == ',' || ch == '/' ||
+	        ch == '?' || ch == '!' || ch == '.' || ch == '~')
+		return true;
+	return false;
+}
+

contrib/src/stc/scintilla/include/Platform.h

@@ -0,0 +1,395 @@
+// Scintilla source code edit control
+// Platform.h - interface to platform facilities
+// Also includes some basic utilities
+// Implemented in PlatGTK.cxx for GTK+/Linux, PlatWin.cxx for Windows, and PlatWX.cxx for wxWindows
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef PLATFORM_H
+#define PLATFORM_H
+
+// PLAT_GTK = GTK+ on Linux, PLAT_WIN = Win32 API on Win32 OS
+// PLAT_WX is wxWindows on any supported platform
+// Could also have PLAT_GTKWIN = GTK+ on Win32 OS in future
+
+#define PLAT_GTK 0
+#define PLAT_WIN 0
+#define PLAT_WX  0
+
+#if defined(__WX__)
+#undef PLAT_WX
+#define PLAT_WX  1
+
+#elif defined(GTK)
+#undef PLAT_GTK
+#define PLAT_GTK 1
+
+#else
+#undef PLAT_WIN
+#define PLAT_WIN 1
+
+#endif
+
+
+// Include the main header for each platform
+
+#if PLAT_GTK
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#endif
+
+#if PLAT_WIN
+#define _WIN32_WINNT  0x0400 // Otherwise some required stuff gets ifdef'd out
+// Vassili Bourdo: shut up annoying Visual C++ warnings:
+#ifdef _MSC_VER
+#pragma warning(disable: 4800 4244 4309)
+#endif
+#include <windows.h>
+#include <richedit.h>
+#endif
+
+#if PLAT_WX
+#include <wx/wx.h>
+#endif
+
+// Underlying the implementation of the platform classes are platform specific types.
+// Sometimes these need to be passed around by client code so they are defined here
+
+#if PLAT_GTK
+typedef GdkColor ColourID;
+typedef GdkFont* FontID;
+typedef GdkDrawable* SurfaceID;
+typedef GtkWidget* WindowID;
+typedef GtkItemFactory* MenuID;
+#endif
+
+#if PLAT_WIN
+typedef COLORREF ColourID;
+typedef HFONT FontID;
+typedef HDC SurfaceID;
+typedef HWND WindowID;
+typedef HMENU MenuID;
+#endif
+
+#if PLAT_WX
+typedef wxColour ColourID;
+typedef wxFont* FontID;
+typedef wxDC* SurfaceID;
+typedef wxWindow* WindowID;
+typedef wxMenu* MenuID;
+#endif
+
+#if PLAT_GTK || PLAT_WX
+#define SHIFT_PRESSED 1
+#define LEFT_CTRL_PRESSED 2
+#define LEFT_ALT_PRESSED 4
+#endif
+
+// Point is exactly the same as the Win32 POINT and GTK+ GdkPoint so can be used interchangeably
+
+class Point {
+public:
+	int x;
+	int y;
+	
+	Point(int x_=0, int y_=0) : x(x_), y(y_) {
+	}
+
+	// Other automatically defined methods (assignment, copy constructor, destructor) are fine
+	
+	static Point FromLong(long lpoint);
+};
+
+// PRectangle is exactly the same as the Win32 RECT so can be used interchangeably
+// PRectangles contain their top and left sides, but not their right and bottom sides
+class PRectangle {
+public:
+	int left;
+	int top;
+	int right;
+	int bottom;
+
+	PRectangle(int left_=0, int top_=0, int right_=0, int bottom_ = 0) :
+		left(left_), top(top_), right(right_), bottom(bottom_) {
+	}
+
+	// Other automatically defined methods (assignment, copy constructor, destructor) are fine
+
+	bool Contains(Point pt) {
+		return (pt.x >= left) && (pt.x <= right) &&
+			(pt.y >= top) && (pt.y <= bottom);
+	}
+	bool Contains(PRectangle rc) {
+		return (rc.left >= left) && (rc.right <= right) &&
+			(rc.top >= top) && (rc.bottom <= bottom);
+	}
+	bool Intersects(PRectangle other) {
+		return (right >= other.left) && (left <= other.right) &&
+			(bottom >= other.top) && (top <= other.bottom);
+	}
+	int Width() { return right - left; }
+	int Height() { return bottom - top; }
+};
+
+#if PLAT_WX
+wxRect wxRectFromPRectangle(PRectangle prc);
+PRectangle PRectangleFromwxRect(wxRect rc);
+#endif
+
+class Colour {
+	ColourID co;
+public:
+	Colour(long lcol=0);
+	Colour(unsigned int red, unsigned int green, unsigned int blue);
+	bool operator==(const Colour &other) const;
+	long AsLong() const;
+	unsigned int GetRed();
+	unsigned int GetGreen();
+	unsigned int GetBlue();
+	
+	friend class Surface;
+	friend class Palette;
+};
+
+// Colour pairs hold a desired colour and the colour that the graphics engine
+// allocates to approximate the desired colour.
+// To make palette management more automatic, ColourPairs could register at 
+// construction time with a palette management object.
+struct ColourPair {
+	Colour desired;
+	Colour allocated;
+
+	ColourPair(Colour desired_=Colour(0,0,0)) {
+		desired = desired_;
+		allocated = desired;
+	}
+};
+
+class Window;	// Forward declaration for Palette
+
+class Palette {
+	int used;
+	enum {numEntries = 100};
+	ColourPair entries[numEntries];
+#if PLAT_GTK
+	GdkColor *allocatedPalette;
+	int allocatedLen;
+#elif PLAT_WIN
+	HPALETTE hpal;
+#elif PLAT_WX
+	// wxPalette* pal;  // **** Is this needed?
+#endif
+public:
+	bool allowRealization;
+	
+	Palette();
+	~Palette();
+
+	void Release();
+	
+	// This method either adds a colour to the list of wanted colours (want==true)
+	// or retrieves the allocated colour back to the ColourPair.
+	// This is one method to make it easier to keep the code for wanting and retrieving in sync.
+	void WantFind(ColourPair &cp, bool want);
+
+	void Allocate(Window &w);
+	
+	friend class Surface;
+};
+
+class Font {
+	FontID id;
+#if PLAT_WX
+	int ascent;
+#endif
+	// Private so Font objects can not be copied
+	Font(const Font &) {}
+	Font &operator=(const Font &) { id=0; return *this; }
+public:
+	Font();
+	~Font();
+
+	void Create(const char *faceName, int size, bool bold=false, bool italic=false);
+	void Release();
+
+	FontID GetID() { return id; }
+	// Alias another font - caller guarantees not to Release
+	void SetID(FontID id_) { id = id_; }
+	friend class Surface;
+};
+
+// A surface abstracts a place to draw
+class Surface {
+private:
+#if PLAT_GTK
+	GdkDrawable *drawable;
+	GdkGC *gc;
+	GdkPixmap *ppixmap;
+	int x;
+	int y;
+	bool inited;
+	bool createdGC;
+#elif PLAT_WIN
+	HDC hdc;
+	bool hdcOwned;
+	HPEN pen;
+	HPEN penOld;
+	HBRUSH brush;
+	HBRUSH brushOld;
+	HFONT font;
+	HFONT fontOld;
+	HBITMAP bitmap;
+	HBITMAP bitmapOld;
+	HPALETTE paletteOld;
+#elif PLAT_WX
+	wxDC* hdc;
+	bool hdcOwned;
+	wxBitmap* bitmap;
+	int x;
+	int y;
+#endif
+
+	// Private so Surface objects can not be copied
+	Surface(const Surface &) {}
+	Surface &operator=(const Surface &) { return *this; }
+#if PLAT_WIN || PLAT_WX
+	void BrushColor(Colour back);
+	void SetFont(Font &font_);
+#endif
+public:
+	Surface();
+	~Surface();
+	
+	void Init();
+	void Init(SurfaceID hdc_);
+	void InitPixMap(int width, int height, Surface *surface_);
+
+	void Release();
+	bool Initialised();
+	void PenColour(Colour fore);
+	int LogPixelsY();
+	void MoveTo(int x_, int y_);
+	void LineTo(int x_, int y_);
+	void Polygon(Point *pts, int npts, Colour fore, Colour back);
+	void RectangleDraw(PRectangle rc, Colour fore, Colour back);
+	void FillRectangle(PRectangle rc, Colour back);
+	void FillRectangle(PRectangle rc, Surface &surfacePattern);
+	void RoundedRectangle(PRectangle rc, Colour fore, Colour back);
+	void Ellipse(PRectangle rc, Colour fore, Colour back);
+	void Copy(PRectangle rc, Point from, Surface &surfaceSource);
+
+	void DrawText(PRectangle rc, Font &font_, int ybase, const char *s, int len, Colour fore, Colour back);
+	void DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len, Colour fore, Colour back);
+	void MeasureWidths(Font &font_, const char *s, int len, int *positions);
+	int WidthText(Font &font_, const char *s, int len);
+	int WidthChar(Font &font_, char ch);
+	int Ascent(Font &font_);
+	int Descent(Font &font_);
+	int InternalLeading(Font &font_);
+	int ExternalLeading(Font &font_);
+	int Height(Font &font_);
+	int AverageCharWidth(Font &font_);
+	
+	int SetPalette(Palette *pal, bool inBackGround);
+	void SetClip(PRectangle rc);
+	void FlushCachedState();
+};
+
+// Class to hide the details of window manipulation
+// Does not own the window which will normally have a longer life than this object
+class Window {
+	friend class ListBox;
+protected:
+	WindowID id;
+public:
+	Window() : id(0) {}
+	virtual ~Window();
+	Window &operator=(WindowID id_) {
+		id = id_;
+		return *this;
+	}
+	WindowID GetID() { return id; }
+	bool Created() { return id != 0; }
+	void Destroy();
+	bool HasFocus();
+	PRectangle GetPosition();
+	void SetPosition(PRectangle rc);
+	void SetPositionRelative(PRectangle rc, Window relativeTo);
+	PRectangle GetClientPosition();
+	void Show(bool show=true);
+	void InvalidateAll();
+	void InvalidateRectangle(PRectangle rc);
+	void SetFont(Font &font);
+	enum Cursor { cursorText, cursorArrow, cursorUp, cursorWait, cursorHoriz, cursorVert, cursorReverseArrow };
+	void SetCursor(Cursor curs);
+	void SetTitle(const char *s);
+#if PLAT_WIN
+	LRESULT SendMessage(UINT msg, WPARAM wParam=0, LPARAM lParam=0);
+	int GetDlgCtrlID();
+	HINSTANCE GetInstance();
+#endif
+};
+
+class ListBox : public Window {
+#if PLAT_GTK
+	WindowID list;
+	WindowID scroller;
+	int current;
+#endif
+public:
+	ListBox();
+	virtual ~ListBox();
+	ListBox &operator=(WindowID id_) {
+		id = id_;
+		return *this;
+	}
+	void Create(Window &parent, int ctrlID);
+	void Clear();
+	void Append(char *s);
+	int Length();
+	void Select(int n);
+	int GetSelection();
+	int Find(const char *prefix);
+	void GetValue(int n, char *value, int len);
+	void Sort();
+};
+
+class Menu {
+	MenuID id;
+public:
+	Menu();
+	MenuID GetID() { return id; }
+	void CreatePopUp();
+	void Destroy();
+	void Show(Point pt, Window &w);
+};
+
+// Platform class used to retrieve system wide parameters such as double click speed
+// and chrome colour. Not a creatable object, more of a module with several functions.
+class Platform {
+	// Private so Platform objects can not be copied
+	Platform(const Platform &) {}
+	Platform &operator=(const Platform &) { return *this; }
+public:
+	// Should be private because no new Platforms are ever created
+	// but gcc warns about this
+	Platform() {}
+	~Platform() {}
+	static Colour Chrome();
+	static Colour ChromeHighlight();
+	static const char *DefaultFont();
+	static int DefaultFontSize();
+	static unsigned int DoubleClickTime();
+	static void DebugDisplay(const char *s);
+	static bool IsKeyDown(int key);
+	static long SendScintilla(
+		WindowID w, unsigned int msg, unsigned long wParam=0, long lParam=0);
+	
+	// These are utility functions not really tied to a platform
+	static int Minimum(int a, int b);
+	static int Maximum(int a, int b);
+	static void DebugPrintf(const char *format, ...);
+	static int Clamp(int val, int minVal, int maxVal);
+};
+
+#endif

contrib/src/stc/scintilla/include/PropSet.h

@@ -0,0 +1,180 @@
+// SciTE - Scintilla based Text Editor
+// PropSet.h - a java style properties file module
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef PROPSET_H
+#define PROPSET_H
+
+bool EqualCaseInsensitive(const char *a, const char *b);
+
+// Define another string class.
+// While it would be 'better' to use std::string, that doubles the executable size.
+
+inline char *StringDup(const char *s) {
+	if (!s)
+		return 0;
+	char *sNew = new char[strlen(s) + 1];
+	if (sNew)
+		strcpy(sNew, s);
+	return sNew;
+}
+
+class SString {
+	char *s;
+public:
+	SString() {
+		s = 0;
+	}
+	SString(const SString &source) {
+		s = StringDup(source.s);
+	}
+	SString(const char *s_) {
+		s = StringDup(s_);
+	}
+	SString(int i) {
+		char number[100];
+		sprintf(number, "%0d", i);
+		//itoa(i, number, 10);
+		s = StringDup(number);
+	}
+	~SString() {
+		delete []s;
+		s = 0;
+	}
+	SString &operator=(const SString &source) {
+		if (this != &source) {
+			delete []s;
+			s = StringDup(source.s);
+		}
+		return *this;
+	}
+	bool operator==(const SString &other) const {
+		if ((s == 0) && (other.s == 0))
+			return true;
+		if ((s == 0) || (other.s == 0))
+			return false;
+		return strcmp(s, other.s) == 0;
+	}
+	bool operator==(const char *sother) const {
+		if ((s == 0) && (sother == 0))
+			return true;
+		if ((s == 0) || (sother == 0))
+			return false;
+		return strcmp(s, sother) == 0;
+	}
+	const char *c_str() const {
+		if (s)
+			return s;
+		else
+			return "";
+	}
+	int length() const {
+		if (s)
+			return strlen(s);
+		else
+			return 0;
+	}
+	char operator[](int i) {
+		if (s)
+			return s[i];
+		else
+			return '\0';
+	}
+	SString &operator +=(const char *sother) {
+		int len = length();
+		int lenOther = strlen(sother);
+		char *sNew = new char[len + lenOther + 1];
+		if (sNew) {
+			if (s)
+				memcpy(sNew, s, len);
+			memcpy(sNew + len, sother, lenOther);
+			sNew[len + lenOther] = '\0';
+			delete []s;
+			s = sNew;
+		}
+		return *this;
+	}
+	int value() {
+		if (s)
+			return atoi(s);
+		else 
+			return 0;
+	}
+};
+
+class PropSet {
+private:
+	char **vals;
+	int size;
+	int used;
+public:
+	PropSet *superPS;
+	PropSet();
+	~PropSet();
+	void EnsureCanAddEntry();
+	void Set(const char *key, const char *val);
+	void Set(char *keyval);
+	SString Get(const char *key);
+	int GetInt(const char *key, int defaultValue=0);
+	SString GetWild(const char *keybase, const char *filename);
+	SString GetNewExpand(const char *keybase, const char *filename);
+	void Clear();
+	void ReadFromMemory(const char *data, int len);
+	void Read(const char *filename);
+};
+
+// This is a fixed length list of strings suitable for display  in combo boxes
+// as a memory of user entries
+template<int sz>
+class EntryMemory {
+	SString entries[sz];
+public:
+	void Insert(SString s) {
+		for (int i=0;i<sz;i++) {
+			if (entries[i] == s) {
+				for (int j=i;j>0;j--) {
+					entries[j] = entries[j-1];
+				}
+				entries[0] = s;
+				return;
+			}
+		}
+		for (int k=sz-1;k>0;k--) {
+			entries[k] = entries[k-1];
+		}
+		entries[0] = s;
+	}
+	int Length() const {
+		int len = 0;
+		for (int i=0;i<sz;i++)
+			if (entries[i].length())
+				len++;
+		return len;
+	}
+	SString At(int n) const {
+		return entries[n];
+	}
+};
+
+class WordList {
+public:
+	// Each word contains at least one character - a empty word acts as sentinal at the end.
+	char **words;
+	char *list;
+	int len;
+	bool onlyLineEnds;	// Delimited by any white space or only line ends
+	int starts[256];
+	WordList(bool onlyLineEnds_ = false) : 
+		words(0), list(0), len(0), onlyLineEnds(onlyLineEnds_) {}
+	~WordList() { Clear(); }
+	operator bool() { return list; }
+	const char *operator[](int ind) { return words[ind]; }
+	void Clear();
+	void Set(const char *s);
+	char *Allocate(int size);
+	void SetFromAllocated();
+	bool InList(const char *s);
+};
+
+#endif

contrib/src/stc/scintilla/include/SciLexer.h

@@ -0,0 +1,172 @@
+// Scintilla source code edit control
+// SciLexer - interface to the added lexer functions in the SciLexer version of the edit control
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SCILEXER_H
+#define SCILEXER_H
+
+// SciLexer features - not in standard Scintilla
+
+#define SCLEX_CONTAINER 0
+#define SCLEX_NULL 1
+#define SCLEX_PYTHON 2
+#define SCLEX_CPP 3
+#define SCLEX_HTML 4
+#define SCLEX_XML 5
+#define SCLEX_PERL 6
+#define SCLEX_SQL 7
+#define SCLEX_VB 8
+#define SCLEX_PROPERTIES 9
+#define SCLEX_ERRORLIST 10
+#define SCLEX_MAKEFILE 11
+#define SCLEX_BATCH 12
+
+// Lexical states for SCLEX_PYTHON
+#define SCE_P_DEFAULT 0
+#define SCE_P_COMMENTLINE 1
+#define SCE_P_NUMBER 2
+#define SCE_P_STRING 3
+#define SCE_P_CHARACTER 4
+#define SCE_P_WORD 5
+#define SCE_P_TRIPLE 6
+#define SCE_P_TRIPLEDOUBLE 7
+#define SCE_P_CLASSNAME 8
+#define SCE_P_DEFNAME 9
+#define SCE_P_OPERATOR 10
+#define SCE_P_IDENTIFIER 11
+#define SCE_P_COMMENTBLOCK 12
+#define SCE_P_STRINGEOL 13
+
+// Lexical states for SCLEX_CPP, SCLEX_VB
+#define SCE_C_DEFAULT 0
+#define SCE_C_COMMENT 1
+#define SCE_C_COMMENTLINE 2
+#define SCE_C_COMMENTDOC 3
+#define SCE_C_NUMBER 4
+#define SCE_C_WORD 5
+#define SCE_C_STRING 6
+#define SCE_C_CHARACTER 7
+#define SCE_C_UUID 8
+#define SCE_C_PREPROCESSOR 9
+#define SCE_C_OPERATOR 10
+#define SCE_C_IDENTIFIER 11
+#define SCE_C_STRINGEOL 12
+
+// Lexical states for SCLEX_HTML, SCLEX_xML
+#define SCE_H_DEFAULT 0
+#define SCE_H_TAG 1
+#define SCE_H_TAGUNKNOWN 2
+#define SCE_H_ATTRIBUTE 3
+#define SCE_H_ATTRIBUTEUNKNOWN 4
+#define SCE_H_NUMBER 5
+#define SCE_H_DOUBLESTRING 6
+#define SCE_H_SINGLESTRING 7
+#define SCE_H_OTHER 8
+#define SCE_H_COMMENT 9
+#define SCE_H_ENTITY 10
+// XML and ASP
+#define SCE_H_TAGEND 11
+#define SCE_H_XMLSTART 12
+#define SCE_H_XMLEND 13
+#define SCE_H_SCRIPT 14
+#define SCE_H_ASP 15
+#define SCE_H_ASPAT 16
+// Embedded Javascript
+#define SCE_HJ_START 40
+#define SCE_HJ_DEFAULT 41
+#define SCE_HJ_COMMENT 42
+#define SCE_HJ_COMMENTLINE 43
+#define SCE_HJ_COMMENTDOC 44
+#define SCE_HJ_NUMBER 45
+#define SCE_HJ_WORD 46
+#define SCE_HJ_KEYWORD 47
+#define SCE_HJ_DOUBLESTRING 48
+#define SCE_HJ_SINGLESTRING 49
+#define SCE_HJ_SYMBOLS 50
+#define SCE_HJ_STRINGEOL 51
+// ASP Javascript
+#define SCE_HJA_START 55
+#define SCE_HJA_DEFAULT 56
+#define SCE_HJA_COMMENT 57
+#define SCE_HJA_COMMENTLINE 58
+#define SCE_HJA_COMMENTDOC 59
+#define SCE_HJA_NUMBER 60
+#define SCE_HJA_WORD 61
+#define SCE_HJA_KEYWORD 62
+#define SCE_HJA_DOUBLESTRING 63
+#define SCE_HJA_SINGLESTRING 64
+#define SCE_HJA_SYMBOLS 65
+#define SCE_HJA_STRINGEOL 66
+// Embedded VBScript
+#define SCE_HB_START 70
+#define SCE_HB_DEFAULT 71
+#define SCE_HB_COMMENTLINE 72
+#define SCE_HB_NUMBER 73
+#define SCE_HB_WORD 74
+#define SCE_HB_STRING 75
+#define SCE_HB_IDENTIFIER 76
+#define SCE_HB_STRINGEOL 77
+// ASP VBScript
+#define SCE_HBA_START 80
+#define SCE_HBA_DEFAULT 81
+#define SCE_HBA_COMMENTLINE 82
+#define SCE_HBA_NUMBER 83
+#define SCE_HBA_WORD 84
+#define SCE_HBA_STRING 85
+#define SCE_HBA_IDENTIFIER 86
+#define SCE_HBA_STRINGEOL 87
+// Embedded Python
+#define SCE_HP_START 90
+#define SCE_HP_DEFAULT 91
+#define SCE_HP_COMMENTLINE 92
+#define SCE_HP_NUMBER 93
+#define SCE_HP_STRING 94
+#define SCE_HP_CHARACTER 95
+#define SCE_HP_WORD 96
+#define SCE_HP_TRIPLE 97
+#define SCE_HP_TRIPLEDOUBLE 98
+#define SCE_HP_CLASSNAME 99
+#define SCE_HP_DEFNAME 100
+#define SCE_HP_OPERATOR 101
+#define SCE_HP_IDENTIFIER 102
+// ASP Python
+#define SCE_HPA_START 105
+#define SCE_HPA_DEFAULT 106
+#define SCE_HPA_COMMENTLINE 107
+#define SCE_HPA_NUMBER 108
+#define SCE_HPA_STRING 109
+#define SCE_HPA_CHARACTER 110
+#define SCE_HPA_WORD 111
+#define SCE_HPA_TRIPLE 112
+#define SCE_HPA_TRIPLEDOUBLE 113
+#define SCE_HPA_CLASSNAME 114
+#define SCE_HPA_DEFNAME 115
+#define SCE_HPA_OPERATOR 116
+#define SCE_HPA_IDENTIFIER 117
+
+// Lexical states for SCLEX_PERL
+#define SCE_PL_DEFAULT 0
+#define SCE_PL_HERE 1
+#define SCE_PL_COMMENTLINE 2
+#define SCE_PL_POD 3
+#define SCE_PL_NUMBER 4
+#define SCE_PL_WORD 5
+#define SCE_PL_STRING 6
+#define SCE_PL_CHARACTER 7
+#define SCE_PL_PUNCTUATION 8
+#define SCE_PL_PREPROCESSOR 9
+#define SCE_PL_OPERATOR 10
+#define SCE_PL_IDENTIFIER 11
+#define SCE_PL_SCALAR 12
+#define SCE_PL_ARRAY 13
+#define SCE_PL_HASH 14
+#define SCE_PL_SYMBOLTABLE 15
+#define SCE_PL_REF 16
+#define SCE_PL_REGEX 17
+#define SCE_PL_REGSUBST 18
+#define SCE_PL_LONGQUOTE 19
+#define SCE_PL_BACKTICKS 20
+#define SCE_PL_DATASECTION 21
+    
+#endif

contrib/src/stc/scintilla/include/Scintilla.h

@@ -0,0 +1,423 @@
+// Scintilla source code edit control
+// Scintilla.h - interface to the edit control
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SCINTILLA_H
+#define SCINTILLA_H
+
+// Compile-time configuration options
+#define MACRO_SUPPORT 1  // Comment out to remove macro hooks
+
+#if PLAT_GTK
+#include <gdk/gdk.h>
+#include <gtk/gtkvbox.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SCINTILLA(obj)          GTK_CHECK_CAST (obj, scintilla_get_type (), ScintillaObject)
+#define SCINTILLA_CLASS(klass)  GTK_CHECK_CLASS_CAS	T (klass, scintilla_get_type (), ScintillaClass)
+#define IS_SCINTILLA(obj)       GTK_CHECK_TYPE (obj, scintilla_get_type ())
+
+	typedef struct _ScintillaObject ScintillaObject;
+	typedef struct _ScintillaClass  ScintillaClass;
+
+	struct _ScintillaObject
+	{
+		GtkFixed vbox;
+		void *pscin;
+	};
+
+	struct _ScintillaClass
+	{
+		GtkFixedClass parent_class;
+
+		void (* command) (ScintillaObject *ttt);
+		void (* notify) (ScintillaObject *ttt);
+	};
+
+	guint		scintilla_get_type	(void);
+	GtkWidget*	scintilla_new		(void);
+	void		scintilla_set_id	(ScintillaObject *sci,int id);
+	long 		scintilla_send_message	(ScintillaObject *sci,int iMessage,int wParam,int lParam);
+
+#include "WinDefs.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#if PLAT_WX
+#include "WinDefs.h"
+#endif
+
+// Both GTK and Windows
+
+#define INVALID_POSITION -1 
+
+// Define start of Scintilla messages to be greater than all edit (EM_*) messages
+// as many EM_ messages can be used.
+#define SCI_START 2000
+#define SCI_OPTIONAL_START 3000
+#define SCI_LEXER_START 4000
+
+#define SCI_ADDTEXT SCI_START + 1
+#define SCI_ADDSTYLEDTEXT SCI_START + 2
+#define SCI_INSERTTEXT SCI_START + 3
+#define SCI_CLEARALL SCI_START + 4
+#define SCI_GETLENGTH SCI_START + 6
+#define SCI_GETCHARAT SCI_START + 7
+#define SCI_GETCURRENTPOS SCI_START + 8
+#define SCI_GETANCHOR SCI_START + 9
+#define SCI_GETSTYLEAT SCI_START + 10
+
+#define SCI_REDO SCI_START + 11
+#define SCI_SETUNDOCOLLECTION SCI_START + 12
+#define SCI_SELECTALL SCI_START + 13
+#define SCI_SETSAVEPOINT SCI_START + 14
+#define SCI_GETSTYLEDTEXT SCI_START + 15
+#define SCI_CANREDO SCI_START + 16
+#define SCI_MARKERLINEFROMHANDLE SCI_START + 17
+#define SCI_MARKERDELETEHANDLE SCI_START + 18
+
+#define SC_UNDOCOLLECT_NONE 0
+#define SC_UNDOCOLLECT_AUTOSTART 1
+
+#define SCI_GETVIEWWS SCI_START + 20
+#define SCI_SETVIEWWS SCI_START + 21
+#define SCI_CHANGEPOSITION SCI_START + 22
+#define SCI_GOTOLINE SCI_START + 24
+#define SCI_GOTOPOS SCI_START + 25
+#define SCI_SETANCHOR SCI_START + 26
+#define SCI_GETCURLINE SCI_START + 27
+#define SCI_GETENDSTYLED SCI_START + 28
+#define SCI_CONVERTEOLS SCI_START + 29
+
+#define SCI_GETEOLMODE SCI_START + 30
+#define SCI_SETEOLMODE SCI_START + 31
+
+#define SC_EOL_CRLF 0
+#define SC_EOL_CR 1
+#define SC_EOL_LF 2
+
+#define SCI_STARTSTYLING SCI_START + 32
+#define SCI_SETSTYLING SCI_START + 33
+
+#define SCI_SETBUFFEREDDRAW SCI_START + 35
+#define SCI_SETTABWIDTH SCI_START + 36
+#define SCI_SETCODEPAGE SCI_START + 37
+#define SCI_SETUSEPALETTE SCI_START + 39
+
+#define MARKER_MAX 31
+
+#define SC_MARK_CIRCLE 0
+#define SC_MARK_ROUNDRECT 1
+#define SC_MARK_ARROW 2
+#define SC_MARK_SMALLRECT 3
+#define SC_MARK_SHORTARROW 4
+#define SC_MARK_EMPTY 5
+#define SC_MARK_ARROWDOWN 6
+#define SC_MARK_MINUS 7
+#define SC_MARK_PLUS 8
+
+#define SCI_MARKERDEFINE SCI_START + 40
+#define SCI_MARKERSETFORE SCI_START + 41
+#define SCI_MARKERSETBACK SCI_START + 42
+#define SCI_MARKERADD SCI_START + 43
+#define SCI_MARKERDELETE SCI_START + 44
+#define SCI_MARKERDELETEALL SCI_START + 45
+#define SCI_MARKERGET SCI_START + 46
+#define SCI_MARKERNEXT SCI_START + 47
+#define SCI_MARKERPREVIOUS SCI_START + 48
+
+#define SC_MARKNUM_FOLDER 30
+#define SC_MARKNUM_FOLDEROPEN 31
+
+#define SC_MASK_FOLDERS ((1<<SC_MARKNUM_FOLDER) | (1<<SC_MARKNUM_FOLDEROPEN))
+
+#define SC_MARGIN_SYMBOL 0
+#define SC_MARGIN_NUMBER 1
+
+#define SCI_SETMARGINTYPEN SCI_START + 240
+#define SCI_GETMARGINTYPEN SCI_START + 241
+#define SCI_SETMARGINWIDTHN SCI_START + 242
+#define SCI_GETMARGINWIDTHN SCI_START + 243
+#define SCI_SETMARGINMASKN SCI_START + 244
+#define SCI_GETMARGINMASKN SCI_START + 245
+#define SCI_SETMARGINSENSITIVEN SCI_START + 246
+#define SCI_GETMARGINSENSITIVEN SCI_START + 247
+
+#define STYLE_DEFAULT 32
+#define STYLE_LINENUMBER 33
+#define STYLE_BRACELIGHT 34
+#define STYLE_BRACEBAD 35
+#define STYLE_CONTROLCHAR 36
+#define STYLE_MAX 127
+
+#define SCI_STYLECLEARALL SCI_START + 50
+#define SCI_STYLESETFORE SCI_START + 51
+#define SCI_STYLESETBACK SCI_START + 52
+#define SCI_STYLESETBOLD SCI_START + 53
+#define SCI_STYLESETITALIC SCI_START + 54
+#define SCI_STYLESETSIZE SCI_START + 55
+#define SCI_STYLESETFONT SCI_START + 56
+#define SCI_STYLESETEOLFILLED SCI_START + 57
+#define SCI_STYLERESETDEFAULT SCI_START + 58
+
+#define SCI_SETSELFORE SCI_START + 67
+#define SCI_SETSELBACK SCI_START + 68
+#define SCI_SETCARETFORE SCI_START + 69
+
+#define SCI_ASSIGNCMDKEY SCI_START + 70
+#define SCI_CLEARCMDKEY SCI_START + 71
+#define SCI_CLEARALLCMDKEYS SCI_START + 72
+
+#define SCI_SETSTYLINGEX SCI_START + 73
+
+#define SCI_GETCARETPERIOD SCI_START + 75
+#define SCI_SETCARETPERIOD SCI_START + 76
+#define SCI_SETWORDCHARS SCI_START + 77
+
+#define SCI_BEGINUNDOACTION SCI_START + 78
+#define SCI_ENDUNDOACTION SCI_START + 79
+
+#define INDIC_MAX 7
+
+#define INDIC_PLAIN 0
+#define INDIC_SQUIGGLE 1
+#define INDIC_TT 2
+
+#define INDIC0_MASK 32
+#define INDIC1_MASK 64
+#define INDIC2_MASK 128
+#define INDICS_MASK (INDIC0_MASK | INDIC1_MASK | INDIC2_MASK)
+
+#define SCI_INDICSETSTYLE SCI_START + 80
+#define SCI_INDICGETSTYLE SCI_START + 81
+#define SCI_INDICSETFORE SCI_START + 82
+#define SCI_INDICGETFORE SCI_START + 83
+
+#define SCI_SETSTYLEBITS SCI_START + 90
+#define SCI_GETSTYLEBITS SCI_START + 91
+#define SCI_SETLINESTATE SCI_START + 92
+#define SCI_GETLINESTATE SCI_START + 93
+#define SCI_GETMAXLINESTATE SCI_START + 94
+
+#define SCI_AUTOCSHOW SCI_START + 100
+#define SCI_AUTOCCANCEL SCI_START + 101
+#define SCI_AUTOCACTIVE SCI_START + 102
+#define SCI_AUTOCPOSSTART SCI_START + 103
+#define SCI_AUTOCCOMPLETE SCI_START + 104
+#define SCI_AUTOCSTOPS SCI_START + 105
+
+#define SCI_CALLTIPSHOW SCI_START + 200
+#define SCI_CALLTIPCANCEL SCI_START + 201
+#define SCI_CALLTIPACTIVE SCI_START + 202
+#define SCI_CALLTIPPOSSTART SCI_START + 203
+#define SCI_CALLTIPSETHLT SCI_START + 204
+#define SCI_CALLTIPSETBACK SCI_START + 205
+
+#define SC_FOLDLEVELBASE 0x400
+#define SC_FOLDLEVELWHITEFLAG 0x1000
+#define SC_FOLDLEVELHEADERFLAG 0x2000
+#define SC_FOLDLEVELNUMBERMASK 0x0FFF
+
+#define SCI_VISIBLEFROMDOCLINE SCI_START + 220
+#define SCI_DOCLINEFROMVISIBLE SCI_START + 221
+#define SCI_SETFOLDLEVEL SCI_START + 222
+#define SCI_GETFOLDLEVEL SCI_START + 223
+#define SCI_GETLASTCHILD SCI_START + 224
+#define SCI_GETFOLDPARENT SCI_START + 225
+#define SCI_SHOWLINES SCI_START + 226
+#define SCI_HIDELINES SCI_START + 227
+#define SCI_GETLINEVISIBLE SCI_START + 228
+#define SCI_SETFOLDEXPANDED SCI_START + 229
+#define SCI_GETFOLDEXPANDED SCI_START + 230
+#define SCI_TOGGLEFOLD SCI_START + 231
+#define SCI_ENSUREVISIBLE SCI_START + 232
+#define SCI_SETFOLDFLAGS SCI_START + 233
+
+// Key messages
+#define SCI_LINEDOWN SCI_START + 300
+#define SCI_LINEDOWNEXTEND SCI_START + 301
+#define SCI_LINEUP SCI_START + 302
+#define SCI_LINEUPEXTEND SCI_START + 303
+#define SCI_CHARLEFT SCI_START + 304
+#define SCI_CHARLEFTEXTEND SCI_START + 305
+#define SCI_CHARRIGHT SCI_START + 306
+#define SCI_CHARRIGHTEXTEND SCI_START + 307
+#define SCI_WORDLEFT SCI_START + 308
+#define SCI_WORDLEFTEXTEND SCI_START + 309
+#define SCI_WORDRIGHT SCI_START + 310
+#define SCI_WORDRIGHTEXTEND SCI_START + 311
+#define SCI_HOME SCI_START + 312
+#define SCI_HOMEEXTEND SCI_START + 313
+#define SCI_LINEEND SCI_START + 314
+#define SCI_LINEENDEXTEND SCI_START + 315
+#define SCI_DOCUMENTSTART SCI_START + 316
+#define SCI_DOCUMENTSTARTEXTEND SCI_START + 317
+#define SCI_DOCUMENTEND SCI_START + 318
+#define SCI_DOCUMENTENDEXTEND SCI_START + 319
+#define SCI_PAGEUP SCI_START + 320
+#define SCI_PAGEUPEXTEND SCI_START + 321
+#define SCI_PAGEDOWN SCI_START + 322
+#define SCI_PAGEDOWNEXTEND SCI_START + 323
+#define SCI_EDITTOGGLEOVERTYPE SCI_START + 324
+#define SCI_CANCEL SCI_START + 325
+#define SCI_DELETEBACK SCI_START + 326
+#define SCI_TAB SCI_START + 327
+#define SCI_BACKTAB SCI_START + 328
+#define SCI_NEWLINE SCI_START + 329
+#define SCI_FORMFEED SCI_START + 330
+#define SCI_VCHOME SCI_START + 331
+#define SCI_VCHOMEEXTEND SCI_START + 332
+#define SCI_ZOOMIN SCI_START + 333
+#define SCI_ZOOMOUT SCI_START + 334
+#define SCI_DELWORDLEFT SCI_START + 335
+#define SCI_DELWORDRIGHT SCI_START + 336
+#define SCI_LINECUT SCI_START + 337
+#define SCI_LINEDELETE SCI_START + 338
+#define SCI_LINETRANSPOSE SCI_START + 339
+#define SCI_LOWERCASE SCI_START + 340
+#define SCI_UPPERCASE SCI_START + 341
+
+#define SCI_LINELENGTH SCI_START + 350
+#define SCI_BRACEHIGHLIGHT SCI_START + 351
+#define SCI_BRACEBADLIGHT SCI_START + 352
+#define SCI_BRACEMATCH SCI_START + 353
+#define SCI_GETVIEWEOL SCI_START + 355
+#define SCI_SETVIEWEOL SCI_START + 356
+#define SCI_GETDOCPOINTER SCI_START + 357
+#define SCI_SETDOCPOINTER SCI_START + 358
+#define SCI_SETMODEVENTMASK SCI_START + 359
+
+#define EDGE_NONE 0
+#define EDGE_LINE 1
+#define EDGE_BACKGROUND 2
+
+#define SCI_GETEDGECOLUMN SCI_START + 360
+#define SCI_SETEDGECOLUMN SCI_START + 361
+#define SCI_GETEDGEMODE SCI_START + 362
+#define SCI_SETEDGEMODE SCI_START + 363
+#define SCI_GETEDGECOLOUR SCI_START + 364
+#define SCI_SETEDGECOLOUR SCI_START + 365
+
+#define SCI_SEARCHANCHOR SCI_START + 366
+#define SCI_SEARCHNEXT SCI_START + 367
+#define SCI_SEARCHPREV SCI_START + 368
+
+#define CARET_SLOP 0x01    // Show caret within N lines of edge when it's scrolled to view
+#define CARET_CENTER 0x02  // Center caret on screen when it's scrolled to view
+#define CARET_STRICT 0x04  // OR this with CARET_CENTER to reposition even when visible, or
+                           // OR this with CARET_SLOP to reposition whenever outside slop border
+
+#define SCI_SETCARETPOLICY SCI_START + 369
+#define SCI_LINESONSCREEN SCI_START + 370
+#define SCI_USEPOPUP SCI_START + 371
+
+// GTK+ Specific
+#define SCI_GRABFOCUS SCI_START + 400
+
+// Optional module for macro recording
+#ifdef MACRO_SUPPORT
+typedef void (tMacroRecorder)(UINT iMessage, WPARAM wParam, LPARAM lParam, 
+                              void *userData);
+#define SCI_STARTRECORD SCI_OPTIONAL_START + 1
+#define SCI_STOPRECORD SCI_OPTIONAL_START + 2
+#endif
+
+#define SCI_SETLEXER SCI_LEXER_START + 1
+#define SCI_GETLEXER SCI_LEXER_START + 2
+#define SCI_COLOURISE SCI_LEXER_START + 3
+#define SCI_SETPROPERTY SCI_LEXER_START + 4
+#define SCI_SETKEYWORDS SCI_LEXER_START + 5
+
+// Notifications
+
+// Type of modification and the action which caused the modification
+// These are defined as a bit mask to make it easy to specify which notifications are wanted.
+// One bit is set from each of SC_MOD_* and SC_PERFORMED_*.
+#define SC_MOD_INSERTTEXT 0x1
+#define SC_MOD_DELETETEXT 0x2
+#define SC_MOD_CHANGESTYLE 0x4
+#define SC_MOD_CHANGEFOLD 0x8
+#define SC_PERFORMED_USER 0x10
+#define SC_PERFORMED_UNDO 0x20
+#define SC_PERFORMED_REDO 0x40
+#define SC_LASTSTEPINUNDOREDO 0x100
+#define SC_MOD_CHANGEMARKER 0x200
+
+#define SC_MODEVENTMASKALL 0x377
+
+struct SCNotification {
+	NMHDR nmhdr;
+	int position;			// SCN_STYLENEEDED, SCN_MODIFIED
+	int ch;					// SCN_CHARADDED, SCN_KEY
+	int modifiers;			// SCN_KEY
+  	int modificationType;	// SCN_MODIFIED
+ 	const char *text;		// SCN_MODIFIED
+ 	int length;				// SCN_MODIFIED
+ 	int linesAdded;	// SCN_MODIFIED
+#ifdef MACRO_SUPPORT
+	int message;	// SCN_MACRORECORD
+	int wParam;	// SCN_MACRORECORD
+	int lParam;	// SCN_MACRORECORD
+#endif
+	int line;			// SCN_MODIFIED
+	int foldLevelNow;	// SCN_MODIFIED
+	int foldLevelPrev;	// SCN_MODIFIED
+	int margin;	// SCN_MARGINCLICK
+};
+
+#define SCN_STYLENEEDED 2000
+#define SCN_CHARADDED 2001
+#define SCN_SAVEPOINTREACHED 2002
+#define SCN_SAVEPOINTLEFT 2003
+#define SCN_MODIFYATTEMPTRO 2004
+// GTK+ Specific to work around focus and accelerator problems:
+#define SCN_KEY 2005
+#define SCN_DOUBLECLICK 2006
+#define SCN_UPDATEUI 2007
+// The old name for SCN_UPDATEUI:
+#define SCN_CHECKBRACE 2007
+#define SCN_MODIFIED 2008
+// Optional module for macro recording
+#ifdef MACRO_SUPPORT
+#define SCN_MACRORECORD 2009
+#endif
+#define SCN_MARGINCLICK 2010
+#define SCN_NEEDSHOWN 2011
+
+#ifdef STATIC_BUILD
+void Scintilla_RegisterClasses(HINSTANCE hInstance);
+#endif
+
+// Deprecation section listing all API features that are deprecated and will
+// will be removed completely in a future version.
+// To enable these features define INCLUDE_DEPRECATED_FEATURES
+
+#ifdef INCLUDE_DEPRECATED_FEATURES
+
+// Default style settings. These are deprecated and will be removed in a future version.
+#define SCI_SETFORE SCI_START + 60
+#define SCI_SETBACK SCI_START + 61
+#define SCI_SETBOLD SCI_START + 62
+#define SCI_SETITALIC SCI_START + 63
+#define SCI_SETSIZE SCI_START + 64
+#define SCI_SETFONT SCI_START + 65
+
+#define SCI_APPENDUNDOSTARTACTION SCI_START + 74
+
+#define SC_UNDOCOLLECT_MANUALSTART 2
+
+// Deprecated in release 1.22
+#define SCI_SETMARGINWIDTH SCI_START + 34
+#define SCI_SETLINENUMBERWIDTH SCI_START + 38
+
+#endif
+
+#endif

contrib/src/stc/scintilla/include/WinDefs.h

@@ -0,0 +1,218 @@
+// Scintilla source code edit control
+// WinDefs.h - the subset of definitions from Windows needed by Scintilla for GTK+
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// 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
+
+/* RTF control */
+#define EM_CANPASTE	(1074)
+#define EM_CANUNDO	(198)
+#define EM_CHARFROMPOS	(215)
+#define EM_DISPLAYBAND	(1075)
+#define EM_EMPTYUNDOBUFFER	(205)
+#define EM_EXGETSEL	(1076)
+#define EM_EXLIMITTEXT	(1077)
+#define EM_EXLINEFROMCHAR	(1078)
+#define EM_EXSETSEL	(1079)
+#define EM_FINDTEXT	(1080)
+#define EM_FINDTEXTEX	(1103)
+#define EM_FINDWORDBREAK	(1100)
+#define EM_FMTLINES	(200)
+#define EM_FORMATRANGE	(1081)
+#define EM_GETCHARFORMAT	(1082)
+#define EM_GETEVENTMASK	(1083)
+#define EM_GETFIRSTVISIBLELINE	(206)
+#define EM_GETHANDLE	(189)
+#define EM_GETLIMITTEXT	(213)
+#define EM_GETLINE	(196)
+#define EM_GETLINECOUNT	(186)
+#define EM_GETMARGINS	(212)
+#define EM_GETMODIFY	(184)
+#define EM_GETIMECOLOR	(1129)
+#define EM_GETIMEOPTIONS	(1131)
+#define EM_GETOPTIONS	(1102)
+#define EM_GETOLEINTERFACE	(1084)
+#define EM_GETPARAFORMAT	(1085)
+#define EM_GETPASSWORDCHAR	(210)
+#define EM_GETPUNCTUATION	(1125)
+#define EM_GETRECT	(178)
+#define EM_GETSEL	(176)
+#define EM_GETSELTEXT	(1086)
+#define EM_GETTEXTRANGE	(1099)
+#define EM_GETTHUMB	(190)
+#define EM_GETWORDBREAKPROC	(209)
+#define EM_GETWORDBREAKPROCEX	(1104)
+#define EM_GETWORDWRAPMODE	(1127)
+#define EM_HIDESELECTION	(1087)
+#define EM_LIMITTEXT	(197)
+#define EM_LINEFROMCHAR	(201)
+#define EM_LINEINDEX	(187)
+#define EM_LINELENGTH	(193)
+#define EM_LINESCROLL	(182)
+#define EM_PASTESPECIAL	(1088)
+#define EM_POSFROMCHAR	(214)
+#define EM_REPLACESEL	(194)
+#define EM_REQUESTRESIZE	(1089)
+#define EM_SCROLL	(181)
+#define EM_SCROLLCARET	(183)
+#define EM_SELECTIONTYPE	(1090)
+#define EM_SETBKGNDCOLOR	(1091)
+#define EM_SETCHARFORMAT	(1092)
+#define EM_SETEVENTMASK	(1093)
+#define EM_SETHANDLE	(188)
+#define EM_SETIMECOLOR	(1128)
+#define EM_SETIMEOPTIONS	(1130)
+#define EM_SETLIMITTEXT	(197)
+#define EM_SETMARGINS	(211)
+#define EM_SETMODIFY	(185)
+#define EM_SETOLECALLBACK	(1094)
+#define EM_SETOPTIONS	(1101)
+#define EM_SETPARAFORMAT	(1095)
+#define EM_SETPASSWORDCHAR	(204)
+#define EM_SETPUNCTUATION	(1124)
+#define EM_SETREADONLY	(207)
+#define EM_SETRECT	(179)
+#define EM_SETRECTNP	(180)
+#define EM_SETSEL	(177)
+#define EM_SETTABSTOPS	(203)
+#define EM_SETTARGETDEVICE	(1096)
+#define EM_SETWORDBREAKPROC	(208)
+#define EM_SETWORDBREAKPROCEX	(1105)
+#define EM_SETWORDWRAPMODE	(1126)
+#define EM_STREAMIN	(1097)
+#define EM_STREAMOUT	(1098)
+#define EM_UNDO	(199)
+
+#define WM_NULL		(0)
+#define WM_CLEAR	(771)
+#define WM_COMMAND	(273)
+#define WM_COPY	(769)
+#define WM_CUT	(768)
+#define WM_GETTEXT	(13)
+#define WM_GETTEXTLENGTH	(14)
+#define WM_NOTIFY	(78)
+#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
+
+#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
+#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
+
+// Are these needed any more
+#define LPSTR char *
+#define LONG long
+#define LPDWORD (long *)
+#endif
+
+/* SELCHANGE structure */
+#define SEL_EMPTY	(0)
+#define SEL_TEXT	(1)
+#define SEL_OBJECT	(2)
+#define SEL_MULTICHAR	(4)
+#define SEL_MULTIOBJECT	(8)
+
+/* FINDREPLACE structure */
+#define FR_MATCHCASE	(0x4)
+#define FR_WHOLEWORD	(0x2)
+#define FR_DOWN		(0x1)
+
+#define SHIFT_PRESSED 1
+#define LEFT_CTRL_PRESSED 2
+#define LEFT_ALT_PRESSED 4
+
+struct RECT {
+	LONG left;
+	LONG top;
+	LONG right;
+	LONG bottom;
+};
+
+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;
+};
+
+#define MAKELONG(a, b) ((a) | ((b) << 16))
+#define LOWORD(x) (x & 0xffff)
+#define HIWORD(x) (x >> 16)
+
+#endif

contrib/src/stc/scintilla/src/Accessor.cxx

@@ -0,0 +1,166 @@
+// SciTE - Scintilla based Text Editor
+// Accessor.cxx - rapid easy access to contents of a Scintilla
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <ctype.h> 
+#include <stdio.h>
+
+#include "Platform.h"
+
+#include "PropSet.h"
+#include "Accessor.h"
+#include "Scintilla.h"
+
+bool Accessor::InternalIsLeadByte(char ch) {
+#if PLAT_GTK
+	// TODO: support DBCS under GTK+
+	return false;
+#elif PLAT_WIN 
+	return IsDBCSLeadByteEx(codePage, ch);
+#elif PLAT_WX 
+	return false;
+#endif 
+}
+
+void Accessor::Fill(int position) {
+	if (lenDoc == -1)
+		lenDoc = Platform::SendScintilla(id, WM_GETTEXTLENGTH, 0, 0);
+	startPos = position - slopSize;
+	if (startPos + bufferSize > lenDoc)
+		startPos = lenDoc - bufferSize;
+	if (startPos < 0)
+		startPos = 0;
+	endPos = startPos + bufferSize;
+	if (endPos > lenDoc)
+		endPos = lenDoc;
+
+	TEXTRANGE tr = {{startPos, endPos}, buf};
+	Platform::SendScintilla(id, EM_GETTEXTRANGE, 0, reinterpret_cast<LPARAM>(&tr));
+}
+
+char Accessor::StyleAt(int position) {
+	return static_cast<char>(Platform::SendScintilla(
+		id, SCI_GETSTYLEAT, position, 0));
+}
+
+int Accessor::GetLine(int position) {
+	return Platform::SendScintilla(id, EM_LINEFROMCHAR, position, 0);
+}
+
+int Accessor::LineStart(int line) {
+	return Platform::SendScintilla(id, EM_LINEINDEX, line, 0);
+}
+
+int Accessor::LevelAt(int line) {
+	return Platform::SendScintilla(id, SCI_GETFOLDLEVEL, line, 0);
+}
+
+int Accessor::Length() { 
+	if (lenDoc == -1) 
+		lenDoc = Platform::SendScintilla(id, WM_GETTEXTLENGTH, 0, 0);
+	return lenDoc; 
+}
+
+int Accessor::GetLineState(int line) {
+	return Platform::SendScintilla(id, SCI_GETLINESTATE, line);
+}
+
+int Accessor::SetLineState(int line, int state) {
+	return Platform::SendScintilla(id, SCI_SETLINESTATE, line, state);
+}
+
+void StylingContext::StartAt(unsigned int start, char chMask) {
+	Platform::SendScintilla(id, SCI_STARTSTYLING, start, chMask);
+}
+
+void StylingContext::StartSegment(unsigned int pos) {
+	startSeg = pos;
+}
+
+void StylingContext::ColourTo(unsigned int pos, int chAttr) {
+	// Only perform styling if non empty range
+	if (pos != startSeg - 1) {
+		if (pos < startSeg) {
+			Platform::DebugPrintf("Bad colour positions %d - %d\n", startSeg, pos);
+		}
+
+		if (validLen + (pos - startSeg + 1) >= bufferSize)
+			Flush();
+		if (validLen + (pos - startSeg + 1) >= bufferSize) {
+			// Too big for buffer so send directly
+			Platform::SendScintilla(id, SCI_SETSTYLING, pos - startSeg + 1, chAttr);
+		} else {
+			if (chAttr != chWhile)
+				chFlags = 0;
+			chAttr |= chFlags;
+			for (unsigned int i = startSeg; i <= pos; i++) {
+				styleBuf[validLen++] = chAttr;
+			}
+		}
+	}
+	startSeg = pos+1;
+}
+
+int StylingContext::GetLine(int position) {
+	return Platform::SendScintilla(id, EM_LINEFROMCHAR, position, 0);
+}
+
+void StylingContext::SetLevel(int line, int level) {
+	Platform::SendScintilla(id, SCI_SETFOLDLEVEL, line, level);
+}
+
+void StylingContext::Flush() {
+	if (validLen > 0) {
+		Platform::SendScintilla(id, SCI_SETSTYLINGEX, validLen, 
+			reinterpret_cast<LPARAM>(styleBuf));
+		validLen = 0;
+	}
+}
+
+int StylingContext::IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader) {
+	int end = Length();
+	int spaceFlags = 0;
+	
+	// Determines the indentation level of the current line and also checks for consistent 
+	// indentation compared to the previous line.
+	// Indentation is judged consistent when the indentation whitespace of each line lines 
+	// the same or the indentation of one line is a prefix of the other.
+	
+	int pos = LineStart(line);
+	char ch = (*this)[pos];
+	int indent = 0;
+	bool inPrevPrefix = line > 0;
+	int posPrev = inPrevPrefix ? LineStart(line-1) : 0;
+	while ((ch == ' ' || ch == '\t') && (pos < end)) {
+		if (inPrevPrefix) {
+			char chPrev = (*this)[posPrev++];
+			if (chPrev == ' ' || chPrev == '\t') {
+				if (chPrev != ch)
+					spaceFlags |= wsInconsistent;
+			} else {
+				inPrevPrefix = false;
+			}
+		}
+		if (ch == ' ') {
+			spaceFlags |= wsSpace;
+			indent++;
+		} else {	// Tab
+			spaceFlags |= wsTab;
+			if (spaceFlags & wsSpace)
+				spaceFlags |= wsSpaceTab;
+			indent = (indent / 8 + 1) * 8;
+		}
+		ch = (*this)[++pos];
+	}
+	
+	*flags = spaceFlags;
+	indent += SC_FOLDLEVELBASE;
+	// if completely empty line or the start of a comment...
+	if (isspace(ch) || (pfnIsCommentLeader && (*pfnIsCommentLeader)(*this, pos, end-pos)) )
+		return indent | SC_FOLDLEVELWHITEFLAG;
+	else
+		return indent;
+}
+

contrib/src/stc/scintilla/src/AutoComplete.cxx

@@ -0,0 +1,104 @@
+// Scintilla source code edit control
+// AutoComplete.cxx - defines the auto completion list box
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "Platform.h"
+
+#include "AutoComplete.h"
+
+AutoComplete::AutoComplete() {
+	lb = 0;
+	active = false;
+	posStart = 0;
+	strcpy(stopChars, "");
+}
+
+AutoComplete::~AutoComplete() {
+	lb.Destroy();
+}
+
+bool AutoComplete::Active() {
+	return active;
+}
+
+void AutoComplete::Start(Window &parent, int ctrlID, int position, int startLen_) {
+	if (!lb.Created()) {
+		lb.Create(parent, ctrlID);
+	}
+	lb.Clear();
+	active = true;
+	startLen = startLen_;
+	posStart = position;
+}
+
+void AutoComplete::SetStopChars(const char *stopChars_) {
+	strncpy(stopChars, stopChars_, sizeof(stopChars));
+	stopChars[sizeof(stopChars) - 1] = '\0';
+}
+
+bool AutoComplete::IsStopChar(char ch) {
+	return ch && strchr(stopChars, ch);
+}
+
+int AutoComplete::SetList(const char *list) {
+	int maxStrLen = 12;
+	lb.Clear();
+	char *words = new char[strlen(list) + 1];
+	if (words) {
+		strcpy(words, list);
+		char *startword = words;
+		int i = 0;
+		for (; words && words[i]; i++) {
+			if (words[i] == ' ') {
+				words[i] = '\0';
+				lb.Append(startword);
+				maxStrLen = Platform::Maximum(maxStrLen, strlen(startword));
+				startword = words + i + 1;
+			}
+		}
+		if (startword) {
+			lb.Append(startword);
+			maxStrLen = Platform::Maximum(maxStrLen, strlen(startword));
+		}
+		delete []words;
+	}
+	lb.Sort();
+	return maxStrLen;
+}
+
+void AutoComplete::Show() {
+	lb.Show();
+	lb.Select(0);
+}
+
+void AutoComplete::Cancel() {
+	if (lb.Created()) {
+		lb.Destroy();
+		lb = 0;
+		active = false;
+	}
+}
+
+
+void AutoComplete::Move(int delta) {
+	int count = lb.Length();
+	int current = lb.GetSelection();
+	current += delta;
+	if (current >= count)
+		current = count - 1;
+	if (current < 0)
+		current = 0;
+	lb.Select(current);
+}
+
+void AutoComplete::Select(const char *word) {
+	int pos = lb.Find(word);
+	//Platform::DebugPrintf("Autocompleting at <%s> %d\n", wordCurrent, pos);
+	if (pos != -1)
+		lb.Select(pos);
+}
+

contrib/src/stc/scintilla/src/AutoComplete.h

@@ -0,0 +1,43 @@
+// Scintilla source code edit control
+// AutoComplete.h - defines the auto completion list box
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef AUTOCOMPLETE_H
+#define AUTOCOMPLETE_H
+
+class AutoComplete {
+	bool active;
+	char stopChars[256];
+public:
+	ListBox lb;
+	int posStart;
+	int startLen;
+	
+	AutoComplete();
+	~AutoComplete();
+
+	// Is the auto completion list displayed?	
+	bool Active();
+	
+	// Display the auto completion list positioned to be near a character position
+	void Start(Window &parent, int ctrlID, int position, int startLen_);
+	
+	// The stop chars are characters which, when typed, cause the auto completion list to disappear
+	void SetStopChars(const char *stopChars_);
+	bool IsStopChar(char ch);
+	
+	// The list string contains a sequence of words separated by spaces
+	int SetList(const char *list);
+	
+	void Show();
+	void Cancel();
+	
+	// Move the current list element by delta, scrolling appropriately
+	void Move(int delta);
+	
+	// Select a list element that starts with word as the current element
+	void Select(const char *word);
+};
+
+#endif

contrib/src/stc/scintilla/src/CallTip.cxx

@@ -0,0 +1,168 @@
+// Scintilla source code edit control
+// CallTip.cxx - code for displaying call tips
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h> 
+#include <string.h> 
+
+#include "Platform.h"
+
+#include "CallTip.h"
+
+CallTip::CallTip() {
+	wCallTip = 0;
+	inCallTipMode = false;
+	posStartCallTip = 0;
+	val = 0;
+	startHighlight = 0;
+	endHighlight = 0;
+
+	colourBG.desired = Colour(0xff, 0xff, 0xff);
+	colourUnSel.desired = Colour(0x80, 0x80, 0x80);
+	colourSel.desired = Colour(0, 0, 0x80);
+	colourShade.desired = Colour(0, 0, 0);
+	colourLight.desired = Colour(0xc0, 0xc0, 0xc0);
+}
+
+CallTip::~CallTip() {
+	wCallTip.Destroy();
+	delete []val;
+	val = 0;
+}
+
+void CallTip::RefreshColourPalette(Palette &pal, bool want) {
+	pal.WantFind(colourBG, want);
+	pal.WantFind(colourUnSel, want);
+	pal.WantFind(colourSel, want);
+	pal.WantFind(colourShade, want);
+	pal.WantFind(colourLight, want);
+}
+
+void CallTip::PaintCT(Surface *surfaceWindow) {
+	if (!val)
+		return;
+	PRectangle rcClientPos = wCallTip.GetClientPosition();
+	PRectangle rcClientSize(0, 0, rcClientPos.right - rcClientPos.left,
+	                        rcClientPos.bottom - rcClientPos.top);
+	PRectangle rcClient(1, 1, rcClientSize.right - 1, rcClientSize.bottom - 1);
+
+	surfaceWindow->FillRectangle(rcClient, colourBG.allocated);
+	// To make a nice small call tip window, it is only sized to fit most normal characters without accents
+	int lineHeight = surfaceWindow->Height(font);
+	int ascent = surfaceWindow->Ascent(font) - surfaceWindow->InternalLeading(font);
+
+	// For each line...
+	// Draw the definition in three parts: before highlight, highlighted, after highlight
+	int ytext = rcClient.top + ascent + 1;
+	char *chunkVal = val;
+	bool moreChunks = true;
+	while (moreChunks) {
+		char *chunkEnd = strchr(chunkVal, '\n');
+		if (chunkEnd == NULL) {
+			chunkEnd = chunkVal + strlen(chunkVal);
+			moreChunks = false;
+		}
+		int chunkOffset = chunkVal - val;
+		int chunkLength = chunkEnd - chunkVal;
+		int chunkEndOffset = chunkOffset + chunkLength;
+		int thisStartHighlight = Platform::Maximum(startHighlight, chunkOffset);
+		thisStartHighlight = Platform::Minimum(thisStartHighlight, chunkEndOffset);
+		thisStartHighlight -= chunkOffset;
+		int thisEndHighlight = Platform::Maximum(endHighlight, chunkOffset);
+		thisEndHighlight = Platform::Minimum(thisEndHighlight, chunkEndOffset);
+		thisEndHighlight -= chunkOffset;
+		int x = 5;
+		int xEnd = x + surfaceWindow->WidthText(font, chunkVal, thisStartHighlight);
+		rcClient.left = x;
+		rcClient.top = ytext - ascent - 1;
+		rcClient.right = xEnd;
+		surfaceWindow->DrawText(rcClient, font, ytext,
+		                        chunkVal, thisStartHighlight,
+		                        colourUnSel.allocated, colourBG.allocated);
+		x = xEnd;
+
+		xEnd = x + surfaceWindow->WidthText(font, chunkVal + thisStartHighlight,
+		                                    thisEndHighlight - thisStartHighlight);
+		rcClient.top = ytext;
+		rcClient.left = x;
+		rcClient.right = xEnd;
+		surfaceWindow->DrawText(rcClient, font, ytext,
+		                        chunkVal + thisStartHighlight, thisEndHighlight - thisStartHighlight,
+		                        colourSel.allocated, colourBG.allocated);
+		x = xEnd;
+
+		xEnd = x + surfaceWindow->WidthText(font, chunkVal + thisEndHighlight,
+		                                    chunkLength - thisEndHighlight);
+		rcClient.left = x;
+		rcClient.right = xEnd;
+		surfaceWindow->DrawText(rcClient, font, ytext,
+		                        chunkVal + thisEndHighlight, chunkLength - thisEndHighlight,
+		                        colourUnSel.allocated, colourBG.allocated);
+		chunkVal = chunkEnd + 1;
+		ytext += lineHeight;
+	}
+	// Draw a raised border around the edges of the window
+	surfaceWindow->MoveTo(0, rcClientSize.bottom - 1);
+	surfaceWindow->PenColour(colourShade.allocated);
+	surfaceWindow->LineTo(rcClientSize.right - 1, rcClientSize.bottom - 1);
+	surfaceWindow->LineTo(rcClientSize.right - 1, 0);
+	surfaceWindow->PenColour(colourLight.allocated);
+	surfaceWindow->LineTo(0, 0);
+	surfaceWindow->LineTo(0, rcClientSize.bottom - 1);
+}
+
+PRectangle CallTip::CallTipStart(int pos, Point pt, const char *defn,
+                                 const char *faceName, int size) {
+	Surface surfaceMeasure;
+	surfaceMeasure.Init();
+	int deviceHeight = (size * surfaceMeasure.LogPixelsY()) / 72;
+	font.Create(faceName, deviceHeight);
+	if (val)
+		delete []val;
+	val = new char[strlen(defn) + 1];
+	if (!val)
+		return PRectangle();
+	strcpy(val, defn);
+	startHighlight = 0;
+	endHighlight = 0;
+	inCallTipMode = true;
+	posStartCallTip = pos;
+	// Look for multiple lines in the text
+	// Only support \n here - simply means container must avoid \r!
+	int width = 0;
+	int numLines = 1;
+	const char *newline;
+	const char *look = val;
+	while ((newline = strchr(look, '\n')) != NULL) {
+		int thisWidth = surfaceMeasure.WidthText(font, look, newline - look);
+		width = Platform::Maximum(width, thisWidth);
+		look = newline + 1;
+		numLines++;
+	}
+	int lastWidth = surfaceMeasure.WidthText(font, look, strlen(look));
+	width = Platform::Maximum(width, lastWidth) + 10;
+	int lineHeight = surfaceMeasure.Height(font);
+	// Extra line for border and an empty line at top and bottom
+	int height = lineHeight * numLines - surfaceMeasure.InternalLeading(font) + 2 + 2;
+	return PRectangle(pt.x -5, pt.y + lineHeight + 1, pt.x + width - 5, pt.y + lineHeight + 1 + height);
+}
+
+
+void CallTip::CallTipCancel() {
+	inCallTipMode = false;
+	if (wCallTip.Created()) {
+		wCallTip.Destroy();
+	}
+}
+
+void CallTip::SetHighlight(int start, int end) {
+	// Avoid flashing by checking something has really changed
+	if ((start != startHighlight) || (end != endHighlight)) {
+		startHighlight = start;
+		endHighlight = end;
+		if (wCallTip.Created()) {
+			wCallTip.InvalidateAll();
+		}
+	}
+}

contrib/src/stc/scintilla/src/CallTip.h

@@ -0,0 +1,46 @@
+// Scintilla source code edit control
+// CallTip.h - interface to the call tip control
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef CALLTIP_H
+#define CALLTIP_H
+
+const char callClassName[] = "CallTip";
+
+class CallTip {
+	int startHighlight;
+	int endHighlight;
+	char *val;
+	Font font;
+public:
+	Window wCallTip;
+	Window wDraw;
+	bool inCallTipMode;
+	int posStartCallTip;
+	ColourPair colourBG;
+	ColourPair colourUnSel;
+	ColourPair colourSel;
+	ColourPair colourShade;
+	ColourPair colourLight;
+	
+	CallTip();
+	~CallTip();
+	
+	// Claim or accept palette entries for the colours required to paint a calltip
+	void RefreshColourPalette(Palette &pal, bool want);
+	
+	void PaintCT(Surface *surfaceWindow);
+	
+	// Setup the calltip and return a rectangle of the area required
+	PRectangle CallTipStart(int pos, Point pt, const char *defn, 
+		const char *faceName, int size);
+		
+	void CallTipCancel();
+	
+	// Set a range of characters to be displayed in a highlight style.
+	// Commonly used to highlight the current parameter.
+	void SetHighlight(int start, int end);
+};
+
+#endif

contrib/src/stc/scintilla/src/CellBuffer.h

@@ -0,0 +1,224 @@
+// Scintilla source code edit control
+// CellBuffer.h - manages the text of the document
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef CELLBUFFER_H
+#define CELLBUFFER_H
+
+// This holds the marker identifier and the marker type to display.
+// MarkerHandleNumbers are members of lists.
+struct MarkerHandleNumber {
+	int handle;
+	int number;
+	MarkerHandleNumber *next;
+};
+
+// A marker handle set contains any number of MarkerHandleNumbers
+class MarkerHandleSet {
+	MarkerHandleNumber *root;
+public:
+	MarkerHandleSet();
+	~MarkerHandleSet();
+	int Length();
+	int NumberFromHandle(int handle);
+	int MarkValue();	// Bit set of marker numbers
+	bool Contains(int handle);
+	bool InsertHandle(int handle, int markerNum);
+	void RemoveHandle(int handle);
+	void RemoveNumber(int markerNum);
+	void CombineWith(MarkerHandleSet *other);
+};
+
+// Each line stores the starting position of the first character of the line in the cell buffer
+// and potentially a marker handle set. Often a line will not have any attached markers.
+struct LineData {
+	int startPosition;
+	MarkerHandleSet *handleSet;
+	LineData() : startPosition(0), handleSet(0) {
+	}
+};
+
+// The line vector contains information about each of the lines in a cell buffer.
+class LineVector {
+public:
+	enum { growSize = 4000 };
+	int lines;
+	LineData *linesData;
+	int size;
+	int *levels;
+	int sizeLevels;
+	
+	// Handles are allocated sequentially and should never have to be reused as 32 bit ints are very big.
+	int handleCurrent;
+	
+	LineVector();
+	~LineVector();
+	void Init();
+
+	void Expand(int sizeNew);
+	void ExpandLevels(int sizeNew=-1);
+	void InsertValue(int pos, int value);
+	void SetValue(int pos, int value);
+	void Remove(int pos);
+	int LineFromPosition(int pos);
+	
+	int AddMark(int line, int marker);
+	void MergeMarkers(int pos);
+	void DeleteMark(int line, int markerNum);
+	void DeleteMarkFromHandle(int markerHandle);
+	int LineFromHandle(int markerHandle);
+};
+
+// Actions are used to store all the information required to perform one undo/redo step.
+enum actionType { insertAction, removeAction, startAction };
+
+class Action {
+public:
+	actionType at;
+	int position;
+	char *data;
+	int lenData;
+
+	Action();
+	~Action();
+	void Create(actionType at_, int position_=0, char *data_=0, int lenData_=0);
+	void Destroy();
+	void Grab(Action *source);
+};
+
+enum undoCollectionType { undoCollectNone, undoCollectAutoStart, undoCollectManualStart };
+
+class UndoHistory {
+	Action *actions;
+	int lenActions;
+	int maxAction;
+	int currentAction;
+	int undoSequenceDepth;
+	int savePoint;
+
+	void EnsureUndoRoom();
+	
+public:
+	UndoHistory();
+	~UndoHistory();
+	
+	void AppendAction(actionType at, int position, char *data, int length);
+
+	void BeginUndoAction();
+	void EndUndoAction();
+	void DropUndoSequence();
+	void DeleteUndoHistory();
+	
+	// The save point is a marker in the undo stack where the container has stated that 
+	// the buffer was saved. Undo and redo can move over the save point.
+	void SetSavePoint();
+	bool IsSavePoint() const;
+
+	// To perform an undo, StartUndo is called to retrieve the number of steps, then UndoStep is 
+	// called that many times. Similarly for redo.
+	bool CanUndo() const;
+	int StartUndo();
+	const Action &UndoStep();
+	bool CanRedo() const;
+	int StartRedo();
+	const Action &RedoStep();
+};
+
+// Holder for an expandable array of characters that supports undo and line markers
+// Based on article "Data Structures in a Bit-Mapped Text Editor"
+// by Wilfred J. Hansen, Byte January 1987, page 183
+class CellBuffer {
+private:
+	char *body;
+	int size;
+	int length;
+	int part1len;
+	int gaplen;
+	char *part2body;
+	bool readOnly;
+
+	undoCollectionType collectingUndo;
+	UndoHistory uh;
+
+	LineVector lv;
+
+	SVector<int, 4000> lineStates;
+
+	void GapTo(int position);
+	void RoomFor(int insertionLength);
+
+	inline char ByteAt(int position);
+	void SetByteAt(int position, char ch);
+
+public:
+
+	CellBuffer(int initialLength = 4000);
+	~CellBuffer();
+	
+	// Retrieving positions outside the range of the buffer works and returns 0
+	char CharAt(int position);
+	void GetCharRange(char *buffer, int position, int lengthRetrieve);
+	char StyleAt(int position);
+	
+	int ByteLength();
+	int Length();
+	int Lines();
+	int LineStart(int line);
+	int LineFromPosition(int pos) { return lv.LineFromPosition(pos); }
+	const char *InsertString(int position, char *s, int insertLength);
+	void InsertCharStyle(int position, char ch, char style);
+	
+	// Setting styles for positions outside the range of the buffer is safe and has no effect.
+	// True is returned if the style of a character changed.
+	bool SetStyleAt(int position, char style, char mask=(char)0xff);
+	bool SetStyleFor(int position, int length, char style, char mask);
+	
+	const char *DeleteChars(int position, int deleteLength);
+
+	bool IsReadOnly();
+	void SetReadOnly(bool set);
+
+	// The save point is a marker in the undo stack where the container has stated that 
+	// the buffer was saved. Undo and redo can move over the save point.
+	void SetSavePoint();
+	bool IsSavePoint();
+
+	// Line marker functions
+	int AddMark(int line, int markerNum);
+	void DeleteMark(int line, int markerNum);
+	void DeleteMarkFromHandle(int markerHandle);
+	int GetMark(int line);
+	void DeleteAllMarks(int markerNum);
+	int LineFromHandle(int markerHandle);
+ 
+	// Without undo
+	void BasicInsertString(int position, char *s, int insertLength);
+	void BasicDeleteChars(int position, int deleteLength);
+
+	undoCollectionType SetUndoCollection(undoCollectionType collectUndo);
+	bool IsCollectingUndo();
+	void BeginUndoAction();
+	void EndUndoAction();
+	void DeleteUndoHistory();
+	
+	// To perform an undo, StartUndo is called to retrieve the number of steps, then UndoStep is 
+	// called that many times. Similarly for redo.
+	bool CanUndo();
+	int StartUndo();
+	const Action &UndoStep();
+	bool CanRedo();
+	int StartRedo();
+	const Action &RedoStep();
+	
+	int SetLineState(int line, int state);
+	int GetLineState(int line);
+	int GetMaxLineState();
+		
+	int SetLevel(int line, int level);
+	int GetLevel(int line);
+};
+
+#define CELL_SIZE	2
+
+#endif

contrib/src/stc/scintilla/src/ContractionState.cxx

@@ -0,0 +1,203 @@
+// Scintilla source code edit control
+// ContractionState.cxx - manages visibility of lines for folding
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include "Platform.h"
+
+#include "ContractionState.h"
+
+OneLine::OneLine() {
+	displayLine = 0;
+	docLine = 0;
+	visible = true;
+	expanded = true;
+}
+
+ContractionState::ContractionState() {
+	lines = 0;
+	size = 0;
+	linesInDoc = 1;
+	linesInDisplay = 1;
+	valid = false;
+}
+
+ContractionState::~ContractionState() {
+	Clear();
+}
+
+void ContractionState::MakeValid() const {
+	if (!valid) {
+		// Could be cleverer by keeping the index of the last still valid entry 
+		// rather than invalidating all.
+		int linePrev = -1;
+		int lineDisplay = 0;
+		for (int line=0; line<linesInDoc; line++) {
+			lines[line].displayLine = lineDisplay;
+			if (lines[line].visible) {
+				lines[lineDisplay].docLine = line;
+				lineDisplay++;
+			}
+		}
+		valid = true;
+	}
+}
+
+void ContractionState::Clear() {
+	delete []lines;
+	lines = 0;
+	size = 0;
+	linesInDoc = 1;
+	linesInDisplay = 1;
+}
+
+int ContractionState::LinesInDoc() const {
+	return linesInDoc;
+}
+
+int ContractionState::LinesDisplayed() const {
+	return linesInDisplay;
+}
+
+int ContractionState::DisplayFromDoc(int lineDoc) const {
+	if (size == 0) {
+		return lineDoc;
+	}
+	MakeValid();
+	if ((lineDoc >= 0) && (lineDoc < linesInDoc)) {
+		return lines[lineDoc].displayLine;
+	}
+	return -1;
+}
+
+int ContractionState::DocFromDisplay(int lineDisplay) const {
+	if (lineDisplay <= 0)
+		return 0;
+	if (lineDisplay >= linesInDisplay)
+		return linesInDoc-1;
+	if (size == 0)
+		return lineDisplay;
+	MakeValid();
+	return lines[lineDisplay].docLine;
+}
+
+void ContractionState::Grow(int sizeNew) {
+	OneLine *linesNew = new OneLine[sizeNew];
+	if (linesNew) {
+		int i = 0;
+		for (; i < size; i++) {
+			linesNew[i] = lines[i];
+		}
+		for (; i < sizeNew; i++) {
+			linesNew[i].displayLine = i;
+		}
+		delete []lines;
+		lines = linesNew;
+		size = sizeNew;
+		valid = false;
+	} else {
+		Platform::DebugPrintf("No memory available\n");
+		// TODO: Blow up
+	}
+}
+
+void ContractionState::InsertLines(int lineDoc, int lineCount) {
+	if (size == 0) {
+		linesInDoc += lineCount;
+		linesInDisplay += lineCount;
+		return;
+	}
+	//Platform::DebugPrintf("InsertLine[%d] = %d\n", lineDoc);
+	if ((linesInDoc + lineCount + 2) >= size) {
+		Grow(linesInDoc + lineCount + growSize);
+	}
+	linesInDoc += lineCount;
+	linesInDisplay += lineCount;
+	for (int i = linesInDoc + 1; i >= lineDoc + lineCount; i--) {
+		lines[i].visible = lines[i - lineCount].visible;
+		lines[i].expanded = lines[i - lineCount].expanded;
+	}
+	for (int d=0;d<lineCount;d++) {
+		lines[lineDoc+d].visible = true;	// Should inherit visibility from context ?
+		lines[lineDoc+d].expanded = true;
+	}
+	valid = false;
+}
+
+void ContractionState::DeleteLines(int lineDoc, int lineCount) {
+	if (size == 0) {
+		linesInDoc -= lineCount;
+		linesInDisplay -= lineCount;
+		return;
+	}
+	int delta = 0;
+	for (int d=0;d<lineCount;d++)
+		if (lines[lineDoc+d].visible)
+			delta--;
+	for (int i = lineDoc; i < linesInDoc-lineCount; i++) {
+		lines[i].visible = lines[i + lineCount].visible;
+		lines[i].expanded = lines[i + lineCount].expanded;
+	}
+	linesInDoc -= lineCount;
+	linesInDisplay += delta;
+	valid = false;
+}
+
+bool ContractionState::GetVisible(int lineDoc) const {
+	if (size == 0)
+		return true;
+	if ((lineDoc >= 0) && (lineDoc < linesInDoc)) {
+		return lines[lineDoc].visible;
+	} else {
+		return false;
+	}
+}
+
+bool ContractionState::SetVisible(int lineDocStart, int lineDocEnd, bool visible) {
+	if (size == 0) {
+		Grow(linesInDoc + growSize);
+	}
+	// TODO: modify docLine members to mirror displayLine
+	int delta = 0;
+	// Change lineDocs
+	if ((lineDocStart <= lineDocEnd) && (lineDocStart >= 0) && (lineDocEnd < linesInDoc)) {
+		for (int line=lineDocStart; line <= lineDocEnd; line++) {
+			if (lines[line].visible != visible) {
+				delta += visible ? 1 : -1;		
+				lines[line].visible = visible;
+			}
+			lines[line].displayLine += delta;
+		}
+		if (delta != 0) {
+			for (int line=lineDocEnd+1; line <= linesInDoc; line++) {
+				lines[line].displayLine += delta;
+			}
+		}
+	}
+	linesInDisplay += delta;
+	valid = false;
+	return delta != 0;
+}
+
+bool ContractionState::GetExpanded(int lineDoc) const {
+	if (size == 0) 
+		return true;
+	if ((lineDoc >= 0) && (lineDoc < linesInDoc)) {
+		return lines[lineDoc].expanded;
+	} else {
+		return false;
+	}
+}
+
+bool ContractionState::SetExpanded(int lineDoc, bool expanded) {
+	if (size == 0) {
+		Grow(linesInDoc + growSize);
+	}
+	if ((lineDoc >= 0) && (lineDoc < linesInDoc)) {
+		if (lines[lineDoc].expanded != expanded) {
+			lines[lineDoc].expanded = expanded;
+			return true;
+		}
+	}
+	return false;
+}

contrib/src/stc/scintilla/src/ContractionState.h

@@ -0,0 +1,50 @@
+// Scintilla source code edit control
+// ContractionState.h - manages visibility of lines for folding
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef CONTRACTIONSTATE_H
+#define CONTRACTIONSTATE_H
+
+class OneLine {
+public:
+	int displayLine;	// position within set of visible lines
+	int docLine;		// inverse of displayLine
+	bool visible;
+	bool expanded;
+	
+	OneLine();
+	virtual ~OneLine() {}
+};
+
+class ContractionState {
+	void Grow(int sizeNew);
+	enum { growSize = 4000 };
+	int linesInDoc;
+	int linesInDisplay;
+	mutable OneLine *lines;
+	int size;
+	mutable bool valid;
+	void MakeValid() const;
+public:
+	ContractionState();
+	virtual ~ContractionState();
+	
+	void Clear();
+	
+	int LinesInDoc() const;	
+	int LinesDisplayed() const;	
+	int DisplayFromDoc(int lineDoc) const;
+	int DocFromDisplay(int lineDisplay) const;
+	
+	void InsertLines(int lineDoc, int lineCount);
+	void DeleteLines(int lineDoc, int lineCount);
+	
+	bool GetVisible(int lineDoc) const;
+	bool SetVisible(int lineDocStart, int lineDocEnd, bool visible);
+	
+	bool GetExpanded(int lineDoc) const;
+	bool SetExpanded(int lineDoc, bool expanded);
+};
+
+#endif

contrib/src/stc/scintilla/src/Document.cxx

@@ -0,0 +1,797 @@
+// Scintilla source code edit control
+// Document.cxx - text document that handles notifications, DBCS, styling, words and end of line
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include "Platform.h"
+
+#include "Scintilla.h"
+#include "SVector.h"
+#include "CellBuffer.h"
+#include "Document.h"
+
+Document::Document() {
+	refCount = 0;
+#ifdef unix
+	eolMode = SC_EOL_LF;
+#else
+	eolMode = SC_EOL_CRLF;
+#endif
+	dbcsCodePage = 0;
+	stylingBits = 5;
+	stylingBitsMask = 0x1F;
+	stylingPos = 0;
+	stylingMask = 0;
+	for (int ch = 0; ch < 256; ch++) {
+		wordchars[ch] = isalnum(ch) || ch == '_';
+	}
+	endStyled = 0;
+	enteredCount = 0;
+	tabInChars = 8;
+	watchers = 0;
+	lenWatchers = 0;
+}
+
+Document::~Document() {
+	for (int i = 0; i < lenWatchers; i++) {
+		watchers[i].watcher->NotifyDeleted(this, watchers[i].userData);
+	}
+	delete []watchers;
+	watchers = 0;
+	lenWatchers = 0;
+}
+
+// Increase reference count and return its previous value.
+int Document::AddRef() {
+	return refCount++;
+}
+
+// Decrease reference count and return its provius value.
+// Delete the document if reference count reaches zero.
+int Document::Release() {
+	int curRefCount = --refCount;
+	if (curRefCount == 0)
+		delete this;
+	return curRefCount;
+}
+
+void Document::SetSavePoint() {
+	cb.SetSavePoint();
+	NotifySavePoint(true);
+}
+
+int Document::AddMark(int line, int markerNum) { 
+	int prev = cb.AddMark(line, markerNum); 
+	DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0);
+	NotifyModified(mh);
+	return prev;
+}
+
+void Document::DeleteMark(int line, int markerNum) { 
+	cb.DeleteMark(line, markerNum); 
+	DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0);
+	NotifyModified(mh);
+}
+
+void Document::DeleteMarkFromHandle(int markerHandle) { 
+	cb.DeleteMarkFromHandle(markerHandle); 
+	DocModification mh(SC_MOD_CHANGEMARKER, 0, 0, 0, 0);
+	NotifyModified(mh);
+}
+
+void Document::DeleteAllMarks(int markerNum) { 
+	cb.DeleteAllMarks(markerNum); 
+	DocModification mh(SC_MOD_CHANGEMARKER, 0, 0, 0, 0);
+	NotifyModified(mh);
+}
+
+int Document::LineStart(int line) {
+	return cb.LineStart(line);
+}
+
+int Document::LineEnd(int line) {
+	if (line == LinesTotal() - 1) {
+		return LineStart(line + 1);
+	} else {
+		int position = LineStart(line + 1) - 1;
+		// When line terminator is CR+LF, may need to go back one more
+		if ((position > LineStart(line)) && (cb.CharAt(position - 1) == '\r')) {
+			position--;
+		}
+		return position;
+	}
+}
+
+int Document::LineFromPosition(int pos) {
+	return cb.LineFromPosition(pos);
+}
+
+int Document::LineEndPosition(int position) {
+	return LineEnd(LineFromPosition(position));
+}
+
+int Document::VCHomePosition(int position) {
+	int line = LineFromPosition(position);
+	int startPosition = LineStart(line);
+	int endLine = LineStart(line + 1) - 1;
+	int startText = startPosition;
+	while (startText < endLine && (cb.CharAt(startText) == ' ' || cb.CharAt(startText) == '\t' ) )
+		startText++;
+	if (position == startText)
+		return startPosition;
+	else
+		return startText;
+}
+
+int Document::SetLevel(int line, int level) { 
+	int prev = cb.SetLevel(line, level); 
+	if (prev != level) {
+		DocModification mh(SC_MOD_CHANGEFOLD, LineStart(line), 0, 0, 0);
+		mh.line = line;
+		mh.foldLevelNow = level;
+		mh.foldLevelPrev = prev;
+		NotifyModified(mh);
+	}
+	return prev;
+}
+
+static bool IsSubordinate(int levelStart, int levelTry) {
+	if (levelTry & SC_FOLDLEVELWHITEFLAG)
+		return true;
+	else 
+		return (levelStart & SC_FOLDLEVELNUMBERMASK) < (levelTry & SC_FOLDLEVELNUMBERMASK);
+}
+
+int Document::GetLastChild(int lineParent, int level) {
+	if (level == -1)
+		level = GetLevel(lineParent) & SC_FOLDLEVELNUMBERMASK;
+	int maxLine = LinesTotal();
+	int lineMaxSubord = lineParent;
+	while (lineMaxSubord < maxLine-1) {
+		EnsureStyledTo(LineStart(lineMaxSubord+2));
+		if (!IsSubordinate(level, GetLevel(lineMaxSubord+1)))
+			break;
+		lineMaxSubord++;
+	}
+	if (lineMaxSubord > lineParent) {
+		if (level > (GetLevel(lineMaxSubord+1) & SC_FOLDLEVELNUMBERMASK)) {
+			// Have chewed up some whitespace that belongs to a parent so seek back 
+			if ((lineMaxSubord > lineParent) && (GetLevel(lineMaxSubord) & SC_FOLDLEVELWHITEFLAG)) {
+				lineMaxSubord--;
+			}
+		}
+	}
+	return lineMaxSubord;
+}
+
+int Document::GetFoldParent(int line) {
+	int level = GetLevel(line);
+	int lineLook = line-1;
+	while ((lineLook > 0) && (
+		(!(GetLevel(lineLook) & SC_FOLDLEVELHEADERFLAG)) || 
+		((GetLevel(lineLook) & SC_FOLDLEVELNUMBERMASK) >= level))
+	) {
+		lineLook--;
+	}
+	if ((GetLevel(lineLook) & SC_FOLDLEVELHEADERFLAG) &&
+		((GetLevel(lineLook) & SC_FOLDLEVELNUMBERMASK) < level)) {
+		return lineLook;
+	} else {
+		return -1;
+	}
+}
+
+int Document::ClampPositionIntoDocument(int pos) {
+	return Platform::Clamp(pos, 0, Length());
+}
+
+bool Document::IsCrLf(int pos) {
+	if (pos < 0)
+		return false;
+	if (pos >= (Length() - 1))
+		return false;
+	return (cb.CharAt(pos) == '\r') && (cb.CharAt(pos + 1) == '\n');
+}
+
+bool Document::IsDBCS(int pos) {
+#if PLAT_WIN
+	if (dbcsCodePage) {
+		// Anchor DBCS calculations at start of line because start of line can
+		// not be a DBCS trail byte.
+		int startLine = pos;
+		while (startLine > 0 && cb.CharAt(startLine) != '\r' && cb.CharAt(startLine) != '\n')
+			startLine--;
+		while (startLine <= pos) {
+			if (IsDBCSLeadByteEx(dbcsCodePage, cb.CharAt(startLine))) {
+				startLine++;
+				if (startLine >= pos)
+					return true;
+			}
+			startLine++;
+		}
+	}
+	return false;
+#else
+	return false;
+#endif
+}
+
+// Normalise a position so that it is not halfway through a two byte character.
+// This can occur in two situations -
+// When lines are terminated with \r\n pairs which should be treated as one character.
+// When displaying DBCS text such as Japanese.
+// If moving, move the position in the indicated direction.
+int Document::MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd) {
+	//Platform::DebugPrintf("NoCRLF %d %d\n", pos, moveDir);
+	// If out of range, just return value - should be fixed up after
+	if (pos < 0)
+		return pos;
+	if (pos > Length())
+		return pos;
+
+	// Position 0 and Length() can not be between any two characters
+	if (pos == 0)
+		return pos;
+	if (pos == Length())
+		return pos;
+
+	// assert pos > 0 && pos < Length()
+	if (checkLineEnd && IsCrLf(pos - 1)) {
+		if (moveDir > 0)
+			return pos + 1;
+		else
+			return pos - 1;
+	}
+
+	// Not between CR and LF
+
+#if PLAT_WIN
+	if (dbcsCodePage) {
+		// Anchor DBCS calculations at start of line because start of line can
+		// not be a DBCS trail byte.
+		int startLine = pos;
+		while (startLine > 0 && cb.CharAt(startLine) != '\r' && cb.CharAt(startLine) != '\n')
+			startLine--;
+		bool atLeadByte = false;
+		while (startLine < pos) {
+			if (atLeadByte)
+				atLeadByte = false;
+			else if (IsDBCSLeadByteEx(dbcsCodePage, cb.CharAt(startLine)))
+				atLeadByte = true;
+			else
+				atLeadByte = false;
+			startLine++;
+			//Platform::DebugPrintf("DBCS %s\n", atlead ? "D" : "-");
+		}
+
+		if (atLeadByte) {
+			// Position is between a lead byte and a trail byte
+			if (moveDir > 0)
+				return pos + 1;
+			else
+				return pos - 1;
+		}
+	}
+#endif
+
+	return pos;
+}
+
+void Document::ModifiedAt(int pos) {
+	if (endStyled > pos)
+		endStyled = pos;
+}
+
+// Document only modified by gateways DeleteChars, InsertStyledString, Undo, Redo, and SetStyleAt.
+// SetStyleAt does not change the persistent state of a document
+
+// Unlike Undo, Redo, and InsertStyledString, the pos argument is a cell number not a char number
+void Document::DeleteChars(int pos, int len) {
+	if (enteredCount == 0) {
+		enteredCount++;
+		if (cb.IsReadOnly())
+			NotifyModifyAttempt();
+		if (!cb.IsReadOnly()) {
+			int prevLinesTotal = LinesTotal();
+			bool startSavePoint = cb.IsSavePoint();
+			const char *text = cb.DeleteChars(pos*2, len * 2);
+			if (startSavePoint && cb.IsCollectingUndo())
+				NotifySavePoint(!startSavePoint);
+			ModifiedAt(pos);
+			int modFlags = SC_MOD_DELETETEXT | SC_PERFORMED_USER;
+			DocModification mh(modFlags, pos, len, LinesTotal() - prevLinesTotal, text);
+			NotifyModified(mh);
+		}
+		enteredCount--;
+	}
+}
+
+void Document::InsertStyledString(int position, char *s, int insertLength) {
+	if (enteredCount == 0) {
+		enteredCount++;
+		if (cb.IsReadOnly())
+			NotifyModifyAttempt();
+		if (!cb.IsReadOnly()) {
+			int prevLinesTotal = LinesTotal();
+			bool startSavePoint = cb.IsSavePoint();
+			const char *text = cb.InsertString(position, s, insertLength);
+			if (startSavePoint && cb.IsCollectingUndo())
+				NotifySavePoint(!startSavePoint);
+			ModifiedAt(position / 2);
+	
+			int modFlags = SC_MOD_INSERTTEXT | SC_PERFORMED_USER;
+			DocModification mh(modFlags, position / 2, insertLength / 2, LinesTotal() - prevLinesTotal, text);
+			NotifyModified(mh);
+		}
+		enteredCount--;
+	}
+}
+
+int Document::Undo() {
+	int newPos = 0;
+	if (enteredCount == 0) {
+		enteredCount++;
+		bool startSavePoint = cb.IsSavePoint();
+		int steps = cb.StartUndo();
+		//Platform::DebugPrintf("Steps=%d\n", steps);
+		for (int step=0; step<steps; step++) {
+			int prevLinesTotal = LinesTotal();
+			const Action &action = cb.UndoStep();
+			int cellPosition = action.position / 2;
+			ModifiedAt(cellPosition);
+			newPos = cellPosition;
+			
+			int modFlags = SC_PERFORMED_UNDO;
+			// With undo, an insertion action becomes a deletion notification
+			if (action.at == removeAction) {
+				newPos += action.lenData;
+				modFlags |= SC_MOD_INSERTTEXT;
+			} else {
+				modFlags |= SC_MOD_DELETETEXT;
+			}
+			if (step == steps-1)
+				modFlags |= SC_LASTSTEPINUNDOREDO;
+			NotifyModified(DocModification(modFlags, cellPosition, action.lenData, 
+				LinesTotal() - prevLinesTotal, action.data));
+		}
+	
+		bool endSavePoint = cb.IsSavePoint();
+		if (startSavePoint != endSavePoint)
+			NotifySavePoint(endSavePoint);
+		enteredCount--;
+	}
+	return newPos;
+}
+
+int Document::Redo() {
+	int newPos = 0;
+	if (enteredCount == 0) {
+		enteredCount++;
+		bool startSavePoint = cb.IsSavePoint();
+		int steps = cb.StartRedo();
+		for (int step=0; step<steps; step++) {
+			int prevLinesTotal = LinesTotal();
+			const Action &action = cb.RedoStep();
+			int cellPosition = action.position / 2;
+			ModifiedAt(cellPosition);
+			newPos = cellPosition;
+			
+			int modFlags = SC_PERFORMED_REDO;
+			if (action.at == insertAction) {
+				newPos += action.lenData;
+				modFlags |= SC_MOD_INSERTTEXT;
+			} else {
+				modFlags |= SC_MOD_DELETETEXT;
+			}
+			if (step == steps-1)
+				modFlags |= SC_LASTSTEPINUNDOREDO;
+			NotifyModified(DocModification(modFlags, cellPosition, action.lenData, 
+				LinesTotal() - prevLinesTotal, action.data));
+		}
+	
+		bool endSavePoint = cb.IsSavePoint();
+		if (startSavePoint != endSavePoint)
+			NotifySavePoint(endSavePoint);
+		enteredCount--;
+	}
+	return newPos;
+}
+
+void Document::InsertChar(int pos, char ch) {
+	char chs[2];
+	chs[0] = ch;
+	chs[1] = 0;
+	InsertStyledString(pos*2, chs, 2);
+}
+
+// Insert a null terminated string
+void Document::InsertString(int position, const char *s) {
+	InsertString(position, s, strlen(s));
+}
+
+// Insert a string with a length
+void Document::InsertString(int position, const char *s, int insertLength) {
+	char *sWithStyle = new char[insertLength * 2];
+	if (sWithStyle) {
+		for (int i = 0; i < insertLength; i++) {
+			sWithStyle[i*2] = s[i];
+			sWithStyle[i*2 + 1] = 0;
+		}
+		InsertStyledString(position*2, sWithStyle, insertLength*2);
+		delete []sWithStyle;
+	}
+}
+
+void Document::ChangeChar(int pos, char ch) {
+	DeleteChars(pos, 1);
+	InsertChar(pos, ch);
+}
+
+void Document::DelChar(int pos) {
+	if (IsCrLf(pos)) {
+		DeleteChars(pos, 2);
+	} else if (IsDBCS(pos)) {
+		DeleteChars(pos, 2);
+	} else if (pos < Length()) {
+		DeleteChars(pos, 1);
+	}
+}
+
+int Document::DelCharBack(int pos) {
+	if (pos <= 0) {
+		return pos;
+	} else if (IsCrLf(pos - 2)) {
+		DeleteChars(pos - 2, 2);
+		return pos - 2;
+	} else if (IsDBCS(pos - 1)) {
+		DeleteChars(pos - 2, 2);
+		return pos - 2;
+	} else {
+		DeleteChars(pos - 1, 1);
+		return pos - 1;
+	}
+}
+
+void Document::Indent(bool forwards, int lineBottom, int lineTop) {
+	if (forwards) {
+		// Indent by a tab
+		for (int line = lineBottom; line >= lineTop; line--) {
+			InsertChar(LineStart(line), '\t');
+		}
+	} else {
+		// Dedent - suck white space off the front of the line to dedent by equivalent of a tab
+		for (int line = lineBottom; line >= lineTop; line--) {
+			int ispc = 0;
+			while (ispc < tabInChars && cb.CharAt(LineStart(line) + ispc) == ' ')
+				ispc++;
+			int posStartLine = LineStart(line);
+			if (ispc == tabInChars) {
+				DeleteChars(posStartLine, ispc);
+			} else if (cb.CharAt(posStartLine + ispc) == '\t') {
+				DeleteChars(posStartLine, ispc + 1);
+			} else {	// Hit a non-white
+				DeleteChars(posStartLine, ispc);
+			}
+		}
+	}
+}
+
+void Document::ConvertLineEnds(int eolModeSet) {
+	BeginUndoAction();
+	for (int pos = 0; pos < Length(); pos++) {
+		if (cb.CharAt(pos) == '\r') {
+			if (cb.CharAt(pos+1) == '\n') {
+				if (eolModeSet != SC_EOL_CRLF) {
+					DeleteChars(pos, 2);
+					if (eolModeSet == SC_EOL_CR)
+						InsertString(pos, "\r", 1);
+					else
+						InsertString(pos, "\n", 1);
+				} else {
+					pos++;
+				}
+			} else {
+				if (eolModeSet != SC_EOL_CR) {
+					DeleteChars(pos, 1);
+					if (eolModeSet == SC_EOL_CRLF) {
+						InsertString(pos, "\r\n", 2);
+						pos++;
+					} else {
+						InsertString(pos, "\n", 1);
+					}
+				}
+			}
+		} else if (cb.CharAt(pos) == '\n') {
+			if (eolModeSet != SC_EOL_LF) {
+				DeleteChars(pos, 1);
+				if (eolModeSet == SC_EOL_CRLF) {
+					InsertString(pos, "\r\n", 2);
+					pos++;
+				} else {
+					InsertString(pos, "\r", 1);
+				}
+			}
+		}
+	}
+	EndUndoAction();
+}
+
+bool Document::IsWordChar(unsigned char ch) {
+	return wordchars[ch];
+}
+
+int Document::ExtendWordSelect(int pos, int delta) {
+	if (delta < 0) {
+		while (pos > 0 && IsWordChar(cb.CharAt(pos - 1)))
+			pos--;
+	} else {
+		while (pos < (Length()) && IsWordChar(cb.CharAt(pos)))
+			pos++;
+	}
+	return pos;
+}
+
+int Document::NextWordStart(int pos, int delta) {
+	if (delta < 0) {
+		while (pos > 0 && (cb.CharAt(pos - 1) == ' ' || cb.CharAt(pos - 1) == '\t'))
+			pos--;
+		if (isspace(cb.CharAt(pos - 1))) {	// Back up to previous line
+			while (pos > 0 && isspace(cb.CharAt(pos - 1)))
+				pos--;
+		} else {
+			bool startAtWordChar = IsWordChar(cb.CharAt(pos - 1));
+			while (pos > 0 && !isspace(cb.CharAt(pos - 1)) && (startAtWordChar == IsWordChar(cb.CharAt(pos - 1))))
+				pos--;
+		}
+	} else {
+		bool startAtWordChar = IsWordChar(cb.CharAt(pos));
+		while (pos < (Length()) && isspace(cb.CharAt(pos)))
+			pos++;
+		while (pos < (Length()) && !isspace(cb.CharAt(pos)) && (startAtWordChar == IsWordChar(cb.CharAt(pos))))
+			pos++;
+		while (pos < (Length()) && (cb.CharAt(pos) == ' ' || cb.CharAt(pos) == '\t'))
+			pos++;
+	}
+	return pos;
+}
+
+bool Document::IsWordAt(int start, int end) {
+	int lengthDoc = Length();
+	if (start > 0) {
+		char ch = CharAt(start - 1);
+		if (IsWordChar(ch))
+			return false;
+	}
+	if (end < lengthDoc - 1) {
+		char ch = CharAt(end);
+		if (IsWordChar(ch))
+			return false;
+	}
+	return true;
+}
+
+// Find text in document, supporting both forward and backward
+// searches (just pass minPos > maxPos to do a backward search)
+// Has not been tested with backwards DBCS searches yet.
+long Document::FindText(int minPos, int maxPos, const char *s, bool caseSensitive, bool word) {
+ 	bool forward = minPos <= maxPos;
+	int increment = forward ? 1 : -1;
+
+	// Range endpoints should not be inside DBCS characters, but just in case, move them.
+	int startPos = MovePositionOutsideChar(minPos, increment, false);
+	int endPos = MovePositionOutsideChar(maxPos, increment, false);
+ 	
+	// Compute actual search ranges needed
+	int lengthFind = strlen(s);
+ 	int endSearch = 0;
+ 	if (startPos <= endPos) {
+ 		endSearch = endPos - lengthFind + 1;
+ 	} else {
+ 		endSearch = endPos;
+ 	}
+	//Platform::DebugPrintf("Find %d %d %s %d\n", startPos, endPos, ft->lpstrText, lengthFind);
+	char firstChar = s[0];
+	if (!caseSensitive)
+		firstChar = toupper(firstChar);
+	int pos = startPos;
+	while (forward ? (pos < endSearch) : (pos >= endSearch)) {
+		char ch = CharAt(pos);
+		if (caseSensitive) {
+			if (ch == firstChar) {
+				bool found = true;
+				for (int posMatch = 1; posMatch < lengthFind && found; posMatch++) {
+					ch = CharAt(pos + posMatch);
+					if (ch != s[posMatch])
+						found = false;
+				}
+				if (found) {
+					if ((!word) || IsWordAt(pos, pos + lengthFind))
+						return pos;
+				}
+			}
+		} else {
+			if (toupper(ch) == firstChar) {
+				bool found = true;
+				for (int posMatch = 1; posMatch < lengthFind && found; posMatch++) {
+					ch = CharAt(pos + posMatch);
+					if (toupper(ch) != toupper(s[posMatch]))
+						found = false;
+				}
+				if (found) {
+					if ((!word) || IsWordAt(pos, pos + lengthFind))
+						return pos;
+				}
+			}
+		}
+		pos += increment;
+		if (dbcsCodePage) {
+			// Ensure trying to match from start of character
+			pos = MovePositionOutsideChar(pos, increment, false);
+		}
+	}
+	//Platform::DebugPrintf("Not found\n");
+	return - 1;
+}
+
+int Document::LinesTotal() {
+	return cb.Lines();
+}
+
+void Document::ChangeCase(Range r, bool makeUpperCase) {
+	for (int pos=r.start; pos<r.end; pos++) {
+		char ch = CharAt(pos);
+		if (dbcsCodePage && IsDBCS(pos)) {
+			pos++;
+		} else {
+			if (makeUpperCase) {
+				if (islower(ch)) {
+					ChangeChar(pos, toupper(ch));
+				}
+			} else {
+				if (isupper(ch)) {
+					ChangeChar(pos, tolower(ch));
+				}
+			}
+		}
+	}
+}
+
+void Document::SetWordChars(unsigned char *chars) {
+	int ch;
+	for (ch = 0; ch < 256; ch++) {
+		wordchars[ch] = false;
+	}
+	if (chars) {
+		while (*chars) {
+			wordchars[*chars] = true;
+			chars++;
+		}
+	} else {
+		for (ch = 0; ch < 256; ch++) {
+			wordchars[ch] = isalnum(ch) || ch == '_';
+		}
+	}
+}
+
+void Document::SetStylingBits(int bits) {
+	stylingBits = bits;
+	stylingBitsMask = 0;
+	for (int bit=0; bit<stylingBits; bit++) {
+		stylingBitsMask <<= 1;
+		stylingBitsMask |= 1;
+	}
+}
+
+void Document::StartStyling(int position, char mask) {
+	stylingPos = position;
+	stylingMask = mask;
+}
+
+void Document::SetStyleFor(int length, char style) {
+	if (enteredCount == 0) {
+		enteredCount++;
+		int prevEndStyled = endStyled;
+		if (cb.SetStyleFor(stylingPos, length, style, stylingMask)) {
+			DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER, 
+				prevEndStyled, length);
+			NotifyModified(mh);
+		}
+		stylingPos += length;
+		endStyled = stylingPos;
+		enteredCount--;
+	}
+}
+
+void Document::SetStyles(int length, char *styles) {
+	if (enteredCount == 0) {
+		enteredCount++;
+		int prevEndStyled = endStyled;
+		bool didChange = false;
+		for (int iPos = 0; iPos < length; iPos++, stylingPos++) {
+			if (cb.SetStyleAt(stylingPos, styles[iPos], stylingMask)) {
+				didChange = true;
+			}
+		}
+		endStyled = stylingPos;
+		if (didChange) {
+			DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER, 
+				prevEndStyled, endStyled - prevEndStyled);
+			NotifyModified(mh);
+		}
+		enteredCount--;
+	}
+}
+
+bool Document::EnsureStyledTo(int pos) {
+	// Ask the watchers to style, and stop as soon as one responds.
+	for (int i = 0; pos > GetEndStyled() && i < lenWatchers; i++)
+		watchers[i].watcher->NotifyStyleNeeded(this, watchers[i].userData, pos);
+	return pos <= GetEndStyled();
+}
+
+bool Document::AddWatcher(DocWatcher *watcher, void *userData) {
+	for (int i = 0; i < lenWatchers; i++) {
+		if ((watchers[i].watcher == watcher) &&
+		        (watchers[i].userData == userData))
+			return false;
+	}
+	WatcherWithUserData *pwNew = new WatcherWithUserData[lenWatchers + 1];
+	if (!pwNew)
+		return false;
+	for (int j = 0; j < lenWatchers; j++)
+		pwNew[j] = watchers[j];
+	pwNew[lenWatchers].watcher = watcher;
+	pwNew[lenWatchers].userData = userData;
+	delete []watchers;
+	watchers = pwNew;
+	lenWatchers++;
+	return true;
+}
+
+bool Document::RemoveWatcher(DocWatcher *watcher, void *userData) {
+	for (int i = 0; i < lenWatchers; i++) {
+		if ((watchers[i].watcher == watcher) &&
+		        (watchers[i].userData == userData)) {
+			if (lenWatchers == 1) {
+				delete []watchers;
+				watchers = 0;
+				lenWatchers = 0;
+			} else {
+				WatcherWithUserData *pwNew = new WatcherWithUserData[lenWatchers];
+				if (!pwNew)
+					return false;
+				for (int j = 0; j < lenWatchers - 1; j++) {
+					pwNew[j] = (j < i) ? watchers[j] : watchers[j + 1];
+				}
+				delete []watchers;
+				watchers = pwNew;
+				lenWatchers--;
+			}
+			return true;
+		}
+	}
+	return false;
+}
+
+void Document::NotifyModifyAttempt() {
+	for (int i = 0; i < lenWatchers; i++) {
+		watchers[i].watcher->NotifyModifyAttempt(this, watchers[i].userData);
+	}
+}
+
+void Document::NotifySavePoint(bool atSavePoint) {
+	for (int i = 0; i < lenWatchers; i++) {
+		watchers[i].watcher->NotifySavePoint(this, watchers[i].userData, atSavePoint);
+	}
+}
+
+void Document::NotifyModified(DocModification mh) {
+	for (int i = 0; i < lenWatchers; i++) {
+		watchers[i].watcher->NotifyModified(this, mh, watchers[i].userData);
+	}
+}

contrib/src/stc/scintilla/src/Document.h

@@ -0,0 +1,227 @@
+// Scintilla source code edit control
+// Document.h - text document that handles notifications, DBCS, styling, words and end of line
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef DOCUMENT_H
+#define DOCUMENT_H
+
+// A Position is a position within a document between two characters or at the beginning or end.
+// Sometimes used as a character index where it identifies the character after the position.
+typedef int Position;
+const Position invalidPosition = -1;
+
+// The range class represents a range of text in a document.
+// The two values are not sorted as one end may be more significant than the other
+// as is the case for the selection where the end position is the position of the caret.
+// If either position is invalidPosition then the range is invalid and most operations will fail.
+class Range {
+public:
+	Position start;
+	Position end;
+	
+	Range(Position pos=0) : 
+		start(pos), end(pos) {
+	};
+	Range(Position start_, Position end_) : 
+		start(start_), end(end_) {
+	};
+	
+	bool Valid() const {
+		return (start != invalidPosition) && (end != invalidPosition);
+	}
+	
+	bool Contains(Position pos) const {
+		if (start < end) {
+			return (pos >= start && pos <= end);
+		} else {
+			return (pos <= start && pos >= end);
+		}
+	}
+	
+	bool Contains(Range other) const {
+		return Contains(other.start) && Contains(other.end);
+	}
+	
+	bool Overlaps(Range other) const {
+		return 
+		Contains(other.start) ||
+		Contains(other.end) ||
+		other.Contains(start) ||
+		other.Contains(end);
+	}
+};
+
+class DocWatcher;
+class DocModification;
+
+class Document {
+
+public:
+	// Used to pair watcher pointer with user data
+	class WatcherWithUserData {
+	public:
+		DocWatcher *watcher;
+		void *userData;
+		WatcherWithUserData() {
+			watcher = 0;
+			userData = 0;
+		}
+	};
+	
+private:	
+	int refCount;
+	CellBuffer cb;
+	bool wordchars[256];
+	int stylingPos;
+	int stylingMask;
+	int endStyled;
+	int enteredCount;
+	
+	WatcherWithUserData *watchers;
+	int lenWatchers;
+	
+public:
+	int stylingBits;
+	int stylingBitsMask;
+	
+	int eolMode;
+	int dbcsCodePage;
+	int tabInChars;
+	
+	Document();
+	virtual ~Document();
+	
+	int AddRef();
+	int Release();
+ 	
+	int LineFromPosition(int pos);
+	int ClampPositionIntoDocument(int pos);
+	bool IsCrLf(int pos);
+	int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true);
+
+	// Gateways to modifying document
+	void DeleteChars(int pos, int len);
+	void InsertStyledString(int position, char *s, int insertLength);
+	int Undo();
+	int Redo();
+	bool CanUndo() { return cb.CanUndo(); }
+	bool CanRedo() { return cb.CanRedo(); }
+	void DeleteUndoHistory() { cb.DeleteUndoHistory(); }
+	undoCollectionType SetUndoCollection(undoCollectionType collectUndo) {
+		return cb.SetUndoCollection(collectUndo);
+	}
+	void BeginUndoAction() { cb.BeginUndoAction(); }
+	void EndUndoAction() { cb.EndUndoAction(); }
+	void SetSavePoint();
+	bool IsSavePoint() { return cb.IsSavePoint(); }
+	void Indent(bool forwards, int lineBottom, int lineTop);
+	void ConvertLineEnds(int eolModeSet);
+	void SetReadOnly(bool set) { cb.SetReadOnly(set); }
+
+	void InsertChar(int pos, char ch);
+	void InsertString(int position, const char *s);
+	void InsertString(int position, const char *s, int insertLength);
+	void ChangeChar(int pos, char ch);
+	void DelChar(int pos);
+	int DelCharBack(int pos);
+
+	char CharAt(int position) { return cb.CharAt(position); }
+	void GetCharRange(char *buffer, int position, int lengthRetrieve) {
+		cb.GetCharRange(buffer, position, lengthRetrieve);
+	}
+	char StyleAt(int position) { return cb.StyleAt(position); }
+	int GetMark(int line) { return cb.GetMark(line); }
+	int AddMark(int line, int markerNum);
+	void DeleteMark(int line, int markerNum);
+	void DeleteMarkFromHandle(int markerHandle);
+	void DeleteAllMarks(int markerNum);
+	int LineFromHandle(int markerHandle) { return cb.LineFromHandle(markerHandle); }
+	int LineStart(int line);
+	int LineEnd(int line);
+	int LineEndPosition(int position);
+	int VCHomePosition(int position);
+
+	int SetLevel(int line, int level);
+	int GetLevel(int line) { return cb.GetLevel(line); }
+	int GetLastChild(int lineParent, int level=-1);
+	int GetFoldParent(int line);
+
+	void Indent(bool forwards);
+	int ExtendWordSelect(int pos, int delta);
+	int NextWordStart(int pos, int delta);
+	int Length() { return cb.Length(); }
+	long FindText(int minPos, int maxPos, const char *s, bool caseSensitive, bool word);
+	long FindText(WORD iMessage,WPARAM wParam,LPARAM lParam);
+	int LinesTotal();
+	
+	void ChangeCase(Range r, bool makeUpperCase);
+	
+	void SetWordChars(unsigned char *chars);
+	void SetStylingBits(int bits);
+	void StartStyling(int position, char mask);
+	void SetStyleFor(int length, char style);
+	void SetStyles(int length, char *styles);
+	int GetEndStyled() { return endStyled; }
+	bool EnsureStyledTo(int pos);
+
+	int SetLineState(int line, int state) { return cb.SetLineState(line, state); }
+	int GetLineState(int line) { return cb.GetLineState(line); }
+	int GetMaxLineState() { return cb.GetMaxLineState(); }
+		
+	bool AddWatcher(DocWatcher *watcher, void *userData);
+	bool RemoveWatcher(DocWatcher *watcher, void *userData);
+	const WatcherWithUserData *GetWatchers() const { return watchers; }
+	int GetLenWatchers() const { return lenWatchers; }
+	
+private:
+	bool IsDBCS(int pos);
+	bool IsWordChar(unsigned char ch);
+	bool IsWordAt(int start, int end);
+	void ModifiedAt(int pos);
+		
+	void NotifyModifyAttempt();
+	void NotifySavePoint(bool atSavePoint);
+	void NotifyModified(DocModification mh);
+};
+
+// To optimise processing of document modifications by DocWatchers, a hint is passed indicating the 
+// scope of the change.
+// If the DocWatcher is a document view then this can be used to optimise screen updating.
+class DocModification {
+public:
+  	int modificationType;
+	int position;
+ 	int length;
+ 	int linesAdded;	// Negative if lines deleted
+ 	const char *text;	// Only valid for changes to text, not for changes to style
+ 	int line;
+	int foldLevelNow;
+	int foldLevelPrev;
+
+	DocModification(int modificationType_, int position_=0, int length_=0, 
+		int linesAdded_=0, const char *text_=0) :
+		modificationType(modificationType_),
+		position(position_),
+		length(length_),
+		linesAdded(linesAdded_),
+		text(text_),
+		line(0),
+		foldLevelNow(0),
+		foldLevelPrev(0) {}
+};
+
+// A class that wants to receive notifications from a Document must be derived from DocWatcher 
+// and implement the notification methods. It can then be added to the watcher list with AddWatcher.
+class DocWatcher {
+public:
+	virtual ~DocWatcher() {}
+	
+	virtual void NotifyModifyAttempt(Document *doc, void *userData) = 0;
+	virtual void NotifySavePoint(Document *doc, void *userData, bool atSavePoint) = 0;
+	virtual void NotifyModified(Document *doc, DocModification mh, void *userData) = 0;
+	virtual void NotifyDeleted(Document *doc, void *userData) = 0;
+	virtual void NotifyStyleNeeded(Document *doc, void *userData, int endPos) = 0;
+};
+
+#endif

contrib/src/stc/scintilla/src/Editor.h

@@ -0,0 +1,287 @@
+// Scintilla source code edit control
+// Editor.h - defines the main editor class
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef EDITOR_H
+#define EDITOR_H
+
+class Caret {
+public:
+	bool active;
+	bool on;
+	int period;
+		
+	Caret();
+};
+
+class Timer {
+
+public:
+	bool ticking;
+	int ticksToWait;
+	enum {tickSize = 100};
+	int tickerID;
+		
+	Timer();
+};
+
+class LineLayout {
+public:
+	// Drawing is only performed for maxLineLength characters on each line.
+	enum {maxLineLength = 4000};
+	int numCharsInLine;
+	char chars[maxLineLength];
+	char styles[maxLineLength];
+	char indicators[maxLineLength];
+	int positions[maxLineLength];
+};
+
+class Editor : public DocWatcher {
+protected:	// ScintillaBase subclass needs access to much of Editor
+
+	// On GTK+, Scintilla is a container widget holding two scroll bars and a drawing area
+	// whereas on Windows there is just one window with both scroll bars turned on.
+	// Therefore, on GTK+ the following are separate windows but only one window on Windows.
+	Window wMain;	// The Scintilla parent window
+	Window wDraw;	// The text drawing area
+
+	// Style resources may be expensive to allocate so are cached between uses.
+	// When a style attribute is changed, this cache is flushed.
+	bool stylesValid;	
+	ViewStyle vs;
+	Palette palette;
+	
+	bool hideSelection;
+	bool inOverstrike;
+
+	// In bufferedDraw mode, graphics operations are drawn to a pixmap and then copied to 
+	// the screen. This avoids flashing but is about 30% slower.
+	bool bufferedDraw;
+
+	int xOffset;				// Horizontal scrolled amount in pixels
+	int xCaretMargin;	// Ensure this many pixels visible on both sides of caret
+	
+	Surface pixmapLine;
+	Surface pixmapSelMargin;
+	Surface pixmapSelPattern;
+	// Intellimouse support - currently only implemented for Windows
+	unsigned int ucWheelScrollLines;
+	short cWheelDelta; //wheel delta from roll
+
+	KeyMap kmap;
+
+	Caret caret;
+	Timer timer;
+
+	Point lastClick;
+	unsigned int lastClickTime;
+	enum { selChar, selWord, selLine } selectionType;
+	Point ptMouseLast;
+	bool firstExpose;
+	bool inDragDrop;
+	bool dropWentOutside;
+	int posDrag;
+	int posDrop;
+	int lastXChosen;
+	int lineAnchor;
+	int originalAnchorPos;
+	int currentPos;
+	int anchor;
+	int topLine;
+	int posTopLine;
+	
+	bool needUpdateUI;
+	Position braces[2];
+	int bracesMatchStyle;
+	
+	int edgeState;
+	int theEdge;
+
+	enum { notPainting, painting, paintAbandoned } paintState;
+	PRectangle rcPaint;
+	bool paintingAllText;
+	
+	int modEventMask;
+	
+	char *dragChars;
+	int lenDrag;
+	bool dragIsRectangle;
+	enum { selStream, selRectangle, selRectangleFixed } selType;
+	int xStartSelect;
+	int xEndSelect;
+	
+	int caretPolicy;
+	int caretSlop;
+
+	int searchAnchor;
+
+	int displayPopupMenu;
+
+#ifdef MACRO_SUPPORT
+	int recordingMacro;
+#endif
+
+	int foldFlags;
+	ContractionState cs;
+
+	Document *pdoc;
+
+	Editor();
+	virtual ~Editor();
+	virtual void Initialise() = 0;
+	virtual void Finalise();
+
+	void InvalidateStyleData();
+	void InvalidateStyleRedraw();
+	virtual void RefreshColourPalette(Palette &pal, bool want);
+	void RefreshStyleData();
+	void DropGraphics();
+
+	PRectangle GetClientRectangle();
+	PRectangle GetTextRectangle();
+	
+	int LinesOnScreen();
+	int LinesToScroll();
+	int MaxScrollPos();
+	Point LocationFromPosition(unsigned int pos);
+	int XFromPosition(unsigned int pos);
+	int PositionFromLocation(Point pt);
+	int PositionFromLineX(int line, int x);
+	int LineFromLocation(Point pt);
+	void SetTopLine(int topLineNew);
+	
+	void RedrawRect(PRectangle rc);
+	void Redraw();
+	void RedrawSelMargin();
+	PRectangle RectangleFromRange(int start, int end);
+	void InvalidateRange(int start, int end);
+	
+	int CurrentPosition();
+	bool SelectionEmpty();
+	int SelectionStart(int line=-1);
+	int SelectionEnd(int line=-1);
+	void SetSelection(int currentPos_, int anchor_);
+	void SetSelection(int currentPos_);
+	void SetEmptySelection(int currentPos_);
+	int MovePositionTo(int newPos, bool extend = false);
+	int MovePositionSoVisible(int pos, int moveDir);
+	void SetLastXChosen();
+
+	void ScrollTo(int line);
+	virtual void ScrollText(int linesToMove);
+	void HorizontalScrollTo(int xPos);
+	void EnsureCaretVisible(bool useMargin=true);
+	void ShowCaretAtCurrentPosition();
+	void DropCaret();
+	void InvalidateCaret();
+
+	void PaintSelMargin(Surface *surface, PRectangle &rc);
+        void LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout &ll);
+	void DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int xStart, 
+		PRectangle rcLine, LineLayout &ll);
+	void Paint(Surface *surfaceWindow, PRectangle rcArea);
+	long FormatRange(bool draw, FORMATRANGE *pfr);
+
+	virtual void SetVerticalScrollPos() = 0;
+	virtual void SetHorizontalScrollPos() = 0;
+	virtual bool ModifyScrollBars(int nMax, int nPage) = 0;
+	void SetScrollBarsTo(PRectangle rsClient);
+	void SetScrollBars();
+
+	virtual void AddChar(char ch);
+	void ClearSelection();
+	void ClearAll();
+	void Cut();
+	void PasteRectangular(int pos, const char *ptr, int len);
+	virtual void Copy() = 0;
+	virtual void Paste() = 0;
+	void Clear();
+	void SelectAll();
+	void Undo();
+	void Redo();
+	void DelChar();
+	void DelCharBack();
+	virtual void ClaimSelection() = 0;
+
+	virtual void NotifyChange() = 0;
+	virtual void NotifyFocus(bool focus);
+	virtual void NotifyParent(SCNotification scn) = 0;
+	virtual void NotifyStyleNeeded(int endStyleNeeded);
+	void NotifyChar(char ch);
+	void NotifySavePoint(bool isSavePoint);
+	void NotifyModifyAttempt();
+	virtual void NotifyDoubleClick(Point pt, bool shift);
+	void NotifyUpdateUI();
+	bool NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt);
+	void NotifyNeedShown(int pos, int len);
+	
+	void NotifyModifyAttempt(Document *document, void *userData);
+	void NotifySavePoint(Document *document, void *userData, bool atSavePoint);
+	void NotifyModified(Document *document, DocModification mh, void *userData);
+	void NotifyDeleted(Document *document, void *userData);
+	void NotifyStyleNeeded(Document *doc, void *userData, int endPos);
+
+	
+#ifdef MACRO_SUPPORT
+	void NotifyMacroRecord(UINT iMessage, WPARAM wParam, LPARAM lParam);
+#endif
+
+	void PageMove(int direction, bool extend=false);
+	void ChangeCaseOfSelection(bool makeUpperCase);
+	void LineTranspose();
+	virtual int KeyCommand(UINT iMessage);
+	virtual int KeyDefault(int /* key */, int /*modifiers*/);
+	int KeyDown(int key, bool shift, bool ctrl, bool alt);
+
+	bool GetWhitespaceVisible();
+	void SetWhitespaceVisible(bool view);
+
+	void Indent(bool forwards);
+
+	long FindText(UINT iMessage,WPARAM wParam,LPARAM lParam);
+	void SearchAnchor();
+	long SearchText(UINT iMessage,WPARAM wParam,LPARAM lParam);
+	void GoToLine(int lineNo);
+
+	char *CopyRange(int start, int end);
+	int SelectionRangeLength();
+	char *CopySelectionRange();
+	void CopySelectionIntoDrag();
+	void SetDragPosition(int newPos);
+	virtual void StartDrag();
+	void DropAt(int position, const char *value, bool moving, bool rectangular);
+	// PositionInSelection returns 0 if position in selection, -1 if position before selection, and 1 if after.
+	// Before means either before any line of selection or before selection on its line, with a similar meaning to after
+	int PositionInSelection(int pos);
+	bool PointInSelection(Point pt);
+	bool PointInSelMargin(Point pt);
+	virtual void ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt);
+	void ButtonMove(Point pt);
+	void ButtonUp(Point pt, unsigned int curTime, bool ctrl);
+
+	void Tick();
+	virtual void SetTicking(bool on) = 0;
+	virtual void SetMouseCapture(bool on) = 0;
+	virtual bool HaveMouseCapture() = 0;
+
+	void CheckForChangeOutsidePaint(Range r);
+	int BraceMatch(int position, int maxReStyle);
+	void SetBraceHighlight(Position pos0, Position pos1, int matchStyle);
+	
+	void SetDocPointer(Document *document);
+	
+	void Expand(int &line, bool doExpand);
+	void ToggleContraction(int line);
+	void EnsureLineVisible(int line);
+
+	virtual LRESULT DefWndProc(UINT iMessage, WPARAM wParam, LPARAM lParam) = 0;
+	
+public:
+	// Public so scintilla_send_message can use it
+	virtual LRESULT WndProc(UINT iMessage, WPARAM wParam, LPARAM lParam);
+	// Public so scintilla_set_id can use it
+	int ctrlID;	
+};
+
+#endif

contrib/src/stc/scintilla/src/Indicator.cxx

@@ -0,0 +1,45 @@
+// Scintilla source code edit control
+// Indicator.cxx - defines the style of indicators which are text decorations such as underlining
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include "Platform.h"
+
+#include "Scintilla.h"
+#include "Indicator.h"
+
+void Indicator::Draw(Surface *surface, PRectangle &rc) {
+	surface->PenColour(fore.allocated);
+	int ymid = (rc.bottom + rc.top) / 2;
+	if (style == INDIC_SQUIGGLE) {
+		surface->MoveTo(rc.left, rc.top);
+		int x = rc.left + 2;
+		int y = 2;
+		while (x < rc.right) {
+			surface->LineTo(x, rc.top + y);
+			x += 2;
+			y = 2 - y;
+		}
+		surface->LineTo(rc.right, rc.top + y);	// Finish the line
+	} else if (style == INDIC_TT) {
+		surface->MoveTo(rc.left, ymid);
+		int x = rc.left + 5;
+		while (x < rc.right) {
+			surface->LineTo(x, ymid);
+			surface->MoveTo(x-3, ymid);
+			surface->LineTo(x-3, ymid+2);
+			x++;
+			surface->MoveTo(x, ymid);
+			x += 5;
+		}
+		surface->LineTo(rc.right, ymid);	// Finish the line
+		if (x - 3 <= rc.right) {
+			surface->MoveTo(x-3, ymid);
+			surface->LineTo(x-3, ymid+2);
+		}
+	} else {	// Either INDIC_PLAIN or unknown
+		surface->MoveTo(rc.left, ymid);
+		surface->LineTo(rc.right, ymid);
+	}
+}
+

contrib/src/stc/scintilla/src/Indicator.h

@@ -0,0 +1,18 @@
+// Scintilla source code edit control
+// Indicator.h - defines the style of indicators which are text decorations such as underlining
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef INDICATOR_H
+#define INDICATOR_H
+
+class Indicator {
+public:
+	int style;
+	ColourPair fore;
+	Indicator() : style(INDIC_PLAIN), fore(Colour(0,0,0)) {
+	}
+	void Draw(Surface *surface, PRectangle &rc);
+};
+
+#endif

contrib/src/stc/scintilla/src/KeyMap.cxx

@@ -0,0 +1,116 @@
+// Scintilla source code edit control
+// KeyMap.cxx  - defines a mapping between keystrokes and commands
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include "Platform.h"
+
+#include "Scintilla.h"
+
+#include "KeyMap.h"
+
+KeyMap::KeyMap() : kmap(0), len(0), alloc(0) {
+	for (int i = 0; MapDefault[i].key; i++) {
+		AssignCmdKey(MapDefault[i].key, 
+			MapDefault[i].modifiers,
+             		MapDefault[i].msg);
+	}
+}
+
+KeyMap::~KeyMap() {
+	Clear();
+}
+
+void KeyMap::Clear() {
+	delete []kmap;
+	kmap = 0;
+	len = 0;
+	alloc = 0;
+}
+
+void KeyMap::AssignCmdKey(int key, int modifiers, UINT msg) {
+	if ((len+1) >= alloc) {
+		KeyToCommand *ktcNew = new KeyToCommand[alloc + 5];
+		if (!ktcNew)
+			return;
+		for (int k=0;k<len;k++)
+			ktcNew[k] = kmap[k];
+		alloc += 5;
+		delete []kmap;
+		kmap = ktcNew;
+	}
+	for (int keyIndex = 0; keyIndex < len; keyIndex++) {
+		if ((key == kmap[keyIndex].key) && (modifiers == kmap[keyIndex].modifiers)) {
+			kmap[keyIndex].msg = msg;
+			return;
+		}
+	}
+	kmap[len].key = key;
+	kmap[len].modifiers = modifiers;
+	kmap[len].msg = msg;
+	len++;
+}
+
+UINT KeyMap::Find(int key, int modifiers) {
+	for (int i=0; i < len; i++) {
+		if ((key == kmap[i].key) && (modifiers == kmap[i].modifiers)) {
+			return kmap[i].msg;
+		}
+	}
+	return 0;
+}
+
+KeyToCommand KeyMap::MapDefault[] = {
+    VK_DOWN,		SCI_NORM,	SCI_LINEDOWN,
+    VK_DOWN,		SCI_SHIFT,	SCI_LINEDOWNEXTEND,
+    VK_UP,			SCI_NORM,	SCI_LINEUP,
+    VK_UP,			SCI_SHIFT,	SCI_LINEUPEXTEND,
+    VK_LEFT,		SCI_NORM,	SCI_CHARLEFT,
+    VK_LEFT,		SCI_SHIFT,	SCI_CHARLEFTEXTEND,
+    VK_LEFT,		SCI_CTRL,	SCI_WORDLEFT,
+    VK_LEFT,		SCI_CSHIFT,	SCI_WORDLEFTEXTEND,
+    VK_RIGHT,		SCI_NORM,	SCI_CHARRIGHT,
+    VK_RIGHT,		SCI_SHIFT,	SCI_CHARRIGHTEXTEND,
+    VK_RIGHT,		SCI_CTRL,	SCI_WORDRIGHT,
+    VK_RIGHT,		SCI_CSHIFT,	SCI_WORDRIGHTEXTEND,
+    VK_HOME, 		SCI_NORM, 	SCI_VCHOME,
+    VK_HOME, 		SCI_SHIFT, 	SCI_VCHOMEEXTEND,
+    VK_HOME, 		SCI_CTRL, 	SCI_DOCUMENTSTART,
+    VK_HOME, 		SCI_CSHIFT, 	SCI_DOCUMENTSTARTEXTEND,
+    VK_END,	 	SCI_NORM, 	SCI_LINEEND,
+    VK_END,	 	SCI_SHIFT, 	SCI_LINEENDEXTEND,
+    VK_END, 		SCI_CTRL, 	SCI_DOCUMENTEND,
+    VK_END, 		SCI_CSHIFT, 	SCI_DOCUMENTENDEXTEND,
+    VK_PRIOR,		SCI_NORM, 	SCI_PAGEUP,
+    VK_PRIOR,		SCI_SHIFT, 	SCI_PAGEUPEXTEND,
+    VK_NEXT, 		SCI_NORM, 	SCI_PAGEDOWN,
+    VK_NEXT, 		SCI_SHIFT, 	SCI_PAGEDOWNEXTEND,
+    VK_DELETE, 	SCI_NORM,	WM_CLEAR,
+    VK_DELETE, 	SCI_SHIFT,	WM_CUT,
+    VK_DELETE, 	SCI_CTRL,	SCI_DELWORDRIGHT,
+    VK_INSERT, 		SCI_NORM,	SCI_EDITTOGGLEOVERTYPE,
+    VK_INSERT, 		SCI_SHIFT,	WM_PASTE,
+    VK_INSERT, 		SCI_CTRL,	WM_COPY,
+    VK_ESCAPE,  	SCI_NORM,	SCI_CANCEL,
+    VK_BACK,		SCI_NORM, 	SCI_DELETEBACK,
+    VK_BACK,		SCI_CTRL, 	SCI_DELWORDLEFT,
+    'Z', 			SCI_CTRL,	WM_UNDO,
+    'Y', 			SCI_CTRL,	SCI_REDO,
+    'X', 			SCI_CTRL,	WM_CUT,
+    'C', 			SCI_CTRL,	WM_COPY,
+    'V', 			SCI_CTRL,	WM_PASTE,
+    'A', 			SCI_CTRL,	SCI_SELECTALL,
+    VK_TAB,		SCI_NORM,	SCI_TAB,
+    VK_TAB,		SCI_SHIFT,	SCI_BACKTAB,
+    VK_RETURN, 	SCI_NORM,	SCI_NEWLINE,
+    VK_ADD, 		SCI_CTRL,	SCI_ZOOMIN,
+    VK_SUBTRACT,	SCI_CTRL,	SCI_ZOOMOUT,
+    //'L', 			SCI_CTRL,		SCI_FORMFEED,
+    'L', 			SCI_CTRL,	SCI_LINECUT,
+    'L', 			SCI_CSHIFT,	SCI_LINEDELETE,
+    'T', 			SCI_CTRL,	SCI_LINETRANSPOSE,
+    'U', 			SCI_CTRL,	SCI_LOWERCASE,
+    'U', 			SCI_CSHIFT,	SCI_UPPERCASE,
+    0,0,0,
+};
+

contrib/src/stc/scintilla/src/KeyMap.h

@@ -0,0 +1,36 @@
+// Scintilla source code edit control
+// KeyMap.h - defines a mapping between keystrokes and commands
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef KEYTOCOMMAND_H
+#define KEYTOCOMMAND_H
+
+#define SCI_NORM 0
+#define SCI_SHIFT SHIFT_PRESSED
+#define SCI_CTRL LEFT_CTRL_PRESSED
+#define SCI_ALT LEFT_ALT_PRESSED
+#define SCI_CSHIFT (SCI_CTRL | SCI_SHIFT)
+#define SCI_ASHIFT (SCI_ALT | SCI_SHIFT)
+
+class KeyToCommand {
+public:
+	int key;
+	int modifiers;
+	UINT msg;
+};
+
+class KeyMap {
+	KeyToCommand *kmap;
+	int len;
+	int alloc;
+	static KeyToCommand MapDefault[];
+public:
+	KeyMap();
+	~KeyMap();
+	void Clear();
+	void AssignCmdKey(int key, int modifiers, UINT msg);
+	UINT Find(int key, int modifiers);	// 0 returned on failure
+};
+
+#endif

contrib/src/stc/scintilla/src/KeyWords.cxx

@@ -0,0 +1,45 @@
+// SciTE - Scintilla based Text Editor
+// KeyWords.cxx - colourise for particular languages
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h> 
+#include <string.h> 
+#include <ctype.h> 
+#include <stdio.h> 
+#include <stdarg.h> 
+
+#include "Platform.h"
+
+#include "PropSet.h"
+#include "Accessor.h"
+#include "KeyWords.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+LexerModule *LexerModule::base = 0;
+
+LexerModule::LexerModule(int language_, LexerFunction fn_) :
+	language(language_), fn(fn_) {
+	next = base;
+	base = this;
+}
+
+void LexerModule::Colourise(unsigned int startPos, int lengthDoc, int initStyle,
+		int language, WordList *keywordlists[], StylingContext &styler) {
+	LexerModule *lm = base;
+	while (lm) {
+		if (lm->language == language) {
+			lm->fn(startPos, lengthDoc, initStyle, keywordlists, styler);
+			return;
+		}
+		lm = lm->next;
+	}
+	// Unknown language
+	// Null language means all style bytes are 0 so just mark the end - no need to fill in.
+	if (lengthDoc > 0) {
+		styler.StartAt(startPos + lengthDoc - 1);
+		styler.StartSegment(startPos + lengthDoc - 1);
+		styler.ColourTo(startPos + lengthDoc - 1, 0);
+	}
+}

contrib/src/stc/scintilla/src/LexCPP.cxx

@@ -0,0 +1,255 @@
+// SciTE - Scintilla based Text Editor
+// LexCPP.cxx - lexer for C++, C, Java, and Javascript
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h> 
+#include <string.h> 
+#include <ctype.h> 
+#include <stdio.h> 
+#include <stdarg.h> 
+
+#include "Platform.h"
+
+#include "PropSet.h"
+#include "Accessor.h"
+#include "KeyWords.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+static bool classifyWordCpp(unsigned int start, unsigned int end, WordList &keywords, StylingContext &styler) {
+	char s[100];
+	bool wordIsNumber = isdigit(styler[start]) || (styler[start] == '.');
+	bool wordIsUUID = false;
+	for (unsigned int i = 0; i < end - start + 1 && i < 30; i++) {
+		s[i] = styler[start + i];
+		s[i + 1] = '\0';
+	}
+	char chAttr = SCE_C_IDENTIFIER;
+	if (wordIsNumber)
+		chAttr = SCE_C_NUMBER;
+	else {
+		if (keywords.InList(s)) {
+			chAttr = SCE_C_WORD;
+			wordIsUUID = strcmp(s, "uuid") == 0; 
+		}
+	}
+	styler.ColourTo(end, chAttr);
+	return wordIsUUID;
+}
+
+static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], 
+	StylingContext &styler) {
+	
+	WordList &keywords = *keywordlists[0];
+	
+	styler.StartAt(startPos);
+	
+	bool fold = styler.GetPropSet().GetInt("fold");
+	int lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+
+	int state = initStyle;
+	char chPrev = ' ';
+	char chNext = styler[startPos];
+	unsigned int lengthDoc = startPos + length;
+	int visChars = 0;
+	styler.StartSegment(startPos);
+	bool lastWordWasUUID = false;
+	for (unsigned int i = startPos; i <= lengthDoc; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+
+		if ((fold) && ((ch == '\r' && chNext != '\n') || (ch == '\n'))) {
+			int lev = levelPrev;
+			if (visChars == 0)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev) && (visChars > 0))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			styler.SetLevel(lineCurrent, lev);
+			lineCurrent++;
+			visChars = 0;
+			levelPrev = levelCurrent;
+		}
+		if (!isspace(ch))
+			visChars++;
+
+		if (styler.IsLeadByte(ch)) {
+			chNext = styler.SafeGetCharAt(i + 2);
+			chPrev = ' ';
+			i += 1;
+			continue;
+		}
+
+		if (state == SCE_C_STRINGEOL) {
+			if (ch != '\r' && ch != '\n') {
+				styler.ColourTo(i-1, state);
+				state = SCE_C_DEFAULT;
+			}
+		}
+		if (state == SCE_C_DEFAULT) {
+			if (iswordstart(ch)) {
+				styler.ColourTo(i-1, state);
+				if (lastWordWasUUID) {
+					state = SCE_C_UUID;
+					lastWordWasUUID = false;
+				} else {
+					state = SCE_C_WORD;
+				}
+			} else if (ch == '/' && chNext == '*') {
+				styler.ColourTo(i-1, state);
+				if (styler.SafeGetCharAt(i + 2) == '*')
+					state = SCE_C_COMMENTDOC;
+				else
+					state = SCE_C_COMMENT;
+			} else if (ch == '/' && chNext == '/') {
+				styler.ColourTo(i-1, state);
+				state = SCE_C_COMMENTLINE;
+			} else if (ch == '\"') {
+				styler.ColourTo(i-1, state);
+				state = SCE_C_STRING;
+			} else if (ch == '\'') {
+				styler.ColourTo(i-1, state);
+				state = SCE_C_CHARACTER;
+			} else if (ch == '#') {
+				styler.ColourTo(i-1, state);
+				state = SCE_C_PREPROCESSOR;
+			} else if (isoperator(ch)) {
+				styler.ColourTo(i-1, state);
+				styler.ColourTo(i, SCE_C_OPERATOR);
+				if ((ch == '{') || (ch == '}')) {
+					levelCurrent += (ch == '{') ? 1 : -1;
+				}
+			}
+		} else if (state == SCE_C_WORD) {
+			if (!iswordchar(ch)) {
+				lastWordWasUUID = classifyWordCpp(styler.GetStartSegment(), i - 1, keywords, styler);
+				state = SCE_C_DEFAULT;
+				if (ch == '/' && chNext == '*') {
+					if (styler.SafeGetCharAt(i + 2) == '*')
+						state = SCE_C_COMMENTDOC;
+					else
+						state = SCE_C_COMMENT;
+				} else if (ch == '/' && chNext == '/') {
+					state = SCE_C_COMMENTLINE;
+				} else if (ch == '\"') {
+					state = SCE_C_STRING;
+				} else if (ch == '\'') {
+					state = SCE_C_CHARACTER;
+				} else if (ch == '#') {
+					state = SCE_C_PREPROCESSOR;
+				} else if (isoperator(ch)) {
+					styler.ColourTo(i, SCE_C_OPERATOR);
+					if ((ch == '{') || (ch == '}')) {
+						levelCurrent += (ch == '{') ? 1 : -1;
+					}
+				}
+			}
+		} else {
+			if (state == SCE_C_PREPROCESSOR) {
+				if ((ch == '\r' || ch == '\n') && (chPrev != '\\')) {
+					styler.ColourTo(i-1, state);
+					state = SCE_C_DEFAULT;
+				}
+			} else if (state == SCE_C_COMMENT) {
+				if (ch == '/' && chPrev == '*') {
+					if (((i > styler.GetStartSegment() + 2) || (
+						(initStyle == SCE_C_COMMENT) && 
+						(styler.GetStartSegment() == static_cast<unsigned int>(startPos))))) {
+						styler.ColourTo(i, state);
+						state = SCE_C_DEFAULT;
+					}
+				}
+			} else if (state == SCE_C_COMMENTDOC) {
+				if (ch == '/' && chPrev == '*') {
+					if (((i > styler.GetStartSegment() + 3) || (
+						(initStyle == SCE_C_COMMENTDOC) && 
+						(styler.GetStartSegment() == static_cast<unsigned int>(startPos))))) {
+						styler.ColourTo(i, state);
+						state = SCE_C_DEFAULT;
+					}
+				}
+			} else if (state == SCE_C_COMMENTLINE) {
+				if (ch == '\r' || ch == '\n') {
+					styler.ColourTo(i-1, state);
+					state = SCE_C_DEFAULT;
+				}
+			} else if (state == SCE_C_STRING) {
+				if ((ch == '\r' || ch == '\n') && (chPrev != '\\')) {
+					styler.ColourTo(i-1, state);
+					state = SCE_C_STRINGEOL;
+				} else if (ch == '\\') {
+					if (chNext == '\"' || chNext == '\'' || chNext == '\\') {
+						i++;
+						ch = chNext;
+						chNext = styler.SafeGetCharAt(i + 1);
+					}
+				} else if (ch == '\"') {
+					styler.ColourTo(i, state);
+					state = SCE_C_DEFAULT;
+					i++;
+					ch = chNext;
+					chNext = styler.SafeGetCharAt(i + 1);
+				}
+			} else if (state == SCE_C_CHARACTER) {
+				if ((ch == '\r' || ch == '\n') && (chPrev != '\\')) {
+					styler.ColourTo(i-1, state);
+					state = SCE_C_STRINGEOL;
+				} else if (ch == '\\') {
+					if (chNext == '\"' || chNext == '\'' || chNext == '\\') {
+						i++;
+						ch = chNext;
+						chNext = styler.SafeGetCharAt(i + 1);
+					}
+				} else if (ch == '\'') {
+					styler.ColourTo(i, state);
+					state = SCE_C_DEFAULT;
+					i++;
+					ch = chNext;
+					chNext = styler.SafeGetCharAt(i + 1);
+				}
+			} else if (state == SCE_C_UUID) {
+				if (ch == '\r' || ch == '\n' || ch == ')') {
+					styler.ColourTo(i-1, state);
+					state = SCE_C_DEFAULT;
+				}
+			}
+			if (state == SCE_C_DEFAULT) {    // One of the above succeeded
+				if (ch == '/' && chNext == '*') {
+					if (styler.SafeGetCharAt(i + 2) == '*')
+						state = SCE_C_COMMENTDOC;
+					else
+						state = SCE_C_COMMENT;
+				} else if (ch == '/' && chNext == '/') {
+					state = SCE_C_COMMENTLINE;
+				} else if (ch == '\"') {
+					state = SCE_C_STRING;
+				} else if (ch == '\'') {
+					state = SCE_C_CHARACTER;
+				} else if (ch == '#') {
+					state = SCE_C_PREPROCESSOR;
+				} else if (iswordstart(ch)) {
+					state = SCE_C_WORD;
+				} else if (isoperator(ch)) {
+					styler.ColourTo(i, SCE_C_OPERATOR);
+					if ((ch == '{') || (ch == '}')) {
+						levelCurrent += (ch == '{') ? 1 : -1;
+					}
+				}
+			}
+		}
+		chPrev = ch;
+	}
+	styler.ColourTo(lengthDoc - 1, state);
+
+	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
+	if (fold) {
+		int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+		//styler.SetLevel(lineCurrent, levelCurrent | flagsNext);
+		styler.SetLevel(lineCurrent, levelPrev | flagsNext);
+		
+	}
+}
+
+LexerModule lmCPP(SCLEX_CPP, ColouriseCppDoc);

contrib/src/stc/scintilla/src/LexOthers.cxx

@@ -0,0 +1,200 @@
+// SciTE - Scintilla based Text Editor
+// LexOthers.cxx - lexers for properties files, batch files, make files and error lists
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h> 
+#include <string.h> 
+#include <ctype.h> 
+#include <stdio.h> 
+#include <stdarg.h> 
+
+#include "Platform.h"
+
+#include "PropSet.h"
+#include "Accessor.h"
+#include "KeyWords.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+static void ColouriseBatchLine(char *lineBuffer, int endLine, StylingContext &styler) {
+	if (0 == strncmp(lineBuffer, "REM", 3)) {
+		styler.ColourTo(endLine, 1);
+	} else if (0 == strncmp(lineBuffer, "rem", 3)) {
+		styler.ColourTo(endLine, 1);
+	} else if (0 == strncmp(lineBuffer, "SET", 3)) {
+		styler.ColourTo(endLine, 2);
+	} else if (0 == strncmp(lineBuffer, "set", 3)) {
+		styler.ColourTo(endLine, 2);
+	} else if (lineBuffer[0] == ':') {
+		styler.ColourTo(endLine, 3);
+	} else {
+		styler.ColourTo(endLine, 0);
+	}
+}
+
+static void ColouriseBatchDoc(unsigned int startPos, int length, int, WordList *[], StylingContext &styler) {
+	char lineBuffer[1024];
+	styler.StartAt(startPos);
+	styler.StartSegment(startPos);
+	unsigned int linePos = 0;
+	for (unsigned int i = startPos; i < startPos + length; i++) {
+		lineBuffer[linePos++] = styler[i];
+		if (styler[i] == '\r' || styler[i] == '\n' || (linePos >= sizeof(lineBuffer) - 1)) {
+			ColouriseBatchLine(lineBuffer, i, styler);
+			linePos = 0;
+		}
+	}
+	if (linePos > 0)
+		ColouriseBatchLine(lineBuffer, startPos + length, styler);
+}
+
+static void ColourisePropsLine(char *lineBuffer, int lengthLine, int startLine, int endPos, StylingContext &styler) {
+	int i = 0;
+	while (isspace(lineBuffer[i]) && (i < lengthLine))	// Skip initial spaces
+		i++;
+	if (lineBuffer[i] == '#' || lineBuffer[i] == '!' || lineBuffer[i] == ';') {
+		styler.ColourTo(endPos, 1);
+	} else if (lineBuffer[i] == '[') {
+		styler.ColourTo(endPos, 2);
+	} else if (lineBuffer[i] == '@') {
+		styler.ColourTo(startLine+i, 4);
+		if (lineBuffer[++i] == '=')
+			styler.ColourTo(startLine+i, 3);
+		styler.ColourTo(endPos, 0);
+	} else {
+		while (lineBuffer[i] != '=' && (i < lengthLine))	// Search the '=' character
+			i++;
+		if (lineBuffer[i] == '=') {
+			styler.ColourTo(startLine+i-1, 0);
+			styler.ColourTo(startLine+i, 3);
+			styler.ColourTo(endPos, 0);
+		} else {
+			styler.ColourTo(endPos, 0);
+		}
+	}
+}
+
+static void ColourisePropsDoc(unsigned int startPos, int length, int, WordList *[], StylingContext &styler) {
+	char lineBuffer[1024];
+	styler.StartAt(startPos);
+	styler.StartSegment(startPos);
+	unsigned int linePos = 0;
+	int startLine = startPos;
+	for (unsigned int i = startPos; i <= startPos + length; i++) {
+		lineBuffer[linePos++] = styler[i];
+		if ((styler[i] == '\r' && styler.SafeGetCharAt(i+1) != '\n') || 
+			styler[i] == '\n' || 
+			(linePos >= sizeof(lineBuffer) - 1)) {
+			lineBuffer[linePos] = '\0';
+			ColourisePropsLine(lineBuffer, linePos, startLine, i, styler);
+			linePos = 0;
+			startLine = i+1;
+		}
+	}
+	if (linePos > 0)
+		ColourisePropsLine(lineBuffer, linePos, startLine, startPos + length, styler);
+}
+
+static void ColouriseMakeLine(char *lineBuffer, int lengthLine, int endPos, StylingContext &styler) {
+	int i = 0;
+	while (isspace(lineBuffer[i]) && (i < lengthLine))
+		i++;
+	if (lineBuffer[i] == '#' || lineBuffer[i] == '!') {
+		styler.ColourTo(endPos, 1);
+	} else {
+		styler.ColourTo(endPos, 0);
+	}
+}
+
+static void ColouriseMakeDoc(unsigned int startPos, int length, int, WordList *[], StylingContext &styler) {
+	char lineBuffer[1024];
+	styler.StartAt(startPos);
+	styler.StartSegment(startPos);
+	unsigned int linePos = 0;
+	for (unsigned int i = startPos; i <= startPos + length; i++) {
+		lineBuffer[linePos++] = styler[i];
+		if (styler[i] == '\r' || styler[i] == '\n' || (linePos >= sizeof(lineBuffer) - 1)) {
+			ColouriseMakeLine(lineBuffer, linePos, i, styler);
+			linePos = 0;
+		}
+	}
+	if (linePos > 0)
+		ColouriseMakeLine(lineBuffer, linePos, startPos + length, styler);
+}
+
+static void ColouriseErrorListLine(char *lineBuffer, int lengthLine, int endPos, StylingContext &styler) {
+	if (lineBuffer[0] == '>') {
+		// Command or return status
+		styler.ColourTo(endPos, 4);
+	} else if (strstr(lineBuffer, "File \"") && strstr(lineBuffer, ", line ")) {
+		styler.ColourTo(endPos, 1);
+	} else if (0 == strncmp(lineBuffer, "Error ", strlen("Error "))) {
+		// Borland error message
+		styler.ColourTo(endPos, 5);
+	} else if (0 == strncmp(lineBuffer, "Warning ", strlen("Warning "))) {
+		// Borland warning message
+		styler.ColourTo(endPos, 5);
+	} else {
+		// Look for <filename>:<line>:message
+		// Look for <filename>(line)message
+		// Look for <filename>(line,pos)message
+		int state = 0;
+		for (int i = 0; i < lengthLine; i++) {
+			if (state == 0 && lineBuffer[i] == ':' && isdigit(lineBuffer[i + 1])) {
+				state = 1;
+			} else if (state == 0 && lineBuffer[i] == '(') {
+				state = 10;
+			} else if (state == 1 && isdigit(lineBuffer[i])) {
+				state = 2;
+			} else if (state == 2 && lineBuffer[i] == ':') {
+				state = 3;
+				break;
+			} else if (state == 2 && !isdigit(lineBuffer[i])) {
+				state = 99;
+			} else if (state == 10 && isdigit(lineBuffer[i])) {
+				state = 11;
+			} else if (state == 11 && lineBuffer[i] == ',') {
+				state = 14;
+			} else if (state == 11 && lineBuffer[i] == ')') {
+				state = 12;
+				break;
+			} else if (state == 12 && lineBuffer[i] == ':') {
+				state = 13;
+			} else if (state == 14 && lineBuffer[i] == ')') {
+				state = 15;
+				break;
+			} else if (((state == 11) || (state == 14)) && !((lineBuffer[i] == ' ') || isdigit(lineBuffer[i]))) {
+				state = 99;
+			}
+		}
+		if (state == 3) {
+			styler.ColourTo(endPos, 2);
+		} else if ((state == 14) || (state == 15)) {
+			styler.ColourTo(endPos, 3);
+		} else {
+			styler.ColourTo(endPos, 0);
+		}
+	}
+}
+
+static void ColouriseErrorListDoc(unsigned int startPos, int length, int, WordList *[], StylingContext &styler) {
+	char lineBuffer[1024];
+	styler.StartAt(startPos);
+	styler.StartSegment(startPos);
+	unsigned int linePos = 0;
+	for (unsigned int i = startPos; i <= startPos + length; i++) {
+		lineBuffer[linePos++] = styler[i];
+		if (styler[i] == '\r' || styler[i] == '\n' || (linePos >= sizeof(lineBuffer) - 1)) {
+			ColouriseErrorListLine(lineBuffer, linePos, i, styler);
+			linePos = 0;
+		}
+	}
+	if (linePos > 0)
+		ColouriseErrorListLine(lineBuffer, linePos, startPos + length, styler);
+}
+
+LexerModule lmProps(SCLEX_PROPERTIES, ColourisePropsDoc);
+LexerModule lmErrorList(SCLEX_ERRORLIST, ColouriseErrorListDoc);
+LexerModule lmMake(SCLEX_MAKEFILE, ColouriseMakeDoc);
+LexerModule lmBatch(SCLEX_BATCH, ColouriseBatchDoc);

contrib/src/stc/scintilla/src/LexPerl.cxx

@@ -0,0 +1,488 @@
+// SciTE - Scintilla based Text Editor
+// LexPerl.cxx - lexer for subset of Perl
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h> 
+#include <string.h> 
+#include <ctype.h> 
+#include <stdio.h> 
+#include <stdarg.h> 
+
+#include "Platform.h"
+
+#include "PropSet.h"
+#include "Accessor.h"
+#include "KeyWords.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+inline bool isPerlOperator(char ch) {
+	if (isalnum(ch))
+		return false;
+	// '.' left out as it is used to make up numbers
+	if (ch == '%' || ch == '^' || ch == '&' || ch == '*' || ch == '\\' ||
+	        ch == '(' || ch == ')' || ch == '-' || ch == '+' ||
+	        ch == '=' || ch == '|' || ch == '{' || ch == '}' ||
+	        ch == '[' || ch == ']' || ch == ':' || ch == ';' ||
+	        ch == '<' || ch == '>' || ch == ',' || ch == '/' ||
+	        ch == '?' || ch == '!' || ch == '.' || ch == '~')
+		return true;
+	return false;
+}
+
+static int classifyWordPerl(unsigned int start, unsigned int end, WordList &keywords, StylingContext &styler) {
+	char s[100];
+	bool wordIsNumber = isdigit(styler[start]) || (styler[start] == '.');
+	for (unsigned int i = 0; i < end - start + 1 && i < 30; i++) {
+		s[i] = styler[start + i];
+		s[i + 1] = '\0';
+	}
+	char chAttr = SCE_PL_IDENTIFIER;
+	if (wordIsNumber)
+		chAttr = SCE_PL_NUMBER;
+	else {
+		if (keywords.InList(s))
+			chAttr = SCE_PL_WORD;
+	}
+	styler.ColourTo(end, chAttr);
+	return chAttr;
+}
+
+static bool isEndVar(char ch) {
+	return !isalnum(ch) && ch != '#' && ch != '$' &&
+	       ch != '_' && ch != '\'';
+}
+
+static bool isMatch(StylingContext &styler, int lengthDoc, int pos, const char *val) {
+	if ((pos + static_cast<int>(strlen(val))) >= lengthDoc) {
+		return false;
+	}
+	while (*val) {
+		if (*val != styler[pos++]) {
+			return false;
+		}
+		val++;
+	}
+	return true;
+}
+
+static bool isOKQuote(char ch) {
+	if (isalnum(ch))
+		return false;
+	if (isspace(ch))
+		return false;
+	if (iscntrl(ch))
+		return false;
+	return true;
+}
+
+static char opposite(char ch) {
+	if (ch == '(')
+		return ')';
+	if (ch == '[')
+		return ']';
+	if (ch == '{')
+		return '}';
+	if (ch == '<')
+		return '>';
+	return ch;
+}
+
+static void ColourisePerlDoc(unsigned int startPos, int length, int initStyle,
+                             WordList *keywordlists[], StylingContext &styler) {
+
+	// Lexer for perl often has to backtrack to start of current style to determine
+	// which characters are being used as quotes, how deeply nested is the
+	// start position and what the termination string is for here documents
+	
+	WordList &keywords = *keywordlists[0];
+	
+	char sooked[100];
+	int quotes = 0;
+	char quoteDown = 'd';
+	char quoteUp = 'd';
+	int quoteRep = 1;
+	int sookedpos = 0;
+	bool preferRE = true;
+	sooked[sookedpos] = '\0';
+	int state = initStyle;
+	int lengthDoc = startPos + length;
+	// If in a long distance lexical state, seek to the beginning  to find quote characters
+	if (state == SCE_PL_HERE || state == SCE_PL_REGEX || 
+		state == SCE_PL_REGSUBST || state == SCE_PL_LONGQUOTE) {
+		while ((startPos > 1) && (styler.StyleAt(startPos - 1) == state)) {
+			startPos--;
+		}
+		state = SCE_PL_DEFAULT;
+	}
+	styler.StartAt(startPos);
+	char chPrev = ' ';
+	char chNext = styler[startPos];
+	styler.StartSegment(startPos);
+	for (int i = startPos; i <= lengthDoc; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		char chNext2 = styler.SafeGetCharAt(i + 2);
+
+		if (styler.IsLeadByte(ch)) {
+			chNext = styler.SafeGetCharAt(i + 2);
+			chPrev = ' ';
+			i += 1;
+			continue;
+		}
+
+		if (state == SCE_PL_DEFAULT) {
+			if (iswordstart(ch)) {
+				styler.ColourTo(i - 1, state);
+				if (ch == 's' && !isalnum(chNext)) {
+					state = SCE_PL_REGSUBST;
+					quotes = 0;
+					quoteUp = '\0';
+					quoteDown = '\0';
+					quoteRep = 2;
+				} else if (ch == 'm' && !isalnum(chNext)) {
+					state = SCE_PL_REGEX;
+					quotes = 0;
+					quoteUp = '\0';
+					quoteDown = '\0';
+					quoteRep = 1;
+				} else if (ch == 't' && chNext == 'r' && !isalnum(chNext2)) {
+					state = SCE_PL_REGSUBST;
+					quotes = 0;
+					quoteUp = '\0';
+					quoteDown = '\0';
+					quoteRep = 2;
+					i++;
+					chNext = chNext2;
+				} else if (ch == 'q' && (chNext == 'q' || chNext == 'r' || chNext == 'w' || chNext == 'x') && !isalnum(chNext2)) {
+					state = SCE_PL_LONGQUOTE;
+					i++;
+					chNext = chNext2;
+					quotes = 0;
+					quoteUp = '\0';
+					quoteDown = '\0';
+					quoteRep = 1;
+				} else {
+					state = SCE_PL_WORD;
+					preferRE = false;
+				}
+			} else if (ch == '#') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_PL_COMMENTLINE;
+			} else if (ch == '\"') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_PL_STRING;
+			} else if (ch == '\'') {
+				if (chPrev == '&') {
+					// Archaic call
+					styler.ColourTo(i, state);
+				} else {
+					styler.ColourTo(i - 1, state);
+					state = SCE_PL_CHARACTER;
+				}
+			} else if (ch == '`') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_PL_BACKTICKS;
+			} else if (ch == '$') {
+				preferRE = false;
+				styler.ColourTo(i - 1, state);
+				if (isalnum(chNext) || chNext == '#' || chNext == '$' || chNext == '_') {
+					state = SCE_PL_SCALAR;
+				} else if (chNext != '{' && chNext != '[') {
+					styler.ColourTo(i, SCE_PL_SCALAR);
+					i++;
+					ch = ' ';
+					chNext = ' ';
+				} else {
+					styler.ColourTo(i, SCE_PL_SCALAR);
+				}
+			} else if (ch == '@') {
+				preferRE = false;
+				styler.ColourTo(i - 1, state);
+				if (isalpha(chNext) || chNext == '#' || chNext == '$' || chNext == '_') {
+					state = SCE_PL_ARRAY;
+				} else if (chNext != '{' && chNext != '[') {
+					styler.ColourTo(i, SCE_PL_ARRAY);
+					i++;
+					ch = ' ';
+				} else {
+					styler.ColourTo(i, SCE_PL_ARRAY);
+				}
+			} else if (ch == '%') {
+				preferRE = false;
+				styler.ColourTo(i - 1, state);
+				if (isalpha(chNext) || chNext == '#' || chNext == '$' || chNext == '_') {
+					state = SCE_PL_HASH;
+				} else if (chNext != '{' && chNext != '[') {
+					styler.ColourTo(i, SCE_PL_HASH);
+					i++;
+					ch = ' ';
+				} else {
+					styler.ColourTo(i, SCE_PL_HASH);
+				}
+			} else if (ch == '*') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_PL_SYMBOLTABLE;
+			} else if (ch == '/' && preferRE) {
+				styler.ColourTo(i - 1, state);
+				state = SCE_PL_REGEX;
+				quoteUp = '/';
+				quoteDown = '/';
+				quotes = 1;
+				quoteRep = 1;
+			} else if (ch == '<' && chNext == '<') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_PL_HERE;
+				i++;
+				ch = chNext;
+				chNext = chNext2;
+				quotes = 0;
+				sookedpos = 0;
+				sooked[sookedpos] = '\0';
+			} else if (ch == '=' && isalpha(chNext)) {
+				styler.ColourTo(i - 1, state);
+				state = SCE_PL_POD;
+				quotes = 0;
+				sookedpos = 0;
+				sooked[sookedpos] = '\0';
+			} else if (isPerlOperator(ch)) {
+				if (ch == ')' || ch == ']')
+					preferRE = false;
+				else
+					preferRE = true;
+				styler.ColourTo(i - 1, state);
+				styler.ColourTo(i, SCE_PL_OPERATOR);
+			}
+		} else if (state == SCE_PL_WORD) {
+			if (!iswordchar(ch) && ch != '\'') {	// Archaic Perl has quotes inside names
+				if (isMatch(styler, lengthDoc, styler.GetStartSegment(), "__DATA__")) {
+					styler.ColourTo(i, SCE_PL_DATASECTION);
+					state = SCE_PL_DATASECTION;
+				} else if (isMatch(styler, lengthDoc, styler.GetStartSegment(), "__END__")) {
+					styler.ColourTo(i, SCE_PL_DATASECTION);
+					state = SCE_PL_DATASECTION;
+				} else {
+					if (classifyWordPerl(styler.GetStartSegment(), i - 1, keywords, styler) == SCE_PL_WORD)
+						preferRE = true;
+					state = SCE_PL_DEFAULT;
+					if (ch == '#') {
+						state = SCE_PL_COMMENTLINE;
+					} else if (ch == '\"') {
+						state = SCE_PL_STRING;
+					} else if (ch == '\'') {
+						state = SCE_PL_CHARACTER;
+					} else if (ch == '<' && chNext == '<') {
+						state = SCE_PL_HERE;
+						quotes = 0;
+						sookedpos = 0;
+						sooked[sookedpos] = '\0';
+					} else if (isPerlOperator(ch)) {
+						if (ch == ')' || ch == ']')
+							preferRE = false;
+						else
+							preferRE = true;
+						styler.ColourTo(i, SCE_PL_OPERATOR);
+						state = SCE_PL_DEFAULT;
+					}
+				}
+			}
+		} else {
+			if (state == SCE_PL_COMMENTLINE) {
+				if (ch == '\r' || ch == '\n') {
+					styler.ColourTo(i - 1, state);
+					state = SCE_PL_DEFAULT;
+				}
+			} else if (state == SCE_PL_HERE) {
+				if (isalnum(ch) && quotes < 2) {
+					sooked[sookedpos++] = ch;
+					sooked[sookedpos] = '\0';
+					if (quotes == 0)
+						quotes = 1;
+				} else {
+					quotes++;
+				}
+
+				if (quotes > 1 && isMatch(styler, lengthDoc, i, sooked)) {
+					styler.ColourTo(i + sookedpos - 1, SCE_PL_HERE);
+					state = SCE_PL_DEFAULT;
+					i += sookedpos;
+					chNext = ' ';
+				}
+			} else if (state == SCE_PL_STRING) {
+				if (ch == '\\') {
+					if (chNext == '\"' || chNext == '\'' || chNext == '\\') {
+						i++;
+						ch = chNext;
+						chNext = styler.SafeGetCharAt(i + 1);
+					}
+				} else if (ch == '\"') {
+					styler.ColourTo(i, state);
+					state = SCE_PL_DEFAULT;
+					i++;
+					ch = chNext;
+					chNext = styler.SafeGetCharAt(i + 1);
+				}
+			} else if (state == SCE_PL_CHARACTER) {
+				if (ch == '\\') {
+					if (chNext == '\"' || chNext == '\'' || chNext == '\\') {
+						i++;
+						ch = chNext;
+						chNext = styler.SafeGetCharAt(i + 1);
+					}
+				} else if (ch == '\'') {
+					styler.ColourTo(i, state);
+					state = SCE_PL_DEFAULT;
+					i++;
+					ch = chNext;
+					chNext = styler.SafeGetCharAt(i + 1);
+				}
+			} else if (state == SCE_PL_BACKTICKS) {
+				if (ch == '`') {
+					styler.ColourTo(i, state);
+					state = SCE_PL_DEFAULT;
+					i++;
+					ch = chNext;
+					chNext = styler.SafeGetCharAt(i + 1);
+				}
+			} else if (state == SCE_PL_POD) {
+				if (ch == '=') {
+					if (isMatch(styler, lengthDoc, i, "=cut")) {
+						styler.ColourTo(i - 1 + 4, state);
+						i += 4;
+						state = SCE_PL_DEFAULT;
+						chNext = ' ';
+						ch = ' ';
+					}
+				}
+			} else if (state == SCE_PL_SCALAR) {
+				if (isEndVar(ch)) {
+					styler.ColourTo(i - 1, state);
+					state = SCE_PL_DEFAULT;
+				}
+			} else if (state == SCE_PL_ARRAY) {
+				if (isEndVar(ch)) {
+					styler.ColourTo(i - 1, state);
+					state = SCE_PL_DEFAULT;
+				}
+			} else if (state == SCE_PL_HASH) {
+				if (isEndVar(ch)) {
+					styler.ColourTo(i - 1, state);
+					state = SCE_PL_DEFAULT;
+				}
+			} else if (state == SCE_PL_SYMBOLTABLE) {
+				if (isEndVar(ch)) {
+					styler.ColourTo(i - 1, state);
+					state = SCE_PL_DEFAULT;
+				}
+			} else if (state == SCE_PL_REF) {
+				if (isEndVar(ch)) {
+					styler.ColourTo(i - 1, state);
+					state = SCE_PL_DEFAULT;
+				}
+			} else if (state == SCE_PL_REGEX) {
+				if (!quoteUp && !isspace(ch)) {
+					quoteUp = ch;
+					quoteDown = opposite(ch);
+					quotes++;
+				} else {
+					if (ch == quoteDown && chPrev != '\\') {
+						quotes--;
+						if (quotes == 0) {
+							quoteRep--;
+							if (quoteUp == quoteDown) {
+								quotes++;
+							}
+						}
+						if (!isalpha(chNext)) {
+							if (quoteRep <= 0) {
+								styler.ColourTo(i, state);
+								state = SCE_PL_DEFAULT;
+								ch = ' ';
+							}
+						}
+					} else if (ch == quoteUp && chPrev != '\\') {
+						quotes++;
+					} else if (!isalpha(chNext)) {
+						if (quoteRep <= 0) {
+							styler.ColourTo(i, state);
+							state = SCE_PL_DEFAULT;
+							ch = ' ';
+						}
+					}
+				}
+			} else if (state == SCE_PL_REGSUBST) {
+				if (!quoteUp && !isspace(ch)) {
+					quoteUp = ch;
+					quoteDown = opposite(ch);
+					quotes++;
+				} else {
+					if (ch == quoteDown && chPrev != '\\') {
+						quotes--;
+						if (quotes == 0) {
+							quoteRep--;
+						}
+						if (!isalpha(chNext)) {
+							if (quoteRep <= 0) {
+								styler.ColourTo(i, state);
+								state = SCE_PL_DEFAULT;
+								ch = ' ';
+							}
+						}
+						if (quoteUp == quoteDown) {
+							quotes++;
+						}
+					} else if (ch == quoteUp && chPrev != '\\') {
+						quotes++;
+					} else if (!isalpha(chNext)) {
+						if (quoteRep <= 0) {
+							styler.ColourTo(i, state);
+							state = SCE_PL_DEFAULT;
+							ch = ' ';
+						}
+					}
+				}
+			} else if (state == SCE_PL_LONGQUOTE) {
+				if (!quoteDown && !isspace(ch)) {
+					quoteUp = ch;
+					quoteDown = opposite(quoteUp);
+					quotes++;
+				} else if (ch == quoteDown) {
+					quotes--;
+					if (quotes == 0) {
+						quoteRep--;
+						if (quoteRep <= 0) {
+							styler.ColourTo(i, state);
+							state = SCE_PL_DEFAULT;
+							ch = ' ';
+						}
+						if (quoteUp == quoteDown) {
+							quotes++;
+						}
+					}
+				} else if (ch == quoteUp) {
+					quotes++;
+				}
+			}
+
+			if (state == SCE_PL_DEFAULT) {    // One of the above succeeded
+				if (ch == '#') {
+					state = SCE_PL_COMMENTLINE;
+				} else if (ch == '\"') {
+					state = SCE_PL_STRING;
+				} else if (ch == '\'') {
+					state = SCE_PL_CHARACTER;
+				} else if (iswordstart(ch)) {
+					state = SCE_PL_WORD;
+					preferRE = false;
+				} else if (isoperator(ch)) {
+					styler.ColourTo(i, SCE_PL_OPERATOR);
+				}
+			}
+		}
+		chPrev = ch;
+	}
+	styler.ColourTo(lengthDoc, state);
+}
+
+LexerModule lmPerl(SCLEX_PERL, ColourisePerlDoc);

contrib/src/stc/scintilla/src/LexPython.cxx

@@ -0,0 +1,254 @@
+// SciTE - Scintilla based Text Editor
+// LexPython.cxx - lexer for Python
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h> 
+#include <string.h> 
+#include <ctype.h> 
+#include <stdio.h> 
+#include <stdarg.h> 
+
+#include "Platform.h"
+
+#include "PropSet.h"
+#include "Accessor.h"
+#include "KeyWords.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+static void classifyWordPy(unsigned int start, unsigned int end, WordList &keywords, StylingContext &styler, char *prevWord) {
+	char s[100];
+	bool wordIsNumber = isdigit(styler[start]);
+	for (unsigned int i = 0; i < end - start + 1 && i < 30; i++) {
+		s[i] = styler[start + i];
+		s[i + 1] = '\0';
+	}
+	char chAttr = SCE_P_IDENTIFIER;
+	if (0 == strcmp(prevWord, "class"))
+		chAttr = SCE_P_CLASSNAME;
+	else if (0 == strcmp(prevWord, "def"))
+		chAttr = SCE_P_DEFNAME;
+	else if (wordIsNumber)
+		chAttr = SCE_P_NUMBER;
+	else if (keywords.InList(s))
+		chAttr = SCE_P_WORD;
+	styler.ColourTo(end, chAttr);
+	strcpy(prevWord, s);
+}
+
+static bool IsPyComment(StylingContext &styler, int pos, int len) {
+	return len>0 && styler[pos]=='#';
+}
+
+static void ColourisePyDoc(unsigned int startPos, int length, int initStyle, 
+						   WordList *keywordlists[], StylingContext &styler) {
+
+	// Python uses a different mask because bad indentation is marked by oring with 32
+	styler.StartAt(startPos, 127);
+	
+	WordList &keywords = *keywordlists[0];
+	
+	//Platform::DebugPrintf("Python coloured\n");
+	bool fold = styler.GetPropSet().GetInt("fold");
+	int whingeLevel = styler.GetPropSet().GetInt("tab.timmy.whinge.level");
+	char prevWord[200];
+	prevWord[0] = '\0';
+	if (length == 0)
+		return ;
+	int lineCurrent = styler.GetLine(startPos);
+	int spaceFlags = 0;
+	// TODO: Need to check previous line for indentation for both folding and bad indentation
+	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, IsPyComment);
+
+	int state = initStyle & 31;
+	char chPrev = ' ';
+	char chPrev2 = ' ';
+	char chNext = styler[startPos];
+	char chNext2 = styler[startPos];
+	styler.StartSegment(startPos);
+	int lengthDoc = startPos + length;
+	bool atStartLine = true;
+	for (int i = startPos; i <= lengthDoc; i++) {
+	
+		if (atStartLine) {
+			if (whingeLevel == 1) {
+				styler.SetFlags((spaceFlags & wsInconsistent) ? 64 : 0, state);
+			} else if (whingeLevel == 2) {
+				styler.SetFlags((spaceFlags & wsSpaceTab) ? 64 : 0, state);
+			} else if (whingeLevel == 3) {
+				styler.SetFlags((spaceFlags & wsSpace) ? 64 : 0, state);
+			} else if (whingeLevel == 4) {
+				styler.SetFlags((spaceFlags & wsTab) ? 64 : 0, state);
+			}
+			atStartLine = false;
+		}
+		
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		chNext2 = styler.SafeGetCharAt(i + 2);
+		
+		if ((ch == '\r' && chNext != '\n') || (ch == '\n') || (i == lengthDoc)) {
+			if ((state == SCE_P_DEFAULT) || (state == SCE_P_TRIPLE) || (state == SCE_P_TRIPLEDOUBLE)) {
+				// Perform colourisation of white space and triple quoted strings at end of each line to allow
+				// tab marking to work inside white space and triple quoted strings
+				styler.ColourTo(i, state);
+			}
+
+			int lev = indentCurrent;
+			int indentNext = styler.IndentAmount(lineCurrent + 1, &spaceFlags, IsPyComment);
+			if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
+				// Only non whitespace lines can be headers
+				if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK)) {
+					lev |= SC_FOLDLEVELHEADERFLAG;
+				} else if (indentNext & SC_FOLDLEVELWHITEFLAG) {
+					// Line after is blank so check the next - maybe should continue further?
+					int spaceFlags2 = 0;
+					int indentNext2 = styler.IndentAmount(lineCurrent + 2, &spaceFlags2, IsPyComment);
+					if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext2 & SC_FOLDLEVELNUMBERMASK)) {
+						lev |= SC_FOLDLEVELHEADERFLAG;
+					}
+				}
+			}
+			indentCurrent = indentNext;
+			if (fold) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			atStartLine = true;
+		}
+
+		if (styler.IsLeadByte(ch)) {
+			chNext = styler.SafeGetCharAt(i + 2);
+			chPrev = ' ';
+			chPrev2 = ' ';
+			i += 1;
+			continue;
+		}
+
+		if (state == SCE_P_STRINGEOL) {
+			if (ch != '\r' && ch != '\n') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_P_DEFAULT;
+			}
+		}
+		if (state == SCE_P_DEFAULT) {
+			if (iswordstart(ch)) {
+				styler.ColourTo(i - 1, state);
+				state = SCE_P_WORD;
+			} else if (ch == '#') {
+				styler.ColourTo(i - 1, state);
+				state = chNext == '#' ? SCE_P_COMMENTBLOCK : SCE_P_COMMENTLINE;
+			} else if (ch == '\"') {
+				styler.ColourTo(i - 1, state);
+				if (chNext == '\"' && chNext2 == '\"') {
+					i += 2;
+					state = SCE_P_TRIPLEDOUBLE;
+					ch = ' ';
+					chPrev = ' ';
+					chNext = styler.SafeGetCharAt(i + 1);
+				} else {
+					state = SCE_P_STRING;
+				}
+			} else if (ch == '\'') {
+				styler.ColourTo(i - 1, state);
+				if (chNext == '\'' && chNext2 == '\'') {
+					i += 2;
+					state = SCE_P_TRIPLE;
+					ch = ' ';
+					chPrev = ' ';
+					chNext = styler.SafeGetCharAt(i + 1);
+				} else {
+					state = SCE_P_CHARACTER;
+				}
+			} else if (isoperator(ch)) {
+				styler.ColourTo(i - 1, state);
+				styler.ColourTo(i, SCE_P_OPERATOR);
+			}
+		} else if (state == SCE_P_WORD) {
+			if (!iswordchar(ch)) {
+				classifyWordPy(styler.GetStartSegment(), i - 1, keywords, styler, prevWord);
+				state = SCE_P_DEFAULT;
+				if (ch == '#') {
+					state = chNext == '#' ? SCE_P_COMMENTBLOCK : SCE_P_COMMENTLINE;
+				} else if (ch == '\"') {
+					if (chNext == '\"' && chNext2 == '\"') {
+						i += 2;
+						state = SCE_P_TRIPLEDOUBLE;
+						ch = ' ';
+						chPrev = ' ';
+						chNext = styler.SafeGetCharAt(i + 1);
+					} else {
+						state = SCE_P_STRING;
+					}
+				} else if (ch == '\'') {
+					if (chNext == '\'' && chNext2 == '\'') {
+						i += 2;
+						state = SCE_P_TRIPLE;
+						ch = ' ';
+						chPrev = ' ';
+						chNext = styler.SafeGetCharAt(i + 1);
+					} else {
+						state = SCE_P_CHARACTER;
+					}
+				} else if (isoperator(ch)) {
+					styler.ColourTo(i, SCE_P_OPERATOR);
+				}
+			}
+		} else {
+			if (state == SCE_P_COMMENTLINE || state == SCE_P_COMMENTBLOCK) {
+				if (ch == '\r' || ch == '\n') {
+					styler.ColourTo(i - 1, state);
+					state = SCE_P_DEFAULT;
+				}
+			} else if (state == SCE_P_STRING) {
+				if ((ch == '\r' || ch == '\n') && (chPrev != '\\')) {
+					styler.ColourTo(i - 1, state);
+					state = SCE_P_STRINGEOL;
+				} else if (ch == '\\') {
+					if (chNext == '\"' || chNext == '\'' || chNext == '\\') {
+						i++;
+						ch = chNext;
+						chNext = styler.SafeGetCharAt(i + 1);
+					}
+				} else if (ch == '\"') {
+					styler.ColourTo(i, state);
+					state = SCE_P_DEFAULT;
+				}
+			} else if (state == SCE_P_CHARACTER) {
+				if ((ch == '\r' || ch == '\n') && (chPrev != '\\')) {
+					styler.ColourTo(i - 1, state);
+					state = SCE_P_STRINGEOL;
+				} else if (ch == '\\') {
+					if (chNext == '\"' || chNext == '\'' || chNext == '\\') {
+						i++;
+						ch = chNext;
+						chNext = styler.SafeGetCharAt(i + 1);
+					}
+				} else if (ch == '\'') {
+					styler.ColourTo(i, state);
+					state = SCE_P_DEFAULT;
+				}
+			} else if (state == SCE_P_TRIPLE) {
+				if (ch == '\'' && chPrev == '\'' && chPrev2 == '\'') {
+					styler.ColourTo(i, state);
+					state = SCE_P_DEFAULT;
+				}
+			} else if (state == SCE_P_TRIPLEDOUBLE) {
+				if (ch == '\"' && chPrev == '\"' && chPrev2 == '\"') {
+					styler.ColourTo(i, state);
+					state = SCE_P_DEFAULT;
+				}
+			}
+		}
+		chPrev2 = chPrev;
+		chPrev = ch;
+	}
+	if (state == SCE_P_WORD) {
+		classifyWordPy(styler.GetStartSegment(), lengthDoc, keywords, styler, prevWord);
+	} else {
+		styler.ColourTo(lengthDoc, state);
+	}
+}
+
+LexerModule lmPython(SCLEX_PYTHON, ColourisePyDoc);

contrib/src/stc/scintilla/src/LexSQL.cxx

@@ -0,0 +1,158 @@
+// SciTE - Scintilla based Text Editor
+// LexSQL.cxx - lexer for SQL
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h> 
+#include <string.h> 
+#include <ctype.h> 
+#include <stdio.h> 
+#include <stdarg.h> 
+
+#include "Platform.h"
+
+#include "PropSet.h"
+#include "Accessor.h"
+#include "KeyWords.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+static void classifyWordSQL(unsigned int start, unsigned int end, WordList &keywords, StylingContext &styler) {
+	char s[100];
+	bool wordIsNumber = isdigit(styler[start]) || (styler[start] == '.');
+	for (unsigned int i = 0; i < end - start + 1 && i < 30; i++) {
+		s[i] = toupper(styler[start + i]);
+		s[i + 1] = '\0';
+	}
+	char chAttr = SCE_C_IDENTIFIER;
+	if (wordIsNumber)
+		chAttr = SCE_C_NUMBER;
+	else {
+		if (keywords.InList(s))
+			chAttr = SCE_C_WORD;
+	}
+	styler.ColourTo(end, chAttr);
+}
+
+static void ColouriseSQLDoc(unsigned int startPos, int length,
+                            int initStyle, WordList *keywordlists[], StylingContext &styler) {
+
+	WordList &keywords = *keywordlists[0];
+	
+	styler.StartAt(startPos);
+
+	bool fold = styler.GetPropSet().GetInt("fold");
+	int lineCurrent = styler.GetLine(startPos);
+	int spaceFlags = 0;
+	int indentCurrent = 0;
+
+	int state = initStyle;
+	char chPrev = ' ';
+	char chNext = styler[startPos];
+	styler.StartSegment(startPos);
+	unsigned int lengthDoc = startPos + length;
+	bool prevCr = false;
+	for (unsigned int i = startPos; i <= lengthDoc; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+
+		if ((ch == '\r' && chNext != '\n') || (ch == '\n')) {
+			indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags);
+			int lev = indentCurrent;
+			if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
+				// Only non whitespace lines can be headers
+				int indentNext = styler.IndentAmount(lineCurrent + 1, &spaceFlags);
+				if (indentCurrent < (indentNext & ~SC_FOLDLEVELWHITEFLAG)) {
+					lev |= SC_FOLDLEVELHEADERFLAG;
+				}
+			}
+			if (fold) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+		}
+
+		if (styler.IsLeadByte(ch)) {
+			chNext = styler.SafeGetCharAt(i + 2);
+			chPrev = ' ';
+			i += 1;
+			continue;
+		}
+
+		if (state == SCE_C_DEFAULT) {
+			if (iswordstart(ch)) {
+				styler.ColourTo(i - 1, state);
+				state = SCE_C_WORD;
+			} else if (ch == '/' && chNext == '*') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_C_COMMENT;
+			} else if (ch == '-' && chNext == '-') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_C_COMMENTLINE;
+			} else if (ch == '\'') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_C_STRING;
+			} else if (isoperator(ch)) {
+				styler.ColourTo(i - 1, state);
+				styler.ColourTo(i, SCE_C_OPERATOR);
+			}
+		} else if (state == SCE_C_WORD) {
+			if (!iswordchar(ch)) {
+				classifyWordSQL(styler.GetStartSegment(), i - 1, keywords, styler);
+				state = SCE_C_DEFAULT;
+				if (ch == '/' && chNext == '*') {
+					state = SCE_C_COMMENT;
+				} else if (ch == '-' && chNext == '-') {
+					state = SCE_C_COMMENTLINE;
+				} else if (ch == '\'') {
+					state = SCE_C_STRING;
+				} else if (isoperator(ch)) {
+					styler.ColourTo(i, SCE_C_OPERATOR);
+				}
+			}
+		} else {
+			if (state == SCE_C_COMMENT) {
+				if (ch == '/' && chPrev == '*') {
+					if (((i > (styler.GetStartSegment() + 2)) || ((initStyle == SCE_C_COMMENT) &&
+					    (styler.GetStartSegment() == startPos)))) {
+						styler.ColourTo(i, state);
+						state = SCE_C_DEFAULT;
+					}
+				}
+			} else if (state == SCE_C_COMMENTLINE) {
+				if (ch == '\r' || ch == '\n') {
+					styler.ColourTo(i - 1, state);
+					state = SCE_C_DEFAULT;
+				}
+			} else if (state == SCE_C_STRING) {
+				if (ch == '\'') {
+					if ( chNext == '\'' ) {
+						i++;
+					} else {
+						styler.ColourTo(i, state);
+						state = SCE_C_DEFAULT;
+						i++;
+					}
+					ch = chNext;
+					chNext = styler.SafeGetCharAt(i + 1);
+				}
+			}
+			if (state == SCE_C_DEFAULT) {    // One of the above succeeded
+				if (ch == '/' && chNext == '*') {
+					state = SCE_C_COMMENT;
+				} else if (ch == '-' && chNext == '-') {
+					state = SCE_C_COMMENTLINE;
+				} else if (ch == '\'') {
+					state = SCE_C_STRING;
+				} else if (iswordstart(ch)) {
+					state = SCE_C_WORD;
+				} else if (isoperator(ch)) {
+					styler.ColourTo(i, SCE_C_OPERATOR);
+				}
+			}
+		}
+		chPrev = ch;
+	}
+	styler.ColourTo(lengthDoc - 1, state);
+}
+
+LexerModule lmSQL(SCLEX_SQL, ColouriseSQLDoc);

contrib/src/stc/scintilla/src/LexVB.cxx

@@ -0,0 +1,118 @@
+// SciTE - Scintilla based Text Editor
+// LexVB.cxx - lexer for Visual Basic and VBScript
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h> 
+#include <string.h> 
+#include <ctype.h> 
+#include <stdio.h> 
+#include <stdarg.h> 
+
+#include "Platform.h"
+
+#include "PropSet.h"
+#include "Accessor.h"
+#include "KeyWords.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+static int classifyWordVB(unsigned int start, unsigned int end, WordList &keywords, StylingContext &styler) {
+
+	char s[100];
+	bool wordIsNumber = isdigit(styler[start]) || (styler[start] == '.');
+	for (unsigned int i = 0; i < end - start + 1 && i < 30; i++) {
+		s[i] = tolower(styler[start + i]);
+		s[i + 1] = '\0';
+	}
+	char chAttr = SCE_C_DEFAULT;
+	if (wordIsNumber)
+		chAttr = SCE_C_NUMBER;
+	else {
+		if (keywords.InList(s)) {
+			chAttr = SCE_C_WORD;
+			if (strcmp(s, "rem") == 0)
+				chAttr = SCE_C_COMMENTLINE;
+		}
+	}
+	styler.ColourTo(end, chAttr);
+	if (chAttr == SCE_C_COMMENTLINE)
+		return SCE_C_COMMENTLINE;
+	else
+		return SCE_C_DEFAULT;
+}
+
+static void ColouriseVBDoc(unsigned int startPos, int length, int initStyle,
+                           WordList *keywordlists[], StylingContext &styler) {
+
+	WordList &keywords = *keywordlists[0];
+	
+	styler.StartAt(startPos);
+
+	int state = initStyle;
+	char chNext = styler[startPos];
+	styler.StartSegment(startPos);
+	int lengthDoc = startPos + length;
+	for (int i = startPos; i < lengthDoc; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+
+		if (styler.IsLeadByte(ch)) {
+			chNext = styler.SafeGetCharAt(i + 2);
+			i += 1;
+			continue;
+		}
+
+		if (state == SCE_C_DEFAULT) {
+			if (iswordstart(ch)) {
+				styler.ColourTo(i - 1, state);
+				state = SCE_C_WORD;
+			} else if (ch == '\'') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_C_COMMENTLINE;
+			} else if (ch == '\"') {
+				styler.ColourTo(i - 1, state);
+				state = SCE_C_STRING;
+			}
+		} else if (state == SCE_C_WORD) {
+			if (!iswordchar(ch)) {
+				state = classifyWordVB(styler.GetStartSegment(), i - 1, keywords, styler);
+				if (state == SCE_C_DEFAULT) {
+					if (ch == '\'') {
+						state = SCE_C_COMMENTLINE;
+					} else if (ch == '\"') {
+						state = SCE_C_STRING;
+					}
+				}
+			}
+		} else {
+			if (state == SCE_C_COMMENTLINE) {
+				if (ch == '\r' || ch == '\n') {
+					styler.ColourTo(i - 1, state);
+					state = SCE_C_DEFAULT;
+				}
+			} else if (state == SCE_C_STRING) {
+				// VB doubles quotes to preserve them
+				if (ch == '\"') {
+					styler.ColourTo(i, state);
+					state = SCE_C_DEFAULT;
+					i++;
+					ch = chNext;
+					chNext = styler.SafeGetCharAt(i + 1);
+				}
+			}
+			if (state == SCE_C_DEFAULT) {    // One of the above succeeded
+				if (ch == '\'') {
+					state = SCE_C_COMMENTLINE;
+				} else if (ch == '\"') {
+					state = SCE_C_STRING;
+				} else if (iswordstart(ch)) {
+					state = SCE_C_WORD;
+				}
+			}
+		}
+	}
+	styler.ColourTo(lengthDoc, state);
+}
+
+LexerModule lmVB(SCLEX_VB, ColouriseVBDoc);

contrib/src/stc/scintilla/src/LineMarker.cxx

@@ -0,0 +1,125 @@
+// Scintilla source code edit control
+// LineMarker.cxx - defines the look of a line marker in the margin 
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include "Platform.h"
+
+#include "Scintilla.h"
+#include "LineMarker.h"
+
+void LineMarker::Draw(Surface *surface, PRectangle &rc) {
+	int minDim = Platform::Minimum(rc.Width(), rc.Height());
+	minDim--;	// Ensure does not go beyond edge
+	int centreX = (rc.right + rc.left) / 2;
+	int centreY = (rc.bottom + rc.top) / 2;
+	int dimOn2 = minDim / 2;
+	int dimOn4 = minDim / 4;
+	if (rc.Width() > (rc.Height() * 2)) {
+		// Wide column is line number so move to left to try to avoid overlapping number
+		centreX = rc.left + dimOn2 + 1;
+	}
+	if (markType == SC_MARK_ROUNDRECT) {
+		PRectangle rcRounded = rc;
+		rcRounded.left = rc.left + 1;
+		rcRounded.right = rc.right - 1;
+		surface->RoundedRectangle(rcRounded, fore.allocated, back.allocated);
+	} else if (markType == SC_MARK_CIRCLE) {
+		PRectangle rcCircle;
+		rcCircle.left = centreX - dimOn2;
+		rcCircle.top = centreY - dimOn2;
+		rcCircle.right = centreX + dimOn2;
+		rcCircle.bottom = centreY + dimOn2;
+		surface->Ellipse(rcCircle, fore.allocated, back.allocated);
+	} else if (markType == SC_MARK_ARROW) {
+		Point pts[] = {
+    		Point(centreX - dimOn4, centreY - dimOn2),
+    		Point(centreX - dimOn4, centreY + dimOn2),
+    		Point(centreX + dimOn2 - dimOn4, centreY),
+		};
+		surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
+                 		fore.allocated, back.allocated);
+
+	} else if (markType == SC_MARK_ARROWDOWN) {
+		Point pts[] = {
+    		Point(centreX - dimOn2, centreY - dimOn4),
+    		Point(centreX + dimOn2, centreY - dimOn4),
+    		Point(centreX, centreY + dimOn2 - dimOn4),
+		};
+		surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
+                 		fore.allocated, back.allocated);
+
+	} else if (markType == SC_MARK_PLUS) {
+		int armSize = dimOn2-2;
+		Point xpts[] = {
+    		Point(centreX - armSize, centreY),
+    		Point(centreX, centreY),
+    		Point(centreX, centreY - armSize),
+    		Point(centreX, centreY - armSize),
+    		Point(centreX, centreY),
+    		Point(centreX + armSize, centreY),
+    		Point(centreX + armSize, centreY),
+    		Point(centreX, centreY),
+    		Point(centreX, centreY + armSize),
+    		Point(centreX, centreY + armSize),
+    		Point(centreX, centreY),
+    		Point(centreX - armSize, centreY),
+		};
+		Point pts[] = {
+    		Point(centreX - armSize, centreY - 1),
+    		Point(centreX - 1, centreY - 1),
+    		Point(centreX - 1, centreY - armSize),
+    		Point(centreX + 1, centreY - armSize),
+    		Point(centreX + 1, centreY - 1),
+    		Point(centreX + armSize, centreY -1),
+    		Point(centreX + armSize, centreY +1),
+    		Point(centreX + 1, centreY + 1),
+    		Point(centreX + 1, centreY + armSize),
+    		Point(centreX - 1, centreY + armSize),
+    		Point(centreX - 1, centreY + 1),
+    		Point(centreX - armSize, centreY + 1),
+		};
+		surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
+                 		fore.allocated, back.allocated);
+
+	} else if (markType == SC_MARK_MINUS) {
+		int armSize = dimOn2-2;
+		Point pts[] = {
+    		Point(centreX - armSize, centreY - 1),
+    		Point(centreX + armSize, centreY -1),
+    		Point(centreX + armSize, centreY +1),
+    		Point(centreX - armSize, centreY + 1),
+		};
+		Point xpts[] = {
+    		Point(centreX - armSize, centreY),
+    		Point(centreX + armSize, centreY),
+    		Point(centreX + armSize, centreY),
+    		Point(centreX - armSize, centreY),
+		};
+		surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
+                 		fore.allocated, back.allocated);
+
+	} else if (markType == SC_MARK_SMALLRECT) {
+		PRectangle rcSmall;
+		rcSmall.left = rc.left + 1;
+		rcSmall.top = rc.top + 2;
+		rcSmall.right = rc.right - 1;
+		rcSmall.bottom = rc.bottom - 2;
+		surface->RectangleDraw(rcSmall, fore.allocated, back.allocated);
+	} else if (markType == SC_MARK_EMPTY) {
+		// An invisible marker so don't draw anything
+	} else { // SC_MARK_SHORTARROW
+		Point pts[] = {
+			Point(centreX, centreY + dimOn2),
+			Point(centreX + dimOn2, centreY),
+			Point(centreX, centreY - dimOn2),
+			Point(centreX, centreY - dimOn4),
+			Point(centreX - dimOn4, centreY - dimOn4),
+			Point(centreX - dimOn4, centreY + dimOn4),
+			Point(centreX, centreY + dimOn4),
+			Point(centreX, centreY + dimOn2),
+		};
+		surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
+				fore.allocated, back.allocated);
+	}
+}

contrib/src/stc/scintilla/src/LineMarker.h

@@ -0,0 +1,22 @@
+// Scintilla source code edit control
+// LineMarker.h - defines the look of a line marker in the margin 
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef LINEMARKER_H
+#define LINEMARKER_H
+
+class LineMarker {
+public:
+	int markType;
+	ColourPair fore;
+	ColourPair back;
+	LineMarker() {
+		markType = SC_MARK_CIRCLE;
+		fore = Colour(0,0,0);
+		back = Colour(0xff,0xff,0xff);
+	}
+	void Draw(Surface *surface, PRectangle &rc);
+};
+
+#endif

contrib/src/stc/scintilla/src/PropSet.cxx

@@ -0,0 +1,404 @@
+// SciTE - Scintilla based Text Editor
+// PropSet.cxx - a java style properties file module
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+// Maintain a dictionary of properties
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+
+#include "Platform.h"
+
+#include "PropSet.h"
+
+bool EqualCaseInsensitive(const char *a, const char *b) {
+#if PLAT_GTK
+	return 0 == strcasecmp(a, b);
+#elif PLAT_WIN
+	return 0 == stricmp(a, b);
+#elif PLAT_WX
+	return 0 == wxStricmp(a, b);
+#endif
+}
+
+// Get a line of input. If end of line escaped with '\\' then continue reading.
+static bool GetFullLine(const char *&fpc, int &lenData, char *s, int len) {
+	bool continuation = true;
+	s[0] = '\0';
+	while ((len > 1) && lenData > 0) {
+		char ch = *fpc;
+		fpc++;
+		lenData--;
+		if ((ch == '\r') || (ch == '\n')) {
+			if (!continuation) {
+				if ((lenData > 0) && (ch == '\r') && ((*fpc) == '\n')) {
+					// munch the second half of a crlf
+					fpc++;
+					lenData--;
+				}
+				*s++ = '\0';
+				return true;
+			}
+		} else if ((ch == '\\') && (lenData > 0) && ((*fpc == '\r') || (*fpc == '\n'))) {
+			continuation = true;
+		} else {
+			continuation = false;
+			*s++ = ch;
+			*s = '\0';
+			len--;
+		}
+	}
+	return false;
+}
+
+PropSet::PropSet() {
+	superPS = 0;
+	size = 10;
+	used = 0;
+	vals = new char * [size];
+}
+
+PropSet::~PropSet() {
+	superPS = 0;
+	Clear();
+	delete []vals;
+}
+
+void PropSet::EnsureCanAddEntry() {
+	if (used >= size - 2) {
+		int newsize = size + 10;
+		char **newvals = new char * [newsize];
+
+		for (int i = 0; i < used; i++) {
+			newvals[i] = vals[i];
+		}
+		delete []vals;
+		vals = newvals;
+		size = newsize;
+	}
+}
+
+void PropSet::Set(const char *key, const char *val) {
+	EnsureCanAddEntry();
+	for (int i = 0; i < used; i += 2) {
+		if (EqualCaseInsensitive(vals[i], key)) {
+			// Replace current value
+			delete [](vals[i + 1]);
+			vals[i + 1] = StringDup(val);
+			return;
+		}
+	}
+	// Not found
+	vals[used++] = StringDup(key);
+	vals[used++] = StringDup(val);
+}
+
+void PropSet::Set(char *keyval) {
+	char *eqat = strchr(keyval, '=');
+	if (eqat) {
+		*eqat = '\0';
+		Set(keyval, eqat + 1);
+		*eqat = '=';
+	}
+}
+
+SString PropSet::Get(const char *key) {
+	for (int i = 0; i < used; i += 2) {
+		if (EqualCaseInsensitive(vals[i], key)) {
+			return vals[i + 1];
+		}
+	}
+	if (superPS) {
+		// Failed here, so try in base property set
+		return superPS->Get(key);
+	} else {
+		return "";
+	}
+}
+
+int PropSet::GetInt(const char *key, int defaultValue) {
+	SString val = Get(key);
+	if (val.length())
+		return Get(key).value();
+	else
+		return defaultValue;
+}
+
+bool isprefix(const char *target, const char *prefix) {
+	while (*target && *prefix) {
+		if (toupper(*target) != toupper(*prefix))
+			return false;
+		target++;
+		prefix++;
+	}
+	if (*prefix)
+		return false;
+	else
+		return true;
+}
+
+bool issuffix(const char *target, const char *suffix) {
+	int lentarget = strlen(target);
+	int lensuffix = strlen(suffix);
+	if (lensuffix > lentarget)
+		return false;
+	for (int i = lensuffix - 1; i >= 0; i--) {
+		if (toupper(target[i + lentarget - lensuffix]) != toupper(suffix[i]))
+			return false;
+	}
+	return true;
+}
+
+SString PropSet::GetWild(const char *keybase, const char *filename) {
+	for (int i = 0; i < used; i += 2) {
+		if (isprefix(vals[i], keybase)) {
+			char *orgkeyfile = vals[i] + strlen(keybase);
+			char *keyfile = NULL;
+
+			if (strstr(orgkeyfile, "$(") == orgkeyfile) {
+				char *cpendvar = strchr(orgkeyfile, ')');
+				if (cpendvar) {
+					int lenvar = cpendvar - orgkeyfile - 2; 	// Subtract the $()
+					char *var = static_cast<char *>(malloc(lenvar + 1));
+					strncpy(var, orgkeyfile + 2, lenvar);
+					var[lenvar] = '\0';
+					SString s = Get(var);
+					free(var);
+					keyfile = strdup(s.c_str());
+				}
+			}
+			char *keyptr = keyfile;
+
+			if (keyfile == NULL)
+				keyfile = orgkeyfile;
+
+			for (; ; ) {
+				char *del = strchr(keyfile, ';');
+				if (del == NULL)
+					del = keyfile + strlen(keyfile);
+				char delchr = *del;
+				*del = '\0';
+				if (*keyfile == '*') {
+					if (issuffix(filename, keyfile + 1)) {
+						*del = delchr;
+						free(keyptr);
+						return vals[i + 1];
+					}
+				} else if (EqualCaseInsensitive(keyfile, filename)) {
+					*del = delchr;
+					free(keyptr);
+					return vals[i + 1];
+				}
+				if (delchr == '\0')
+					break;
+				*del = delchr;
+				keyfile = del + 1;
+			}
+			free(keyptr);
+
+			if (EqualCaseInsensitive(vals[i], keybase)) {
+				return vals[i + 1];
+			}
+		}
+	}
+	if (superPS) {
+		// Failed here, so try in base property set
+		return superPS->GetWild(keybase, filename);
+	} else {
+		return "";
+	}
+}
+
+SString PropSet::GetNewExpand(const char *keybase, const char *filename) {
+	char *base = StringDup(GetWild(keybase, filename).c_str());
+	char *cpvar = strstr(base, "$(");
+	while (cpvar) {
+		char *cpendvar = strchr(cpvar, ')');
+		if (cpendvar) {
+			int lenvar = cpendvar - cpvar - 2;  	// Subtract the $()
+			char *var = new char[lenvar + 1];
+			strncpy(var, cpvar + 2, lenvar);
+			var[lenvar] = '\0';
+			SString val = GetWild(var, filename);
+			int newlenbase = strlen(base) + val.length() - lenvar;
+			char *newbase = new char[newlenbase];
+			strncpy(newbase, base, cpvar - base);
+			strcpy(newbase + (cpvar - base), val.c_str());
+			strcpy(newbase + (cpvar - base) + val.length(), cpendvar + 1);
+			delete []var;
+			delete []base;
+			base = newbase;
+		}
+		cpvar = strstr(base, "$(");
+	}
+	SString sret = base;
+	delete []base;
+	return sret;
+}
+
+void PropSet::Clear() {
+	for (int i = 0; i < used; i++) {
+		delete [](vals[i]);
+		vals[i] = 0;
+	}
+	used = 0;
+}
+
+void PropSet::ReadFromMemory(const char *data, int len) {
+	if (len > 0) {
+		const char *pd = data;
+		char linebuf[60000];
+		while (GetFullLine(pd, len, linebuf, sizeof(linebuf))) {
+			if (isalpha(linebuf[0]))
+				Set(linebuf);
+		}
+		// If there is a final line:
+		if (isalpha(linebuf[0]))
+			Set(linebuf);
+	}
+}
+
+void PropSet::Read(const char *filename) {
+	//printf("Opening properties <%s>\n", filename);
+	Clear();
+	char propsData[60000];
+	FILE *rcfile = fopen(filename, "rb");
+	if (rcfile) {
+		int lenFile = fread(propsData, 1, sizeof(propsData), rcfile);
+		fclose(rcfile);
+		ReadFromMemory(propsData, lenFile);
+	} else {
+		//printf("Could not open <%s>\n", filename);
+	}
+}
+
+static bool iswordsep(char ch, bool onlyLineEnds) {
+	if (!isspace(ch))
+		return false;
+	if (!onlyLineEnds)
+		return true;
+	return ch == '\r' || ch == '\n';
+}
+
+// Creates an array that points into each word in the string and puts \0 terminators
+// after each word.
+static char **ArrayFromWordList(char *wordlist, bool onlyLineEnds = false) {
+	char prev = '\n';
+	int words = 0;
+	for (int j = 0; wordlist[j]; j++) {
+		if (!iswordsep(wordlist[j], onlyLineEnds) && iswordsep(prev, onlyLineEnds))
+			words++;
+		prev = wordlist[j];
+	}
+	char **keywords = new char * [words + 1];
+	if (keywords) {
+		words = 0;
+		prev = '\0';
+		int len = strlen(wordlist);
+		for (int k = 0; k < len; k++) {
+			if (!iswordsep(wordlist[k], onlyLineEnds)) {
+				if (!prev) {
+					keywords[words] = &wordlist[k];
+					words++;
+				}
+			} else {
+				wordlist[k] = '\0';
+			}
+			prev = wordlist[k];
+		}
+		keywords[words] = &wordlist[len];
+	}
+	return keywords;
+}
+
+void WordList::Clear() {
+	if (words) {
+		delete []words;
+		delete []list;
+	}
+	words = 0;
+	list = 0;
+	len = 0;
+}
+
+void WordList::Set(const char *s) {
+	len = 0;
+	list = StringDup(s);
+	words = ArrayFromWordList(list, onlyLineEnds);
+}
+
+char *WordList::Allocate(int size) {
+	list = new char[size + 1];
+	list[size] = '\0';
+	return list;
+}
+
+void WordList::SetFromAllocated() {
+	len = 0;
+	words = ArrayFromWordList(list, onlyLineEnds);
+}
+
+// Shell sort based upon public domain C implementation by Raymond Gardner 1991
+// Used here because of problems with mingw qsort.
+static void SortWordList(char **words, unsigned int len) {
+	unsigned int gap = len / 2;
+
+	while (gap > 0) {
+		unsigned int i = gap;
+		while (i < len) {
+			unsigned int j = i;
+			char **a = words + j;
+			do {
+				j -= gap;
+				char **b = a;
+				a -= gap;
+				if (strcmp(*a, *b) > 0) {
+					char *tmp = *a;
+					*a = *b;
+					*b = tmp;
+				} else {
+					break;
+				}
+			} while (j >= gap);
+			i++;
+		}
+		gap = gap / 2;
+	}
+}
+
+bool WordList::InList(const char *s) {
+	if (0 == words)
+		return false;
+	if (len == 0) {
+		for (int i = 0; words[i][0]; i++)
+			len++;
+		SortWordList(words, len);
+		for (int k = 0; k < (sizeof(starts) / sizeof(starts[0])); k++)
+			starts[k] = -1;
+		for (int l = len - 1; l >= 0; l--) {
+			unsigned char indexChar = words[l][0];
+			starts[indexChar] = l;
+		}
+	}
+	unsigned char firstChar = s[0];
+	int j = starts[firstChar];
+	if (j >= 0) {
+		while (words[j][0] == firstChar) {
+			if (s[1] == words[j][1]) {
+				const char *a = words[j] + 1;
+				const char *b = s + 1;
+				while (*a && *a == *b) {
+					a++;
+					b++;
+				}
+				if (!*a && !*b)
+					return true;
+			}
+			j++;
+		}
+	}
+	return false;
+}

contrib/src/stc/scintilla/src/SVector.h

@@ -0,0 +1,110 @@
+// Scintilla source code edit control
+// SVector.h - a simple expandable vector
+// Copyright 1998-1999 by Neil Hodgson <neilh@hare.net.au>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SVECTOR_H
+#define SVECTOR_H
+
+// A simple expandable vector. 
+// T must support assignment.
+// Storage not allocated for elements until an element is used. 
+// This makes it very lightweight unless used so is a good match for optional features.
+template<class T, int sizeIncrement>
+class SVector {
+	T *v;
+	unsigned int size;	// Number of elements allocated
+	unsigned int len;	// Number of elements in vector
+	bool allocFailure;	// A memory allocation call has failed
+	
+	// Internally allocate more elements than the user wants to avoid 
+	// thrashng the memory allocator
+	void SizeTo(int newSize) {
+		if (newSize < sizeIncrement)
+			newSize += sizeIncrement;
+		else 
+			newSize = (newSize * 3) / 2;
+		T* newv = new T[newSize];
+		if (!newv) {
+			allocFailure = true;
+			return;
+		}
+		size = newSize;
+		for (unsigned int i=0; i<len; i++) {
+			newv[i] = v[i];
+		}
+		delete []v;
+		v = newv;
+	}
+	
+public:
+	SVector() {
+		allocFailure = false;
+		v = 0;
+		len = 0;
+		size = 0;
+	}
+	~SVector() {
+		Free();
+	}
+	SVector(const SVector &other) {
+		allocFailure = false;
+		v = 0;
+		len = 0;
+		size = 0;
+		if (other.Length() > 0) {
+			SizeTo(other.Length());
+			if (!allocFailure) {
+				for (int i=0;i<other.Length();i++)
+					v[i] = other.v[i];
+				len = other.Length();
+			}
+		}
+	}
+	SVector &operator=(const SVector &other) {
+		if (this != &other) {
+			delete []v;
+			allocFailure = false;
+			v = 0;
+			len = 0;
+			size = 0;
+			if (other.Length() > 0) {
+				SizeTo(other.Length());
+				if (!allocFailure) {
+					for (int i=0;i<other.Length();i++)
+						v[i] = other.v[i];
+				}
+				len = other.Length();
+			}
+		}
+		return *this;
+	}
+	T &operator[](unsigned int i) {
+		if (i >= len) {
+			if (i >= size) {
+				SizeTo(i);
+			}
+			len = i+1;
+		}
+		return v[i];
+	}
+	void Free() {
+		delete []v;
+		v = 0;
+		size = 0;
+		len = 0;
+	}
+	void SetLength(unsigned int newLength) {
+		if (newLength > len) {
+			if (newLength >= size) {
+				SizeTo(newLength);
+			}
+		}
+		len = newLength;
+	}
+	int Length() const {
+		return len;
+	}
+};
+
+#endif

contrib/src/stc/scintilla/src/ScintillaBase.cxx

@@ -0,0 +1,398 @@
+// Scintilla source code edit control
+// ScintillaBase.cxx - an enhanced subclass of Editor with calltips, autocomplete and context menu
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include "Platform.h"
+
+#include "Scintilla.h"
+#ifdef SCI_LEXER
+#include "SciLexer.h"
+#include "PropSet.h"
+#include "Accessor.h"
+#include "KeyWords.h"
+#endif
+#include "ContractionState.h"
+#include "SVector.h"
+#include "CellBuffer.h"
+#include "CallTip.h"
+#include "KeyMap.h"
+#include "Indicator.h"
+#include "LineMarker.h"
+#include "Style.h"
+#include "ViewStyle.h"
+#include "AutoComplete.h"
+#include "Document.h"
+#include "Editor.h"
+#include "ScintillaBase.h"
+
+ScintillaBase::ScintillaBase() {
+#ifdef SCI_LEXER	
+	lexLanguage = SCLEX_CONTAINER;
+	for (int wl=0;wl<numWordLists;wl++)
+		keyWordLists[wl] = new WordList;
+#endif
+}
+
+ScintillaBase::~ScintillaBase() {}
+
+void ScintillaBase::Finalise() {
+	popup.Destroy();
+}
+
+void ScintillaBase::RefreshColourPalette(Palette &pal, bool want) {
+	Editor::RefreshColourPalette(pal, want);
+	ct.RefreshColourPalette(pal, want);
+}
+
+void ScintillaBase::AddChar(char ch) {
+	bool acActiveBeforeCharAdded = ac.Active();
+	Editor::AddChar(ch);
+	if (acActiveBeforeCharAdded)
+		AutoCompleteChanged(ch);
+}
+
+void ScintillaBase::Command(int cmdId) {
+
+	switch (cmdId) {
+
+	case idAutoComplete: 	// Nothing to do
+		break;
+
+	case idCallTip: 	// Nothing to do
+		break;
+
+	case idcmdUndo:
+		WndProc(WM_UNDO, 0, 0);
+		break;
+
+	case idcmdRedo:
+		WndProc(SCI_REDO, 0, 0);
+		break;
+
+	case idcmdCut:
+		WndProc(WM_CUT, 0, 0);
+		break;
+
+	case idcmdCopy:
+		WndProc(WM_COPY, 0, 0);
+		break;
+
+	case idcmdPaste:
+		WndProc(WM_PASTE, 0, 0);
+		break;
+
+	case idcmdDelete:
+		WndProc(WM_CLEAR, 0, 0);
+		break;
+
+	case idcmdSelectAll:
+		WndProc(SCI_SELECTALL, 0, 0);
+		break;
+	}
+}
+
+int ScintillaBase::KeyCommand(UINT iMessage) {
+	// Most key commands cancel autocompletion mode
+	if (ac.Active()) {
+		switch (iMessage) {
+			// Except for these
+		case SCI_LINEDOWN:
+			AutoCompleteMove(1);
+			return 0;
+		case SCI_LINEUP:
+			AutoCompleteMove( -1);
+			return 0;
+		case SCI_PAGEDOWN:
+			AutoCompleteMove(5);
+			return 0;
+		case SCI_PAGEUP:
+			AutoCompleteMove( -5);
+			return 0;
+		case SCI_VCHOME:
+			AutoCompleteMove( -5000);
+			return 0;
+		case SCI_LINEEND:
+			AutoCompleteMove(5000);
+			return 0;
+		case SCI_DELETEBACK:
+			DelCharBack();
+			AutoCompleteChanged();
+			EnsureCaretVisible();
+			return 0;
+		case SCI_TAB:
+			AutoCompleteCompleted();
+			return 0;
+
+		default:
+			ac.Cancel();
+		}
+	}
+
+	if (ct.inCallTipMode) {
+		if (
+		    (iMessage != SCI_CHARLEFT) &&
+		    (iMessage != SCI_CHARLEFTEXTEND) &&
+		    (iMessage != SCI_CHARRIGHT) &&
+		    (iMessage != SCI_CHARLEFTEXTEND) &&
+		    (iMessage != SCI_EDITTOGGLEOVERTYPE) &&
+		    (iMessage != SCI_DELETEBACK)
+		) {
+			ct.CallTipCancel();
+		}
+		if (iMessage == SCI_DELETEBACK) {
+			if (currentPos <= ct.posStartCallTip) {
+				ct.CallTipCancel();
+			}
+		}
+	}
+	return Editor::KeyCommand(iMessage);
+}
+
+void ScintillaBase::AutoCompleteStart(int lenEntered, const char *list) {
+	//Platform::DebugPrintf("AutoCOmplete %s\n", list);
+	ct.CallTipCancel();
+
+	ac.Start(wDraw, idAutoComplete, currentPos, lenEntered);
+
+	PRectangle rcClient = GetClientRectangle();
+	Point pt = LocationFromPosition(currentPos-lenEntered);
+
+	//Platform::DebugPrintf("Auto complete %x\n", lbAutoComplete);
+	int heightLB = 100;
+	int widthLB = 100;
+	if (pt.x >= rcClient.right - widthLB) {
+		HorizontalScrollTo(xOffset + pt.x - rcClient.right + widthLB);
+		Redraw();
+		pt = LocationFromPosition(currentPos);
+	}
+	PRectangle rcac;
+	rcac.left = pt.x - 5;
+	if (pt.y >= rcClient.bottom - heightLB && // Wont fit below.
+	    pt.y >= (rcClient.bottom + rcClient.top) / 2) { // and there is more room above.
+		rcac.top = pt.y - heightLB;
+		if (rcac.top < 0) {
+			heightLB += rcac.top;
+			rcac.top = 0;
+		}
+	} else {
+		rcac.top = pt.y + vs.lineHeight;
+	}
+	rcac.right = rcac.left + widthLB;
+	rcac.bottom = Platform::Minimum(rcac.top + heightLB, rcClient.bottom);
+	ac.lb.SetPositionRelative(rcac, wMain);
+	ac.lb.SetFont(vs.styles[0].font);
+
+	int maxStrLen = ac.SetList(list);
+
+	// Fiddle the position of the list so it is right next to the target and wide enough for all its strings
+	PRectangle rcList = ac.lb.GetPosition();
+	int heightAlloced = rcList.bottom - rcList.top;
+	// Make an allowance for large strings in list
+	rcList.left = pt.x - 5;
+	rcList.right = rcList.left + Platform::Maximum(widthLB, maxStrLen * 8 + 16);
+	if (pt.y >= rcClient.bottom - heightLB && // Wont fit below.
+	    pt.y >= (rcClient.bottom + rcClient.top) / 2) { // and there is more room above.
+		rcList.top = pt.y - heightAlloced;
+	} else {
+		rcList.top = pt.y + vs.lineHeight;
+	}
+	rcList.bottom = rcList.top + heightAlloced;
+	ac.lb.SetPositionRelative(rcList, wMain);
+	//lbAutoComplete.SetPosition(rcList);
+	ac.Show();
+}
+
+void ScintillaBase::AutoCompleteCancel() {
+	ac.Cancel();
+}
+
+void ScintillaBase::AutoCompleteMove(int delta) {
+	ac.Move(delta);
+}
+
+void ScintillaBase::AutoCompleteChanged(char ch) {
+	if (currentPos <= ac.posStart) {
+		ac.Cancel();
+	} else if (ac.IsStopChar(ch)) {
+		ac.Cancel();
+	} else {
+		char wordCurrent[1000];
+		int i;
+		int startWord = ac.posStart - ac.startLen;
+		for (i = startWord; i < currentPos; i++)
+			wordCurrent[i - startWord] = pdoc->CharAt(i);
+		wordCurrent[i - startWord] = '\0';
+		ac.Select(wordCurrent);
+	}
+}
+
+void ScintillaBase::AutoCompleteCompleted() {
+	int item = ac.lb.GetSelection();
+	char selected[200];
+	if (item != -1) {
+		ac.lb.GetValue(item, selected, sizeof(selected));
+	}
+	ac.Cancel();
+	if (currentPos != ac.posStart) {
+		pdoc->DeleteChars(ac.posStart, currentPos - ac.posStart);
+	}
+	SetEmptySelection(ac.posStart);
+	if (item != -1) {
+		pdoc->InsertString(currentPos, selected + ac.startLen);
+		SetEmptySelection(currentPos + strlen(selected + ac.startLen));
+	}
+}
+
+void ScintillaBase::ContextMenu(Point pt) {
+	popup.CreatePopUp();
+	AddToPopUp("Undo", idcmdUndo, pdoc->CanUndo());
+	AddToPopUp("Redo", idcmdRedo, pdoc->CanRedo());
+	AddToPopUp("");
+	AddToPopUp("Cut", idcmdCut, currentPos != anchor);
+	AddToPopUp("Copy", idcmdCopy, currentPos != anchor);
+	AddToPopUp("Paste", idcmdPaste, WndProc(EM_CANPASTE, 0, 0));
+	AddToPopUp("Delete", idcmdDelete, currentPos != anchor);
+	AddToPopUp("");
+	AddToPopUp("Select All", idcmdSelectAll);
+	popup.Show(pt, wMain);
+}
+
+void ScintillaBase::ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) {
+	AutoCompleteCancel();
+	ct.CallTipCancel();
+	Editor::ButtonDown(pt, curTime, shift, ctrl, alt);
+}
+
+#ifdef SCI_LEXER
+void ScintillaBase::Colourise(int start, int end) {
+	int lengthDoc = Platform::SendScintilla(wMain.GetID(), SCI_GETLENGTH, 0, 0);
+	if (end == -1)
+		end = lengthDoc;
+	int len = end - start;
+
+	StylingContext styler(wMain.GetID(), props);
+
+	int styleStart = 0;
+	if (start > 0)
+		styleStart = styler.StyleAt(start - 1);
+	styler.SetCodePage(pdoc->dbcsCodePage);
+	
+	LexerModule::Colourise(start, len, styleStart, lexLanguage, keyWordLists, styler);
+	styler.Flush();
+}
+#endif
+
+void ScintillaBase::NotifyStyleNeeded(int endStyleNeeded) {
+#ifdef SCI_LEXER
+	if (lexLanguage != SCLEX_CONTAINER) {
+		int endStyled = Platform::SendScintilla(wMain.GetID(), SCI_GETENDSTYLED, 0, 0);
+		int lineEndStyled = Platform::SendScintilla(wMain.GetID(), EM_LINEFROMCHAR, endStyled, 0);
+		endStyled = Platform::SendScintilla(wMain.GetID(), EM_LINEINDEX, lineEndStyled, 0);
+		Colourise(endStyled, endStyleNeeded);
+		return;
+	}
+#endif
+	Editor::NotifyStyleNeeded(endStyleNeeded);
+}
+
+LRESULT ScintillaBase::WndProc(UINT iMessage, WPARAM wParam, LPARAM lParam) {
+	switch (iMessage) {
+	case SCI_AUTOCSHOW:
+		AutoCompleteStart(wParam, reinterpret_cast<const char *>(lParam));
+		break;
+
+	case SCI_AUTOCCANCEL:
+		AutoCompleteCancel();
+		break;
+
+	case SCI_AUTOCACTIVE:
+		return ac.Active();
+
+	case SCI_AUTOCPOSSTART:
+		return ac.posStart;
+
+	case SCI_AUTOCCOMPLETE:
+		AutoCompleteCompleted();
+		break;
+
+	case SCI_AUTOCSTOPS:
+		ac.SetStopChars(reinterpret_cast<char *>(lParam));
+		break;
+
+	case SCI_CALLTIPSHOW: {
+			AutoCompleteCancel();
+			if (!ct.wCallTip.Created()) {
+				PRectangle rc = ct.CallTipStart(currentPos, LocationFromPosition(wParam),
+				                                reinterpret_cast<char *>(lParam),
+				                                vs.styles[0].fontName, vs.styles[0].size);
+				// If the call-tip window would be out of the client
+				// space, adjust so it displays above the text.
+				PRectangle rcClient = GetClientRectangle();
+				if (rc.bottom > rcClient.bottom) {
+					int offset = vs.lineHeight + rc.Height();
+					rc.top -= offset;
+					rc.bottom -= offset;
+				}
+				// Now display the window.
+				CreateCallTipWindow(rc);
+				ct.wCallTip.SetPositionRelative(rc, wDraw);
+				ct.wCallTip.Show();
+			}
+		}
+		break;
+
+	case SCI_CALLTIPCANCEL:
+		ct.CallTipCancel();
+		break;
+
+	case SCI_CALLTIPACTIVE:
+		return ct.inCallTipMode;
+
+	case SCI_CALLTIPPOSSTART:
+		return ct.posStartCallTip;
+
+	case SCI_CALLTIPSETHLT:
+		ct.SetHighlight(wParam, lParam);
+		break;
+
+	case SCI_CALLTIPSETBACK:
+		ct.colourBG = Colour(wParam);
+		InvalidateStyleRedraw();
+		break;
+		
+#ifdef SCI_LEXER
+	case SCI_SETLEXER:
+		lexLanguage = wParam;
+		break;
+		
+	case SCI_GETLEXER:
+		return lexLanguage;
+		
+	case SCI_COLOURISE:
+		Colourise(wParam, lParam);
+		break;
+		
+	case SCI_SETPROPERTY:
+		props.Set(reinterpret_cast<const char *>(wParam), 
+			reinterpret_cast<const char *>(lParam));
+		break;
+		
+	case SCI_SETKEYWORDS:
+		if ((wParam >= 0) && (wParam < numWordLists)) {
+			keyWordLists[wParam]->Clear();
+			keyWordLists[wParam]->Set(reinterpret_cast<const char *>(lParam));
+		}
+		break;
+#endif
+
+	default:
+		return Editor::WndProc(iMessage, wParam, lParam);
+	}
+	return 0l;
+}

contrib/src/stc/scintilla/src/ScintillaBase.h

@@ -0,0 +1,68 @@
+// Scintilla source code edit control
+// ScintillaBase.h - defines an enhanced subclass of Editor with calltips, autocomplete and context menu
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SCINTILLABASE_H
+#define SCINTILLABASE_H
+
+class ScintillaBase : public Editor {
+protected:
+	// Enumeration of commands and child windows
+	enum {
+		idCallTip=1,
+		idAutoComplete=2,
+		
+		idcmdUndo=10,
+		idcmdRedo=11,
+		idcmdCut=12,
+		idcmdCopy=13,
+		idcmdPaste=14,
+		idcmdDelete=15,
+		idcmdSelectAll=16
+	};
+
+	Menu popup;
+	AutoComplete ac;
+
+	CallTip ct;
+
+#ifdef SCI_LEXER
+	int lexLanguage;
+	PropSet props;
+	enum {numWordLists=5};
+	WordList *keyWordLists[numWordLists];
+	void Colourise(int start, int end);
+#endif
+
+	ScintillaBase();
+	virtual ~ScintillaBase();
+	virtual void Initialise() = 0;
+	virtual void Finalise() = 0;
+
+	virtual void RefreshColourPalette(Palette &pal, bool want);
+	
+	virtual void AddChar(char ch);
+	void Command(int cmdId);
+	virtual int KeyCommand(UINT iMessage);
+	
+	void AutoCompleteStart(int lenEntered, const char *list);
+	void AutoCompleteCancel();
+	void AutoCompleteMove(int delta);
+	void AutoCompleteChanged(char ch=0);
+	void AutoCompleteCompleted();
+
+	virtual void CreateCallTipWindow(PRectangle rc) = 0;
+		
+	virtual void AddToPopUp(const char *label, int cmd=0, bool enabled=true) = 0;
+	void ContextMenu(Point pt);
+	
+	virtual void ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt);
+
+	virtual void NotifyStyleNeeded(int endStyleNeeded);
+public:
+	// Public so scintilla_send_message can use it
+	virtual LRESULT WndProc(UINT iMessage, WPARAM wParam, LPARAM lParam);
+};
+
+#endif

contrib/src/stc/scintilla/src/Style.cxx

@@ -0,0 +1,101 @@
+// Scintilla source code edit control
+// Style.cxx - defines the font and colour style for a class of text
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <string.h>
+
+#include "Platform.h"
+
+#include "Style.h"
+
+Style::Style() {
+	aliasOfDefaultFont = true;
+	Clear(Colour(0,0,0), Colour(0xff,0xff,0xff),
+	        Platform::DefaultFontSize(), 0,
+		false, false, false);
+}
+	
+Style::~Style() {
+	if (aliasOfDefaultFont)
+		font.SetID(0);
+	else
+		font.Release();
+	aliasOfDefaultFont = false;
+}
+
+Style &Style::operator=(const Style &source) {
+	if (this == &source)
+		return *this;
+	Clear(Colour(0,0,0), Colour(0xff,0xff,0xff),
+	        0, 0,
+		false, false, false);
+	fore.desired = source.fore.desired;
+	back.desired = source.back.desired;
+	bold = source.bold;
+	italic = source.italic;
+	size = source.size;
+	eolFilled = source.eolFilled;
+	return *this;
+}
+
+void Style::Clear(Colour fore_, Colour back_, int size_, const char *fontName_, 
+	bool bold_, bool italic_, bool eolFilled_) {
+	fore.desired = fore_;
+	back.desired = back_;
+	bold = bold_;
+	italic = italic_;
+	size = size_;
+	fontName = fontName_;
+	eolFilled = eolFilled_;
+	if (aliasOfDefaultFont)
+		font.SetID(0);
+	else 
+		font.Release();
+	aliasOfDefaultFont = false;
+}
+
+bool Style::EquivalentFontTo(const Style *other) const {
+	if (bold != other->bold ||
+		italic != other->italic ||
+		size != other->size)
+		return false;
+	if (fontName == other->fontName)
+		return true;
+	if (!fontName)
+		return false;
+	if (!other->fontName)
+		return false;
+	return strcmp(fontName, other->fontName) == 0;
+}
+
+void Style::Realise(Surface &surface, int zoomLevel, Style *defaultStyle) {
+	int sizeZoomed = size + zoomLevel;
+	if (sizeZoomed <= 2)	// Hangs if sizeZoomed <= 1
+		sizeZoomed = 2;
+
+	if (aliasOfDefaultFont)
+		font.SetID(0);
+	else 
+		font.Release();		
+	int deviceHeight = (sizeZoomed * surface.LogPixelsY()) / 72;
+	aliasOfDefaultFont = defaultStyle && 
+		(EquivalentFontTo(defaultStyle) || !fontName);
+	if (aliasOfDefaultFont) {
+		font.SetID(defaultStyle->font.GetID());
+	} else if (fontName) {
+		font.Create(fontName, deviceHeight, bold, italic);
+	} else {
+		font.SetID(0);
+	}
+
+	ascent = surface.Ascent(font);
+	descent = surface.Descent(font);
+	// Probably more typographically correct to include leading
+	// but that means more complex drawing as leading must be erased
+	//lineHeight = surface.ExternalLeading() + surface.Height();
+	externalLeading = surface.ExternalLeading(font);
+	lineHeight = surface.Height(font);
+	aveCharWidth = surface.AverageCharWidth(font);
+	spaceWidth = surface.WidthChar(font, ' ');
+}

contrib/src/stc/scintilla/src/Style.h

@@ -0,0 +1,39 @@
+// Scintilla source code edit control
+// Style.h - defines the font and colour style for a class of text
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef STYLE_H
+#define STYLE_H
+
+class Style {
+public:
+	ColourPair fore;
+	ColourPair back;
+	bool aliasOfDefaultFont;
+	bool bold;
+	bool italic;
+	int size;
+	const char *fontName;
+	bool eolFilled;
+
+	Font font;
+	unsigned int lineHeight;
+	unsigned int ascent;
+	unsigned int descent;
+	unsigned int externalLeading;
+	unsigned int aveCharWidth;
+	unsigned int spaceWidth;
+
+	Style();
+	~Style();
+	Style &operator=(const Style &source);
+	void Clear(Colour fore_, Colour back_,
+           	int size_, 
+		const char *fontName_, 
+		bool bold_, bool italic_, bool eolFilled_);
+	bool EquivalentFontTo(const Style *other) const;
+	void Realise(Surface &surface, int zoomLevel, Style *defaultStyle=0);
+};
+
+#endif

contrib/src/stc/scintilla/src/ViewStyle.cxx

@@ -0,0 +1,227 @@
+// Scintilla source code edit control
+// ViewStyle.cxx - store information on how the document is to be viewed
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <string.h>
+
+#include "Platform.h"
+
+#include "Scintilla.h"
+#include "Indicator.h"
+#include "LineMarker.h"
+#include "Style.h"
+#include "ViewStyle.h"
+
+MarginStyle::MarginStyle() : 
+	symbol(false), width(16), mask(0xffffffff), sensitive(false) {
+}
+
+// A list of the fontnames - avoids wasting space in each style
+FontNames::FontNames() {
+	max = 0;
+}
+
+FontNames::~FontNames() {
+	Clear();
+}
+
+void FontNames::Clear() {
+	for (int i=0;i<max;i++) {
+		delete []names[i];
+	}
+	max = 0;
+}
+
+const char *FontNames::Save(const char *name) {
+	if (!name)
+		return 0;
+	for (int i=0;i<max;i++) {
+		if (strcmp(names[i], name) == 0) {
+			return names[i];
+		}
+	}
+	names[max] = new char[strlen(name) + 1];
+	strcpy(names[max], name);
+	max++;
+	return names[max-1];
+}
+
+ViewStyle::ViewStyle() {
+	Init();
+}
+
+ViewStyle::ViewStyle(const ViewStyle &source) {
+	Init();
+	for (unsigned int sty=0;sty<(sizeof(styles)/sizeof(styles[0]));sty++) {
+		styles[sty] = source.styles[sty];
+		// Can't just copy fontname as its lifetime is relative to its owning ViewStyle
+		styles[sty].fontName = fontNames.Save(source.styles[sty].fontName);
+	}
+	for (int mrk=0;mrk<=MARKER_MAX;mrk++) {
+		markers[mrk] = source.markers[mrk];
+	}
+	for (int ind=0;ind<=INDIC_MAX;ind++) {
+		indicators[ind] = source.indicators[ind];
+	}
+	
+	selforeset = source.selforeset;
+	selforeground.desired = source.selforeground.desired;
+	selbackset = source.selbackset;
+	selbackground.desired = source.selbackground.desired;
+	selbar.desired = source.selbar.desired;
+	selbarlight.desired = source.selbarlight.desired;
+	caretcolour.desired = source.caretcolour.desired;
+	edgecolour.desired = source.edgecolour.desired;
+	leftMarginWidth = source.leftMarginWidth;
+	rightMarginWidth = source.rightMarginWidth;
+	for (int i=0;i < margins; i++) {
+		ms[i] = source.ms[i];
+	}
+	symbolMargin = source.symbolMargin;
+	maskInLine = source.maskInLine;
+	fixedColumnWidth = source.fixedColumnWidth;
+	zoomLevel = source.zoomLevel;
+	viewWhitespace = source.viewWhitespace;
+	viewEOL = source.viewEOL;
+	showMarkedLines = source.showMarkedLines;		
+}
+
+ViewStyle::~ViewStyle() {
+}
+
+void ViewStyle::Init() {
+	fontNames.Clear();
+	ResetDefaultStyle();
+	
+	indicators[0].style = INDIC_SQUIGGLE;
+	indicators[0].fore = Colour(0, 0x7f, 0);
+	indicators[1].style = INDIC_TT;
+	indicators[1].fore = Colour(0, 0, 0xff);
+	indicators[2].style = INDIC_PLAIN;
+	indicators[2].fore = Colour(0xff, 0, 0);
+
+	lineHeight = 1;
+	maxAscent = 1;
+	maxDescent = 1;
+	aveCharWidth = 8;
+	spaceWidth = 8;
+
+	selforeset = false;
+	selforeground.desired = Colour(0xff, 0, 0);
+	selbackset = true;
+	selbackground.desired = Colour(0xc0, 0xc0, 0xc0);
+	selbar.desired = Platform::Chrome();
+	selbarlight.desired = Platform::ChromeHighlight();
+	styles[STYLE_LINENUMBER].fore.desired = Colour(0, 0, 0);
+	styles[STYLE_LINENUMBER].back.desired = Platform::Chrome();
+	//caretcolour.desired = Colour(0xff, 0, 0);
+	caretcolour.desired = Colour(0, 0, 0);
+	edgecolour.desired = Colour(0xc0, 0xc0, 0xc0);
+	
+	leftMarginWidth = 1;
+	rightMarginWidth = 1;
+	ms[0].symbol = false;
+	ms[0].width = 0;
+	ms[0].mask = 0;
+	ms[1].symbol = true;
+	ms[1].width = 16;
+	ms[1].mask = ~SC_MASK_FOLDERS;
+	ms[2].symbol = true;
+	ms[2].width = 14;	// Nice width for arrows
+	ms[2].mask = SC_MASK_FOLDERS;
+	ms[2].width = 0;	// Nice width for arrows
+	ms[2].mask = 0;
+	fixedColumnWidth = leftMarginWidth;
+	symbolMargin = false;
+	maskInLine = 0xffffffff;
+	for (int margin=0; margin < margins; margin++) {
+		fixedColumnWidth += ms[margin].width;
+		symbolMargin = symbolMargin || ms[margin].symbol;
+		if (ms[margin].width > 0)
+			maskInLine &= ~ms[margin].mask;
+	}
+	zoomLevel = 0;
+	viewWhitespace = false;
+	viewEOL = false;
+	showMarkedLines = true;
+}
+
+void ViewStyle::RefreshColourPalette(Palette &pal, bool want) {
+	unsigned int i;
+	for (i=0;i<(sizeof(styles)/sizeof(styles[0]));i++) {
+		pal.WantFind(styles[i].fore, want);
+		pal.WantFind(styles[i].back, want);
+	}
+	for (i=0;i<(sizeof(indicators)/sizeof(indicators[0]));i++) {
+		pal.WantFind(indicators[i].fore, want);
+	}
+	for (i=0;i<(sizeof(markers)/sizeof(markers[0]));i++) {
+		pal.WantFind(markers[i].fore, want);
+		pal.WantFind(markers[i].back, want);
+	}
+	pal.WantFind(selforeground, want);
+	pal.WantFind(selbackground, want);
+	pal.WantFind(selbar, want);
+	pal.WantFind(selbarlight, want);
+	pal.WantFind(caretcolour, want);
+	pal.WantFind(edgecolour, want);
+}
+
+void ViewStyle::Refresh(Surface &surface) {
+	selbar.desired = Platform::Chrome();
+	selbarlight.desired = Platform::ChromeHighlight();
+	styles[STYLE_DEFAULT].Realise(surface, zoomLevel);
+	maxAscent = styles[STYLE_DEFAULT].ascent;
+	maxDescent = styles[STYLE_DEFAULT].descent;
+	for (unsigned int i=0;i<(sizeof(styles)/sizeof(styles[0]));i++) {
+		if (i != STYLE_DEFAULT) {
+			styles[i].Realise(surface, zoomLevel, &styles[STYLE_DEFAULT]);
+			if (maxAscent < styles[i].ascent)
+				maxAscent = styles[i].ascent;
+			if (maxDescent < styles[i].descent)
+				maxDescent = styles[i].descent;
+		}
+	}
+	
+	lineHeight = maxAscent + maxDescent;
+	aveCharWidth = styles[STYLE_DEFAULT].aveCharWidth;
+	spaceWidth = styles[STYLE_DEFAULT].spaceWidth;
+
+	fixedColumnWidth = leftMarginWidth;
+	symbolMargin = false;
+	maskInLine = 0xffffffff;
+	for (int margin=0; margin < margins; margin++) {
+		fixedColumnWidth += ms[margin].width;
+		symbolMargin = symbolMargin || ms[margin].symbol;
+		if (ms[margin].width > 0)
+			maskInLine &= ~ms[margin].mask;
+	}
+}
+
+void ViewStyle::ResetDefaultStyle() {
+	styles[STYLE_DEFAULT].Clear(Colour(0,0,0), Colour(0xff,0xff,0xff),
+	        Platform::DefaultFontSize(), fontNames.Save(Platform::DefaultFont()),
+		false, false, false);
+}
+
+void ViewStyle::ClearStyles() {
+	// Reset all styles to be like the default style
+	for (unsigned int i=0;i<(sizeof(styles)/sizeof(styles[0]));i++) {
+		if (i != STYLE_DEFAULT) {
+			styles[i].Clear(
+				styles[STYLE_DEFAULT].fore.desired, 
+				styles[STYLE_DEFAULT].back.desired, 
+				styles[STYLE_DEFAULT].size, 
+				styles[STYLE_DEFAULT].fontName, 
+				styles[STYLE_DEFAULT].bold, 
+				styles[STYLE_DEFAULT].italic,
+				styles[STYLE_DEFAULT].eolFilled);
+		}
+	}
+	styles[STYLE_LINENUMBER].back.desired = Platform::Chrome();
+}
+
+void ViewStyle::SetStyleFontName(int styleIndex, const char *name) {
+	styles[styleIndex].fontName = fontNames.Save(name);
+}

contrib/src/stc/scintilla/src/ViewStyle.h

@@ -0,0 +1,72 @@
+// Scintilla source code edit control
+// ViewStyle.h - store information on how the document is to be viewed
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef VIEWSTYLE_H
+#define VIEWSTYLE_H
+
+class MarginStyle {
+public:
+	bool symbol;
+	int width;
+	int mask;
+	bool sensitive;
+	MarginStyle();
+};
+
+class FontNames {
+private:
+	char *names[STYLE_MAX + 1];
+	int max;
+public:
+	FontNames();
+	~FontNames();
+	void Clear();
+	const char *Save(const char *name);
+};
+
+class ViewStyle {
+public:
+	FontNames fontNames;
+	Style styles[STYLE_MAX + 1];
+	LineMarker markers[MARKER_MAX + 1];
+	Indicator indicators[INDIC_MAX + 1];
+	int lineHeight;
+	unsigned int maxAscent;
+	unsigned int maxDescent;
+	unsigned int aveCharWidth;
+	unsigned int spaceWidth;
+	bool selforeset;
+	ColourPair selforeground;
+	bool selbackset;
+	ColourPair selbackground;
+	ColourPair selbar;
+	ColourPair selbarlight;
+	// Margins are ordered: Line Numbers, Selection Margin, Spacing Margin
+	int leftMarginWidth;		// Spacing margin on left of text
+	int rightMarginWidth;	// Spacing margin on left of text
+	enum { margins=3 };
+	bool symbolMargin;
+	int maskInLine;	// Mask for markers to be put into text because there is nowhere for them to go in margin
+	MarginStyle ms[margins];
+	int fixedColumnWidth;
+	int zoomLevel;
+	bool viewWhitespace;
+	bool viewEOL;
+	bool showMarkedLines;
+	ColourPair caretcolour;
+	ColourPair edgecolour;
+	
+	ViewStyle();
+	ViewStyle(const ViewStyle &source);
+	~ViewStyle();
+	void Init();
+	void RefreshColourPalette(Palette &pal, bool want);
+	void Refresh(Surface &surface);
+	void ResetDefaultStyle();
+	void ClearStyles();
+	void SetStyleFontName(int styleIndex, const char *name);
+};
+
+#endif

docs/latex/wx/accel.tex

@@ -1,206 +0,0 @@
-\section{\class{wxAcceleratorEntry}}\label{wxacceleratorentry}
-
-An object used by an application wishing to create an \helpref{accelerator table}{wxacceleratortable}.
-
-\wxheading{Derived from}
-
-None
-
-\wxheading{Include files}
-
-<wx/accel.h>
-
-\wxheading{See also}
-
-\helpref{wxAcceleratorTable}{wxacceleratortable}, \helpref{wxWindow::SetAcceleratorTable}{wxwindowsetacceleratortable}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxAcceleratorEntry::wxAcceleratorEntry}\label{wxacceleratorentryconstr}
-
-\func{}{wxAcceleratorEntry}{\void}
-
-Default constructor.
-
-\func{}{wxAcceleratorEntry}{\param{int}{ flags}, \param{int}{ keyCode}, \param{int}{ cmd}}
-
-Constructor.
-
-\wxheading{Parameters}
-
-\docparam{flags}{One of wxACCEL\_ALT, wxACCEL\_SHIFT, wxACCEL\_CTRL and wxACCEL\_NORMAL. Indicates
-which modifier key is held down.}
-
-\docparam{keyCode}{The keycode to be detected. See \helpref{Keycodes}{keycodes} for a full list of keycodes.}
-
-\docparam{cmd}{The menu or control command identifier.}
-
-\membersection{wxAcceleratorEntry::GetCommand}\label{wxacceleratorentrygetcommand}
-
-\constfunc{int}{GetCommand}{\void}
-
-Returns the command identifier for the accelerator table entry.
-
-\membersection{wxAcceleratorEntry::GetFlags}\label{wxacceleratorentrygetflags}
-
-\constfunc{int}{GetFlags}{\void}
-
-Returns the flags for the accelerator table entry.
-
-\membersection{wxAcceleratorEntry::GetKeyCode}\label{wxacceleratorentrygetkeycode}
-
-\constfunc{int}{GetKeyCode}{\void}
-
-Returns the keycode for the accelerator table entry.
-
-\membersection{wxAcceleratorEntry::Set}\label{wxacceleratorentryset}
-
-\func{void}{Set}{\param{int}{ flags}, \param{int}{ keyCode}, \param{int}{ cmd}}
-
-Sets the accelerator entry parameters.
-
-\wxheading{Parameters}
-
-\docparam{flags}{One of wxACCEL\_ALT, wxACCEL\_SHIFT, wxACCEL\_CTRL and wxACCEL\_NORMAL. Indicates
-which modifier key is held down.}
-
-\docparam{keyCode}{The keycode to be detected. See \helpref{Keycodes}{keycodes} for a full list of keycodes.}
-
-\docparam{cmd}{The menu or control command identifier.}
-
-\section{\class{wxAcceleratorTable}}\label{wxacceleratortable}
-
-An accelerator table allows the application to specify a table of keyboard shortcuts for
-menus or other commands. On Windows, menu or button commands are supported; on GTK,
-only menu commands are supported.
-
-The object {\bf wxNullAcceleratorTable} is defined to be a table with no data, and is the
-initial accelerator table for a window.
-
-\wxheading{Derived from}
-
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/accel.h>
-
-\wxheading{Example}
-
-{\small%
-\begin{verbatim}
-  wxAcceleratorEntry entries[4];
-  entries[0].Set(wxACCEL_CTRL,  (int) 'N',     ID_NEW_WINDOW);
-  entries[1].Set(wxACCEL_CTRL,  (int) 'X',     wxID_EXIT);
-  entries[2].Set(wxACCEL_SHIFT, (int) 'A',     ID_ABOUT);
-  entries[3].Set(wxACCEL_NORMAL,  WXK_DELETE,    wxID_CUT);
-  wxAcceleratorTable accel(4, entries);
-  frame->SetAcceleratorTable(accel);
-\end{verbatim}
-}
-
-\wxheading{Remarks}
-
-An accelerator takes precedence over normal processing and can be a convenient way to program some event handling.
-For example, you can use an accelerator table to enable a dialog with a multi-line text control to
-accept CTRL-Enter as meaning `OK' (but not in GTK at present).
-
-\wxheading{See also}
-
-\helpref{wxAcceleratorEntry}{wxacceleratorentry}, \helpref{wxWindow::SetAcceleratorTable}{wxwindowsetacceleratortable}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxAcceleratorTable::wxAcceleratorTable}\label{wxacceleratortableconstr}
-
-\func{}{wxAcceleratorTable}{\void}
-
-Default constructor.
-
-\func{}{wxAcceleratorTable}{\param{const wxAcceleratorTable\& }{bitmap}}
-
-Copy constructor.
-
-\func{}{wxAcceleratorTable}{\param{int}{ n}, \param{wxAcceleratorEntry}{ entries[]}}
-
-Creates from an array of \helpref{wxAcceleratorEntry}{wxacceleratorentry} objects.
-
-\func{}{wxAcceleratorTable}{\param{const wxString\&}{ resource}}
-
-Loads the accelerator table from a Windows resource (Windows only).
-
-\wxheading{Parameters}
-
-\docparam{n}{Number of accelerator entries.}
-
-\docparam{entries}{The array of entries.}
-
-\docparam{resource}{Name of a Windows accelerator.}
-
-\pythonnote{The wxPython constructor accepts a list of
-wxAcceleratorEntry objects, or 3-tuples consisting of flags, keyCode,
-and cmd values like you would construct wxAcceleratorEntry objects with.}
-
-\perlnote{The wxPerl constructor accepts a list of either
-  Wx::AcceleratorEntry objects or references to 3-element arrays
-  ( flags, keyCode, cmd ), like the parameters of Wx::AcceleratorEntry::new.}
-
-\membersection{wxAcceleratorTable::\destruct{wxAcceleratorTable}}
-
-\func{}{\destruct{wxAcceleratorTable}}{\void}
-
-Destroys the wxAcceleratorTable object.
-
-\membersection{wxAcceleratorTable::Ok}\label{wxacceleratortableok}
-
-\constfunc{bool}{Ok}{\void}
-
-Returns TRUE if the accelerator table is valid.
-
-\membersection{wxAcceleratorTable::operator $=$}
-
-\func{wxAcceleratorTable\& }{operator $=$}{\param{const wxAcceleratorTable\& }{accel}}
-
-Assignment operator. This operator does not copy any data, but instead
-passes a pointer to the data in {\it accel} and increments a reference
-counter. It is a fast operation.
-
-\wxheading{Parameters}
-
-\docparam{accel}{Accelerator table to assign.}
-
-\wxheading{Return value}
-
-Returns reference to this object.
-
-\membersection{wxAcceleratorTable::operator $==$}
-
-\func{bool}{operator $==$}{\param{const wxAcceleratorTable\& }{accel}}
-
-Equality operator. This operator tests whether the internal data pointers are
-equal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{accel}{Accelerator table to compare with}
-
-\wxheading{Return value}
-
-Returns TRUE if the accelerator tables were effectively equal, FALSE otherwise.
-
-\membersection{wxAcceleratorTable::operator $!=$}
-
-\func{bool}{operator $!=$}{\param{const wxAcceleratorTable\& }{accel}}
-
-Inequality operator. This operator tests whether the internal data pointers are
-unequal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{accel}{Accelerator table to compare with}
-
-\wxheading{Return value}
-
-Returns TRUE if the accelerator tables were unequal, FALSE otherwise.
-
-

docs/latex/wx/activevt.tex

@@ -1,61 +0,0 @@
-\section{\class{wxActivateEvent}}\label{wxactivateevent}
-
-An activate event is sent when a window or application is being activated
-or deactivated.
-
-\wxheading{Derived from}
-
-\helpref{wxEvent}{wxevent}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/event.h>
-
-\wxheading{Event table macros}
-
-To process an activate event, use these event handler macros to direct input to a member
-function that takes a wxActivateEvent argument.
-
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_ACTIVATE(func)}}{Process a wxEVT\_ACTIVATE event.}
-\twocolitem{{\bf EVT\_ACTIVATE\_APP(func)}}{Process a wxEVT\_ACTIVATE\_APP event.}
-\end{twocollist}%
-
-\wxheading{Remarks}
-
-A top-level window (a dialog or frame) receives an activate event when is
-being activated or deactivated. This is indicated visually by the title
-bar changing colour, and a subwindow gaining the keyboard focus.
-
-An application is activated or deactivated when one of its frames becomes activated,
-or a frame becomes inactivate resulting in all application frames being inactive. (Windows only)
-
-\wxheading{See also}
-
-%\helpref{wxWindow::OnActivate}{wxwindowonactivate},\rtfsp
-%% GD: OnXXX functions are not documented
-%%\helpref{wxApp::OnActivate}{wxapponactivate},\rtfsp
-\helpref{Event handling overview}{eventhandlingoverview}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxActivateEvent::wxActivateEvent}
-
-\func{}{wxActivateEvent}{\param{WXTYPE }{eventType = 0}, \param{bool}{ active = TRUE}, \param{int }{id = 0}}
-
-Constructor.
-
-\membersection{wxActivateEvent::m\_active}
-
-\member{bool}{m\_active}
-
-TRUE if the window or application was activated.
-
-\membersection{wxActivateEvent::GetActive}\label{wxactivateeventgetactive}
-
-\constfunc{bool}{GetActive}{\void}
-
-Returns TRUE if the application or window is being activated, FALSE otherwise.
-

docs/latex/wx/app.tex

@@ -1,636 +0,0 @@
-\section{\class{wxApp}}\label{wxapp}
-
-The {\bf wxApp} class represents the application itself. It is used
-to:
-
-\begin{itemize}\itemsep=0pt
-\item set and get application-wide properties;
-\item implement the windowing system message or event loop;
-\item initiate application processing via \helpref{wxApp::OnInit}{wxapponinit};
-\item allow default processing of events not handled by other
-objects in the application.
-\end{itemize}
-
-You should use the macro IMPLEMENT\_APP(appClass) in your application implementation
-file to tell wxWindows how to create an instance of your application class.
-
-Use DECLARE\_APP(appClass) in a header file if you want the wxGetApp function (which returns
-a reference to your application object) to be visible to other files.
-
-\wxheading{Derived from}
-
-\helpref{wxEvtHandler}{wxevthandler}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/app.h>
-
-\wxheading{See also}
-
-\helpref{wxApp overview}{wxappoverview}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxApp::wxApp}
-
-\func{void}{wxApp}{\void}
-
-Constructor. Called implicitly with a definition of a wxApp object.
-
-\membersection{wxApp::\destruct{wxApp}}
-
-\func{void}{\destruct{wxApp}}{\void}
-
-Destructor. Will be called implicitly on program exit if the wxApp
-object is created on the stack.
-
-\membersection{wxApp::argc}\label{wxappargc}
-
-\member{int}{argc}
-
-Number of command line arguments (after environment-specific processing).
-
-\membersection{wxApp::argv}\label{wxappargv}
-
-\member{char **}{argv}
-
-Command line arguments (after environment-specific processing).
-
-\membersection{wxApp::CreateLogTarget}\label{wxappcreatelogtarget}
-
-\func{virtual wxLog*}{CreateLogTarget}{\void}
-
-Creates a wxLog class for the application to use for logging errors. The default
-implementation returns a new wxLogGui class.
-
-\wxheading{See also}
-
-\helpref{wxLog}{wxlog}
-
-\membersection{wxApp::Dispatch}\label{wxappdispatch}
-
-\func{void}{Dispatch}{\void}
-
-Dispatches the next event in the windowing system event queue.
-
-This can be used for programming event loops, e.g.
-
-\begin{verbatim}
-  while (app.Pending())
-    Dispatch();
-\end{verbatim}
-
-\wxheading{See also}
-
-\helpref{wxApp::Pending}{wxapppending}
-
-\membersection{wxApp::FilterEvent}\label{wxappfilterevent}
-
-\func{int}{FilterEvent}{\param{wxEvent\& }{event}}
-
-This function is called before processing any event and allows the application
-to preempt the processing of some events. If this method returns $-1$ the event
-is processed normally, otherwise either {\tt TRUE} or {\tt FALSE} should be
-returned and the event processing stops immediately considering that the event
-had been already processed (for the former return value) or that it is not
-going to be processed at all (for the latter one).
-
-\membersection{wxApp::GetAppName}\label{wxappgetappname}
-
-\constfunc{wxString}{GetAppName}{\void}
-
-Returns the application name.
-
-\wxheading{Remarks}
-
-wxWindows sets this to a reasonable default before
-calling \helpref{wxApp::OnInit}{wxapponinit}, but the application can reset it at will.
-
-\membersection{wxApp::GetAuto3D}\label{wxappgetauto3d}
-
-\constfunc{bool}{GetAuto3D}{\void}
-
-Returns TRUE if 3D control mode is on, FALSE otherwise.
-
-\wxheading{See also}
-
-\helpref{wxApp::SetAuto3D}{wxappsetauto3d}
-
-\membersection{wxApp::GetClassName}\label{wxappgetclassname}
-
-\constfunc{wxString}{GetClassName}{\void}
-
-Gets the class name of the application. The class name may be used in a platform specific
-manner to refer to the application.
-
-\wxheading{See also}
-
-\helpref{wxApp::SetClassName}{wxappsetclassname}
-
-\membersection{wxApp::GetExitOnFrameDelete}\label{wxappgetexitonframedelete}
-
-\constfunc{bool}{GetExitFrameOnDelete}{\void}
-
-Returns TRUE if the application will exit when the top-level window is deleted, FALSE
-otherwise.
-
-\wxheading{See also}
-
-\helpref{wxApp::SetExitOnFrameDelete}{wxappsetexitonframedelete},\\
-\helpref{wxApp shutdown overview}{wxappshutdownoverview}
-
-\membersection{wxApp::GetTopWindow}\label{wxappgettopwindow}
-
-\constfunc{virtual wxWindow *}{GetTopWindow}{\void}
-
-Returns a pointer to the top window.
-
-\wxheading{Remarks}
-
-If the top window hasn't been set using \helpref{wxApp::SetTopWindow}{wxappsettopwindow}, this
-function will find the first top-level window (frame or dialog) and return that.
-
-\wxheading{See also}
-
-\helpref{SetTopWindow}{wxappsettopwindow}
-
-\membersection{wxApp::GetUseBestVisual}\label{wxappgetusebestvisual}
-
-\constfunc{bool}{GetUseBestVisual}{\void}
-
-Returns TRUE if the application will use the best visual on systems that support
-different visuals, FALSE otherwise.
-
-\wxheading{See also}
-
-\helpref{SetUseBestVisual}{wxappsetusebestvisual}
-
-\membersection{wxApp::GetVendorName}\label{wxappgetvendorname}
-
-\constfunc{wxString}{GetVendorName}{\void}
-
-Returns the application's vendor name.
-
-\membersection{wxApp::ExitMainLoop}\label{wxappexitmainloop}
-
-\func{void}{ExitMainLoop}{\void}
-
-Call this to explicitly exit the main message (event) loop.
-You should normally exit the main loop (and the application) by deleting
-the top window.
-
-\membersection{wxApp::Initialized}\label{wxappinitialized}
-
-\func{bool}{Initialized}{\void}
-
-Returns TRUE if the application has been initialized (i.e. if\rtfsp
-\helpref{wxApp::OnInit}{wxapponinit} has returned successfully).  This can be useful for error
-message routines to determine which method of output is best for the
-current state of the program (some windowing systems may not like
-dialogs to pop up before the main loop has been entered).
-
-\membersection{wxApp::MainLoop}\label{wxappmainloop}
-
-\func{int}{MainLoop}{\void}
-
-Called by wxWindows on creation of the application. Override this if you wish
-to provide your own (environment-dependent) main loop.
-
-\wxheading{Return value}
-
-Returns 0 under X, and the wParam of the WM\_QUIT message under Windows.
-
-%% VZ: OnXXX() functions should *not* be documented
-%%
-%%\membersection{wxApp::OnActivate}\label{wxapponactivate}
-%%
-%%\func{void}{OnActivate}{\param{wxActivateEvent\& }{event}}
-%%
-%%Provide this member function to know whether the application is being
-%%activated or deactivated (Windows only).
-%%
-%%\wxheading{See also}
-%%
-%%\helpref{wxWindow::OnActivate}{wxwindowonactivate}, \helpref{wxActivateEvent}{wxactivateevent}
-%%
-%%\membersection{wxApp::OnCharHook}\label{wxapponcharhook}
-%%
-%%\func{void}{OnCharHook}{\param{wxKeyEvent\&}{ event}}
-%%
-%%This event handler function is called (under Windows only) to allow the window to intercept keyboard events
-%%before they are processed by child windows.
-%%
-%%\wxheading{Parameters}
-%%
-%%\docparam{event}{The keypress event.}
-%%
-%%\wxheading{Remarks}
-%%
-%%Use the wxEVT\_CHAR\_HOOK macro in your event table.
-%%
-%%If you use this member, you can selectively consume keypress events by calling\rtfsp
-%%\helpref{wxEvent::Skip}{wxeventskip} for characters the application is not interested in.
-%%
-%%\wxheading{See also}
-%%
-%%\helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnChar}{wxwindowonchar},\rtfsp
-%%\helpref{wxWindow::OnCharHook}{wxwindowoncharhook}, \helpref{wxDialog::OnCharHook}{wxdialogoncharhook}
-
-\membersection{wxApp::OnAssert}\label{wxapponassert}
-
-\func{void}{OnAssert}{\param{const wxChar }{*file}, \param{int }{line}, \param{const wxChar }{*cond}, \param{const wxChar }{*msg}}
-
-This function is called when an assert failure occurs, i.e. the condition
-specified in \helpref{wxASSERT}{wxassert} macro evaluated to {\tt FALSE}.
-It is only called in debug mode (when {\tt \_\_WXDEBUG\_\_} is defined) as
-asserts are not left in the release code at all.
-
-The base class version show the default assert failure dialog box proposing to
-the user to stop the program, continue or ignore all subsequent asserts.
-
-\wxheading{Parameters}
-
-\docparam{file}{the name of the source file where the assert occured}
-
-\docparam{line}{the line number in this file where the assert occured}
-
-\docparam{cond}{the condition of the failed assert in string form}
-
-\docparam{msg}{the message specified as argument to 
-\helpref{wxASSERT\_MSG}{wxassertmsg} or \helpref{wxFAIL\_MSG}{wxfailmsg}, will
-be {\tt NULL} if just \helpref{wxASSERT}{wxassert} or \helpref{wxFAIL}{wxfail} 
-was used}
-
-\membersection{wxApp::OnExit}\label{wxapponexit}
-
-\func{int}{OnExit}{\void}
-
-Provide this member function for any processing which needs to be
-done as the application is about to exit. OnExit is called after
-destroying all application windows and controls, but before
-wxWindows cleanup.
-
-\membersection{wxApp::OnCmdLineError}\label{wxapponcmdlineerror}
-
-\func{bool}{OnCmdLineError}{\param{wxCmdLineParser\& }{parser}}
-
-Called when command line parsing fails (i.e. an incorrect command line option
-was specified by the user). The default behaviour is to show the program usage
-text and abort the program.
-
-Return {\tt TRUE} to continue normal execution or {\tt FALSE} to return 
-{\tt FALSE} from \helpref{OnInit}{wxapponinit} thus terminating the program.
-
-\wxheading{See also}
-
-\helpref{OnInitCmdLine}{wxapponinitcmdline}
-
-\membersection{wxApp::OnCmdLineHelp}\label{wxapponcmdlinehelp}
-
-\func{bool}{OnCmdLineHelp}{\param{wxCmdLineParser\& }{parser}}
-
-Called when the help option ({\tt --help}) was specified on the command line.
-The default behaviour is to show the program usage text and abort the program.
-
-Return {\tt TRUE} to continue normal execution or {\tt FALSE} to return 
-{\tt FALSE} from \helpref{OnInit}{wxapponinit} thus terminating the program.
-
-\wxheading{See also}
-
-\helpref{OnInitCmdLine}{wxapponinitcmdline}
-
-\membersection{wxApp::OnCmdLineParsed}\label{wxapponcmdlineparsed}
-
-\func{bool}{OnCmdLineParsed}{\param{wxCmdLineParser\& }{parser}}
-
-Called after the command line had been successfully parsed. You may override
-this method to test for the values of the various parameters which could be
-set from the command line.
-
-Don't forget to call the base class version unless you want to suppress
-processing of the standard command line options.
-
-Return {\tt TRUE} to continue normal execution or {\tt FALSE} to return 
-{\tt FALSE} from \helpref{OnInit}{wxapponinit} thus terminating the program.
-
-\wxheading{See also}
-
-\helpref{OnInitCmdLine}{wxapponinitcmdline}
-
-\membersection{wxApp::OnFatalException}\label{wxapponfatalexception}
-
-\func{void}{OnFatalException}{\void}
-
-This function may be called if something fatal happens: an unhandled
-exception under Win32 or a a fatal signal under Unix, for example. However,
-this will not happen by default: you have to explicitly call 
-\helpref{wxHandleFatalExceptions}{wxhandlefatalexceptions} to enable this.
-
-Generally speaking, this function should only show a message to the user and
-return. You may attempt to save unsaved data but this is not guaranteed to
-work and, in fact, probably won't.
-
-\wxheading{See also}
-
-\helpref{wxHandleFatalExcetions}{wxhandlefatalexceptions}
-
-%% VZ: the wxApp event handler are private and should not be documented here!
-%%
-%%\membersection{wxApp::OnIdle}\label{wxapponidle}
-%%
-%%\func{void}{OnIdle}{\param{wxIdleEvent\& }{event}}
-%%
-%%Override this member function for any processing which needs to be done
-%%when the application is idle. You should call wxApp::OnIdle from your own function,
-%%since this forwards OnIdle events to windows and also performs garbage collection for
-%%windows whose destruction has been delayed.
-%%
-%%wxWindows' strategy for OnIdle processing is as follows. After pending user interface events for an
-%%application have all been processed, wxWindows sends an OnIdle event to the application object. wxApp::OnIdle itself
-%%sends an OnIdle event to each application window, allowing windows to do idle processing such as updating
-%%their appearance. If either wxApp::OnIdle or a window OnIdle function requested more time, by
-%%calling \helpref{wxIdleEvent::RequestMore}{wxidleeventrequestmore}, wxWindows will send another OnIdle
-%%event to the application object. This will occur in a loop until either a user event is found to be
-%%pending, or OnIdle requests no more time. Then all pending user events are processed until the system
-%%goes idle again, when OnIdle is called, and so on.
-%%
-%%\wxheading{See also}
-%%
-%%\helpref{wxWindow::OnIdle}{wxwindowonidle}, \helpref{wxIdleEvent}{wxidleevent},\rtfsp
-%%\helpref{wxWindow::SendIdleEvents}{wxappsendidleevents}
-%%
-%%\membersection{wxApp::OnEndSession}\label{wxapponendsession}
-%%
-%%\func{void}{OnEndSession}{\param{wxCloseEvent\& }{event}}
-%%
-%%This is an event handler function called when the operating system or GUI session is
-%%about to close down. The application has a chance to silently save information,
-%%and can optionally close itself.
-%%
-%%Use the EVT\_END\_SESSION event table macro to handle query end session events.
-%%
-%%The default handler calls \helpref{wxWindow::Close}{wxwindowclose} with a TRUE argument
-%%(forcing the application to close itself silently).
-%%
-%%\wxheading{Remarks}
-%%
-%%Under X, OnEndSession is called in response to the `die' event.
-%%
-%%Under Windows, OnEndSession is called in response to the WM\_ENDSESSION message.
-%%
-%%\wxheading{See also}
-%%
-%%\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
-%%\helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
-%%\helpref{wxCloseEvent}{wxcloseevent},\rtfsp
-%%\helpref{wxApp::OnQueryEndSession}{wxapponqueryendsession}
-
-\membersection{wxApp::OnInit}\label{wxapponinit}
-
-\func{bool}{OnInit}{\void}
-
-This must be provided by the application, and will usually create the
-application's main window, optionally calling 
-\helpref{wxApp::SetTopWindow}{wxappsettopwindow}.
-
-Notice that if you want to to use the command line processing provided by
-wxWindows you have to call the base class version in the derived class
-OnInit().
-
-Return TRUE to continue processing, FALSE to exit the application.
-
-\membersection{wxApp::OnInitCmdLine}\label{wxapponinitcmdline}
-
-\func{void}{OnInitCmdLine}{\param{wxCmdLineParser\& }{parser}}
-
-Called from \helpref{OnInit}{wxapponinit} and may be used to initialize the
-parser with the command line options for this application. The base class
-versions adds support for a few standard options only.
-
-\membersection{wxApp::OnQueryEndSession}\label{wxapponqueryendsession}
-
-\func{void}{OnQueryEndSession}{\param{wxCloseEvent\& }{event}}
-
-This is an event handler function called when the operating system or GUI session is
-about to close down. Typically, an application will try to save unsaved documents
-at this point.
-
-If \helpref{wxCloseEvent::CanVeto}{wxcloseeventcanveto} returns TRUE, the application
-is allowed to veto the shutdown by calling \helpref{wxCloseEvent::Veto}{wxcloseeventveto}.
-The application might veto the shutdown after prompting for documents to be saved, and the
-user has cancelled the save.
-
-Use the EVT\_QUERY\_END\_SESSION event table macro to handle query end session events.
-
-You should check whether the application is forcing the deletion of the window
-using \helpref{wxCloseEvent::GetForce}{wxcloseeventgetforce}. If this is TRUE,
-destroy the window using \helpref{wxWindow::Destroy}{wxwindowdestroy}.
-If not, it is up to you whether you respond by destroying the window.
-
-The default handler calls \helpref{wxWindow::Close}{wxwindowclose} on the top-level window,
-and vetoes the shutdown if Close returns FALSE. This will be sufficient for many applications.
-
-\wxheading{Remarks}
-
-Under X, OnQueryEndSession is called in response to the `save session' event.
-
-Under Windows, OnQueryEndSession is called in response to the WM\_QUERYENDSESSION message.
-
-\wxheading{See also}
-
-\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
-\helpref{wxCloseEvent}{wxcloseevent}
-%% GD: OnXXX functions are not documented
-%%\helpref{wxApp::OnEndSession}{wxapponendsession}
-
-\membersection{wxApp::ProcessMessage}\label{wxappprocessmessage}
-
-\func{bool}{ProcessMessage}{\param{WXMSG *}{msg}}
-
-Windows-only function for processing a message. This function
-is called from the main message loop, checking for windows that
-may wish to process it. The function returns TRUE if the message
-was processed, FALSE otherwise. If you use wxWindows with another class
-library with its own message loop, you should make sure that this
-function is called to allow wxWindows to receive messages. For example,
-to allow co-existence with the Microsoft Foundation Classes, override
-the PreTranslateMessage function:
-
-\begin{verbatim}
-// Provide wxWindows message loop compatibility
-BOOL CTheApp::PreTranslateMessage(MSG *msg)
-{
-  if (wxTheApp && wxTheApp->ProcessMessage((WXMSW *)msg))
-    return TRUE;
-  else
-    return CWinApp::PreTranslateMessage(msg);
-}
-\end{verbatim}
-
-\membersection{wxApp::Pending}\label{wxapppending}
-
-\func{bool}{Pending}{\void}
-
-Returns TRUE if unprocessed events are in the window system event queue.
-
-\wxheading{See also}
-
-\helpref{wxApp::Dispatch}{wxappdispatch}
-
-\membersection{wxApp::SendIdleEvents}\label{wxappsendidleevents}
-
-\func{bool}{SendIdleEvents}{\void}
-
-Sends idle events to all top-level windows.
-
-\func{bool}{SendIdleEvents}{\param{wxWindow*}{ win}}
-
-Sends idle events to a window and its children.
-
-\wxheading{Remarks}
-
-These functions poll the top-level windows, and their children, for idle event processing.
-If TRUE is returned, more OnIdle processing is requested by one or more window.
-
-\wxheading{See also}
-
-%% GD: OnXXX functions are not documented
-%%\helpref{wxApp::OnIdle}{wxapponidle}
-\helpref{wxIdleEvent}{wxidleevent}
-
-\membersection{wxApp::SetAppName}\label{wxappsetappname}
-
-\func{void}{SetAppName}{\param{const wxString\& }{name}}
-
-Sets the name of the application. The name may be used in dialogs
-(for example by the document/view framework). A default name is set by
-wxWindows.
-
-\wxheading{See also}
-
-\helpref{wxApp::GetAppName}{wxappgetappname}
-
-\membersection{wxApp::SetAuto3D}\label{wxappsetauto3d}
-
-\func{void}{SetAuto3D}{\param{const bool}{ auto3D}}
-
-Switches automatic 3D controls on or off.
-
-\wxheading{Parameters}
-
-\docparam{auto3D}{If TRUE, all controls will be created with 3D appearances unless
-overridden for a control or dialog. The default is TRUE}
-
-\wxheading{Remarks}
-
-This has an effect on Windows only.
-
-\wxheading{See also}
-
-\helpref{wxApp::GetAuto3D}{wxappgetauto3d}
-
-\membersection{wxApp::SetClassName}\label{wxappsetclassname}
-
-\func{void}{SetClassName}{\param{const wxString\& }{name}}
-
-Sets the class name of the application. This may be used in a platform specific
-manner to refer to the application.
-
-\wxheading{See also}
-
-\helpref{wxApp::GetClassName}{wxappgetclassname}
-
-\membersection{wxApp::SetExitOnFrameDelete}\label{wxappsetexitonframedelete}
-
-\func{void}{SetExitOnFrameDelete}{\param{bool}{ flag}}
-
-Allows the programmer to specify whether the application will exit when the
-top-level frame is deleted.
-
-\wxheading{Parameters}
-
-\docparam{flag}{If TRUE (the default), the application will exit when the top-level frame is
-deleted. If FALSE, the application will continue to run.}
-
-\wxheading{See also}
-
-\helpref{wxApp::GetExitOnFrameDelete}{wxappgetexitonframedelete},\\
-\helpref{wxApp shutdown overview}{wxappshutdownoverview}
-
-\membersection{wxApp::SetTopWindow}\label{wxappsettopwindow}
-
-\func{void}{SetTopWindow}{\param{wxWindow* }{window}}
-
-Sets the `top' window. You can call this from within \helpref{wxApp::OnInit}{wxapponinit} to
-let wxWindows know which is the main window. You don't have to set the top window;
-it is only a convenience so that (for example) certain dialogs without parents can use a
-specific window as the top window. If no top window is specified by the application,
-wxWindows just uses the first frame or dialog in its top-level window list, when it
-needs to use the top window.
-
-\wxheading{Parameters}
-
-\docparam{window}{The new top window.}
-
-\wxheading{See also}
-
-\helpref{wxApp::GetTopWindow}{wxappgettopwindow}, \helpref{wxApp::OnInit}{wxapponinit}
-
-
-\membersection{wxApp::SetVendorName}\label{wxappsetvendorname}
-
-\func{void}{SetVendorName}{\param{const wxString\& }{name}}
-
-Sets the name of application's vendor. The name will be used
-in registry access. A default name is set by
-wxWindows.
-
-\wxheading{See also}
-
-\helpref{wxApp::GetVendorName}{wxappgetvendorname}
-
-\membersection{wxApp::SetUseBestVisual}\label{wxappsetusebestvisual}
-
-\func{void}{SetUseBestVisual}{\param{bool}{ flag}}
-
-Allows the programmer to specify whether the application will use the best visual
-on systems that support several visual on the same display. This is typically the
-case under Solaris and IRIX, where the default visual is only 8-bit whereas certain
-applications are supposed to run in TrueColour mode.
-
-Note that this function has to be called in the constructor of the {\tt wxApp} 
-instance and won't have any effect when called later on.
-
-This function currently only has effect under GTK.
-
-\wxheading{Parameters}
-
-\docparam{flag}{If TRUE, the app will use the best visual.}
-
-\membersection{wxApp::Yield}\label{wxappyield}
-
-\func{bool}{Yield}{\param{bool}{ onlyIfNeeded = FALSE}}
-
-Yields control to pending messages in the windowing system. This can be useful, for example, when a
-time-consuming process writes to a text window. Without an occasional
-yield, the text window will not be updated properly, and on systems with
-cooperative multitasking, such as Windows 3.1 other processes will not respond.
-
-Caution should be exercised, however, since yielding may allow the
-user to perform actions which are not compatible with the current task.
-Disabling menu items or whole menus during processing can avoid unwanted
-reentrance of code: see \helpref{::wxSafeYield}{wxsafeyield} for a better
-function.
-
-Note that Yield() will not flush the message logs. This is intentional as
-calling Yield() is usually done to quickly update the screen and popping up a
-message box dialog may be undesirable. If you do wish to flush the log
-messages immediately (otherwise it will be done during the next idle loop
-iteration), call \helpref{wxLog::FlushActive}{wxlogflushactive}.
-
-Calling Yield() recursively is normally an error and an assert failure is
-raised in debug build if such situation is detected. However if the the 
-{\it onlyIfNeeded} parameter is {\tt TRUE}, the method will just silently
-return {\tt FALSE} instead.
-

docs/latex/wx/array.tex

@@ -1,620 +0,0 @@
-\section{\class{wxArray}}\label{wxarray}
-
-This section describes the so called {\it dynamic arrays}. This is a C
-array-like data structure i.e. the member access time is constant (and not
-linear according to the number of container elements as for linked lists). However, these
-arrays are dynamic in the sense that they will automatically allocate more
-memory if there is not enough of it for adding a new element. They also perform
-range checking on the index values but in debug mode only, so please be sure to
-compile your application in debug mode to use it (see \helpref{debugging overview}{debuggingoverview} for
-details). So, unlike the arrays in some other
-languages, attempt to access an element beyond the arrays bound doesn't
-automatically expand the array but provokes an assertion failure instead in
-debug build and does nothing (except possibly crashing your program) in the
-release build.
-
-The array classes were designed to be reasonably efficient, both in terms of
-run-time speed and memory consumption and the executable size. The speed of
-array item access is, of course, constant (independent of the number of elements)
-making them much more efficient than linked lists (\helpref{wxList}{wxlist}).
-Adding items to the arrays is also implemented in more or less constant time -
-but the price is preallocating the memory in advance. In the \helpref{memory management}{wxarraymemorymanagement} section
-you may find some useful hints about optimizing wxArray memory usage. As for executable size, all
-wxArray functions are inline, so they do not take {\it any space at all}.
-
-wxWindows has three different kinds of array. All of them derive from
-wxBaseArray class which works with untyped data and can not be used directly.
-The standard macros WX\_DEFINE\_ARRAY(), WX\_DEFINE\_SORTED\_ARRAY() and
-WX\_DEFINE\_OBJARRAY() are used to define a new class deriving from it. The
-classes declared will be called in this documentation wxArray, wxSortedArray and
-wxObjArray but you should keep in mind that no classes with such names actually
-exist, each time you use one of WX\_DEFINE\_XXXARRAY macro you define a class
-with a new name. In fact, these names are "template" names and each usage of one
-of the macros mentioned above creates a template specialization for the given
-element type.
-
-wxArray is suitable for storing integer types and pointers which it does not
-treat as objects in any way, i.e. the element pointed to by the pointer is not
-deleted when the element is removed from the array. It should be noted that
-all of wxArray's functions are inline, so it costs strictly nothing to define as
-many array types as you want (either in terms of the executable size or the
-speed) as long as at least one of them is defined and this is always the case
-because wxArrays are used by wxWindows internally. This class has one serious
-limitation: it can only be used for storing integral types (bool, char, short,
-int, long and their unsigned variants) or pointers (of any kind). An attempt
-to use with objects of sizeof() greater than sizeof(long) will provoke a
-runtime assertion failure, however declaring a wxArray of floats will not (on
-the machines where sizeof(float) <= sizeof(long)), yet it will {\bf not} work,
-please use wxObjArray for storing floats and doubles (NB: a more efficient
-wxArrayDouble class is scheduled for the next release of wxWindows).
-
-wxSortedArray is a wxArray variant which should be used when searching in the
-array is a frequently used operation. It requires you to define an additional
-function for comparing two elements of the array element type and always stores
-its items in the sorted order (according to this function). Thus, it is 
- \helpref{Index()}{wxarrayindex} function execution time is $O(log(N))$ instead of
-$O(N)$ for the usual arrays but the \helpref{Add()}{wxarrayadd} method is
-slower: it is $O(log(N))$ instead of constant time (neglecting time spent in
-memory allocation routine). However, in a usual situation elements are added to
-an array much less often than searched inside it, so wxSortedArray may lead to
-huge performance improvements compared to wxArray. Finally, it should be
-noticed that, as wxArray, wxSortedArray can be only used for storing integral
-types or pointers.
-
-wxObjArray class treats its elements like "objects". It may delete them when
-they are removed from the array (invoking the correct destructor) and copies
-them using the objects copy constructor. In order to implement this behaviour
-the definition of the wxObjArray arrays is split in two parts: first, you should
-declare the new wxObjArray class using WX\_DECLARE\_OBJARRAY() macro and then
-you must include the file defining the implementation of template type:
-<wx/arrimpl.cpp> and define the array class with WX\_DEFINE\_OBJARRAY() macro
-from a point where the full (as opposed to `forward') declaration of the array
-elements class is in scope. As it probably sounds very complicated here is an
-example:
-
-\begin{verbatim}
-#include <wx/dynarray.h>
-
-// we must forward declare the array because it is used inside the class
-// declaration
-class MyDirectory;
-class MyFile;
-
-// this defines two new types: ArrayOfDirectories and ArrayOfFiles which can be
-// now used as shown below
-WX_DECLARE_OBJARRAY(MyDirectory, ArrayOfDirectories);
-WX_DECLARE_OBJARRAY(MyFile,      ArrayOfFiles);
-
-class MyDirectory
-{
-...
-    ArrayOfDirectories m_subdirectories; // all subdirectories
-    ArrayOfFiles       m_files;          // all files in this directory
-};
-
-...
-
-// now that we have MyDirectory declaration in scope we may finish the
-// definition of ArrayOfDirectories -- note that this expands into some C++
-// code and so should only be compiled once (i.e., don't put this in the
-// header, but into a source file or you will get linking errors)
-#include <wx/arrimpl.cpp> // this is a magic incantation which must be done!
-WX_DEFINE_OBJARRAY(ArrayOfDirectories);
-
-// that's all!
-\end{verbatim}
-
-It is not as elegant as writing
-
-\begin{verbatim} 
-typedef std::vector<MyDirectory> ArrayOfDirectories;
-\end{verbatim}
-
-but is not that complicated and allows the code to be compiled with any, however
-dumb, C++ compiler in the world.
-
-Things are much simpler for wxArray and wxSortedArray however: it is enough
-just to write
-
-\begin{verbatim} 
-WX_DEFINE_ARRAY(MyDirectory *, ArrayOfDirectories);
-WX_DEFINE_SORTED_ARRAY(MyFile *, ArrayOfFiles);
-\end{verbatim}
-
-\wxheading{See also:}
-
-\helpref{Container classes overview}{wxcontaineroverview}, \helpref{wxList}{wxlist}
-
-\wxheading{Include files}
-
-<wx/dynarray.h> for wxArray and wxSortedArray and additionally <wx/arrimpl.cpp>
-for wxObjArray.
-
-\latexignore{\rtfignore{\wxheading{Function groups}}}
-
-\membersection{Macros for template array definition}
-
-To use an array you must first define the array class. This is done with the
-help of the macros in this section. The class of array elements must be (at
-least) forward declared for WX\_DEFINE\_ARRAY, WX\_DEFINE\_SORTED\_ARRAY and
-WX\_DECLARE\_OBJARRAY macros and must be fully declared before you use
-WX\_DEFINE\_OBJARRAY macro.
-
-\helpref{WX\_DEFINE\_ARRAY}{wxdefinearray}\\
-\helpref{WX\_DEFINE\_EXPORTED\_ARRAY}{wxdefinearray}\\
-\helpref{WX\_DEFINE\_USER\_EXPORTED\_ARRAY}{wxdefinearray}\\
-\helpref{WX\_DEFINE\_SORTED\_ARRAY}{wxdefinesortedarray}\\
-\helpref{WX\_DEFINE\_SORTED\_EXPORTED\_ARRAY}{wxdefinesortedarray}\\
-\helpref{WX\_DEFINE\_SORTED\_USER\_EXPORTED\_ARRAY}{wxdefinesortedarray}\\
-\helpref{WX\_DECLARE\_EXPORTED\_OBJARRAY}{wxdeclareobjarray}\\
-\helpref{WX\_DECLARE\_USER\_EXPORTED\_OBJARRAY}{wxdeclareobjarray}\\
-\helpref{WX\_DEFINE\_OBJARRAY}{wxdefineobjarray}\\
-\helpref{WX\_DEFINE\_EXPORTED\_OBJARRAY}{wxdefineobjarray}\\
-\helpref{WX\_DEFINE\_USER\_EXPORTED\_OBJARRAY}{wxdefineobjarray}
-
-\membersection{Constructors and destructors}
-
-Array classes are 100\% C++ objects and as such they have the appropriate copy
-constructors and assignment operators. Copying wxArray just copies the elements
-but copying wxObjArray copies the arrays items. However, for memory-efficiency
-sake, neither of these classes has virtual destructor. It is not very important
-for wxArray which has trivial destructor anyhow, but it does mean that you
-should avoid deleting wxObjArray through a wxBaseArray pointer (as you would
-never use wxBaseArray anyhow it shouldn't be a problem) and that you should not
-derive your own classes from the array classes.
-
-\helpref{wxArray default constructor}{wxarrayctordef}\\
-\helpref{wxArray copy constructors and assignment operators}{wxarrayctorcopy}\\
-\helpref{\destruct{wxArray}}{wxarraydtor}
-
-\membersection{Memory management}\label{wxarraymemorymanagement}
-
-Automatic array memory management is quite trivial: the array starts by
-preallocating some minimal amount of memory (defined by
-WX\_ARRAY\_DEFAULT\_INITIAL\_SIZE) and when further new items exhaust already
-allocated memory it reallocates it adding 50\% of the currently allocated
-amount, but no more than some maximal number which is defined by
-ARRAY\_MAXSIZE\_INCREMENT constant. Of course, this may lead to some memory
-being wasted (ARRAY\_MAXSIZE\_INCREMENT in the worst case, i.e. 4Kb in the
-current implementation), so the \helpref{Shrink()}{wxarrayshrink} function is
-provided to deallocate the extra memory. The \helpref{Alloc()}{wxarrayalloc} 
-function can also be quite useful if you know in advance how many items you are
-going to put in the array and will prevent the array code from reallocating the
-memory more times than needed.
-
-\helpref{Alloc}{wxarrayalloc}\\
-\helpref{Shrink}{wxarrayshrink}
-
-\membersection{Number of elements and simple item access}
-
-Functions in this section return the total number of array elements and allow to
-retrieve them - possibly using just the C array indexing $[]$ operator which
-does exactly the same as \helpref{Item()}{wxarrayitem} method.
-
-\helpref{Count}{wxarraycount}\\
-\helpref{GetCount}{wxarraygetcount}\\
-\helpref{IsEmpty}{wxarrayisempty}\\
-\helpref{Item}{wxarrayitem}\\
-\helpref{Last}{wxarraylast}
-
-\membersection{Adding items}
-
-\helpref{Add}{wxarrayadd}\\
-\helpref{Insert}{wxarrayinsert}\\
-\helpref{WX\_APPEND\_ARRAY}{wxappendarray}
-
-\membersection{Removing items}
-
-\helpref{WX\_CLEAR\_ARRAY}{wxcleararray}\\
-\helpref{Empty}{wxarrayempty}\\
-\helpref{Clear}{wxarrayclear}\\
-\helpref{RemoveAt}{wxarrayremoveat}\\
-\helpref{Remove}{wxarrayremove}
-
-\membersection{Searching and sorting}
-
-\helpref{Index}{wxarrayindex}\\
-\helpref{Sort}{wxarraysort}
-
-%%%%% MEMBERS HERE %%%%%
-\helponly{\insertatlevel{2}{
-
-\wxheading{Members}
-
-}}
-
-\membersection{WX\_DEFINE\_ARRAY}\label{wxdefinearray}
-
-\func{}{WX\_DEFINE\_ARRAY}{\param{}{T}, \param{}{name}}
-
-\func{}{WX\_DEFINE\_EXPORTED\_ARRAY}{\param{}{T}, \param{}{name}}
-
-\func{}{WX\_DEFINE\_USER\_EXPORTED\_ARRAY}{\param{}{T}, \param{}{name}, \param{}{exportspec}}
-
-This macro defines a new array class named {\it name} and containing the
-elements of type {\it T}. The second form is used when compiling wxWindows as
-a DLL under Windows and array needs to be visible outside the DLL.  The third is
-needed for exporting an array from a user DLL.
-
-Example:
-
-\begin{verbatim}
-WX_DEFINE_ARRAY(int, wxArrayInt);
-
-class MyClass;
-WX_DEFINE_ARRAY(MyClass *, wxArrayOfMyClass);
-\end{verbatim}
-
-Note that wxWindows predefines the following standard array classes: wxArrayInt,
-wxArrayLong and wxArrayPtrVoid.
-
-\membersection{WX\_DEFINE\_SORTED\_ARRAY}\label{wxdefinesortedarray}
-
-\func{}{WX\_DEFINE\_SORTED\_ARRAY}{\param{}{T}, \param{}{name}}
-
-\func{}{WX\_DEFINE\_SORTED\_EXPORTED\_ARRAY}{\param{}{T}, \param{}{name}}
-
-\func{}{WX\_DEFINE\_SORTED\_USER\_EXPORTED\_ARRAY}{\param{}{T}, \param{}{name}}
-
-This macro defines a new sorted array class named {\it name} and containing
-the elements of type {\it T}. The second form is used when compiling wxWindows as
-a DLL under Windows and array needs to be visible outside the DLL.  The third is
-needed for exporting an array from a user DLL.
-
-Example:
-
-\begin{verbatim}
-WX_DEFINE_SORTED_ARRAY(int, wxSortedArrayInt);
-
-class MyClass;
-WX_DEFINE_SORTED_ARRAY(MyClass *, wxArrayOfMyClass);
-\end{verbatim}
-
-You will have to initialize the objects of this class by passing a comparison
-function to the array object constructor like this:
-
-\begin{verbatim}
-int CompareInts(int n1, int n2)
-{
-    return n1 - n2;
-}
-
-wxSortedArrayInt sorted(CompareInts);
-
-int CompareMyClassObjects(MyClass *item1, MyClass *item2)
-{
-    // sort the items by their address...
-    return Stricmp(item1->GetAddress(), item2->GetAddress());
-}
-
-wxArrayOfMyClass another(CompareMyClassObjects);
-\end{verbatim}
-
-\membersection{WX\_DECLARE\_OBJARRAY}\label{wxdeclareobjarray}
-
-\func{}{WX\_DECLARE\_OBJARRAY}{\param{}{T}, \param{}{name}}
-
-\func{}{WX\_DECLARE\_EXPORTED\_OBJARRAY}{\param{}{T}, \param{}{name}}
-
-\func{}{WX\_DECLARE\_USER\_EXPORTED\_OBJARRAY}{\param{}{T}, \param{}{name}}
-
-This macro declares a new object array class named {\it name} and containing
-the elements of type {\it T}. The second form is used when compiling wxWindows as
-a DLL under Windows and array needs to be visible outside the DLL.  The third is
-needed for exporting an array from a user DLL.
-
-Example:
-
-\begin{verbatim}
-class MyClass;
-WX_DEFINE_OBJARRAY(MyClass, wxArrayOfMyClass); // note: not "MyClass *"!
-\end{verbatim}
-
-You must use \helpref{WX\_DEFINE\_OBJARRAY()}{wxdefineobjarray} macro to define
-the array class - otherwise you would get link errors.
-
-\membersection{WX\_DEFINE\_OBJARRAY}\label{wxdefineobjarray}
-
-\func{}{WX\_DEFINE\_OBJARRAY}{\param{}{name}}
-
-\func{}{WX\_DEFINE\_EXPORTED\_OBJARRAY}{\param{}{name}}
-
-\func{}{WX\_DEFINE\_USER\_EXPORTED\_OBJARRAY}{\param{}{name}}
-
-This macro defines the methods of the array class {\it name} not defined by the 
-\helpref{WX\_DECLARE\_OBJARRAY()}{wxdeclareobjarray} macro. You must include the
-file <wx/arrimpl.cpp> before using this macro and you must have the full
-declaration of the class of array elements in scope! If you forget to do the 
-first, the error will be caught by the compiler, but, unfortunately, many
-compilers will not give any warnings if you forget to do the second - but the
-objects of the class will not be copied correctly and their real destructor will
-not be called.  The latter two forms are merely aliases of the first to satisfy
-some people's sense of symmetry when using the exported declarations.
-
-Example of usage:
-
-\begin{verbatim}
-// first declare the class!
-class MyClass
-{
-public:
-   MyClass(const MyClass&);
-
-   ...
-
-   virtual ~MyClass();
-};
-
-#include <wx/arrimpl.cpp>
-WX_DEFINE_OBJARRAY(wxArrayOfMyClass);
-\end{verbatim}
-
-\membersection{WX\_APPEND\_ARRAY}\label{wxappendarray}
-
-\func{void}{WX\_APPEND\_ARRAY}{\param{wxArray\& }{array}, \param{wxArray\& }{other}}
-
-This macro may be used to append all elements of the {\it other} array to the 
-{\it array}. The two arrays must be of the same type.
-
-\membersection{WX\_CLEAR\_ARRAY}\label{wxcleararray}
-
-\func{void}{WX\_CLEAR\_ARRAY}{\param{wxArray\& }{array}}
-
-This macro may be used to delete all elements of the array before emptying it.
-It can not be used with wxObjArrays - but they will delete their elements anyhow
-when you call Empty().
-
-\membersection{Default constructors}\label{wxarrayctordef}
-
-\func{}{wxArray}{\void}
-
-\func{}{wxObjArray}{\void}
-
-Default constructor initializes an empty array object.
-
-\func{}{wxSortedArray}{\param{int (*)(T first, T second)}{compareFunction}}
-
-There is no default constructor for wxSortedArray classes - you must initialize it
-with a function to use for item comparison. It is a function which is passed
-two arguments of type {\it T} where {\it T} is the array element type and which
-should return a negative, zero or positive value according to whether the first
-element passed to it is less than, equal to or greater than the second one.
-
-\membersection{wxArray copy constructor and assignment operator}\label{wxarrayctorcopy}
-
-\func{}{wxArray}{\param{const wxArray\& }{array}}
-
-\func{}{wxSortedArray}{\param{const wxSortedArray\& }{array}}
-
-\func{}{wxObjArray}{\param{const wxObjArray\& }{array}}
-
-\func{wxArray\&}{operator$=$}{\param{const wxArray\& }{array}}
-
-\func{wxSortedArray\&}{operator$=$}{\param{const wxSortedArray\& }{array}}
-
-\func{wxObjArray\&}{operator$=$}{\param{const wxObjArray\& }{array}}
-
-The copy constructors and assignment operators perform a shallow array copy
-(i.e. they don't copy the objects pointed to even if the source array contains
-the items of pointer type) for wxArray and wxSortedArray and a deep copy (i.e.
-the array element are copied too) for wxObjArray.
-
-\membersection{wxArray::\destruct{wxArray}}\label{wxarraydtor}
-
-\func{}{\destruct{wxArray}}{\void}
-
-\func{}{\destruct{wxSortedArray}}{\void}
-
-\func{}{\destruct{wxObjArray}}{\void}
-
-The wxObjArray destructor deletes all the items owned by the array. This is not
-done by wxArray and wxSortedArray versions - you may use 
-\helpref{WX\_CLEAR\_ARRAY}{wxcleararray} macro for this.
-
-\membersection{wxArray::Add}\label{wxarrayadd}
-
-\func{void}{Add}{\param{T }{item}, \param{size\_t}{ copies = $1$}}
-
-\func{void}{Add}{\param{T *}{item}}
-
-\func{void}{Add}{\param{T \&}{item}, \param{size\_t}{ copies = $1$}}
-
-Appends the given number of {\it copies} of the {\it item} to the array
-consisting of the elements of type {\it T}.
-
-The first version is used with wxArray and wxSortedArray. The second and the
-third are used with wxObjArray. There is an important difference between
-them: if you give a pointer to the array, it will take ownership of it, i.e.
-will delete it when the item is deleted from the array. If you give a reference
-to the array, however, the array will make a copy of the item and will not take
-ownership of the original item. Once again, it only makes sense for wxObjArrays
-because the other array types never take ownership of their elements. Also note
-that you cannot append more than one pointer as reusing it would lead to
-deleting it twice (or more) and hence to a crash.
-
-You may also use \helpref{WX\_APPEND\_ARRAY}{wxappendarray} macro to append all
-elements of one array to another one but it is more efficient to use 
-{\it copies} parameter and modify the elements in place later if you plan to
-append a lot of items.
-
-\membersection{wxArray::Alloc}\label{wxarrayalloc}
-
-\func{void}{Alloc}{\param{size\_t }{count}}
-
-Preallocates memory for a given number of array elements. It is worth calling
-when the number of items which are going to be added to the array is known in
-advance because it will save unneeded memory reallocation. If the array already
-has enough memory for the given number of items, nothing happens.
-
-\membersection{wxArray::Clear}\label{wxarrayclear}
-
-\func{void}{Clear}{\void}
-
-This function does the same as \helpref{Empty()}{wxarrayempty} and additionally
-frees the memory allocated to the array.
-
-\membersection{wxArray::Count}\label{wxarraycount}
-
-\constfunc{size\_t}{Count}{\void}
-
-Same as \helpref{GetCount()}{wxarraygetcount}. This function is deprecated -
-it exists only for compatibility.
-
-\membersection{wxObjArray::Detach}\label{wxobjarraydetach}
-
-\func{T *}{Detach}{\param{size\_t }{index}}
-
-Removes the element from the array, but, unlike, 
-\helpref{Remove()}{wxarrayremove} doesn't delete it. The function returns the
-pointer to the removed element.
-
-\membersection{wxArray::Empty}\label{wxarrayempty}
-
-\func{void}{Empty}{\void}
-
-Empties the array. For wxObjArray classes, this destroys all of the array
-elements. For wxArray and wxSortedArray this does nothing except marking the
-array of being empty - this function does not free the allocated memory, use 
-\helpref{Clear()}{wxarrayclear} for this.
-
-\membersection{wxArray::GetCount}\label{wxarraygetcount}
-
-\constfunc{size\_t}{GetCount}{\void}
-
-Return the number of items in the array.
-
-\membersection{wxArray::Index}\label{wxarrayindex}
-
-\func{int}{Index}{\param{T\& }{item}, \param{bool }{searchFromEnd = FALSE}}
-
-\func{int}{Index}{\param{T\& }{item}}
-
-The first version of the function is for wxArray and wxObjArray, the second is
-for wxSortedArray only.
-
-Searches the element in the array, starting from either beginning or the end
-depending on the value of {\it searchFromEnd} parameter. wxNOT\_FOUND is
-returned if the element is not found, otherwise the index of the element is
-returned.
-
-Linear search is used for the wxArray and wxObjArray classes but binary search
-in the sorted array is used for wxSortedArray (this is why searchFromEnd
-parameter doesn't make sense for it).
-
-{\bf NB:} even for wxObjArray classes, the operator==() of the elements in the
-array is {\bf not} used by this function. It searches exactly the given
-element in the array and so will only succeed if this element had been
-previously added to the array, but fail even if another, identical, element is
-in the array.
-
-\membersection{wxArray::Insert}\label{wxarrayinsert}
-
-\func{void}{Insert}{\param{T }{item}, \param{size\_t }{n}, \param{size\_t }{copies = $1$}}
-
-\func{void}{Insert}{\param{T *}{item}, \param{size\_t }{n}}
-
-\func{void}{Insert}{\param{T \&}{item}, \param{size\_t }{n}, \param{size\_t }{copies = $1$}}
-
-Insert the given number of {\it copies} of the {\it item} into the array before
-the existing item {\it n} - thus, {\it Insert(something, 0u)} will insert an
-item in such way that it will become the first array element.
-
-Please see \helpref{Add()}{wxarrayadd} for explanation of the differences
-between the overloaded versions of this function.
-
-\membersection{wxArray::IsEmpty}\label{wxarrayisempty}
-
-\constfunc{bool}{IsEmpty}{\void}
-
-Returns TRUE if the array is empty, FALSE otherwise.
-
-\membersection{wxArray::Item}\label{wxarrayitem}
-
-\constfunc{T\&}{Item}{\param{size\_t }{index}}
-
-Returns the item at the given position in the array. If {\it index} is out of
-bounds, an assert failure is raised in the debug builds but nothing special is
-done in the release build.
-
-The returned value is of type "reference to the array element type" for all of
-the array classes.
-
-\membersection{wxArray::Last}\label{wxarraylast}
-
-\constfunc{T\&}{Last}{\void}
-
-Returns the last element in the array, i.e. is the same as Item(GetCount() - 1).
-An assert failure is raised in the debug mode if the array is empty.
-
-The returned value is of type "reference to the array element type" for all of
-the array classes.
-
-\membersection{wxArray::Remove}\label{wxarrayremove}
-
-\func{\void}{Remove}{\param{T }{item}}
-
-Removes an element from the array by value: the first item of the
-array equal to {\it item} is removed, an assert failure will result from an
-attempt to remove an item which doesn't exist in the array.
-
-When an element is removed from wxObjArray it is deleted by the array - use 
-\helpref{Detach()}{wxobjarraydetach} if you don't want this to happen. On the
-other hand, when an object is removed from a wxArray nothing happens - you
-should delete it manually if required:
-
-\begin{verbatim}
-T *item = array[n];
-delete item;
-array.Remove(n)
-\end{verbatim}
-
-See also \helpref{WX\_CLEAR\_ARRAY}{wxcleararray} macro which deletes all
-elements of a wxArray (supposed to contain pointers).
-
-\membersection{wxArray::RemoveAt}\label{wxarrayremoveat}
-
-\func{\void}{RemoveAt}{\param{size\_t }{index}, \param{size\_t }{count = $1$}}
-
-Removes {\it count} elements starting at {\it index} from the array. When an
-element is removed from wxObjArray it is deleted by the array - use
-\helpref{Detach()}{wxobjarraydetach} if you don't want this to happen. On
-the other hand, when an object is removed from a wxArray nothing happens -
-you should delete it manually if required:
-
-\begin{verbatim}
-T *item = array[n];
-delete item;
-array.RemoveAt(n)
-\end{verbatim}
-
-See also \helpref{WX\_CLEAR\_ARRAY}{wxcleararray} macro which deletes all
-elements of a wxArray (supposed to contain pointers).
-
-\membersection{wxArray::Shrink}\label{wxarrayshrink}
-
-\func{void}{Shrink}{\void}
-
-Frees all memory unused by the array. If the program knows that no new items
-will be added to the array it may call Shrink() to reduce its memory usage.
-However, if a new item is added to the array, some extra memory will be
-allocated again.
-
-\membersection{wxArray::Sort}\label{wxarraysort}
-
-\func{void}{Sort}{\param{CMPFUNC<T> }{compareFunction}}
-
-The notation CMPFUNC<T> should be read as if we had the following declaration:
-
-\begin{verbatim}
-template int CMPFUNC(T *first, T *second);
-\end{verbatim}
-
-where {\it T} is the type of the array elements. I.e. it is a function returning 
-{\it int} which is passed two arguments of type {\it T *}.
-
-Sorts the array using the specified compare function: this function should
-return a negative, zero or positive value according to whether the first element
-passed to it is less than, equal to or greater than the second one.
-
-wxSortedArray doesn't have this function because it is always sorted.
-

docs/latex/wx/arrstrng.tex

@@ -1,288 +0,0 @@
-\section{\class{wxArrayString}}\label{wxarraystring}
-
-wxArrayString is an efficient container for storing 
-\helpref{wxString}{wxstring} objects. It has the same features as all 
-\helpref{wxArray}{wxarray} classes, i.e. it dynamically expands when new items
-are added to it (so it is as easy to use as a linked list), but the access
-time to the elements is constant, instead of being linear in number of
-elements as in the case of linked lists. It is also very size efficient and
-doesn't take more space than a C array {\it wxString[]} type (wxArrayString
-uses its knowledge of internals of wxString class to achieve this).
-
-This class is used in the same way as other dynamic \helpref{arrays}{wxarray},
-except that no {\it WX\_DEFINE\_ARRAY} declaration is needed for it. When a
-string is added or inserted in the array, a copy of the string is created, so
-the original string may be safely deleted (e.g. if it was a {\it char *} 
-pointer the memory it was using can be freed immediately after this). In
-general, there is no need to worry about string memory deallocation when using
-this class - it will always free the memory it uses itself.
-
-The references returned by \helpref{Item}{wxarraystringitem}, 
-\helpref{Last}{wxarraystringlast} or 
-\helpref{operator[]}{wxarraystringoperatorindex} are not constant, so the
-array elements may be modified in place like this
-
-\begin{verbatim}
-    array.Last().MakeUpper();
-\end{verbatim}
-
-There is also a variant of wxArrayString called wxSortedArrayString which has
-exactly the same methods as wxArrayString, but which always keeps the string
-in it in (alphabetical) order. wxSortedArrayString uses binary search in its 
-\helpref{Index}{wxarraystringindex} function (instead of linear search for
-wxArrayString::Index) which makes it much more efficient if you add strings to
-the array rarely (because, of course, you have to pay for Index() efficiency
-by having Add() be slower) but search for them often. Several methods should
-not be used with sorted array (basically, all which break the order of items)
-which is mentioned in their description.
-
-Final word: none of the methods of wxArrayString is virtual including its
-destructor, so this class should not be used as a base class.
-
-\wxheading{Derived from}
-
-Although this is not true strictly speaking, this class may be considered as a
-specialization of \helpref{wxArray}{wxarray} class for the wxString member
-data: it is not implemented like this, but it does have all of the wxArray
-functions.
-
-\wxheading{Include files}
-
-<wx/string.h>
-
-\wxheading{See also}
-
-\helpref{wxArray}{wxarray}, \helpref{wxString}{wxstring}, \helpref{wxString overview}{wxstringoverview}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxArrayString::wxArrayString}\label{wxarraystringctor}
-
-\func{}{wxArrayString}{\void}
-
-\func{}{wxArrayString}{\param{const wxArrayString\&}{ array}}
-
-Default and copy constructors.
-
-Note that when an array is assigned to a sorted array, its contents is
-automatically sorted during construction.
-
-\membersection{wxArrayString::\destruct{wxArrayString}}\label{wxarraystringdtor}
-
-\func{}{\destruct{wxArrayString}}{}
-
-Destructor frees memory occupied by the array strings. For the performance
-reasons it is not virtual, so this class should not be derived from.
-
-\membersection{wxArrayString::operator=}\label{wxarraystringoperatorassign}
-
-\func{wxArrayString \&}{operator $=$}{\param{const wxArrayString\&}{ array}}
-
-Assignment operator.
-
-\membersection{wxArrayString::operator==}\label{wxarraystringoperatorequal}
-
-\constfunc{bool}{operator $==$}{\param{const wxArrayString\&}{ array}}
-
-Compares 2 arrays respecting the case. Returns TRUE only if the arrays have
-the same number of elements and the same strings in the same order.
-
-\membersection{wxArrayString::operator!=}\label{wxarraystringoperatornotequal}
-
-\constfunc{bool}{operator $!=$}{\param{const wxArrayString\&}{ array}}
-
-Compares 2 arrays respecting the case. Returns TRUE if the arrays have
-different number of elements or if the elements don't match pairwise.
-
-\membersection{wxArrayString::operator[]}\label{wxarraystringoperatorindex}
-
-\func{wxString\&}{operator[]}{\param{size\_t }{nIndex}}
-
-Return the array element at position {\it nIndex}. An assert failure will
-result from an attempt to access an element beyond the end of array in debug
-mode, but no check is done in release mode.
-
-This is the operator version of \helpref{Item}{wxarraystringitem} method.
-
-\membersection{wxArrayString::Add}\label{wxarraystringadd}
-
-\func{size\_t}{Add}{\param{const wxString\& }{str}, \param{size\_t}{ copies = $1$}}
-
-Appends the given number of {\it copies} of the new item {\it str} to the
-array and returns the index of the first new item in the array.
-
-{\bf Warning:} For sorted arrays, the index of the inserted item will not be,
-in general, equal to \helpref{GetCount()}{wxarraystringgetcount} - 1 because
-the item is inserted at the correct position to keep the array sorted and not
-appended.
-
-See also: \helpref{Insert}{wxarraystringinsert}
-
-\membersection{wxArrayString::Alloc}\label{wxarraystringalloc}
-
-\func{void}{Alloc}{\param{size\_t }{nCount}}
-
-Preallocates enough memory to store {\it nCount} items. This function may be
-used to improve array class performance before adding a known number of items
-consecutively.
-
-See also: \helpref{Dynamic array memory management}{wxarraymemorymanagement}
-
-\membersection{wxArrayString::Clear}\label{wxarraystringclear}
-
-\func{void}{Clear}{\void}
-
-Clears the array contents and frees memory.
-
-See also: \helpref{Empty}{wxarraystringempty}
-
-\membersection{wxArrayString::Count}\label{wxarraystringcount}
-
-\constfunc{size\_t}{Count}{\void}
-
-Returns the number of items in the array. This function is deprecated and is
-for backwards compatibility only, please use 
-\helpref{GetCount}{wxarraystringgetcount} instead.
-
-\membersection{wxArrayString::Empty}\label{wxarraystringempty}
-
-\func{void}{Empty}{\void}
-
-Empties the array: after a call to this function 
-\helpref{GetCount}{wxarraystringgetcount} will return $0$. However, this
-function does not free the memory used by the array and so should be used when
-the array is going to be reused for storing other strings. Otherwise, you
-should use \helpref{Clear}{wxarraystringclear} to empty the array and free
-memory.
-
-\membersection{wxArrayString::GetCount}\label{wxarraystringgetcount}
-
-\constfunc{size\_t}{GetCount}{\void}
-
-Returns the number of items in the array.
-
-\membersection{wxArrayString::Index}\label{wxarraystringindex}
-
-\func{int}{Index}{\param{const char *}{ sz}, \param{bool}{ bCase = TRUE}, \param{bool}{ bFromEnd = FALSE}}
-
-Search the element in the array, starting from the beginning if
-{\it bFromEnd} is FALSE or from end otherwise. If {\it bCase}, comparison is
-case sensitive (default), otherwise the case is ignored.
-
-This function uses linear search for wxArrayString and binary search for
-wxSortedArrayString, but it ignores the {\it bCase} and {\it bFromEnd} 
-parameters in the latter case.
-
-Returns index of the first item matched or wxNOT\_FOUND if there is no match.
-
-\membersection{wxArrayString::Insert}\label{wxarraystringinsert}
-
-\func{void}{Insert}{\param{const wxString\& }{str}, \param{size\_t}{ nIndex}, \param{size\_t }{copies = $1$}}
-
-Insert the given number of {\it copies} of the new element in the array before the position {\it nIndex}. Thus, for
-example, to insert the string in the beginning of the array you would write
-
-\begin{verbatim}
-Insert("foo", 0);
-\end{verbatim}
-
-If {\it nIndex} is equal to {\it GetCount()} this function behaves as 
-\helpref{Add}{wxarraystringadd}.
-
-{\bf Warning:} this function should not be used with sorted arrays because it
-could break the order of items and, for example, subsequent calls to 
-\helpref{Index()}{wxarraystringindex} would then not work!
-
-\membersection{wxArrayString::IsEmpty}\label{wxarraystringisempty}
-
-\func{}{IsEmpty}{}
-
-Returns TRUE if the array is empty, FALSE otherwise. This function returns the
-same result as {\it GetCount() == 0} but is probably easier to read.
-
-\membersection{wxArrayString::Item}\label{wxarraystringitem}
-
-\constfunc{wxString\&}{Item}{\param{size\_t }{nIndex}}
-
-Return the array element at position {\it nIndex}. An assert failure will
-result from an attempt to access an element beyond the end of array in debug
-mode, but no check is done in release mode.
-
-See also \helpref{operator[]}{wxarraystringoperatorindex} for the operator
-version.
-
-\membersection{wxArrayString::Last}\label{wxarraystringlast}
-
-\func{}{Last}{}
-
-Returns the last element of the array. Attempt to access the last element of
-an empty array will result in assert failure in debug build, however no checks
-are done in release mode.
-
-\membersection{wxArrayString::Remove}\label{wxarraystringremove}
-
-\func{void}{Remove}{\param{const char *}{ sz}}
-
-Removes the first item matching this value. An assert failure is provoked by
-an attempt to remove an element which does not exist in debug build.
-
-See also: \helpref{Index}{wxarraystringindex}
-
-\func{void}{Remove}{\param{size\_t }{nIndex}, \param{size\_t }{count = $1$}}
-
-Removes {\it count} items starting at position {\it nIndex} from the array.
-
-\membersection{wxArrayString::Shrink}\label{wxarraystringshrink}
-
-\func{void}{Shrink}{\void}
-
-Releases the extra memory allocated by the array. This function is useful to
-minimize the array memory consumption.
-
-See also: \helpref{Alloc}{wxarraystringalloc}, \helpref{Dynamic array memory management}{wxarraymemorymanagement}
-
-\membersection{wxArrayString::Sort}\label{wxarraystringsort}
-
-\func{void}{Sort}{\param{bool}{ reverseOrder = FALSE}}
-
-Sorts the array in alphabetical order or in reverse alphabetical order if 
-{\it reverseOrder} is TRUE.
-
-{\bf Warning:} this function should not be used with sorted array because it
-could break the order of items and, for example, subsequent calls to 
-\helpref{Index()}{wxarraystringindex} would then not work!
-
-\func{void}{Sort}{\param{CompareFunction }{compareFunction}}
-
-Sorts the array using the specified {\it compareFunction} for item comparison.
-{\it CompareFunction} is defined as a function taking two {\it const
-wxString\&} parameters and returning an {\it int} value less than, equal to or
-greater than 0 if the first string is less than, equal to or greater than the
-second one.
-
-\wxheading{Example}
-
-The following example sorts strings by their length.
-
-\begin{verbatim}
-static int CompareStringLen(const wxString& first, const wxString& second)
-{
-    return first.length() - second.length();
-}
-
-...
-
-wxArrayString array;
-
-array.Add("one");
-array.Add("two");
-array.Add("three");
-array.Add("four");
-
-array.Sort(CompareStringLen);
-\end{verbatim}
-
-{\bf Warning:} this function should not be used with sorted array because it
-could break the order of items and, for example, subsequent calls to 
-\helpref{Index()}{wxarraystringindex} would then not work!
-

docs/latex/wx/artprov.tex

@@ -1,182 +0,0 @@
-%
-% automatically generated by HelpGen $Revision$ from
-% artprov.h at 08/Apr/02 17:44:57
-%
-
-\section{\class{wxArtProvider}}\label{wxartprovider}
-
-wxArtProvider class is used to customize the look of wxWindows application.
-When wxWindows need to display an icon or a bitmap (e.g. in the standard file
-dialog), it does not use hard-coded resource but asks wxArtProvider for it
-instead. This way the users can plug in own wxArtProvider class and easily
-replace standard art with his/her own version. It is easy thing to do: all
-that is needed is to derive a class from wxArtProvider, override it's
-\helpref{CreateBitmap}{wxartprovidercreatebitmap} method and register the
-provider with
-\helpref{wxArtProvider::PushProvider}{wxartproviderpushprovider}:
-
-\begin{verbatim}
-  class MyProvider : public wxArtProvider
-  {
-  protected:
-    wxBitmap CreateBitmap(const wxArtID& id, 
-                          const wxArtClient& client,
-                          const wxSize size)
-    { ... }
-  };
-  ...
-  wxArtProvider::PushProvider(new MyProvider);
-\end{verbatim}
-
-There's another way of taking advantage of this class: you can use it in your code and use
-platform native icons as provided by
-\helpref{wxArtProvider::GetBitmap}{wxartprovidergetbitmap} or 
-\helpref{wxArtProvider::GetIcon}{wxartprovidergeticon} (NB: this is not yet really
-possible as of wxWindows 2.3.3, the set of wxArtProvider bitmaps is too
-small). 
-
-\membersection{Identifying art resources}
-
-Every bitmap is known to wxArtProvider under an unique ID that is used by when
-requesting a resource from it. The ID is represented by wxArtID type and can
-have one of these predefined values (you can see bitmaps represented by these
-constants in the \helpref{artprov}{sampleartprovider} sample):
-\begin{itemize}\itemsep=0pt
-\item wxART\_ADD\_BOOKMARK     
-\item wxART\_DEL\_BOOKMARK     
-\item wxART\_HELP\_SIDE\_PANEL  
-\item wxART\_HELP\_SETTINGS    
-\item wxART\_HELP\_BOOK        
-\item wxART\_HELP\_FOLDER      
-\item wxART\_HELP\_PAGE        
-\item wxART\_GO\_BACK          
-\item wxART\_GO\_FORWARD       
-\item wxART\_GO\_UP            
-\item wxART\_GO\_DOWN          
-\item wxART\_GO\_TO\_PARENT     
-\item wxART\_GO\_HOME          
-\item wxART\_FILE\_OPEN        
-\item wxART\_PRINT            
-\item wxART\_HELP             
-\item wxART\_TIP              
-\item wxART\_REPORT\_VIEW      
-\item wxART\_LIST\_VIEW        
-\item wxART\_NEW\_DIR          
-\item wxART\_FOLDER           
-\item wxART\_GO\_DIR\_UP        
-\item wxART\_EXECUTABLE\_FILE  
-\item wxART\_NORMAL\_FILE      
-\item wxART\_TICK\_MARK        
-\item wxART\_CROSS\_MARK       
-\item wxART\_ERROR            
-\item wxART\_QUESTION         
-\item wxART\_WARNING          
-\item wxART\_INFORMATION      
-\end{itemize}
-
-\membersection{Clients}
-
-Client is the entity that calls wxArtProvider's GetBitmap or GetIcon
-function. It is represented by wxClientID type and can have one of these 
-values:
-\begin{itemize}\itemsep=0pt
-\item wxART\_TOOLBAR
-\item wxART\_MENU
-\item wxART\_FRAME\_ICON
-\item wxART\_CMN\_DIALOG
-\item wxART\_HELP\_BROWSER
-\item wxART\_MESSAGE\_BOX
-\item wxART\_OTHER (used for all requests that don't fit into any of the categories above)
-\end{itemize}
-Client ID servers as a hint to wxArtProvider that is supposed to help it to
-choose the best looking bitmap. For example it is often desirable to use
-slightly different icons in menus and toolbars even though they represent the
-same action (e.g. {\tt wx\_ART\_FILE\_OPEN}). Remember that this is really
-only a hint for wxArtProvider -- it is common that
-\helpref{wxArtProvider::GetBitmap}{wxartprovidergetbitmap} 
-returns identical bitmap for different {\it client} values!
-
-\wxheading{See also}
-
-See the \helpref{artprov}{sampleartprovider} sample for an example of wxArtProvider usage.
-
-\wxheading{Derived from}
-
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/artprov.h>
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxArtProvider::CreateBitmap}\label{wxartprovidercreatebitmap}
-
-\func{wxBitmap}{CreateBitmap}{\param{const wxArtID\& }{id}, \param{const wxArtClient\& }{client}, \param{const wxSize\& }{size}}
-
-Derived art provider classes must override this method to create requested 
-art resource. Note that returned bitmaps are cached by wxArtProvider and it is therefore
-not neccessary to optimize CreateBitmap for speed (e.g. you may create wxBitmap objects
-from XPMs here).
-
-\wxheading{Parameters}
-
-\docparam{id}{wxArtID unique identifier of the bitmap.}
-
-\docparam{client}{wxArtClient identifier of the client (i.e. who is asking for the bitmap).
-This only servers as a hint.}
-
-\docparam{size}{Prefered size of the bitmap. The function may return a bitmap of different
-dimensions, it will be automatically rescaled to meet client's request.}
-
-\wxheading{Note}
-
-This is {\bf not} part of wxArtProvider's public API, use
-\helpref{wxArtProvider::GetBitmap}{wxartprovidergetbitmap} or 
-\helpref{wxArtProvider::GetIcon}{wxartprovidergeticon}
-to query wxArtProvider for a resource.
-
-\membersection{wxArtProvider::GetBitmap}\label{wxartprovidergetbitmap}
-
-\func{static wxBitmap}{GetBitmap}{\param{const wxArtID\& }{id}, \param{const wxArtClient\& }{client = wxART\_OTHER}, \param{const wxSize\& }{size = wxDefaultSize}}
-
-Query registered providers for bitmap with given ID.
-
-\wxheading{Parameters}
-
-\docparam{id}{wxArtID unique identifier of the bitmap.}
-
-\docparam{client}{wxArtClient identifier of the client (i.e. who is asking for the bitmap).}
-
-\docparam{size}{Size of the returned bitmap or {\tt wxDefaultSize} if size doesn't matter.}
-
-\wxheading{Return value}
-
-The bitmap if one of registered providers recognizes the ID or wxNullBitmap otherwise.
-
-\membersection{wxArtProvider::GetIcon}\label{wxartprovidergeticon}
-
-\func{static wxIcon}{GetIcon}{\param{const wxArtID\& }{id}, \param{const wxArtClient\& }{client = wxART\_OTHER}, \param{const wxSize\& }{size = wxDefaultSize}}
-
-Same as \helpref{wxArtProvider::GetBitmap}{wxartprovidergetbitmap}, but
-return a wxIcon object (or wxNullIcon on failure).
-
-\membersection{wxArtProvider::PopProvider}\label{wxartproviderpopprovider}
-
-\func{static bool}{PopProvider}{\void}
-
-Remove latest added provider and delete it.
-
-\membersection{wxArtProvider::PushProvider}\label{wxartproviderpushprovider}
-
-\func{static void}{PushProvider}{\param{wxArtProvider* }{provider}}
-
-Register new art provider (add it to the top of providers stack).
-
-\membersection{wxArtProvider::RemoveProvider}\label{wxartproviderremoveprovider}
-
-\func{static bool}{RemoveProvider}{\param{wxArtProvider* }{provider}}
-
-Remove a provider from the stack. The provider must have been added previously
-and is {\it not} deleted.
-

docs/latex/wx/autoobj.tex

@@ -1,201 +0,0 @@
-\section{\class{wxAutomationObject}}\label{wxautomationobject}
-
-The {\bf wxAutomationObject} class represents an OLE automation object containing a single data member,
-an IDispatch pointer. It contains a number of functions that make it easy to perform
-automation operations, and set and get properties. The class makes heavy use of the \helpref{wxVariant}{wxvariant} class.
-
-The usage of these classes is quite close to OLE automation usage in Visual Basic. The API is
-high-level, and the application can specify multiple properties in a single string. The following example
-gets the current Excel instance, and if it exists, makes the active cell bold.
-
-{\small
-\begin{verbatim}
-  wxAutomationObject excelObject;
-  if (excelObject.GetInstance("Excel.Application"))
-      excelObject.PutProperty("ActiveCell.Font.Bold", TRUE);
-\end{verbatim}
-}
-
-Note that this class works under Windows only, and currently only for Visual C++.
-
-\wxheading{Derived from}
-
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/msw/ole/automtn.h>
-
-\wxheading{See also}
-
-\helpref{wxVariant}{wxvariant}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxAutomationObject::wxAutomationObject}\label{wxautomationobjectctor}
-
-\func{}{wxAutomationObject}{\param{WXIDISPATCH*}{ dispatchPtr = NULL}}
-
-Constructor, taking an optional IDispatch pointer which will be released when the
-object is deleted.
-
-\membersection{wxAutomationObject::\destruct{wxAutomationObject}}\label{wxautomationobjectdtor}
-
-\func{}{\destruct{wxAutomationObject}}{\void}
-
-Destructor. If the internal IDispatch pointer is non-null, it will be released.
-
-\membersection{wxAutomationObject::CallMethod}\label{wxautomationobjectcallmethod}
-
-\constfunc{wxVariant}{CallMethod}{\param{const wxString\&}{ method}, \param{int}{ noArgs},
- \param{wxVariant }{args[]}}
-
-\constfunc{wxVariant}{CallMethod}{\param{const wxString\&}{ method}, \param{...}{}}
-
-Calls an automation method for this object. The first form takes a method name, number of
-arguments, and an array of variants. The second form takes a method name and zero to six
-constant references to variants. Since the variant class has constructors for the basic
-data types, and C++ provides temporary objects automatically, both of the following lines
-are syntactically valid:
-
-{\small
-\begin{verbatim}
-  wxVariant res = obj.CallMethod("Sum", wxVariant(1.2), wxVariant(3.4));
-  wxVariant res = obj.CallMethod("Sum", 1.2, 3.4);
-\end{verbatim}
-}
-
-Note that {\it method} can contain dot-separated property names, to save the application
-needing to call GetProperty several times using several temporary objects. For example:
-
-{\small
-\begin{verbatim}
-  object.CallMethod("ActiveCell.Font.ShowDialog", "My caption");
-\end{verbatim}
-}
-
-\membersection{wxAutomationObject::CreateInstance}\label{wxautomationobjectcreateinstance}
-
-\constfunc{bool}{CreateInstance}{\param{const wxString\&}{ classId}}
-
-Creates a new object based on the class id, returning TRUE if the object was successfully created,
-or FALSE if not.
-
-\membersection{wxAutomationObject::GetDispatchPtr}\label{wxautomationobjectgetdispatchptr}
-
-\constfunc{IDispatch*}{GetDispatchPtr}{\void}
-
-Gets the IDispatch pointer.
-
-\membersection{wxAutomationObject::GetInstance}\label{wxautomationobjectgetinstance}
-
-\constfunc{bool}{GetInstance}{\param{const wxString\&}{ classId}}
-
-Retrieves the current object associated with a class id, and attaches the IDispatch pointer
-to this object. Returns TRUE if a pointer was successfully retrieved, FALSE otherwise.
-
-Note that this cannot cope with two instances of a given OLE object being active simultaneously,
-such as two copies of Excel running. Which object is referenced cannot currently be specified.
-
-\membersection{wxAutomationObject::GetObject}\label{wxautomationobjectgetobject}
-
-\constfunc{bool}{GetObject}{\param{wxAutomationObject\&}{obj} \param{const wxString\&}{ property},
- \param{int}{ noArgs = 0}, \param{wxVariant }{args[] = NULL}}
-
-Retrieves a property from this object, assumed to be a dispatch pointer, and initialises {\it obj} with it.
-To avoid having to deal with IDispatch pointers directly, use this function in preference
-to \helpref{wxAutomationObject::GetProperty}{wxautomationobjectgetproperty} when retrieving objects
-from other objects.
-
-Note that an IDispatch pointer is stored as a void* pointer in wxVariant objects.
-
-\wxheading{See also}
-
-\helpref{wxAutomationObject::GetProperty}{wxautomationobjectgetproperty}
-
-\membersection{wxAutomationObject::GetProperty}\label{wxautomationobjectgetproperty}
-
-\constfunc{wxVariant}{GetProperty}{\param{const wxString\&}{ property}, \param{int}{ noArgs},
- \param{wxVariant }{args[]}}
-
-\constfunc{wxVariant}{GetProperty}{\param{const wxString\&}{ property}, \param{...}{}}
-
-Gets a property value from this object. The first form takes a property name, number of
-arguments, and an array of variants. The second form takes a property name and zero to six
-constant references to variants. Since the variant class has constructors for the basic
-data types, and C++ provides temporary objects automatically, both of the following lines
-are syntactically valid:
-
-{\small
-\begin{verbatim}
-  wxVariant res = obj.GetProperty("Range", wxVariant("A1"));
-  wxVariant res = obj.GetProperty("Range", "A1");
-\end{verbatim}
-}
-
-Note that {\it property} can contain dot-separated property names, to save the application
-needing to call GetProperty several times using several temporary objects.
-
-\membersection{wxAutomationObject::Invoke}\label{wxautomationobjectinvoke}
-
-\constfunc{bool}{Invoke}{\param{const wxString\&}{ member}, \param{int}{ action},
- \param{wxVariant\& }{retValue}, \param{int}{ noArgs}, \param{wxVariant}{ args[]},
- \param{const wxVariant*}{ ptrArgs[] = 0}}
-
-This function is a low-level implementation that allows access to the IDispatch Invoke function.
-It is not meant to be called directly by the application, but is used by other convenience functions.
-
-\wxheading{Parameters}
-
-\docparam{member}{The member function or property name.}
-
-\docparam{action}{Bitlist: may contain DISPATCH\_PROPERTYPUT, DISPATCH\_PROPERTYPUTREF,
-DISPATCH\_METHOD.}
-
-\docparam{retValue}{Return value (ignored if there is no return value)}.
-
-\docparam{noArgs}{Number of arguments in {\it args} or {\it ptrArgs}.}
-
-\docparam{args}{If non-null, contains an array of variants.}
-
-\docparam{ptrArgs}{If non-null, contains an array of constant pointers to variants.}
-
-\wxheading{Return value}
-
-TRUE if the operation was successful, FALSE otherwise.
-
-\wxheading{Remarks}
-
-Two types of argument array are provided, so that when possible pointers are used for efficiency.
-
-\membersection{wxAutomationObject::PutProperty}\label{wxautomationobjectputproperty}
-
-\constfunc{bool}{PutProperty}{\param{const wxString\&}{ property}, \param{int}{ noArgs},
- \param{wxVariant }{args[]}}
-
-\func{bool}{PutProperty}{\param{const wxString\&}{ property}, \param{...}{}}
-
-Puts a property value into this object. The first form takes a property name, number of
-arguments, and an array of variants. The second form takes a property name and zero to six
-constant references to variants. Since the variant class has constructors for the basic
-data types, and C++ provides temporary objects automatically, both of the following lines
-are syntactically valid:
-
-{\small
-\begin{verbatim}
-  obj.PutProperty("Value", wxVariant(23));
-  obj.PutProperty("Value", 23);
-\end{verbatim}
-}
-
-Note that {\it property} can contain dot-separated property names, to save the application
-needing to call GetProperty several times using several temporary objects.
-
-\membersection{wxAutomationObject::SetDispatchPtr}\label{wxautomationobjectsetdispatchptr}
-
-\func{void}{SetDispatchPtr}{\param{WXIDISPATCH*}{ dispatchPtr}}
-
-Sets the IDispatch pointer. This function does not check if there is already an IDispatch pointer.
-
-You may need to cast from IDispatch* to WXIDISPATCH* when calling this function.
-

docs/latex/wx/bbutton.tex

@@ -1,245 +0,0 @@
-\section{\class{wxBitmapButton}}\label{wxbitmapbutton}
-
-A bitmap button is a control that contains a bitmap.
-It may be placed on a \helpref{dialog box}{wxdialog} or \helpref{panel}{wxpanel}, or indeed
-almost any other window.
-
-\wxheading{Derived from}
-
-\helpref{wxButton}{wxbutton}\\
-\helpref{wxControl}{wxcontrol}\\
-\helpref{wxWindow}{wxwindow}\\
-\helpref{wxEvtHandler}{wxevthandler}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/bmpbuttn.h>
-
-\wxheading{Remarks}
-
-A bitmap button can be supplied with a single bitmap, and wxWindows will draw
-all button states using this bitmap. If the application needs more control, additional bitmaps for
-the selected state, unpressed focused state, and greyed-out state may be supplied.
-
-\wxheading{Window styles}
-
-\twocolwidtha{5cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\windowstyle{wxBU\_AUTODRAW}}{If
-this is specified, the button will be drawn automatically using the label bitmap only, providing
-a 3D-look border. If this style is not specified, the button will be drawn without borders and using all
-provided bitmaps. WIN32 only.}
-\twocolitem{\windowstyle{wxBU\_LEFT}}{Left-justifies the bitmap label. WIN32 only.}
-\twocolitem{\windowstyle{wxBU\_TOP}}{Aligns the bitmap label to the top of the button. WIN32 only.}
-\twocolitem{\windowstyle{wxBU\_RIGHT}}{Right-justifies the bitmap label. WIN32 only.}
-\twocolitem{\windowstyle{wxBU\_BOTTOM}}{Aligns the bitmap label to the bottom of the button. WIN32 only.}
-\end{twocollist}
-
-See also \helpref{window styles overview}{windowstyles}.
-
-\wxheading{Event handling}
-
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_BUTTON(id, func)}}{Process a wxEVT\_COMMAND\_BUTTON\_CLICKED event,
-when the button is clicked.}
-\end{twocollist}
-
-\wxheading{See also}
-
-\helpref{wxButton}{wxbutton}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxBitmapButton::wxBitmapButton}\label{wxbitmapbuttonconstr}
-
-\func{}{wxBitmapButton}{\void}
-
-Default constructor.
-
-\func{}{wxBitmapButton}{
-\param{wxWindow* }{parent}, 
-\param{wxWindowID }{id}, 
-\param{const wxBitmap\& }{bitmap},\rtfsp
-\param{const wxPoint\& }{pos = wxDefaultPosition}, 
-\param{const wxSize\& }{size = wxDefaultSize},\rtfsp
-\param{long }{style = wxBU\_AUTODRAW}, 
-\param{const wxValidator\& }{validator = wxDefaultValidator}, 
-\param{const wxString\& }{name = ``button"}}
-
-Constructor, creating and showing a button.
-
-\wxheading{Parameters}
-
-\docparam{parent}{Parent window. Must not be NULL.}
-
-\docparam{id}{Button identifier. A value of -1 indicates a default value.}
-
-\docparam{bitmap}{Bitmap to be displayed.}
-
-\docparam{pos}{Button position.}
-
-\docparam{size}{Button size. If the default size (-1, -1) is specified then the button is sized
-appropriately for the bitmap.}
-
-\docparam{style}{Window style. See \helpref{wxBitmapButton}{wxbitmapbutton}.}
-
-\docparam{validator}{Window validator.}
-
-\docparam{name}{Window name.}
-
-\wxheading{Remarks}
-
-The {\it bitmap} parameter is normally the only bitmap you need to provide, and wxWindows will
-draw the button correctly in its different states. If you want more control, call
-any of the functions \helpref{wxBitmapButton::SetBitmapSelected}{wxbitmapbuttonsetbitmapselected},\rtfsp
-\helpref{wxBitmapButton::SetBitmapFocus}{wxbitmapbuttonsetbitmapfocus},\rtfsp
-\helpref{wxBitmapButton::SetBitmapDisabled}{wxbitmapbuttonsetbitmapdisabled}.
-
-Note that the bitmap passed is smaller than the actual button created.
-
-\wxheading{See also}
-
-\helpref{wxBitmapButton::Create}{wxbitmapbuttoncreate}, \helpref{wxValidator}{wxvalidator}
-
-\membersection{wxBitmapButton::\destruct{wxBitmapButton}}
-
-\func{}{\destruct{wxBitmapButton}}{\void}
-
-Destructor, destroying the button.
-
-\membersection{wxBitmapButton::Create}\label{wxbitmapbuttoncreate}
-
-\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id}, \param{const wxBitmap\& }{bitmap},\rtfsp
-\param{const wxPoint\& }{pos}, \param{const wxSize\& }{size = wxDefaultSize},\rtfsp
-\param{long}{ style = 0}, \param{const wxValidator\& }{validator}, \param{const wxString\& }{name = ``button"}}
-
-Button creation function for two-step creation. For more details, see \helpref{wxBitmapButton::wxBitmapButton}{wxbitmapbuttonconstr}.
-
-\membersection{wxBitmapButton::GetBitmapDisabled}\label{wxbitmapbuttongetbitmapdisabled}
-
-\constfunc{wxBitmap\&}{GetBitmapDisabled}{\void}
-
-Returns the bitmap for the disabled state.
-
-\wxheading{Return value}
-
-A reference to the disabled state bitmap.
-
-\wxheading{See also}
-
-\helpref{wxBitmapButton::SetBitmapDisabled}{wxbitmapbuttonsetbitmapdisabled}
-
-\membersection{wxBitmapButton::GetBitmapFocus}\label{wxbitmapbuttongetbitmapfocus}
-
-\constfunc{wxBitmap\&}{GetBitmapFocus}{\void}
-
-Returns the bitmap for the focused state.
-
-\wxheading{Return value}
-
-A reference to the focused state bitmap.
-
-\wxheading{See also}
-
-\helpref{wxBitmapButton::SetBitmapFocus}{wxbitmapbuttonsetbitmapfocus}
-
-\membersection{wxBitmapButton::GetBitmapLabel}\label{wxbitmapbuttongetbitmaplabel}
-
-\constfunc{wxBitmap\&}{GetBitmapLabel}{\void}
-
-Returns the label bitmap (the one passed to the constructor).
-
-\wxheading{Return value}
-
-A reference to the button's label bitmap.
-
-\wxheading{See also}
-
-\helpref{wxBitmapButton::SetBitmapLabel}{wxbitmapbuttonsetbitmaplabel}
-
-\membersection{wxBitmapButton::GetBitmapSelected}\label{wxbitmapbuttongetbitmapselected}
-
-\constfunc{wxBitmap\&}{GetBitmapSelected}{\void}
-
-Returns the bitmap for the selected state.
-
-\wxheading{Return value}
-
-A reference to the selected state bitmap.
-
-\wxheading{See also}
-
-\helpref{wxBitmapButton::SetBitmapSelected}{wxbitmapbuttonsetbitmapselected}
-
-\membersection{wxBitmapButton::SetBitmapDisabled}\label{wxbitmapbuttonsetbitmapdisabled}
-
-\func{void}{SetBitmapDisabled}{\param{const wxBitmap\& }{bitmap}}
-
-Sets the bitmap for the disabled button appearance.
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{The bitmap to set.}
-
-\wxheading{See also}
-
-\helpref{wxBitmapButton::GetBitmapDisabled}{wxbitmapbuttongetbitmapdisabled},\rtfsp
-\helpref{wxBitmapButton::SetBitmapLabel}{wxbitmapbuttonsetbitmaplabel},\rtfsp
-\helpref{wxBitmapButton::SetBitmapSelected}{wxbitmapbuttonsetbitmapselected},\rtfsp
-\helpref{wxBitmapButton::SetBitmapFocus}{wxbitmapbuttonsetbitmapfocus}
-
-\membersection{wxBitmapButton::SetBitmapFocus}\label{wxbitmapbuttonsetbitmapfocus}
-
-\func{void}{SetBitmapFocus}{\param{const wxBitmap\& }{bitmap}}
-
-Sets the bitmap for the button appearance when it has the keyboard focus.
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{The bitmap to set.}
-
-\wxheading{See also}
-
-\helpref{wxBitmapButton::GetBitmapFocus}{wxbitmapbuttongetbitmapfocus},\rtfsp
-\helpref{wxBitmapButton::SetBitmapLabel}{wxbitmapbuttonsetbitmaplabel},\rtfsp
-\helpref{wxBitmapButton::SetBitmapSelected}{wxbitmapbuttonsetbitmapselected},\rtfsp
-\helpref{wxBitmapButton::SetBitmapDisabled}{wxbitmapbuttonsetbitmapdisabled}
-
-\membersection{wxBitmapButton::SetBitmapLabel}\label{wxbitmapbuttonsetbitmaplabel}
-
-\func{void}{SetBitmapLabel}{\param{const wxBitmap\& }{bitmap}}
-
-Sets the bitmap label for the button.
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{The bitmap label to set.}
-
-\wxheading{Remarks}
-
-This is the bitmap used for the unselected state, and for all other states
-if no other bitmaps are provided.
-
-\wxheading{See also}
-
-\helpref{wxBitmapButton::GetBitmapLabel}{wxbitmapbuttongetbitmaplabel}
-
-\membersection{wxBitmapButton::SetBitmapSelected}\label{wxbitmapbuttonsetbitmapselected}
-
-\func{void}{SetBitmapSelected}{\param{const wxBitmap\& }{bitmap}}
-
-Sets the bitmap for the selected (depressed) button appearance.
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{The bitmap to set.}
-
-\wxheading{See also}
-
-\helpref{wxBitmapButton::GetBitmapSelected}{wxbitmapbuttongetbitmapselected},\rtfsp
-\helpref{wxBitmapButton::SetBitmapLabel}{wxbitmapbuttonsetbitmaplabel},\rtfsp
-\helpref{wxBitmapButton::SetBitmapFocus}{wxbitmapbuttonsetbitmapfocus},\rtfsp
-\helpref{wxBitmapButton::SetBitmapDisabled}{wxbitmapbuttonsetbitmapdisabled}
-

docs/latex/wx/bitmap.tex

@@ -1,615 +0,0 @@
-\section{\class{wxBitmap}}\label{wxbitmap}
-
-%\overview{Overview}{wxbitmapoverview}
-%
-This class encapsulates the concept of a platform-dependent bitmap,
-either monochrome or colour.
-
-\wxheading{Derived from}
-
-\helpref{wxGDIObject}{wxgdiobject}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include file}
-
-<wx/bitmap.h>
-
-\wxheading{Predefined objects}
-
-Objects:
-
-{\bf wxNullBitmap}
-
-\wxheading{See also}
-
-\helpref{wxBitmap overview}{wxbitmapoverview},
-\helpref{supported bitmap file formats}{supportedbitmapformats},
-\helpref{wxDC::Blit}{wxdcblit},
-\helpref{wxIcon}{wxicon}, \helpref{wxCursor}{wxcursor}, \helpref{wxBitmap}{wxbitmap},
-\helpref{wxMemoryDC}{wxmemorydc}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxBitmap::wxBitmap}\label{wxbitmapconstr}
-
-\func{}{wxBitmap}{\void}
-
-Default constructor.
-
-\func{}{wxBitmap}{\param{const wxBitmap\& }{bitmap}}
-
-Copy constructor.
-
-\func{}{wxBitmap}{\param{void*}{ data}, \param{int}{ type}, \param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
-
-Creates a bitmap from the given data which is interpreted in platform-dependent
-manner.
-
-\func{}{wxBitmap}{\param{const char}{ bits[]}, \param{int}{ width}, \param{int}{ height}\\
-  \param{int}{ depth = 1}}
-
-Creates a bitmap from an array of bits.
-
-You should only use this function for monochrome bitmaps ({\it depth} 1) in
-portable programs: in this case the {\it bits} parameter should contain an XBM
-image.
-
-For other bit depths, the behaviour is platform dependent: under Windows, the
-data is passed without any changes to the underlying {\tt CreateBitmap()} API.
-Under other platforms, only monochrome bitmaps may be created using this
-constructor and \helpref{wxImage}{wximage} should be used for creating colour
-bitmaps from static data.
-
-\func{}{wxBitmap}{\param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
-
-Creates a new bitmap. A depth of -1 indicates the depth of the current screen
-or visual. Some platforms only support 1 for monochrome and -1 for the current
-colour setting.
-
-\func{}{wxBitmap}{\param{const char**}{ bits}}
-
-Creates a bitmap from XPM data.
-
-\func{}{wxBitmap}{\param{const wxString\& }{name}, \param{long}{ type}}
-
-Loads a bitmap from a file or resource.
-
-\func{}{wxBitmap}{\param{const wxImage\&}{ img}, \param{int}{ depth = -1}}
-
-Creates bitmap object from the image. This has to be done
-to actually display an image as you cannot draw an image directly on a window.
-The resulting bitmap will use the provided colour depth (or that of the
-current system if depth is -1) which entails that a colour reduction has
-to take place.
-
-When in 8-bit mode (PseudoColour mode), the GTK port will use a color cube created
-on program start-up to look up colors. This ensures a very fast conversion, but
-the image quality won't be perfect (and could be better for photo images using more
-sophisticated dithering algorithms).
-
-On Windows, if there is a palette present (set with SetPalette), it will be used when
-creating the wxBitmap (most useful in 8-bit display mode). On other platforms,
-the palette is currently ignored.
-
-\wxheading{Parameters}
-
-\docparam{bits}{Specifies an array of pixel values.}
-
-\docparam{width}{Specifies the width of the bitmap.}
-
-\docparam{height}{Specifies the height of the bitmap.}
-
-\docparam{depth}{Specifies the depth of the bitmap. If this is omitted, the display depth of the
-screen is used.}
-
-\docparam{name}{This can refer to a resource name under MS Windows, or a filename under MS Windows and X.
-Its meaning is determined by the {\it type} parameter.}
-
-\docparam{type}{May be one of the following:
-
-\twocolwidtha{5cm}
-\begin{twocollist}
-\twocolitem{\indexit{wxBITMAP\_TYPE\_BMP}}{Load a Windows bitmap file.}
-\twocolitem{\indexit{wxBITMAP\_TYPE\_BMP\_RESOURCE}}{Load a Windows bitmap from the resource database.}
-\twocolitem{\indexit{wxBITMAP\_TYPE\_GIF}}{Load a GIF bitmap file.}
-\twocolitem{\indexit{wxBITMAP\_TYPE\_XBM}}{Load an X bitmap file.}
-\twocolitem{\indexit{wxBITMAP\_TYPE\_XPM}}{Load an XPM bitmap file.}
-\twocolitem{\indexit{wxBITMAP\_TYPE\_RESOURCE}}{Load a Windows resource name.}
-\end{twocollist}
-
-The validity of these flags depends on the platform and wxWindows configuration.
-If all possible wxWindows settings are used, the Windows platform supports BMP file, BMP resource,
-XPM data, and XPM. Under wxGTK, the available formats are BMP file, XPM data, XPM file, and PNG file.
-Under wxMotif, the available formats are XBM data, XBM file, XPM data, XPM file.
-
-In addition, wxBitmap can read all formats that \helpref{wxImage}{wximage} can, which currently include
-wxBITMAP\_TYPE\_JPEG, wxBITMAP\_TYPE\_TIF, wxBITMAP\_TYPE\_PNG, wxBITMAP\_TYPE\_GIF, wxBITMAP\_TYPE\_PCX,
-and wxBITMAP\_TYPE\_PNM. Of course, you must have wxImage handlers loaded. }
-
-\docparam{img}{Platform-independent wxImage object.}
-
-\wxheading{Remarks}
-
-The first form constructs a bitmap object with no data; an assignment or another member function such as Create
-or LoadFile must be called subsequently.
-
-The second and third forms provide copy constructors. Note that these do not copy the
-bitmap data, but instead a pointer to the data, keeping a reference count. They are therefore
-very efficient operations.
-
-The fourth form constructs a bitmap from data whose type and value depends on
-the value of the {\it type} argument.
-
-The fifth form constructs a (usually monochrome) bitmap from an array of pixel values, under both
-X and Windows.
-
-The sixth form constructs a new bitmap.
-
-The seventh form constructs a bitmap from pixmap (XPM) data, if wxWindows has been configured
-to incorporate this feature.
-
-To use this constructor, you must first include an XPM file. For
-example, assuming that the file {\tt mybitmap.xpm} contains an XPM array
-of character pointers called mybitmap:
-
-\begin{verbatim}
-#include "mybitmap.xpm"
-
-...
-
-wxBitmap *bitmap = new wxBitmap(mybitmap);
-\end{verbatim}
-
-The eighth form constructs a bitmap from a file or resource. {\it name} can refer
-to a resource name under MS Windows, or a filename under MS Windows and X.
-
-Under Windows, {\it type} defaults to wxBITMAP\_TYPE\_BMP\_RESOURCE.
-Under X, {\it type} defaults to wxBITMAP\_TYPE\_XPM.
-
-\wxheading{See also}
-
-\helpref{wxBitmap::LoadFile}{wxbitmaploadfile}
-
-\pythonnote{Constructors supported by wxPython are:\par
-\indented{2cm}{\begin{twocollist}
-\twocolitem{{\bf wxBitmap(name, flag)}}{Loads a bitmap from a file}
-\twocolitem{{\bf wxEmptyBitmap(width, height, depth = -1)}}{Creates an
-empty bitmap with the given specifications}
-\twocolitem{{\bf wxBitmapFromXPMData(listOfStrings)}}{Create a bitmap
-from a Python list of strings whose contents are XPM data.}
-\twocolitem{{\bf wxBitmapFromBits(bits, width, height,
-depth=-1)}}{Create a bitmap from an array of bits contained in a
-string.}
-\twocolitem{{\bf wxBitmapFromImage(image, depth=-1)}}{Convert a
-wxImage to a wxBitmap.}
-\end{twocollist}}
-}
-
-\perlnote{Constructors supported by wxPerl are:\par
-\begin{itemize}
-\item{Wx::Bitmap->new( width, height, depth = -1 )}
-\item{Wx::Bitmap->new( name, type )}
-\item{Wx::Bitmap->new( icon )}
-\item{Wx::Bitmap->newFromBits( bits, width, height, depth = 1 )}
-\item{Wx::Bitmap->newFromXPM( data )}
-\end{itemize}
-}
-
-\membersection{wxBitmap::\destruct{wxBitmap}}
-
-\func{}{\destruct{wxBitmap}}{\void}
-
-Destroys the wxBitmap object and possibly the underlying bitmap data.
-Because reference counting is used, the bitmap may not actually be
-destroyed at this point - only when the reference count is zero will the
-data be deleted.
-
-If the application omits to delete the bitmap explicitly, the bitmap will be
-destroyed automatically by wxWindows when the application exits.
-
-Do not delete a bitmap that is selected into a memory device context.
-
-\membersection{wxBitmap::AddHandler}\label{wxbitmapaddhandler}
-
-\func{static void}{AddHandler}{\param{wxBitmapHandler*}{ handler}}
-
-Adds a handler to the end of the static list of format handlers.
-
-\docparam{handler}{A new bitmap format handler object. There is usually only one instance
-of a given handler class in an application session.}
-
-\wxheading{See also}
-
-\helpref{wxBitmapHandler}{wxbitmaphandler}
-
-\membersection{wxBitmap::CleanUpHandlers}
-
-\func{static void}{CleanUpHandlers}{\void}
-
-Deletes all bitmap handlers.
-
-This function is called by wxWindows on exit.
-
-\membersection{wxBitmap::ConvertToImage}\label{wxbitmapconverttoimage}
-
-\func{wxImage}{ConvertToImage}{\void}
-
-Creates an image from a platform-dependent bitmap. This preserves
-mask information so that bitmaps and images can be converted back
-and forth without loss in that respect.
-
-\membersection{wxBitmap::Create}\label{wxbitmapcreate}
-
-\func{virtual bool}{Create}{\param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
-
-Creates a fresh bitmap. If the final argument is omitted, the display depth of
-the screen is used.
-
-\func{virtual bool}{Create}{\param{void*}{ data}, \param{int}{ type}, \param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
-
-Creates a bitmap from the given data, which can be of arbitrary type.
-
-\wxheading{Parameters}
-
-\docparam{width}{The width of the bitmap in pixels.}
-
-\docparam{height}{The height of the bitmap in pixels.}
-
-\docparam{depth}{The depth of the bitmap in pixels. If this is -1, the screen depth is used.}
-
-\docparam{data}{Data whose type depends on the value of {\it type}.}
-
-\docparam{type}{A bitmap type identifier - see \helpref{wxBitmap::wxBitmap}{wxbitmapconstr} for a list
-of possible values.}
-
-\wxheading{Return value}
-
-TRUE if the call succeeded, FALSE otherwise.
-
-\wxheading{Remarks}
-
-The first form works on all platforms. The portability of the second form depends on the
-type of data.
-
-\wxheading{See also}
-
-\helpref{wxBitmap::wxBitmap}{wxbitmapconstr}
-
-\membersection{wxBitmap::FindHandler}
-
-\func{static wxBitmapHandler*}{FindHandler}{\param{const wxString\& }{name}}
-
-Finds the handler with the given name.
-
-\func{static wxBitmapHandler*}{FindHandler}{\param{const wxString\& }{extension}, \param{long}{ bitmapType}}
-
-Finds the handler associated with the given extension and type.
-
-\func{static wxBitmapHandler*}{FindHandler}{\param{long }{bitmapType}}
-
-Finds the handler associated with the given bitmap type.
-
-\docparam{name}{The handler name.}
-
-\docparam{extension}{The file extension, such as ``bmp".}
-
-\docparam{bitmapType}{The bitmap type, such as wxBITMAP\_TYPE\_BMP.}
-
-\wxheading{Return value}
-
-A pointer to the handler if found, NULL otherwise.
-
-\wxheading{See also}
-
-\helpref{wxBitmapHandler}{wxbitmaphandler}
-
-\membersection{wxBitmap::GetDepth}
-
-\constfunc{int}{GetDepth}{\void}
-
-Gets the colour depth of the bitmap. A value of 1 indicates a
-monochrome bitmap.
-
-\membersection{wxBitmap::GetHandlers}
-
-\func{static wxList\&}{GetHandlers}{\void}
-
-Returns the static list of bitmap format handlers.
-
-\wxheading{See also}
-
-\helpref{wxBitmapHandler}{wxbitmaphandler}
-
-\membersection{wxBitmap::GetHeight}\label{wxbitmapgetheight}
-
-\constfunc{int}{GetHeight}{\void}
-
-Gets the height of the bitmap in pixels.
-
-\membersection{wxBitmap::GetPalette}\label{wxbitmapgetpalette}
-
-\constfunc{wxPalette*}{GetPalette}{\void}
-
-Gets the associated palette (if any) which may have been loaded from a file
-or set for the bitmap.
-
-\wxheading{See also}
-
-\helpref{wxPalette}{wxpalette}
-
-\membersection{wxBitmap::GetMask}\label{wxbitmapgetmask}
-
-\constfunc{wxMask*}{GetMask}{\void}
-
-Gets the associated mask (if any) which may have been loaded from a file
-or set for the bitmap.
-
-\wxheading{See also}
-
-\helpref{wxBitmap::SetMask}{wxbitmapsetmask}, \helpref{wxMask}{wxmask}
-
-\membersection{wxBitmap::GetWidth}\label{wxbitmapgetwidth}
-
-\constfunc{int}{GetWidth}{\void}
-
-Gets the width of the bitmap in pixels.
-
-\wxheading{See also}
-
-\helpref{wxBitmap::GetHeight}{wxbitmapgetheight}
-
-\membersection{wxBitmap::GetSubBitmap}\label{wxbitmapgetsubbitmap}
-
-\constfunc{wxBitmap}{GetSubBitmap}{\param{const wxRect\&}{rect}}
-
-Returns a sub bitmap of the current one as long as the rect belongs entirely to
-the bitmap. This function preserves bit depth and mask information.
-
-\membersection{wxBitmap::InitStandardHandlers}
-
-\func{static void}{InitStandardHandlers}{\void}
-
-Adds the standard bitmap format handlers, which, depending on wxWindows
-configuration, can be handlers for Windows bitmap, Windows bitmap resource, and XPM.
-
-This function is called by wxWindows on startup.
-
-\wxheading{See also}
-
-\helpref{wxBitmapHandler}{wxbitmaphandler}
-
-\membersection{wxBitmap::InsertHandler}
-
-\func{static void}{InsertHandler}{\param{wxBitmapHandler*}{ handler}}
-
-Adds a handler at the start of the static list of format handlers.
-
-\docparam{handler}{A new bitmap format handler object. There is usually only one instance
-of a given handler class in an application session.}
-
-\wxheading{See also}
-
-\helpref{wxBitmapHandler}{wxbitmaphandler}
-
-\membersection{wxBitmap::LoadFile}\label{wxbitmaploadfile}
-
-\func{bool}{LoadFile}{\param{const wxString\&}{ name}, \param{long}{ type}}
-
-Loads a bitmap from a file or resource.
-
-\wxheading{Parameters}
-
-\docparam{name}{Either a filename or a Windows resource name.
-The meaning of {\it name} is determined by the {\it type} parameter.}
-
-\docparam{type}{One of the following values:
-
-\twocolwidtha{5cm}
-\begin{twocollist}
-\twocolitem{{\bf wxBITMAP\_TYPE\_BMP}}{Load a Windows bitmap file.}
-\twocolitem{{\bf wxBITMAP\_TYPE\_BMP\_RESOURCE}}{Load a Windows bitmap from the resource database.}
-\twocolitem{{\bf wxBITMAP\_TYPE\_GIF}}{Load a GIF bitmap file.}
-\twocolitem{{\bf wxBITMAP\_TYPE\_XBM}}{Load an X bitmap file.}
-\twocolitem{{\bf wxBITMAP\_TYPE\_XPM}}{Load an XPM bitmap file.}
-\end{twocollist}
-
-The validity of these flags depends on the platform and wxWindows configuration.
-
-In addition, wxBitmap can read all formats that \helpref{wxImage}{wximage} can
-(wxBITMAP\_TYPE\_JPEG, wxBITMAP\_TYPE\_PNG, wxBITMAP\_TYPE\_GIF, wxBITMAP\_TYPE\_PCX, wxBITMAP\_TYPE\_PNM).
-(Of course you must have wxImage handlers loaded.) }
-
-\wxheading{Return value}
-
-TRUE if the operation succeeded, FALSE otherwise.
-
-\wxheading{Remarks}
-
-A palette may be associated with the bitmap if one exists (especially for
-colour Windows bitmaps), and if the code supports it. You can check
-if one has been created by using the \helpref{GetPalette}{wxbitmapgetpalette} member.
-
-\wxheading{See also}
-
-\helpref{wxBitmap::SaveFile}{wxbitmapsavefile}
-
-\membersection{wxBitmap::Ok}\label{wxbitmapok}
-
-\constfunc{bool}{Ok}{\void}
-
-Returns TRUE if bitmap data is present.
-
-\membersection{wxBitmap::RemoveHandler}
-
-\func{static bool}{RemoveHandler}{\param{const wxString\& }{name}}
-
-Finds the handler with the given name, and removes it. The handler
-is not deleted.
-
-\docparam{name}{The handler name.}
-
-\wxheading{Return value}
-
-TRUE if the handler was found and removed, FALSE otherwise.
-
-\wxheading{See also}
-
-\helpref{wxBitmapHandler}{wxbitmaphandler}
-
-\membersection{wxBitmap::SaveFile}\label{wxbitmapsavefile}
-
-\func{bool}{SaveFile}{\param{const wxString\& }{name}, \param{int}{ type}, \param{wxPalette* }{palette = NULL}}
-
-Saves a bitmap in the named file.
-
-\wxheading{Parameters}
-
-\docparam{name}{A filename. The meaning of {\it name} is determined by the {\it type} parameter.}
-
-\docparam{type}{One of the following values:
-
-\twocolwidtha{5cm}
-\begin{twocollist}
-\twocolitem{{\bf wxBITMAP\_TYPE\_BMP}}{Save a Windows bitmap file.}
-\twocolitem{{\bf wxBITMAP\_TYPE\_GIF}}{Save a GIF bitmap file.}
-\twocolitem{{\bf wxBITMAP\_TYPE\_XBM}}{Save an X bitmap file.}
-\twocolitem{{\bf wxBITMAP\_TYPE\_XPM}}{Save an XPM bitmap file.}
-\end{twocollist}
-
-The validity of these flags depends on the platform and wxWindows configuration.
-
-In addition, wxBitmap can save all formats that \helpref{wxImage}{wximage} can
-(wxBITMAP\_TYPE\_JPEG, wxBITMAP\_TYPE\_PNG).
-(Of course you must have wxImage handlers loaded.) }
-
-\docparam{palette}{An optional palette used for saving the bitmap.}
-% TODO: this parameter should
-%probably be eliminated; instead the app should set the palette before saving.
-
-\wxheading{Return value}
-
-TRUE if the operation succeeded, FALSE otherwise.
-
-\wxheading{Remarks}
-
-Depending on how wxWindows has been configured, not all formats may be available.
-
-\wxheading{See also}
-
-\helpref{wxBitmap::LoadFile}{wxbitmaploadfile}
-
-\membersection{wxBitmap::SetDepth}\label{wxbitmapsetdepth}
-
-\func{void}{SetDepth}{\param{int }{depth}}
-
-Sets the depth member (does not affect the bitmap data).
-
-\wxheading{Parameters}
-
-\docparam{depth}{Bitmap depth.}
-
-\membersection{wxBitmap::SetHeight}\label{wxbitmapsetheight}
-
-\func{void}{SetHeight}{\param{int }{height}}
-
-Sets the height member (does not affect the bitmap data).
-
-\wxheading{Parameters}
-
-\docparam{height}{Bitmap height in pixels.}
-
-\membersection{wxBitmap::SetMask}\label{wxbitmapsetmask}
-
-\func{void}{SetMask}{\param{wxMask* }{mask}}
-
-Sets the mask for this bitmap.
-
-\wxheading{Remarks}
-
-The bitmap object owns the mask once this has been called.
-
-\wxheading{See also}
-
-\helpref{wxBitmap::GetMask}{wxbitmapgetmask}, \helpref{wxMask}{wxmask}
-
-%% VZ: this function is an implementation detail and shouldn't be documented
-%%\membersection{wxBitmap::SetOk}
-%%
-%%\func{void}{SetOk}{\param{int }{isOk}}
-%%
-%%Sets the validity member (does not affect the bitmap data).
-%%
-%%\wxheading{Parameters}
-%%
-%%\docparam{isOk}{Validity flag.}
-
-\membersection{wxBitmap::SetPalette}\label{wxbitmapsetpalette}
-
-\func{void}{SetPalette}{\param{const wxPalette\& }{palette}}
-
-Sets the associated palette.
-
-\wxheading{Parameters}
-
-\docparam{palette}{The palette to set.}
-
-\wxheading{See also}
-
-\helpref{wxPalette}{wxpalette}
-
-\membersection{wxBitmap::SetWidth}
-
-\func{void}{SetWidth}{\param{int }{width}}
-
-Sets the width member (does not affect the bitmap data).
-
-\wxheading{Parameters}
-
-\docparam{width}{Bitmap width in pixels.}
-
-\membersection{wxBitmap::operator $=$}
-
-\func{wxBitmap\& }{operator $=$}{\param{const wxBitmap\& }{bitmap}}
-
-Assignment operator. This operator does not copy any data, but instead
-passes a pointer to the data in {\it bitmap} and increments a reference
-counter. It is a fast operation.
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{Bitmap to assign.}
-
-\wxheading{Return value}
-
-Returns 'this' object.
-
-\membersection{wxBitmap::operator $==$}
-
-\func{bool}{operator $==$}{\param{const wxBitmap\& }{bitmap}}
-
-Equality operator. This operator tests whether the internal data pointers are
-equal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{Bitmap to compare with 'this'}
-
-\wxheading{Return value}
-
-Returns TRUE if the bitmaps were effectively equal, FALSE otherwise.
-
-\membersection{wxBitmap::operator $!=$}
-
-\func{bool}{operator $!=$}{\param{const wxBitmap\& }{bitmap}}
-
-Inequality operator. This operator tests whether the internal data pointers are
-unequal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{Bitmap to compare with 'this'}
-
-\wxheading{Return value}
-
-Returns TRUE if the bitmaps were unequal, FALSE otherwise.
-

docs/latex/wx/bmpdatob.tex

@@ -1,60 +0,0 @@
-\section{\class{wxBitmapDataObject}}\label{wxbitmapdataobject}
-
-wxBitmapDataObject is a specialization of wxDataObject for bitmap data. It can
-be used without change to paste data into the 
-\helpref{wxClipboard}{wxclipboard} or a \helpref{wxDropSource}{wxdropsource}. A
-user may wish to derive a new class from this class for providing a bitmap
-on-demand in order to minimize memory consumption when offering data in several
-formats, such as a bitmap and GIF.
-
-\pythonnote{If you wish to create a derived wxBitmapDataObject class in
-wxPython you should derive the class from wxPyBitmapDataObject
-in order to get Python-aware capabilities for the various virtual
-methods.}
-
-\wxheading{Virtual functions to override}
-
-This class may be used as is, but 
-\helpref{GetBitmap}{wxbitmapdataobjectgetbitmap} may be overridden to increase
-efficiency.
-
-\wxheading{Derived from}
-
-\helpref{wxDataObjectSimple}{wxdataobjectsimple}\\
-\helpref{wxDataObject}{wxdataobject}
-
-\wxheading{Include files}
-
-<wx/dataobj.h>
-
-\wxheading{See also}
-
-\helpref{Clipboard and drag and drop overview}{wxdndoverview}, 
-\helpref{wxDataObject}{wxdataobject}, 
-\helpref{wxDataObjectSimple}{wxdataobjectsimple}, 
-\helpref{wxFileDataObject}{wxfiledataobject}, 
-\helpref{wxTextDataObject}{wxtextdataobject}, 
-\helpref{wxDataObject}{wxdataobject}
-
-\func{}{wxBitmapDataObject}{\param{const wxBitmap\& }{bitmap = wxNullBitmap}}
-
-Constructor, optionally passing a bitmap (otherwise use 
-\helpref{SetBitmap}{wxbitmapdataobjectsetbitmap} later).
-
-\membersection{wxBitmapDataObject::GetBitmap}\label{wxbitmapdataobjectgetbitmap}
-
-\constfunc{virtual wxBitmap}{GetBitmap}{\void}
-
-Returns the bitmap associated with the data object. You may wish to override
-this method when offering data on-demand, but this is not required by
-wxWindows' internals. Use this method to get data in bitmap form from
-the \helpref{wxClipboard}{wxclipboard}.
-
-\membersection{wxBitmapDataObject::SetBitmap}\label{wxbitmapdataobjectsetbitmap}
-
-\func{virtual void}{SetBitmap}{\param{const wxBitmap\& }{bitmap}}
-
-Sets the bitmap associated with the data object. This method is called when the
-data object receives data. Usually there will be no reason to override this
-function.
-

docs/latex/wx/bmphand.tex

@@ -1,165 +0,0 @@
-\section{\class{wxBitmapHandler}}\label{wxbitmaphandler}
-
-\overview{Overview}{wxbitmapoverview}
-
-This is the base class for implementing bitmap file loading/saving, and bitmap creation from data.
-It is used within wxBitmap and is not normally seen by the application.
-
-If you wish to extend the capabilities of wxBitmap, derive a class from wxBitmapHandler
-and add the handler using \helpref{wxBitmap::AddHandler}{wxbitmapaddhandler} in your
-application initialisation.
-
-\wxheading{Derived from}
-
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/bitmap.h>
-
-\wxheading{See also}
-
-\helpref{wxBitmap}{wxbitmap}, \helpref{wxIcon}{wxicon}, \helpref{wxCursor}{wxcursor}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxBitmapHandler::wxBitmapHandler}\label{wxbitmaphandlerconstr}
-
-\func{}{wxBitmapHandler}{\void}
-
-Default constructor. In your own default constructor, initialise the members
-m\_name, m\_extension and m\_type.
-
-\membersection{wxBitmapHandler::\destruct{wxBitmapHandler}}
-
-\func{}{\destruct{wxBitmapHandler}}{\void}
-
-Destroys the wxBitmapHandler object.
-
-\membersection{wxBitmapHandler::Create}
-
-\func{virtual bool}{Create}{\param{wxBitmap* }{bitmap}, \param{void*}{ data}, \param{int}{ type}, \param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
-
-Creates a bitmap from the given data, which can be of arbitrary type. The wxBitmap object {\it bitmap} is
-manipulated by this function.
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{The wxBitmap object.}
-
-\docparam{width}{The width of the bitmap in pixels.}
-
-\docparam{height}{The height of the bitmap in pixels.}
-
-\docparam{depth}{The depth of the bitmap in pixels. If this is -1, the screen depth is used.}
-
-\docparam{data}{Data whose type depends on the value of {\it type}.}
-
-\docparam{type}{A bitmap type identifier - see \helpref{wxBitmapHandler::wxBitmapHandler}{wxbitmapconstr} for a list
-of possible values.}
-
-\wxheading{Return value}
-
-TRUE if the call succeeded, FALSE otherwise (the default).
-
-\membersection{wxBitmapHandler::GetName}
-
-\constfunc{wxString}{GetName}{\void}
-
-Gets the name of this handler.
-
-\membersection{wxBitmapHandler::GetExtension}
-
-\constfunc{wxString}{GetExtension}{\void}
-
-Gets the file extension associated with this handler.
-
-\membersection{wxBitmapHandler::GetType}
-
-\constfunc{long}{GetType}{\void}
-
-Gets the bitmap type associated with this handler.
-
-\membersection{wxBitmapHandler::LoadFile}\label{wxbitmaphandlerloadfile}
-
-\func{bool}{LoadFile}{\param{wxBitmap* }{bitmap}, \param{const wxString\&}{ name}, \param{long}{ type}}
-
-Loads a bitmap from a file or resource, putting the resulting data into {\it bitmap}.
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{The bitmap object which is to be affected by this operation.}
-
-\docparam{name}{Either a filename or a Windows resource name.
-The meaning of {\it name} is determined by the {\it type} parameter.}
-
-\docparam{type}{See \helpref{wxBitmap::wxBitmap}{wxbitmapconstr} for values this can take.}
-
-\wxheading{Return value}
-
-TRUE if the operation succeeded, FALSE otherwise.
-
-\wxheading{See also}
-
-\helpref{wxBitmap::LoadFile}{wxbitmaploadfile}\\
-\helpref{wxBitmap::SaveFile}{wxbitmapsavefile}\\
-\helpref{wxBitmapHandler::SaveFile}{wxbitmaphandlersavefile}
-
-\membersection{wxBitmapHandler::SaveFile}\label{wxbitmaphandlersavefile}
-
-\func{bool}{SaveFile}{\param{wxBitmap* }{bitmap}, \param{const wxString\& }{name}, \param{int}{ type}, \param{wxPalette* }{palette = NULL}}
-
-Saves a bitmap in the named file.
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{The bitmap object which is to be affected by this operation.}
-
-\docparam{name}{A filename. The meaning of {\it name} is determined by the {\it type} parameter.}
-
-\docparam{type}{See \helpref{wxBitmap::wxBitmap}{wxbitmapconstr} for values this can take.}
-
-\docparam{palette}{An optional palette used for saving the bitmap.}
-
-\wxheading{Return value}
-
-TRUE if the operation succeeded, FALSE otherwise.
-
-\wxheading{See also}
-
-\helpref{wxBitmap::LoadFile}{wxbitmaploadfile}\\
-\helpref{wxBitmap::SaveFile}{wxbitmapsavefile}\\
-\helpref{wxBitmapHandler::LoadFile}{wxbitmaphandlerloadfile}
-
-\membersection{wxBitmapHandler::SetName}
-
-\func{void}{SetName}{\param{const wxString\& }{name}}
-
-Sets the handler name.
-
-\wxheading{Parameters}
-
-\docparam{name}{Handler name.}
-
-\membersection{wxBitmapHandler::SetExtension}
-
-\func{void}{SetExtension}{\param{const wxString\& }{extension}}
-
-Sets the handler extension.
-
-\wxheading{Parameters}
-
-\docparam{extension}{Handler extension.}
-
-\membersection{wxBitmapHandler::SetType}
-
-\func{void}{SetType}{\param{long }{type}}
-
-Sets the handler type.
-
-\wxheading{Parameters}
-
-\docparam{name}{Handler type.}
-
-
-

docs/latex/wx/body.tex

@@ -1,723 +0,0 @@
-\chapter{Introduction}\label{introduction}
-\pagenumbering{arabic}%
-\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
-\setfooter{\thepage}{}{}{}{}{\thepage}%
-
-\section{What is wxWindows?}
-
-wxWindows is a C++ framework providing GUI (Graphical User
-Interface) and other facilities on more than one platform.  Version 2 currently
-supports all desktop versions of MS Windows, Unix with GTK+, Unix with Motif,
-and MacOS. An OS/2 port is in progress.
-
-wxWindows was originally developed at the Artificial Intelligence
-Applications Institute, University of Edinburgh, for internal use,
-and was first made publicly available in 1992.
-Version 2 is a vastly improved version written and maintained by
-Julian Smart, Robert Roebling, Vadim Zeitlin, Vaclav Slavik and many others.
-
-This manual contains a class reference and topic overviews.
-For a selection of wxWindows tutorials, please see the documentation page on the \urlref{wxWindows web site}{http://www.wxwindows.org}.
-
-Please note that in the following, ``MS Windows" often refers to all
-platforms related to Microsoft Windows, including 16-bit and 32-bit
-variants, unless otherwise stated. All trademarks are acknowledged.
-
-\section{Why another cross-platform development tool?}
-
-wxWindows was developed to provide a cheap and flexible way to maximize
-investment in GUI application development.  While a number of commercial
-class libraries already existed for cross-platform development,
-none met all of the following criteria:
-
-\begin{enumerate}\itemsep=0pt
-\item low price;
-\item source availability;
-\item simplicity of programming;
-\item support for a wide range of compilers.
-\end{enumerate}
-
-Since wxWindows was started, several other free or almost-free
-GUI frameworks have emerged. However, none has the range of
-features, flexibility, documentation and the well-established
-development team that wxWindows has.
-
-As open source software, wxWindows has benefited from comments,
-ideas, bug fixes, enhancements and the sheer enthusiasm of
-users. This gives wxWindows a certain advantage over its
-commercial competitors (and over free libraries without an
-independent development team), plus a robustness against the
-transience of one individual or company. This openness and
-availability of source code is especially important when the
-future of thousands of lines of application code may depend upon
-the longevity of the underlying class library.
-
-Version 2 goes much further than previous versions in terms of
-generality and features, allowing applications to be produced
-that are often indistinguishable from those produced using
-single-platform toolkits such as Motif, GTK+ and MFC.
-
-The importance of using a platform-independent class library
-cannot be overstated, since GUI application development is very
-time-consuming, and sustained popularity of particular GUIs
-cannot be guaranteed. Code can very quickly become obsolete if
-it addresses the wrong platform or audience.  wxWindows helps to
-insulate the programmer from these winds of change. Although
-wxWindows may not be suitable for every application (such as an
-OLE-intensive program), it provides access to most of the
-functionality a GUI program normally requires, plus many extras
-such as network programming, PostScript output, and HTML
-rendering; and it can of course be extended as needs dictate.
-As a bonus, it provides a far cleaner and easier programming
-interface than the native APIs. Programmers may find it
-worthwhile to use wxWindows even if they are developing on only
-one platform.
-
-It is impossible to sum up the functionality of wxWindows in a few paragraphs, but
-here are some of the benefits:
-
-\begin{itemize}\itemsep=0pt
-\item Low cost (free, in fact!)
-\item You get the source.
-\item Available on a variety of popular platforms.
-\item Works with almost all popular C++ compilers and Python.
-\item Over 50 example programs.
-\item Over 1000 pages of printable and on-line documentation.
-\item Includes Tex2RTF, to allow you to produce your own documentation
-in Windows Help, HTML and Word RTF formats.
-\item Simple-to-use, object-oriented API.
-\item Flexible event system.
-\item Graphics calls include lines, rounded rectangles, splines, polylines, etc.
-\item Constraint-based and sizer-based layouts.
-\item Print/preview and document/view architectures.
-\item Toolbar, notebook, tree control, advanced list control classes.
-\item PostScript generation under Unix, normal MS Windows printing on the PC.
-\item MDI (Multiple Document Interface) support.
-\item Can be used to create DLLs under Windows, dynamic libraries on Unix.
-\item Common dialogs for file browsing, printing, colour selection, etc.
-\item Under MS Windows, support for creating metafiles and copying
-them to the clipboard.
-\item An API for invoking help from applications.
-\item Ready-to-use HTML window (supporting a subset of HTML).
-\item Dialog Editor for building dialogs.
-\item Network support via a family of socket and protocol classes.
-\item Support for platform independent image processing.
-\item Built-in support for many file formats (BMP, PNG, JPEG, GIF, XPM, PNM, PCX).
-\end{itemize}
-
-\begin{comment}
-\section{Changes from version 2.0}\label{versionchanges20}
-
-These are a few of the differences between versions 2.0 and 2.2.
-
-Removals:
-
-\begin{itemize}\itemsep=0pt
-\item GTK 1.0 no longer supported.
-\end{itemize}
-
-Additions and changes:
-
-\begin{itemize}\itemsep=0pt
-\item Corrected many classes to conform better to documented behaviour.
-\item Added handlers for more image formats (Now GIF, JPEG, PCX, BMP, XPM, PNG, PNM).
-\item Improved support for socket and network functions.
-\item Support for different national font encodings.
-\item Sizer based layout system.
-\item HTML widget and help system.
-\item Added some controls (e.g. wxSpinCtrl) and supplemented many.
-\item Many optical improvements to GTK port.
-\item Support for menu accelerators in GTK port.
-\item Enhanced and improved support for scrolling, including child windows.
-\item Complete rewrite of clipboard and drag and drop classes.
-\item Improved support for ODBC databases.
-\item Improved tab traversal in dialogs.
-\end{itemize}
-\end{comment}
-
-\section{wxWindows requirements}\label{requirements}
-
-To make use of wxWindows, you currently need one of the following setups.
-
-(a) MS-Windows:
-
-\begin{enumerate}\itemsep=0pt
-\item A 486 or higher PC running MS Windows.
-\item A Windows compiler: most are supported, but please see {\tt install.txt} for
-details. Supported compilers include Microsoft Visual C++ 4.0 or higher, Borland C++, Cygwin,
-Metrowerks CodeWarrior.
-\item At least 60 MB of disk space.
-\end{enumerate}
-
-(b) Unix:
-
-\begin{enumerate}\itemsep=0pt
-\item Almost any C++ compiler, including GNU C++ (EGCS 1.1.1 or above).
-\item Almost any Unix workstation, and one of: GTK+ 1.2, GTK+ 2.0, Motif 1.2 or higher, Lesstif.
-\item At least 60 MB of disk space.
-\end{enumerate}
-
-(c) Mac OS/Mac OS X:
-
-\begin{enumerate}\itemsep=0pt
-\item A PowerPC Mac running Mac OS 8.6/9.x (eg. Classic) or Mac OS X 10.x.
-\item CodeWarrior 5.3, 6 or 7 for Classic Mac OS.
-\item The Apple Developer Tools (eg. GNU C++) or CodeWarrior 7 for Mac OS X.
-\item At least 60 MB of disk space.
-\end{enumerate}
-
-\section{Availability and location of wxWindows}
-
-\winhelponly{wxWindows is available by anonymous FTP and World Wide Web
-from ftp://biolpc22.york.ac.uk/pub and/or http://www.wxwindows.org.}
-\winhelpignore{wxWindows is available by anonymous FTP and World Wide Web
-from \urlref{ftp://biolpc22.york.ac.uk/pub}{ftp://biolpc22.york.ac.uk/pub} 
-and/or \urlref{http://www.wxwindows.org}{http://www.wxwindows.org}.}
-
-You can also buy a CD-ROM using the form on the Web site.
-
-\section{Acknowledgements}
-
-Thanks are due to AIAI for being willing to release the original version of
-wxWindows into the public domain, and to our patient partners.
-
-We would particularly like to thank the following for their contributions to wxWindows, and the many others who have been involved in
-the project over the years. Apologies for any unintentional omissions from this list. 
- 
-Yiorgos Adamopoulos, Jamshid Afshar, Alejandro Aguilar-Sierra, AIAI, Patrick Albert, Karsten Ballueder, Michael Bedward, Kai Bendorf, Yura Bidus, Keith 
-Gary Boyce, Chris Breeze, Pete Britton, Ian Brown, C. Buckley, Dmitri Chubraev, Robin Corbet, Cecil Coupe, Andrew Davison, Neil Dudman, Robin 
-Dunn, Hermann Dunkel, Jos van Eijndhoven, Tom Felici, Thomas Fettig, Matthew Flatt, Pasquale Foggia, Josep Fortiana, Todd Fries, Dominic Gallagher, 
-Guillermo Rodriguez Garcia, Wolfram Gloger, Norbert Grotz, Stefan Gunter, Bill Hale, Patrick Halke, Stefan Hammes, Guillaume Helle, Harco de Hilster, Cord Hockemeyer, Markus 
-Holzem, Olaf Klein, Leif Jensen, Bart Jourquin, Guilhem Lavaux, Jan Lessner, Nicholas Liebmann, Torsten Liermann, Per Lindqvist, Thomas Runge, Tatu
-M\"{a}nnist\"{o}, Scott Maxwell, Thomas Myers, Oliver Niedung, Stefan Neis, Hernan Otero, Ian Perrigo, Timothy Peters, Giordano Pezzoli, Harri Pasanen, Thomaso Paoletti, 
-Garrett Potts, Marcel Rasche, Robert Roebling, Dino Scaringella, Jobst Schmalenbach, Arthur Seaton, Paul Shirley, Vaclav Slavik, Stein Somers, Petr Smilauer, Neil Smith, 
-Kari Syst\"{a}, Arthur Tetzlaff-Deas, Jonathan Tonberg, Jyrki Tuomi, David Webster, Janos Vegh, Andrea Venturoli, Vadim Zeitlin, Xiaokun Zhu, Edward Zimmermann.
-
-`Graphplace', the basis for the wxGraphLayout library, is copyright Dr. Jos
-T.J. van Eijndhoven of Eindhoven University of Technology. The code has
-been used in wxGraphLayout with his permission.
-
-We also acknowledge the author of XFIG, the excellent Unix drawing tool,
-from the source of which we have borrowed some spline drawing code.
-His copyright is included below.
-
-{\it XFig2.1 is copyright (c) 1985 by Supoj Sutanthavibul. Permission to
-use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided
-that the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation, and that the name of M.I.T. not be used in advertising or
-publicity pertaining to distribution of the software without specific,
-written prior permission.  M.I.T. makes no representations about the
-suitability of this software for any purpose.  It is provided ``as is''
-without express or implied warranty.}
-
-\chapter{Multi-platform development with wxWindows}\label{multiplat}
-\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
-\setfooter{\thepage}{}{}{}{}{\thepage}%
-
-This chapter describes the practical details of using wxWindows. Please
-see the file install.txt for up-to-date installation instructions, and
-changes.txt for differences between versions.
-
-\section{Include files}
-
-The main include file is {\tt "wx/wx.h"}; this includes the most commonly
-used modules of wxWindows.
-
-To save on compilation time, include only those header files relevant to the
-source file. If you are using precompiled headers, you should include
-the following section before any other includes:
-
-\begin{verbatim}
-// For compilers that support precompilation, includes "wx.h".
-#include <wx/wxprec.h>
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#ifndef WX_PRECOMP
-// Include your minimal set of headers here, or wx.h
-#include <wx/wx.h>
-#endif
-
-... now your other include files ...
-\end{verbatim}
-
-The file {\tt "wx/wxprec.h"} includes {\tt "wx/wx.h"}. Although this incantation
-may seem quirky, it is in fact the end result of a lot of experimentation,
-and several Windows compilers to use precompilation (those tested are Microsoft Visual C++, Borland C++
-and Watcom C++).
-
-Borland precompilation is largely automatic. Visual C++ requires specification of {\tt "wx/wxprec.h"} as
-the file to use for precompilation. Watcom C++ is automatic apart from the specification of
-the .pch file. Watcom C++ is strange in requiring the precompiled header to be used only for
-object files compiled in the same directory as that in which the precompiled header was created.
-Therefore, the wxWindows Watcom C++ makefiles go through hoops deleting and recreating
-a single precompiled header file for each module, thus preventing an accumulation of many
-multi-megabyte .pch files.
-
-\section{Libraries}
-
-The GTK and Motif ports of wxWindow can create either a static library or a shared
-library on most Unix or Unix-like systems. The static library is called libwx\_gtk.a
-and libwx\_motif.a whereas the name of the shared library is dependent on the
-system it is created on and the version you are using. The library name for the
-GTK version of wxWindows 2.2 on Linux and Solaris will be libwx\_gtk-2.2.so.0.0.0,
-on HP-UX, it will be libwx\_gtk-2.2.sl, on AIX just libwx\_gtk.a etc.
-
-Under Windows, use the library wx.lib (release) or wxd.lib (debug) for stand-alone Windows
-applications, or wxdll.lib (wxdlld.lib) for creating DLLs.
-
-\section{Configuration}
-
-Options are configurable in the file
-\rtfsp{\tt "wx/XXX/setup.h"} where XXX is the required platform (such as msw, motif, gtk, mac). Some 
-settings are a matter of taste, some help with platform-specific problems, and
-others can be set to minimize the size of the library. Please see the setup.h file
-and {\tt install.txt} files for details on configuration.
-
-Under Unix (GTK and Motif) the corresponding setup.h files are generated automatically
-when configuring the wxWindows using the "configure" script. When using the RPM packages
-for installing wxWindows on Linux, a correct setup.h is shipped in the package and
-this must not be changed.
-
-\section{Makefiles}
-
-At the moment there is no attempt to make Unix makefiles and
-PC makefiles compatible, i.e. one makefile is required for
-each environment. The Unix ports use a sophisticated system based
-on the GNU autoconf tool and this system will create the
-makefiles as required on the respective platform. Although the
-makefiles are not identical in Windows, Mac and Unix, care has
-been taken to make them relatively similar so that moving from
-one platform to another will be painless.
-
-Sample makefiles for Unix (suffix .unx), MS C++ (suffix .DOS and .NT), Borland
-C++ (.BCC and .B32) and Symantec C++ (.SC) are included for the library, demos
-and utilities.
-
-The controlling makefile for wxWindows is in the MS-Windows
-directory {\tt src/msw} for the different Windows compiler and
-in the build directory when using the Unix ports. The build
-directory can be chosen by the user. It is the directory in
-which the "configure" script is run. This can be the normal
-base directory (by running {\tt ./configure} there) or any other
-directory (e.g. {\tt ../configure} after creating a build-directory
-in the directory level above the base directory).
-
-Please see the platform-specific {\tt install.txt} file for further details.
-
-\section{Windows-specific files}
-
-wxWindows application compilation under MS Windows requires at least two
-extra files, resource and module definition files.
-
-\subsection{Resource file}\label{resources}
-
-The least that must be defined in the Windows resource file (extension RC)
-is the following statement:
-
-\begin{verbatim}
-rcinclude "wx/msw/wx.rc"
-\end{verbatim}
-
-which includes essential internal wxWindows definitions.  The resource script
-may also contain references to icons, cursors, etc., for example:
-
-\begin{verbatim}
-wxicon icon wx.ico
-\end{verbatim}
-
-The icon can then be referenced by name when creating a frame icon. See
-the MS Windows SDK documentation.
-
-\normalbox{Note: include wx.rc {\it after} any ICON statements
-so programs that search your executable for icons (such
-as the Program Manager) find your application icon first.}
-
-\subsection{Module definition file}
-
-A module definition file (extension DEF) is required for 16-bit applications, and
-looks like the following:
-
-\begin{verbatim}
-NAME         Hello
-DESCRIPTION  'Hello'
-EXETYPE      WINDOWS
-STUB         'WINSTUB.EXE'
-CODE         PRELOAD MOVEABLE DISCARDABLE
-DATA         PRELOAD MOVEABLE MULTIPLE
-HEAPSIZE     1024
-STACKSIZE    8192
-\end{verbatim}
-
-The only lines which will usually have to be changed per application are
-NAME and DESCRIPTION.
-
-\section{Allocating and deleting wxWindows objects}
-
-In general, classes derived from wxWindow must dynamically allocated
-with {\it new} and deleted with {\it delete}. If you delete a window,
-all of its children and descendants will be automatically deleted,
-so you don't need to delete these descendants explicitly.
-
-When deleting a frame or dialog, use {\bf Destroy} rather than {\bf delete} so
-that the wxWindows delayed deletion can take effect. This waits until idle time
-(when all messages have been processed) to actually delete the window, to avoid
-problems associated with the GUI sending events to deleted windows.
-
-Don't create a window on the stack, because this will interfere
-with delayed deletion.
-
-If you decide to allocate a C++ array of objects (such as wxBitmap) that may
-be cleaned up by wxWindows, make sure you delete the array explicitly
-before wxWindows has a chance to do so on exit, since calling {\it delete} on
-array members will cause memory problems.
-
-wxColour can be created statically: it is not automatically cleaned
-up and is unlikely to be shared between other objects; it is lightweight
-enough for copies to be made.
-
-Beware of deleting objects such as a wxPen or wxBitmap if they are still in use.
-Windows is particularly sensitive to this: so make sure you
-make calls like wxDC::SetPen(wxNullPen) or wxDC::SelectObject(wxNullBitmap) before deleting
-a drawing object that may be in use. Code that doesn't do this will probably work
-fine on some platforms, and then fail under Windows.
-
-\section{Architecture dependency}
-
-A problem which sometimes arises from writing multi-platform programs is that
-the basic C types are not defined the same on all platforms. This holds true
-for both the length in bits of the standard types (such as int and long) as 
-well as their byte order, which might be little endian (typically
-on Intel computers) or big endian (typically on some Unix workstations). wxWindows
-defines types and macros that make it easy to write architecture independent
-code. The types are:
-
-wxInt32, wxInt16, wxInt8, wxUint32, wxUint16 = wxWord, wxUint8 = wxByte
-
-where wxInt32 stands for a 32-bit signed integer type etc. You can also check
-which architecture the program is compiled on using the wxBYTE\_ORDER define
-which is either wxBIG\_ENDIAN or wxLITTLE\_ENDIAN (in the future maybe wxPDP\_ENDIAN
-as well).
-
-The macros handling bit-swapping with respect to the applications endianness
-are described in the \helpref{Byte order macros}{byteordermacros} section.
-
-\section{Conditional compilation}
-
-One of the purposes of wxWindows is to reduce the need for conditional
-compilation in source code, which can be messy and confusing to follow.
-However, sometimes it is necessary to incorporate platform-specific
-features (such as metafile use under MS Windows). The symbols
-listed in the file {\tt symbols.txt} may be used for this purpose,
-along with any user-supplied ones.
-
-\section{C++ issues}
-
-The following documents some miscellaneous C++ issues.
-
-\subsection{Templates}
-
-wxWindows does not use templates since it is a notoriously unportable feature.
-
-\subsection{RTTI}
-
-wxWindows does not use run-time type information since wxWindows provides
-its own run-time type information system, implemented using macros.
-
-\subsection{Type of NULL}
-
-Some compilers (e.g. the native IRIX cc) define NULL to be 0L so that
-no conversion to pointers is allowed. Because of that, all these
-occurrences of NULL in the GTK port use an explicit conversion such 
-as
-
-{\small
-\begin{verbatim}
-  wxWindow *my_window = (wxWindow*) NULL;
-\end{verbatim}
-}
-
-It is recommended to adhere to this in all code using wxWindows as
-this make the code (a bit) more portable.
-
-\subsection{Precompiled headers}
-
-Some compilers, such as Borland C++ and Microsoft C++, support
-precompiled headers. This can save a great deal of compiling time. The
-recommended approach is to precompile {\tt "wx.h"}, using this
-precompiled header for compiling both wxWindows itself and any
-wxWindows applications. For Windows compilers, two dummy source files
-are provided (one for normal applications and one for creating DLLs)
-to allow initial creation of the precompiled header.
-
-However, there are several downsides to using precompiled headers. One
-is that to take advantage of the facility, you often need to include
-more header files than would normally be the case. This means that
-changing a header file will cause more recompilations (in the case of
-wxWindows, everything needs to be recompiled since everything includes {\tt "wx.h"}!)
-
-A related problem is that for compilers that don't have precompiled
-headers, including a lot of header files slows down compilation
-considerably. For this reason, you will find (in the common
-X and Windows parts of the library) conditional
-compilation that under Unix, includes a minimal set of headers;
-and when using Visual C++, includes {\tt wx.h}. This should help provide
-the optimal compilation for each compiler, although it is
-biased towards the precompiled headers facility available
-in Microsoft C++.
-
-\section{File handling}
-
-When building an application which may be used under different
-environments, one difficulty is coping with documents which may be
-moved to different directories on other machines. Saving a file which
-has pointers to full pathnames is going to be inherently unportable. One
-approach is to store filenames on their own, with no directory
-information.  The application searches through a number of locally
-defined directories to find the file. To support this, the class {\bf
-wxPathList} makes adding directories and searching for files easy, and
-the global function {\bf wxFileNameFromPath} allows the application to
-strip off the filename from the path if the filename must be stored.
-This has undesirable ramifications for people who have documents of the
-same name in different directories.
-
-As regards the limitations of DOS 8+3 single-case filenames versus
-unrestricted Unix filenames, the best solution is to use DOS filenames
-for your application, and also for document filenames {\it if} the user
-is likely to be switching platforms regularly. Obviously this latter
-choice is up to the application user to decide.  Some programs (such as
-YACC and LEX) generate filenames incompatible with DOS; the best
-solution here is to have your Unix makefile rename the generated files
-to something more compatible before transferring the source to DOS.
-Transferring DOS files to Unix is no problem, of course, apart from EOL
-conversion for which there should be a utility available (such as
-dos2unix).
-
-See also the File Functions section of the reference manual for
-descriptions of miscellaneous file handling functions.
-
-\chapter{Utilities and libraries supplied with wxWindows}\label{utilities}
-\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
-\setfooter{\thepage}{}{}{}{}{\thepage}%
-
-In addition to the core wxWindows library, a number of further
-libraries and utilities are supplied with each distribution.
-
-Some are under the 'contrib' hierarchy which mirrors the
-structure of the main wxWindows hierarchy. See also the 'utils'
-hierarchy. The first place to look for documentation about
-these tools and libraries is under the wxWindows 'docs' hierarchy,
-for example {\tt docs/htmlhelp/fl.chm}.
-
-For other user-contributed packages, please see the Contributions page
-on the \urlref{wxWindows Web site}{http://www.wxwindows.org}.
-
-\begin{description}\itemsep=0pt
-\item[{\bf Helpview}]
-Helpview is a program for displaying wxWindows HTML
-Help files. In many cases, you may wish to use the wxWindows HTML
-Help classes from within your application, but this provides a
-handy stand-alone viewer. See \helpref{wxHTML Notes}{wxhtml} for more details.
-You can find it in {\tt samples/html/helpview}.
-
-\item[{\bf Tex2RTF}]
-Supplied with wxWindows is a utility called Tex2RTF for converting\rtfsp
-\LaTeX\ manuals HTML, MS HTML Help, wxHTML Help, RTF, and Windows
-Help RTF formats. Tex2RTF is used for the wxWindows manuals and can be used independently
-by authors wishing to create on-line and printed manuals from the same\rtfsp
-\LaTeX\ source. Please see the separate documentation for Tex2RTF.
-You can find it under {\tt utils/tex2rtf}.
-
-\item[{\bf Helpgen}]
-Helpgen takes C++ header files and generates a Tex2RTF-compatible
-documentation file for each class it finds, using comments as appropriate.
-This is a good way to start a reference for a set of classes.
-
-\item[{\bf Dialog Editor}]
-Dialog Editor allows interactive construction of dialogs using
-absolute positioning, producing WXR output files. This tool is generally deprecated
-in favour of sizer-based tools. You can find Dialog Editor
-in {\tt utils/dialoged}.
-
-\item[{\bf XRC resource system}]
-This is the sizer-aware replacement for the WXR resource system, and uses
-XML-based resource specifications that can be generated by tools
-such as \urlref{wxDesigner}{http://www.roebling.de} and XRC's own wxrcedit.
-You can find this in {\tt contrib/src/xrc}, {\tt contrib/include/wx/xrc}, {\tt contrib/samples/xrc}, and {\tt contrib/utils/wxrcedit}.
-For more information, see the \helpref{XML-based resource system overview}{xrcoverview}.
-
-\item[{\bf Object Graphics Library}]
-OGL defines an API for applications that need to display objects connected by lines.
-The objects can be moved around and interacted with.
-You can find this in {\tt contrib/src/ogl}, {\tt contrib/include/wx/ogl}, and {\tt contrib/samples/ogl}.
-
-\item[{\bf Frame Layout library}]
-FL provides sophisticated pane dragging and docking facilities.
-You can find this in {\tt contrib/src/fl}, {\tt contrib/include/wx/fl}, and {\tt contrib/samples/fl}.
-
-\item[{\bf Gizmos library}]
-Gizmos is a collection of useful widgets and other classes. Classes include wxLEDNumberCtrl,
-wxEditableListBox, wxMultiCellCanvas.
-You can find this in {\tt contrib/src/fl}, {\tt contrib/include/wx/fl}, and {\tt contrib/samples/fl}.
-
-\item[{\bf Net library}]
-Net is a collection of very simple mail and web related classes. Currently
-there is only wxEmail, which makes it easy to send email messages via MAPI on Windows or sendmail on Unix.
-You can find this in {\tt contrib/src/net} and {\tt contrib/include/wx/net}.
-
-\item[{\bf Animate library}]
-Animate allows you to load animated GIFs and play them on a window. The library can be extended
-to use other animation formats.
-You can find this in {\tt contrib/src/animate}, {\tt contrib/include/wx/animate}, and {\tt contrib/samples/animate}.
-
-\item[{\bf Canvas library}]
-Canvas supports high-level, double-buffered drawing operations with transformations.
-You can find this in {\tt contrib/src/canvas}, {\tt contrib/include/wx/canvas}, and {\tt contrib/samples/canvas}.
-
-\item[{\bf MMedia library}]
-Mmedia supports a variety of multimedia functionality. The status of this library is currently unclear.
-You can find this in {\tt contrib/src/mmedia}, {\tt contrib/include/wx/mmedia}, and {\tt contrib/samples/mmedia}.
-
-\item[{\bf Styled Text Control library}]
-STC is a wrapper around Scintilla, a syntax-highlighting text editor.
-You can find this in {\tt contrib/src/stc}, {\tt contrib/include/wx/stc}, and {\tt contrib/samples/stc}.
-
-\item[{\bf Plot}]
-Plot is a simple curve plotting library.
-You can find this in {\tt contrib/src/plot}, {\tt contrib/include/wx/plot}, and {\tt contrib/samples/plot}.
-\end{description}
-
-\chapter{Programming strategies}\label{strategies}
-\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
-\setfooter{\thepage}{}{}{}{}{\thepage}%
-
-This chapter is intended to list strategies that may be useful when
-writing and debugging wxWindows programs. If you have any good tips,
-please submit them for inclusion here.
-
-\section{Strategies for reducing programming errors}
-
-\subsection{Use ASSERT}
-
-Although I haven't done this myself within wxWindows, it is good
-practice to use ASSERT statements liberally, that check for conditions that
-should or should not hold, and print out appropriate error messages.
-These can be compiled out of a non-debugging version of wxWindows
-and your application. Using ASSERT is an example of `defensive programming':
-it can alert you to problems later on.
-
-\subsection{Use wxString in preference to character arrays}
-
-Using wxString can be much safer and more convenient than using char *.
-Again, I haven't practiced what I'm preaching, but I'm now trying to use
-wxString wherever possible. You can reduce the possibility of memory
-leaks substantially, and it is much more convenient to use the overloaded
-operators than functions such as strcmp. wxString won't add a significant
-overhead to your program; the overhead is compensated for by easier
-manipulation (which means less code).
-
-The same goes for other data types: use classes wherever possible.
-
-\section{Strategies for portability}
-
-\subsection{Use relative positioning or constraints}
-
-Don't use absolute panel item positioning if you can avoid it. Different GUIs have
-very differently sized panel items. Consider using the constraint system, although this
-can be complex to program.
-
-Alternatively, you could use alternative .wrc (wxWindows resource files) on different
-platforms, with slightly different dimensions in each. Or space your panel items out
-to avoid problems.
-
-\subsection{Use wxWindows resource files}
-
-Use .wrc (wxWindows resource files) where possible, because they can be easily changed
-independently of source code. Bitmap resources can be set up to load different
-kinds of bitmap depending on platform (see the section on resource files).
-
-\section{Strategies for debugging}\label{debugstrategies}
-
-\subsection{Positive thinking}
-
-It is common to blow up the problem in one's imagination, so that it seems to threaten
-weeks, months or even years of work. The problem you face may seem insurmountable:
-but almost never is. Once you have been programming for some time, you will be able
-to remember similar incidents that threw you into the depths of despair. But
-remember, you always solved the problem, somehow!
-
-Perseverance is often the key, even though a seemingly trivial problem
-can take an apparently inordinate amount of time to solve. In the end,
-you will probably wonder why you worried so much. That's not to say it
-isn't painful at the time. Try not to worry -- there are many more important
-things in life.
-
-\subsection{Simplify the problem}
-
-Reduce the code exhibiting the problem to the smallest program possible
-that exhibits the problem. If it is not possible to reduce a large and
-complex program to a very small program, then try to ensure your code
-doesn't hide the problem (you may have attempted to minimize the problem
-in some way: but now you want to expose it).
-
-With luck, you can add a small amount of code that causes the program
-to go from functioning to non-functioning state. This should give a clue
-to the problem. In some cases though, such as memory leaks or wrong
-deallocation, this can still give totally spurious results!
-
-\subsection{Use a debugger}
-
-This sounds like facetious advice, but it is surprising how often people
-don't use a debugger. Often it is an overhead to install or learn how to
-use a debugger, but it really is essential for anything but the most
-trivial programs.
-
-\subsection{Use logging functions}
-
-There is a variety of logging functions that you can use in your program:
-see \helpref{Logging functions}{logfunctions}.
-
-Using tracing statements may be more convenient than using the debugger
-in some circumstances (such as when your debugger doesn't support a lot
-of debugging code, or you wish to print a bunch of variables).
-
-\subsection{Use the wxWindows debugging facilities}
-
-You can use wxDebugContext to check for
-memory leaks and corrupt memory: in fact in debugging mode, wxWindows will
-automatically check for memory leaks at the end of the program if wxWindows is suitably
-configured. Depending on the operating system and compiler, more or less
-specific information about the problem will be logged.
-
-You should also use \helpref{debug macros}{debugmacros} as part of a `defensive programming' strategy,
-scattering wxASSERTs liberally to test for problems in your code as early as possible. Forward thinking
-will save a surprising amount of time in the long run.
-
-See the \helpref{debugging overview}{debuggingoverview} for further information.
-
-\subsection{Check Windows debug messages}
-
-Under Windows, it is worth running your program with 
-\urlref{DbgView}{http://www.sysinternals.com} running or
-some other program that shows Windows-generated debug messages. It is
-possible it will show invalid handles being used. You may have fun seeing
-what commercial programs cause these normally hidden errors! Microsoft
-recommend using the debugging version of Windows, which shows up even
-more problems. However, I doubt it is worth the hassle for most
-applications. wxWindows is designed to minimize the possibility of such
-errors, but they can still happen occasionally, slipping through unnoticed
-because they are not severe enough to cause a crash.
-
-\subsection{Genetic mutation}
-
-If we had sophisticated genetic algorithm tools that could be applied
-to programming, we could use them. Until then, a common -- if rather irrational --
-technique is to just make arbitrary changes to the code until something
-different happens. You may have an intuition why a change will make a difference;
-otherwise, just try altering the order of code, comment lines out, anything
-to get over an impasse. Obviously, this is usually a last resort.
-

docs/latex/wx/boxsizer.tex

@@ -1,46 +0,0 @@
-\section{\class{wxBoxSizer}}\label{wxboxsizer}
-
-The basic idea behind a box sizer is that windows will most often be laid out in rather
-simple basic geometry, typically in a row or a column or several hierarchies of either.
-
-For more information, please see \helpref{Programming with wxBoxSizer}{boxsizerprogramming}.
-
-\wxheading{Derived from}
-
-\helpref{wxSizer}{wxsizer}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{See also}
-
-\helpref{wxSizer}{wxsizer}, \helpref{Sizer overview}{sizeroverview}
-
-\membersection{wxBoxSizer::wxBoxSizer}\label{wxboxsizerwxboxsizer}
-
-\func{}{wxBoxSizer}{\param{int }{orient}}
-
-Constructor for a wxBoxSizer. {\it orient} may be either of wxVERTICAL
-or wxHORIZONTAL for creating either a column sizer or a row sizer.
-
-\membersection{wxBoxSizer::RecalcSizes}\label{wxboxsizerrecalcsizes}
-
-\func{void}{RecalcSizes}{\void}
-
-Implements the calculation of a box sizer's dimensions and then sets
-the size of its its children (calling \helpref{wxWindow::SetSize}{wxwindowsetsize} 
-if the child is a window). It is used internally only and must not be called
-by the user. Documented for information.
-
-\membersection{wxBoxSizer::CalcMin}\label{wxboxsizercalcmin}
-
-\func{wxSize}{CalcMin}{\void}
-
-Implements the calculation of a box sizer's minimal. It is used internally
-only and must not be called by the user. Documented for information.
-
-\membersection{wxBoxSizer::GetOrientation}\label{wxboxsizergetorientation}
-
-\func{int}{GetOrientation}{\void}
-
-Returns the orientation of the box sizer, either wxVERTICAL
-or wxHORIZONTAL.
-

docs/latex/wx/brush.tex

@@ -1,371 +0,0 @@
-\section{\class{wxBrush}}\label{wxbrush}
-
-A brush is a drawing tool for filling in areas. It is used for painting
-the background of rectangles, ellipses, etc. It has a colour and a
-style.
-
-\wxheading{Derived from}
-
-\helpref{wxGDIObject}{wxgdiobject}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/brush.h>
-
-\wxheading{Predefined objects}
-
-Objects:
-
-{\bf wxNullBrush}
-
-Pointers:
-
-{\bf wxBLUE\_BRUSH\\
-wxGREEN\_BRUSH\\
-wxWHITE\_BRUSH\\
-wxBLACK\_BRUSH\\
-wxGREY\_BRUSH\\
-wxMEDIUM\_GREY\_BRUSH\\
-wxLIGHT\_GREY\_BRUSH\\
-wxTRANSPARENT\_BRUSH\\
-wxCYAN\_BRUSH\\
-wxRED\_BRUSH}
-
-\wxheading{Remarks}
-
-On a monochrome display, wxWindows shows
-all brushes as white unless the colour is really black.
-
-Do not initialize objects on the stack before the program commences,
-since other required structures may not have been set up yet. Instead,
-define global pointers to objects and create them in \helpref{wxApp::OnInit}{wxapponinit} or
-when required.
-
-An application may wish to create brushes with different
-characteristics dynamically, and there is the consequent danger that a
-large number of duplicate brushes will be created. Therefore an
-application may wish to get a pointer to a brush by using the global
-list of brushes {\bf wxTheBrushList}, and calling the member function
-\rtfsp{\bf FindOrCreateBrush}.
-
-wxBrush uses a reference counting system, so assignments between brushes are very
-cheap. You can therefore use actual wxBrush objects instead of pointers without
-efficiency problems. Once one wxBrush object changes its data it will create its
-own brush data internally so that other brushes, which previously shared the
-data using the reference counting, are not affected.
-
-%TODO: an overview for wxBrush.
-\wxheading{See also}
-
-\helpref{wxBrushList}{wxbrushlist}, \helpref{wxDC}{wxdc}, \helpref{wxDC::SetBrush}{wxdcsetbrush}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxBrush::wxBrush}
-
-\func{}{wxBrush}{\void}
-
-Default constructor. The brush will be uninitialised, and \helpref{wxBrush::Ok}{wxbrushok} will
-return FALSE.
-
-\func{}{wxBrush}{\param{const wxColour\&}{ colour}, \param{int}{ style}}
-
-Constructs a brush from a colour object and style.
-
-\func{}{wxBrush}{\param{const wxString\& }{colourName}, \param{int}{ style}}
-
-Constructs a brush from a colour name and style.
-
-\func{}{wxBrush}{\param{const wxBitmap\& }{stippleBitmap}}
-
-Constructs a stippled brush using a bitmap.
-
-\func{}{wxBrush}{\param{const wxBrush\&}{ brush}}
-
-Copy constructor. This uses reference counting so is a cheap operation.
-
-\wxheading{Parameters}
-
-\docparam{colour}{Colour object.}
-
-\docparam{colourName}{Colour name. The name will be looked up in the colour database.}
-
-\docparam{style}{One of:
-
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf wxTRANSPARENT}}{Transparent (no fill).}
-\twocolitem{{\bf wxSOLID}}{Solid.}
-\twocolitem{{\bf wxBDIAGONAL\_HATCH}}{Backward diagonal hatch.}
-\twocolitem{{\bf wxCROSSDIAG\_HATCH}}{Cross-diagonal hatch.}
-\twocolitem{{\bf wxFDIAGONAL\_HATCH}}{Forward diagonal hatch.}
-\twocolitem{{\bf wxCROSS\_HATCH}}{Cross hatch.}
-\twocolitem{{\bf wxHORIZONTAL\_HATCH}}{Horizontal hatch.}
-\twocolitem{{\bf wxVERTICAL\_HATCH}}{Vertical hatch.}
-\end{twocollist}}
-
-\docparam{brush}{Pointer or reference to a brush to copy.}
-
-\docparam{stippleBitmap}{A bitmap to use for stippling.}
-
-\wxheading{Remarks}
-
-If a stipple brush is created, the brush style will be set to wxSTIPPLE.
-
-\wxheading{See also}
-
-\helpref{wxBrushList}{wxbrushlist}, \helpref{wxColour}{wxcolour}, \helpref{wxColourDatabase}{wxcolourdatabase}
-
-\membersection{wxBrush::\destruct{wxBrush}}
-
-\func{void}{\destruct{wxBrush}}{\void}
-
-Destructor.
-
-\wxheading{Remarks}
-
-The destructor may not delete the underlying brush object of the native windowing
-system, since wxBrush uses a reference counting system for efficiency.
-
-Although all remaining brushes are deleted when the application exits,
-the application should try to clean up all brushes itself. This is because
-wxWindows cannot know if a pointer to the brush object is stored in an
-application data structure, and there is a risk of double deletion.
-
-\membersection{wxBrush::GetColour}\label{wxbrushgetcolour}
-
-\constfunc{wxColour\&}{GetColour}{\void}
-
-Returns a reference to the brush colour.
-
-\wxheading{See also}
-
-\helpref{wxBrush::SetColour}{wxbrushsetcolour}
-
-\membersection{wxBrush::GetStipple}\label{wxbrushgetstipple}
-
-\constfunc{wxBitmap *}{GetStipple}{\void}
-
-Gets a pointer to the stipple bitmap. If the brush does not have a wxSTIPPLE style,
-this bitmap may be non-NULL but uninitialised (\helpref{wxBitmap::Ok}{wxbitmapok} returns FALSE).
-
-\wxheading{See also}
-
-\helpref{wxBrush::SetStipple}{wxbrushsetstipple}
-
-\membersection{wxBrush::GetStyle}\label{wxbrushgetstyle}
-
-\constfunc{int}{GetStyle}{\void}
-
-Returns the brush style, one of:
-
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf wxTRANSPARENT}}{Transparent (no fill).}
-\twocolitem{{\bf wxSOLID}}{Solid.}
-\twocolitem{{\bf wxBDIAGONAL\_HATCH}}{Backward diagonal hatch.}
-\twocolitem{{\bf wxCROSSDIAG\_HATCH}}{Cross-diagonal hatch.}
-\twocolitem{{\bf wxFDIAGONAL\_HATCH}}{Forward diagonal hatch.}
-\twocolitem{{\bf wxCROSS\_HATCH}}{Cross hatch.}
-\twocolitem{{\bf wxHORIZONTAL\_HATCH}}{Horizontal hatch.}
-\twocolitem{{\bf wxVERTICAL\_HATCH}}{Vertical hatch.}
-\twocolitem{{\bf wxSTIPPLE}}{Stippled using a bitmap.}
-\twocolitem{{\bf wxSTIPPLE\_MASK\_OPAQUE}}{Stippled using a bitmap's mask.}
-\end{twocollist}
-
-\wxheading{See also}
-
-\helpref{wxBrush::SetStyle}{wxbrushsetstyle}, \helpref{wxBrush::SetColour}{wxbrushsetcolour},\rtfsp
-\helpref{wxBrush::SetStipple}{wxbrushsetstipple}
-
-\membersection{wxBrush::Ok}\label{wxbrushok}
-
-\constfunc{bool}{Ok}{\void}
-
-Returns TRUE if the brush is initialised. It will return FALSE if the default
-constructor has been used (for example, the brush is a member of a class, or
-NULL has been assigned to it).
-
-\membersection{wxBrush::SetColour}\label{wxbrushsetcolour}
-
-\func{void}{SetColour}{\param{wxColour\& }{colour}}
-
-Sets the brush colour using a reference to a colour object.
-
-\func{void}{SetColour}{\param{const wxString\& }{colourName}}
-
-Sets the brush colour using a colour name from the colour database.
-
-\func{void}{SetColour}{\param{const unsigned char}{ red}, \param{const unsigned char}{ green}, \param{const unsigned char}{ blue}}
-
-Sets the brush colour using red, green and blue values.
-
-\wxheading{See also}
-
-\helpref{wxBrush::GetColour}{wxbrushgetcolour}
-
-\membersection{wxBrush::SetStipple}\label{wxbrushsetstipple}
-
-\func{void}{SetStipple}{\param{const wxBitmap\&}{ bitmap}}
-
-Sets the stipple bitmap.
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{The bitmap to use for stippling.}
-
-\wxheading{Remarks}
-
-The style will be set to wxSTIPPLE, unless the bitmap has a mask associated
-to it, in which case the style will be set to wxSTIPPLE\_MASK\_OPAQUE.
-
-If the wxSTIPPLE variant is used, the bitmap will be used to fill out the
-area to be drawn. If the wxSTIPPLE\_MASK\_OPAQUE is used, the current
-text foreground and text background determine what colours are used for
-displaying and the bits in the mask (which is a mono-bitmap actually)
-determine where to draw what.
-
-Note that under Windows 95, only 8x8 pixel large stipple bitmaps are
-supported, Windows 98 and NT as well as GTK support arbitrary bitmaps.
-
-\wxheading{See also}
-
-\helpref{wxBitmap}{wxbitmap}
-
-\membersection{wxBrush::SetStyle}\label{wxbrushsetstyle}
-
-\func{void}{SetStyle}{\param{int}{ style}}
-
-Sets the brush style.
-
-\docparam{style}{One of:
-
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf wxTRANSPARENT}}{Transparent (no fill).}
-\twocolitem{{\bf wxSOLID}}{Solid.}
-\twocolitem{{\bf wxBDIAGONAL\_HATCH}}{Backward diagonal hatch.}
-\twocolitem{{\bf wxCROSSDIAG\_HATCH}}{Cross-diagonal hatch.}
-\twocolitem{{\bf wxFDIAGONAL\_HATCH}}{Forward diagonal hatch.}
-\twocolitem{{\bf wxCROSS\_HATCH}}{Cross hatch.}
-\twocolitem{{\bf wxHORIZONTAL\_HATCH}}{Horizontal hatch.}
-\twocolitem{{\bf wxVERTICAL\_HATCH}}{Vertical hatch.}
-\twocolitem{{\bf wxSTIPPLE}}{Stippled using a bitmap.}
-\twocolitem{{\bf wxSTIPPLE\_MASK\_OPAQUE}}{Stippled using a bitmap's mask.}
-\end{twocollist}}
-
-\wxheading{See also}
-
-\helpref{wxBrush::GetStyle}{wxbrushgetstyle}
-
-\membersection{wxBrush::operator $=$}\label{wxbrushassignment}
-
-\func{wxBrush\&}{operator $=$}{\param{const wxBrush\& }{brush}}
-
-Assignment operator, using reference counting. Returns a reference
-to `this'.
-
-\membersection{wxBrush::operator $==$}\label{wxbrushequals}
-
-\func{bool}{operator $==$}{\param{const wxBrush\& }{brush}}
-
-Equality operator. Two brushes are equal if they contain pointers
-to the same underlying brush data. It does not compare each attribute,
-so two independently-created brushes using the same parameters will
-fail the test.
-
-\membersection{wxBrush::operator $!=$}\label{wxbrushnotequals}
-
-\func{bool}{operator $!=$}{\param{const wxBrush\& }{brush}}
-
-Inequality operator. Two brushes are not equal if they contain pointers
-to different underlying brush data. It does not compare each attribute.
-
-\section{\class{wxBrushList}}\label{wxbrushlist}
-
-A brush list is a list containing all brushes which have been created.
-
-\wxheading{Derived from}
-
-\helpref{wxList}{wxlist}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/gdicmn.h>
-
-\wxheading{Remarks}
-
-There is only one instance of this class: {\bf wxTheBrushList}.  Use
-this object to search for a previously created brush of the desired
-type and create it if not already found. In some windowing systems,
-the brush may be a scarce resource, so it can pay to reuse old
-resources if possible. When an application finishes, all brushes will
-be deleted and their resources freed, eliminating the possibility of
-`memory leaks'. However, it is best not to rely on this automatic
-cleanup because it can lead to double deletion in some circumstances.
-
-There are two mechanisms in recent versions of wxWindows which make the
-brush list less useful than it once was. Under Windows, scarce resources
-are cleaned up internally if they are not being used. Also, a referencing
-counting mechanism applied to all GDI objects means that some sharing
-of underlying resources is possible. You don't have to keep track of pointers,
-working out when it is safe delete a brush, because the referencing counting does
-it for you. For example, you can set a brush in a device context, and then
-immediately delete the brush you passed, because the brush is `copied'.
-
-So you may find it easier to ignore the brush list, and instead create
-and copy brushes as you see fit. If your Windows resource meter suggests
-your application is using too many resources, you can resort to using
-GDI lists to share objects explicitly.
-
-The only compelling use for the brush list is for wxWindows to keep
-track of brushes in order to clean them up on exit. It is also kept for
-backward compatibility with earlier versions of wxWindows.
-
-\wxheading{See also}
-
-\helpref{wxBrush}{wxbrush}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxBrushList::wxBrushList}\label{wxbrushlistconstr}
-
-\func{void}{wxBrushList}{\void}
-
-Constructor. The application should not construct its own brush list:
-use the object pointer {\bf wxTheBrushList}.
-
-\membersection{wxBrushList::AddBrush}\label{wxbrushlistaddbrush}
-
-\func{void}{AddBrush}{\param{wxBrush *}{brush}}
-
-Used internally by wxWindows to add a brush to the list.
-
-\membersection{wxBrushList::FindOrCreateBrush}\label{wxbrushlistfindorcreatebrush}
-
-\func{wxBrush *}{FindOrCreateBrush}{\param{const wxColour\& }{colour}, \param{int}{ style}}
-
-Finds a brush with the specified attributes and returns it, else creates a new brush, adds it
-to the brush list, and returns it.
-
-\func{wxBrush *}{FindOrCreateBrush}{\param{const wxString\& }{colourName}, \param{int}{ style}}
-
-Finds a brush with the specified attributes and returns it, else creates a new brush, adds it
-to the brush list, and returns it.
-
-Finds a brush of the given specification, or creates one and adds it to the list.
-
-\wxheading{Parameters}
-
-\docparam{colour}{Colour object.}
-
-\docparam{colourName}{Colour name, which should be in the colour database.}
-
-\docparam{style}{Brush style. See \helpref{wxBrush::SetStyle}{wxbrushsetstyle} for a list of styles.}
-
-\membersection{wxBrushList::RemoveBrush}\label{wxbrushlistremovebrush}
-
-\func{void}{RemoveBrush}{\param{wxBrush *}{brush}}
-
-Used by wxWindows to remove a brush from the list.
-
-

docs/latex/wx/busycurs.tex

@@ -1,46 +0,0 @@
-\section{\class{wxBusyCursor}}\label{wxbusycursor}
-
-This class makes it easy to tell your user that the program is temporarily busy.
-Just create a wxBusyCursor object on the stack, and within the current scope,
-the hourglass will be shown.
-
-For example:
-
-\begin{verbatim}
-  wxBusyCursor wait;
-
-  for (int i = 0; i < 100000; i++)
-    DoACalculation();
-\end{verbatim}
-
-It works by calling \helpref{wxBeginBusyCursor}{wxbeginbusycursor} in the constructor,
-and \helpref{wxEndBusyCursor}{wxendbusycursor} in the destructor.
-
-\wxheading{Derived from}
-
-None
-
-\wxheading{Include files}
-
-<wx/utils.h>
-
-\wxheading{See also}
-
-\helpref{wxBeginBusyCursor}{wxbeginbusycursor},\rtfsp
-\helpref{wxEndBusyCursor}{wxendbusycursor},\rtfsp
-\helpref{wxWindowDisabler}{wxwindowdisabler}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxBusyCursor::wxBusyCursor}
-
-\func{}{wxBusyCursor}{\param{wxCursor*}{ cursor = wxHOURGLASS\_CURSOR}}
-
-Constructs a busy cursor object, calling \helpref{wxBeginBusyCursor}{wxbeginbusycursor}.
-
-\membersection{wxBusyCursor::\destruct{wxBusyCursor}}
-
-\func{}{\destruct{wxBusyCursor}}{\void}
-
-Destroys the busy cursor object, calling \helpref{wxEndBusyCursor}{wxendbusycursor}.
-

docs/latex/wx/busyinfo.tex

@@ -1,69 +0,0 @@
-\section{\class{wxBusyInfo}}\label{wxbusyinfo}
-
-This class makes it easy to tell your user that the program is temporarily busy.
-Just create a wxBusyInfo object on the stack, and within the current scope,
-a message window will be shown.
-
-For example:
-
-\begin{verbatim}
-    wxBusyInfo wait("Please wait, working...");
-
-    for (int i = 0; i < 100000; i++)
-    {
-        DoACalculation();
-    }
-\end{verbatim}
-
-It works by creating a window in the constructor,
-and deleting it in the destructor.
-
-You may also want to call wxTheApp->Yield() to refresh the window
-periodically (in case it had been obscured by other windows, for
-example) like this:
-
-\begin{verbatim}
-    wxWindowDisabler disableAll;
-
-    wxBusyInfo wait("Please wait, working...");
-
-    for (int i = 0; i < 100000; i++)
-    {
-        DoACalculation();
-
-        if ( !(i % 1000) )
-            wxTheApp->Yield();
-    }
-\end{verbatim}
-
-but take care to not cause undesirable reentrancies when doing it (see 
-\helpref{wxApp::Yield()}{wxappyield} for more details). The simplest way to do
-it is to use \helpref{wxWindowDisabler}{wxwindowdisabler} class as illustrated
-in the above example.
-
-\wxheading{Derived from}
-
-None
-
-\wxheading{Include files}
-
-<wx/busyinfo.h>
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxBusyInfo::wxBusyInfo}
-
-\func{}{wxBusyInfo}{\param{const wxString\&}{ msg}, \param{wxParent }{*parent = NULL}}
-
-Constructs a busy info window as child of {\it parent} and displays {\it msg}
-in it.
-
-{\bf NB:} If {\it parent} is not {\tt NULL} you must ensure that it is not
-closed while the busy info is shown.
-
-\membersection{wxBusyInfo::\destruct{wxBusyInfo}}
-
-\func{}{\destruct{wxBusyInfo}}{\void}
-
-Hides and closes the window containing the information text.
-

docs/latex/wx/button.tex

@@ -1,153 +0,0 @@
-\section{\class{wxButton}}\label{wxbutton}
-
-A button is a control that contains a text string,
-and is one of the commonest elements of a GUI. It may be placed on a
-\rtfsp\helpref{dialog box}{wxdialog} or \helpref{panel}{wxpanel}, or indeed
-almost any other window.
-
-\wxheading{Derived from}
-
-\helpref{wxControl}{wxcontrol}\\
-\helpref{wxWindow}{wxwindow}\\
-\helpref{wxEvtHandler}{wxevthandler}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/button.h>
-
-\wxheading{Window styles}
-
-\twocolwidtha{5cm}%
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\windowstyle{wxBU\_LEFT}}{Left-justifies the label. WIN32 only.}
-\twocolitem{\windowstyle{wxBU\_TOP}}{Aligns the label to the top of the button. WIN32 only.}
-\twocolitem{\windowstyle{wxBU\_RIGHT}}{Right-justifies the bitmap label. WIN32 only.}
-\twocolitem{\windowstyle{wxBU\_BOTTOM}}{Aligns the label to the bottom of the button. WIN32 only.}
-\twocolitem{\windowstyle{wxBU\_EXACTFIT}}{Creates the button as small as possible instead of making it of the standard size (which is the default behaviour ).}
-\end{twocollist}
-
-See also \helpref{window styles overview}{windowstyles}.
-
-\wxheading{Event handling}
-
-\twocolwidtha{7cm}%
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_BUTTON(id, func)}}{Process a wxEVT\_COMMAND\_BUTTON\_CLICKED event,
-when the button is clicked.}
-\end{twocollist}
-
-\wxheading{See also}
-
-\helpref{wxBitmapButton}{wxbitmapbutton}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxButton::wxButton}\label{wxbuttonconstr}
-
-\func{}{wxButton}{\void}
-
-Default constructor.
-
-\func{}{wxButton}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id}, \param{const wxString\& }{label},\rtfsp
-\param{const wxPoint\& }{pos}, \param{const wxSize\& }{size = wxDefaultSize},\rtfsp
-\param{long}{ style = 0}, \param{const wxValidator\& }{validator}, \param{const wxString\& }{name = ``button"}}
-
-Constructor, creating and showing a button.
-
-\wxheading{Parameters}
-
-\docparam{parent}{Parent window. Must not be NULL.}
-
-\docparam{id}{Button identifier. A value of -1 indicates a default value.}
-
-\docparam{label}{Text to be displayed on the button.}
-
-\docparam{pos}{Button position.}
-
-\docparam{size}{Button size. If the default size (-1, -1) is specified then the button is sized
-appropriately for the text.}
-
-\docparam{style}{Window style. See \helpref{wxButton}{wxbutton}.}
-
-\docparam{validator}{Window validator.}
-
-\docparam{name}{Window name.}
-
-\wxheading{See also}
-
-\helpref{wxButton::Create}{wxbuttoncreate}, \helpref{wxValidator}{wxvalidator}
-
-\membersection{wxButton::\destruct{wxButton}}
-
-\func{}{\destruct{wxButton}}{\void}
-
-Destructor, destroying the button.
-
-\membersection{wxButton::Create}\label{wxbuttoncreate}
-
-\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id}, \param{const wxString\& }{label},\rtfsp
-\param{const wxPoint\& }{pos}, \param{const wxSize\& }{size = wxDefaultSize},\rtfsp
-\param{long}{ style = 0}, \param{const wxValidator\& }{validator}, \param{const wxString\& }{name = ``button"}}
-
-Button creation function for two-step creation. For more details, see \helpref{wxButton::wxButton}{wxbuttonconstr}.
-
-\membersection{wxButton::GetLabel}\label{wxbuttongetlabel}
-
-\constfunc{wxString}{GetLabel}{\void}
-
-Returns the string label for the button.
-
-\wxheading{Return value}
-
-The button's label.
-
-\wxheading{See also}
-
-\helpref{wxButton::SetLabel}{wxbuttonsetlabel}
-
-\membersection{wxButton::GetDefaultSize}\label{wxbuttongetdefaultsize}
-
-\func{wxSize}{GetDefaultSize}{\void}
-
-Returns the default size for the buttons. It is advised to make all the dialog
-buttons of the same size and this function allows to retrieve the (platform and
-current font dependent size) which should be the best suited for this.
-
-\membersection{wxButton::SetDefault}\label{wxbuttonsetdefault}
-
-\func{void}{SetDefault}{\void}
-
-This sets the button to be the default item for the panel or dialog
-box.
-
-\wxheading{Remarks}
-
-Under Windows, only dialog box buttons respond to this function.  As
-normal under Windows and Motif, pressing return causes the default button to
-be depressed when the return key is pressed. See also \helpref{wxWindow::SetFocus}{wxwindowsetfocus}\rtfsp
-which sets the keyboard focus for windows and text panel items,\rtfsp
-and \helpref{wxPanel::SetDefaultItem}{wxpanelsetdefaultitem}.
-
-Note that under Motif, calling this function immediately after
-creation of a button and before the creation of other buttons
-will cause misalignment of the row of buttons, since default
-buttons are larger. To get around this, call {\it SetDefault}\rtfsp
-after you have created a row of buttons: wxWindows will
-then set the size of all buttons currently on the panel to
-the same size.
-
-\membersection{wxButton::SetLabel}\label{wxbuttonsetlabel}
-
-\func{void}{SetLabel}{\param{const wxString\& }{label}}
-
-Sets the string label for the button.
-
-\wxheading{Parameters}
-
-\docparam{label}{The label to set.}
-
-\wxheading{See also}
-
-\helpref{wxButton::GetLabel}{wxbuttongetlabel}
-

docs/latex/wx/calclevt.tex

@@ -1,64 +0,0 @@
-\section{\class{wxCalculateLayoutEvent}}\label{wxcalculatelayoutevent}
-
-This event is sent by \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm} to
-calculate the amount of the remaining client area that the window should
-occupy.
-
-\wxheading{Derived from}
-
-\helpref{wxEvent}{wxevent}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/laywin.h>
-
-\wxheading{Event table macros}
-
-\twocolwidtha{7cm}%
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_CALCULATE\_LAYOUT(func)}}{Process a wxEVT\_CALCULATE\_LAYOUT event,
-which asks the window to take a 'bite' out of a rectangle provided by the algorithm.}
-\end{twocollist}
-
-\wxheading{See also}
-
-\helpref{wxQueryLayoutInfoEvent}{wxquerylayoutinfoevent},\rtfsp
-\helpref{wxSashLayoutWindow}{wxsashlayoutwindow},\rtfsp
-\helpref{wxLayoutAlgorithm}{wxlayoutalgorithm}.
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCalculateLayoutEvent::wxCalculateLayoutEvent}
-
-\func{}{wxCalculateLayoutEvent}{\param{wxWindowID }{id = 0}}
-
-Constructor.
-
-\membersection{wxCalculateLayoutEvent::GetFlags}\label{wxcalculatelayouteventgetflags}
-
-\constfunc{int}{GetFlags}{\void}
-
-Returns the flags associated with this event. Not currently used.
-
-\membersection{wxCalculateLayoutEvent::GetRect}\label{wxcalculatelayouteventgetrect}
-
-\constfunc{wxRect}{GetRect}{\void}
-
-Before the event handler is entered, returns the remaining parent client area that the window
-could occupy. When the event handler returns, this should contain the remaining parent client rectangle,
-after the event handler has subtracted the area that its window occupies.
-
-\membersection{wxCalculateLayoutEvent::SetFlags}\label{wxcalculatelayouteventsetflags}
-
-\func{void}{SetFlags}{\param{int }{flags}}
-
-Sets the flags associated with this event. Not currently used.
-
-\membersection{wxCalculateLayoutEvent::SetRect}\label{wxcalculatelayouteventsetrect}
-
-\func{void}{SetRect}{\param{const wxRect\& }{rect}}
-
-Call this to specify the new remaining parent client area, after the space occupied by the
-window has been subtracted.
-

docs/latex/wx/calctrl.tex

@@ -1,453 +0,0 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% Name:        calctrl.tex
-%% Purpose:     wxCalendarCtrl documentation
-%% Author:      Vadim Zeitlin
-%% Modified by:
-%% Created:     03.01.00
-%% RCS-ID:      $Id$
-%% Copyright:   (c) Vadim Zeitlin
-%% License:     wxWindows license
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-\section{\class{wxCalendarCtrl}}\label{wxcalendarctrl}
-
-The calendar control allows the user to pick a date interactively. For this,
-it displays a window containing several parts: the control to pick the month
-and the year at the top (either or both of them may be disabled) and a month
-area below them which shows all the days in the month. The user can move the
-current selection using the keyboard and select the date (generating 
-{\tt EVT\_CALENDAR} event) by pressing {\tt <Return>} or double clicking it.
-
-It has advanced possibilities for the customization of its display. All global
-settings (such as colours and fonts used) can, of course, be changed. But
-also, the display style for each day in the month can be set independently
-using \helpref{wxCalendarDateAttr}{wxcalendardateattr} class.
-
-An item without custom attributes is drawn with the default colours and
-font and without border, but setting custom attributes with 
-\helpref{SetAttr}{wxcalendarctrlsetattr} allows to modify its appearance. Just
-create a custom attribute object and set it for the day you want to be
-displayed specially (note that the control will take ownership of the pointer,
-i.e. it will delete it itself). A day may be marked as being a holiday, even
-if it is not recognized as one by \helpref{wxDateTime}{tdateholidays} using 
-\helpref{SetHoliday}{wxcalendardateattrsetholiday} method.
-
-As the attributes are specified for each day, they may change when the month
-is changed, so you will often want to update them in 
-{\tt EVT\_CALENDAR\_MONTH} event handler.
-
-\wxheading{Derived from}
-
-\helpref{wxControl}{wxcontrol}\\
-\helpref{wxWindow}{wxwindow}\\
-\helpref{wxEvtHandler}{wxevthandler}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/calctrl.h>
-
-\wxheading{Window styles}
-
-\twocolwidtha{5cm}
-\begin{twocollist}\itemsep=4pt
-\twocolitem{\windowstyle{wxCAL\_SUNDAY\_FIRST}}{Show Sunday as the first day in the week}
-\twocolitem{\windowstyle{wxCAL\_MONDAY\_FIRST}}{Show Monday as the first day in the week}
-\twocolitem{\windowstyle{wxCAL\_SHOW\_HOLIDAYS}}{Highlight holidays in the calendar}
-\twocolitem{\windowstyle{wxCAL\_NO\_YEAR\_CHANGE}}{Disable the year changing}
-\twocolitem{\windowstyle{wxCAL\_NO\_MONTH\_CHANGE}}{Disable the month (and, implicitly, the year) changing}
-\twocolitem{\windowstyle{wxCAL\_SHOW\_SURROUNDING\_WEEKS}}{Show the neighbouring weeks in the previous and next months}
-\twocolitem{\windowstyle{wxCAL\_SEQUENTIAL\_MONTH\_SELECTION}}{Use alternative, more compact, style for the month and year selection controls.}
-\end{twocollist}
-
-The default calendar style is {\tt wxCAL\_SHOW\_HOLIDAYS}.
-
-\wxheading{Event table macros}
-
-To process input from a calendar control, use these event handler macros to
-direct input to member functions that take a 
-\helpref{wxCalendarEvent}{wxcalendarevent} argument.
-
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=7pt
-\twocolitem{{\bf EVT\_CALENDAR(id, func)}}{A day was double clicked in the calendar.}
-\twocolitem{{\bf EVT\_CALENDAR\_SEL\_CHANGED(id, func)}}{The selected date changed.}
-\twocolitem{{\bf EVT\_CALENDAR\_DAY(id, func)}}{The selected day changed.}
-\twocolitem{{\bf EVT\_CALENDAR\_MONTH(id, func)}}{The selected month changed.}
-\twocolitem{{\bf EVT\_CALENDAR\_YEAR(id, func)}}{The selected year changed.}
-\twocolitem{{\bf EVT\_CALENDAR\_WEEKDAY\_CLICKED(id, func)}}{User clicked on the week day header}
-\end{twocollist}%
-
-Note that changing the selected date will result in either of 
-{\tt EVT\_CALENDAR\_DAY}, {\tt MONTH} or {\tt YEAR} events and 
-{\tt EVT\_CALENDAR\_SEL\_CHANGED} one.
-
-\wxheading{Constants}
-
-The following are the possible return values for 
-\helpref{HitTest}{wxcalendarctrlhittest} method:
-
-{\small
-\begin{verbatim}
-enum wxCalendarHitTestResult
-{
-    wxCAL_HITTEST_NOWHERE,      // outside of anything
-    wxCAL_HITTEST_HEADER,       // on the header (weekdays)
-    wxCAL_HITTEST_DAY           // on a day in the calendar
-}
-\end{verbatim}
-}
-
-\wxheading{See also}
-
-\helpref{Calendar sample}{samplecalendar}\\
-\helpref{wxCalendarDateAttr}{wxcalendardateattr}\\
-\helpref{wxCalendarEvent}{wxcalendarevent}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCalendarCtrl::wxCalendarCtrl}\label{wxcalendarctrlwxcalendarctrldef}
-
-\func{}{wxCalendarCtrl}{\void}
-
-Default constructor, use \helpref{Create}{wxcalendarctrlcreate} after it.
-
-\membersection{wxCalendarCtrl::wxCalendarCtrl}\label{wxcalendarctrlwxcalendarctrl}
-
-\func{}{wxCalendarCtrl}{\param{wxWindow* }{parent}, \param{wxWindowID }{id}, \param{const wxDateTime\& }{date = wxDefaultDateTime}, \param{const wxPoint\& }{pos = wxDefaultPosition}, \param{const wxSize\& }{size = wxDefaultSize}, \param{long }{style = wxCAL\_SHOW\_HOLIDAYS}, \param{const wxString\& }{name = wxCalendarNameStr}}
-
-Does the same as \helpref{Create}{wxcalendarctrlcreate} method.
-
-\membersection{wxCalendarCtrl::Create}\label{wxcalendarctrlcreate}
-
-\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID }{id}, \param{const wxDateTime\& }{date = wxDefaultDateTime}, \param{const wxPoint\& }{pos = wxDefaultPosition}, \param{const wxSize\& }{size = wxDefaultSize}, \param{long }{style = wxCAL\_SHOW\_HOLIDAYS}, \param{const wxString\& }{name = wxCalendarNameStr}}
-
-Creates the control. See \helpref{wxWindow}{wxwindowctor} for the meaning of
-the parameters and the control overview for the possible styles.
-
-\membersection{wxCalendarCtrl::\destruct{wxCalendarCtrl}}\label{wxcalendarctrldtor}
-
-\func{}{\destruct{wxCalendarCtrl}}{\void}
-
-Destroys the control.
-
-\membersection{wxCalendarCtrl::SetDate}\label{wxcalendarctrlsetdate}
-
-\func{void}{SetDate}{\param{const wxDateTime\& }{date}}
-
-Sets the current date.
-
-\membersection{wxCalendarCtrl::GetDate}\label{wxcalendarctrlgetdate}
-
-\constfunc{const wxDateTime\&}{GetDate}{\void}
-
-Gets the currently selected date.
-
-\membersection{wxCalendarCtrl::EnableYearChange}\label{wxcalendarctrlenableyearchange}
-
-\func{void}{EnableYearChange}{\param{bool }{enable = TRUE}}
-
-This function should be used instead of changing {\tt wxCAL\_NO\_YEAR\_CHANGE}
-style bit directly. It allows or disallows the user to change the year
-interactively.
-
-\membersection{wxCalendarCtrl::EnableMonthChange}\label{wxcalendarctrlenablemonthchange}
-
-\func{void}{EnableMonthChange}{\param{bool }{enable = TRUE}}
-
-This function should be used instead of changing 
-{\tt wxCAL\_NO\_MONTH\_CHANGE} style bit. It allows or disallows the user to
-change the month interactively. Note that if the month can not be changed, the
-year can not be changed neither.
-
-\membersection{wxCalendarCtrl::EnableHolidayDisplay}\label{wxcalendarctrlenableholidaydisplay}
-
-\func{void}{EnableHolidayDisplay}{\param{bool }{display = TRUE}}
-
-This function should be used instead of changing {\tt wxCAL\_SHOW\_HOLIDAYS}
-style bit directly. It enables or disables the special highlighting of the
-holidays.
-
-\membersection{wxCalendarCtrl::SetHeaderColours}\label{wxcalendarctrlsetheadercolours}
-
-\func{void}{SetHeaderColours}{\param{const wxColour\& }{colFg}, \param{const wxColour\& }{colBg}}
-
-Set the colours used for painting the weekdays at the top of the control.
-
-\membersection{wxCalendarCtrl::GetHeaderColourFg}\label{wxcalendarctrlgetheadercolourfg}
-
-\constfunc{const wxColour\&}{GetHeaderColourFg}{\void}
-
-Gets the foreground colour of the header part of the calendar window.
-
-\wxheading{See also}
-
-\helpref{SetHeaderColours}{wxcalendarctrlsetheadercolours}
-
-\membersection{wxCalendarCtrl::GetHeaderColourBg}\label{wxcalendarctrlgetheadercolourbg}
-
-\constfunc{const wxColour\&}{GetHeaderColourBg}{\void}
-
-Gets the background colour of the header part of the calendar window.
-
-\wxheading{See also}
-
-\helpref{SetHeaderColours}{wxcalendarctrlsetheadercolours}
-
-\membersection{wxCalendarCtrl::SetHighlightColours}\label{wxcalendarctrlsethighlightcolours}
-
-\func{void}{SetHighlightColours}{\param{const wxColour\& }{colFg}, \param{const wxColour\& }{colBg}}
-
-Set the colours to be used for highlighting the currently selected date.
-
-\membersection{wxCalendarCtrl::GetHighlightColourFg}\label{wxcalendarctrlgethighlightcolourfg}
-
-\constfunc{const wxColour\&}{GetHighlightColourFg}{\void}
-
-Gets the foreground highlight colour.
-
-\wxheading{See also}
-
-\helpref{SetHighlightColours}{wxcalendarctrlsethighlightcolours}
-
-\membersection{wxCalendarCtrl::GetHighlightColourBg}\label{wxcalendarctrlgethighlightcolourbg}
-
-\constfunc{const wxColour\&}{GetHighlightColourBg}{\void}
-
-Gets the background highlight colour.
-
-\wxheading{See also}
-
-\helpref{SetHighlightColours}{wxcalendarctrlsethighlightcolours}
-
-\membersection{wxCalendarCtrl::SetHolidayColours}\label{wxcalendarctrlsetholidaycolours}
-
-\func{void}{SetHolidayColours}{\param{const wxColour\& }{colFg}, \param{const wxColour\& }{colBg}}
-
-Sets the colours to be used for the holidays highlighting (only used if the
-window style includes {\tt wxCAL\_SHOW\_HOLIDAYS} flag).
-
-\membersection{wxCalendarCtrl::GetHolidayColourFg}\label{wxcalendarctrlgetholidaycolourfg}
-
-\constfunc{const wxColour\&}{GetHolidayColourFg}{\void}
-
-Return the foreground colour currently used for holiday highlighting.
-
-\wxheading{See also}
-
-\helpref{SetHolidayColours}{wxcalendarctrlsetholidaycolours}
-
-\membersection{wxCalendarCtrl::GetHolidayColourBg}\label{wxcalendarctrlgetholidaycolourbg}
-
-\constfunc{const wxColour\&}{GetHolidayColourBg}{\void}
-
-Return the background colour currently used for holiday highlighting.
-
-\wxheading{See also}
-
-\helpref{SetHolidayColours}{wxcalendarctrlsetholidaycolours}
-
-\membersection{wxCalendarCtrl::GetAttr}\label{wxcalendarctrlgetattr}
-
-\constfunc{wxCalendarDateAttr *}{GetAttr}{\param{size\_t }{day}}
-
-Returns the attribute for the given date (should be in the range $1\ldots31$).
-
-The returned pointer may be {\tt NULL}.
-
-\membersection{wxCalendarCtrl::SetAttr}\label{wxcalendarctrlsetattr}
-
-\func{void}{SetAttr}{\param{size\_t }{day}, \param{wxCalendarDateAttr* }{attr}}
-
-Associates the attribute with the specified date (in the range $1\ldots31$).
-
-If the pointer is {\tt NULL}, the items attribute is cleared.
-
-\membersection{wxCalendarCtrl::SetHoliday}\label{wxcalendarctrlsetholiday}
-
-\func{void}{SetHoliday}{\param{size\_t }{day}}
-
-Marks the specified day as being a holiday in the current month.
-
-\membersection{wxCalendarCtrl::ResetAttr}\label{wxcalendarctrlresetattr}
-
-\func{void}{ResetAttr}{\param{size\_t }{day}}
-
-Clears any attributes associated with the given day (in the range
-$1\ldots31$).
-
-\membersection{wxCalendarCtrl::HitTest}\label{wxcalendarctrlhittest}
-
-\func{wxCalendarHitTestResult}{HitTest}{\param{const wxPoint\& }{pos}, \param{wxDateTime* }{date = NULL}, \param{wxDateTime::WeekDay* }{wd = NULL}}
-
-Returns one of {\tt wxCAL\_HITTEST\_XXX} 
-\helpref{constants}{wxcalendarctrl} and fills either {\it date} or 
-{\it wd} pointer with the corresponding value depending on the hit test code.
-
-\section{\class{wxCalendarDateAttr}}\label{wxcalendardateattr}
-
-wxCalendarDateAttr is a custom attributes for a calendar date. The objects of
-this class are used with \helpref{wxCalendarCtrl}{wxcalendarctrl}.
-
-\wxheading{Derived from}
-
-No base class
-
-\wxheading{Constants}
-
-Here are the possible kinds of borders which may be used to decorate a date:
-
-\begin{verbatim}
-enum wxCalendarDateBorder
-{
-    wxCAL_BORDER_NONE,          // no border (default)
-    wxCAL_BORDER_SQUARE,        // a rectangular border
-    wxCAL_BORDER_ROUND          // a round border
-}
-\end{verbatim}
-
-\wxheading{See also}
-
-\helpref{wxCalendarCtrl}{wxcalendarctrl}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCalendarDateAttr::wxCalendarDateAttr}\label{wxcalendardateattrwxcalendardateattr}
-
-\func{}{wxCalendarDateAttr}{\void}
-
-\func{}{wxCalendarDateAttr}{\param{const wxColour\& }{colText}, \param{const wxColour\& }{colBack = wxNullColour}, \param{const wxColour\& }{colBorder = wxNullColour}, \param{const wxFont\& }{font = wxNullFont}, \param{wxCalendarDateBorder }{border = wxCAL\_BORDER\_NONE}}
-
-\func{}{wxCalendarDateAttr}{\param{wxCalendarDateBorder }{border}, \param{const wxColour\& }{colBorder = wxNullColour}}
-
-The constructors.
-
-\membersection{wxCalendarDateAttr::SetTextColour}\label{wxcalendardateattrsettextcolour}
-
-\func{void}{SetTextColour}{\param{const wxColour\& }{colText}}
-
-Sets the text (foreground) colour to use.
-
-\membersection{wxCalendarDateAttr::SetBackgroundColour}\label{wxcalendardateattrsetbackgroundcolour}
-
-\func{void}{SetBackgroundColour}{\param{const wxColour\& }{colBack}}
-
-Sets the text background colour to use.
-
-\membersection{wxCalendarDateAttr::SetBorderColour}\label{wxcalendardateattrsetbordercolour}
-
-\func{void}{SetBorderColour}{\param{const wxColour\& }{col}}
-
-Sets the border colour to use.
-
-\membersection{wxCalendarDateAttr::SetFont}\label{wxcalendardateattrsetfont}
-
-\func{void}{SetFont}{\param{const wxFont\& }{font}}
-
-Sets the font to use.
-
-\membersection{wxCalendarDateAttr::SetBorder}\label{wxcalendardateattrsetborder}
-
-\func{void}{SetBorder}{\param{wxCalendarDateBorder }{border}}
-
-Sets the \helpref{border kind}{wxcalendardateattr}
-
-\membersection{wxCalendarDateAttr::SetHoliday}\label{wxcalendardateattrsetholiday}
-
-\func{void}{SetHoliday}{\param{bool }{holiday}}
-
-Display the date with this attribute as a holiday.
-
-\membersection{wxCalendarDateAttr::HasTextColour}\label{wxcalendardateattrhastextcolour}
-
-\constfunc{bool}{HasTextColour}{\void}
-
-Returns {\tt TRUE} if this item has a non default text foreground colour.
-
-\membersection{wxCalendarDateAttr::HasBackgroundColour}\label{wxcalendardateattrhasbackgroundcolour}
-
-\constfunc{bool}{HasBackgroundColour}{\void}
-
-Returns {\tt TRUE} if this attribute specifies a non default text background colour.
-
-\membersection{wxCalendarDateAttr::HasBorderColour}\label{wxcalendardateattrhasbordercolour}
-
-\constfunc{bool}{HasBorderColour}{\void}
-
-Returns {\tt TRUE} if this attribute specifies a non default border colour.
-
-\membersection{wxCalendarDateAttr::HasFont}\label{wxcalendardateattrhasfont}
-
-\constfunc{bool}{HasFont}{\void}
-
-Returns {\tt TRUE} if this attribute specifies a non default font.
-
-\membersection{wxCalendarDateAttr::HasBorder}\label{wxcalendardateattrhasborder}
-
-\constfunc{bool}{HasBorder}{\void}
-
-Returns {\tt TRUE} if this attribute specifies a non default (i.e. any) border.
-
-\membersection{wxCalendarDateAttr::IsHoliday}\label{wxcalendardateattrisholiday}
-
-\constfunc{bool}{IsHoliday}{\void}
-
-Returns {\tt TRUE} if this attribute specifies that this item should be
-displayed as a holiday.
-
-\membersection{wxCalendarDateAttr::GetTextColour}\label{wxcalendardateattrgettextcolour}
-
-\constfunc{const wxColour\&}{GetTextColour}{\void}
-
-Returns the text colour to use for the item with this attribute.
-
-\membersection{wxCalendarDateAttr::GetBackgroundColour}\label{wxcalendardateattrgetbackgroundcolour}
-
-\constfunc{const wxColour\&}{GetBackgroundColour}{\void}
-
-Returns the background colour to use for the item with this attribute.
-
-\membersection{wxCalendarDateAttr::GetBorderColour}\label{wxcalendardateattrgetbordercolour}
-
-\constfunc{const wxColour\&}{GetBorderColour}{\void}
-
-Returns the border colour to use for the item with this attribute.
-
-\membersection{wxCalendarDateAttr::GetFont}\label{wxcalendardateattrgetfont}
-
-\constfunc{const wxFont\&}{GetFont}{\void}
-
-Returns the font to use for the item with this attribute.
-
-\membersection{wxCalendarDateAttr::GetBorder}\label{wxcalendardateattrgetborder}
-
-\constfunc{wxCalendarDateBorder}{GetBorder}{\void}
-
-Returns the \helpref{border}{wxcalendardateattr} to use for the item with this attribute.
-
-\section{\class{wxCalendarEvent}}\label{wxcalendarevent}
-
-The wxCalendarEvent class is used together with 
-\helpref{wxCalendarCtrl}{wxcalendarctrl}.
-
-\wxheading{See also}
-
-\helpref{wxCalendarCtrl}{wxcalendarctrl}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCalendarEvent::GetDate}{wxcalendareventgetdate}
-
-\constfunc{const wxDateTime\&}{GetDate}{\void}
-
-Returns the date. This function may be called for all event types except 
-{\tt EVT\_CALENDAR\_WEEKDAY\_CLICKED} one for which it doesn't make sense.
-
-\membersection{wxCalendarEvent::GetWeekDay}{wxcalendareventgetweekday}
-
-\constfunc{wxDateTime::WeekDay}{GetWeekDay}{\void}
-
-Returns the week day on which the user clicked in 
-{\tt EVT\_CALENDAR\_WEEKDAY\_CLICKED} handler. It doesn't make sense to call
-this function in other handlers.
-

docs/latex/wx/caret.tex

@@ -1,165 +0,0 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% Name:        caret.tex
-%% Purpose:     wxCaret documentation
-%% Author:      Vadim Zeitlin
-%% Modified by:
-%% Created:     20.06.00
-%% RCS-ID:      $Id$
-%% Copyright:   (c) Vadim Zeitlin
-%% License:     wxWindows license
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-\section{\class{wxCaret}}\label{wxcaret}
-
-A caret is a blinking cursor showing the position where the typed text will
-appear. The text controls usually have a caret but wxCaret class also allows
-to use a caret in other windows.
-
-Currently, the caret appears as a rectangle of the given size. In the future,
-it will be possible to specify a bitmap to be used for the caret shape.
-
-A caret is always associated with a window and the current caret can be
-retrieved using \helpref{wxWindow::GetCaret}{wxwindowgetcaret}. The same caret
-can't be reused in two different windows.
-
-\wxheading{Derived from}
-
-No base class
-
-\wxheading{Include files}
-
-<wx/caret.h>
-
-\wxheading{Data structures}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCaret::wxCaret}\label{wxcaretwxcaret}
-
-\func{}{wxCaret}{\void}
-
-Default constructor: you must use one of Create() functions later.
-
-\func{}{wxCaret}{\param{wxWindow* }{window}, \param{int }{width}, \param{int }{height}}
-
-\func{}{wxCaret}{\param{wxWindowBase* }{window}, \param{const wxSize\& }{size}}
-
-Create the caret of given (in pixels) width and height and associates it
-with the given window.
-
-\membersection{wxCaret::Create}\label{wxcaretcreate}
-
-\func{bool}{Create}{\param{wxWindowBase* }{window}, \param{int }{width}, \param{int }{height}}
-
-\func{bool}{Create}{\param{wxWindowBase* }{window}, \param{const wxSize\& }{size}}
-
-Create the caret of given (in pixels) width and height and associates it
-with the given window (same as constructor).
-
-\membersection{wxCaret::GetBlinkTime}\label{wxcaretgetblinktime}
-
-\func{static int}{GetBlinkTime}{\void}
-
-Returns the blink time which is measured in milliseconds and is the time elapsed
-between 2 inversions of the caret (blink time of the caret is the same
-for all carets, so this functions is static).
-
-\membersection{wxCaret::GetPosition}\label{wxcaretgetposition}
-
-\constfunc{void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
-
-\constfunc{wxPoint}{GetPosition}{\void}
-
-Get the caret position (in pixels).
-
-\perlnote{In wxPerl there are two methods instead of a single overloaded
-method:\par
-\indented{2cm}{\begin{twocollist}
-\twocolitem{{\bf GetPosition()}}{Returns a Wx::Point}
-\twocolitem{{\bf GetPositionXY()}}{Returns a 2-element list
- {\tt ( x, y )}}
-\end{twocollist}
-}}
-
-\membersection{wxCaret::GetSize}\label{wxcaretgetsize}
-
-\constfunc{void}{GetSize}{\param{int* }{width}, \param{int* }{height}}
-
-\constfunc{wxSize}{GetSize}{\void}
-
-Get the caret size.
-
-\perlnote{In wxPerl there are two methods instead of a single overloaded
-method:\par
-\indented{2cm}{\begin{twocollist}
-\twocolitem{{\bf GetSize()}}{Returns a Wx::Size}
-\twocolitem{{\bf GetSizeWH()}}{Returns a 2-element list
- {\tt ( width, height )}}
-\end{twocollist}
-}}
-
-\membersection{wxCaret::GetWindow}\label{wxcaretgetwindow}
-
-\constfunc{wxWindow*}{GetWindow}{\void}
-
-Get the window the caret is associated with.
-
-\membersection{wxCaret::Hide}\label{wxcarethide}
-
-\func{void}{Hide}{\void}
-
-Same as \helpref{wxCaret::Show(FALSE)}{wxcaretshow}.
-
-\membersection{wxCaret::IsOk}\label{wxcaretisok}
-
-\constfunc{bool}{IsOk}{\void}
-
-Returns TRUE if the caret was created successfully.
-
-\membersection{wxCaret::IsVisible}\label{wxcaretisvisible}
-
-\constfunc{bool}{IsVisible}{\void}
-
-Returns TRUE if the caret is visible and FALSE if it is permanently
-hidden (if it is is blinking and not shown currently but will be after the
-next blink, this method still returns TRUE).
-
-\membersection{wxCaret::Move}\label{wxcaretmove}
-
-\func{void}{Move}{\param{int }{x}, \param{int }{y}}
-
-\func{void}{Move}{\param{const wxPoint\& }{pt}}
-
-Move the caret to given position (in logical coordinates).
-
-\membersection{wxCaret::SetBlinkTime}\label{wxcaretsetblinktime}
-
-\func{static void}{SetBlinkTime}{\param{int }{milliseconds}}
-
-Sets the blink time for all the carets.
-
-\wxheading{Remarks}
-
-Under Windows, this function will change the blink time for {\bf all} carets
-permanently (until the next time it is called), even for the carets in other
-applications.
-
-\wxheading{See also}
-
-\helpref{GetBlinkTime}{wxcaretgetblinktime}
-
-\membersection{wxCaret::SetSize}\label{wxcaretsetsize}
-
-\func{void}{SetSize}{\param{int }{width}, \param{int }{height}}
-
-\func{void}{SetSize}{\param{const wxSize\& }{size}}
-
-Changes the size of the caret.
-
-\membersection{wxCaret::Show}\label{wxcaretshow}
-
-\func{void}{Show}{\param{bool }{show = TRUE}}
-
-Shows or hides the caret. Notice that if the caret was hidden $N$ times, it
-must be shown $N$ times as well to reappear on the screen.
-

docs/latex/wx/category.tex

@@ -1,623 +0,0 @@
-\chapter{Classes by category}\label{classesbycat}
-\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
-\setfooter{\thepage}{}{}{}{}{\thepage}%
-
-A classification of wxWindows classes by category.
-
-{\large {\bf Managed windows}}
-
-There are several types of window that are directly controlled by the
-window manager (such as MS Windows, or the Motif Window Manager).
-Frames may contain windows, and dialog boxes may directly contain controls.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxDialog}{wxdialog}}{Dialog box}
-\twocolitem{\helpref{wxFrame}{wxframe}}{Normal frame}
-\twocolitem{\helpref{wxMDIChildFrame}{wxmdichildframe}}{MDI child frame}
-\twocolitem{\helpref{wxMDIParentFrame}{wxmdiparentframe}}{MDI parent frame}
-\twocolitem{\helpref{wxMiniFrame}{wxminiframe}}{A frame with a small title bar}
-\twocolitem{\helpref{wxSplashScreen}{wxsplashscreen}}{Splash screen class}
-%\twocolitem{\helpref{wxTabbedDialog}{wxtabbeddialog}}{Tabbed dialog
-%(deprecated, use wxNotebook instead)}
-\twocolitem{\helpref{wxTipWindow}{wxtipwindow}}{Shows text in a small window}
-\twocolitem{\helpref{wxWizard}{wxwizard}}{A wizard dialog}
-\end{twocollist}
-
-See also {\bf Common dialogs}.
-
-{\large {\bf Miscellaneous windows}}
-
-The following are a variety of classes that are derived from wxWindow.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxPanel}{wxpanel}}{A window whose colour changes according to current user settings}
-\twocolitem{\helpref{wxScrolledWindow}{wxscrolledwindow}}{Window with automatically managed scrollbars}
-\twocolitem{\helpref{wxGrid}{wxgrid}}{A grid (table) window}
-\twocolitem{\helpref{wxSplitterWindow}{wxsplitterwindow}}{Window which can be split vertically or horizontally}
-\twocolitem{\helpref{wxStatusBar}{wxstatusbar}}{Implements the status bar on a frame}
-\twocolitem{\helpref{wxToolBar}{wxtoolbar}}{Toolbar class}
-%\twocolitem{\helpref{wxTabbedPanel}{wxtabbedpanel}}{Tabbed panel (to be replaced with wxNotebook)}
-\twocolitem{\helpref{wxNotebook}{wxnotebook}}{Notebook class}
-\twocolitem{\helpref{wxPlotWindow}{wxplotwindow}}{A class to display data.}
-\twocolitem{\helpref{wxSashWindow}{wxsashwindow}}{Window with four optional sashes that can be dragged}
-\twocolitem{\helpref{wxSashLayoutWindow}{wxsashlayoutwindow}}{Window that can be involved in an IDE-like layout arrangement}
-\twocolitem{\helpref{wxWizardPage}{wxwizardpage}}{A base class for the page in wizard dialog.}
-\twocolitem{\helpref{wxWizardPageSimple}{wxwizardpagesimple}}{A page in wizard dialog.}
-\end{twocollist}
-
-{\large {\bf Common dialogs}}
-
-\overview{Overview}{commondialogsoverview}
-
-Common dialogs are ready-made dialog classes which are frequently used
-in an application.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxDialog}{wxdialog}}{Base class for common dialogs}
-\twocolitem{\helpref{wxColourDialog}{wxcolourdialog}}{Colour chooser dialog}
-\twocolitem{\helpref{wxDirDialog}{wxdirdialog}}{Directory selector dialog}
-\twocolitem{\helpref{wxFileDialog}{wxfiledialog}}{File selector dialog}
-\twocolitem{\helpref{wxFindReplaceDialog}{wxfindreplacedialog}}{Text search/replace dialog}
-\twocolitem{\helpref{wxMultipleChoiceDialog}{wxmultiplechoicedialog}}{Dialog to get one or more selections from a list}
-\twocolitem{\helpref{wxSingleChoiceDialog}{wxsinglechoicedialog}}{Dialog to get a single selection from a list and return the string}
-\twocolitem{\helpref{wxTextEntryDialog}{wxtextentrydialog}}{Dialog to get a single line of text from the user}
-\twocolitem{\helpref{wxFontDialog}{wxfontdialog}}{Font chooser dialog}
-\twocolitem{\helpref{wxPageSetupDialog}{wxpagesetupdialog}}{Standard page setup dialog}
-\twocolitem{\helpref{wxPrintDialog}{wxprintdialog}}{Standard print dialog}
-\twocolitem{\helpref{wxPageSetupDialog}{wxpagesetupdialog}}{Standard page setup dialog}
-\twocolitem{\helpref{wxMessageDialog}{wxmessagedialog}}{Simple message box dialog}
-\twocolitem{\helpref{wxWizard}{wxwizard}}{A wizard dialog.}
-\end{twocollist}
-
-{\large {\bf Controls}}
-
-Typically, these are small windows which provide interaction with the user. Controls
-that are not static can have \helpref{validators}{wxvalidator} associated with them.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxControl}{wxcontrol}}{The base class for controls}
-\twocolitem{\helpref{wxButton}{wxbutton}}{Push button control, displaying text}
-\twocolitem{\helpref{wxBitmapButton}{wxbitmapbutton}}{Push button control, displaying a bitmap}
-\twocolitem{\helpref{wxToggleButton}{wxtogglebutton}}{A button which stays pressed when clicked by user.}
-\twocolitem{\helpref{wxCalendarCtrl}{wxcalendarctrl}}{Date picker control}
-\twocolitem{\helpref{wxCheckBox}{wxcheckbox}}{Checkbox control}
-\twocolitem{\helpref{wxCheckListBox}{wxchecklistbox}}{A listbox with a checkbox to the left of each item}
-\twocolitem{\helpref{wxChoice}{wxchoice}}{Choice control (a combobox without the editable area)}
-\twocolitem{\helpref{wxComboBox}{wxcombobox}}{A choice with an editable area}
-\twocolitem{\helpref{wxGauge}{wxgauge}}{A control to represent a varying quantity, such as time remaining}
-\twocolitem{\helpref{wxGenericDirCtrl}{wxgenericdirctrl}}{A control for displaying a directory tree}
-\twocolitem{\helpref{wxStaticBox}{wxstaticbox}}{A static, or group box for visually grouping related controls}
-\twocolitem{\helpref{wxListBox}{wxlistbox}}{A list of strings for single or multiple selection}
-\twocolitem{\helpref{wxListCtrl}{wxlistctrl}}{A control for displaying lists of strings and/or icons, plus a multicolumn report view}
-\twocolitem{\helpref{wxListView}{wxlistview}}{A simpler interface ({\it fa\c{c}ade} for wxListCtrl in report mode}
-\twocolitem{\helpref{wxTabCtrl}{wxtabctrl}}{Manages several tabs}
-\twocolitem{\helpref{wxTextCtrl}{wxtextctrl}}{Single or multiline text editing control}
-\twocolitem{\helpref{wxTreeCtrl}{wxtreectrl}}{Tree (hierarchy) control}
-\twocolitem{\helpref{wxScrollBar}{wxscrollbar}}{Scrollbar control}
-\twocolitem{\helpref{wxSpinButton}{wxspinbutton}}{A spin or `up-down' control}
-\twocolitem{\helpref{wxSpinCtrl}{wxspinctrl}}{A spin control - i.e. spin button and text control}
-\twocolitem{\helpref{wxStaticText}{wxstatictext}}{One or more lines of non-editable text}
-\twocolitem{\helpref{wxStaticBitmap}{wxstaticbitmap}}{A control to display a bitmap}
-\twocolitem{\helpref{wxRadioBox}{wxradiobox}}{A group of radio buttons}
-\twocolitem{\helpref{wxRadioButton}{wxradiobutton}}{A round button to be used with others in a mutually exclusive way}
-\twocolitem{\helpref{wxSlider}{wxslider}}{A slider that can be dragged by the user}
-\end{twocollist}
-
-{\large {\bf Menus}}
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxMenu}{wxmenu}}{Displays a series of menu items for selection}
-\twocolitem{\helpref{wxMenuBar}{wxmenubar}}{Contains a series of menus for use with a frame}
-\twocolitem{\helpref{wxMenuItem}{wxmenuitem}}{Represents a single menu item}
-\end{twocollist}
-
-{\large {\bf Window layout}}
-
-There are two different systems for laying out windows (and dialogs in particular).
-One is based upon so-called sizers and it requires less typing, thinking and calculating
-and will in almost all cases produce dialogs looking equally well on all platforms, the
-other is based on so-called constraints and is deprecated, though still available.
-
-\overview{Sizer overview}{sizeroverview} describes sizer-based layout.
-
-These are the classes relevant to sizer-based layout.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxSizer}{wxsizer}}{Abstract base class}
-\twocolitem{\helpref{wxGridSizer}{wxgridsizer}}{A sizer for laying out windows in a grid with all fields having the same size}
-\twocolitem{\helpref{wxFlexGridSizer}{wxflexgridsizer}}{A sizer for laying out windows in a flexible grid}
-\twocolitem{\helpref{wxBoxSizer}{wxboxsizer}}{A sizer for laying out windows in a row or column}
-\twocolitem{\helpref{wxStaticBoxSizer}{wxstaticboxsizer}}{Same as wxBoxSizer, but with a surrounding static box}
-\twocolitem{\helpref{wxNotebookSizer}{wxnotebooksizer}}{Sizer to use with the wxNotebook control}
-\end{twocollist}
-
-\overview{Constraints overview}{constraintsoverview} describes constraints-based layout.
-
-These are the classes relevant to constraints-based window layout.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxIndividualLayoutConstraint}{wxindividuallayoutconstraint}}{Represents a single constraint dimension}
-\twocolitem{\helpref{wxLayoutConstraints}{wxlayoutconstraints}}{Represents the constraints for a window class}
-\end{twocollist}
-
-{\large {\bf Device contexts}}
-
-\overview{Overview}{dcoverview}
-
-Device contexts are surfaces that may be drawn on, and provide an
-abstraction that allows parameterisation of your drawing code
-by passing different device contexts.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxClientDC}{wxclientdc}}{A device context to access the client area outside {\bf OnPaint} events}
-\twocolitem{\helpref{wxPaintDC}{wxpaintdc}}{A device context to access the client area inside {\bf OnPaint} events}
-\twocolitem{\helpref{wxWindowDC}{wxwindowdc}}{A device context to access the non-client area}
-\twocolitem{\helpref{wxScreenDC}{wxscreendc}}{A device context to access the entire screen}
-\twocolitem{\helpref{wxDC}{wxdc}}{The device context base class}
-\twocolitem{\helpref{wxMemoryDC}{wxmemorydc}}{A device context for drawing into bitmaps}
-\twocolitem{\helpref{wxMetafileDC}{wxmetafiledc}}{A device context for drawing into metafiles}
-\twocolitem{\helpref{wxPostScriptDC}{wxpostscriptdc}}{A device context for drawing into PostScript files}
-\twocolitem{\helpref{wxPrinterDC}{wxprinterdc}}{A device context for drawing to printers}
-\end{twocollist}
-
-{\large {\bf Graphics device interface}}
-
-\overview{Bitmaps overview}{wxbitmapoverview}
-
-These classes are related to drawing on device contexts and windows.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxColour}{wxcolour}}{Represents the red, blue and green elements of a colour}
-\twocolitem{\helpref{wxDCClipper}{wxdcclipper}}{Wraps the operations of setting and destroying the clipping region}
-\twocolitem{\helpref{wxBitmap}{wxbitmap}}{Represents a bitmap}
-\twocolitem{\helpref{wxBrush}{wxbrush}}{Used for filling areas on a device context}
-\twocolitem{\helpref{wxBrushList}{wxbrushlist}}{The list of previously-created brushes}
-\twocolitem{\helpref{wxCursor}{wxcursor}}{A small, transparent bitmap representing the cursor}
-\twocolitem{\helpref{wxFont}{wxfont}}{Represents fonts}
-\twocolitem{\helpref{wxFontList}{wxfontlist}}{The list of previously-created fonts}
-\twocolitem{\helpref{wxIcon}{wxicon}}{A small, transparent bitmap for assigning to frames and drawing on device contexts}
-\twocolitem{\helpref{wxImage}{wximage}}{A platform-independent image class}
-\twocolitem{\helpref{wxImageList}{wximagelist}}{A list of images, used with some controls}
-\twocolitem{\helpref{wxMask}{wxmask}}{Represents a mask to be used with a bitmap for transparent drawing}
-\twocolitem{\helpref{wxPen}{wxpen}}{Used for drawing lines on a device context}
-\twocolitem{\helpref{wxPenList}{wxpenlist}}{The list of previously-created pens}
-\twocolitem{\helpref{wxPalette}{wxpalette}}{Represents a table of indices into RGB values}
-\twocolitem{\helpref{wxRegion}{wxregion}}{Represents a simple or complex region on a window or device context}
-\end{twocollist}
-
-{\large {\bf Events}}
-
-\overview{Overview}{eventhandlingoverview}
-
-An event object contains information about a specific event. Event handlers
-(usually member functions) have a single, event argument.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxActivateEvent}{wxactivateevent}}{A window or application activation event}
-\twocolitem{\helpref{wxCalendarEvent}{wxcalendarevent}}{Used with \helpref{wxCalendarCtrl}{wxcalendarctrl}}
-\twocolitem{\helpref{wxCalculateLayoutEvent}{wxcalculatelayoutevent}}{Used to calculate window layout}
-\twocolitem{\helpref{wxCloseEvent}{wxcloseevent}}{A close window or end session event}
-\twocolitem{\helpref{wxCommandEvent}{wxcommandevent}}{An event from a variety of standard controls}
-\twocolitem{\helpref{wxDialUpEvent}{wxdialupevent}}{Event send by \helpref{wxDialUpManager}{wxdialupmanager}}
-\twocolitem{\helpref{wxDropFilesEvent}{wxdropfilesevent}}{A drop files event}
-\twocolitem{\helpref{wxEraseEvent}{wxeraseevent}}{An erase background event}
-\twocolitem{\helpref{wxEvent}{wxevent}}{The event base class}
-\twocolitem{\helpref{wxFindDialogEvent}{wxfinddialogevent}}{Event sent by
-\helpref{wxFindReplaceDialog}{wxfindreplacedialog}}
-\twocolitem{\helpref{wxFocusEvent}{wxfocusevent}}{A window focus event}
-\twocolitem{\helpref{wxKeyEvent}{wxkeyevent}}{A keypress event}
-\twocolitem{\helpref{wxIconizeEvent}{wxiconizeevent}}{An iconize/restore event}
-\twocolitem{\helpref{wxIdleEvent}{wxidleevent}}{An idle event}
-\twocolitem{\helpref{wxInitDialogEvent}{wxinitdialogevent}}{A dialog initialisation event}
-\twocolitem{\helpref{wxJoystickEvent}{wxjoystickevent}}{A joystick event}
-\twocolitem{\helpref{wxListEvent}{wxlistevent}}{A list control event}
-\twocolitem{\helpref{wxMaximizeEvent}{wxmaximizeevent}}{A maximize event}
-\twocolitem{\helpref{wxMenuEvent}{wxmenuevent}}{A menu event}
-\twocolitem{\helpref{wxMouseCaptureChangedEvent}{wxmousecapturechangedevent}}{A mouse capture changed event}
-\twocolitem{\helpref{wxMouseEvent}{wxmouseevent}}{A mouse event}
-\twocolitem{\helpref{wxMoveEvent}{wxmoveevent}}{A move event}
-\twocolitem{\helpref{wxNotebookEvent}{wxnotebookevent}}{A notebook control event}
-\twocolitem{\helpref{wxNotifyEvent}{wxnotifyevent}}{A notification event, which can be vetoed}
-\twocolitem{\helpref{wxPaintEvent}{wxpaintevent}}{A paint event}
-\twocolitem{\helpref{wxProcessEvent}{wxprocessevent}}{A process ending event}
-\twocolitem{\helpref{wxQueryLayoutInfoEvent}{wxquerylayoutinfoevent}}{Used to query layout information}
-\twocolitem{\helpref{wxScrollEvent}{wxscrollevent}}{A scroll event from sliders, stand-alone scrollbars and spin buttons}
-\twocolitem{\helpref{wxScrollWinEvent}{wxscrollwinevent}}{A scroll event from scrolled windows}
-\twocolitem{\helpref{wxSizeEvent}{wxsizeevent}}{A size event}
-\twocolitem{\helpref{wxSocketEvent}{wxsocketevent}}{A socket event}
-\twocolitem{\helpref{wxSpinEvent}{wxspinevent}}{An event from \helpref{wxSpinButton}{wxspinbutton}}
-\twocolitem{\helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent}}{A system colour change event}
-\twocolitem{\helpref{wxTabEvent}{wxtabevent}}{A tab control event}
-\twocolitem{\helpref{wxTreeEvent}{wxtreeevent}}{A tree control event}
-\twocolitem{\helpref{wxUpdateUIEvent}{wxupdateuievent}}{A user interface update event}
-\twocolitem{\helpref{wxWizardEvent}{wxwizardevent}}{A wizard event}
-\end{twocollist}
-
-{\large {\bf Validators}}
-
-\overview{Overview}{validatoroverview}
-
-These are the window validators, used for filtering and validating
-user input.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxValidator}{wxvalidator}}{Base validator class}
-\twocolitem{\helpref{wxTextValidator}{wxtextvalidator}}{Text control validator class}
-\twocolitem{\helpref{wxGenericValidator}{wxgenericvalidator}}{Generic control validator class}
-\end{twocollist}
-
-{\large {\bf Data structures}}
-
-These are the data structure classes supported by wxWindows.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxCmdLineParser}{wxcmdlineparser}}{Command line parser class}
-\twocolitem{\helpref{wxDate}{wxdate}}{A class for date manipulation (deprecated in favour of wxDateTime)}
-\twocolitem{\helpref{wxDateSpan}{wxdatespan}}{A logical time interval.}
-\twocolitem{\helpref{wxDateTime}{wxdatetime}}{A class for date/time manipulations}
-\twocolitem{\helpref{wxExpr}{wxexpr}}{A class for flexible I/O}
-\twocolitem{\helpref{wxExprDatabase}{wxexprdatabase}}{A class for flexible I/O}
-\twocolitem{\helpref{wxHashMap}{wxhashmap}}{A simple hash map implementation}
-\twocolitem{\helpref{wxHashTable}{wxhashtable}}{A simple hash table implementation (deprecated, use wxHashMap)}
-% \twocolitem{\helpref{wxHashTableLong}{wxhashtablelong}}{A wxHashTable version for storing long data}
-\twocolitem{\helpref{wxList}{wxlist}}{A simple linked list implementation}
-\twocolitem{\helpref{wxLongLong}{wxlonglong}}{A portable 64 bit integer type}
-\twocolitem{\helpref{wxNode}{wxnode}}{Represents a node in the wxList implementation}
-\twocolitem{\helpref{wxObject}{wxobject}}{The root class for most wxWindows classes}
-\twocolitem{\helpref{wxPathList}{wxpathlist}}{A class to help search multiple paths}
-\twocolitem{\helpref{wxPoint}{wxpoint}}{Representation of a point}
-\twocolitem{\helpref{wxRect}{wxrect}}{A class representing a rectangle}
-\twocolitem{\helpref{wxRegEx}{wxregex}}{Regular expression support}
-\twocolitem{\helpref{wxRegion}{wxregion}}{A class representing a region}
-\twocolitem{\helpref{wxString}{wxstring}}{A string class}
-\twocolitem{\helpref{wxStringList}{wxstringlist}}{A class representing a list of strings}
-\twocolitem{\helpref{wxStringTokenizer}{wxstringtokenizer}}{A class for interpreting a string as a list of tokens or words}
-\twocolitem{\helpref{wxRealPoint}{wxrealpoint}}{Representation of a point using floating point numbers}
-\twocolitem{\helpref{wxSize}{wxsize}}{Representation of a size}
-\twocolitem{\helpref{wxTime}{wxtime}}{A class for time manipulation (deprecated in favour of wxDateTime)}
-\twocolitem{\helpref{wxTimeSpan}{wxtimespan}}{A time interval.}
-\twocolitem{\helpref{wxVariant}{wxvariant}}{A class for storing arbitrary types that may change at run-time}
-\end{twocollist}
-
-{\large {\bf Run-time class information system}}
-
-\overview{Overview}{runtimeclassoverview}
-
-wxWindows supports run-time manipulation of class information, and dynamic
-creation of objects given class names.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxClassInfo}{wxclassinfo}}{Holds run-time class information}
-\twocolitem{\helpref{wxObject}{wxobject}}{Root class for classes with run-time information}
-\twocolitem{\helpref{RTTI macros}{rttimacros}}{Macros for manipulating run-time information}
-\end{twocollist}
-
-{\large {\bf Debugging features}}
-
-\overview{Overview}{wxlogoverview}
-
-wxWindows provides several classes and functions for the message logging.
-Please see the \helpref{wxLog overview}{wxlogoverview} for more details.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxLog}{wxlog}}{The base log class}
-\twocolitem{\helpref{wxLogStderr}{wxlogstderr}}{Log messages to a C STDIO stream}
-\twocolitem{\helpref{wxLogStream}{wxlogstream}}{Log messages to a C++ iostream}
-\twocolitem{\helpref{wxLogTextCtrl}{wxlogtextctrl}}{Log messages to a \helpref{wxTextCtrl}{wxtextctrl}}
-\twocolitem{\helpref{wxLogWindow}{wxlogwindow}}{Log messages to a log frame}
-\twocolitem{\helpref{wxLogGui}{wxloggui}}{Default log target for GUI programs}
-\twocolitem{\helpref{wxLogNull}{wxlognull}}{Temporarily suppress message logging}
-\twocolitem{\helpref{wxLogChain}{wxlogchain}}{Allows to chain two log targets}
-\twocolitem{\helpref{wxLogPassThrough}{wxlogpassthrough}}{Allows to filter the log messages}
-\twocolitem{\helpref{wxStreamToTextRedirector}{wxstreamtotextredirector}}{Allows
-to redirect output sent to {\tt cout} to a \helpref{wxTextCtrl}{wxtextctrl}}
-\twocolitem{\helpref{Log functions}{logfunctions}}{Error and warning logging functions}
-\end{twocollist}
-
-{\large {\bf Debugging features}}
-
-\overview{Overview}{debuggingoverview}
-
-wxWindows supports some aspects of debugging an application through
-classes, functions and macros.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxDebugContext}{wxdebugcontext}}{Provides memory-checking facilities}
-%\twocolitem{\helpref{wxDebugStreamBuf}{wxdebugstreambuf}}{A stream buffer writing to the debug stream}
-\twocolitem{\helpref{Debugging macros}{debugmacros}}{Debug macros for assertion and checking}
-\twocolitem{\helpref{WXDEBUG\_NEW}{debugnew}}{Use this macro to give further debugging information}
-%\twocolitem{\helpref{WXTRACE}{trace}}{Trace macro}
-%\twocolitem{\helpref{WXTRACELEVEL}{tracelevel}}{Trace macro with levels}
-\end{twocollist}
-
-{\large {\bf Networking classes}}
-
-wxWindows provides its own classes for socket based networking.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxDialUpManager}{wxdialupmanager}}{Provides functions to check the status of network connection and to establish one}
-\twocolitem{\helpref{wxIPV4address}{wxipv4address}}{Represents an Internet address}
-\twocolitem{\helpref{wxSocketBase}{wxsocketbase}}{Represents a socket base object}
-\twocolitem{\helpref{wxSocketClient}{wxsocketclient}}{Represents a socket client}
-\twocolitem{\helpref{wxSocketServer}{wxsocketserver}}{Represents a socket server}
-\twocolitem{\helpref{wxSocketEvent}{wxsocketevent}}{A socket event}
-\twocolitem{\helpref{wxFTP}{wxftp}}{FTP protocol class}
-\twocolitem{\helpref{wxHTTP}{wxhttp}}{HTTP protocol class}
-\twocolitem{\helpref{wxURL}{wxurl}}{Represents a Universal Resource Locator}
-\end{twocollist}
-
-
-{\large {\bf Interprocess communication}}
-
-\overview{Overview}{ipcoverview}
-
-wxWindows provides simple interprocess communications facilities
-based on Windows DDE, but available on most platforms using TCP.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxClient}{wxddeclient}}{Represents a client}
-\twocolitem{\helpref{wxConnection}{wxddeconnection}}{Represents the connection between a client and a server}
-\twocolitem{\helpref{wxServer}{wxddeserver}}{Represents a server}
-%\twocolitem{\helpref{wxSocketHandler}{wxsockethandler}}{Represents a socket handler}
-\end{twocollist}
-
-{\large {\bf Document/view framework}}
-
-\overview{Overview}{docviewoverview}
-
-wxWindows supports a document/view framework which provides
-housekeeping for a document-centric application.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxDocument}{wxdocument}}{Represents a document}
-\twocolitem{\helpref{wxView}{wxview}}{Represents a view}
-\twocolitem{\helpref{wxDocTemplate}{wxdoctemplate}}{Manages the relationship between a document class and a view class}
-\twocolitem{\helpref{wxDocManager}{wxdocmanager}}{Manages the documents and views in an application}
-\twocolitem{\helpref{wxDocChildFrame}{wxdocchildframe}}{A child frame for showing a document view}
-\twocolitem{\helpref{wxDocParentFrame}{wxdocparentframe}}{A parent frame to contain views}
-%\twocolitem{\helpref{wxMDIDocChildFrame}{wxmdidocchildframe}}{An MDI child frame for showing a document view}
-%\twocolitem{\helpref{wxMDIDocParentFrame}{wxmdidocparentframe}}{An MDI parent frame to contain views}
-\end{twocollist}
-
-{\large {\bf Printing framework}}
-
-\overview{Overview}{printingoverview}
-
-A printing and previewing framework is implemented to
-make it relatively straightforward to provide document printing
-facilities.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxPreviewFrame}{wxpreviewframe}}{Frame for displaying a print preview}
-\twocolitem{\helpref{wxPreviewCanvas}{wxpreviewcanvas}}{Canvas for displaying a print preview}
-\twocolitem{\helpref{wxPreviewControlBar}{wxpreviewcontrolbar}}{Standard control bar for a print preview}
-\twocolitem{\helpref{wxPrintDialog}{wxprintdialog}}{Standard print dialog}
-\twocolitem{\helpref{wxPageSetupDialog}{wxpagesetupdialog}}{Standard page setup dialog}
-\twocolitem{\helpref{wxPrinter}{wxprinter}}{Class representing the printer}
-\twocolitem{\helpref{wxPrinterDC}{wxprinterdc}}{Printer device context}
-\twocolitem{\helpref{wxPrintout}{wxprintout}}{Class representing a particular printout}
-\twocolitem{\helpref{wxPrintPreview}{wxprintpreview}}{Class representing a print preview}
-\twocolitem{\helpref{wxPrintData}{wxprintdata}}{Represents information about the document being printed}
-\twocolitem{\helpref{wxPrintDialogData}{wxprintdialogdata}}{Represents information about the print dialog}
-\twocolitem{\helpref{wxPageSetupDialogData}{wxpagesetupdialogdata}}{Represents information about the page setup dialog}
-\end{twocollist}
-
-{\large {\bf Drag and drop and clipboard classes}}
-
-\overview{Drag and drop and clipboard overview}{wxdndoverview}
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxDataObject}{wxdataobject}}{Data object class}
-\twocolitem{\helpref{wxDataFormat}{wxdataformat}}{Represents a data format}
-\twocolitem{\helpref{wxTextDataObject}{wxtextdataobject}}{Text data object class}
-\twocolitem{\helpref{wxFileDataObject}{wxtextdataobject}}{File data object class}
-\twocolitem{\helpref{wxBitmapDataObject}{wxbitmapdataobject}}{Bitmap data object class}
-\twocolitem{\helpref{wxCustomDataObject}{wxcustomdataobject}}{Custom data object class}
-\twocolitem{\helpref{wxClipboard}{wxclipboard}}{Clipboard class}
-\twocolitem{\helpref{wxDropTarget}{wxdroptarget}}{Drop target class}
-\twocolitem{\helpref{wxFileDropTarget}{wxfiledroptarget}}{File drop target class}
-\twocolitem{\helpref{wxTextDropTarget}{wxtextdroptarget}}{Text drop target class}
-\twocolitem{\helpref{wxDropSource}{wxdropsource}}{Drop source class}
-\end{twocollist}
-
-{\large {\bf File related classes}}
-
-wxWindows has several small classes to work with disk files, see \helpref{file classes
-overview}{wxfileoverview} for more details.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxFileName}{wxfilename}}{Operations with the file name and attributes}
-\twocolitem{\helpref{wxDir}{wxdir}}{Class for enumerating files/subdirectories.}
-\twocolitem{\helpref{wxDirTraverser}{wxdirtraverser}}{Class used together with wxDir for recursively enumerating the files/subdirectories}
-\twocolitem{\helpref{wxFile}{wxfile}}{Low-level file input/output class.}
-\twocolitem{\helpref{wxFFile}{wxffile}}{Another low-level file input/output class.}
-\twocolitem{\helpref{wxTempFile}{wxtempfile}}{Class to safely replace an existing file}
-\twocolitem{\helpref{wxTextFile}{wxtextfile}}{Class for working with text files as with arrays of lines}
-\end{twocollist}
-
-{\large {\bf Stream classes}}
-
-wxWindows has its own set of stream classes, as an alternative to often buggy standard stream
-libraries, and to provide enhanced functionality.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxStreamBase}{wxstreambase}}{Stream base class}
-\twocolitem{\helpref{wxStreamBuffer}{wxstreambuffer}}{Stream buffer class}
-\twocolitem{\helpref{wxInputStream}{wxinputstream}}{Input stream class}
-\twocolitem{\helpref{wxOutputStream}{wxoutputstream}}{Output stream class}
-\twocolitem{\helpref{wxCountingOutputStream}{wxcountingoutputstream}}{Stream class for querying what size a stream would have.}
-\twocolitem{\helpref{wxFilterInputStream}{wxfilterinputstream}}{Filtered input stream class}
-\twocolitem{\helpref{wxFilterOutputStream}{wxfilteroutputstream}}{Filtered output stream class}
-\twocolitem{\helpref{wxBufferedInputStream}{wxbufferedinputstream}}{Buffered input stream class}
-\twocolitem{\helpref{wxBufferedOutputStream}{wxbufferedoutputstream}}{Buffered output stream class}
-\twocolitem{\helpref{wxMemoryInputStream}{wxmeminputstream}}{Memory input stream class}
-\twocolitem{\helpref{wxMemoryOutputStream}{wxmemoutputstream}}{Memory output stream class}
-\twocolitem{\helpref{wxDataInputStream}{wxdatainputstream}}{Platform-independent binary data input stream class}
-\twocolitem{\helpref{wxDataOutputStream}{wxdataoutputstream}}{Platform-independent binary data output stream class}
-\twocolitem{\helpref{wxTextInputStream}{wxtextinputstream}}{Platform-independent text data input stream class}
-\twocolitem{\helpref{wxTextOutputStream}{wxtextoutputstream}}{Platform-independent text data output stream class}
-\twocolitem{\helpref{wxFileInputStream}{wxfileinputstream}}{File input stream class}
-\twocolitem{\helpref{wxFileOutputStream}{wxfileoutputstream}}{File output stream class}
-\twocolitem{\helpref{wxFFileInputStream}{wxffileinputstream}}{Another file input stream class}
-\twocolitem{\helpref{wxFFileOutputStream}{wxffileoutputstream}}{Another file output stream class}
-\twocolitem{\helpref{wxZlibInputStream}{wxzlibinputstream}}{Zlib (compression) input stream class}
-\twocolitem{\helpref{wxZlibOutputStream}{wxzliboutputstream}}{Zlib (compression) output stream class}
-\twocolitem{\helpref{wxZipInputStream}{wxzipinputstream}}{Input stream for reading from ZIP archives}
-\twocolitem{\helpref{wxSocketInputStream}{wxsocketinputstream}}{Socket input stream class}
-\twocolitem{\helpref{wxSocketOutputStream}{wxsocketoutputstream}}{Socket output stream class}
-\end{twocollist}
-
-{\large {\bf Threading classes}}
-
-\overview{Multithreading overview}{wxthreadoverview}
-
-wxWindows provides a set of classes to make use of the native thread
-capabilities of the various platforms.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxThread}{wxthread}}{Thread class}
-\twocolitem{\helpref{wxMutex}{wxmutex}}{Mutex class}
-\twocolitem{\helpref{wxMutexLocker}{wxmutexlocker}}{Mutex locker utility class}
-\twocolitem{\helpref{wxCriticalSection}{wxcriticalsection}}{Critical section class}
-\twocolitem{\helpref{wxCriticalSectionLocker}{wxcriticalsectionlocker}}{Critical section locker utility class}
-\twocolitem{\helpref{wxCondition}{wxcondition}}{Condition class}
-\twocolitem{\helpref{wxSemaphore}{wxsemaphore}}{Semaphore class}
-\end{twocollist}
-
-{\large {\bf HTML classes}}
-
-wxWindows provides a set of classes to display text in HTML format. These
-class include a help system based on the HTML widget.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxHtmlHelpController}{wxhtmlhelpcontroller}}{HTML help controller class}
-\twocolitem{\helpref{wxHtmlWindow}{wxhtmlwindow}}{HTML window class}
-\twocolitem{\helpref{wxHtmlEasyPrinting}{wxhtmleasyprinting}}{Simple class for printing HTML}
-\twocolitem{\helpref{wxHtmlPrintout}{wxhtmlprintout}}{Generic HTML wxPrintout class}
-\twocolitem{\helpref{wxHtmlParser}{wxhtmlparser}}{Generic HTML parser class}
-\twocolitem{\helpref{wxHtmlTagHandler}{wxhtmltaghandler}}{HTML tag handler, pluginable into wxHtmlParser}
-\twocolitem{\helpref{wxHtmlWinParser}{wxhtmlwinparser}}{HTML parser class for wxHtmlWindow}
-\twocolitem{\helpref{wxHtmlWinTagHandler}{wxhtmlwintaghandler}}{HTML tag handler, pluginable into wxHtmlWinParser}
-\end{twocollist}
-
-{\large {\bf Virtual file system classes}}
-
-wxWindows provides a set of classes that implement an extensible virtual file system,
-used internally by the HTML classes.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxFSFile}{wxfsfile}}{Represents a file in the virtual file system}
-\twocolitem{\helpref{wxFileSystem}{wxfilesystem}}{Main interface for the virtual file system}
-\twocolitem{\helpref{wxFileSystemHandler}{wxfilesystemhandler}}{Class used to announce file system type}
-\end{twocollist}
-
-{\large {\bf XML-based resource system classes}}
-
-\overview{XML-based resource system overview}{xrcoverview}
-
-Resources allow your application to create controls and other user interface elements
-from specifications stored in an XML format.
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxXmlResource}{wxxmlresource}}{The main class for working with resources.}
-\twocolitem{\helpref{wxXmlResourceHandler}{wxxmlresourcehandler}}{The base class for XML resource handlers.}
-\end{twocollist}
-
-{\large {\bf Online help}}
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxHelpController}{wxhelpcontroller}}{Family of classes for controlling help windows}
-\twocolitem{\helpref{wxHtmlHelpController}{wxhtmlhelpcontroller}}{HTML help controller class}
-\twocolitem{\helpref{wxContextHelp}{wxcontexthelp}}{Class to put application into context-sensitive help mode}
-\twocolitem{\helpref{wxContextHelpButton}{wxcontexthelpbutton}}{Button class for putting application into context-sensitive help mode}
-\twocolitem{\helpref{wxHelpProvider}{wxhelpprovider}}{Abstract class for context-sensitive help provision}
-\twocolitem{\helpref{wxSimpleHelpProvider}{wxsimplehelpprovider}}{Class for simple context-sensitive help provision}
-\twocolitem{\helpref{wxHelpControllerHelpProvider}{wxhelpcontrollerhelpprovider}}{Class for context-sensitive help provision via a help controller}
-\twocolitem{\helpref{wxToolTip}{wxtooltip}}{Class implementing tooltips}
-\end{twocollist}
-
-{\large {\bf Database classes}}
-
-\overview{Database classes overview}{odbcoverview}
-
-wxWindows provides two alternative sets of classes for accessing Microsoft's ODBC (Open Database Connectivity)
-product. The new version by Remstar, known as wxODBC, is more powerful,
-portable, flexible and better supported, so please use the classes below for
-working with databases:
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxDb}{wxdb}}{ODBC database connection}
-\twocolitem{\helpref{wxDbTable}{wxdbtable}}{Provides access to a database table}
-\twocolitem{\helpref{wxDbInf}{wxdbinf}}{}
-\twocolitem{\helpref{wxDbTableInf}{wxdbtableinf}}{}
-\twocolitem{\helpref{wxDbColDef}{wxdbcoldef}}{}
-\twocolitem{\helpref{wxDbColInf}{wxdbcolinf}}{}
-\twocolitem{\helpref{wxDbColDataPtr}{wxdbcoldataptr}}{}
-\twocolitem{\helpref{wxDbColFor}{wxdbcolfor}}{}
-\twocolitem{\helpref{wxDbConnectInf}{wxdbconnectinf}}{}
-\twocolitem{\helpref{wxDbIdxDef}{wxdbidxdef}}{}
-\end{twocollist}
-
-The documentation for the older classes is still included, but you should avoid
-using any of them in new programs:
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxDatabase}{wxdatabase}}{Database class}
-\twocolitem{\helpref{wxQueryCol}{wxquerycol}}{Class representing a column}
-\twocolitem{\helpref{wxQueryField}{wxqueryfield}}{Class representing a field}
-\twocolitem{\helpref{wxRecordSet}{wxrecordset}}{Class representing one or more record}
-\end{twocollist}
-
-{\large {\bf Miscellaneous}}
-
-\twocolwidtha{6cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\helpref{wxApp}{wxapp}}{Application class}
-\twocolitem{\helpref{wxCaret}{wxcaret}}{A caret (cursor) object}
-\twocolitem{\helpref{wxCmdLineParser}{wxcmdlineparser}}{Command line parser class}
-\twocolitem{\helpref{wxConfig}{wxconfigbase}}{Classes for configuration reading/writing (using either INI files or registry)}
-\twocolitem{\helpref{wxDllLoader}{wxdllloader}}{Class to work with shared libraries.}
-\twocolitem{\helpref{wxLayoutAlgorithm}{wxlayoutalgorithm}}{An alternative window layout facility}
-\twocolitem{\helpref{wxProcess}{wxprocess}}{Process class}
-\twocolitem{\helpref{wxTimer}{wxtimer}}{Timer class}
-\twocolitem{\helpref{wxStopWatch}{wxstopwatch}}{Stop watch class}
-\twocolitem{\helpref{wxMimeTypesManager}{wxmimetypesmanager}}{MIME-types manager class}
-\twocolitem{\helpref{wxSystemSettings}{wxsystemsettings}}{System settings class for obtaining various global parameters}
-\twocolitem{\helpref{wxSystemOptions}{wxsystemoptions}}{System options class for run-time configuration}
-\twocolitem{\helpref{wxAcceleratorTable}{wxacceleratortable}}{Accelerator table}
-\twocolitem{\helpref{wxAutomationObject}{wxautomationobject}}{OLE automation class}
-\twocolitem{\helpref{wxFontMapper}{wxfontmapper}}{Font mapping, finding suitable font for given encoding}
-\twocolitem{\helpref{wxEncodingConverter}{wxencodingconverter}}{Encoding conversions}
-\twocolitem{\helpref{wxCalendarDateAttr}{wxcalendardateattr}}{Used with \helpref{wxCalendarCtrl}{wxcalendarctrl}}
-\twocolitem{\helpref{wxQuantize}{wxquantize}}{Class to perform quantization, or colour reduction}
-\twocolitem{\helpref{wxSingleInstanceChecker}{wxsingleinstancechecker}}{Check that only single program instance is running}
-\end{twocollist}

docs/latex/wx/checkbox.tex

@@ -1,116 +0,0 @@
-\section{\class{wxCheckBox}}\label{wxcheckbox}
-
-A checkbox is a labelled box which is either on (checkmark is visible)
-or off (no checkmark).
-
-\wxheading{Derived from}
-
-\helpref{wxControl}{wxcontrol}\\
-\helpref{wxWindow}{wxwindow}\\
-\helpref{wxEvtHandler}{wxevthandler}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/checkbox.h>
-
-\wxheading{Window styles}
-
-There are no special styles for wxCheckBox.
-
-See also \helpref{window styles overview}{windowstyles}.
-
-\wxheading{Event handling}
-
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_CHECKBOX(id, func)}}{Process a wxEVT\_COMMAND\_CHECKBOX\_CLICKED event,
-when the checkbox is clicked.}
-\end{twocollist}
-
-\wxheading{See also}
-
-\helpref{wxRadioButton}{wxradiobutton}, \helpref{wxCommandEvent}{wxcommandevent}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCheckBox::wxCheckBox}\label{wxcheckboxconstr}
-
-\func{}{wxCheckBox}{\void}
-
-Default constructor.
-
-\func{}{wxCheckBox}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id},\rtfsp
-\param{const wxString\& }{label}, \param{const wxPoint\& }{pos = wxDefaultPosition},\rtfsp
-\param{const wxSize\& }{size = wxDefaultSize}, \param{long}{ style = 0},\rtfsp
-\param{const wxValidator\& }{val}, \param{const wxString\& }{name = ``checkBox"}}
-
-Constructor, creating and showing a checkbox.
-
-\wxheading{Parameters}
-
-\docparam{parent}{Parent window. Must not be NULL.}
-
-\docparam{id}{Checkbox identifier. A value of -1 indicates a default value.}
-
-\docparam{label}{Text to be displayed next to the checkbox.}
-
-\docparam{pos}{Checkbox position. If the position (-1, -1) is specified then a default position is chosen.}
-
-\docparam{size}{Checkbox size. If the default size (-1, -1) is specified then a default size is chosen.}
-
-\docparam{style}{Window style. See \helpref{wxCheckBox}{wxcheckbox}.}
-
-\docparam{validator}{Window validator.}
-
-\docparam{name}{Window name.}
-
-\wxheading{See also}
-
-\helpref{wxCheckBox::Create}{wxcheckboxcreate}, \helpref{wxValidator}{wxvalidator}
-
-\membersection{wxCheckBox::\destruct{wxCheckBox}}
-
-\func{}{\destruct{wxCheckBox}}{\void}
-
-Destructor, destroying the checkbox.
-
-\membersection{wxCheckBox::Create}\label{wxcheckboxcreate}
-
-\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id},\rtfsp
-\param{const wxString\& }{label}, \param{const wxPoint\& }{pos = wxDefaultPosition},\rtfsp
-\param{const wxSize\& }{size = wxDefaultSize}, \param{long}{ style = 0},\rtfsp
-\param{const wxValidator\& }{val}, \param{const wxString\& }{name = ``checkBox"}}
-
-Creates the checkbox for two-step construction. See \helpref{wxCheckBox::wxCheckBox}{wxcheckboxconstr}\rtfsp
-for details.
-
-\membersection{wxCheckBox::GetValue}\label{wxcheckboxgetvalue}
-
-\constfunc{bool}{GetValue}{\void}
-
-Gets the state of the checkbox.
-
-\wxheading{Return value}
-
-Returns {\tt TRUE} if it is checked, {\tt FALSE} otherwise.
-
-\membersection{wxCheckBox::IsChecked}\label{wxcheckboxischecked}
-
-\constfunc{bool}{IsChecked}{\void}
-
-This is just a maybe more readable synonym for 
-\helpref{GetValue}{wxcheckboxgetvalue}: just as the latter, it returns 
-{\tt TRUE} if the checkbox is checked and {\tt FALSE} otherwise.
-
-\membersection{wxCheckBox::SetValue}\label{wxcheckboxsetvalue}
-
-\func{void}{SetValue}{\param{const bool}{ state}}
-
-Sets the checkbox to the given state. This does not cause a
-wxEVT\_COMMAND\_CHECKBOX\_CLICKED event to get emitted.
-
-\wxheading{Parameters}
-
-\docparam{state}{If {\tt TRUE}, the check is on, otherwise it is off.}
-

docs/latex/wx/checklst.tex

@@ -1,111 +0,0 @@
-\section{\class{wxCheckListBox}}\label{wxchecklistbox}
-
-A checklistbox is like a listbox, but allows items to be checked or unchecked.
-
-This class is currently implemented under Windows and GTK. When using this
-class under Windows wxWindows must be compiled with USE\_OWNER\_DRAWN set to 1.
-
-Only the new functions for this class are documented; see also \helpref{wxListBox}{wxlistbox}.
-
-\wxheading{Derived from}
-
-\helpref{wxListBox}{wxlistbox}\\
-\helpref{wxControl}{wxcontrol}\\
-\helpref{wxWindow}{wxwindow}\\
-\helpref{wxEvtHandler}{wxevthandler}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/checklst.h>
-
-\wxheading{Window styles}
-
-See \helpref{wxListBox}{wxlistbox}.
-
-\wxheading{Event handling}
-
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_CHECKLISTBOX(id, func)}}{Process a wxEVT\_COMMAND\_CHECKLISTBOX\_TOGGLE event,
-when an item in the check list box is checked or unchecked.}
-\end{twocollist}
-
-\wxheading{See also}
-
-\helpref{wxListBox}{wxlistbox}, \helpref{wxChoice}{wxchoice}, \helpref{wxComboBox}{wxcombobox}, \helpref{wxListCtrl}{wxlistctrl},
-\rtfsp\helpref{wxCommandEvent}{wxcommandevent}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCheckListBox::wxCheckListBox}\label{wxchecklistboxconstr}
-
-\func{}{wxCheckListBox}{\void}
-
-Default constructor.
-
-\func{}{wxCheckListBox}{\param{wxWindow*}{ parent}, \param{wxWindowID}{ id},\rtfsp
-\param{const wxPoint\&}{ pos = wxDefaultPosition}, \param{const wxSize\&}{ size = wxDefaultSize},\rtfsp
-\param{int}{ n}, \param{const wxString }{choices[] = NULL},\rtfsp
-\param{long}{ style = 0}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``listBox"}}
-
-Constructor, creating and showing a list box.
-
-\wxheading{Parameters}
-
-\docparam{parent}{Parent window. Must not be NULL.}
-
-\docparam{id}{Window identifier. A value of -1 indicates a default value.}
-
-\docparam{pos}{Window position.}
-
-\docparam{size}{Window size. If the default size (-1, -1) is specified then the window is sized
-appropriately.}
-
-\docparam{n}{Number of strings with which to initialise the control.}
-
-\docparam{choices}{An array of strings with which to initialise the control.}
-
-\docparam{style}{Window style. See \helpref{wxCheckListBox}{wxchecklistbox}.}
-
-\docparam{validator}{Window validator.}
-
-\docparam{name}{Window name.}
-
-\pythonnote{The wxCheckListBox constructor in wxPython reduces the {\tt n}
-and {\tt choices} arguments are to a single argument, which is
-a list of strings.}
-
-\perlnote{In wxPerl there is just an array reference in place of {\tt n}
-and {\tt choices}.}
-
-\membersection{wxCheckListBox::\destruct{wxCheckListBox}}
-
-\func{void}{\destruct{wxCheckListBox}}{\void}
-
-Destructor, destroying the list box.
-
-\membersection{wxCheckListBox::Check}\label{wxchecklistboxcheck}
-
-\func{void}{Check}{\param{int }{item}, \param{bool}{ check = TRUE}}
-
-Checks the given item. Note that calling this method doesn't result in
-wxEVT\_COMMAND\_CHECKLISTBOX\_TOGGLE being emitted.
-
-\wxheading{Parameters}
-
-\docparam{item}{Index of item to check.}
-
-\docparam{check}{TRUE if the item is to be checked, FALSE otherwise.}
-
-\membersection{wxCheckListBox::IsChecked}\label{wxchecklistboxischecked}
-
-\constfunc{bool}{IsChecked}{\param{int}{ item}}
-
-Returns TRUE if the given item is checked, FALSE otherwise.
-
-\wxheading{Parameters}
-
-\docparam{item}{Index of item whose check status is to be returned.}
-
-

docs/latex/wx/choice.tex

@@ -1,135 +0,0 @@
-\section{\class{wxChoice}}\label{wxchoice}
-
-A choice item is used to select one of a list of strings. Unlike a
-listbox, only the selection is visible until the user pulls down the
-menu of choices.
-
-\wxheading{Derived from}
-
-\helpref{wxControlWithItems}{wxcontrolwithitems}\\
-\helpref{wxControl}{wxcontrol}\\
-\helpref{wxWindow}{wxwindow}\\
-\helpref{wxEvtHandler}{wxevthandler}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/choice.h>
-
-\wxheading{Window styles}
-
-There are no special styles for wxChoice.
-
-See also \helpref{window styles overview}{windowstyles}.
-
-\wxheading{Event handling}
-
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_CHOICE(id, func)}}{Process a wxEVT\_COMMAND\_CHOICE\_SELECTED event,
-when an item on the list is selected.}
-\end{twocollist}
-
-\wxheading{See also}
-
-\helpref{wxListBox}{wxlistbox}, \helpref{wxComboBox}{wxcombobox},
-\rtfsp\helpref{wxCommandEvent}{wxcommandevent}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxChoice::wxChoice}\label{wxchoiceconstr}
-
-\func{}{wxChoice}{\void}
-
-Default constructor.
-
-\func{}{wxChoice}{\param{wxWindow *}{parent}, \param{wxWindowID}{ id},\rtfsp
-\param{const wxPoint\& }{pos}, \param{const wxSize\&}{ size},\rtfsp
-\param{int}{ n}, \param{const wxString }{choices[]},\rtfsp
-\param{long}{ style = 0}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``choice"}}
-
-Constructor, creating and showing a choice.
-
-\wxheading{Parameters}
-
-\docparam{parent}{Parent window. Must not be NULL.}
-
-\docparam{id}{Window identifier. A value of -1 indicates a default value.}
-
-\docparam{pos}{Window position.}
-
-\docparam{size}{Window size. If the default size (-1, -1) is specified then the choice is sized
-appropriately.}
-
-\docparam{n}{Number of strings with which to initialise the choice control.}
-
-\docparam{choices}{An array of strings with which to initialise the choice control.}
-
-\docparam{style}{Window style. See \helpref{wxChoice}{wxchoice}.}
-
-\docparam{validator}{Window validator.}
-
-\docparam{name}{Window name.}
-
-\wxheading{See also}
-
-\helpref{wxChoice::Create}{wxchoicecreate}, \helpref{wxValidator}{wxvalidator}
-
-\pythonnote{The wxChoice constructor in wxPython reduces the {\tt n}
-and {\tt choices} arguments are to a single argument, which is
-a list of strings.}
-
-\perlnote{In wxPerl there is just an array reference in place of {\tt n}
-and {\tt choices}.}
-
-\membersection{wxChoice::\destruct{wxChoice}}
-
-\func{}{\destruct{wxChoice}}{\void}
-
-Destructor, destroying the choice item.
-
-\membersection{wxChoice::Create}\label{wxchoicecreate}
-
-\func{bool}{Create}{\param{wxWindow *}{parent}, \param{wxWindowID}{ id},\rtfsp
-\param{const wxPoint\& }{pos}, \param{const wxSize\&}{ size},\rtfsp
-\param{int}{ n}, \param{const wxString }{choices[]},\rtfsp
-\param{long}{ style = 0}, \param{const wxString\& }{name = ``choice"}}
-
-Creates the choice for two-step construction. See \helpref{wxChoice::wxChoice}{wxchoiceconstr}.
-
-\membersection{wxChoice::Delete}\label{wxchoicedelete}
-
-\func{void}{Delete}{\param{int }{n}}
-
-Deletes the item with the given index from the control.
-
-\wxheading{Parameters}
-
-\docparam{n}{The item to delete.}
-
-\membersection{wxChoice::GetColumns}\label{wxchoicegetcolumns}
-
-\constfunc{int}{GetColumns}{\void}
-
-Gets the number of columns in this choice item.
-
-\wxheading{Remarks}
-
-This is implemented for Motif only and always returns $1$ for the other
-platforms.
-
-\membersection{wxChoice::SetColumns}\label{wxchoicesetcolumns}
-
-\func{void}{SetColumns}{\param{int}{ n = 1}}
-
-Sets the number of columns in this choice item.
-
-\wxheading{Parameters}
-
-\docparam{n}{Number of columns.}
-
-\wxheading{Remarks}
-
-This is implemented for Motif only and doesn't do anything under other
-platforms.
-

docs/latex/wx/clasinfo.tex

@@ -1,79 +0,0 @@
-\section{\class{wxClassInfo}}\label{wxclassinfo}
-
-This class stores meta-information about classes. Instances of this class are
-not generally defined directly by an application, but indirectly through use
-of macros such as {\bf DECLARE\_DYNAMIC\_CLASS} and {\bf IMPLEMENT\_DYNAMIC\_CLASS}.
-
-\wxheading{Derived from}
-
-No parent class.
-
-\wxheading{Include files}
-
-<wx/object.h>
-
-\wxheading{See also}
-
-\helpref{Overview}{wxclassinfooverview}, \helpref{wxObject}{wxobject}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxClassInfo::wxClassInfo}\label{wxclassinfoconstr}
-
-\func{}{wxClassInfo}{\param{char* }{className}, \param{char* }{baseClass1}, \param{char* }{baseClass2},
- \param{int}{ size}, \param{wxObjectConstructorFn }{fn}}
-
-Constructs a wxClassInfo object. The supplied macros implicitly construct objects of this
-class, so there is no need to create such objects explicitly in an application.
-
-\membersection{wxClassInfo::CreateObject}
-
-\func{wxObject*}{CreateObject}{\void}
-
-Creates an object of the appropriate kind. Returns NULL if the class has not been declared
-dynamically creatable (typically, it is an abstract class).
-
-\membersection{wxClassInfo::FindClass}
-
-\func{static wxClassInfo *}{FindClass}{\param{char* }{name}}
-
-Finds the wxClassInfo object for a class of the given string name.
-
-\membersection{wxClassInfo::GetBaseClassName1}
-
-\constfunc{char*}{GetBaseClassName1}{\void}
-
-Returns the name of the first base class (NULL if none).
-
-\membersection{wxClassInfo::GetBaseClassName2}
-
-\constfunc{char*}{GetBaseClassName2}{\void}
-
-Returns the name of the second base class (NULL if none).
-
-\membersection{wxClassInfo::GetClassName}
-
-\constfunc{char *}{GetClassName}{\void}
-
-Returns the string form of the class name.
-
-\membersection{wxClassInfo::GetSize}
-
-\constfunc{int}{GetSize}{\void}
-
-Returns the size of the class.
-
-\membersection{wxClassInfo::InitializeClasses}
-
-\func{static void}{InitializeClasses}{\void}
-
-Initializes pointers in the wxClassInfo objects for fast execution
-of IsKindOf. Called in base wxWindows library initialization.
-
-\membersection{wxClassInfo::IsKindOf}\label{wxclassinfoiskindof}
-
-\func{bool}{IsKindOf}{\param{wxClassInfo* }{info}}
-
-Returns TRUE if this class is a kind of (inherits from) the given class.
-
-

docs/latex/wx/classes.tex

@@ -1,326 +0,0 @@
-\chapter{Alphabetical class reference}\label{classref}
-\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
-\setfooter{\thepage}{}{}{}{}{\thepage}%
-
-% NB: the files should be in alphabetic order of the classes documented in
-%     them and *not* in alphabetic order of the file names!
-
-\input accel.tex
-\input activevt.tex
-\input app.tex
-\input array.tex
-\input arrstrng.tex
-\input artprov.tex
-\input autoobj.tex
-\input bitmap.tex
-\input bbutton.tex
-\input bmpdatob.tex
-\input bmphand.tex
-\input boxsizer.tex
-\input brush.tex
-\input strmbfrd.tex
-\input busycurs.tex
-\input busyinfo.tex
-\input button.tex
-\input calclevt.tex
-\input calctrl.tex
-\input caret.tex
-\input checkbox.tex
-\input checklst.tex
-\input choice.tex
-\input clasinfo.tex
-\input ipcclint.tex
-\input clientdc.tex
-\input clientdat.tex
-\input clipbrd.tex
-\input closeevt.tex
-\input cmdlpars.tex
-\input colour.tex
-\input colordlg.tex
-\input combobox.tex
-\input command.tex
-\input cmdevent.tex
-\input cmdproc.tex
-\input conditn.tex
-\input config.tex
-\input ipcconn.tex
-\input cshelp.tex
-\input control.tex
-\input ctrlsub.tex
-\input countstr.tex
-\input critsect.tex
-\input crtslock.tex
-\input csconv.tex
-\input cursor.tex
-\input custdobj.tex
-\input database.tex
-\input dataform.tex
-\input datistrm.tex
-\input dataobj.tex
-\input dobjcomp.tex
-\input dobjsmpl.tex
-\input datostrm.tex
-\input date.tex
-\input datespan.tex
-\input datetime.tex
-\input db.tex
-\input dc.tex
-\input debugcxt.tex
-\input dialog.tex
-\input dialevt.tex
-\input dialup.tex
-\input dir.tex
-\input dirdlg.tex
-\input dirtrav.tex
-\input dllload.tex
-\input docchfrm.tex
-\input docmanag.tex
-\input docmdich.tex
-\input docmdipr.tex
-\input docprfrm.tex
-\input doctempl.tex
-\input document.tex
-\input dragimag.tex
-\input dropevt.tex
-\input dropsrc.tex
-\input droptrgt.tex
-\input dynlib.tex
-\input encconv.tex
-\input eraseevt.tex
-\input event.tex
-\input evthand.tex
-\input expr.tex
-\input ffile.tex
-\input ffilestr.tex
-\input file.tex
-\input fildatob.tex
-\input filedlg.tex
-\input fildrptg.tex
-\input filehist.tex
-\input fileistr.tex
-\input filename.tex
-\input fileostr.tex
-\input filestrm.tex
-\input filesys.tex
-\input filesysh.tex
-\input filetype.tex
-\input fltinstr.tex
-\input fltoutst.tex
-\input fdrepdlg.tex
-\input flexsizr.tex
-\input focusevt.tex
-\input font.tex
-\input fontdlg.tex
-\input fontenum.tex
-\input fontlist.tex
-\input fontmap.tex
-\input frame.tex
-\input fsfile.tex
-\input ftp.tex
-\input gauge.tex
-\input gdiobj.tex
-\input dirctrl.tex
-\input valgen.tex
-\input glcanvas.tex
-\input grid.tex
-\input gridattr.tex
-\input gridedit.tex
-\input gridevt.tex
-\input gridrend.tex
-\input gridtbl.tex
-\input gridsizr.tex
-\input hashmap.tex
-\input hash.tex
-\input helpinst.tex
-\input hprovcnt.tex
-\input helpevt.tex
-\input helpprov.tex
-\input htcell.tex
-\input htcolor.tex
-\input htcontnr.tex
-\input htdcrend.tex
-\input hteasypr.tex
-\input htfilter.tex
-\input hthelpct.tex
-\input hthlpdat.tex
-\input hthlpfrm.tex
-\input htlnkinf.tex
-\input htparser.tex
-\input htprint.tex
-\input httag.tex
-\input httaghnd.tex
-\input httagmod.tex
-\input htwidget.tex
-\input htwindow.tex
-\input htwinprs.tex
-\input htwinhnd.tex
-\input http.tex
-\input icon.tex
-\input iconbndl.tex
-\input iconevt.tex
-\input idleevt.tex
-\input image.tex
-\input imaglist.tex
-\input ilayout.tex
-\input indlgevt.tex
-\input inputstr.tex
-\input ipvaddr.tex
-\input joystick.tex
-\input joyevent.tex
-\input keyevent.tex
-\input layalgor.tex
-\input layout.tex
-\input list.tex
-\input listbox.tex
-\input listctrl.tex
-\input listevt.tex
-\input listitem.tex
-\input listview.tex
-\input locale.tex
-\input log.tex
-\input longlong.tex
-\input mask.tex
-\input maxzevt.tex
-\input mbconv.tex
-\input mbcnvfil.tex
-\input mbcnvut7.tex
-\input mbcnvut8.tex
-\input mdi.tex
-\input memorydc.tex
-\input fs_mem.tex
-\input strmmem.tex
-\input menu.tex
-\input menuevt.tex
-\input menuitem.tex
-\input msgdlg.tex
-\input metafile.tex
-\input mimetype.tex
-\input minifram.tex
-\input module.tex
-\input mcaptevt.tex
-\input mouseevt.tex
-\input moveevt.tex
-\input mltchdlg.tex
-\input mutex.tex
-\input mutexlck.tex
-\input node.tex
-\input notebook.tex
-\input noteevt.tex
-\input nbsizer.tex
-\input notifevt.tex
-\input object.tex
-\input outptstr.tex
-\input pagedlg.tex
-\input paintdc.tex
-\input paintevt.tex
-\input palette.tex
-\input panel.tex
-\input pathlist.tex
-\input pen.tex
-\input plotcurve.tex
-\input plotwindow.tex
-\input point.tex
-\input postscpt.tex
-\input prevwin.tex
-\input print.tex
-\input prvtdrpt.tex
-\input process.tex
-\input procevt.tex
-\input progdlg.tex
-\input protocol.tex
-\input quantize.tex
-\input query.tex
-\input qylayevt.tex
-\input radiobox.tex
-\input radiobut.tex
-\input realpoin.tex
-\input recrdset.tex
-\input rect.tex
-\input regex.tex
-\input region.tex
-\input sashevt.tex
-\input sashlayw.tex
-\input sashwin.tex
-\input screendc.tex
-\input scpdarry.tex
-\input scpdptr.tex
-\input scrolbar.tex
-\input scrolwin.tex
-\input scrolevt.tex
-\input scrlwevt.tex
-\input semaphor.tex
-\input ipcservr.tex
-\input hprovsmp.tex
-\input sngchdlg.tex
-\input snglinst.tex
-\input size.tex
-\input sizeevt.tex
-\input sizer.tex
-\input slider.tex
-\input sckaddr.tex
-\input socket.tex
-\input strmsock.tex
-\input socksrv.tex
-\input spinbutt.tex
-\input spinctrl.tex
-\input spinevt.tex
-\input splash.tex
-\input splitevt.tex
-\input splitter.tex
-\input statbmp.tex
-\input statbox.tex
-\input sbsizer.tex
-\input statline.tex
-\input stattext.tex
-\input statusbr.tex
-\input stopwtch.tex
-\input strmbase.tex
-\input stream.tex
-\input strtotxt.tex
-\input wxstring.tex
-\input strcldat.tex
-\input strlist.tex
-\input tokenizr.tex
-\input sysclevt.tex
-\input sysopt.tex
-\input settings.tex
-\input tabctrl.tex
-\input tabevent.tex
-\input taskbar.tex
-\input tempfile.tex
-\input text.tex
-\input txtdatob.tex
-\input txtdrptg.tex
-\input textdlg.tex
-\input textfile.tex
-\input txtstrm.tex
-\input valtext.tex
-\input thread.tex
-\input time.tex
-\input timer.tex
-\input timespan.tex
-\input tipprov.tex
-\input tipwin.tex
-\input tglbtn.tex
-\input toolbar.tex
-\input tooltip.tex
-\input treectrl.tex
-\input treeevt.tex
-\input treedata.tex
-\input treelay.tex
-\input upduievt.tex
-\input url.tex
-\input validatr.tex
-\input variant.tex
-\input view.tex
-\input wave.tex
-\input window.tex
-\input windowdc.tex
-\input wnddisbl.tex
-\input wizard.tex
-\input wizevt.tex
-\input wizpage.tex
-\input xmlres.tex
-\input xmlresh.tex
-\input zipstrm.tex
-\input strmzlib.tex

docs/latex/wx/clientdat.tex

@@ -1,113 +0,0 @@
-\section{\class{wxClientData}}\label{wxclientdata}
-
-All classes deriving from \helpref{wxEvtHandler}{wxevthandler}
-(such as all controls and \helpref{wxApp}{wxapp})
-can hold arbitrary data which is here referred to as "client data".
-This is useful e.g. for scripting languages which need to handle
-shadow objects for most of wxWindows' classes and which store
-a handle to such a shadow class as client data in that class.
-This data can either be of type void - in which case the data
-{\it container} does not take care of freeing the data again
-or it is of type wxClientData or its derivates. In that case the
-container (e.g. a control) will free the memory itself later.
-Note that you {\it must not} assign both void data and data
-derived from the wxClientData class to a container.
-
-Some controls can hold various items and these controls can
-additionally hold client data for each item. This is the case for
-\helpref{wxChoice}{wxchoice}, \helpref{wxComboBox}{wxcombobox}
-and \helpref{wxListBox}{wxlistbox}. \helpref{wxTreeCtrl}{wxtreectrl}
-has a specialized class \helpref{wxTreeItemData}{wxtreeitemdata}
-for each item in the tree.
-
-If you want to add client data to your own classes, you may
-use the mix-in class \helpref{wxClientDataContainer}{wxclientdatacontainer}.
-
-\wxheading{Include files}
-
-<wx/clntdata.h>
-
-\wxheading{See also}
-
-\helpref{wxEvtHandler}{wxevthandler}, \helpref{wxTreeItemData}{wxtreeitemdata},
-\helpref{wxStringClientData}{wxstringclientdata}, \helpref{wxClientDataContainer}{wxclientdatacontainer}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-
-\membersection{wxClientData::wxClientData}\label{wxclientdatawxclientdata}
-
-\func{}{wxClientData}{\void}
-
-Constructor.
-
-\membersection{wxClientData::\destruct{wxClientData}}\label{wxclientdatadtor}
-
-\func{}{\destruct{wxClientData}}{\void}
-
-Virtual destructor.
-
-\section{\class{wxClientDataContainer}}\label{wxclientdatacontainer}
-
-This class is a mixin that provides storage and management of "client
-data." This data can either be of type void - in which case the data
-{\it container} does not take care of freeing the data again
-or it is of type wxClientData or its derivates. In that case the
-container will free the memory itself later.
-Note that you {\it must not} assign both void data and data
-derived from the wxClientData class to a container.
-
-NOTE: This functionality is currently duplicated in wxEvtHandler in
-order to avoid having more than one vtable in that class heirachy.
-
-\wxheading{See also}
-
-\helpref{wxEvtHandler}{wxevthandler}, \helpref{wxClientData}{wxclientdata}
-
-\wxheading{Derived from}
-
-No base class
-
-\wxheading{Include files}
-
-<clntdata.h>
-
-\wxheading{Data structures}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-
-\membersection{wxClientDataContainer::wxClientDataContainer}\label{wxclientdatacontainerwxclientdatacontainer}
-
-\func{}{wxClientDataContainer}{\void}
-
-
-\membersection{wxClientDataContainer::\destruct{wxClientDataContainer}}\label{wxclientdatacontainerdtor}
-
-\func{}{\destruct{wxClientDataContainer}}{\void}
-
-
-\membersection{wxClientDataContainer::GetClientData}\label{wxclientdatacontainergetclientdata}
-
-\constfunc{void*}{GetClientData}{\void}
-
-Get the untyped client data.
-
-\membersection{wxClientDataContainer::GetClientObject}\label{wxclientdatacontainergetclientobject}
-
-\constfunc{wxClientData*}{GetClientObject}{\void}
-
-Get a pointer to the client data object.
-
-\membersection{wxClientDataContainer::SetClientData}\label{wxclientdatacontainersetclientdata}
-
-\func{void}{SetClientData}{\param{void* }{data}}
-
-Set the untyped client data.
-
-\membersection{wxClientDataContainer::SetClientObject}\label{wxclientdatacontainersetclientobject}
-
-\func{void}{SetClientObject}{\param{wxClientData* }{data}}
-
-Set the client data object. Any previous object will be deleted.
-

docs/latex/wx/clientdc.tex

@@ -1,36 +0,0 @@
-\section{\class{wxClientDC}}\label{wxclientdc}
-
-A wxClientDC must be constructed if an application wishes to paint on the
-client area of a window from outside an {\bf OnPaint} event.
-This should normally be constructed as a temporary stack object; don't store
-a wxClientDC object.
-
-To draw on a window from within {\bf OnPaint}, construct a \helpref{wxPaintDC}{wxpaintdc} object.
-
-To draw on the whole window including decorations, construct a \helpref{wxWindowDC}{wxwindowdc} object
-(Windows only).
-
-\wxheading{Derived from}
-
-\helpref{wxWindowDC}{wxwindowdc}\\
-\helpref{wxDC}{wxdc}
-
-\wxheading{Include files}
-
-<wx/dcclient.h>
-
-\wxheading{See also}
-
-\helpref{wxDC}{wxdc}, \helpref{wxMemoryDC}{wxmemorydc}, \helpref{wxPaintDC}{wxpaintdc},\rtfsp
-\helpref{wxWindowDC}{wxwindowdc}, \helpref{wxScreenDC}{wxscreendc}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxClientDC::wxClientDC}
-
-\func{}{wxClientDC}{\param{wxWindow*}{ window}}
-
-Constructor. Pass a pointer to the window on which you wish to paint.
-
-
-

docs/latex/wx/clipbrd.tex

@@ -1,156 +0,0 @@
-\section{\class{wxClipboard}}\label{wxclipboard}
-
-A class for manipulating the clipboard. Note that this is not compatible with the
-clipboard class from wxWindows 1.xx, which has the same name but a different implementation.
-
-To use the clipboard, you call member functions of the global {\bf wxTheClipboard} object.
-
-See also the \helpref{wxDataObject overview}{wxdataobjectoverview} for further information.
-
-Call \helpref{wxClipboard::Open}{wxclipboardopen} to get ownership of the clipboard. If this operation returns TRUE, you
-now own the clipboard. Call \helpref{wxClipboard::SetData}{wxclipboardsetdata} to put data
-on the clipboard, or \helpref{wxClipboard::GetData}{wxclipboardgetdata} to
-retrieve data from the clipboard. Call \helpref{wxClipboard::Close}{wxclipboardclose} to close
-the clipboard and relinquish ownership. You should keep the clipboard open only momentarily.
-
-For example:
-
-\begin{verbatim}
-  // Write some text to the clipboard
-  if (wxTheClipboard->Open())
-  {
-    // This data objects are held by the clipboard, 
-    // so do not delete them in the app.
-    wxTheClipboard->SetData( new wxTextDataObject("Some text") );
-    wxTheClipboard->Close();
-  }
-
-  // Read some text
-  if (wxTheClipboard->Open())
-  {
-    if (wxTheClipboard->IsSupported( wxDF_TEXT ))
-    {
-      wxTextDataObject data;
-      wxTheClipboard->GetData( data );
-      wxMessageBox( data.GetText() );
-    }  
-    wxTheClipboard->Close();
-  }
-\end{verbatim}
-
-\wxheading{Derived from}
-
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/clipbrd.h>
-
-\wxheading{See also}
-
-\helpref{Drag and drop overview}{wxdndoverview}, \helpref{wxDataObject}{wxdataobject}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxClipboard::wxClipboard}
-
-\func{}{wxClipboard}{\void}
-
-Constructor.
-
-\membersection{wxClipboard::\destruct{wxClipboard}}
-
-\func{}{\destruct{wxClipboard}}{\void}
-
-Destructor.
-
-\membersection{wxClipboard::AddData}\label{wxclipboardadddata}
-
-\func{bool}{AddData}{\param{wxDataObject*}{ data}}
-
-Call this function to add the data object to the clipboard. You may call
-this function repeatedly after having cleared the clipboard using \helpref{wxClipboard::Clear}{wxclipboardclear}.
-
-After this function has been called, the clipboard owns the data, so do not delete
-the data explicitly.
-
-\wxheading{See also}
-
-\helpref{wxClipboard::SetData}{wxclipboardsetdata}
-
-\membersection{wxClipboard::Clear}\label{wxclipboardclear}
-
-\func{void}{Clear}{\void}
-
-Clears the global clipboard object and the system's clipboard if possible.
-
-\membersection{wxClipboard::Close}\label{wxclipboardclose}
-
-\func{bool}{Close}{\void}
-
-Call this function to close the clipboard, having opened it with \helpref{wxClipboard::Open}{wxclipboardopen}.
-
-\membersection{wxClipboard::Flush}\label{wxclipboardflush}
-
-\func{bool}{Flush}{\void}
-
-Flushes the clipboard: this means that the data which is currently on
-clipboard will stay available even after the application exits (possibly
-eating memory), otherwise the clipboard will be emptied on exit.
-Returns FALSE if the operation is unsuccesful for any reason.
-
-\membersection{wxClipboard::GetData}\label{wxclipboardgetdata}
-
-\func{bool}{GetData}{\param{wxDataObject\&}{ data}}
-
-Call this function to fill {\it data} with data on the clipboard, if available in the required
-format. Returns TRUE on success.
-
-\membersection{wxClipboard::IsOpened}\label{wxclipboardisopened}
-
-\constfunc{bool}{IsOpened}{\void}
-
-Returns TRUE if the clipboard has been opened.
-
-\membersection{wxClipboard::IsSupported}\label{wxclipboardissupported}
-
-\func{bool}{IsSupported}{\param{const wxDataFormat\&}{ format}}
-
-Returns TRUE if the format of the given data object is available on the clipboard.
-
-\membersection{wxClipboard::Open}\label{wxclipboardopen}
-
-\func{bool}{Open}{\void}
-
-Call this function to open the clipboard before calling \helpref{wxClipboard::SetData}{wxclipboardsetdata} 
-and \helpref{wxClipboard::GetData}{wxclipboardgetdata}.
-
-Call \helpref{wxClipboard::Close}{wxclipboardclose} when you have finished with the clipboard. You
-should keep the clipboard open for only a very short time.
-
-Returns TRUE on success. This should be tested (as in the sample shown above).
-
-\membersection{wxClipboard::SetData}\label{wxclipboardsetdata}
-
-\func{bool}{SetData}{\param{wxDataObject*}{ data}}
-
-Call this function to set the data object to the clipboard. This function will
-clear all previous contents in the clipboard, so calling it several times
-does not make any sense.
-
-After this function has been called, the clipboard owns the data, so do not delete
-the data explicitly.
-
-\wxheading{See also}
-
-\helpref{wxClipboard::AddData}{wxclipboardadddata}
-
-\membersection{wxClipboard::UsePrimarySelection}\label{wxclipboarduseprimary}
-
-\func{void}{UsePrimarySelection}{\param{bool}{ primary = TRUE}}
-
-On platforms supporting it (currently only GTK), selects the so called
-PRIMARY SELECTION as the clipboard as opposed to the normal clipboard,
-if {\it primary} is TRUE.
-
-

docs/latex/wx/closeevt.tex

@@ -1,113 +0,0 @@
-\section{\class{wxCloseEvent}}\label{wxcloseevent}
-
-This event class contains information about window and session close events.
-
-The handler function for EVT\_CLOSE is called when the user has tried to close a a frame
-or dialog box using the window manager (X) or system menu (Windows). It can
-also be invoked by the application itself programmatically, for example by
-calling the \helpref{wxWindow::Close}{wxwindowclose} function.
-
-You should check whether the application is forcing the deletion of the window
-using \helpref{wxCloseEvent::CanVeto}{wxcloseeventcanveto}. If this is {\tt FALSE},
-you {\it must} destroy the window using \helpref{wxWindow::Destroy}{wxwindowdestroy}.
-If the return value is TRUE, it is up to you whether you respond by destroying the window.
-
-If you don't destroy the window, you should call \helpref{wxCloseEvent::Veto}{wxcloseeventveto} to
-let the calling code know that you did not destroy the window. This allows the \helpref{wxWindow::Close}{wxwindowclose} function
-to return {\tt TRUE} or {\tt FALSE} depending on whether the close instruction was honoured or not.
-
-\wxheading{Derived from}
-
-\helpref{wxEvent}{wxevent}
-
-\wxheading{Include files}
-
-<wx/event.h>
-
-\wxheading{Event table macros}
-
-To process a close event, use these event handler macros to direct input to member
-functions that take a wxCloseEvent argument.
-
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_CLOSE(func)}}{Process a close event, supplying the member function. This
-event applies to wxFrame and wxDialog classes.}
-\twocolitem{{\bf EVT\_QUERY\_END\_SESSION(func)}}{Process a query end session event, supplying the member function.
-This event applies to wxApp only.}
-\twocolitem{{\bf EVT\_END\_SESSION(func)}}{Process an end session event, supplying the member function.
-This event applies to wxApp only.}
-\end{twocollist}%
-
-\wxheading{See also}
-
-\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
-\helpref{wxApp::OnQueryEndSession}{wxapponqueryendsession},\rtfsp
-%% GD: OnXXX functions are not documented
-%%\helpref{wxApp::OnEndSession}{wxapponendsession},\rtfsp
-\helpref{Window deletion overview}{windowdeletionoverview}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCloseEvent::wxCloseEvent}
-
-\func{}{wxCloseEvent}{\param{WXTYPE}{ commandEventType = 0}, \param{int}{ id = 0}}
-
-Constructor.
-
-\membersection{wxCloseEvent::CanVeto}\label{wxcloseeventcanveto}
-
-\func{bool}{CanVeto}{\void}
-
-Returns TRUE if you can veto a system shutdown or a window close event.
-Vetoing a window close event is not possible if the calling code wishes to
-force the application to exit, and so this function must be called to check this.
-
-\membersection{wxCloseEvent::GetLoggingOff}\label{wxcloseeventgetloggingoff}
-
-\constfunc{bool}{GetLoggingOff}{\void}
-
-Returns TRUE if the user is logging off.
-
-\membersection{wxCloseEvent::GetSessionEnding}\label{wxcloseeventgetsessionending}
-
-\constfunc{bool}{GetSessionEnding}{\void}
-
-Returns TRUE if the session is ending.
-
-\membersection{wxCloseEvent::GetForce}\label{wxcloseeventgetforce}
-
-\constfunc{bool}{GetForce}{\void}
-
-Returns TRUE if the application wishes to force the window to close.
-This will shortly be obsolete, replaced by CanVeto.
-
-\membersection{wxCloseEvent::SetCanVeto}\label{wxcloseeventsetcanveto}
-
-\func{void}{SetCanVeto}{\param{bool}{ canVeto}}
-
-Sets the 'can veto' flag.
-
-\membersection{wxCloseEvent::SetForce}\label{wxcloseeventsetforce}
-
-\constfunc{void}{SetForce}{\param{bool}{ force}}
-
-Sets the 'force' flag.
-
-\membersection{wxCloseEvent::SetLoggingOff}\label{wxcloseeventsetloggingoff}
-
-\constfunc{void}{SetLoggingOff}{\param{bool}{ loggingOff}}
-
-Sets the 'logging off' flag.
-
-\membersection{wxCloseEvent::Veto}\label{wxcloseeventveto}
-
-\func{void}{Veto}{\param{bool}{ veto = TRUE}}
-
-Call this from your event handler to veto a system shutdown or to signal
-to the calling application that a window close did not happen.
-
-You can only veto a shutdown if \helpref{wxCloseEvent::CanVeto}{wxcloseeventcanveto} returns
-TRUE.
-
-

docs/latex/wx/cmdevent.tex

@@ -1,206 +0,0 @@
-\section{\class{wxCommandEvent}}\label{wxcommandevent}
-
-This event class contains information about command events, which originate from a variety of
-simple controls. More complex controls, such as \helpref{wxTreeCtrl}{wxtreectrl}, have separate command event classes.
-
-\wxheading{Derived from}
-
-\helpref{wxEvent}{wxevent}
-
-\wxheading{Include files}
-
-<wx/event.h>
-
-\wxheading{Event table macros}
-
-To process a menu command event, use these event handler macros to direct input to member
-functions that take a wxCommandEvent argument.
-
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_COMMAND(id, event, func)}}{Process a command, supplying the window identifier,
-command event identifier, and member function.}
-\twocolitem{{\bf EVT\_COMMAND\_RANGE(id1, id2, event, func)}}{Process a command for a range
-of window identifiers, supplying the minimum and maximum window identifiers,
-command event identifier, and member function.}
-\twocolitem{{\bf EVT\_BUTTON(id, func)}}{Process a wxEVT\_COMMAND\_BUTTON\_CLICKED command,
-which is generated by a wxButton control.}
-\twocolitem{{\bf EVT\_CHECKBOX(id, func)}}{Process a wxEVT\_COMMAND\_CHECKBOX\_CLICKED command,
-which is generated by a wxCheckBox control.}
-\twocolitem{{\bf EVT\_CHOICE(id, func)}}{Process a wxEVT\_COMMAND\_CHOICE\_SELECTED command,
-which is generated by a wxChoice control.}
-\twocolitem{{\bf EVT\_LISTBOX(id, func)}}{Process a wxEVT\_COMMAND\_LISTBOX\_SELECTED command,
-which is generated by a wxListBox control.}
-\twocolitem{{\bf EVT\_LISTBOX\_DCLICK(id, func)}}{Process a wxEVT\_COMMAND\_LISTBOX\_DOUBLECLICKED command,
-which is generated by a wxListBox control.}
-\twocolitem{{\bf EVT\_TEXT(id, func)}}{Process a wxEVT\_COMMAND\_TEXT\_UPDATED command,
-which is generated by a wxTextCtrl control.}
-\twocolitem{{\bf EVT\_TEXT\_ENTER(id, func)}}{Process a wxEVT\_COMMAND\_TEXT\_ENTER command,
-which is generated by a wxTextCtrl control. Note that you must use
-wxTE\_PROCESS\_ENTER flag when creating the control if you want it to generate
-such events.}
-\twocolitem{{\bf EVT\_TEXT\_MAXLEN(id, func)}}{Process a wxEVT\_COMMAND\_TEXT\_MAXLEN command,
-which is generated by a wxTextCtrl control when the user tries to enter more
-characters into it than the limit previously set with 
-\helpref{SetMaxLength}{wxtextctrlsetmaxlength}.}
-\twocolitem{{\bf EVT\_MENU(id, func)}}{Process a wxEVT\_COMMAND\_MENU\_SELECTED command,
-which is generated by a menu item.}
-\twocolitem{{\bf EVT\_MENU\_RANGE(id1, id2, func)}}{Process a wxEVT\_COMMAND\_MENU\_RANGE command,
-which is generated by a range of menu items.}
-\twocolitem{{\bf EVT\_CONTEXT\_MENU(func)}}{Process the event generated
-when the user has requested a popup menu to appear by pressing a special
-keyboard key (under Windows) or by right clicking the mouse.}
-\twocolitem{{\bf EVT\_SLIDER(id, func)}}{Process a wxEVT\_COMMAND\_SLIDER\_UPDATED command,
-which is generated by a wxSlider control.}
-\twocolitem{{\bf EVT\_RADIOBOX(id, func)}}{Process a wxEVT\_COMMAND\_RADIOBOX\_SELECTED command,
-which is generated by a wxRadioBox control.}
-\twocolitem{{\bf EVT\_RADIOBUTTON(id, func)}}{Process a wxEVT\_COMMAND\_RADIOBUTTON\_SELECTED command,
-which is generated by a wxRadioButton control.}
-\twocolitem{{\bf EVT\_SCROLLBAR(id, func)}}{Process a wxEVT\_COMMAND\_SCROLLBAR\_UPDATED command,
-which is generated by a wxScrollBar control. This is provided for compatibility only;
-more specific scrollbar event macros should be used instead (see \helpref{wxScrollEvent}{wxscrollevent}).}
-\twocolitem{{\bf EVT\_COMBOBOX(id, func)}}{Process a wxEVT\_COMMAND\_COMBOBOX\_SELECTED command,
-which is generated by a wxComboBox control.}
-\twocolitem{{\bf EVT\_TOOL(id, func)}}{Process a wxEVT\_COMMAND\_TOOL\_CLICKED event
-(a synonym for wxEVT\_COMMAND\_MENU\_SELECTED). Pass the id of the tool.}
-\twocolitem{{\bf EVT\_TOOL\_RANGE(id1, id2, func)}}{Process a wxEVT\_COMMAND\_TOOL\_CLICKED event
-for a range id identifiers. Pass the ids of the tools.}
-\twocolitem{{\bf EVT\_TOOL\_RCLICKED(id, func)}}{Process a wxEVT\_COMMAND\_TOOL\_RCLICKED event.
-Pass the id of the tool.}
-\twocolitem{{\bf EVT\_TOOL\_RCLICKED\_RANGE(id1, id2, func)}}{Process a wxEVT\_COMMAND\_TOOL\_RCLICKED event
-for a range of ids. Pass the ids of the tools.}
-\twocolitem{{\bf EVT\_TOOL\_ENTER(id, func)}}{Process a wxEVT\_COMMAND\_TOOL\_ENTER event.
-Pass the id of the toolbar itself. The value of wxCommandEvent::GetSelection is the tool id, or -1 if the mouse cursor has moved off a tool.}
-\twocolitem{{\bf EVT\_COMMAND\_LEFT\_CLICK(id, func)}}{Process a wxEVT\_COMMAND\_LEFT\_CLICK command,
-which is generated by a control (Windows 95 and NT only).}
-\twocolitem{{\bf EVT\_COMMAND\_LEFT\_DCLICK(id, func)}}{Process a wxEVT\_COMMAND\_LEFT\_DCLICK command,
-which is generated by a control (Windows 95 and NT only).}
-\twocolitem{{\bf EVT\_COMMAND\_RIGHT\_CLICK(id, func)}}{Process a wxEVT\_COMMAND\_RIGHT\_CLICK command,
-which is generated by a control (Windows 95 and NT only).}
-\twocolitem{{\bf EVT\_COMMAND\_SET\_FOCUS(id, func)}}{Process a wxEVT\_COMMAND\_SET\_FOCUS command,
-which is generated by a control (Windows 95 and NT only).}
-\twocolitem{{\bf EVT\_COMMAND\_KILL\_FOCUS(id, func)}}{Process a wxEVT\_COMMAND\_KILL\_FOCUS command,
-which is generated by a control (Windows 95 and NT only).}
-\twocolitem{{\bf EVT\_COMMAND\_ENTER(id, func)}}{Process a wxEVT\_COMMAND\_ENTER command,
-which is generated by a control.}
-\end{twocollist}%
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCommandEvent::m\_clientData}
-
-\member{void*}{m\_clientData}
-
-Contains a pointer to client data for listboxes and choices, if the event
-was a selection. Beware, this is not implemented anyway...
-
-\membersection{wxCommandEvent::m\_commandInt}
-
-\member{int}{m\_commandInt}
-
-Contains an integer identifier corresponding to a listbox, choice or
-radiobox selection (only if the event was a selection, not a
-deselection), or a boolean value representing the value of a checkbox.
-
-\membersection{wxCommandEvent::m\_commandString}
-
-\member{wxString}{m\_commandString}
-
-Contains a string corresponding to a listbox or choice selection.
-
-\membersection{wxCommandEvent::m\_extraLong}
-
-\member{long}{m\_extraLong}
-
-Extra information. If the event comes from a listbox selection, it is
-a boolean determining whether the event was a selection (TRUE) or a
-deselection (FALSE). A listbox deselection only occurs for
-multiple-selection boxes, and in this case the index and string values
-are indeterminate and the listbox must be examined by the application.
-
-\membersection{wxCommandEvent::wxCommandEvent}
-
-\func{}{wxCommandEvent}{\param{WXTYPE}{ commandEventType = 0}, \param{int}{ id = 0}}
-
-Constructor.
-
-\membersection{wxCommandEvent::Checked}
-
-\constfunc{bool}{Checked}{\void}
-
-Deprecated, use \helpref{IsChecked}{wxcommandeventischecked} instead.
-
-\membersection{wxCommandEvent::GetClientData}
-
-\func{void*}{GetClientData}{\void}
-
-Returns client data pointer for a listbox or choice selection event
-(not valid for a deselection).
-
-\membersection{wxCommandEvent::GetExtraLong}
-
-\func{long}{GetExtraLong}{\void}
-
-Returns the {\bf m\_extraLong} member.
-
-\membersection{wxCommandEvent::GetInt}
-
-\func{int}{GetInt}{\void}
-
-Returns the {\bf m\_commandInt} member.
-
-\membersection{wxCommandEvent::GetSelection}
-
-\func{int}{GetSelection}{\void}
-
-Returns item index for a listbox or choice selection event (not valid for
-a deselection).
-
-\membersection{wxCommandEvent::GetString}
-
-\func{wxString}{GetString}{\void}
-
-Returns item string for a listbox or choice selection event (not valid for
-a deselection).
-
-\membersection{wxCommandEvent::IsChecked}\label{wxcommandeventischecked}
-
-\constfunc{bool}{IsChecked}{\void}
-
-This method can be used with checkbox and menu events: for the checkboxes, the
-method returns {\tt TRUE} for a selection event and {\tt FALSE} for a
-deselection one. For the menu events, this method indicates if the menu item
-just has become checked or unchecked (and thus only makes sense for checkable
-menu items).
-
-\membersection{wxCommandEvent::IsSelection}
-
-\func{bool}{IsSelection}{\void}
-
-For a listbox or choice event, returns TRUE if it is a selection, FALSE if it
-is a deselection.
-
-\membersection{wxCommandEvent::SetClientData}
-
-\func{void}{SetClientData}{\param{void*}{ clientData}}
-
-Sets the client data for this event.
-
-\membersection{wxCommandEvent::SetExtraLong}
-
-\func{void}{SetExtraLong}{\param{int}{ extraLong}}
-
-Sets the {\bf m\_extraLong} member.
-
-\membersection{wxCommandEvent::SetInt}
-
-\func{void}{SetInt}{\param{int}{ intCommand}}
-
-Sets the {\bf m\_commandInt} member.
-
-\membersection{wxCommandEvent::SetString}
-
-\func{void}{SetString}{\param{const wxString\&}{ string}}
-
-Sets the {\bf m\_commandString} member.
-

docs/latex/wx/cmdlpars.tex

@@ -1,487 +0,0 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% Name:        cmdlpars.tex
-%% Purpose:     wxCmdLineParser documentation
-%% Author:      Vadim Zeitlin
-%% Modified by:
-%% Created:     27.03.00
-%% RCS-ID:      $Id$
-%% Copyright:   (c) Vadim Zeitlin
-%% License:     wxWindows license
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-\section{\class{wxCmdLineParser}}\label{wxcmdlineparser}
-
-wxCmdLineParser is a class for parsing command line.
-
-It has the following features:
-
-\begin{enumerate}\itemsep=0pt
-\item distinguishes options, switches and parameters; allows option grouping
-\item allows both short and long options
-\item automatically generates the usage message from the command line description
-\item does type checks on the options values (number, date, $\ldots$).
-\end{enumerate}
-
-To use it you should follow these steps:
-
-\begin{enumerate}\itemsep=0pt
-\item \helpref{construct}{wxcmdlineparserconstruction} an object of this class
-giving it the command line to parse and optionally its description or use 
-{\tt AddXXX()} functions later
-\item call {\tt Parse()}
-\item use {\tt Found()} to retrieve the results
-\end{enumerate}
-
-In the documentation below the following terminology is used:
-
-\begin{twocollist}\itemsep=0pt
-\twocolitem{switch}{This is a boolean option which can be given or not, but
-which doesn't have any value. We use the word switch to distinguish such boolean
-options from more generic options like those described below. For example, 
-{\tt -v} might be a switch meaning "enable verbose mode".}
-\twocolitem{option}{Option for us here is something which comes with a value 0
-unlike a switch. For example, {\tt -o:filename} might be an option which allows
-to specify the name of the output file.}
-\twocolitem{parameter}{This is a required program argument.}
-\end{twocollist}
-
-\wxheading{Derived from}
-
-No base class
-
-\wxheading{Include files}
-
-<wx/cmdline.h>
-
-\wxheading{Constants}
-
-The structure wxCmdLineEntryDesc is used to describe the one command
-line switch, option or parameter. An array of such structures should be passed
-to \helpref{SetDesc()}{wxcmdlineparsersetdesc}. Also, the meanings of parameters
-of the {\tt AddXXX()} functions are the same as of the corresponding fields in
-this structure:
-
-\begin{verbatim}
-struct wxCmdLineEntryDesc
-{
-    wxCmdLineEntryType kind;
-    const wxChar *shortName;
-    const wxChar *longName;
-    const wxChar *description;
-    wxCmdLineParamType type;
-    int flags;
-};
-\end{verbatim}
-
-The type of a command line entity is in the {\tt kind} field and may be one of
-the following constants:
-
-{\small%
-\begin{verbatim}
-enum wxCmdLineEntryType
-{
-    wxCMD_LINE_SWITCH,
-    wxCMD_LINE_OPTION,
-    wxCMD_LINE_PARAM,
-    wxCMD_LINE_NONE         // use this to terminate the list
-}
-\end{verbatim}
-}
-
-The field {\tt shortName} is the usual, short, name of the switch or the option.
-{\tt longName} is the corresponding long name or NULL if the option has no long
-name. Both of these fields are unused for the parameters. Both the short and
-long option names can contain only letters, digits and the underscores.
-
-{\tt description} is used by the \helpref{Usage()}{wxcmdlineparserusage} method
-to construct a help message explaining the syntax of the program.
-
-The possible values of {\tt type} which specifies the type of the value accepted
-by an option or parameter are:
-
-{\small%
-\begin{verbatim}
-enum wxCmdLineParamType
-{
-    wxCMD_LINE_VAL_STRING,  // default
-    wxCMD_LINE_VAL_NUMBER,
-    wxCMD_LINE_VAL_DATE,
-    wxCMD_LINE_VAL_NONE
-}
-\end{verbatim}
-}
-
-Finally, the {\tt flags} field is a combination of the following bit masks:
-
-{\small%
-\begin{verbatim}
-enum
-{
-    wxCMD_LINE_OPTION_MANDATORY = 0x01, // this option must be given
-    wxCMD_LINE_PARAM_OPTIONAL   = 0x02, // the parameter may be omitted
-    wxCMD_LINE_PARAM_MULTIPLE   = 0x04, // the parameter may be repeated
-    wxCMD_LINE_OPTION_HELP      = 0x08, // this option is a help request
-    wxCMD_LINE_NEEDS_SEPARATOR  = 0x10, // must have sep before the value
-}
-\end{verbatim}
-}
-
-Notice that by default (i.e. if flags are just $0$), options are optional (sic)
-and each call to \helpref{AddParam()}{wxcmdlineparseraddparam} allows one more
-parameter - this may be changed by giving non-default flags to it, i.e. use 
-{\tt wxCMD\_LINE\_OPTION\_MANDATORY} to require that the option is given and 
-{\tt wxCMD\_LINE\_PARAM\_OPTIONAL} to make a parameter optional. Also, 
-{\tt wxCMD\_LINE\_PARAM\_MULTIPLE} may be specified if the programs accepts a
-variable number of parameters - but it only can be given for the last parameter
-in the command line description. If you use this flag, you will probably need to
-use \helpref{GetParamCount}{wxcmdlineparsergetparamcount} to retrieve the number
-of parameters effectively specified after calling 
-\helpref{Parse}{wxcmdlineparserparse}.
-
-The last flag {\tt wxCMD\_LINE\_NEEDS\_SEPARATOR} can be specified to require a
-separator (either a colon, an equal sign or white space) between the option
-name and its value. By default, no separator is required.
-
-\wxheading{See also}
-
-\helpref{wxApp::argc}{wxappargc} and \helpref{wxApp::argv}{wxappargv}\\
-console sample
-
-%%%%%%%%%%%%% Methods by group %%%%%%%%%%%%%
-\latexignore{\rtfignore{\wxheading{Function groups}}}
-
-\membersection{Construction}\label{wxcmdlineparserconstruction}
-
-Before \helpref{Parse}{wxcmdlineparserparse} can be called, the command line
-parser object must have the command line to parse and also the rules saying
-which switches, options and parameters are valid - this is called command line
-description in what follows.
-
-You have complete freedom of choice as to when specify the required information,
-the only restriction is that it must be done before calling 
-\helpref{Parse}{wxcmdlineparserparse}.
-
-To specify the command line to parse you may use either one of constructors
-accepting it (\helpref{wxCmdLineParser(argc, argv)}{wxcmdlineparserwxcmdlineparserargc} or 
-\helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserdescargc} usually) or,
-if you use \helpref{the default constructor}{wxcmdlineparserwxcmdlineparserdef},
-you can do it later by calling 
-\helpref{SetCmdLine}{wxcmdlineparsersetcmdlineargc}.
-
-The same holds for command line description: it can be specified either in
-the constructor (\helpref{without command line}{wxcmdlineparserwxcmdlineparserdesc} or 
-\helpref{together with it}{wxcmdlineparserwxcmdlineparserdescargc}) or
-constructed later using either \helpref{SetDesc}{wxcmdlineparsersetdesc} or
-combination of \helpref{AddSwitch}{wxcmdlineparseraddswitch}, 
-\helpref{AddOption}{wxcmdlineparseraddoption} and 
-\helpref{AddParam}{wxcmdlineparseraddparam} methods.
-
-Using constructors or \helpref{SetDesc}{wxcmdlineparsersetdesc} uses a (usually 
-{\tt const static}) table containing the command line description. If you want
-to decide which options to accept during the run-time, using one of the 
-{\tt AddXXX()} functions above might be preferable.
-
-\membersection{Customization}\label{wxcmdlineparsercustomization}
-
-wxCmdLineParser has several global options which may be changed by the
-application. All of the functions described in this section should be called
-before \helpref{Parse}{wxcmdlineparserparse}.
-
-First global option is the support for long (also known as GNU-style) options.
-The long options are the ones which start with two dashes ({\tt "--"}) and look
-like this: {\tt --verbose}, i.e. they generally are complete words and not some
-abbreviations of them. As long options are used by more and more applications,
-they are enabled by default, but may be disabled with 
-\helpref{DisableLongOptions}{wxcmdlineparserdisablelongoptions}.
-
-Another global option is the set of characters which may be used to start an
-option (otherwise, the word on the command line is assumed to be a parameter).
-Under Unix, {\tt '-'} is always used, but Windows has at least two common
-choices for this: {\tt '-'} and {\tt '/'}. Some programs also use {\tt '+'}.
-The default is to use what suits most the current platform, but may be changed
-with \helpref{SetSwitchChars}{wxcmdlineparsersetswitchchars} method.
-
-Finally, \helpref{SetLogo}{wxcmdlineparsersetlogo} can be used to show some
-application-specific text before the explanation given by 
-\helpref{Usage}{wxcmdlineparserusage} function.
-
-\membersection{Parsing command line}\label{wxcmdlineparserparsing}
-
-After the command line description was constructed and the desired options were
-set, you can finally call \helpref{Parse}{wxcmdlineparserparse} method.
-It returns $0$ if the command line was correct and was parsed, $-1$ if the help
-option was specified (this is a separate case as, normally, the program will
-terminate after this) or a positive number if there was an error during the
-command line parsing.
-
-In the latter case, the appropriate error message and usage information are
-logged by wxCmdLineParser itself using the standard wxWindows logging functions.
-
-\membersection{Getting results}\label{wxcmdlineparsergettingresults}
-
-After calling \helpref{Parse}{wxcmdlineparserparse} (and if it returned $0$),
-you may access the results of parsing using one of overloaded {\tt Found()}
-methods.
-
-For a simple switch, you will simply call 
-\helpref{Found}{wxcmdlineparserfoundswitch} to determine if the switch was given
-or not, for an option or a parameter, you will call a version of {\tt Found()} 
-which also returns the associated value in the provided variable. All 
-{\tt Found()} functions return TRUE if the switch or option were found in the
-command line or FALSE if they were not specified.
-
-%%%%%%%%%%%%% Methods in alphabetic order %%%%%%%%%%%%%
-\helponly{\insertatlevel{2}{
-
-\wxheading{Members}
-
-}}
-
-\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserdef}
-
-\func{}{wxCmdLineParser}{\void}
-
-Default constructor. You must use 
-\helpref{SetCmdLine}{wxcmdlineparsersetcmdlineargc} later.
-
-\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserargc}
-
-\func{}{wxCmdLineParser}{\param{int }{argc}, \param{char** }{argv}}
-
-Constructor specifies the command line to parse. This is the traditional
-(Unix) command line format. The parameters {\it argc} and {\it argv} have the
-same meaning as for {\tt main()} function.
-
-\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserstr}
-
-\func{}{wxCmdLineParser}{\param{const wxString\& }{cmdline}}
-
-Constructor specifies the command line to parse in Windows format. The parameter 
-{\it cmdline} has the same meaning as the corresponding parameter of 
-{\tt WinMain()}.
-
-\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserdesc}
-
-\func{}{wxCmdLineParser}{\param{const wxCmdLineEntryDesc* }{desc}}
-
-Same as \helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserdef}, but also
-specifies the \helpref{command line description}{wxcmdlineparsersetdesc}.
-
-\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserdescargc}
-
-\func{}{wxCmdLineParser}{\param{const wxCmdLineEntryDesc* }{desc}, \param{int }{argc}, \param{char** }{argv}}
-
-Same as \helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserargc}, but also
-specifies the \helpref{command line description}{wxcmdlineparsersetdesc}.
-
-\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserdescstr}
-
-\func{}{wxCmdLineParser}{\param{const wxCmdLineEntryDesc* }{desc}, \param{const wxString\& }{cmdline}}
-
-Same as \helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserstr}, but also
-specifies the \helpref{command line description}{wxcmdlineparsersetdesc}.
-
-\membersection{wxCmdLineParser::ConvertStringToArgs}\label{wxcmdlineparserconvertstringtoargs}
-
-\func{static wxArrayString}{ConvertStringToArgs}{\param{const wxChar }{*cmdline}}
-
-Breaks down the string containing the full command line in words. The words are
-separated by whitespace. The quotes can be used in the input string to quote
-the white space and the back slashes can be used to quote the quotes.
-
-\membersection{wxCmdLineParser::SetCmdLine}\label{wxcmdlineparsersetcmdlineargc}
-
-\func{void}{SetCmdLine}{\param{int }{argc}, \param{char** }{argv}}
-
-Set command line to parse after using one of the constructors which don't do it.
-
-\wxheading{See also}
-
-\helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserargc}
-
-\membersection{wxCmdLineParser::SetCmdLine}\label{wxcmdlineparsersetcmdlinestr}
-
-\func{void}{SetCmdLine}{\param{const wxString\& }{cmdline}}
-
-Set command line to parse after using one of the constructors which don't do it.
-
-\wxheading{See also}
-
-\helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserstr}
-
-\membersection{wxCmdLineParser::\destruct{wxCmdLineParser}}\label{wxcmdlineparserdtor}
-
-\func{}{\destruct{wxCmdLineParser}}{\void}
-
-Frees resources allocated by the object.
-
-{\bf NB:} destructor is not virtual, don't use this class polymorphically.
-
-\membersection{wxCmdLineParser::SetSwitchChars}\label{wxcmdlineparsersetswitchchars}
-
-\func{void}{SetSwitchChars}{\param{const wxString\& }{switchChars}}
-
-{\it switchChars} contains all characters with which an option or switch may
-start. Default is {\tt "-"} for Unix, {\tt "-/"} for Windows.
-
-\membersection{wxCmdLineParser::EnableLongOptions}\label{wxcmdlineparserenablelongoptions}
-
-\func{void}{EnableLongOptions}{\param{bool }{enable = TRUE}}
-
-Enable or disable support for the long options.
-
-As long options are not (yet) POSIX-compliant, this option allows to disable
-them.
-
-\wxheading{See also}
-
-\helpref{Customization}{wxcmdlineparsercustomization} and \helpref{AreLongOptionsEnabled}{wxcmdlineparserarelongoptionsenabled}
-
-\membersection{wxCmdLineParser::DisableLongOptions}\label{wxcmdlineparserdisablelongoptions}
-
-\func{void}{DisableLongOptions}{\void}
-
-Identical to \helpref{EnableLongOptions(FALSE)}{wxcmdlineparserenablelongoptions}.
-
-\membersection{wxCmdLineParser::AreLongOptionsEnabled}\label{wxcmdlineparserarelongoptionsenabled}
-
-\func{bool}{AreLongOptionsEnabled}{\void}
-
-Returns TRUE if long options are enabled, otherwise FALSE.
-
-\wxheading{See also}
-
-\helpref{EnableLongOptions}{wxcmdlineparserenablelongoptions}
-
-\membersection{wxCmdLineParser::SetLogo}\label{wxcmdlineparsersetlogo}
-
-\func{void}{SetLogo}{\param{const wxString\& }{logo}}
-
-{\it logo} is some extra text which will be shown by 
-\helpref{Usage}{wxcmdlineparserusage} method.
-
-\membersection{wxCmdLineParser::SetDesc}\label{wxcmdlineparsersetdesc}
-
-\func{void}{SetDesc}{\param{const wxCmdLineEntryDesc* }{desc}}
-
-Construct the command line description
-
-Take the command line description from the wxCMD\_LINE\_NONE terminated table.
-
-Example of usage:
-
-\begin{verbatim}
-static const wxCmdLineEntryDesc cmdLineDesc[] =
-{
-    { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
-    { wxCMD_LINE_SWITCH, "q", "quiet",   "be quiet" },
-
-    { wxCMD_LINE_OPTION, "o", "output",  "output file" },
-    { wxCMD_LINE_OPTION, "i", "input",   "input dir" },
-    { wxCMD_LINE_OPTION, "s", "size",    "output block size", wxCMD_LINE_VAL_NUMBER },
-    { wxCMD_LINE_OPTION, "d", "date",    "output file date", wxCMD_LINE_VAL_DATE },
-
-    { wxCMD_LINE_PARAM,  NULL, NULL, "input file", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
-
-    { wxCMD_LINE_NONE }
-};
-
-wxCmdLineParser parser;
-
-parser.SetDesc(cmdLineDesc);
-\end{verbatim}
-
-\membersection{wxCmdLineParser::AddSwitch}\label{wxcmdlineparseraddswitch}
-
-\func{void}{AddSwitch}{\param{const wxString\& }{name}, \param{const wxString\& }{lng = wxEmptyString}, \param{const wxString\& }{desc = wxEmptyString}, \param{int }{flags = 0}}
-
-Add a switch {\it name} with an optional long name {\it lng} (no long name if it
-is empty, which is default), description {\it desc} and flags {\it flags} to the
-command line description.
-
-\membersection{wxCmdLineParser::AddOption}\label{wxcmdlineparseraddoption}
-
-\func{void}{AddOption}{\param{const wxString\& }{name}, \param{const wxString\& }{lng = wxEmptyString}, \param{const wxString\& }{desc = wxEmptyString}, \param{wxCmdLineParamType }{type = wxCMD\_LINE\_VAL\_STRING}, \param{int }{flags = 0}}
-
-Add an option {\it name} with an optional long name {\it lng} (no long name if
-it is empty, which is default) taking a value of the given type (string by
-default) to the command line description.
-
-\membersection{wxCmdLineParser::AddParam}\label{wxcmdlineparseraddparam}
-
-\func{void}{AddParam}{\param{const wxString\& }{desc = wxEmptyString}, \param{wxCmdLineParamType }{type = wxCMD\_LINE\_VAL\_STRING}, \param{int }{flags = 0}}
-
-Add a parameter of the given {\it type} to the command line description.
-
-\membersection{wxCmdLineParser::Parse}\label{wxcmdlineparserparse}
-
-\func{int}{Parse}{\param{bool }{giveUsage = {\tt TRUE}}}
-
-Parse the command line, return $0$ if ok, $-1$ if {\tt "-h"} or {\tt "--help"} 
-option was encountered and the help message was given or a positive value if a
-syntax error occured.
-
-\wxheading{Parameters}
-
-\docparam{giveUsage}{If {\tt TRUE} (default), the usage message is given if a
-syntax error was encountered while parsing the command line or if help was
-requested. If {\tt FALSE}, only error messages about possible syntax errors
-are given, use \helpref{Usage}{wxcmdlineparserusage} to show the usage message
-from the caller if needed.}
-
-\membersection{wxCmdLineParser::Usage}\label{wxcmdlineparserusage}
-
-\func{void}{Usage}{\void}
-
-Give the standard usage message describing all program options. It will use the
-options and parameters descriptions specified earlier, so the resulting message
-will not be helpful to the user unless the descriptions were indeed specified.
-
-\wxheading{See also}
-
-\helpref{SetLogo}{wxcmdlineparsersetlogo}
-
-\membersection{wxCmdLineParser::Found}\label{wxcmdlineparserfoundswitch}
-
-\constfunc{bool}{Found}{\param{const wxString\& }{name}}
-
-Returns TRUE if the given switch was found, FALSE otherwise.
-
-\membersection{wxCmdLineParser::Found}\label{wxcmdlineparserfoundstringoption}
-
-\constfunc{bool}{Found}{\param{const wxString\& }{name}, \param{wxString* }{value}}
-
-Returns TRUE if an option taking a string value was found and stores the
-value in the provided pointer (which should not be NULL).
-
-\membersection{wxCmdLineParser::Found}\label{wxcmdlineparserfoundintoption}
-
-\constfunc{bool}{Found}{\param{const wxString\& }{name}, \param{long* }{value}}
-
-Returns TRUE if an option taking an integer value was found and stores
-the value in the provided pointer (which should not be NULL).
-
-\membersection{wxCmdLineParser::Found}\label{wxcmdlineparserfounddateoption}
-
-\constfunc{bool}{Found}{\param{const wxString\& }{name}, \param{wxDateTime* }{value}}
-
-Returns TRUE if an option taking a date value was found and stores the
-value in the provided pointer (which should not be NULL).
-
-\membersection{wxCmdLineParser::GetParamCount}\label{wxcmdlineparsergetparamcount}
-
-\constfunc{size\_t}{GetParamCount}{\void}
-
-Returns the number of parameters found. This function makes sense mostly if you
-had used {\tt wxCMD\_LINE\_PARAM\_MULTIPLE} flag.
-
-\membersection{wxCmdLineParser::GetParam}\label{wxcmdlineparsergetparam}
-
-\constfunc{wxString}{GetParam}{\param{size\_t }{n = 0u}}
-
-Returns the value of Nth parameter (as string only for now).
-
-\wxheading{See also}
-
-\helpref{GetParamCount}{wxcmdlineparsergetparamcount}
-

docs/latex/wx/cmdproc.tex

@@ -1,153 +0,0 @@
-\section{\class{wxCommandProcessor}}\label{wxcommandprocessor}
-
-wxCommandProcessor is a class that maintains a history of wxCommands,
-with undo/redo functionality built-in. Derive a new class from this
-if you want different behaviour.
-
-\wxheading{Derived from}
-
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/cmdproc.h>
-
-\wxheading{See also}
-
-\helpref{wxCommandProcessor overview}{wxcommandprocessoroverview}, \helpref{wxCommand}{wxcommand}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCommandProcessor::wxCommandProcessor}
-
-\func{}{wxCommandProcessor}{\param{int}{ maxCommands = $-1$}}
-
-Constructor.
-
-{\it maxCommands} may be set to a positive integer to limit the number of
-commands stored to it, otherwise (and by default) the list of commands can grow
-arbitrarily.
-
-\membersection{wxCommandProcessor::\destruct{wxCommandProcessor}}
-
-\func{}{\destruct{wxCommandProcessor}}{\void}
-
-Destructor.
-
-\membersection{wxCommandProcessor::CanUndo}
-
-\func{virtual bool}{CanUndo}{\void}
-
-Returns TRUE if the currently-active command can be undone, FALSE otherwise.
-
-\membersection{wxCommandProcessor::ClearCommands}
-
-\func{virtual void}{ClearCommands}{\void}
-
-Deletes all the commands in the list and sets the current command pointer to NULL.
-
-\membersection{wxCommandProcessor::Redo}
-
-\func{virtual bool}{Redo}{\void}
-
-Executes (redoes) the current command (the command that has just been undone if any).
-
-\membersection{wxCommandProcessor::GetCommands}
-
-\constfunc{wxList\&}{GetCommands}{\void}
-
-Returns the list of commands.
-
-\membersection{wxCommandProcessor::GetMaxCommands}
-
-\constfunc{int}{GetMaxCommands}{\void}
-
-Returns the maximum number of commands that the command processor stores.
-
-\membersection{wxCommandProcessor::GetEditMenu}
-
-\constfunc{wxMenu*}{GetEditMenu}{\void}
-
-Returns the edit menu associated with the command processor.
-
-\membersection{wxCommandProcessor::GetRedoAccelerator}\label{wxcommandprocessorgetredoaccelerator}
-
-\constfunc{const wxString\&}{GetRedoAccelerator}{\void}
-
-Returns the string that will be appended to the Redo menu item.
-
-\membersection{wxCommandProcessor::GetRedoMenuLabel}\label{wxcommandprocessorgetredomenulabel}
-
-\constfunc{wxString}{GetRedoMenuLabel}{\void}
-
-Returns the string that will be shown for the redo menu item.
-
-\membersection{wxCommandProcessor::GetUndoAccelerator}\label{wxcommandprocessorgetundoaccelerator}
-
-\constfunc{const wxString\&}{GetUndoAccelerator}{\void}
-
-Returns the string that will be appended to the Undo menu item.
-
-\membersection{wxCommandProcessor::GetUndoMenuLabel}\label{wxcommandprocessorgetundomenulabel}
-
-\constfunc{wxString}{GetUndoMenuLabel}{\void}
-
-Returns the string that will be shown for the undo menu item.
-
-\membersection{wxCommandProcessor::Initialize}
-
-\func{virtual void}{Initialize}{\void}
-
-Initializes the command processor, setting the current command to the
-last in the list (if any), and updating the edit menu (if one has been
-specified).
-
-\membersection{wxCommandProcessor::SetEditMenu}
-
-\func{void}{SetEditMenu}{\param{wxMenu* }{menu}}
-
-Tells the command processor to update the Undo and Redo items on this
-menu as appropriate. Set this to NULL if the menu is about to be
-destroyed and command operations may still be performed, or the command
-processor may try to access an invalid pointer.
-
-\membersection{wxCommandProcessor::SetMenuStrings}
-
-\func{void}{SetMenuStrings}{\void}
-
-Sets the menu labels according to the currently set menu and the current
-command state.
-
-\membersection{wxCommandProcessor::SetRedoAccelerator}\label{wxcommandprocessorsetredoaccelerator}
-
-\func{void}{SetRedoAccelerator}{\param{const wxString\&}{accel}}
-
-Sets the string that will be appended to the Redo menu item.
-
-\membersection{wxCommandProcessor::SetUndoAccelerator}\label{wxcommandprocessorsetundoaccelerator}
-
-\func{void}{SetUndoAccelerator}{\param{const wxString\&}{accel}}
-
-Sets the string that will be appended to the Undo menu item.
-
-\membersection{wxCommandProcessor::Submit}
-
-\func{virtual bool}{Submit}{\param{wxCommand *}{command}, \param{bool}{ storeIt = TRUE}}
-
-Submits a new command to the command processor. The command processor
-calls wxCommand::Do to execute the command; if it succeeds, the command
-is stored in the history list, and the associated edit menu (if any) updated
-appropriately. If it fails, the command is deleted
-immediately. Once Submit has been called, the passed command should not
-be deleted directly by the application.
-
-{\it storeIt} indicates whether the successful command should be stored
-in the history list.
-
-\membersection{wxCommandProcessor::Undo}
-
-\func{virtual bool}{Undo}{\void}
-
-Undoes the command just executed.
-
-

docs/latex/wx/colordlg.tex

@@ -1,61 +0,0 @@
-\section{\class{wxColourDialog}}\label{wxcolourdialog}
-
-This class represents the colour chooser dialog.
-
-\wxheading{Derived from}
-
-\helpref{wxDialog}{wxdialog}\\
-\helpref{wxWindow}{wxwindow}\\
-\helpref{wxEvtHandler}{wxevthandler}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/colordlg.h>
-
-\wxheading{See also}
-
-\helpref{wxColourDialog Overview}{wxcolourdialogoverview},\\
-\helpref{wxColour}{wxcolour},\\
-\helpref{wxColourData}{wxcolourdata},\\
-\helpref{wxGetColourFromUser}{wxgetcolourfromuser}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxColourDialog::wxColourDialog}\label{wxcolourdialogwxcolourdialog}
-
-\func{}{wxColourDialog}{\param{wxWindow* }{parent}, \param{wxColourData* }{data = NULL}}
-
-Constructor. Pass a parent window, and optionally a pointer to a block of colour
-data, which will be copied to the colour dialog's colour data.
-
-\wxheading{See also}
-
-\helpref{wxColourData}{wxcolourdata}
-
-\membersection{wxColourDialog::\destruct{wxColourDialog}}
-
-\func{}{\destruct{wxColourDialog}}{\void}
-
-Destructor.
-
-\membersection{wxColourDialog::Create}
-
-\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxColourData* }{data = NULL}}
-
-Same as \helpref{constructor}{wxcolourdialogwxcolourdialog}.
-
-\membersection{wxColourDialog::GetColourData}
-
-\func{wxColourData\&}{GetColourData}{\void}
-
-Returns the \helpref{colour data}{wxcolourdata} associated with the colour dialog.
-
-\membersection{wxColourDialog::ShowModal}
-
-\func{int}{ShowModal}{\void}
-
-Shows the dialog, returning wxID\_OK if the user pressed OK, and wxOK\_CANCEL
-otherwise.
-
-

docs/latex/wx/colour.tex

@@ -1,302 +0,0 @@
-\section{\class{wxColour}}\label{wxcolour}
-
-A colour is an object representing a combination of Red, Green, and Blue (RGB) intensity values,
-and is used to determine drawing colours. See the
-entry for \helpref{wxColourDatabase}{wxcolourdatabase} for how a pointer to a predefined,
-named colour may be returned instead of creating a new colour.
-
-Valid RGB values are in the range 0 to 255.
-
-\wxheading{Derived from}
-
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/colour.h>
-
-\wxheading{Predefined objects}
-
-Objects:
-
-{\bf wxNullColour}
-
-Pointers:
-
-{\bf wxBLACK\\
-wxWHITE\\
-wxRED\\
-wxBLUE\\
-wxGREEN\\
-wxCYAN\\
-wxLIGHT\_GREY}
-
-\wxheading{See also}
-
-\helpref{wxColourDatabase}{wxcolourdatabase}, \helpref{wxPen}{wxpen}, \helpref{wxBrush}{wxbrush},\rtfsp
-\helpref{wxColourDialog}{wxcolourdialog}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxColour::wxColour}\label{wxcolourconstr}
-
-\func{}{wxColour}{\void}
-
-Default constructor.
-
-\func{}{wxColour}{\param{const unsigned char}{ red}, \param{const unsigned char}{ green}, \param{const unsigned char}{ blue}}
-
-Constructs a colour from red, green and blue values.
-
-\func{}{wxColour}{\param{const wxString\& }{colourNname}}
-
-Constructs a colour object using a colour name
-listed in {\bf wxTheColourDatabase}.
-
-\func{}{wxColour}{\param{const wxColour\&}{ colour}}
-
-Copy constructor.
-
-\wxheading{Parameters}
-
-\docparam{red}{The red value.}
-
-\docparam{green}{The green value.}
-
-\docparam{blue}{The blue value.}
-
-\docparam{colourName}{The colour name.}
-
-\docparam{colour}{The colour to copy.}
-
-\wxheading{See also}
-
-\helpref{wxColourDatabase}{wxcolourdatabase}
-
-\pythonnote{Constructors supported by wxPython are:\par
-\indented{2cm}{\begin{twocollist}
-\twocolitem{{\bf wxColour(red=0, green=0, blue=0)}}{}
-\twocolitem{{\bf wxNamedColour(name)}}{}
-\end{twocollist}}
-}
-
-
-\membersection{wxColour::Blue}\label{wxcolourblue}
-
-\constfunc{unsigned char}{Blue}{\void}
-
-Returns the blue intensity.
-
-\membersection{wxColour::GetPixel}\label{wxcolourgetpixel}
-
-\constfunc{long}{GetPixel}{\void}
-
-Returns a pixel value which is platform-dependent. On Windows, a COLORREF is returned.
-On X, an allocated pixel value is returned.
-
--1 is returned if the pixel is invalid (on X, unallocated).
-
-\membersection{wxColour::Green}\label{wxcolourgreen}
-
-\constfunc{unsigned char}{Green}{\void}
-
-Returns the green intensity.
-
-\membersection{wxColour::Ok}\label{wxcolourok}
-
-\constfunc{bool}{Ok}{\void}
-
-Returns TRUE if the colour object is valid (the colour has been initialised with RGB values).
-
-\membersection{wxColour::Red}\label{wxcolourred}
-
-\constfunc{unsigned char}{Red}{\void}
-
-Returns the red intensity.
-
-\membersection{wxColour::Set}\label{wxcolourset}
-
-\func{void}{Set}{\param{const unsigned char}{ red}, \param{const unsigned char}{ green}, \param{const unsigned char}{ blue}}
-
-Sets the RGB intensity values.
-
-\membersection{wxColour::operator $=$}\label{wxcolourassign}
-
-\func{wxColour\&}{operator $=$}{\param{const wxColour\&}{ colour}}
-
-Assignment operator, taking another colour object.
-
-\func{wxColour\&}{operator $=$}{\param{const wxString\&}{ colourName}}
-
-Assignment operator, using a colour name to be found in the colour database.
-
-\wxheading{See also}
-
-\helpref{wxColourDatabase}{wxcolourdatabase}
-
-\membersection{wxColour::operator $==$}\label{wxcolourequality}
-
-\func{bool}{operator $==$}{\param{const wxColour\&}{ colour}}
-
-Tests the equality of two colours by comparing individual red, green blue colours.
-
-\membersection{wxColour::operator $!=$}\label{wxcolourinequality}
-
-\func{bool}{operator $!=$}{\param{const wxColour\&}{ colour}}
-
-Tests the inequality of two colours by comparing individual red, green blue colours.
-
-\section{\class{wxColourData}}\label{wxcolourdata}
-
-This class holds a variety of information related to colour dialogs.
-
-\wxheading{Derived from}
-
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/cmndata.h>
-
-\wxheading{See also}
-
-\helpref{wxColour}{wxcolour}, \helpref{wxColourDialog}{wxcolourdialog}, \helpref{wxColourDialog overview}{wxcolourdialogoverview}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxColourData::wxColourData}\label{wxcolourdataconstr}
-
-\func{}{wxColourData}{\void}
-
-Constructor. Initializes the custom colours to white, the {\it data colour} setting
-to black, and the {\it choose full} setting to TRUE.
-
-\membersection{wxColourData::\destruct{wxColourData}}
-
-\func{}{\destruct{wxColourData}}{\void}
-
-Destructor.
-
-\membersection{wxColourData::GetChooseFull}\label{wxcolourdatagetchoosefull}
-
-\constfunc{bool}{GetChooseFull}{\void}
-
-Under Windows, determines whether the Windows colour dialog will display the full dialog
-with custom colour selection controls. Has no meaning under other platforms.
-
-The default value is TRUE.
-
-\membersection{wxColourData::GetColour}\label{wxcolourdatagetcolour}
-
-\constfunc{wxColour\&}{GetColour}{\void}
-
-Gets the current colour associated with the colour dialog.
-
-The default colour is black.
-
-\membersection{wxColourData::GetCustomColour}\label{wxcolourdatagetcustomcolour}
-
-\constfunc{wxColour\&}{GetCustomColour}{\param{int}{ i}}
-
-Gets the {\it i}th custom colour associated with the colour dialog. {\it i} should
-be an integer between 0 and 15.
-
-The default custom colours are all white.
-
-\membersection{wxColourData::SetChooseFull}\label{wxcolourdatasetchoosefull}
-
-\func{void}{SetChooseFull}{\param{const bool }{flag}}
-
-Under Windows, tells the Windows colour dialog to display the full dialog
-with custom colour selection controls. Under other platforms, has no effect.
-
-The default value is TRUE.
-
-\membersection{wxColourData::SetColour}\label{wxcolourdatasetcolour}
-
-\func{void}{SetColour}{\param{const wxColour\&}{ colour}}
-
-Sets the default colour for the colour dialog.
-
-The default colour is black.
-
-\membersection{wxColourData::SetCustomColour}\label{wxcolourdatasetcustomcolour}
-
-\func{void}{SetCustomColour}{\param{int}{ i}, \param{const wxColour\&}{ colour}}
-
-Sets the {\it i}th custom colour for the colour dialog. {\it i} should
-be an integer between 0 and 15.
-
-The default custom colours are all white.
-
-\membersection{wxColourData::operator $=$}\label{wxcolourdataassign}
-
-\func{void}{operator $=$}{\param{const wxColourData\&}{ data}}
-
-Assignment operator for the colour data.
-
-\section{\class{wxColourDatabase}}\label{wxcolourdatabase}
-
-wxWindows maintains a database of standard RGB colours for a predefined
-set of named colours (such as ``BLACK'', ``LIGHT GREY''). The
-application may add to this set if desired by using {\it Append}.  There
-is only one instance of this class: {\bf wxTheColourDatabase}.
-
-\wxheading{Derived from}
-
-\helpref{wxList}{wxlist}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/gdicmn.h>
-
-\wxheading{Remarks}
-
-The colours in the standard database are as follows:
-
-AQUAMARINE, BLACK, BLUE, BLUE VIOLET, BROWN, CADET BLUE, CORAL,
-CORNFLOWER BLUE, CYAN, DARK GREY, DARK GREEN, DARK OLIVE GREEN, DARK
-ORCHID, DARK SLATE BLUE, DARK SLATE GREY DARK TURQUOISE, DIM GREY,
-FIREBRICK, FOREST GREEN, GOLD, GOLDENROD, GREY, GREEN, GREEN YELLOW,
-INDIAN RED, KHAKI, LIGHT BLUE, LIGHT GREY, LIGHT STEEL BLUE, LIME GREEN,
-MAGENTA, MAROON, MEDIUM AQUAMARINE, MEDIUM BLUE, MEDIUM FOREST GREEN,
-MEDIUM GOLDENROD, MEDIUM ORCHID, MEDIUM SEA GREEN, MEDIUM SLATE BLUE,
-MEDIUM SPRING GREEN, MEDIUM TURQUOISE, MEDIUM VIOLET RED, MIDNIGHT BLUE,
-NAVY, ORANGE, ORANGE RED, ORCHID, PALE GREEN, PINK, PLUM, PURPLE, RED,
-SALMON, SEA GREEN, SIENNA, SKY BLUE, SLATE BLUE, SPRING GREEN, STEEL
-BLUE, TAN, THISTLE, TURQUOISE, VIOLET, VIOLET RED, WHEAT, WHITE, YELLOW,
-YELLOW GREEN.
-
-\wxheading{See also}
-
-\helpref{wxColour}{wxcolour}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxColourDatabase::wxColourDatabase}\label{wxcolourdatabaseconstr}
-
-\func{}{wxColourDatabase}{\void}
-
-Constructs the colour database.
-
-\membersection{wxColourDatabase::FindColour}\label{wxcolourdatabasefindcolour}
-
-\func{wxColour*}{FindColour}{\param{const wxString\& }{colourName}}
-
-Finds a colour given the name. Returns NULL if not found.
-
-\membersection{wxColourDatabase::FindName}\label{wxcolourdatabasefindname}
-
-\constfunc{wxString}{FindName}{\param{const wxColour\&}{ colour}}
-
-Finds a colour name given the colour. Returns NULL if not found.
-
-\membersection{wxColourDatabase::Initialize}\label{wxcolourdatabaseinitialize}
-
-\func{void}{Initialize}{\void}
-
-Initializes the database with a number of stock colours.  Called by wxWindows
-on start-up.
-
-

docs/latex/wx/combobox.tex

@@ -1,223 +0,0 @@
-\section{\class{wxComboBox}}\label{wxcombobox}
-
-A combobox is like a combination of an edit control and a listbox. It can be
-displayed as static list with editable or read-only text field; or a drop-down list with
-text field; or a drop-down list without a text field.
-
-A combobox permits a single selection only. Combobox items are numbered from zero.
-
-\wxheading{Derived from}
-
-\helpref{wxControlWithItems}{wxcontrolwithitems}\\
-\helpref{wxChoice}{wxchoice}\\
-\helpref{wxControl}{wxcontrol}\\
-\helpref{wxWindow}{wxwindow}\\
-\helpref{wxEvtHandler}{wxevthandler}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/combobox.h>
-
-\wxheading{Window styles}
-
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\windowstyle{wxCB\_SIMPLE}}{Creates a combobox with a permanently displayed list. Windows only. }
-\twocolitem{\windowstyle{wxCB\_DROPDOWN}}{Creates a combobox with a drop-down list.}
-\twocolitem{\windowstyle{wxCB\_READONLY}}{Same as wxCB\_DROPDOWN but only the
-strings specified as the combobox choices can be selected, it is impossible to
-select (even from a program) a string which is not in the choices list.}
-\twocolitem{\windowstyle{wxCB\_SORT}}{Sorts the entries in the list alphabetically.}
-\end{twocollist}
-
-See also \helpref{window styles overview}{windowstyles}.
-
-\wxheading{Event handling}
-
-\twocolwidtha{7cm}
-\begin{twocollist}\itemsep=0pt
-\twocolitem{{\bf EVT\_COMBOBOX(id, func)}}{Process a wxEVT\_COMMAND\_COMBOBOX\_SELECTED event,
-when an item on the list is selected.}
-\twocolitem{{\bf EVT\_TEXT(id, func)}}{Process a wxEVT\_COMMAND\_TEXT\_UPDATED event,
-when the combobox text changes.}
-\end{twocollist}
-
-\wxheading{See also}
-
-\helpref{wxListBox}{wxlistbox}, \helpref{wxTextCtrl}{wxtextctrl}, \helpref{wxChoice}{wxchoice},
-\rtfsp\helpref{wxCommandEvent}{wxcommandevent}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxComboBox::wxComboBox}\label{wxcomboboxconstr}
-
-\func{}{wxComboBox}{\void}
-
-Default constructor.
-
-\func{}{wxComboBox}{\param{wxWindow*}{ parent}, \param{wxWindowID}{ id},\rtfsp
-\param{const wxString\& }{value = ``"}, \param{const wxPoint\&}{ pos = wxDefaultPosition}, \param{const wxSize\&}{ size = wxDefaultSize},\rtfsp
-\param{int}{ n}, \param{const wxString }{choices[]},\rtfsp
-\param{long}{ style = 0}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``comboBox"}}
-
-Constructor, creating and showing a combobox.
-
-\wxheading{Parameters}
-
-\docparam{parent}{Parent window. Must not be NULL.}
-
-\docparam{id}{Window identifier. A value of -1 indicates a default value.}
-
-\docparam{value}{Initial selection string. An empty string indicates no selection.}
-
-\docparam{pos}{Window position.}
-
-\docparam{size}{Window size. If the default size (-1, -1) is specified then the window is sized
-appropriately.}
-
-\docparam{n}{Number of strings with which to initialise the control.}
-
-\docparam{choices}{An array of strings with which to initialise the control.}
-
-\docparam{style}{Window style. See \helpref{wxComboBox}{wxcombobox}.}
-
-\docparam{validator}{Window validator.}
-
-\docparam{name}{Window name.}
-
-\wxheading{See also}
-
-\helpref{wxComboBox::Create}{wxcomboboxcreate}, \helpref{wxValidator}{wxvalidator}
-
-\pythonnote{The wxComboBox constructor in wxPython reduces the {\tt n}
-and {\tt choices} arguments are to a single argument, which is
-a list of strings.}
-
-\perlnote{In wxPerl there is just an array reference in place of {\tt n}
-and {\tt choices}.}
-
-\membersection{wxComboBox::\destruct{wxComboBox}}
-
-\func{}{\destruct{wxComboBox}}{\void}
-
-Destructor, destroying the combobox.
-
-\membersection{wxComboBox::Create}\label{wxcomboboxcreate}
-
-\func{bool}{Create}{\param{wxWindow*}{ parent}, \param{wxWindowID}{ id},\rtfsp
-\param{const wxString\& }{value = ``"}, \param{const wxPoint\&}{ pos = wxDefaultPosition}, \param{const wxSize\&}{ size = wxDefaultSize},\rtfsp
-\param{int}{ n}, \param{const wxString }{choices[]},\rtfsp
-\param{long}{ style = 0}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``comboBox"}}
-
-Creates the combobox for two-step construction. Derived classes
-should call or replace this function. See \helpref{wxComboBox::wxComboBox}{wxcomboboxconstr}\rtfsp
-for further details.
-
-\membersection{wxComboBox::Copy}\label{wxcomboboxcopy}
-
-\func{void}{Copy}{\void}
-
-Copies the selected text to the clipboard.
-
-\membersection{wxComboBox::Cut}\label{wxcomboboxcut}
-
-\func{void}{Cut}{\void}
-
-Copies the selected text to the clipboard and removes the selection.
-
-\membersection{wxComboBox::GetInsertionPoint}\label{wxcomboboxgetinsertionpoint}
-
-\constfunc{long}{GetInsertionPoint}{\void}
-
-Returns the insertion point for the combobox's text field.
-
-\membersection{wxComboBox::GetLastPosition}\label{wxcomboboxgetlastposition}
-
-\constfunc{long}{GetLastPosition}{\void}
-
-Returns the last position in the combobox text field.
-
-\membersection{wxComboBox::GetValue}\label{wxcomboboxgetvalue}
-
-\constfunc{wxString}{GetValue}{\void}
-
-Returns the current value in the combobox text field.
-
-\membersection{wxComboBox::Paste}\label{wxcomboboxpaste}
-
-\func{void}{Paste}{\void}
-
-Pastes text from the clipboard to the text field.
-
-\membersection{wxComboBox::Replace}\label{wxcomboboxreplace}
-
-\func{void}{Replace}{\param{long}{ from}, \param{long}{ to}, \param{const wxString\& }{text}}
-
-Replaces the text between two positions with the given text, in the combobox text field.
-
-\wxheading{Parameters}
-
-\docparam{from}{The first position.}
-
-\docparam{to}{The second position.}
-
-\docparam{text}{The text to insert.}
-
-\membersection{wxComboBox::Remove}\label{wxcomboboxremove}
-
-\func{void}{Remove}{\param{long}{ from}, \param{long}{ to}}
-
-Removes the text between the two positions in the combobox text field.
-
-\wxheading{Parameters}
-
-\docparam{from}{The first position.}
-
-\docparam{to}{The last position.}
-
-\membersection{wxComboBox::SetInsertionPoint}\label{wxcomboboxsetinsertionpoint}
-
-\func{void}{SetInsertionPoint}{\param{long}{ pos}}
-
-Sets the insertion point in the combobox text field.
-
-\wxheading{Parameters}
-
-\docparam{pos}{The new insertion point.}
-
-\membersection{wxComboBox::SetInsertionPointEnd}\label{wxcomboboxsetinsertionpointend}
-
-\func{void}{SetInsertionPointEnd}{\void}
-
-Sets the insertion point at the end of the combobox text field.
-
-\membersection{wxComboBox::SetSelection}\label{wxcomboboxsetselection}
-
-\func{void}{SetSelection}{\param{long}{ from}, \param{long}{ to}}
-
-Selects the text between the two positions, in the combobox text field.
-
-\wxheading{Parameters}
-
-\docparam{from}{The first position.}
-
-\docparam{to}{The second position.}
-
-\pythonnote{This method is called {\tt SetMark} in wxPython, {\tt SetSelection}
-name is kept for 
-\helpref{wxControlWithItems::SetSelection}{wxcontrolwithitemssetselection}.}
-
-\membersection{wxComboBox::SetValue}\label{wxcomboboxsetvalue}
-
-\func{void}{SetValue}{\param{const wxString\& }{text}}
-
-Sets the text for the combobox text field.
-
-{\bf NB:} For a combobox with {\tt wxCB\_READONLY} style the string must be in
-the combobox choices list, otherwise the call to SetValue() is ignored.
-
-\wxheading{Parameters}
-
-\docparam{text}{The text to set.}
-
-

docs/latex/wx/command.tex

@@ -1,89 +0,0 @@
-\section{\class{wxCommand}}\label{wxcommand}
-
-wxCommand is a base class for modelling an application command,
-which is an action usually performed by selecting a menu item, pressing
-a toolbar button or any other means provided by the application to
-change the data or view.
-
-\wxheading{Derived from}
-
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/cmdproc.h>
-
-\wxheading{See also}
-
-\overview{Overview}{wxcommandoverview}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCommand::wxCommand}
-
-\func{}{wxCommand}{\param{bool}{ canUndo = FALSE}, \param{const wxString\& }{name = NULL}}
-
-Constructor. wxCommand is an abstract class, so you will need to derive
-a new class and call this constructor from your own constructor.
-
-{\it canUndo} tells the command processor whether this command is undo-able. You
-can achieve the same functionality by overriding the CanUndo member function (if for example
-the criteria for undoability is context-dependent).
-
-{\it name} must be supplied for the command processor to display the command name
-in the application's edit menu.
-
-\membersection{wxCommand::\destruct{wxCommand}}
-
-\func{}{\destruct{wxCommand}}{\void}
-
-Destructor.
-
-\membersection{wxCommand::CanUndo}
-
-\func{bool}{CanUndo}{\void}
-
-Returns TRUE if the command can be undone, FALSE otherwise.
-
-\membersection{wxCommand::Do}
-
-\func{bool}{Do}{\void}
-
-Override this member function to execute the appropriate action when called.
-Return TRUE to indicate that the action has taken place, FALSE otherwise.
-Returning FALSE will indicate to the command processor that the action is
-not undoable and should not be added to the command history.
-
-\membersection{wxCommand::GetName}
-
-\func{wxString}{GetName}{\void}
-
-Returns the command name.
-
-\membersection{wxCommand::Undo}
-
-\func{bool}{Undo}{\void}
-
-Override this member function to un-execute a previous Do.
-Return TRUE to indicate that the action has taken place, FALSE otherwise.
-Returning FALSE will indicate to the command processor that the action is
-not redoable and no change should be made to the command history.
-
-How you implement this command is totally application dependent, but typical
-strategies include:
-
-\begin{itemize}\itemsep=0pt
-\item Perform an inverse operation on the last modified piece of
-data in the document. When redone, a copy of data stored in command
-is pasted back or some operation reapplied. This relies on the fact that
-you know the ordering of Undos; the user can never Undo at an arbitrary position
-in the command history.
-\item Restore the entire document state (perhaps using document transactioning).
-Potentially very inefficient, but possibly easier to code if the user interface
-and data are complex, and an `inverse execute' operation is hard to write.
-\end{itemize}
-
-The docview sample uses the first method, to remove or restore segments
-in the drawing.
-
-

docs/latex/wx/conditn.tex

@@ -1,162 +0,0 @@
-\section{\class{wxCondition}}\label{wxcondition}
-
-wxCondition variables correspond to pthread conditions or to Win32 event
-objects. They may be used in a multithreaded application to wait until the
-given condition becomes true which happens when the condition becomes signaled.
-
-For example, if a worker thread is doing some long task and another thread has
-to wait until it is finished, the latter thread will wait on the condition
-object and the worker thread will signal it on exit (this example is not
-perfect because in this particular case it would be much better to just 
-\helpref{Wait()}{wxthreadwait} for the worker thread, but if there are several
-worker threads it already makes much more sense).
-
-Note that a call to \helpref{Signal()}{wxconditionsignal} may happen before the
-other thread calls \helpref{Wait()}{wxconditionwait} and, just as with the
-pthread conditions, the signal is then lost and so if you want to be sure to
-get it you must use a mutex together with the condition variable.
-
-\wxheading{Example}
-
-This example shows how a main thread may launch a worker thread which starts
-running and then waits until the main thread signals it to continue:
-
-\begin{verbatim}
-class MySignallingThread : public wxThread
-{
-public:
-    MySignallingThread(wxMutex *mutex, wxCondition *condition)
-    {
-        m_mutex = mutex;
-        m_condition = condition;
-
-        Create();
-    }
-
-    virtual ExitCode Entry()
-    {
-        ... do our job ...
-
-        // tell the other(s) thread(s) that we're about to terminate: we must
-        // lock the mutex first or we might signal the condition before the
-        // waiting threads start waiting on it!
-        wxMutexLocker lock(m_mutex);
-        m_condition.Broadcast(); // same as Signal() here -- one waiter only
-
-        return 0;
-    }
-
-private:
-    wxCondition *m_condition;
-    wxMutex *m_mutex;
-};
-
-int main()
-{
-    wxMutex mutex;
-    wxCondition condition(mutex);
-
-    // the mutex should be initially locked
-    mutex.Lock();
-
-    // create and run the thread but notice that it won't be able to
-    // exit (and signal its exit) before we unlock the mutex below
-    MySignallingThread *thread = new MySignallingThread(&mutex, &condition);
-
-    thread->Run();
-
-    // wait for the thread termination: Wait() atomically unlocks the mutex
-    // which allows the thread to continue and starts waiting
-    condition.Wait();
-
-    // now we can exit
-    return 0;
-}
-\end{verbatim}
-
-Of course, here it would be much better to simply use a joinable thread and
-call \helpref{wxThread::Wait}{wxthreadwait} on it, but this example does
-illustrate the importance of properly locking the mutex when using
-wxCondition.
-
-\wxheading{Derived from}
-
-None.
-
-\wxheading{Include files}
-
-<wx/thread.h>
-
-\wxheading{See also}
-
-\helpref{wxThread}{wxthread}, \helpref{wxMutex}{wxmutex}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCondition::wxCondition}\label{wxconditionconstr}
-
-\func{}{wxCondition}{\param{wxMutex\& }{mutex}}
-
-Default and only constructor. The {\it mutex} must be locked by the caller
-before calling \helpref{Wait}{wxconditionwait} function.
-
-\membersection{wxCondition::\destruct{wxCondition}}
-
-\func{}{\destruct{wxCondition}}{\void}
-
-Destroys the wxCondition object. The destructor is not virtual so this class
-should not be used polymorphically.
-
-\membersection{wxCondition::Broadcast}\label{wxconditionbroadcast}
-
-\func{void}{Broadcast}{\void}
-
-Broadcasts to all waiting threads, waking all of them up. Note that this method
-may be called whether the mutex associated with this condition is locked or
-not.
-
-\wxheading{See also}
-
-\helpref{wxCondition::Signal}{wxconditionsignal}
-
-\membersection{wxCondition::Signal}\label{wxconditionsignal}
-
-\func{void}{Signal}{\void}
-
-Signals the object waking up at most one thread. If several threads are waiting
-on the same condition, the exact thread which is woken up is undefined. If no
-threads are waiting, the signal is lost and the condition would have to be
-signalled again to wake up any thread which may start waiting on it later.
-
-Note that this method may be called whether the mutex associated with this
-condition is locked or not.
-
-\wxheading{See also}
-
-\helpref{wxCondition::Broadcast}{wxconditionbroadcast}
-
-\membersection{wxCondition::Wait}\label{wxconditionwait}
-
-\func{void}{Wait}{\void}
-
-Waits until the condition is signalled.
-
-\func{bool}{Wait}{\param{unsigned long}{ sec}, \param{unsigned long}{ nsec}}
-
-Waits until the condition is signalled or the timeout has elapsed.
-
-Note that the mutex associated with this condition {\bf must} be acquired by
-the thread before calling this method.
-
-\wxheading{Parameters}
-
-\docparam{sec}{Timeout in seconds}
-
-\docparam{nsec}{Timeout nanoseconds component (added to {\it sec}).}
-
-\wxheading{Return value}
-
-The second form returns {\tt TRUE} if the condition has been signalled, or
-{\tt FALSE} if it returned because the timeout has elapsed.
-
-

docs/latex/wx/config.tex

@@ -1,771 +0,0 @@
-\section{\class{wxConfigBase}}\label{wxconfigbase}
-
-wxConfigBase class defines the basic interface of all config classes. It can
-not be used by itself (it is an abstract base class) and you will always use one
-of its derivations: wxIniConfig, wxFileConfig, wxRegConfig or any other.
-
-However, usually you don't even need to know the precise nature of the class
-you're working with but you would just use the wxConfigBase methods. This
-allows you to write the same code regardless of whether you're working with
-the registry under Win32 or text-based config files under Unix (or even
-Windows 3.1 .INI files if you're really unlucky). To make writing the portable
-code even easier, wxWindows provides a typedef wxConfig
-which is mapped onto the native wxConfigBase implementation on the given
-platform: i.e. wxRegConfig under Win32, wxIniConfig under Win16 and
-wxFileConfig otherwise.
-
-See \helpref{config overview}{wxconfigoverview} for the descriptions of all
-features of this class.
-
-It is highly recommended to use static functions {\it Get()} and/or {\it Set()}, 
-so please have a \helpref{look at them.}{wxconfigstaticfunctions}
-
-\wxheading{Derived from}
-
-No base class
-
-\wxheading{Include files}
-
-<wx/config.h> (to let wxWindows choose a wxConfig class for your platform)\\
-<wx/confbase.h> (base config class)\\
-<wx/fileconf.h> (wxFileconfig class)\\
-<wx/msw/regconf.h> (wxRegConfig class)\\
-<wx/msw/iniconf.h> (wxIniConfig class)
-
-\wxheading{Example}
-
-Here is how you would typically use this class:
-
-\begin{verbatim}
-  // using wxConfig instead of writing wxFileConfig or wxRegConfig enhances
-  // portability of the code
-  wxConfig *config = new wxConfig("MyAppName");
-
-  wxString str;
-  if ( config->Read("LastPrompt", &str) ) {
-    // last prompt was found in the config file/registry and its value is now
-    // in str
-    ...
-  }
-  else {
-    // no last prompt...
-  }
-
-  // another example: using default values and the full path instead of just
-  // key name: if the key is not found , the value 17 is returned
-  long value = config->Read("/LastRun/CalculatedValues/MaxValue", 17);
-  ...
-  ...
-  ...
-  // at the end of the program we would save everything back
-  config->Write("LastPrompt", str);
-  config->Write("/LastRun/CalculatedValues/MaxValue", value);
-
-  // the changes will be written back automatically
-  delete config;
-\end{verbatim}
-
-This basic example, of course, doesn't show all wxConfig features, such as
-enumerating, testing for existence and deleting the entries and groups of
-entries in the config file, its abilities to automatically store the default
-values or expand the environment variables on the fly. However, the main idea
-is that using this class is easy and that it should normally do what you
-expect it to.
-
-NB: in the documentation of this class, the words "config file" also mean
-"registry hive" for wxRegConfig and, generally speaking, might mean any
-physical storage where a wxConfigBase-derived class stores its data.
-
-\latexignore{\rtfignore{\wxheading{Function groups}}}
-
-\membersection{Static functions}\label{wxconfigstaticfunctions}
-
-These functions deal with the "default" config object. Although its usage is
-not at all mandatory it may be convenient to use a global config object
-instead of creating and deleting the local config objects each time you need
-one (especially because creating a wxFileConfig object might be a time
-consuming operation). In this case, you may create this global config object
-in the very start of the program and {\it Set()} it as the default. Then, from
-anywhere in your program, you may access it using the {\it Get()} function.
-Note that wxWindows will delete this config object for you during the program
-shutdown (from \helpref{wxApp::OnExit}{wxapponexit} to be precise) but you can
-also do it yourself earlier if needed.
-
-As it happens, you may even further simplify the procedure described above:
-you may forget about calling {\it Set()}. When {\it Get()} is called and there
-is no current object, it will create one using {\it Create()} function. To
-disable this behaviour {\it DontCreateOnDemand()} is provided.
-
-{\bf Note:} You should use either {\it Set()} or {\it Get()} because wxWindows
-library itself would take advantage of it and could save various information
-in it. For example \helpref{wxFontMapper}{wxfontmapper} or Unix version
-of \helpref{wxFileDialog}{wxfiledialog} have ability to use wxConfig class.
-
-\helpref{Set}{wxconfigbaseset}\\
-\helpref{Get}{wxconfigbaseget}\\
-\helpref{Create}{wxconfigbasecreate}\\
-\helpref{DontCreateOnDemand}{wxconfigbasedontcreateondemand}
-
-\membersection{Constructor and destructor}
-
-\helpref{wxConfigBase}{wxconfigbasector}\\
-\helpref{\destruct{wxConfigBase}}{wxconfigbasedtor}
-
-\membersection{Path management}
-
-As explained in \helpref{config overview}{wxconfigoverview}, the config classes
-support a file system-like hierarchy of keys (files) and groups (directories).
-As in the file system case, to specify a key in the config class you must use
-a path to it. Config classes also support the notion of the current group,
-which makes it possible to use the relative paths. To clarify all this, here
-is an example (it is only for the sake of demonstration, it doesn't do anything
-sensible!):
-
-\begin{verbatim}
-  wxConfig *config = new wxConfig("FooBarApp");
-
-  // right now the current path is '/'
-  conf->Write("RootEntry", 1);
-
-  // go to some other place: if the group(s) don't exist, they will be created
-  conf->SetPath("/Group/Subgroup");
-
-  // create an entry in subgroup
-  conf->Write("SubgroupEntry", 3);
-
-  // '..' is understood
-  conf->Write("../GroupEntry", 2);
-  conf->SetPath("..");
-
-  wxASSERT( conf->Read("Subgroup/SubgroupEntry", 0l) == 3 );
-
-  // use absolute path: it is allowed, too
-  wxASSERT( conf->Read("/RootEntry", 0l) == 1 );
-\end{verbatim}
-
-{\it Warning}: it is probably a good idea to always restore the path to its
-old value on function exit:
-
-\begin{verbatim}
-  void foo(wxConfigBase *config)
-  {
-    wxString strOldPath = config->GetPath();
-
-    config->SetPath("/Foo/Data");
-    ...
-
-    config->SetPath(strOldPath);
-  }
-\end{verbatim}
-
-because otherwise the assert in the following example will surely fail
-(we suppose here that {\it foo()} function is the same as above except that it
-doesn't save and restore the path):
-
-\begin{verbatim}
-  void bar(wxConfigBase *config)
-  {
-    config->Write("Test", 17);
-
-    foo(config);
-
-    // we're reading "/Foo/Data/Test" here! -1 will probably be returned...
-    wxASSERT( config->Read("Test", -1) == 17 );
-  }
-\end{verbatim}
-
-Finally, the path separator in wxConfigBase and derived classes is always '/',
-regardless of the platform (i.e. it is {\bf not} '$\backslash\backslash$' under Windows).
-
-\helpref{SetPath}{wxconfigbasesetpath}\\
-\helpref{GetPath}{wxconfigbasegetpath}
-
-\membersection{Enumeration}
-
-The functions in this section allow to enumerate all entries and groups in the
-config file. All functions here return FALSE when there are no more items.
-
-You must pass the same index to GetNext and GetFirst (don't modify it).
-Please note that it is {\bf not} the index of the current item (you will have
-some great surprises with wxRegConfig if you assume this) and you shouldn't
-even look at it: it is just a "cookie" which stores the state of the
-enumeration. It can't be stored inside the class because it would prevent you
-from running several enumerations simultaneously, that's why you must pass it
-explicitly.
-
-Having said all this, enumerating the config entries/groups is very simple:
-
-\begin{verbatim}
-  wxArrayString aNames;
-
-  // enumeration variables
-  wxString str;
-  long dummy;
-
-  // first enum all entries
-  bool bCont = config->GetFirstEntry(str, dummy);
-  while ( bCont ) {
-    aNames.Add(str);
-
-    bCont = GetConfig()->GetNextEntry(str, dummy);
-  }
-
-  ... we have all entry names in aNames...
-
-  // now all groups...
-  bCont = GetConfig()->GetFirstGroup(str, dummy);
-  while ( bCont ) {
-    aNames.Add(str);
-
-    bCont = GetConfig()->GetNextGroup(str, dummy);
-  }
-
-  ... we have all group (and entry) names in aNames...
-
-\end{verbatim}
-
-There are also functions to get the number of entries/subgroups without
-actually enumerating them, but you will probably never need them.
-
-\helpref{GetFirstGroup}{wxconfigbasegetfirstgroup}\\
-\helpref{GetNextGroup}{wxconfigbasegetnextgroup}\\
-\helpref{GetFirstEntry}{wxconfigbasegetfirstentry}\\
-\helpref{GetNextEntry}{wxconfigbasegetnextentry}\\
-\helpref{GetNumberOfEntries}{wxconfigbasegetnumberofentries}\\
-\helpref{GetNumberOfGroups}{wxconfigbasegetnumberofgroups}
-
-\membersection{Tests of existence}
-
-\helpref{HasGroup}{wxconfigbasehasgroup}\\
-\helpref{HasEntry}{wxconfigbasehasentry}\\
-\helpref{Exists}{wxconfigbaseexists}\\
-\helpref{GetEntryType}{wxconfigbasegetentrytype}
-
-\membersection{Miscellaneous functions}
-
-\helpref{GetAppName}{wxconfigbasegetappname}\\
-\helpref{GetVendorName}{wxconfigbasegetvendorname}\\
-\helpref{SetUmask}{wxfileconfigsetumask}
-
-\membersection{Key access}
-
-These function are the core of wxConfigBase class: they allow you to read and
-write config file data. All {\it Read} function take a default value which
-will be returned if the specified key is not found in the config file.
-
-Currently, only two types of data are supported: string and long (but it might
-change in the near future). To work with other types: for {\it int} or {\it
-bool} you can work with function taking/returning {\it long} and just use the
-casts. Better yet, just use {\it long} for all variables which you're going to
-save in the config file: chances are that {\tt sizeof(bool) == sizeof(int) == sizeof(long)} anyhow on your system. For {\it float}, {\it double} and, in
-general, any other type you'd have to translate them to/from string
-representation and use string functions.
-
-Try not to read long values into string variables and vice versa: although it
-just might work with wxFileConfig, you will get a system error with
-wxRegConfig because in the Windows registry the different types of entries are
-indeed used.
-
-Final remark: the {\it szKey} parameter for all these functions can contain an
-arbitrary path (either relative or absolute), not just the key name.
-
-\helpref{Read}{wxconfigbaseread}\\
-\helpref{Write}{wxconfigbasewrite}\\
-\helpref{Flush}{wxconfigbaseflush}
-
-\membersection{Rename entries/groups}
-
-The functions in this section allow to rename entries or subgroups of the
-current group. They will return FALSE on error. typically because either the
-entry/group with the original name doesn't exist, because the entry/group with
-the new name already exists or because the function is not supported in this
-wxConfig implementation.
-
-\helpref{RenameEntry}{wxconfigbaserenameentry}\\
-\helpref{RenameGroup}{wxconfigbaserenamegroup}
-
-\membersection{Delete entries/groups}
-
-The functions in this section delete entries and/or groups of entries from the
-config file. {\it DeleteAll()} is especially useful if you want to erase all
-traces of your program presence: for example, when you uninstall it.
-
-\helpref{DeleteEntry}{wxconfigbasedeleteentry}\\
-\helpref{DeleteGroup}{wxconfigbasedeletegroup}\\
-\helpref{DeleteAll}{wxconfigbasedeleteall}
-
-\membersection{Options}
-
-Some aspects of wxConfigBase behaviour can be changed during run-time. The
-first of them is the expansion of environment variables in the string values
-read from the config file: for example, if you have the following in your
-config file:
-
-\begin{verbatim}
-  # config file for my program
-  UserData = $HOME/data
-
-  # the following syntax is valud only under Windows
-  UserData = %windir%\\data.dat
-\end{verbatim}
-% $ % help EMACS syntax highlighting...
-the call to {\tt config->Read("UserData")} will return something like
-{\tt "/home/zeitlin/data"} if you're lucky enough to run a Linux system ;-)
-
-Although this feature is very useful, it may be annoying if you read a value
-which containts '\$' or '\%' symbols (\% is used for environment variables
-expansion under Windows) which are not used for environment variable
-expansion. In this situation you may call SetExpandEnvVars(FALSE) just before
-reading this value and SetExpandEnvVars(TRUE) just after. Another solution
-would be to prefix the offending symbols with a backslash.
-
-The following functions control this option:
-
-\helpref{IsExpandingEnvVars}{wxconfigbaseisexpandingenvvars}\\
-\helpref{SetExpandEnvVars}{wxconfigbasesetexpandenvvars}\\
-\helpref{SetRecordDefaults}{wxconfigbasesetrecorddefaults}\\
-\helpref{IsRecordingDefaults}{wxconfigbaseisrecordingdefaults}
-
-%%%%% MEMBERS HERE %%%%%
-\helponly{\insertatlevel{2}{
-
-\wxheading{Members}
-
-}}
-
-\membersection{wxConfigBase::wxConfigBase}\label{wxconfigbasector}
-
-\func{}{wxConfigBase}{\param{const wxString\& }{appName = wxEmptyString},
- \param{const wxString\& }{vendorName = wxEmptyString},
- \param{const wxString\& }{localFilename = wxEmptyString},
- \param{const wxString\& }{globalFilename = wxEmptyString},
- \param{long}{ style = 0}}
-
-This is the default and only constructor of the wxConfigBase class, and
-derived classes.
-
-\wxheading{Parameters}
-
-\docparam{appName}{The application name. If this is empty, the class will
-normally use \helpref{wxApp::GetAppName}{wxappgetappname} to set it. The
-application name is used in the registry key on Windows, and can be used to
-deduce the local filename parameter if that is missing.}
-
-\docparam{vendorName}{The vendor name. If this is empty, it is assumed that
-no vendor name is wanted, if this is optional for the current config class.
-The vendor name is appended to the application name for wxRegConfig.}
-
-\docparam{localFilename}{Some config classes require a local filename. If this
-is not present, but required, the application name will be used instead.}
-
-\docparam{globalFilename}{Some config classes require a global filename. If
-this is not present, but required, the application name will be used instead.}
-
-\docparam{style}{Can be one of wxCONFIG\_USE\_LOCAL\_FILE and
-wxCONFIG\_USE\_GLOBAL\_FILE. The style interpretation depends on the config
-class and is ignored by some. For wxFileConfig, these styles determine whether
-a local or global config file is created or used. If the flag is present but
-the parameter is empty, the parameter will be set to a default. If the
-parameter is present but the style flag not, the relevant flag will be added
-to the style. For wxFileConfig you can also add wxCONFIG\_USE\_RELATIVE\_PATH 
-by logically or'ing it to either of the \_FILE options to tell wxFileConfig to 
-use relative instead of absolute paths.  For wxFileConfig, you can also 
-add wxCONFIG\_USE\_NO\_ESCAPE\_CHARACTERS which will turn off character 
-escaping for the values of entries stored in the config file: for example 
-a {\it foo} key with some backslash characters will be stored as {\tt foo=C:$\backslash$mydir} instead
-of the usual storage of {\tt foo=C:$\backslash\backslash$mydir}.
-
-The wxCONFIG\_USE\_NO\_ESCAPE\_CHARACTERS style can be helpful if your config 
-file must be read or written to by a non-wxWindows program (which might not 
-understand the escape characters). Note, however, that if 
-wxCONFIG\_USE\_NO\_ESCAPE\_CHARACTERS style is used, it is is now 
-your application's responsibility to ensure that there is no newline or 
-other illegal characters in a value, before writing that value to the file.}
-
-\wxheading{Remarks}
-
-By default, environment variable expansion is on and recording defaults is
-off.
-
-\membersection{wxConfigBase::\destruct{wxConfigBase}}\label{wxconfigbasedtor}
-
-\func{}{\destruct{wxConfigBase}}{\void}
-
-Empty but ensures that dtor of all derived classes is virtual.
-
-\membersection{wxConfigBase::Create}\label{wxconfigbasecreate}
-
-\func{static wxConfigBase *}{Create}{\void}
-
-Create a new config object: this function will create the "best"
-implementation of wxConfig available for the current platform, see comments
-near the definition of wxCONFIG\_WIN32\_NATIVE for details. It returns the
-created object and also sets it as the current one.
-
-\membersection{wxConfigBase::DontCreateOnDemand}\label{wxconfigbasedontcreateondemand}
-
-\func{void}{DontCreateOnDemand}{\void}
-
-Calling this function will prevent {\it Get()} from automatically creating a
-new config object if the current one is NULL. It might be useful to call it
-near the program end to prevent new config object "accidental" creation.
-
-\membersection{wxConfigBase::DeleteAll}\label{wxconfigbasedeleteall}
-
-\func{bool}{DeleteAll}{\void}
-
-Delete the whole underlying object (disk file, registry key, ...). Primarly
-for use by desinstallation routine.
-
-\membersection{wxConfigBase::DeleteEntry}\label{wxconfigbasedeleteentry}
-
-\func{bool}{DeleteEntry}{\param{const wxString\& }{ key}, \param{bool}{ bDeleteGroupIfEmpty = TRUE}}
-
-Deletes the specified entry and the group it belongs to if it was the last key
-in it and the second parameter is true.
-
-\membersection{wxConfigBase::DeleteGroup}\label{wxconfigbasedeletegroup}
-
-\func{bool}{DeleteGroup}{\param{const wxString\& }{ key}}
-
-Delete the group (with all subgroups)
-
-\membersection{wxConfigBase::Exists}\label{wxconfigbaseexists}
-
-\constfunc{bool}{Exists}{\param{wxString\& }{strName}}
-
-returns TRUE if either a group or an entry with a given name exists
-
-\membersection{wxConfigBase::Flush}\label{wxconfigbaseflush}
-
-\func{bool}{Flush}{\param{bool }{bCurrentOnly = FALSE}}
-
-permanently writes all changes (otherwise, they're only written from object's
-destructor)
-
-\membersection{wxConfigBase::Get}\label{wxconfigbaseget}
-
-\func{static wxConfigBase *}{Get}{\param{bool }{CreateOnDemand = TRUE}}
-
-Get the current config object. If there is no current object and
-{\it CreateOnDemand} is TRUE, creates one
-(using {\it Create}) unless DontCreateOnDemand was called previously.
-
-\membersection{wxConfigBase::GetAppName}\label{wxconfigbasegetappname}
-
-\constfunc{wxString}{GetAppName}{\void}
-
-Returns the application name.
-
-\membersection{wxConfigBase::GetEntryType}\label{wxconfigbasegetentrytype}
-
-\constfunc{enum wxConfigBase::EntryType}{GetEntryType}{\param{const wxString\& }{name}}
-
-Returns the type of the given entry or {\it Unknown} if the entry doesn't
-exist. This function should be used to decide which version of Read() should
-be used because some of wxConfig implementations will complain about type
-mismatch otherwise: e.g., an attempt to read a string value from an integer
-key with wxRegConfig will fail.
-
-The result is an element of enum EntryType:
-
-\begin{verbatim}
-  enum EntryType
-  {
-    Unknown,
-    String,
-    Boolean,
-    Integer,
-    Float
-  };
-\end{verbatim}
-
-\membersection{wxConfigBase::GetFirstGroup}\label{wxconfigbasegetfirstgroup}
-
-\constfunc{bool}{GetFirstGroup}{\param{wxString\& }{str}, \param{long\&}{ index}}
-
-Gets the first group.
-
-\pythonnote{The wxPython version of this method returns a 3-tuple
-consisting of the continue flag, the value string, and the index for
-the next call.}
-
-\perlnote{In wxPerl this method takes no arguments and returns a 3-element
-list {\tt ( continue, str, index )}.}
-
-\membersection{wxConfigBase::GetFirstEntry}\label{wxconfigbasegetfirstentry}
-
-\constfunc{bool}{GetFirstEntry}{\param{wxString\& }{str}, \param{long\&}{ index}}
-
-Gets the first entry.
-
-\pythonnote{The wxPython version of this method returns a 3-tuple
-consisting of the continue flag, the value string, and the index for
-the next call.}
-
-\perlnote{In wxPerl this method takes no arguments and returns a 3-element
-list {\tt ( continue, str, index )}.}
-
-\membersection{wxConfigBase::GetNextGroup}\label{wxconfigbasegetnextgroup}
-
-\constfunc{bool}{GetNextGroup}{\param{wxString\& }{str}, \param{long\&}{ index}}
-
-Gets the next group.
-
-\pythonnote{The wxPython version of this method returns a 3-tuple
-consisting of the continue flag, the value string, and the index for
-the next call.}
-
-\perlnote{In wxPerl this method only takes the {\tt index} parameter
-and returns a 3-element list {\tt ( continue, str, index )}.}
-
-\membersection{wxConfigBase::GetNextEntry}\label{wxconfigbasegetnextentry}
-
-\constfunc{bool}{GetNextEntry}{\param{wxString\& }{str}, \param{long\&}{ index}}
-
-Gets the next entry.
-
-\pythonnote{The wxPython version of this method returns a 3-tuple
-consisting of the continue flag, the value string, and the index for
-the next call.}
-
-\perlnote{In wxPerl this method only takes the {\tt index} parameter
-and returns a 3-element list {\tt ( continue, str, index )}.}
-
-\membersection{wxConfigBase::GetNumberOfEntries}\label{wxconfigbasegetnumberofentries}
-
-\constfunc{uint }{GetNumberOfEntries}{\param{bool }{bRecursive = FALSE}}
-
-\membersection{wxConfigBase::GetNumberOfGroups}\label{wxconfigbasegetnumberofgroups}
-
-\constfunc{uint}{GetNumberOfGroups}{\param{bool }{bRecursive = FALSE}}
-
-Get number of entries/subgroups in the current group, with or without its
-subgroups.
-
-\membersection{wxConfigBase::GetPath}\label{wxconfigbasegetpath}
-
-\constfunc{const wxString\&}{GetPath}{\void}
-
-Retrieve the current path (always as absolute path).
-
-\membersection{wxConfigBase::GetVendorName}\label{wxconfigbasegetvendorname}
-
-\constfunc{wxString}{GetVendorName}{\void}
-
-Returns the vendor name.
-
-\membersection{wxConfigBase::HasEntry}\label{wxconfigbasehasentry}
-
-\constfunc{bool}{HasEntry}{\param{wxString\& }{strName}}
-
-returns TRUE if the entry by this name exists
-
-\membersection{wxConfigBase::HasGroup}\label{wxconfigbasehasgroup}
-
-\constfunc{bool}{HasGroup}{\param{const wxString\& }{strName}}
-
-returns TRUE if the group by this name exists
-
-\membersection{wxConfigBase::IsExpandingEnvVars}\label{wxconfigbaseisexpandingenvvars}
-
-\constfunc{bool}{IsExpandingEnvVars}{\void}
-
-Returns TRUE if we are expanding environment variables in key values.
-
-\membersection{wxConfigBase::IsRecordingDefaults}\label{wxconfigbaseisrecordingdefaults}
-
-\constfunc{bool}{IsRecordingDefaults}{\void}
-
-Returns TRUE if we are writing defaults back to the config file.
-
-\membersection{wxConfigBase::Read}\label{wxconfigbaseread}
-
-\constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{ str}}
-
-Read a string from the key, returning TRUE if the value was read. If the key
-was not found, {\it str} is not changed.
-
-\constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{ str}, \param{const wxString\& }{defaultVal}}
-
-Read a string from the key. The default value is returned if the key was not
-found.
-
-Returns TRUE if value was really read, FALSE if the default was used.
-
-\constfunc{wxString}{Read}{\param{const wxString\& }{key}, \param{const
-wxString\& }{defaultVal}}
-
-Another version of {\it Read()}, returning the string value directly.
-
-\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{long*}{ l}}
-
-Reads a long value, returning TRUE if the value was found. If the value was
-not found, {\it l} is not changed.
-
-\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{long*}{ l},
-\param{long}{ defaultVal}}
-
-Reads a long value, returning TRUE if the value was found. If the value was
-not found, {\it defaultVal} is used instead.
-
-\constfunc{long }{Read}{\param{const wxString\& }{key}, \param{long}{ defaultVal}}
-
-Reads a long value from the key and returns it. {\it defaultVal} is returned
-if the key is not found.
-
-NB: writing
-
-{\small
-\begin{verbatim}
-    conf->Read("key", 0);
-\end{verbatim}
-}
-
-won't work because the call is ambiguous: compiler can not choose between two
-{\it Read} functions. Instead, write:
-
-{\small
-\begin{verbatim}
-    conf->Read("key", 0l);
-\end{verbatim}
-}
-
-\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{double*}{ d}}
-
-Reads a double value, returning TRUE if the value was found. If the value was
-not found, {\it d} is not changed.
-
-\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{double*}{ d},
- \param{double}{ defaultVal}}
-
-Reads a double value, returning TRUE if the value was found. If the value was
-not found, {\it defaultVal} is used instead.
-
-\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{bool*}{ b}}
-
-Reads a bool value, returning TRUE if the value was found. If the value was
-not found, {\it b} is not changed.
-
-\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{bool*}{ d},
-\param{bool}{ defaultVal}}
-
-Reads a bool value, returning TRUE if the value was found. If the value was
-not found, {\it defaultVal} is used instead.
-
-\pythonnote{In place of a single overloaded method name, wxPython
-implements the following methods:\par
-\indented{2cm}{\begin{twocollist}
-\twocolitem{{\bf Read(key, default="")}}{Returns a string.}
-\twocolitem{{\bf ReadInt(key, default=0)}}{Returns an int.}
-\twocolitem{{\bf ReadFloat(key, default=0.0)}}{Returns a floating point number.}
-\end{twocollist}}
-}
-
-\perlnote{In place of a single overloaded method, wxPerl uses:\par
-\indented{2cm}{\begin{twocollist}
-\twocolitem{{\bf Read(key, default="")}}{Returns a string}
-\twocolitem{{\bf ReadInt(key, default=0)}}{Returns an integer}
-\twocolitem{{\bf ReadFloat(key, default=0.0)}}{Returns a floating point number}
-\twocolitem{{\bf ReadBool(key, default=0)}}{Returns a boolean}
-\end{twocollist}
-}}
-
-\membersection{wxConfigBase::RenameEntry}\label{wxconfigbaserenameentry}
-
-\func{bool}{RenameEntry}{\param{const wxString\& }{ oldName}, \param{const wxString\& }{ newName}}
-
-Renames an entry in the current group. The entries names (both the old and
-the new one) shouldn't contain backslashes, i.e. only simple names and not
-arbitrary paths are accepted by this function.
-
-Returns FALSE if the {\it oldName} doesn't exist or if {\it newName} already
-exists.
-
-\membersection{wxConfigBase::RenameGroup}\label{wxconfigbaserenamegroup}
-
-\func{bool}{RenameGroup}{\param{const wxString\& }{ oldName}, \param{const wxString\& }{ newName}}
-
-Renames a subgroup of the current group. The subgroup names (both the old and
-the new one) shouldn't contain backslashes, i.e. only simple names and not
-arbitrary paths are accepted by this function.
-
-Returns FALSE if the {\it oldName} doesn't exist or if {\it newName} already
-exists.
-
-\membersection{wxConfigBase::Set}\label{wxconfigbaseset}
-
-\func{static wxConfigBase *}{Set}{\param{wxConfigBase *}{pConfig}}
-
-Sets the config object as the current one, returns the pointer to the previous
-current object (both the parameter and returned value may be NULL)
-
-\membersection{wxConfigBase::SetExpandEnvVars}\label{wxconfigbasesetexpandenvvars}
-
-\func{void}{SetExpandEnvVars }{\param{bool }{bDoIt = TRUE}}
-
-Determine whether we wish to expand environment variables in key values.
-
-\membersection{wxConfigBase::SetPath}\label{wxconfigbasesetpath}
-
-\func{void}{SetPath}{\param{const wxString\& }{strPath}}
-
-Set current path: if the first character is '/', it is the absolute path,
-otherwise it is a relative path. '..' is supported. If the strPath doesn't
-exist it is created.
-
-\membersection{wxConfigBase::SetRecordDefaults}\label{wxconfigbasesetrecorddefaults}
-
-\func{void}{SetRecordDefaults}{\param{bool }{bDoIt = TRUE}}
-
-Sets whether defaults are recorded to the config file whenever an attempt to
-read read the value which is not present in it is done.
-
-If on (default is off) all default values for the settings used by the program
-are written back to the config file. This allows the user to see what config
-options may be changed and is probably useful only for wxFileConfig.
-
-\membersection{wxConfigBase::SetUmask}\label{wxfileconfigsetumask}
-
-\func{void}{SetUmask}{\param{int }{mode}}
-
-{\bf NB:} this function is not in the base wxConfigBase class but is only
-implemented in wxFileConfig. Moreover, this function is Unix-specific and
-doesn't do anything on other platforms.
-
-SetUmask() allows to set the mode to be used for the config file creation.
-For example, to create a config file which is not readable by other users
-(useful if it stores some sensitive information, such as passwords), you
-should do {\tt SetUmask(0077)}.
-
-\membersection{wxConfigBase::Write}\label{wxconfigbasewrite}
-
-\func{bool}{Write}{\param{const wxString\& }{ key}, \param{const wxString\& }{
-value}}
-
-\func{bool}{Write}{\param{const wxString\& }{ key}, \param{long}{ value}}
-
-\func{bool}{Write}{\param{const wxString\& }{ key}, \param{double}{ value}}
-
-\func{bool}{Write}{\param{const wxString\& }{ key}, \param{bool}{ value}}
-
-These functions write the specified value to the config file and return TRUE
-on success.
-
-\pythonnote{In place of a single overloaded method name, wxPython
-implements the following methods:\par
-\indented{2cm}{\begin{twocollist}
-\twocolitem{{\bf Write(key, value)}}{Writes a string.}
-\twocolitem{{\bf WriteInt(key, value)}}{Writes an int.}
-\twocolitem{{\bf WriteFloat(key, value)}}{Writes a floating point number.}
-\end{twocollist}}
-}
-
-\perlnote{In place of a single overloaded method, wxPerl uses:\par
-\indented{2cm}{\begin{twocollist}
-\twocolitem{{\bf Write(key, value)}}{Writes a string}
-\twocolitem{{\bf WriteInt(key, value)}}{Writes an integer}
-\twocolitem{{\bf WriteFloat(key, value)}}{Writes a floating point number}
-\twocolitem{{\bf WriteBool(key, value)}}{Writes a boolean}
-\end{twocollist}
-}}

docs/latex/wx/constant.tex

@@ -1,10 +0,0 @@
-\chapter{Constants}\label{constants}
-\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
-\setfooter{\thepage}{}{}{}{}{\thepage}
-
-This chapter describes the constants defined by wxWindows.
-
-\input cppconst.tex
-\input stdevtid.tex
-\input keycode.tex
-

docs/latex/wx/control.tex

@@ -1,41 +0,0 @@
-\section{\class{wxControl}}\label{wxcontrol}
-
-This is the base class for a control or `widget'.
-
-A control is generally a small window which processes user input and/or displays one or more item
-of data.
-
-\wxheading{Derived from}
-
-\helpref{wxWindow}{wxwindow}\\
-\helpref{wxEvtHandler}{wxevthandler}\\
-\helpref{wxObject}{wxobject}
-
-\wxheading{Include files}
-
-<wx/control.h>
-
-\wxheading{See also}
-
-\helpref{wxValidator}{wxvalidator}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxControl::Command}\label{wxcontrolcommand}
-
-\func{void}{Command}{\param{wxCommandEvent\& }{event}}
-
-Simulates the effect of the user issuing a command to the item. See \helpref{wxCommandEvent}{wxcommandevent}.
-
-\membersection{wxControl::GetLabel}\label{wxcontrolgetlabel}
-
-\func{wxString\&}{GetLabel}{\void}
-
-Returns the control's text.
-
-\membersection{wxControl::SetLabel}\label{wxcontrolsetlabel}
-
-\func{void}{SetLabel}{\param{const wxString\& }{label}}
-
-Sets the item's text.
-

docs/latex/wx/countstr.tex

@@ -1,46 +0,0 @@
-% -----------------------------------------------------------------------------
-% wxCountingOutputStream
-% -----------------------------------------------------------------------------
-\section{\class{wxCountingOutputStream}}\label{wxcountingoutputstream}
-
-wxCountingOutputStream is a specialized output stream which does not write any data anyway,
-instead it counts how many bytes would get written if this were a normal stream. This
-can sometimes be useful or required if some data gets serialized to a stream or compressed
-by using stream compression and thus the final size of the stream cannot be known other
-than pretending to write the stream. One case where the resulting size would have to be
-known is if the data has to be written to a piece of memory and the memory has to be
-allocated before writing to it (which is probably always the case when writing to a 
-memory stream).
-
-\wxheading{Derived from}
-
-\helpref{wxOutputStream}{wxoutputstream}
-\helpref{wxStreamBase}{wxstreambase}
-
-\wxheading{Include files}
-
-<wx/stream.h>
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-% -----------
-% ctor & dtor
-% -----------
-\membersection{wxCountingOutputStream::wxCountingOutputStream}
-
-\func{}{wxCountingOutputStream}{\void}
-
-Creates a wxCountingOutputStream object.
-
-\membersection{wxCountingOutputStream::\destruct{wxCountingOutputStream}}
-
-\func{}{\destruct{wxCountingOutputStream}}{\void}
-
-Destructor.
-
-\membersection{wxCountingOutputStream::GetSize}
-
-\constfunc{size\_t}{GetSize}{\void}
-
-Returns the current size of the stream.
-

docs/latex/wx/cppconst.tex

@@ -1,106 +0,0 @@
-\section{Preprocesser symbols defined by wxWindows}\label{cppconst}
-
-Here is the list of preprocessor symbols used in the wxWindows source grouped
-by category (and sorted by alphabetical order inside each category).
-
-\subsection{GUI system}
-
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\_\_WINDOWS\_\_}{any Windows, yom may also use \_\_WXMSW\_\_}
-\twocolitem{\_\_WIN16\_\_}{Win16 API}
-\twocolitem{\_\_WIN32\_\_}{Win32 API}
-\twocolitem{\_\_WIN95\_\_}{Windows 95 or NT 4.0 and above system (not NT 3.5x)}
-\twocolitem{\_\_WXGTK\_\_}{GTK}
-\twocolitem{\_\_WXGTK12\_\_}{GTK 1.2 or higher}
-\twocolitem{\_\_WXGTK20\_\_}{GTK 2.0 or higher}
-\twocolitem{\_\_WXMOTIF\_\_}{Motif}
-\twocolitem{\_\_WXMAC\_\_}{Mac OS whether Classic (Mac OS 8/9 TARGET\_CARBON == 0) or Carbon (including Mac OS X TARGET\_CARBON == 1)}
-\twocolitem{\_\_WXMGL\_\_}{SciTech Soft MGL (\_\_WXUNIVERSAL\_\_ will be also
-defined)}
-\twocolitem{\_\_WXMSW\_\_}{Any Windows}
-\twocolitem{\_\_WXOS2\_\_}{Identical to \_\_WXPM\_\_}
-\twocolitem{\_\_WXPM\_\_}{OS/2 native Presentation Manager}
-\twocolitem{\_\_WXSTUBS\_\_}{Stubbed version ('template' wxWin implementation)}
-\twocolitem{\_\_WXXT\_\_}{Xt; mutually exclusive with WX\_MOTIF, not
-implemented in wxWindows 2.x}
-\twocolitem{\_\_WXX11\_\_}{wxX11 (\_\_WXUNIVERSAL\_\_ will be also defined)}
-\twocolitem{\_\_WXWINE\_\_}{WINE (i.e. Win32 on Unix)}
-\twocolitem{\_\_WXUNIVERSAL\_\_}{wxUniversal port, always defined in addition
-to one of the symbols above so this should be tested first.}
-\twocolitem{\_\_X\_\_}{any X11-based GUI toolkit except GTK+}
-\end{twocollist}
-
-In fact, they should better all start with \_\_WX instead of \_\_ only. The
-only GUIs implemented for 2.0 are \_\_WXGTK\_\_, \_\_WXMSW\_\_ and
-\_\_WXMOTIF\_\_ yet. Any new ones, please start the define with \_\_WX.
-
-\subsection{Operating systems}
-
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\_\_APPLE\_\_}{any Mac OS version}
-\twocolitem{\_\_AIX\_\_}{AIX}
-\twocolitem{\_\_BSD\_\_}{Any *BSD system}
-\twocolitem{\_\_CYGWIN\_\_}{Cygwin: Unix on Win32}
-\twocolitem{\_\_DARWIN\_\_}{Mac OS X using the BSD Unix C library (as opposed to using the Metrowerks MSL C/C++ library)}
-\twocolitem{\_\_DATA\_GENERAL\_\_}{DG-UX}
-\twocolitem{\_\_DOS\_GENERAL\_\_}{DOS (used with wxMGL only)}
-\twocolitem{\_\_FREEBSD\_\_}{FreeBSD}
-\twocolitem{\_\_HPUX\_\_}{HP-UX (Unix)}
-\twocolitem{\_\_LINUX\_\_}{Linux}
-\twocolitem{\_\_MACH\_\_}{Mach-O Architecture (Mac OS X only builds)}
-\twocolitem{\_\_OSF\_\_}{OSF/1}
-\twocolitem{\_\_SGI\_\_}{IRIX}
-\twocolitem{\_\_SOLARIS\_\_}{Solaris}
-\twocolitem{\_\_SUN\_\_}{Any Sun}
-\twocolitem{\_\_SUNOS\_\_}{Sun OS}
-\twocolitem{\_\_SVR4\_\_}{SystemV R4}
-\twocolitem{\_\_SYSV\_\_}{SystemV generic}
-\twocolitem{\_\_ULTRIX\_\_}{Ultrix}
-\twocolitem{\_\_UNIX\_\_}{any Unix}
-\twocolitem{\_\_UNIX\_LIKE\_\_}{Unix, BeOS or VMS}
-\twocolitem{\_\_VMS\_\_}{VMS}
-\twocolitem{\_\_WINDOWS\_\_}{any Windows}
-\end{twocollist}
-
-\subsection{Hardware architectures}
-
-Note that not all of these symbols are always defined, it depends on the
-compiler used.
-
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\_\_ALPHA\_\_}{DEC Alpha architecture}
-\twocolitem{\_\_INTEL\_\_}{Intel i386 or compatible}
-\twocolitem{\_\_POWERPC\_\_}{Motorola Power PC}
-\end{twocollist}
-
-\subsection{Compilers}
-
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\_\_BORLANDC\_\_}{Borland C++. The value of the macro corresponds
-to the compiler version: $500$ is $5.0$.}
-\twocolitem{\_\_DJGPP\_\_}{DJGPP}
-\twocolitem{\_\_GNUG\_\_}{Gnu C++ on any platform, see also 
-\helpref{wxCHECK\_GCC\_VERSION}{wxcheckgccversion}}
-\twocolitem{\_\_GNUWIN32\_\_}{Gnu-Win32 compiler, see also 
-\helpref{wxCHECK\_W32API\_VERSION}{wxcheckw32apiversion}}
-\twocolitem{\_\_MWERKS\_\_}{CodeWarrior MetroWerks compiler}
-\twocolitem{\_\_SUNCC\_\_}{Sun CC}
-\twocolitem{\_\_SYMANTECC\_\_}{Symantec C++}
-\twocolitem{\_\_VISAGECPP\_\_}{IBM Visual Age (OS/2)}
-\twocolitem{\_\_VISUALC\_\_}{Microsoft Visual C++. The value of this macro
-corresponds to the compiler version: $1020$ for $4.2$ (the first supported
-version), $1100$ for $5.0$, $1200$ for $6.0$ and so on}
-\twocolitem{\_\_XLC\_\_}{AIX compiler}
-\twocolitem{\_\_WATCOMC\_\_}{Watcom C++. The value of this macro corresponds to
-the compiler version, $1100$ is $11.0$ and $1200$ is OpenWatcom.}
-\end{twocollist}
-
-\subsection{Miscellaneous}
-
-\begin{twocollist}\itemsep=0pt
-\twocolitem{\_\_WXDEBUG\_\_}{defined in debug mode, undefined in release mode}
-\twocolitem{wxUSE\_XXX}{if defined as $1$, feature XXX is active
-(the symbols of this form are always defined, use #if and not #ifdef to test
- for them)}
-\end{twocollist}
-

docs/latex/wx/critsect.tex

@@ -1,58 +0,0 @@
-\section{\class{wxCriticalSection}}\label{wxcriticalsection}
-
-A critical section object is used for exactly the same purpose as 
-\helpref{mutexes}{wxmutex}. The only difference is that under Windows platform
-critical sections are only visible inside one process, while mutexes may be
-shared between processes, so using critical sections is slightly more
-efficient. The terminology is also slightly different: mutex may be locked (or
-acquired) and unlocked (or released) while critical section is entered and left
-by the program.
-
-Finally, you should try to use 
-\helpref{wxCriticalSectionLocker}{wxcriticalsectionlocker} class whenever
-possible instead of directly using wxCriticalSection for the same reasons 
-\helpref{wxMutexLocker}{wxmutexlocker} is preferrable to 
-\helpref{wxMutex}{wxmutex} - please see wxMutex for an example.
-
-\wxheading{Derived from}
-
-None.
-
-\wxheading{Include files}
-
-<wx/thread.h>
-
-\wxheading{See also}
-
-\helpref{wxThread}{wxthread}, \helpref{wxCondition}{wxcondition}, 
-\helpref{wxMutexLocker}{wxmutexlocker}, \helpref{wxCriticalSection}{wxcriticalsection}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCriticalSection::wxCriticalSection}\label{wxcriticalsectionctor}
-
-\func{}{wxCriticalSection}{\void}
-
-Default constructor initializes critical section object.
-
-\membersection{wxCriticalSection::\destruct{wxCriticalSection}}\label{wxcriticalsectiondtor}
-
-\func{}{\destruct{wxCriticalSection}}{\void}
-
-Destructor frees the resources.
-
-\membersection{wxCriticalSection::Enter}\label{wxcriticalsectionenter}
-
-\func{void }{Enter}{\void}
-
-Enter the critical section (same as locking a mutex). There is no error return
-for this function. After entering the critical section protecting some global
-data the thread running in critical section may safely use/modify it.
-
-\membersection{wxCriticalSection::Leave}\label{wxcriticalsectionleave}
-
-\func{void }{Leave}{\void}
-
-Leave the critical section allowing other threads use the global data protected
-by it. There is no error return for this function.
-

docs/latex/wx/crtslock.tex

@@ -1,63 +0,0 @@
-\section{\class{wxCriticalSectionLocker}}\label{wxcriticalsectionlocker}
-
-This is a small helper class to be used with \helpref{wxCriticalSection}{wxcriticalsection} 
-objects. A wxCriticalSectionLocker enters the critical section in the
-constructor and leaves it in the destructor making it much more difficult to
-forget to leave a critical section (which, in general, will lead to serious
-and difficult to debug problems).
-
-Example of using it:
-
-\begin{verbatim}
-void Set Foo()
-{
-    // gs_critSect is some (global) critical section guarding access to the
-    // object "foo"
-    wxCriticalSectionLocker locker(gs_critSect);
-
-    if ( ... )
-    {
-        // do something
-        ...
-
-        return;
-    }
-
-    // do something else
-    ...
-
-    return;
-}
-\end{verbatim}
-
-Without wxCriticalSectionLocker, you would need to remember to manually leave
-the critical section before each {\tt return}.
-
-\wxheading{Derived from}
-
-None.
-
-\wxheading{Include files}
-
-<wx/thread.h>
-
-\wxheading{See also}
-
-\helpref{wxCriticalSection}{wxcriticalsection}, 
-\helpref{wxMutexLocker}{wxmutexlocker}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCriticalSectionLocker::wxCriticalSectionLocker}\label{wxcriticalsectionlockerctor}
-
-\func{}{wxCriticalSectionLocker}{\param{wxCriticalSection\& }{criticalsection}}
-
-Constructs a wxCriticalSectionLocker object associated with given
-{\it criticalsection} and enters it.
-
-\membersection{wxCriticalSectionLocker::\destruct{wxCriticalSectionLocker}}\label{wxcriticalsectionlockerdtor}
-
-\func{}{\destruct{wxCriticalSectionLocker}}{\void}
-
-Destructor leaves the critical section.
-

docs/latex/wx/csconv.tex

@@ -1,60 +0,0 @@
-%
-% automatically generated by HelpGen from
-% ../include/wx/strconv.h at 25/Mar/00 10:20:56
-%
-
-\section{\class{wxCSConv}}\label{wxcsconv}
-
-This class converts between any character sets and Unicode.
-It has one predefined instance, {\bf wxConvLocal}, for the
-default user character set.
-
-\wxheading{Derived from}
-
-\helpref{wxMBConv}{wxmbconv}
-
-\wxheading{Include files}
-
-<wx/strconv.h>
-
-\wxheading{See also}
-
-\helpref{wxMBConv}{wxmbconv}, 
-\helpref{wxEncodingConverter}{wxencodingconverter}, 
-\helpref{wxMBConv classes overview}{mbconvclasses}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxCSConv::wxCSConv}\label{wxcsconvwxcsconv}
-
-\func{}{wxCSConv}{\param{const wxChar* }{charset}}
-
-Constructor. Specify the name of the character set you want to convert
-from/to.
-
-\membersection{wxCSConv::\destruct{wxCSConv}}\label{wxcsconvdtor}
-
-\func{}{\destruct{wxCSConv}}{\void}
-
-Destructor.
-
-\membersection{wxCSConv::LoadNow}\label{wxcsconvloadnow}
-
-\func{void}{LoadNow}{\void}
-
-If the conversion tables needs to be loaded from disk, this method
-will do so. Otherwise, they will be loaded when any of the conversion
-methods are called.
-
-\membersection{wxCSConv::MB2WC}\label{wxcsconvmb2wc}
-
-\constfunc{size\_t}{MB2WC}{\param{wchar\_t* }{buf}, \param{const char* }{psz}, \param{size\_t }{n}}
-
-Converts from the selected character set to Unicode. Returns the size of the destination buffer.
-
-\membersection{wxCSConv::WC2MB}\label{wxcsconvwc2mb}
-
-\constfunc{size\_t}{WC2MB}{\param{char* }{buf}, \param{const wchar\_t* }{psz}, \param{size\_t }{n}}
-
-Converts from Unicode to the selected character set. Returns the size of the destination buffer.
-