Gentoo Attachment #95614 for bug #145800

View | Details | Raw Unified
Collapse All | Expand All

(-) fox1.2-1.2.13.orig/include/FXCharset.h (+9 lines)

Lines 27-32	Link Here

namespace FX {

namespace FX {

/// A set of characters

/// A set of characters

class FXCharset;

/// Save set to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXCharset& cs);

/// Load set from a stream

FXAPI FXStream& operator>>(FXStream& store,FXCharset& cs);

class FXAPI FXCharset {

class FXAPI FXCharset {

private:

private:

  FXuint s[8];              // Because 8*32 is 256 characters

  FXuint s[8];              // Because 8*32 is 256 characters

(-) fox1.2-1.2.13.orig/include/FXMat3d.h (+36 lines)

Lines 29-34	Link Here

/// Double-precision 3x3 matrix

/// Double-precision 3x3 matrix

class FXMat3d;

/// Other operators

FXAPI FXMat3d operator+(const FXMat3d& a,const FXMat3d& b);

FXAPI FXMat3d operator-(const FXMat3d& a,const FXMat3d& b);

FXAPI FXMat3d operator-(const FXMat3d& a);

FXAPI FXMat3d operator*(const FXMat3d& a,const FXMat3d& b);

FXAPI FXMat3d operator*(FXdouble x,const FXMat3d& a);

FXAPI FXMat3d operator*(const FXMat3d& a,FXdouble x);

FXAPI FXMat3d operator/(const FXMat3d& a,FXdouble x);

FXAPI FXMat3d operator/(FXdouble x,const FXMat3d& a);

/// Multiply matrix and vector

FXAPI FXVec3d operator*(const FXVec3d& v,const FXMat3d& m);

FXAPI FXVec3d operator*(const FXMat3d& a,const FXVec3d& v);

/// Mutiply matrix and vector, for non-projective matrix

FXAPI FXVec2d operator*(const FXVec2d& v,const FXMat3d& m);

FXAPI FXVec2d operator*(const FXMat3d& a,const FXVec2d& v);

/// Determinant

FXAPI FXdouble det(const FXMat3d& m);

/// Transpose

FXAPI FXMat3d transpose(const FXMat3d& m);

/// Invert

FXAPI FXMat3d invert(const FXMat3d& m);

/// Save to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXMat3d& m);

/// Load from a stream

FXAPI FXStream& operator>>(FXStream& store,FXMat3d& m);

class FXAPI FXMat3d {

class FXAPI FXMat3d {

protected:

protected:

  FXVec3d m[3];

  FXVec3d m[3];

(-) fox1.2-1.2.13.orig/include/FXMat3f.h (+36 lines)

Lines 29-34	Link Here

/// Single-precision 3x3 matrix

/// Single-precision 3x3 matrix

class FXMat3f;

/// Other operators

FXAPI FXMat3f operator+(const FXMat3f& a,const FXMat3f& b);

FXAPI FXMat3f operator-(const FXMat3f& a,const FXMat3f& b);

FXAPI FXMat3f operator-(const FXMat3f& a);

FXAPI FXMat3f operator*(const FXMat3f& a,const FXMat3f& b);

FXAPI FXMat3f operator*(FXfloat x,const FXMat3f& a);

FXAPI FXMat3f operator*(const FXMat3f& a,FXfloat x);

FXAPI FXMat3f operator/(const FXMat3f& a,FXfloat x);

FXAPI FXMat3f operator/(FXfloat x,const FXMat3f& a);

/// Multiply matrix and vector

FXAPI FXVec3f operator*(const FXVec3f& v,const FXMat3f& m);

FXAPI FXVec3f operator*(const FXMat3f& a,const FXVec3f& v);

/// Mutiply matrix and vector, for non-projective matrix

FXAPI FXVec2f operator*(const FXVec2f& v,const FXMat3f& m);

FXAPI FXVec2f operator*(const FXMat3f& a,const FXVec2f& v);

/// Determinant

FXAPI FXfloat det(const FXMat3f& m);

/// Transpose

FXAPI FXMat3f transpose(const FXMat3f& m);

/// Invert

FXAPI FXMat3f invert(const FXMat3f& m);

/// Save to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXMat3f& m);

/// Load from a stream

FXAPI FXStream& operator>>(FXStream& store,FXMat3f& m);

class FXAPI FXMat3f {

class FXAPI FXMat3f {

protected:

protected:

  FXVec3f m[3];

  FXVec3f m[3];

(-) fox1.2-1.2.13.orig/include/FXMat4d.h (+36 lines)

Lines 29-34	Link Here

/// Double-precision 4x4 matrix

/// Double-precision 4x4 matrix

class FXMat4d;

/// Other operators

FXAPI FXMat4d operator+(const FXMat4d& a,const FXMat4d& b);

FXAPI FXMat4d operator-(const FXMat4d& a,const FXMat4d& b);

FXAPI FXMat4d operator-(const FXMat4d& a);

FXAPI FXMat4d operator*(const FXMat4d& a,const FXMat4d& b);

FXAPI FXMat4d operator*(FXdouble x,const FXMat4d& a);

FXAPI FXMat4d operator*(const FXMat4d& a,FXdouble x);

FXAPI FXMat4d operator/(const FXMat4d& a,FXdouble x);

FXAPI FXMat4d operator/(FXdouble x,const FXMat4d& a);

/// Multiply matrix and vector

FXAPI FXVec4d operator*(const FXVec4d& v,const FXMat4d& m);

FXAPI FXVec4d operator*(const FXMat4d& a,const FXVec4d& v);

/// Mutiply matrix and vector, for non-projective matrix

FXAPI FXVec3d operator*(const FXVec3d& v,const FXMat4d& m);

FXAPI FXVec3d operator*(const FXMat4d& a,const FXVec3d& v);

/// Determinant

FXAPI FXdouble det(const FXMat4d& m);

/// Transpose

FXAPI FXMat4d transpose(const FXMat4d& m);

/// Invert

FXAPI FXMat4d invert(const FXMat4d& m);

/// Save to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXMat4d& m);

/// Load from a stream

FXAPI FXStream& operator>>(FXStream& store,FXMat4d& m);

class FXAPI FXMat4d {

class FXAPI FXMat4d {

protected:

protected:

  FXVec4d m[4];

  FXVec4d m[4];

(-) fox1.2-1.2.13.orig/include/FXMat4f.h (+36 lines)

Lines 29-34	Link Here

/// Single-precision 4x4 matrix

/// Single-precision 4x4 matrix

class FXMat4f;

/// Other operators

FXAPI FXMat4f operator+(const FXMat4f& a,const FXMat4f& b);

FXAPI FXMat4f operator-(const FXMat4f& a,const FXMat4f& b);

FXAPI FXMat4f operator-(const FXMat4f& a);

FXAPI FXMat4f operator*(const FXMat4f& a,const FXMat4f& b);

FXAPI FXMat4f operator*(FXfloat x,const FXMat4f& a);

FXAPI FXMat4f operator*(const FXMat4f& a,FXfloat x);

FXAPI FXMat4f operator/(const FXMat4f& a,FXfloat x);

FXAPI FXMat4f operator/(FXfloat x,const FXMat4f& a);

/// Multiply matrix and vector

FXAPI FXVec4f operator*(const FXVec4f& v,const FXMat4f& m);

FXAPI FXVec4f operator*(const FXMat4f& a,const FXVec4f& v);

/// Mutiply matrix and vector, for non-projective matrix

FXAPI FXVec3f operator*(const FXVec3f& v,const FXMat4f& m);

FXAPI FXVec3f operator*(const FXMat4f& a,const FXVec3f& v);

/// Determinant

FXAPI FXfloat det(const FXMat4f& m);

/// Transpose

FXAPI FXMat4f transpose(const FXMat4f& m);

/// Invert

FXAPI FXMat4f invert(const FXMat4f& m);

/// Save to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXMat4f& m);

/// Load from a stream

FXAPI FXStream& operator>>(FXStream& store,FXMat4f& m);

class FXAPI FXMat4f {

class FXAPI FXMat4f {

protected:

protected:

  FXVec4f m[4];

  FXVec4f m[4];

(-) fox1.2-1.2.13.orig/include/FXPoint.h (+9 lines)

Lines 28-33	Link Here

namespace FX {

namespace FX {

/// Point

/// Point

class FXPoint;

/// Save object to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXPoint& p);

/// Load object from a stream

FXAPI FXStream& operator>>(FXStream& store,FXPoint& p);

class FXAPI FXPoint {

class FXAPI FXPoint {

public:

public:

  FXshort x;

  FXshort x;

(-) fox1.2-1.2.13.orig/include/FXQuatd.h (+30 lines)

Lines 29-34	Link Here

/// double-precision quaternion

/// double-precision quaternion

class FXQuatd;

/// Exponentiate quaternion

FXAPI FXQuatd exp(const FXQuatd& q);

/// Take logarithm of quaternion

FXAPI FXQuatd log(const FXQuatd& q);

/// Invert quaternion

FXAPI FXQuatd invert(const FXQuatd& q);

/// Invert unit quaternion

FXAPI FXQuatd unitinvert(const FXQuatd& q);

/// Conjugate quaternion

FXAPI FXQuatd conj(const FXQuatd& q);

/// Multiply quaternions

FXAPI FXQuatd operator*(const FXQuatd& p,const FXQuatd& q);

// Rotation of a vector by a quaternion

FXAPI FXVec3d operator*(const FXQuatd& quat,const FXVec3d& vec);

/// Construct quaternion from arc a->b on unit sphere

FXAPI FXQuatd arc(const FXVec3d& a,const FXVec3d& b);

/// Spherical lerp

FXAPI FXQuatd lerp(const FXQuatd& u,const FXQuatd& v,FXdouble f);

class FXAPI FXQuatd : public FXVec4d {

class FXAPI FXQuatd : public FXVec4d {

public:

public:

(-) fox1.2-1.2.13.orig/include/FXQuatf.h (+30 lines)

Lines 29-34	Link Here

/// Single-precision quaternion

/// Single-precision quaternion

class FXQuatf;

/// Exponentiate quaternion

FXAPI FXQuatf exp(const FXQuatf& q);

/// Take logarithm of quaternion

FXAPI FXQuatf log(const FXQuatf& q);

/// Invert quaternion

FXAPI FXQuatf invert(const FXQuatf& q);

/// Invert unit quaternion

FXAPI FXQuatf unitinvert(const FXQuatf& q);

/// Conjugate quaternion

FXAPI FXQuatf conj(const FXQuatf& q);

/// Multiply quaternions

FXAPI FXQuatf operator*(const FXQuatf& p,const FXQuatf& q);

// Rotation of a vector by a quaternion

FXAPI FXVec3f operator*(const FXQuatf& quat,const FXVec3f& vec);

/// Construct quaternion from arc a->b on unit sphere

FXAPI FXQuatf arc(const FXVec3f& a,const FXVec3f& b);

/// Spherical lerp

FXAPI FXQuatf lerp(const FXQuatf& u,const FXQuatf& v,FXfloat f);

class FXAPI FXQuatf : public FXVec4f {

class FXAPI FXQuatf : public FXVec4f {

public:

public:

(-) fox1.2-1.2.13.orig/include/FXRanged.h (+18 lines)

Lines 32-37	Link Here

/// Bounds

/// Bounds

class FXRanged;

/// Test if bounds overlap

FXAPI FXbool overlap(const FXRanged& a,const FXRanged& b);

/// Union of two boxes

FXAPI FXRanged unite(const FXRanged& a,const FXRanged& b);

/// Intersection of two boxes

FXAPI FXRanged intersect(const FXRanged& a,const FXRanged& b);

/// Save object to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXRanged& bounds);

/// Load object from a stream

FXAPI FXStream& operator>>(FXStream& store,FXRanged& bounds);

class FXAPI FXRanged {

class FXAPI FXRanged {

public:

public:

  FXVec3d lower;

  FXVec3d lower;

(-) fox1.2-1.2.13.orig/include/FXRangef.h (+18 lines)

Lines 32-37	Link Here

/// Bounds

/// Bounds

class FXRangef;

/// Test if boxes a and b overlap

FXAPI FXbool overlap(const FXRangef& a,const FXRangef& b);

/// Union of two boxes

FXAPI FXRangef unite(const FXRangef& a,const FXRangef& b);

/// Intersection of two boxes

FXAPI FXRangef intersect(const FXRangef& a,const FXRangef& b);

/// Save object to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXRangef& bounds);

/// Load object from a stream

FXAPI FXStream& operator>>(FXStream& store,FXRangef& bounds);

class FXAPI FXRangef {

class FXAPI FXRangef {

public:

public:

  FXVec3f lower;

  FXVec3f lower;

(-) fox1.2-1.2.13.orig/include/FXRectangle.h (+12 lines)

Lines 28-33	Link Here

namespace FX {

namespace FX {

/// Rectangle

/// Rectangle

class FXRectangle;

/// Rectangles overlap

FXAPI FXbool overlap(const FXRectangle& a,const FXRectangle& b);

/// Save object to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXRectangle& r);

/// Load object from a stream

FXAPI FXStream& operator>>(FXStream& store,FXRectangle& r);

class FXAPI FXRectangle {

class FXAPI FXRectangle {

public:

public:

  FXshort x;

  FXshort x;

(-) fox1.2-1.2.13.orig/include/FXRegion.h (+21 lines)

Lines 27-32	Link Here

namespace FX {

namespace FX {

/// Region

/// Region

class FXRegion;

/// Union of region r1 and region r2

FXAPI FXRegion operator+(const FXRegion& r1,const FXRegion& r2);

/// Intersection of region r1 and region r2

FXAPI FXRegion operator*(const FXRegion& r1,const FXRegion& r2);

/// Substract region r2 from region r1

FXAPI FXRegion operator-(const FXRegion& r1,const FXRegion& r2);

/// Xor of region r1 and region r2

FXAPI FXRegion operator^(const FXRegion& r1,const FXRegion& r2);

/// Return TRUE if region equal to this one

FXAPI FXbool operator==(const FXRegion& r1,const FXRegion& r2);

/// Return TRUE if region not equal to this one

FXAPI FXbool operator!=(const FXRegion& r1,const FXRegion& r2);

class FXAPI FXRegion {

class FXAPI FXRegion {

  friend class FXDC;

  friend class FXDC;

  friend class FXDCWindow;

  friend class FXDCWindow;

(-) fox1.2-1.2.13.orig/include/FXRex.h (+11 lines)

Lines 96-101	Link Here

* or line end. The flag REX_NOT_EMPTY causes a match to fail if

* or line end. The flag REX_NOT_EMPTY causes a match to fail if

* the empty string was matched.

* the empty string was matched.

*/

*/

class FXRex;

/// Comparison operators

FXAPI FXbool operator==(const FXRex &r1,const FXRex &r2);

FXAPI FXbool operator!=(const FXRex &r1,const FXRex &r2);

/// Saving and loading

FXAPI FXStream& operator<<(FXStream& store,const FXRex& s);

FXAPI FXStream& operator>>(FXStream& store,FXRex& s);

class FXAPI FXRex {

class FXAPI FXRex {

private:

private:

  FXint *code;

  FXint *code;

(-) fox1.2-1.2.13.orig/include/FXSize.h (+8 lines)

Lines 28-33	Link Here

namespace FX {

namespace FX {

/// Size

/// Size

class FXSize;

/// Save object to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXSize& s);

/// Load object from a stream

FXAPI FXStream& operator>>(FXStream& store,FXSize& s);

class FXAPI FXSize {

class FXAPI FXSize {

public:

public:

  FXshort w;

  FXshort w;

(-) fox1.2-1.2.13.orig/include/FXSphered.h (+18 lines)

Lines 32-37	Link Here

// Spherical bounds

// Spherical bounds

class FXSphered;

/// Test if box overlaps with sphere

FXAPI FXbool overlap(const FXRanged& a,const FXSphered& b);

/// Test if sphere overlaps with box

FXAPI FXbool overlap(const FXSphered& a,const FXRanged& b);

/// Test if spheres overlap

FXAPI FXbool overlap(const FXSphered& a,const FXSphered& b);

/// Save object to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXSphered& sphere);

/// Load object from a stream

FXAPI FXStream& operator>>(FXStream& store,FXSphered& sphere);

class FXAPI FXSphered {

class FXAPI FXSphered {

public:

public:

  FXVec3d  center;

  FXVec3d  center;

(-) fox1.2-1.2.13.orig/include/FXSpheref.h (+18 lines)

Lines 32-37	Link Here

// Spherical bounds

// Spherical bounds

class FXSpheref;

/// Test if box overlaps with sphere

FXAPI FXbool overlap(const FXRangef& a,const FXSpheref& b);

/// Test if sphere overlaps with box

FXAPI FXbool overlap(const FXSpheref& a,const FXRangef& b);

/// Test if spheres overlap

FXAPI FXbool overlap(const FXSpheref& a,const FXSpheref& b);

/// Save object to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXSpheref& sphere);

/// Load object from a stream

FXAPI FXStream& operator>>(FXStream& store,FXSpheref& sphere);

class FXAPI FXSpheref {

class FXAPI FXSpheref {

public:

public:

  FXVec3f center;

  FXVec3f center;

(-) fox1.2-1.2.13.orig/include/FXString.h (-25 / +102 lines)

Lines 30-35	Link Here

/**

/**

* FXString provides essential string manipulation capabilities.

* FXString provides essential string manipulation capabilities.

*/

*/

class FXString;

/// Compare

FXAPI FXint compare(const FXchar* s1,const FXchar* s2);

FXAPI FXint compare(const FXchar* s1,const FXString& s2);

FXAPI FXint compare(const FXString& s1,const FXchar* s2);

FXAPI FXint compare(const FXString& s1,const FXString& s2);

/// Compare up to n

FXAPI FXint compare(const FXchar* s1,const FXchar* s2,FXint n);

FXAPI FXint compare(const FXchar* s1,const FXString& s2,FXint n);

FXAPI FXint compare(const FXString& s1,const FXchar* s2,FXint n);

FXAPI FXint compare(const FXString& s1,const FXString& s2,FXint n);

/// Compare case insensitive

FXAPI FXint comparecase(const FXchar* s1,const FXchar* s2);

FXAPI FXint comparecase(const FXchar* s1,const FXString& s2);

FXAPI FXint comparecase(const FXString& s1,const FXchar* s2);

FXAPI FXint comparecase(const FXString& s1,const FXString& s2);

/// Compare case insensitive up to n

FXAPI FXint comparecase(const FXchar* s1,const FXchar* s2,FXint n);

FXAPI FXint comparecase(const FXchar* s1,const FXString& s2,FXint n);

FXAPI FXint comparecase(const FXString& s1,const FXchar* s2,FXint n);

FXAPI FXint comparecase(const FXString& s1,const FXString& s2,FXint n);

/// Comparison operators

FXAPI FXbool operator==(const FXString& s1,const FXString& s2);

FXAPI FXbool operator==(const FXString& s1,const FXchar* s2);

FXAPI FXbool operator==(const FXchar* s1,const FXString& s2);

FXAPI FXbool operator!=(const FXString& s1,const FXString& s2);

FXAPI FXbool operator!=(const FXString& s1,const FXchar* s2);

FXAPI FXbool operator!=(const FXchar* s1,const FXString& s2);

FXAPI FXbool operator<(const FXString& s1,const FXString& s2);

FXAPI FXbool operator<(const FXString& s1,const FXchar* s2);

FXAPI FXbool operator<(const FXchar* s1,const FXString& s2);

FXAPI FXbool operator<=(const FXString& s1,const FXString& s2);

FXAPI FXbool operator<=(const FXString& s1,const FXchar* s2);

FXAPI FXbool operator<=(const FXchar* s1,const FXString& s2);

FXAPI FXbool operator>(const FXString& s1,const FXString& s2);

FXAPI FXbool operator>(const FXString& s1,const FXchar* s2);

FXAPI FXbool operator>(const FXchar* s1,const FXString& s2);

FXAPI FXbool operator>=(const FXString& s1,const FXString& s2);

FXAPI FXbool operator>=(const FXString& s1,const FXchar* s2);

FXAPI FXbool operator>=(const FXchar* s1,const FXString& s2);

/// Concatenate two strings

FXAPI FXString operator+(const FXString& s1,const FXString& s2);

FXAPI FXString operator+(const FXString& s1,const FXchar* s2);

FXAPI FXString operator+(const FXchar* s1,const FXString& s2);

/// Concatenate with single character

FXAPI FXString operator+(const FXString& s,FXchar c);

FXAPI FXString operator+(FXchar c,const FXString& s);

/// Saving to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXString& s);

/// Load from a stream

FXAPI FXStream& operator>>(FXStream& store,FXString& s);

/// Format a string a-la printf

FXAPI FXString FXStringFormat(const FXchar* fmt,...) FX_PRINTF(1,2) ;

FXAPI FXString FXStringVFormat(const FXchar* fmt,va_list args);

/**

* Convert integer number to a string, using the given number

* base, which must be between 2 and 16.

*/

FXAPI FXString FXStringVal(FXint num,FXint base=10);

FXAPI FXString FXStringVal(FXuint num,FXint base=10);

/**

* Convert real number to a string, using the given procision and

* exponential notation mode, which may be FALSE (never), TRUE (always), or

* MAYBE (when needed).

*/

FXAPI FXString FXStringVal(FXfloat num,FXint prec=6,FXbool exp=MAYBE);

FXAPI FXString FXStringVal(FXdouble num,FXint prec=6,FXbool exp=MAYBE);

/// Convert string to a integer number, assuming given number base

FXAPI FXint FXIntVal(const FXString& s,FXint base);

FXAPI FXuint FXUIntVal(const FXString& s,FXint base);

/// Convert string into real number

FXAPI FXfloat FXFloatVal(const FXString& s);

FXAPI FXdouble FXDoubleVal(const FXString& s);

/// Escape special characters in a string

FXAPI FXString escape(const FXString& s);

/// Unescape special characters in a string

FXAPI FXString unescape(const FXString& s);

/// Swap two strings

FXAPI void swap(FXString& a,FXString& b);

class FXAPI FXString {

class FXAPI FXString {

private:

private:

  FXchar* str;

  FXchar* str;

Lines 359-383	Link Here

  FXuint hash() const;

  FXuint hash() const;

  /// Compare

  /// Compare

  friend FXAPI FXint compare(const FXchar* s1,const FXchar* s2);

  friend FXAPI FXint compare(const FXchar* s1,const FXString& s2);

  friend FXAPI FXint compare(const FXchar* s1,const FXString& s2);

  friend FXAPI FXint compare(const FXString& s1,const FXchar* s2);

  friend FXAPI FXint compare(const FXString& s1,const FXchar* s2);

  friend FXAPI FXint compare(const FXString& s1,const FXString& s2);

  friend FXAPI FXint compare(const FXString& s1,const FXString& s2);

  /// Compare up to n

  /// Compare up to n

  friend FXAPI FXint compare(const FXchar* s1,const FXchar* s2,FXint n);

  friend FXAPI FXint compare(const FXchar* s1,const FXString& s2,FXint n);

  friend FXAPI FXint compare(const FXchar* s1,const FXString& s2,FXint n);

  friend FXAPI FXint compare(const FXString& s1,const FXchar* s2,FXint n);

  friend FXAPI FXint compare(const FXString& s1,const FXchar* s2,FXint n);

  friend FXAPI FXint compare(const FXString& s1,const FXString& s2,FXint n);

  friend FXAPI FXint compare(const FXString& s1,const FXString& s2,FXint n);

  /// Compare case insensitive

  /// Compare case insensitive

  friend FXAPI FXint comparecase(const FXchar* s1,const FXchar* s2);

  friend FXAPI FXint comparecase(const FXchar* s1,const FXString& s2);

  friend FXAPI FXint comparecase(const FXchar* s1,const FXString& s2);

  friend FXAPI FXint comparecase(const FXString& s1,const FXchar* s2);

  friend FXAPI FXint comparecase(const FXString& s1,const FXchar* s2);

  friend FXAPI FXint comparecase(const FXString& s1,const FXString& s2);

  friend FXAPI FXint comparecase(const FXString& s1,const FXString& s2);

  /// Compare case insensitive up to n

  /// Compare case insensitive up to n

  friend FXAPI FXint comparecase(const FXchar* s1,const FXchar* s2,FXint n);

  friend FXAPI FXint comparecase(const FXchar* s1,const FXString& s2,FXint n);

  friend FXAPI FXint comparecase(const FXchar* s1,const FXString& s2,FXint n);

  friend FXAPI FXint comparecase(const FXString& s1,const FXchar* s2,FXint n);

  friend FXAPI FXint comparecase(const FXString& s1,const FXchar* s2,FXint n);

  friend FXAPI FXint comparecase(const FXString& s1,const FXString& s2,FXint n);

  friend FXAPI FXint comparecase(const FXString& s1,const FXString& s2,FXint n);

Lines 431-451	Link Here

  friend FXAPI FXString FXStringFormat(const FXchar* fmt,...) FX_PRINTF(1,2) ;

  friend FXAPI FXString FXStringFormat(const FXchar* fmt,...) FX_PRINTF(1,2) ;

  friend FXAPI FXString FXStringVFormat(const FXchar* fmt,va_list args);

  friend FXAPI FXString FXStringVFormat(const FXchar* fmt,va_list args);

/**

  * Convert integer number to a string, using the given number

  * base, which must be between 2 and 16.

*/

  friend FXAPI FXString FXStringVal(FXint num,FXint base=10);

  friend FXAPI FXString FXStringVal(FXuint num,FXint base=10);

/**

  * Convert real number to a string, using the given procision and

  * exponential notation mode, which may be FALSE (never), TRUE (always), or

  * MAYBE (when needed).

*/

  friend FXAPI FXString FXStringVal(FXfloat num,FXint prec=6,FXbool exp=MAYBE);

  friend FXAPI FXString FXStringVal(FXdouble num,FXint prec=6,FXbool exp=MAYBE);

  /// Convert string to a integer number, assuming given number base

  /// Convert string to a integer number, assuming given number base

  friend FXAPI FXint FXIntVal(const FXString& s,FXint base=10);

  friend FXAPI FXint FXIntVal(const FXString& s,FXint base=10);

  friend FXAPI FXuint FXUIntVal(const FXString& s,FXint base=10);

  friend FXAPI FXuint FXUIntVal(const FXString& s,FXint base=10);

Lines 454-465	Link Here

  friend FXAPI FXfloat FXFloatVal(const FXString& s);

  friend FXAPI FXfloat FXFloatVal(const FXString& s);

  friend FXAPI FXdouble FXDoubleVal(const FXString& s);

  friend FXAPI FXdouble FXDoubleVal(const FXString& s);

  /// Escape special characters in a string

  friend FXAPI FXString escape(const FXString& s);

  /// Unescape special characters in a string

  friend FXAPI FXString unescape(const FXString& s);

  /// Swap two strings

  /// Swap two strings

  friend FXAPI void swap(FXString& a,FXString& b){ FXchar *t=a.str; a.str=b.str; b.str=t; }

  friend FXAPI void swap(FXString& a,FXString& b){ FXchar *t=a.str; a.str=b.str; b.str=t; }

(-) fox1.2-1.2.13.orig/include/FXVec2d.h (+20 lines)

Lines 29-34	Link Here

/// Double-precision 2-element vector

/// Double-precision 2-element vector

class FXVec2d;

/// Length and square of length

FXAPI FXdouble len2(const FXVec2d& a);

FXAPI FXdouble len(const FXVec2d& a);

/// Normalize vector

FXAPI FXVec2d normalize(const FXVec2d& a);

/// Lowest or highest components

FXAPI FXVec2d lo(const FXVec2d& a,const FXVec2d& b);

FXAPI FXVec2d hi(const FXVec2d& a,const FXVec2d& b);

/// Save vector to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXVec2d& v);

/// Load vector from a stream

FXAPI FXStream& operator>>(FXStream& store,FXVec2d& v);

class FXAPI FXVec2d {

class FXAPI FXVec2d {

public:

public:

  FXdouble x;

  FXdouble x;

(-) fox1.2-1.2.13.orig/include/FXVec2f.h (+20 lines)

Lines 29-34	Link Here

/// Single-precision 2-element vector

/// Single-precision 2-element vector

class FXVec2f;

/// Length and square of length

FXAPI FXfloat len2(const FXVec2f& a);

FXAPI FXfloat len(const FXVec2f& a);

/// Normalize vector

FXAPI FXVec2f normalize(const FXVec2f& a);

/// Lowest or highest components

FXAPI FXVec2f lo(const FXVec2f& a,const FXVec2f& b);

FXAPI FXVec2f hi(const FXVec2f& a,const FXVec2f& b);

/// Save vector to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXVec2f& v);

/// Load vector from a stream

FXAPI FXStream& operator>>(FXStream& store,FXVec2f& v);

class FXAPI FXVec2f {

class FXAPI FXVec2f {

public:

public:

  FXfloat x;

  FXfloat x;

(-) fox1.2-1.2.13.orig/include/FXVec3d.h (+20 lines)

Lines 29-34	Link Here

/// Double-precision 3-element vector

/// Double-precision 3-element vector

class FXVec3d;

/// Length and square of length

FXAPI FXdouble len2(const FXVec3d& a);

FXAPI FXdouble len(const FXVec3d& a);

/// Normalize vector

FXAPI FXVec3d normalize(const FXVec3d& a);

/// Lowest or highest components

FXAPI FXVec3d lo(const FXVec3d& a,const FXVec3d& b);

FXAPI FXVec3d hi(const FXVec3d& a,const FXVec3d& b);

/// Save vector to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXVec3d& v);

/// Load vector from a stream

FXAPI FXStream& operator>>(FXStream& store,FXVec3d& v);

class FXAPI FXVec3d {

class FXAPI FXVec3d {

public:

public:

  FXdouble x;

  FXdouble x;

(-) fox1.2-1.2.13.orig/include/FXVec3f.h (+20 lines)

Lines 29-34	Link Here

/// Single-precision 3-element vector

/// Single-precision 3-element vector

class FXVec3f;

/// Length and square of length

FXAPI FXfloat len2(const FXVec3f& a);

FXAPI FXfloat len(const FXVec3f& a);

/// Normalize vector

FXAPI FXVec3f normalize(const FXVec3f& a);

/// Lowest or highest components

FXAPI FXVec3f lo(const FXVec3f& a,const FXVec3f& b);

FXAPI FXVec3f hi(const FXVec3f& a,const FXVec3f& b);

/// Save vector to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXVec3f& v);

/// Load vector from a stream

FXAPI FXStream& operator>>(FXStream& store,FXVec3f& v);

class FXAPI FXVec3f {

class FXAPI FXVec3f {

public:

public:

  FXfloat x;

  FXfloat x;

(-) fox1.2-1.2.13.orig/include/FXVec4d.h (+20 lines)

Lines 29-34	Link Here

/// Double-precision 4-element vector

/// Double-precision 4-element vector

class FXVec4d;

/// Length and square of length

FXAPI FXdouble len2(const FXVec4d& a);

FXAPI FXdouble len(const FXVec4d& a);

/// Normalize vector

FXAPI FXVec4d normalize(const FXVec4d& a);

/// Lowest or highest components

FXAPI FXVec4d lo(const FXVec4d& a,const FXVec4d& b);

FXAPI FXVec4d hi(const FXVec4d& a,const FXVec4d& b);

/// Save to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXVec4d& v);

/// Load from a stream

FXAPI FXStream& operator>>(FXStream& store,FXVec4d& v);

class FXAPI FXVec4d {

class FXAPI FXVec4d {

public:

public:

  FXdouble x;

  FXdouble x;

(-) fox1.2-1.2.13.orig/include/FXVec4f.h (+20 lines)

Lines 29-34	Link Here

/// Single-precision 4-element vector

/// Single-precision 4-element vector

class FXVec4f;

/// Length and square of length

FXAPI FXfloat len2(const FXVec4f& a);

FXAPI FXfloat len(const FXVec4f& a);

/// Normalize vector

FXAPI FXVec4f normalize(const FXVec4f& a);

/// Lowest or highest components

FXAPI FXVec4f lo(const FXVec4f& a,const FXVec4f& b);

FXAPI FXVec4f hi(const FXVec4f& a,const FXVec4f& b);

/// Save to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXVec4f& v);

/// Load from a stream

FXAPI FXStream& operator>>(FXStream& store,FXVec4f& v);

class FXAPI FXVec4f {

class FXAPI FXVec4f {

public:

public:

  FXfloat x;

  FXfloat x;

(-) fox1.2-1.2.13.orig/include/FXWString.h (-4 / +69 lines)

Lines 34-39	Link Here

/**

/**

* FXWString provides a "wide" string class suitable for storing Unicode strings.

* FXWString provides a "wide" string class suitable for storing Unicode strings.

*/

*/

class FXWString;

/// Compare

FXAPI FXint compare(const FXwchar *s1,const FXwchar *s2);

FXAPI FXint compare(const FXwchar *s1,const FXWString &s2);

FXAPI FXint compare(const FXWString &s1,const FXwchar *s2);

FXAPI FXint compare(const FXWString &s1,const FXWString &s2);

/// Compare up to n

FXAPI FXint compare(const FXwchar *s1,const FXwchar *s2,FXint n);

FXAPI FXint compare(const FXwchar *s1,const FXWString &s2,FXint n);

FXAPI FXint compare(const FXWString &s1,const FXwchar *s2,FXint n);

FXAPI FXint compare(const FXWString &s1,const FXWString &s2,FXint n);

/// Compare case insensitive

FXAPI FXint comparecase(const FXwchar *s1,const FXwchar *s2);

FXAPI FXint comparecase(const FXwchar *s1,const FXWString &s2);

FXAPI FXint comparecase(const FXWString &s1,const FXwchar *s2);

FXAPI FXint comparecase(const FXWString &s1,const FXWString &s2);

/// Compare case insensitive up to n

FXAPI FXint comparecase(const FXwchar *s1,const FXwchar *s2,FXint n);

FXAPI FXint comparecase(const FXwchar *s1,const FXWString &s2,FXint n);

FXAPI FXint comparecase(const FXWString &s1,const FXwchar *s2,FXint n);

FXAPI FXint comparecase(const FXWString &s1,const FXWString &s2,FXint n);

/// Comparison operators

FXAPI FXbool operator==(const FXWString &s1,const FXWString &s2);

FXAPI FXbool operator==(const FXWString &s1,const FXwchar *s2);

FXAPI FXbool operator==(const FXwchar *s1,const FXWString &s2);

FXAPI FXbool operator!=(const FXWString &s1,const FXWString &s2);

FXAPI FXbool operator!=(const FXWString &s1,const FXwchar *s2);

FXAPI FXbool operator!=(const FXwchar *s1,const FXWString &s2);

FXAPI FXbool operator<(const FXWString &s1,const FXWString &s2);

FXAPI FXbool operator<(const FXWString &s1,const FXwchar *s2);

FXAPI FXbool operator<(const FXwchar *s1,const FXWString &s2);

FXAPI FXbool operator<=(const FXWString &s1,const FXWString &s2);

FXAPI FXbool operator<=(const FXWString &s1,const FXwchar *s2);

FXAPI FXbool operator<=(const FXwchar *s1,const FXWString &s2);

FXAPI FXbool operator>(const FXWString &s1,const FXWString &s2);

FXAPI FXbool operator>(const FXWString &s1,const FXwchar *s2);

FXAPI FXbool operator>(const FXwchar *s1,const FXWString &s2);

FXAPI FXbool operator>=(const FXWString &s1,const FXWString &s2);

FXAPI FXbool operator>=(const FXWString &s1,const FXwchar *s2);

FXAPI FXbool operator>=(const FXwchar *s1,const FXWString &s2);

/// Concatenate two strings

FXAPI FXWString operator+(const FXWString& s1,const FXWString& s2);

FXAPI FXWString operator+(const FXWString& s1,const FXwchar* s2);

FXAPI FXWString operator+(const FXwchar* s1,const FXWString& s2);

/// Concatenate with single character

FXAPI FXWString operator+(const FXWString& s,FXwchar c);

FXAPI FXWString operator+(FXwchar c,const FXWString& s);

/// Saving to a stream

FXAPI FXStream& operator<<(FXStream& store,const FXWString& s);

/// Load from a stream

FXAPI FXStream& operator>>(FXStream& store,FXWString& s);

/// Swap two strings

FXAPI void swap(FXWString& a,FXWString& b);

class FXAPI FXWString {

class FXAPI FXWString {

private:

private:

  FXwchar* str;

  FXwchar* str;

Lines 363-387	Link Here

  FXuint hash() const;

  FXuint hash() const;

  /// Compare

  /// Compare

  friend FXAPI FXint compare(const FXwchar *s1,const FXwchar *s2);

  friend FXAPI FXint compare(const FXwchar *s1,const FXWString &s2);

  friend FXAPI FXint compare(const FXwchar *s1,const FXWString &s2);

  friend FXAPI FXint compare(const FXWString &s1,const FXwchar *s2);

  friend FXAPI FXint compare(const FXWString &s1,const FXwchar *s2);

  friend FXAPI FXint compare(const FXWString &s1,const FXWString &s2);

  friend FXAPI FXint compare(const FXWString &s1,const FXWString &s2);

  /// Compare up to n

  /// Compare up to n

  friend FXAPI FXint compare(const FXwchar *s1,const FXwchar *s2,FXint n);

  friend FXAPI FXint compare(const FXwchar *s1,const FXWString &s2,FXint n);

  friend FXAPI FXint compare(const FXwchar *s1,const FXWString &s2,FXint n);

  friend FXAPI FXint compare(const FXWString &s1,const FXwchar *s2,FXint n);

  friend FXAPI FXint compare(const FXWString &s1,const FXwchar *s2,FXint n);

  friend FXAPI FXint compare(const FXWString &s1,const FXWString &s2,FXint n);

  friend FXAPI FXint compare(const FXWString &s1,const FXWString &s2,FXint n);

  /// Compare case insensitive

  /// Compare case insensitive

  friend FXAPI FXint comparecase(const FXwchar *s1,const FXwchar *s2);

  friend FXAPI FXint comparecase(const FXwchar *s1,const FXWString &s2);

  friend FXAPI FXint comparecase(const FXwchar *s1,const FXWString &s2);

  friend FXAPI FXint comparecase(const FXWString &s1,const FXwchar *s2);

  friend FXAPI FXint comparecase(const FXWString &s1,const FXwchar *s2);

  friend FXAPI FXint comparecase(const FXWString &s1,const FXWString &s2);

  friend FXAPI FXint comparecase(const FXWString &s1,const FXWString &s2);

  /// Compare case insensitive up to n

  /// Compare case insensitive up to n

  friend FXAPI FXint comparecase(const FXwchar *s1,const FXwchar *s2,FXint n);

  friend FXAPI FXint comparecase(const FXwchar *s1,const FXWString &s2,FXint n);

  friend FXAPI FXint comparecase(const FXwchar *s1,const FXWString &s2,FXint n);

  friend FXAPI FXint comparecase(const FXWString &s1,const FXwchar *s2,FXint n);

  friend FXAPI FXint comparecase(const FXWString &s1,const FXwchar *s2,FXint n);

  friend FXAPI FXint comparecase(const FXWString &s1,const FXWString &s2,FXint n);

  friend FXAPI FXint comparecase(const FXWString &s1,const FXWString &s2,FXint n);

Attachment #95614: gcc 4.1 patch for fox 1.2.x headers for bug #145800