[arch-commits] Commit in codeblocks/repos (5 files)
Antonio Rojas
arojas at gemini.archlinux.org
Mon Jul 11 16:39:20 UTC 2022
Date: Monday, July 11, 2022 @ 16:39:20
Author: arojas
Revision: 1249591
archrelease: copy trunk to community-staging-x86_64
Added:
codeblocks/repos/community-staging-x86_64/
codeblocks/repos/community-staging-x86_64/PKGBUILD
(from rev 1249590, codeblocks/trunk/PKGBUILD)
codeblocks/repos/community-staging-x86_64/codeblocks-gcc11.patch
(from rev 1249590, codeblocks/trunk/codeblocks-gcc11.patch)
codeblocks/repos/community-staging-x86_64/sc_wxtypes-normalize.patch
(from rev 1249590, codeblocks/trunk/sc_wxtypes-normalize.patch)
codeblocks/repos/community-staging-x86_64/wxwidgets-3.2.patch
(from rev 1249590, codeblocks/trunk/wxwidgets-3.2.patch)
----------------------------+
PKGBUILD | 81 ++
codeblocks-gcc11.patch | 13
sc_wxtypes-normalize.patch | 13
wxwidgets-3.2.patch | 1590 +++++++++++++++++++++++++++++++++++++++++++
4 files changed, 1697 insertions(+)
Copied: codeblocks/repos/community-staging-x86_64/PKGBUILD (from rev 1249590, codeblocks/trunk/PKGBUILD)
===================================================================
--- community-staging-x86_64/PKGBUILD (rev 0)
+++ community-staging-x86_64/PKGBUILD 2022-07-11 16:39:20 UTC (rev 1249591)
@@ -0,0 +1,81 @@
+# Maintainer: Balló György <ballogyor+arch at gmail dot com>
+# Contributor: Alexander F Rødseth <xyproto at archlinux.org>
+# Contributor: Bartłomiej Piotrowski <nospam at bpiotrowski.pl>
+# Contributor: Robert Hollencamp <rhollencamp at gmail.com>
+# Contributor: Daniel J Griffiths <griffithsdj at inbox.com>
+# Contributor: Stefan Husmann <stefan-husmann at t-online.de>
+# Contributor: Roman Mikhayloff <rimf at inbox.ru>
+
+pkgname=codeblocks
+pkgver=20.03
+pkgrel=3
+pkgdesc='Cross-platform C/C++ IDE'
+arch=('x86_64')
+url='http://codeblocks.org/'
+license=('GPL3')
+depends=('boost-libs' 'wxwidgets-gtk3' 'hunspell')
+makedepends=('boost' 'imagemagick' 'zip')
+source=("https://downloads.sourceforge.net/codeblocks/$pkgname-$pkgver.tar.xz"
+ codeblocks-gcc11.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/40eb88e3f2b933f19f9933e06c8d0899c54f5e25.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/56ac0396fad7a5b4bbb40bb8c4b5fe1755078aef.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/a4aacc92640b587ad049cd6aa68c637e536e9ab5.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/f2f127cf5cd97c7da6a957a3f7764cb25cc9017e.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/04b7c50fb8c6a29b2d84579ee448d2498414d855.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/2345b020b862ec855038dd32a51ebb072647f28d.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/dbdf5c5ea9e3161233f0588a7616b7e4fedc7870.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/8035dfdff321754819f79e3165401aa59bd8c7f7.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/9a9c6a9d5e3e0f6eff5594ecd61a2222f073be9c.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/c28746f4887f10e6f9f10eeafae0fb22ecdbf9c7.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/b2e4f1279804e1d11b71bc75eeb37072c3589296.patch
+ https://github.com/arnholm/codeblocks_sfmirror/commit/29315df024251850832583f73e67e515dae10830.patch
+ sc_wxtypes-normalize.patch)
+sha256sums=('15eeb3e28aea054e1f38b0c7f4671b4d4d1116fd05f63c07aa95a91db89eaac5'
+ '10b2b08440adc447d1d23eb122fa37beff1f26b9d7588b83f8435721586f4ed1'
+ '0f9a3ae205afd358eeb643d5553f57f43cb0494c54ebd0a03f2c07d08df7713a'
+ 'fda1ed975756f8b12b8d84e91be890becaa0fcd3797fd7d36df393531f42f5ea'
+ '520ee4ad5264d2a602c034259c3e47f768906f18fbc9a45c7102344345e17ebf'
+ '4ab925d798922394ca28193b459515c6cd6f647629b867487eb9e4a40bbcc988'
+ 'b98ed0bfe926903ce16daea8b16973adfe97a3b8b12b628bc76b27e3fd1eccf5'
+ '28e23c2e1d1fd22d47c9a8bc318cd80d96eee23e03d397e59d2bf775cb802db7'
+ '2e62744218373cbba213f33eb4c473ac464dc8f3267253097fdf6ed39fedac0f'
+ '29bb2bbe3262b5590567227f79fa2513570dd69102bb4932e8bb77dc4f087398'
+ 'cd12faec5678cf0c0906a3f7fe7cd09fc2eecf5b5fbb9d9ce7c6b6effd89af33'
+ '309eb824493a36f5ad9b51bc29af77730a0cf8698f75584c95bdd16f22f3fc78'
+ 'c9723cac8ca690694b9db867b9b65736a1596958e153efd7672bf89ce832a6bd'
+ '8a89646c875e2c4f39019a58c378531b3bbe5e0a21deb18f679a799da0e2321b'
+ 'a4d39d3016fe128e521c38a23b7b25ce94ea18263498a60d6224729dee528564')
+
+prepare() {
+ cd $pkgname-$pkgver
+ convert src/mime/codeblocks.png +set date:create +set date:modify -background none -extent 64x64 src/mime/codeblocks.png
+ sed -i 's|$(datadir)/pixmaps|$(datadir)/icons/hicolor/64x64/apps|' src/mime/Makefile.{am,in}
+ sed -i 's|$(datarootdir)/appdata|$(datarootdir)/metainfo|' Makefile.{am,in} src/plugins/contrib/appdata/Makefile.{am,in}
+
+ patch -p1 < ../codeblocks-gcc11.patch # Fix build with GCC 11 (Fedora)
+ patch -p1 < ../2345b020b862ec855038dd32a51ebb072647f28d.patch # Fix build with wxWidgets 3.2
+ patch -p1 < ../40eb88e3f2b933f19f9933e06c8d0899c54f5e25.patch
+ patch -p1 -F3 < ../56ac0396fad7a5b4bbb40bb8c4b5fe1755078aef.patch
+ patch -p1 < ../a4aacc92640b587ad049cd6aa68c637e536e9ab5.patch
+ patch -p1 < ../f2f127cf5cd97c7da6a957a3f7764cb25cc9017e.patch
+ patch -p1 < ../dbdf5c5ea9e3161233f0588a7616b7e4fedc7870.patch
+ patch -p1 < ../04b7c50fb8c6a29b2d84579ee448d2498414d855.patch
+ patch -p1 < ../8035dfdff321754819f79e3165401aa59bd8c7f7.patch
+ patch -p1 < ../9a9c6a9d5e3e0f6eff5594ecd61a2222f073be9c.patch
+ patch -p1 < ../c28746f4887f10e6f9f10eeafae0fb22ecdbf9c7.patch
+ patch -p1 < ../b2e4f1279804e1d11b71bc75eeb37072c3589296.patch
+ patch -p1 < ../29315df024251850832583f73e67e515dae10830.patch
+ patch -p1 < ../sc_wxtypes-normalize.patch
+}
+
+build() {
+ cd $pkgname-$pkgver
+ ./configure --prefix=/usr --with-contrib-plugins=all,-FileManager
+ sed -i 's/ -shared / -Wl,-O1,--as-needed\0/g' libtool
+ make
+}
+
+package() {
+ cd $pkgname-$pkgver
+ make DESTDIR="$pkgdir" install
+}
Copied: codeblocks/repos/community-staging-x86_64/codeblocks-gcc11.patch (from rev 1249590, codeblocks/trunk/codeblocks-gcc11.patch)
===================================================================
--- community-staging-x86_64/codeblocks-gcc11.patch (rev 0)
+++ community-staging-x86_64/codeblocks-gcc11.patch 2022-07-11 16:39:20 UTC (rev 1249591)
@@ -0,0 +1,13 @@
+diff --git a/src/plugins/openfileslist/openfileslistplugin.h b/src/plugins/openfileslist/openfileslistplugin.h
+index 7fd7a95..87b08ee 100644
+--- a/src/plugins/openfileslist/openfileslistplugin.h
++++ b/src/plugins/openfileslist/openfileslistplugin.h
+@@ -23,7 +23,7 @@ struct TargetFilesData
+ // Functor for the std::set predicate to sort the opened editor files according to their tab order
+ struct compareLess
+ {
+- bool operator()(const ProjectFile* lhs, const ProjectFile* rhs) { return lhs->editorTabPos < rhs->editorTabPos; }
++ bool operator()(const ProjectFile* lhs, const ProjectFile* rhs) const { return lhs->editorTabPos < rhs->editorTabPos; }
+ };
+ typedef std::set<ProjectFile*, compareLess> OpenFilesSet;
+ ProjectFile* activeFile;
Copied: codeblocks/repos/community-staging-x86_64/sc_wxtypes-normalize.patch (from rev 1249590, codeblocks/trunk/sc_wxtypes-normalize.patch)
===================================================================
--- community-staging-x86_64/sc_wxtypes-normalize.patch (rev 0)
+++ community-staging-x86_64/sc_wxtypes-normalize.patch 2022-07-11 16:39:20 UTC (rev 1249591)
@@ -0,0 +1,13 @@
+diff --git a/src/sdk/scripting/bindings/sc_wxtypes.cpp b/src/sdk/scripting/bindings/sc_wxtypes.cpp
+index 33cd09850..9a162bf9a 100644
+--- a/src/sdk/scripting/bindings/sc_wxtypes.cpp
++++ b/src/sdk/scripting/bindings/sc_wxtypes.cpp
+@@ -389,7 +389,6 @@ namespace ScriptBindings
+ func(&wxFileName::IsDir, "IsDir").
+ func(&wxFileName::MakeAbsolute, "MakeAbsolute").
+ func(&wxFileName::MakeRelativeTo, "MakeRelativeTo").
+- func(&wxFileName::Normalize, "Normalize").
+ func(&wxFileName::PrependDir, "PrependDir").
+ func(&wxFileName::RemoveDir, "RemoveDir").
+ func(&wxFileName::RemoveLastDir, "RemoveLastDir").
+
Copied: codeblocks/repos/community-staging-x86_64/wxwidgets-3.2.patch (from rev 1249590, codeblocks/trunk/wxwidgets-3.2.patch)
===================================================================
--- community-staging-x86_64/wxwidgets-3.2.patch (rev 0)
+++ community-staging-x86_64/wxwidgets-3.2.patch 2022-07-11 16:39:20 UTC (rev 1249591)
@@ -0,0 +1,1590 @@
+Index: sc_wxtypes.cpp
+===================================================================
+--- a/src/sdk/scripting/bindings/sc_wxtypes.cpp (revisión: 12231)
++++ b/src/sdk/scripting/bindings/sc_wxtypes.cpp (revisión: 12444)
+@@ -9,465 +9,1204 @@
+
+ #include "sdk_precomp.h"
+ #ifndef CB_PRECOMP
++ #include <wx/gdicmn.h>
++ #include <wx/intl.h>
+ #include <wx/string.h>
+- #include <globals.h>
+ #endif
++
++#include "scripting/bindings/sc_utils.h"
++#include "scripting/bindings/sc_typeinfo_all.h"
++
+ #include <wx/filename.h>
+-#include <wx/colour.h>
+
+-#include "sc_base_types.h"
++using namespace cb;
+
+ namespace ScriptBindings
+ {
+- ///////////////////
+- // wxArrayString //
+- ///////////////////
+- void wxArrayString_Clear(HSQUIRRELVM v)
++
++/// The _T() function for scripts.
++/// Returns new wxString squirrel instance which wraps the passed string as parameter.
++SQInteger static_T(HSQUIRRELVM v)
++{
++ // The first parameter is a environment table, because this is a global function.
++ // We don't care about it, so we skip it.
++ ExtractParams2<SkipParam, const SQChar*> extractor(v);
++ if (!extractor.Process("_T"))
++ return extractor.ErrorMessage();
++
++ return ConstructAndReturnInstance(v, cbC2U(extractor.p1));
++}
++
++/// The _() function for scripts
++SQInteger static_(HSQUIRRELVM v)
++{
++ // The first parameter is a environment table, because this is a global function.
++ // We don't care about it, so we skip it.
++ ExtractParams2<SkipParam, const SQChar*> extractor(v);
++ if (!extractor.Process("_T"))
++ return extractor.ErrorMessage();
++
++ return ConstructAndReturnInstance(v, wxGetTranslation(cbC2U(extractor.p1)));
++}
++
++SQInteger wxString_ctor(HSQUIRRELVM v)
++{
++ ExtractParamsBase extractor(v);
++ if (!extractor.CheckNumArguments(1, 2, "wxString_ctor"))
++ return extractor.ErrorMessage();
++ const int numArgs = sq_gettop(v);
++
++ if (numArgs == 1) // empty ctor
+ {
+- static_assert(wxMinimumVersion<2,8,12>::eval, "wxWidgets 2.8.12 is required");
+- StackHandler sa(v);
+- wxArrayString& self = *SqPlus::GetInstance<wxArrayString,false>(v, 1);
+- self.Clear();
++ UserDataForType<wxString> *data;
++ data = SetupUserPointer<wxString, InstanceAllocationMode::InstanceIsInline>(v, 1);
++ if (!data)
++ return -1; // SetupUserPointer should have called sq_throwerror!
++ new (&(data->userdata)) wxString();
++ return 0;
+ }
+- SQInteger wxArrayString_GetCount(HSQUIRRELVM v)
++ else
+ {
+- static_assert(wxMinimumVersion<2,8,12>::eval, "wxWidgets 2.8.12 is required");
+- StackHandler sa(v);
+- wxArrayString& self = *SqPlus::GetInstance<wxArrayString,false>(v, 1);
+- return sa.Return((SQInteger)self.GetCount());
++ // 1 argument ctor
++ const SQObjectType type = sq_gettype(v, 2);
++ switch (type)
++ {
++ case OT_STRING:
++ {
++ // Construct from Squirrel string
++ const SQChar *value = extractor.GetParamString(2);
++ cbAssert(value);
++ UserDataForType<wxString> *data;
++ data = SetupUserPointer<wxString, InstanceAllocationMode::InstanceIsInline>(v, 1);
++ if (!data)
++ return -1; // SetupUserPointer should have called sq_throwerror!
++ new (&(data->userdata)) wxString(value);
++ return 0;
++ }
++ case OT_INSTANCE:
++ {
++ // Construct from wxString
++ wxString *value;
++ if (!extractor.ProcessParam(value, 2, "wxString_ctor"))
++ return extractor.ErrorMessage();
++ UserDataForType<wxString> *data;
++ data = SetupUserPointer<wxString, InstanceAllocationMode::InstanceIsInline>(v, 1);
++ if (!data)
++ return -1; // SetupUserPointer should have called sq_throwerror!
++ new (&(data->userdata)) wxString(*value);
++ return 0;
++ }
++ default:
++ return sq_throwerror(v, _SC("Unsupported argument type passed to wxString constructor!"));
++ }
+ }
++}
+
+- SQInteger wxArrayString_Index(HSQUIRRELVM v)
++SQInteger wxString_OpAdd(HSQUIRRELVM v)
++{
++ // TODO: Optional Args
++ ExtractParamsBase extractor(v);
++ if (!extractor.CheckNumArguments(2, "wxString_OpAdd"))
++ return extractor.ErrorMessage();
++
++ // Squirrel doesn't call us, the first parameter is not a wxString.
++ const wxString *s1 = nullptr;
++ if (!extractor.ProcessParam(s1, 1, "wxString_OpAdd"))
++ return extractor.ErrorMessage();
++
++ wxString result = *s1;
++ const SQObjectType type2 = sq_gettype(v, 2);
++ switch (type2)
+ {
+- static_assert(wxMinimumVersion<2,8,12>::eval, "wxWidgets 2.8.12 is required");
+- StackHandler sa(v);
+- wxArrayString& self = *SqPlus::GetInstance<wxArrayString,false>(v, 1);
+- wxString inpstr = *SqPlus::GetInstance<wxString,false>(v, 2);
+- bool chkCase = true;
+- bool frmEnd = false;
+- if (sa.GetParamCount() >= 3)
+- chkCase = sa.GetBool(3);
+- if (sa.GetParamCount() == 4)
+- frmEnd = sa.GetBool(4);
+- return sa.Return((SQInteger)self.Index(inpstr.c_str(), chkCase, frmEnd));
++ case OT_INSTANCE:
++ {
++ const wxString *s2 = nullptr;
++ if (!extractor.ProcessParam(s2, 2, "wxString_OpAdd"))
++ return extractor.ErrorMessage();
++ result += *s2;
++ break;
++ }
++ case OT_STRING:
++ {
++ const SQChar *s2 = nullptr;
++ if (!extractor.ProcessParam(s2, 2, "wxString_OpAdd"))
++ return extractor.ErrorMessage();
++ result << s2;
++ break;
++ }
++ case OT_INTEGER:
++ {
++ SQInteger s2;
++ if (!extractor.ProcessParam(s2, 2, "wxString_OpAdd"))
++ return extractor.ErrorMessage();
++ result << s2;
++ break;
++ }
++ case OT_FLOAT:
++ {
++ SQFloat s2;
++ if (!extractor.ProcessParam(s2, 2, "wxString_OpAdd"))
++ return extractor.ErrorMessage();
++ result << s2;
++ break;
++ }
++ default:
++ return sq_throwerror(v, _SC("Unknown type"));
+ }
+- SQInteger wxArrayString_SetItem(HSQUIRRELVM v)
+- {
+- StackHandler sa(v);
+- if (sa.GetParamCount() != 3)
+- return sq_throwerror(v, "wxArrayString::SetItem wrong number of parameters!");
+- wxArrayString& self = *SqPlus::GetInstance<wxArrayString,false>(v, 1);
+- int index = sa.GetInt(2);
+- if (index < 0 || size_t(index) >= self.GetCount())
+- return sq_throwerror(v, "wxArrayString::SetItem index out of bounds!");
+- const wxString &value = *SqPlus::GetInstance<wxString,false>(v, 3);
+- self[index] = value;
+- return 0;
+- }
+
+- //////////////
+- // wxColour //
+- //////////////
+- SQInteger wxColour_OpToString(HSQUIRRELVM v)
++ return ConstructAndReturnInstance(v, result);
++}
++
++SQInteger wxString_OpCompare(HSQUIRRELVM v)
++{
++ // TODO: Optional Args
++ ExtractParamsBase extractor(v);
++ if (!extractor.CheckNumArguments(2, "wxString_OpCompare"))
+ {
+- StackHandler sa(v);
+- wxColour& self = *SqPlus::GetInstance<wxColour,false>(v, 1);
+- wxString str = wxString::Format(_T("[r=%d, g=%d, b=%d]"), self.Red(), self.Green(), self.Blue());
+- return sa.Return((const SQChar*)str.mb_str(wxConvUTF8));
++ extractor.ErrorMessage();
++ return false;
+ }
+
+- ////////////////
+- // wxFileName //
+- ////////////////
+- SQInteger wxFileName_OpToString(HSQUIRRELVM v)
++ const SQObjectType type1 = sq_gettype(v, 1);
++ const SQObjectType type2 = sq_gettype(v, 2);
++
++ if (type1 == OT_STRING && type2 == OT_INSTANCE)
+ {
+- StackHandler sa(v);
+- wxFileName& self = *SqPlus::GetInstance<wxFileName,false>(v, 1);
+- return sa.Return((const SQChar*)self.GetFullPath().mb_str(wxConvUTF8));
++ const SQChar *s1;
++ const wxString *s2;
++ if (extractor.ProcessParam(s1, 1, "wxString_OpCompare")
++ && extractor.ProcessParam(s2, 2, "wxString_OpCompare"))
++ {
++ wxString temp1(s1);
++ sq_pushinteger(v, temp1.Cmp(*s2));
++ return 1;
++ }
++ else
++ return extractor.ErrorMessage();
+ }
+
+- /////////////
+- // wxPoint //
+- /////////////
++ // At least one of the parameters is a wxString. It is not the seconds, so at least the first
++ // one is a wxString.
++ const wxString *s1 = nullptr;
++ if (!extractor.ProcessParam(s1, 1, "wxString_OpCompare"))
++ return extractor.ErrorMessage();
+
+- template<typename UserType>
+- SQInteger wxPointSize_OpToString(HSQUIRRELVM v)
++ if (type2 == OT_STRING)
+ {
+- StackHandler sa(v);
+- const UserType *self = SqPlus::GetInstance<UserType, false>(v, 1);
+- if (!self)
+- return sa.ThrowError(_SC("Cannot extract 'this'!"));
+- SQChar buf[100];
+- scsprintf(buf, "[%d,%d]", self->x, self->y);
+- return sa.Return(buf);
++ const SQChar *s2;
++ if (!extractor.ProcessParam(s2, 2, "wxString_OpCompare"))
++ return extractor.ErrorMessage();
++ sq_pushinteger(v, s1->Cmp(wxString(s2)));
++ return 1;
+ }
+
+- // wxPoint operator==
+- SQInteger wxPoint_OpCmp(HSQUIRRELVM v)
+- {
+- StackHandler sa(v);
+- const wxPoint *self = SqPlus::GetInstance<wxPoint,false>(v, 1);
+- if (!self)
+- return sa.ThrowError(_SC("wxPoint_OpCmp: Cannot extract 'this'!"));
+- const wxPoint *other = SqPlus::GetInstance<wxPoint,false>(v, 2);
+- if (!other)
+- return sa.ThrowError(_SC("wxPoint_OpCmp: Cannot extract 'other!"));
++ const wxString *s2;
++ if (!extractor.ProcessParam(s2, 2, "wxString_OpCompare"))
++ return extractor.ErrorMessage();
++ sq_pushinteger(v, s1->Cmp(*s2));
++ return 1;
++}
+
+- SQInteger res;
+- if (self->x < other->x)
+- res = -1;
+- else if (self->x > other->x)
+- res = 1;
+- else
+- {
+- if (self->y < other->y)
+- res = -1;
+- else if (self->y > other->y)
+- res = 1;
+- else
+- res = 0;
+- }
+- return sa.Return(res);
+- }
+- SQInteger wxPoint_x(HSQUIRRELVM v)
++SQInteger wxString_OpToString(HSQUIRRELVM v)
++{
++ ExtractParams1<const wxString*> extractor(v);
++ if (!extractor.Process("wxString::_tostring"))
++ return extractor.ErrorMessage();
++
++ sq_pushstring(v, extractor.p0->utf8_str().data(), -1);
++ return 1;
++}
++
++SQInteger wxString_Find(HSQUIRRELVM v)
++{
++ ExtractParams2<const wxString*, const wxString*> extractor(v);
++ if (!extractor.Process("wxString_Find"))
++ return extractor.ErrorMessage();
++
++ sq_pushinteger(v, extractor.p0->Find(*extractor.p1));
++ return 1;
++}
++
++SQInteger wxString_Matches(HSQUIRRELVM v)
++{
++ ExtractParams2<const wxString*, const wxString*> extractor(v);
++ if (!extractor.Process("wxString_Matches"))
++ return extractor.ErrorMessage();
++
++ sq_pushbool(v, extractor.p0->Matches(*extractor.p1));
++ return 1;
++}
++
++SQInteger wxString_AddChar(HSQUIRRELVM v)
++{
++ ExtractParams2<wxString*, SQInteger> extractor(v);
++ if (!extractor.Process("wxString_AddChar"))
++ return extractor.ErrorMessage();
++ char tmp[8];
++ snprintf(tmp, 8, "%c", char(extractor.p1));
++ *extractor.p0 += cbC2U(tmp);
++ return 0;
++}
++
++SQInteger wxString_GetChar(HSQUIRRELVM v)
++{
++ ExtractParams2<const wxString*, SQInteger> extractor(v);
++ if (!extractor.Process("wxString_GetChar"))
++ return extractor.ErrorMessage();
++ if (extractor.p1 < 0 || wxString::size_type(extractor.p1) >= extractor.p0->length())
++ return sq_throwerror(v, _SC("wxString_GetChar: Index outside of valid range!"));
++ sq_pushinteger(v, extractor.p0->GetChar(extractor.p1));
++ return 1;
++}
++
++SQInteger wxString_Set(HSQUIRRELVM v)
++{
++ ExtractParams2<wxString*, const wxString*> extractor(v);
++ if (!extractor.Process("wxString_Set"))
++ return extractor.ErrorMessage();
++ *extractor.p0 = *extractor.p1;
++ return 0;
++}
++
++SQInteger wxString_IsEmpty(HSQUIRRELVM v)
++{
++ ExtractParams1<const wxString*> extractor(v);
++ if (!extractor.Process("wxString::IsEmpty"))
++ return extractor.ErrorMessage();
++
++ sq_pushbool(v, extractor.p0->empty());
++ return 1;
++}
++
++SQInteger wxString_Length(HSQUIRRELVM v)
++{
++ ExtractParams1<const wxString*> extractor(v);
++ if (!extractor.Process("wxString_Length"))
++ return extractor.ErrorMessage();
++
++ sq_pushinteger(v, extractor.p0->Length());
++ return 1;
++}
++
++using wxStringDoSomethingAndReturnNewFunc = wxString& (wxString::*)();
++
++template<wxStringDoSomethingAndReturnNewFunc func>
++SQInteger wxString_NoParamReturnWxString(HSQUIRRELVM v)
++{
++ ExtractParams1<wxString*> extractor(v);
++ if (!extractor.Process("wxString_NoParamReturnWxString"))
++ return extractor.ErrorMessage();
++
++ return ConstructAndReturnInstance(v, (extractor.p0->*func)());
++}
++
++using wxStringDoSomethingNoReturnFunc = void (wxString::*)();
++
++template<wxStringDoSomethingNoReturnFunc func>
++SQInteger wxString_NoParamNoReturn(HSQUIRRELVM v)
++{
++ ExtractParams1<wxString*> extractor(v);
++ if (!extractor.Process("wxString_NoParamNoReturn"))
++ return extractor.ErrorMessage();
++ (extractor.p0->*func)();
++ return 0;
++}
++
++SQInteger wxString_Mid(HSQUIRRELVM v)
++{
++ ExtractParams3<const wxString*, SQInteger, SQInteger> extractor(v);
++ if (!extractor.Process("wxString_Mid"))
++ return extractor.ErrorMessage();
++
++ return ConstructAndReturnInstance(v, extractor.p0->Mid(extractor.p1, extractor.p2));
++}
++
++SQInteger wxString_Remove(HSQUIRRELVM v)
++{
++ ExtractParams3<wxString*, SQInteger, SQInteger> extractor(v);
++ if (!extractor.Process("wxString_Remove"))
++ return extractor.ErrorMessage();
++ if (extractor.p1 < 0)
++ return sq_throwerror(v, _SC("wxString::Remove: Parameter nStart needs to be non-negative!"));
++ if (extractor.p2 < 0)
++ return sq_throwerror(v, _SC("wxString::Remove: Parameter nLen needs to be non-negative!"));
++ wxString &res = extractor.p0->Remove(extractor.p1, extractor.p2);
++ assert(&res == extractor.p0);
++
++ DuplicateInstance(v, 1);
++
++ return 1;
++}
++
++SQInteger wxString_RemoveLast(HSQUIRRELVM v)
++{
++ ExtractParams2<wxString*, SQInteger> extractor(v);
++ if (!extractor.Process("wxString_RemoveLast"))
++ return extractor.ErrorMessage();
++ if (extractor.p1 < 0)
++ return sq_throwerror(v, _SC("wxString::RemoveLast: Parameter n needs to be non-negative!"));
++ wxString &res = extractor.p0->RemoveLast(extractor.p1);
++ assert(&res == extractor.p0);
++
++ DuplicateInstance(v, 1);
++
++ return 1;
++}
++
++SQInteger wxString_Replace(HSQUIRRELVM v)
++{
++ SQInteger result = -1;
++
++ // TODO: Optional Args
++ const int numArgs = sq_gettop(v);
++ if (numArgs == 3)
+ {
+- StackHandler sa(v);
+- wxPoint& self = *SqPlus::GetInstance<wxPoint,false>(v, 1);
+- return sa.Return((SQInteger)(self.x));
++ ExtractParams3<wxString*, const wxString*, const wxString*> extractor(v);
++ if (!extractor.Process("wxString_Replace"))
++ return extractor.ErrorMessage();
++ result = extractor.p0->Replace(*extractor.p1, *extractor.p2);
+ }
+- SQInteger wxPoint_y(HSQUIRRELVM v)
++ else if (numArgs == 4)
+ {
+- StackHandler sa(v);
+- wxPoint& self = *SqPlus::GetInstance<wxPoint,false>(v, 1);
+- return sa.Return((SQInteger)(self.y));
++ ExtractParams4<wxString*, const wxString*, const wxString*, bool> extractor(v);
++ if (!extractor.Process("wxString_Replace"))
++ return extractor.ErrorMessage();
++ result = extractor.p0->Replace(*extractor.p1, *extractor.p2, extractor.p3);
+ }
+
+- //////////////
+- // wxString //
+- //////////////
++ DuplicateInstance(v, 1);
++ sq_pushinteger(v, result);
+
+- // the _() function for scripts
+- wxString static_(const SQChar* str)
++ return 1;
++}
++
++using wxStringLeftRightFunc = wxString (wxString::*)(size_t) const;
++
++template<wxStringLeftRightFunc func>
++SQInteger wxString_LeftRight(HSQUIRRELVM v)
++{
++ ExtractParams2<const wxString*, SQInteger> extractor(v);
++ if (!extractor.Process("wxString_LeftRight"))
++ return extractor.ErrorMessage();
++ if (extractor.p1 < 0)
++ return sq_throwerror(v, _SC("wxString_LeftRight: nCount should be non-negative integer!"));
++
++ return ConstructAndReturnInstance(v, (extractor.p0->*func)(extractor.p1));
++}
++
++/// Extract parameters for a call to Before/After-First/Last kind of function.
++/// The first parameter is this/self wxString.
++/// The second parameter is the search character. Currently we support an int (for some kind of
++/// ascii, untested), const wxString*, const string. For both kind of strings we extract the first
++/// character.
++bool SetupFirstLastParams(HSQUIRRELVM v, const wxString *&self, wxUniChar &searchChar)
++{
++ // TODO: Optional Args
++ ExtractParamsBase extractor(v);
++ if (!extractor.CheckNumArguments(2, "SetupFirstLastParams"))
+ {
+- return wxGetTranslation(cbC2U(str));
++ extractor.ErrorMessage();
++ return false;
+ }
+
+- // the _T() function for scripts
+- wxString static_T(const SQChar* str)
++ self = nullptr;
++ if (!extractor.ProcessParam(self, 1, "SetupFirstLastParams"))
+ {
+- return cbC2U(str);
++ extractor.ErrorMessage();
++ return false;
+ }
+
+- SQInteger wxString_Set(HSQUIRRELVM v)
++ const SQObjectType charParamType = sq_gettype(v, 2);
++ switch (charParamType)
+ {
+- StackHandler sa(v);
+-
+- wxString *self = SqPlus::GetInstance<wxString, false>(v, 1);
+- if (!self)
+- return sa.ThrowError(_SC("Cannot extract 'this'!"));
+- const wxString *other = SqPlus::GetInstance<wxString, false>(v, 2);
+- if (!other)
+- return sa.ThrowError(_SC("Cannot extract 'other'!"));
+- self->assign(*other);
+- return sa.Return();
++ case OT_INTEGER:
++ {
++ SQInteger temp;
++ if (!extractor.ProcessParam(temp, 2, "SetupFirstLastParams"))
++ {
++ extractor.ErrorMessage();
++ return false;
++ }
++ searchChar = temp;
++ return true;
++ }
++ case OT_INSTANCE:
++ {
++ const wxString *search = nullptr;
++ if (!extractor.ProcessParam(search, 2, "SetupFirstLastParams"))
++ {
++ extractor.ErrorMessage();
++ return false;
++ }
++ if (search->length() < 1)
++ {
++ sq_throwerror(v, _SC("SetupFirstLastParams: String length too short!"));
++ return false;
++ }
++ searchChar = search->GetChar(0);
++ return true;
++ }
++ case OT_STRING:
++ {
++ const SQChar *search = nullptr;
++ if (!extractor.ProcessParam(search, 2, "SetupFirstLastParams"))
++ {
++ extractor.ErrorMessage();
++ return false;
++ }
++ if (search && search[0] != _SC('\0'))
++ searchChar = search[0];
++ else
++ {
++ sq_throwerror(v, _SC("SetupFirstLastParams: Invalid searchChar parameter!"));
++ return false;
++ }
++ return true;
++ }
++ default:
++ sq_throwerror(v, _SC("SetupFirstLastParams: Invalid searchChar parameter!"));
++ return false;
+ }
++}
+
+- // wxString operator+
+- SQInteger wxString_OpAdd(HSQUIRRELVM v)
++using wxStringDoAfterFirstLastFunc = wxString (wxString::*)(wxUniChar) const;
++
++template<wxStringDoAfterFirstLastFunc func>
++SQInteger wxString_DoAfterFirstLast(HSQUIRRELVM v)
++{
++ const wxString *self;
++ wxUniChar searchChar;
++ if (!SetupFirstLastParams(v, self, searchChar))
++ return -1; // An error should have been logged already.
++
++ return ConstructAndReturnInstance(v, (self->*func)(searchChar));
++}
++
++using wxStringDoBeforeFirstLastFunc = wxString (wxString::*)(wxUniChar, wxString *) const;
++
++template<wxStringDoBeforeFirstLastFunc func>
++SQInteger wxString_DoBeforeFirstLast(HSQUIRRELVM v)
++{
++ const wxString *self;
++ wxUniChar searchChar;
++ if (!SetupFirstLastParams(v, self, searchChar))
++ return -1; // An error should have been logged already.
++
++ return ConstructAndReturnInstance(v, (self->*func)(searchChar, nullptr));
++}
++
++SQInteger wxString_ToLong(HSQUIRRELVM v)
++{
++ // env table, string
++ ExtractParams2<SkipParam, const wxString*> extractor(v);
++ if (!extractor.Process("wxString_ToLong"))
++ return extractor.ErrorMessage();
++
++ long value;
++ if (!extractor.p1->ToLong(&value))
++ value = -1;
++ sq_pushinteger(v, value);
++ return 1;
++}
++
++SQInteger wxColour_ctor(HSQUIRRELVM v)
++{
++ ExtractParamsBase extractor(v);
++ if (!extractor.CheckNumArguments(1, 5, "wxColour_ctor"))
++ return extractor.ErrorMessage();
++
++ const int numArgs = sq_gettop(v);
++ switch (numArgs)
+ {
+- StackHandler sa(v);
+- wxString result;
+- wxString& str1 = *SqPlus::GetInstance<wxString,false>(v, 1);
+- if (sa.GetType(2) == OT_INTEGER)
++ case 1: // empty ctor
+ {
+-#ifdef _SQ64
+- result.Printf(_T("%s%ld"), str1.c_str(), sa.GetInt(2));
+-#else
+- result.Printf(_T("%s%d"), str1.c_str(), sa.GetInt(2));
+-#endif
++ UserDataForType<wxColour> *data;
++ data = SetupUserPointer<wxColour, InstanceAllocationMode::InstanceIsInline>(v, 1);
++ if (!data)
++ return -1; // SetupUserPointer should have called sq_throwerror!
++ new (&(data->userdata)) wxColour();
++ return 0;
+ }
+- else if (sa.GetType(2) == OT_FLOAT)
+- result.Printf(_T("%s%f"), str1.c_str(), sa.GetFloat(2));
+- else if (sa.GetType(2) == OT_USERPOINTER)
+- result.Printf(_T("%s%p"), str1.c_str(), sa.GetUserPointer(2));
+- else if (sa.GetType(2) == OT_STRING)
+- result.Printf(_T("%s%s"), str1.c_str(), cbC2U(sa.GetString(2)).c_str());
+- else
++ case 4: // 3 ints
+ {
+- wxString *str2 = SqPlus::GetInstance<wxString,false>(v, 2);
+- if (!str2)
+- return sa.ThrowError("Second parameter is not a wxString instance!");
+- result = str1 + *str2;
++ // env table, red, green, blue
++ ExtractParams4<SkipParam, SQInteger, SQInteger, SQInteger> extractor(v);
++ if (!extractor.Process("wxColour_ctor(3 ints)"))
++ return extractor.ErrorMessage();
++ UserDataForType<wxColour> *data;
++ data = SetupUserPointer<wxColour, InstanceAllocationMode::InstanceIsInline>(v, 1);
++ if (!data)
++ return -1; // SetupUserPointer should have called sq_throwerror!
++ new (&(data->userdata)) wxColour(extractor.p1, extractor.p2, extractor.p3);
++ return 0;
+ }
+- return SqPlus::ReturnCopy(v, result);
++ case 5: // 4 ints
++ {
++ // env table, red, green, blue, alpha
++ ExtractParams5<SkipParam, SQInteger, SQInteger, SQInteger, SQInteger> extractor(v);
++ if (!extractor.Process("wxColour_ctor(4 ints)"))
++ return extractor.ErrorMessage();
++ UserDataForType<wxColour> *data;
++ data = SetupUserPointer<wxColour, InstanceAllocationMode::InstanceIsInline>(v, 1);
++ if (!data)
++ return -1; // SetupUserPointer should have called sq_throwerror!
++ new (&(data->userdata)) wxColour(extractor.p1, extractor.p2, extractor.p3, extractor.p4);
++ return 0;
++ }
++ default:
++ return sq_throwerror(v, _SC("Unsupported number of arguments passed wxString()!"));
+ }
++}
+
+- SQInteger wxString_OpCmp(HSQUIRRELVM v)
++
++SQInteger wxColour_Set(HSQUIRRELVM v)
++{
++ // this, red, green, blue, alpha
++ ExtractParams5<wxColour*, SQInteger, SQInteger, SQInteger, SQInteger> extractor(v);
++ if (!extractor.Process("wxColour_Set"))
++ return extractor.ErrorMessage();
++ extractor.p0->Set(extractor.p1, extractor.p2, extractor.p3, extractor.p4);
++ return 0;
++}
++
++SQInteger wxColour_IsOk(HSQUIRRELVM v)
++{
++ ExtractParams1<const wxColour*> extractor(v);
++ if (!extractor.Process("wxColour_IsOk"))
++ return extractor.ErrorMessage();
++ sq_pushbool(v, extractor.p0->IsOk());
++
++ return 1;
++}
++
++SQInteger wxColour_ToString(HSQUIRRELVM v)
++{
++ ExtractParams1<const wxColour*> extractor(v);
++ if (!extractor.Process("wxColour_ToString"))
++ return extractor.ErrorMessage();
++
++ SQChar buf[100];
++ scsprintf(buf, 100, _SC("[r=%d, g=%d, b=%d, a=%d]"), extractor.p0->Red(), extractor.p0->Green(),
++ extractor.p0->Blue(), extractor.p0->Alpha());
++ sq_pushstring(v, buf, -1);
++ return 1;
++}
++
++SQInteger wxPoint_get(HSQUIRRELVM v)
++{
++ ExtractParams2<const wxPoint*, const SQChar*> extractor(v);
++ if (!extractor.Process("wxPoint_get"))
++ return extractor.ErrorMessage();
++
++ const SQChar *fieldName = extractor.p1;
++ if (scstrcmp(fieldName, _SC("x")) == 0)
+ {
+- StackHandler sa(v);
+- wxString& str1 = *SqPlus::GetInstance<wxString,false>(v, 1);
+- if (sa.GetType(2) == OT_STRING)
+- return sa.Return((SQInteger)str1.Cmp(cbC2U(sa.GetString(2))));
+- return sa.Return((SQInteger)str1.Cmp(*SqPlus::GetInstance<wxString,false>(v, 2)));
++ sq_pushinteger(v, extractor.p0->x);
++ return 1;
+ }
+-
+- SQInteger wxString_OpToString(HSQUIRRELVM v)
++ if (scstrcmp(fieldName, _SC("y")) == 0)
+ {
+- StackHandler sa(v);
+- wxString& self = *SqPlus::GetInstance<wxString,false>(v, 1);
+- return sa.Return((const SQChar*)self.mb_str(wxConvUTF8));
++ sq_pushinteger(v, extractor.p0->y);
++ return 1;
+ }
++ return sq_throwerror(v, _SC("wxPoint_get: Unknown field"));
++}
+
+- SQInteger wxString_AddChar(HSQUIRRELVM v)
++SQInteger wxPoint_set(HSQUIRRELVM v)
++{
++ ExtractParams3<wxPoint*, const SQChar*, SQInteger> extractor(v);
++ if (!extractor.Process("wxPoint_set"))
++ return extractor.ErrorMessage();
++
++ const SQChar *fieldName = extractor.p1;
++ if (scstrcmp(fieldName, _SC("x")) == 0)
+ {
+- StackHandler sa(v);
+- wxString& self = *SqPlus::GetInstance<wxString,false>(v, 1);
+- int idx = sa.GetInt(2);
+- char tmp[8] = {};
+- sprintf(tmp, "%c", idx);
+- self += cbC2U(tmp);
+- return sa.Return();
++ extractor.p0->x = extractor.p2;
++ return 0;
+ }
+- SQInteger wxString_GetChar(HSQUIRRELVM v)
++ if (scstrcmp(fieldName, _SC("y")) == 0)
+ {
+- StackHandler sa(v);
+- wxString& self = *SqPlus::GetInstance<wxString,false>(v, 1);
+- int idx = sa.GetInt(2);
+- return sa.Return((SQInteger)(((const char*)cbU2C(self))[idx]));
++ extractor.p0->y = extractor.p2;
++ return 0;
+ }
+- SQInteger wxString_Matches(HSQUIRRELVM v)
+- {
+- StackHandler sa(v);
+- wxString& self = *SqPlus::GetInstance<wxString,false>(v, 1);
+- wxString& other = *SqPlus::GetInstance<wxString,false>(v, 2);
+- return sa.Return(self.Matches(other));
+- }
++ return sq_throwerror(v, _SC("wxPoint_set: Unknown field"));
++}
+
+- static SQChar ExtractChar(HSQUIRRELVM v, StackHandler &sa, SQInteger idx)
++SQInteger wxPoint_cmp(HSQUIRRELVM v)
++{
++ ExtractParams2<const wxPoint*, const wxPoint*> extractor(v);
++ if (!extractor.Process("wxPoint_cmp"))
++ return extractor.ErrorMessage();
++
++ int res;
++ if (extractor.p0->x < extractor.p1->x)
++ res = -1;
++ else if (extractor.p0->x > extractor.p1->x)
++ res = 1;
++ else
+ {
+- switch (sa.GetType(idx))
+- {
+- case OT_INTEGER:
+- return sa.GetInt(idx);
+- case OT_STRING:
+- {
+- const SQChar *str = sa.GetString(idx);
+- if (str && str[0] != _SC('\0'))
+- return str[0];
+- sa.ThrowError(_SC("Empty string not supported!"));
+- return _SC('\0');
+- }
+- case OT_INSTANCE:
+- {
+- SQChar result = _SC('\0');
+- wxString* arg = SqPlus::GetInstance<wxString, false>(v, idx);
+- if (!arg)
+- sa.ThrowError(_SC("Can't extract wxString"));
+- else if (arg->empty())
+- sa.ThrowError(_SC("Empty string not supported!"));
+- else
+- result = arg->GetChar(0).GetValue();
+- return result;
+- }
+- default:
+- sa.ThrowError(_SC("Unsupported parameter type!"));
+- return _SC('\0');
+- }
++ if (extractor.p0->y < extractor.p1->y)
++ res = -1;
++ else if (extractor.p0->y > extractor.p1->y)
++ res = 1;
++ else
++ res = 0;
+ }
++ sq_pushinteger(v, res);
++ return 1;
++}
+
+- SQInteger wxString_AfterFirst(HSQUIRRELVM v)
++template<typename Type>
++SQInteger wxPointSize_tostring(HSQUIRRELVM v)
++{
++ ExtractParams1<const Type*> extractor(v);
++ if (!extractor.Process("wxPointSize_tostring"))
++ return extractor.ErrorMessage();
++
++ SQChar buf[100];
++ scsprintf(buf, 100, _SC("[%d,%d]"), extractor.p0->x, extractor.p0->y);
++ sq_pushstring(v, buf, -1);
++ return 1;
++}
++
++SQInteger wxSize_Set(HSQUIRRELVM v)
++{
++ ExtractParams3<wxSize*, SQInteger, SQInteger> extractor(v);
++ if (!extractor.Process("wxSize_Set"))
++ return extractor.ErrorMessage();
++ extractor.p0->Set(extractor.p1, extractor.p2);
++ return 0;
++}
++
++template<void (wxSize::*func)(int)>
++SQInteger wxSize_SetWidthHeight(HSQUIRRELVM v)
++{
++ ExtractParams2<wxSize*, SQInteger> extractor(v);
++ if (!extractor.Process("wxSize_SetWidthHeight"))
++ return extractor.ErrorMessage();
++ (extractor.p0->*func)(extractor.p1);
++ return 0;
++}
++
++SQInteger wxArrayString_Add(HSQUIRRELVM v)
++{
++ ExtractParams3<wxArrayString*, const wxString*, SQInteger> extractor(v);
++ if (!extractor.Process("wxArrayString_Add"))
++ return extractor.ErrorMessage();
++ sq_pushinteger(v, extractor.p0->Add(*extractor.p1, extractor.p2));
++ return 1;
++}
++
++SQInteger wxArrayString_Clear(HSQUIRRELVM v)
++{
++ ExtractParams1<wxArrayString*> extractor(v);
++ if (!extractor.Process("wxArrayString_Clear"))
++ return extractor.ErrorMessage();
++ extractor.p0->Clear();
++ return 0;
++}
++
++SQInteger wxArrayString_Index(HSQUIRRELVM v)
++{
++ // TODO: Optional Args
++ ExtractParamsBase extractor(v);
++ if (!extractor.CheckNumArguments(2, 4, "wxArrayString_Index"))
++ return extractor.ErrorMessage();
++
++ wxArrayString *self = nullptr;
++ if (!extractor.ProcessParam(self, 1, "wxArrayString_Index"))
++ return extractor.ErrorMessage();
++
++ const wxString *str = nullptr;
++ if (!extractor.ProcessParam(str, 2, "wxArrayString_Index"))
++ return extractor.ErrorMessage();
++
++ bool bCase = true;
++ bool bFromEnd = false;
++ const int numArgs = sq_gettop(v);
++ if (numArgs >= 3)
+ {
+- StackHandler sa(v);
+- wxString& self = *SqPlus::GetInstance<wxString,false>(v, 1);
+- return SqPlus::ReturnCopy(v, self.AfterFirst(static_cast<wxChar>(ExtractChar(v, sa, 2))));
++ if (!extractor.ProcessParam(bCase, 3, "wxArrayString_Index"))
++ return extractor.ErrorMessage();
+ }
+- SQInteger wxString_AfterLast(HSQUIRRELVM v)
++ if (numArgs == 4)
+ {
+- StackHandler sa(v);
+- wxString& self = *SqPlus::GetInstance<wxString,false>(v, 1);
+- return SqPlus::ReturnCopy(v, self.AfterLast(static_cast<wxChar>(ExtractChar(v, sa, 2))));
++ if (!extractor.ProcessParam(bFromEnd, 4, "wxArrayString_Index"))
++ return extractor.ErrorMessage();
+ }
+- SQInteger wxString_BeforeFirst(HSQUIRRELVM v)
++
++ sq_pushinteger(v, self->Index(*str, bCase, bFromEnd));
++ return 1;
++}
++
++SQInteger wxArrayString_Item(HSQUIRRELVM v)
++{
++ ExtractParams2<wxArrayString*, SQInteger> extractor(v);
++ if (!extractor.Process("wxArrayString_Item"))
++ return extractor.ErrorMessage();
++ const SQInteger index = extractor.p1;
++ if (index < 0 || size_t(index) >= extractor.p0->GetCount())
++ return sq_throwerror(v, _SC("wxArrayString_Item: index out of bounds!"));
++
++ // Create an instance for the return value.
++ wxString *ref = &((*extractor.p0)[index]);
++ return ConstructAndReturnNonOwnedPtr(v, ref);
++}
++
++SQInteger wxArrayString_SetItem(HSQUIRRELVM v)
++{
++ ExtractParams3<wxArrayString*, SQInteger, const wxString*> extractor(v);
++ if (!extractor.Process("wxArrayString_SetItem"))
++ return extractor.ErrorMessage();
++
++ const SQInteger index = extractor.p1;
++ if (index < 0 || size_t(index) >= extractor.p0->GetCount())
++ return sq_throwerror(v, _SC("wxArrayString_SetItem: index out of bounds!"));
++
++ (*extractor.p0)[index] = *extractor.p2;
++ return 0;
++}
++
++SQInteger wxFileName_Assign(HSQUIRRELVM v)
++{
++ ExtractParams3<wxFileName*, const wxString *, SQInteger> extractor(v);
++ if (!extractor.Process("wxFileName_Assign"))
++ return extractor.ErrorMessage();
++
++ if (extractor.p2 < wxPATH_NATIVE || extractor.p2 >= wxPATH_MAX)
++ return sq_throwerror(v, _SC("wxFileName_Assign: format out of range!"));
++
++ extractor.p0->Assign(*extractor.p1, wxPathFormat(extractor.p2));
++ return 0;
++}
++
++template<void (wxFileName::*func)(const wxString&)>
++SQInteger wxFileName_SetWxString(HSQUIRRELVM v)
++{
++ ExtractParams2<wxFileName*, const wxString *> extractor(v);
++ if (!extractor.Process("wxFileName_SetWxString"))
++ return extractor.ErrorMessage();
++ (extractor.p0->*func)(*extractor.p1);
++ return 0;
++}
++
++SQInteger wxFileName_AssignDir(HSQUIRRELVM v)
++{
++ ExtractParams3<wxFileName*, const wxString *, SQInteger> extractor(v);
++ if (!extractor.Process("wxFileName_AssignDir"))
++ return extractor.ErrorMessage();
++
++ if (extractor.p2 < wxPATH_NATIVE || extractor.p2 >= wxPATH_MAX)
++ return sq_throwerror(v, _SC("wxFileName_Assign: format out of range!"));
++
++ extractor.p0->AssignDir(*extractor.p1, wxPathFormat(extractor.p2));
++ return 0;
++}
++
++template<void (wxFileName::*func)()>
++SQInteger wxFileName_Action(HSQUIRRELVM v)
++{
++ ExtractParams1<wxFileName*> extractor(v);
++ if (!extractor.Process("wxFileName_Action"))
++ return extractor.ErrorMessage();
++ (extractor.p0->*func)();
++ return 0;
++}
++
++SQInteger wxFileName_GetCwd(HSQUIRRELVM v)
++{
++ ExtractParams2<SkipParam, const wxString *> extractor(v);
++ if (!extractor.Process("wxFileName_GetCwd"))
++ return extractor.ErrorMessage();
++
++ return ConstructAndReturnInstance(v, wxFileName::GetCwd(*extractor.p1));
++}
++
++SQInteger wxFileName_tostring(HSQUIRRELVM v)
++{
++ ExtractParams1<const wxFileName*> extractor(v);
++ if (!extractor.Process("wxFileName_tostring"))
++ return extractor.ErrorMessage();
++ sq_pushstring(v, (const SQChar*)extractor.p0->GetFullPath().mb_str(wxConvUTF8), -1);
++ return 1;
++}
++
++SQInteger wxFileName_GetDirs(HSQUIRRELVM v)
++{
++ ExtractParams1<const wxFileName*> extractor(v);
++ if (!extractor.Process("wxFileName_GetDirs"))
++ return extractor.ErrorMessage();
++
++ // FIXME (squirrel) This doesn't matter much, because squirrel doesn't care for constness.
++ wxArrayString *dirs = &const_cast<wxArrayString&>(extractor.p0->GetDirs());
++ return ConstructAndReturnNonOwnedPtr(v, dirs);
++}
++
++/// TODO: Probably simplify by removing the generic ClassType support.
++template<typename ReturnType, typename ClassType, ReturnType (ClassType::*func)() const>
++SQInteger NoParamReturnWxString(HSQUIRRELVM v)
++{
++ ExtractParams1<const ClassType*> extractor(v);
++ if (!extractor.Process("NoParamReturnWxString"))
++ return extractor.ErrorMessage();
++
++ return ConstructAndReturnInstance(v, (extractor.p0->*func)());
++}
++
++SQInteger wxFileName_GetFullPath(HSQUIRRELVM v)
++{
++ ExtractParams2<const wxFileName*, SQInteger> extractor(v);
++ if (!extractor.Process("wxFileName_GetFullPath"))
++ return extractor.ErrorMessage();
++
++ if (extractor.p1 < wxPATH_NATIVE || extractor.p1 >= wxPATH_MAX)
++ return sq_throwerror(v, _SC("wxFileName_GetFullPath: format out of range!"));
++
++ return ConstructAndReturnInstance(v, extractor.p0->GetFullPath(wxPathFormat(extractor.p1)));
++}
++
++SQInteger wxFileName_GetPath(HSQUIRRELVM v)
++{
++ ExtractParams3<const wxFileName*, SQInteger, SQInteger> extractor(v);
++ if (!extractor.Process("wxFileName_GetPath"))
++ return extractor.ErrorMessage();
++
++ if (extractor.p2 < wxPATH_NATIVE || extractor.p2 >= wxPATH_MAX)
++ return sq_throwerror(v, _SC("wxFileName_GetPath: format out of range!"));
++
++ return ConstructAndReturnInstance(v, extractor.p0->GetPath(int(extractor.p1),
++ wxPathFormat(extractor.p2)));
++}
++
++SQInteger wxFileName_InsertDir(HSQUIRRELVM v)
++{
++ ExtractParams3<wxFileName*, SQInteger, const wxString *> extractor(v);
++ if (!extractor.Process("wxFileName_InsertDir"))
++ return extractor.ErrorMessage();
++
++ if (extractor.p1 < 0)
++ return sq_throwerror(v, _SC("wxFileName_InsertDir: parameter before must be non-negative!"));
++
++ sq_pushbool(v, extractor.p0->InsertDir(extractor.p1, *extractor.p2));
++ return 1;
++}
++
++template<bool (wxFileName::*func)(wxPathFormat) const>
++SQInteger wxFileName_Is(HSQUIRRELVM v)
++{
++ /// TODO: Consider adding a modifier which checks for wxPathFormat range.
++ ExtractParams2<const wxFileName*, SQInteger> extractor(v);
++ if (!extractor.Process("wxFileName_Is"))
++ return extractor.ErrorMessage();
++
++ if (extractor.p1 < wxPATH_NATIVE || extractor.p1 >= wxPATH_MAX)
++ return sq_throwerror(v, _SC("wxFileName_Is: format out of range!"));
++
++ sq_pushbool(v, (extractor.p0->*func)(wxPathFormat(extractor.p1)));
++ return 1;
++}
++
++template<bool (wxFileName::*func)() const>
++SQInteger wxFileName_ReturnBool(HSQUIRRELVM v)
++{
++ ExtractParams1<const wxFileName*> extractor(v);
++ if (!extractor.Process("wxFileName_ReturnBool"))
++ return extractor.ErrorMessage();
++ sq_pushbool(v, (extractor.p0->*func)());
++ return 1;
++}
++
++template<bool (wxFileName::*func)(const wxString &, wxPathFormat)>
++SQInteger wxFileName_Make(HSQUIRRELVM v)
++{
++ /// TODO: Consider adding a modifier which checks for wxPathFormat range.
++ ExtractParams3<wxFileName*, const wxString *, SQInteger> extractor(v);
++ if (!extractor.Process("wxFileName_Make"))
++ return extractor.ErrorMessage();
++
++ if (extractor.p2 < wxPATH_NATIVE || extractor.p2 >= wxPATH_MAX)
++ return sq_throwerror(v, _SC("wxFileName_Make: format out of range!"));
++
++ sq_pushbool(v, (extractor.p0->*func)(*extractor.p1, wxPathFormat(extractor.p2)));
++ return 1;
++}
++
++SQInteger wxFileName_Normalize(HSQUIRRELVM v)
++{
++ /// TODO: Consider adding a modifier which checks for wxPathFormat range.
++ ExtractParams4<wxFileName*, SQInteger, const wxString *, SQInteger> extractor(v);
++ if (!extractor.Process("wxFileName_MakeRelativeTo"))
++ return extractor.ErrorMessage();
++
++ if (extractor.p3 < wxPATH_NATIVE || extractor.p3 >= wxPATH_MAX)
++ return sq_throwerror(v, _SC("wxFileName_MakeRelativeTo: format out of range!"));
++
++ sq_pushbool(v, extractor.p0->Normalize(extractor.p1, *extractor.p2,
++ wxPathFormat(extractor.p3)));
++ return 1;
++}
++
++SQInteger wxFileName_AppendDir(HSQUIRRELVM v)
++{
++ ExtractParams2<wxFileName*, const wxString *> extractor(v);
++ if (!extractor.Process("wxFileName_AppendDir"))
++ return extractor.ErrorMessage();
++ sq_pushbool(v, extractor.p0->AppendDir(*extractor.p1));
++ return 1;
++}
++
++SQInteger wxFileName_RemoveDir(HSQUIRRELVM v)
++{
++ ExtractParams2<wxFileName*, SQInteger> extractor(v);
++ if (!extractor.Process("wxFileName_RemoveDir"))
++ return extractor.ErrorMessage();
++ extractor.p0->RemoveDir(extractor.p1);
++ return 0;
++}
++
++SQInteger wxFileName_RemoveLastDir(HSQUIRRELVM v)
++{
++ ExtractParams1<wxFileName*> extractor(v);
++ if (!extractor.Process("wxFileName_RemoveLastDir"))
++ return extractor.ErrorMessage();
++ extractor.p0->RemoveLastDir();
++ return 0;
++}
++
++SQInteger wxFileName_SameAs(HSQUIRRELVM v)
++{
++ ExtractParams3<wxFileName*, const wxFileName*, SQInteger> extractor(v);
++ if (!extractor.Process("wxFileName_SameAs"))
++ return extractor.ErrorMessage();
++
++ if (extractor.p2 < wxPATH_NATIVE || extractor.p2 >= wxPATH_MAX)
++ return sq_throwerror(v, _SC("wxFileName_MakeRelativeTo: format out of range!"));
++
++ sq_pushbool(v, extractor.p0->SameAs(*extractor.p1, wxPathFormat(extractor.p2)));
++ return 1;
++}
++
++void Register_wxTypes(HSQUIRRELVM v)
++{
++ PreserveTop preserveTop(v);
++ sq_pushroottable(v);
+ {
+- StackHandler sa(v);
+- wxString& self = *SqPlus::GetInstance<wxString,false>(v, 1);
+- return SqPlus::ReturnCopy(v, self.BeforeFirst(static_cast<wxChar>(ExtractChar(v, sa, 2))));
++ // register wxString
++ const SQInteger classDecl = CreateClassDecl<wxString>(v);
++ BindMethod(v, _SC("constructor"), wxString_ctor, _SC("wxString::constructor"));
++ BindDefaultClone<wxString>(v);
++ BindMethod(v, _SC("_add"), wxString_OpAdd, _SC("wxString::operator+"));
++ BindMethod(v, _SC("_cmp"), wxString_OpCompare, _SC("wxString::operator=="));
++ BindMethod(v, _SC("Compare"), wxString_OpCompare, _SC("wxString::Compare"));
++ BindMethod(v, _SC("_tostring"), wxString_OpToString, _SC("wxString::_tostring"));
++ BindMethod(v, _SC("Find"), wxString_Find, _SC("wxString::Find"));
++ BindMethod(v, _SC("Matches"), wxString_Matches, _SC("wxString::Matches"));
++ BindMethod(v, _SC("AddChar"), wxString_AddChar, _SC("wxString::AddChar"));
++ BindMethod(v, _SC("GetChar"), wxString_GetChar, _SC("wxString::GetChar"));
++ BindMethod(v, _SC("Set"), wxString_Set, _SC("wxString::Set"));
++ BindMethod(v, _SC("IsEmpty"), wxString_IsEmpty, _SC("wxString::IsEmpty"));
++ BindMethod(v, _SC("Length"), wxString_Length, _SC("wxString::Length"));
++ BindMethod(v, _SC("length"), wxString_Length, _SC("wxString::length"));
++ BindMethod(v, _SC("len"), wxString_Length, _SC("wxString::len"));
++ BindMethod(v, _SC("size"), wxString_Length, _SC("wxString::size"));
++
++ BindMethod(v, _SC("Lower"), wxString_NoParamReturnWxString<&wxString::MakeLower>,
++ _SC("wxString::Lower"));
++ BindMethod(v, _SC("MakeLower"), wxString_NoParamReturnWxString<&wxString::MakeLower>,
++ _SC("wxString::MakeLower"));
++ BindMethod(v, _SC("LowerCase"), wxString_NoParamNoReturn<&wxString::LowerCase>,
++ _SC("wxString::LowerCase"));
++
++ BindMethod(v, _SC("Upper"), wxString_NoParamReturnWxString<&wxString::MakeUpper>,
++ _SC("wxString::Upper"));
++ BindMethod(v, _SC("MakeUpper"), wxString_NoParamReturnWxString<&wxString::MakeUpper>,
++ _SC("wxString::MakeUpper"));
++ BindMethod(v, _SC("UpperCase"), wxString_NoParamNoReturn<&wxString::UpperCase>,
++ _SC("wxString::UpperCase"));
++
++ BindMethod(v, _SC("Mid"), wxString_Mid, _SC("wxString::Mid"));
++ BindMethod(v, _SC("Remove"), wxString_Remove, _SC("wxString::Remove"));
++ BindMethod(v, _SC("RemoveLast"), wxString_RemoveLast, _SC("wxString::RemoveLast"));
++ BindMethod(v, _SC("Replace"), wxString_Replace, _SC("wxString::Replace"));
++ BindMethod(v, _SC("Left"), wxString_LeftRight<&wxString::Left>, _SC("wxString::Left"));
++ BindMethod(v, _SC("Right"), wxString_LeftRight<&wxString::Right>, _SC("wxString::Right"));
++
++ BindMethod(v, _SC("AfterFirst"), wxString_DoAfterFirstLast<&wxString::AfterFirst>,
++ _SC("wxString::AfterFirst"));
++ BindMethod(v, _SC("AfterLast"), wxString_DoAfterFirstLast<&wxString::AfterLast>,
++ _SC("wxString::AfterLast"));
++ BindMethod(v, _SC("BeforeFirst"), wxString_DoBeforeFirstLast<&wxString::BeforeFirst>,
++ _SC("wxString::BeforeFirst"));
++ BindMethod(v, _SC("BeforeLast"), wxString_DoBeforeFirstLast<&wxString::BeforeLast>,
++ _SC("wxString::BeforeLast"));
++
++ sq_newslot(v, classDecl, SQFalse); // Put the class in the root table. This must be last!
+ }
+- SQInteger wxString_BeforeLast(HSQUIRRELVM v)
++
++ BindMethod(v, _SC("_T"), static_T, nullptr);
++ BindMethod(v, _SC("_"), static_, nullptr);
++ BindMethod(v, _SC("wxString_ToLong"), wxString_ToLong, nullptr);
++
+ {
+- StackHandler sa(v);
+- wxString& self = *SqPlus::GetInstance<wxString,false>(v, 1);
+- return SqPlus::ReturnCopy(v, self.BeforeLast(static_cast<wxChar>(ExtractChar(v, sa, 2))));
++ // Register wxColour
++ const SQInteger classDecl = CreateClassDecl<wxColour>(v);
++ BindMethod(v, _SC("constructor"), wxColour_ctor, _SC("wxColour::constructor"));
++ BindDefaultClone<wxColour>(v);
++
++ BindMethod(v, _SC("_tostring"), wxColour_ToString, _SC("wxColour::_tostring"));
++ BindMethod(v, _SC("Blue"), NoParamGetterInt<wxColour::ChannelType, wxColour, &wxColour::Blue>, _SC("wxColour::Blue"));
++ BindMethod(v, _SC("Green"), NoParamGetterInt<wxColour::ChannelType, wxColour, &wxColour::Green>, _SC("wxColour::Green"));
++ BindMethod(v, _SC("Red"), NoParamGetterInt<wxColour::ChannelType, wxColour, &wxColour::Red>, _SC("wxColour::Red"));
++ BindMethod(v, _SC("Alpha"), NoParamGetterInt<wxColour::ChannelType, wxColour, &wxColour::Alpha>, _SC("wxColour::Alpha"));
++ BindMethod(v, _SC("IsOk"), wxColour_IsOk, _SC("wxColour::IsOk"));
++ BindMethod(v, _SC("Set"), wxColour_Set, _SC("wxColour::Set"));
++
++ sq_newslot(v, classDecl, SQFalse); // Put the class in the root table. This must be last!
+ }
+- SQInteger wxString_Replace(HSQUIRRELVM v)
++
+ {
+- StackHandler sa(v);
+- wxString& self = *SqPlus::GetInstance<wxString,false>(v, 1);
+- wxString from = *SqPlus::GetInstance<wxString,false>(v, 2);
+- wxString to = *SqPlus::GetInstance<wxString,false>(v, 3);
+- bool all = true;
+- if (sa.GetParamCount() == 4)
+- all = sa.GetBool(4);
+- return sa.Return((SQInteger)self.Replace(from, to, all));
++ // Register wxPoint
++ const SQInteger classDecl = CreateClassDecl<wxPoint>(v);
++ BindEmptyCtor<wxPoint>(v);
++ BindDefaultClone<wxPoint>(v);
++ BindMethod(v, _SC("_tostring"), wxPointSize_tostring<wxPoint>, _SC("wxPoint::_tostring"));
++ BindMethod(v, _SC("_cmp"), wxPoint_cmp, _SC("wxPoint::_cmp"));
++ BindMethod(v, _SC("_get"), wxPoint_get, _SC("wxPoint::_get"));
++ BindMethod(v, _SC("_set"), wxPoint_set, _SC("wxPoint::_set"));
++
++ sq_newslot(v, classDecl, SQFalse); // Put the class in the root table. This must be last!
+ }
+
+-////////////////////////////////////////////////////////////////////////////////
+-
+- void Register_wxTypes()
+ {
+-#if wxCHECK_VERSION(3, 0, 0) && !wxUSE_STD_CONTAINERS
+- typedef const wxString& (wxArrayString::*wxArrayStringItem)(size_t nIndex) const;
+-#else
+- typedef wxString& (wxArrayString::*wxArrayStringItem)(size_t nIndex) const;
+-#endif
+- typedef size_t (wxArrayString::*wxArrayStrinGetCount)() const;
++ // Register wxSize
++ const SQInteger classDecl = CreateClassDecl<wxSize>(v);
++ BindEmptyCtor<wxSize>(v);
++ BindDefaultClone<wxSize>(v);
++ BindMethod(v, _SC("_tostring"), wxPointSize_tostring<wxSize>, _SC("wxSize::_tostring"));
++ BindMethod(v, _SC("GetWidth"), NoParamGetterInt<int, wxSize, &wxSize::GetWidth>,
++ _SC("wxSize::GetWidth"));
++ BindMethod(v, _SC("GetHeight"), NoParamGetterInt<int, wxSize, &wxSize::GetHeight>,
++ _SC("wxSize::GetHeight"));
++ BindMethod(v, _SC("Set"), wxSize_Set, _SC("wxSize::Set"));
++ BindMethod(v, _SC("SetHeight"), wxSize_SetWidthHeight<&wxSize::SetHeight>,
++ _SC("wxSize::SetHeight"));
++ BindMethod(v, _SC("SetWidth"), wxSize_SetWidthHeight<&wxSize::SetWidth>,
++ _SC("wxSize::SetWidth"));
+
+- ///////////////////
+- // wxArrayString //
+- ///////////////////
+- SqPlus::SQClassDef<wxArrayString>("wxArrayString").
+- emptyCtor().
+- func(&wxArrayString::Add, "Add").
+- staticFunc(&wxArrayString_Clear, "Clear").
+- staticFuncVarArgs(&wxArrayString_Index, "Index", "*").
+- func<wxArrayStrinGetCount>(&wxArrayString::GetCount, "GetCount").
+- func<wxArrayStringItem>(&wxArrayString::Item, "Item").
+- staticFuncVarArgs(&wxArrayString_SetItem, "SetItem", "*");
++ sq_newslot(v, classDecl, SQFalse); // Put the class in the root table. This must be last!
++ }
+
+- //////////////
+- // wxColour //
+- //////////////
+- typedef void(wxColour::*WXC_SET)(const unsigned char, const unsigned char, const unsigned char, const unsigned char);
+- typedef bool (wxColour::*WXC_ISOK)() const;
+- SqPlus::SQClassDef<wxColour>("wxColour").
+- emptyCtor().
+- staticFuncVarArgs(&wxColour_OpToString, "_tostring", "").
+- func(&wxColour::Blue, "Blue").
+- func(&wxColour::Green, "Green").
+- func(&wxColour::Red, "Red").
+- func<WXC_ISOK>(&wxColour::IsOk, "IsOk").
+- func<WXC_SET>(&wxColour::Set, "Set");
++ {
++ // Register wxSize
++ const SQInteger classDecl = CreateClassDecl<wxArrayString>(v);
++ BindEmptyCtor<wxArrayString>(v);
++ BindDefaultClone<wxArrayString>(v);
++ BindMethod(v, _SC("Add"), wxArrayString_Add, _SC("wxArrayString::Add"));
++ BindMethod(v, _SC("Clear"), wxArrayString_Clear, _SC("wxArrayString::Clear"));
++ BindMethod(v, _SC("Index"), wxArrayString_Index, _SC("wxArrayString::Index"));
++ BindMethod(v, _SC("GetCount"),
++ NoParamGetterInt<size_t, wxArrayString, &wxArrayString::GetCount>,
++ _SC("wxArrayString::GetCount"));
++ BindMethod(v, _SC("Item"), wxArrayString_Item, _SC("wxArrayString::Item"));
++ BindMethod(v, _SC("SetItem"), wxArrayString_SetItem, _SC("wxArrayString::SetItem"));
+
+- ////////////////
+- // wxFileName //
+- ////////////////
+- typedef void(wxFileName::*WXFN_ASSIGN_FN)(const wxFileName&);
+- typedef void(wxFileName::*WXFN_ASSIGN_STR)(const wxString&, wxPathFormat);
+- typedef wxString(wxFileName::*WXFN_GETPATH)(int, wxPathFormat)const;
+- typedef bool(wxFileName::*WXFN_SETCWD)()const;
+- typedef bool(wxFileName::*WXFN_SETCWD)()const;
+- typedef bool(wxFileName::*WXFN_ISFILEWRITEABLE)()const;
++ sq_newslot(v, classDecl, SQFalse); // Put the class in the root table. This must be last!
++ }
+
+- SqPlus::SQClassDef<wxFileName>("wxFileName").
+- emptyCtor().
+- staticFuncVarArgs(&wxFileName_OpToString, "_tostring", "").
+- func<WXFN_ASSIGN_FN>(&wxFileName::Assign, "Assign").
+- func<WXFN_ASSIGN_STR>(&wxFileName::Assign, "Assign").
+- func(&wxFileName::AssignCwd, "AssignCwd").
+- func(&wxFileName::AssignDir, "AssignDir").
+- func(&wxFileName::AssignHomeDir, "AssignHomeDir").
+- func(&wxFileName::Clear, "Clear").
+- func(&wxFileName::ClearExt, "ClearExt").
+- staticFunc(&wxFileName::GetCwd, "GetCwd").
+- func(&wxFileName::GetDirCount, "GetDirCount").
+- func(&wxFileName::GetDirs, "GetDirs").
+- func(&wxFileName::GetExt, "GetExt").
+- func(&wxFileName::GetFullName, "GetFullName").
+- func(&wxFileName::GetFullPath, "GetFullPath").
+- func(&wxFileName::GetLongPath, "GetLongPath").
+- func(&wxFileName::GetName, "GetName").
+- func<WXFN_GETPATH>(&wxFileName::GetPath, "GetPath").
+- func(&wxFileName::GetShortPath, "GetShortPath").
+- func(&wxFileName::GetVolume, "GetVolume").
+- func(&wxFileName::HasExt, "HasExt").
+- func(&wxFileName::HasName, "HasName").
+- func(&wxFileName::HasVolume, "HasVolume").
+- func(&wxFileName::InsertDir, "InsertDir").
+- func(&wxFileName::IsAbsolute, "IsAbsolute").
+- func(&wxFileName::IsOk, "IsOk").
+- func(&wxFileName::IsRelative, "IsRelative").
+- func(&wxFileName::IsDir, "IsDir").
+- func(&wxFileName::MakeAbsolute, "MakeAbsolute").
+- func(&wxFileName::MakeRelativeTo, "MakeRelativeTo").
+- func(&wxFileName::Normalize, "Normalize").
+- func(&wxFileName::AppendDir, "AppendDir").
+- func(&wxFileName::PrependDir, "PrependDir").
+- func(&wxFileName::RemoveDir, "RemoveDir").
+- func(&wxFileName::RemoveLastDir, "RemoveLastDir").
+- func(&wxFileName::SameAs, "SameAs").
+- func<WXFN_SETCWD>(&wxFileName::SetCwd, "SetCwd").
+- func(&wxFileName::SetExt, "SetExt").
+- func(&wxFileName::SetEmptyExt, "SetEmptyExt").
+- func(&wxFileName::SetFullName, "SetFullName").
+- func(&wxFileName::SetName, "SetName").
+- func(&wxFileName::SetVolume, "SetVolume").
+- func<WXFN_ISFILEWRITEABLE>(&wxFileName::IsFileWritable,"IsFileWritable");
++ {
++ // Register wxFileName
++ const SQInteger classDecl = CreateClassDecl<wxFileName>(v);
++ BindEmptyCtor<wxFileName>(v);
++ BindDefaultClone<wxFileName>(v);
++ BindMethod(v, _SC("_tostring"), wxFileName_tostring, _SC("wxFileName::_tostring"));
++ BindMethod(v, _SC("Assign"), wxFileName_Assign, _SC("wxFileName::Assign"));
++ BindMethod(v, _SC("AssignCwd"), wxFileName_SetWxString<&wxFileName::AssignCwd>,
++ _SC("wxFileName::AssignCwd"));
++ BindMethod(v, _SC("AssignDir"), wxFileName_AssignDir, _SC("wxFileName::AssignDir"));
++ BindMethod(v, _SC("AssignHomeDir"), wxFileName_Action<&wxFileName::AssignHomeDir>,
++ _SC("wxFileName::AssignHomeDir"));
++ BindMethod(v, _SC("Clear"), wxFileName_Action<&wxFileName::Clear>, _SC("wxFileName::Clear"));
++ BindMethod(v, _SC("ClearExt"), wxFileName_Action<&wxFileName::ClearExt>, _SC("wxFileName::ClearExt"));
++ BindStaticMethod(v, _SC("GetCwd"), wxFileName_GetCwd, _SC("wxFileName::GetCwd"));
++ BindMethod(v, _SC("GetDirCount"),
++ NoParamGetterInt<size_t, wxFileName, &wxFileName::GetDirCount>,
++ _SC("wxFileName::GetDirCount"));
++ BindMethod(v, _SC("GetDirs"), wxFileName_GetDirs, _SC("wxFileName::GetDirs"));
++ BindMethod(v, _SC("GetExt"),
++ NoParamReturnWxString<wxString, wxFileName, &wxFileName::GetExt>,
++ _SC("wxFileName::GetExt"));
++ BindMethod(v, _SC("GetFullName"),
++ NoParamReturnWxString<wxString, wxFileName, &wxFileName::GetFullName>,
++ _SC("wxFileName::GetFullName"));
++ BindMethod(v, _SC("GetFullPath"), wxFileName_GetFullPath, _SC("wxFileName::GetFullPath"));
++ BindMethod(v, _SC("GetLongPath"),
++ NoParamReturnWxString<wxString, wxFileName, &wxFileName::GetLongPath>,
++ _SC("wxFileName::GetLongPath"));
++ BindMethod(v, _SC("GetName"),
++ NoParamReturnWxString<wxString, wxFileName, &wxFileName::GetName>,
++ _SC("wxFileName::GetName"));
++ BindMethod(v, _SC("GetPath"), wxFileName_GetPath, _SC("wxFileName::GetPath"));
++ BindMethod(v, _SC("GetShortPath"),
++ NoParamReturnWxString<wxString, wxFileName, &wxFileName::GetShortPath>,
++ _SC("wxFileName::GetShortPath"));
++ BindMethod(v, _SC("GetVolume"),
++ NoParamReturnWxString<wxString, wxFileName, &wxFileName::GetVolume>,
++ _SC("wxFileName::GetVolume"));
++ BindMethod(v, _SC("HasExt"), wxFileName_ReturnBool<&wxFileName::HasExt>,
++ _SC("wxFileName::HasExt"));
++ BindMethod(v, _SC("HasName"), wxFileName_ReturnBool<&wxFileName::HasName>,
++ _SC("wxFileName::HasName"));
++ BindMethod(v, _SC("HasVolume"), wxFileName_ReturnBool<&wxFileName::HasVolume>,
++ _SC("wxFileName::HasVolume"));
++ BindMethod(v, _SC("InsertDir"), wxFileName_InsertDir, _SC("wxFileName::InsertDir"));
++ BindMethod(v, _SC("IsAbsolute"), wxFileName_Is<&wxFileName::IsAbsolute>,
++ _SC("wxFileName::IsAbsolute"));
++ BindMethod(v, _SC("IsOk"), wxFileName_ReturnBool<&wxFileName::IsOk>,
++ _SC("wxFileName::IsOk"));
++ BindMethod(v, _SC("IsRelative"), wxFileName_Is<&wxFileName::IsRelative>,
++ _SC("wxFileName::IsRelative"));
++ BindMethod(v, _SC("IsDir"), wxFileName_ReturnBool<&wxFileName::IsDir>,
++ _SC("wxFileName::IsDir"));
++ BindMethod(v, _SC("MakeAbsolute"), wxFileName_Make<&wxFileName::MakeAbsolute>,
++ _SC("wxFileName::MakeAbsolute"));
++ BindMethod(v, _SC("MakeRelativeTo"), wxFileName_Make<&wxFileName::MakeRelativeTo>,
++ _SC("wxFileName::MakeRelativeTo"));
++ BindMethod(v, _SC("Normalize"), wxFileName_Normalize, _SC("wxFileName::Normalize"));
++ BindMethod(v, _SC("AppendDir"), wxFileName_AppendDir, _SC("wxFileName::AppendDir"));
++ BindMethod(v, _SC("PrependDir"), wxFileName_SetWxString<&wxFileName::PrependDir>,
++ _SC("wxFileName::PrependDir"));
++ BindMethod(v, _SC("RemoveDir"), wxFileName_RemoveDir, _SC("wxFileName::RemoveDir"));
++ BindMethod(v, _SC("RemoveLastDir"), wxFileName_RemoveLastDir,
++ _SC("wxFileName::RemoveLastDir"));
++ BindMethod(v, _SC("SameAs"), wxFileName_SameAs, _SC("wxFileName::SameAs"));
++ BindMethod(v, _SC("SetCwd"), wxFileName_ReturnBool<&wxFileName::SetCwd>,
++ _SC("wxFileName::SetCwd"));
++ BindMethod(v, _SC("SetExt"), wxFileName_SetWxString<&wxFileName::SetExt>,
++ _SC("wxFileName::SetExt"));
++ BindMethod(v, _SC("SetEmptyExt"), wxFileName_Action<&wxFileName::SetEmptyExt>, _SC("wxFileName::SetEmptyExt"));
++ BindMethod(v, _SC("SetFullName"), wxFileName_SetWxString<&wxFileName::SetFullName>,
++ _SC("wxFileName::SetFullName"));
++ BindMethod(v, _SC("SetName"), wxFileName_SetWxString<&wxFileName::SetName>,
++ _SC("wxFileName::SetName"));
++ BindMethod(v, _SC("SetVolume"), wxFileName_SetWxString<&wxFileName::SetVolume>,
++ _SC("wxFileName::SetVolume"));
+
+- /////////////
+- // wxPoint //
+- /////////////
+- SqPlus::SQClassDef<wxPoint>("wxPoint").
+- emptyCtor().
+- staticFuncVarArgs(&wxPointSize_OpToString<wxPoint>, "_tostring", "").
+- staticFuncVarArgs(&wxPoint_OpCmp, "_cmp", "*").
+- var(&wxPoint::x, "x").
+- var(&wxPoint::y, "y");
++ BindMethod(v, _SC("IsFileWritable"), wxFileName_ReturnBool<&wxFileName::IsFileWritable>,
++ _SC("wxFileName::IsFileWritable"));
++ BindMethod(v, _SC("IsFileReadable"), wxFileName_ReturnBool<&wxFileName::IsFileReadable>,
++ _SC("wxFileName::IsFileReadable"));
++ BindMethod(v, _SC("IsFileExecutable"), wxFileName_ReturnBool<&wxFileName::IsFileExecutable>,
++ _SC("wxFileName::IsFileExecutable"));
+
+- ////////////
+- // wxSize //
+- ////////////
+- typedef void(wxSize::*WXS_SET)(int, int);
+- typedef void(wxSize::*WXS_SETH)(int);
+- typedef void(wxSize::*WXS_SETW)(int);
+- SqPlus::SQClassDef<wxSize>("wxSize").
+- emptyCtor().
+- staticFuncVarArgs(&wxPointSize_OpToString<wxSize>, "_tostring", "").
+- func(&wxSize::GetWidth, "GetWidth").
+- func(&wxSize::GetHeight, "GetHeight").
+- func<WXS_SET>(&wxSize::Set, "Set").
+- func<WXS_SETH>(&wxSize::SetHeight, "SetHeight").
+- func<WXS_SETW>(&wxSize::SetWidth, "SetWidth");
++ BindMethod(v, _SC("IsDirWritable"), wxFileName_ReturnBool<&wxFileName::IsDirWritable>,
++ _SC("wxFileName::IsDirWritable"));
++ BindMethod(v, _SC("IsDirReadable"), wxFileName_ReturnBool<&wxFileName::IsDirReadable>,
++ _SC("wxFileName::IsDirReadable"));
+
+- //////////////
+- // wxString //
+- //////////////
+- SqPlus::RegisterGlobal(&static_, "_");
+- SqPlus::RegisterGlobal(&static_T, "_T");
++ sq_newslot(v, classDecl, SQFalse); // Put the class in the root table. This must be last!
++ }
+
+- typedef int(wxString::*WXSTR_FIRST_STR)(const wxString&)const;
+- typedef wxString&(wxString::*WXSTR_REMOVE_2)(size_t pos, size_t len);
++ sq_pop(v, 1); // Pop root table.
++}
+
+- SqPlus::SQClassDef<wxString>("wxString").
+- emptyCtor().
+- staticFuncVarArgs(&wxString_Set, "Set", "*").
+- staticFuncVarArgs(&wxString_OpAdd, "_add", "*").
+- staticFuncVarArgs(&wxString_OpCmp, "_cmp", "*").
+- staticFuncVarArgs(&wxString_OpCmp, "Compare", "*").
+- staticFuncVarArgs(&wxString_OpToString, "_tostring", "").
+- func<WXSTR_FIRST_STR>(&wxString::First, "Find").
+- staticFuncVarArgs(&wxString_Matches, "Matches", "*").
+- staticFuncVarArgs(&wxString_AddChar, "AddChar", "n").
+- staticFuncVarArgs(&wxString_GetChar, "GetChar", "n").
+- func(&wxString::IsEmpty, "IsEmpty").
+- func(&wxString::Length, "Length").
+- func(&wxString::Length, "length").
+- func(&wxString::Length, "len").
+- func(&wxString::Length, "size").
+- func(&wxString::Lower, "Lower").
+- func(&wxString::LowerCase, "LowerCase").
+- func(&wxString::MakeLower, "MakeLower").
+- func(&wxString::Upper, "Upper").
+- func(&wxString::UpperCase, "UpperCase").
+- func(&wxString::MakeUpper, "MakeUpper").
+- func(&wxString::Mid, "Mid").
+- func<WXSTR_REMOVE_2>(&wxString::Remove, "Remove").
+- func(&wxString::RemoveLast, "RemoveLast").
+- staticFuncVarArgs(&wxString_Replace, "Replace", "*").
+- func(&wxString::Right, "Right").
+- func(&wxString::Left, "Left").
+- staticFuncVarArgs(&wxString_AfterFirst, "AfterFirst", "*").
+- staticFuncVarArgs(&wxString_AfterLast, "AfterLast", "*").
+- staticFuncVarArgs(&wxString_BeforeFirst, "BeforeFirst", "*").
+- staticFuncVarArgs(&wxString_BeforeLast, "BeforeLast", "*");
+- }
+-};
++} // namespace ScriptBindings
+
More information about the arch-commits
mailing list