basic.pkg

cegui界面库

/***********************************************************************
    Vector2
***********************************************************************/
class Vector2
{
    // rename 'd_x' and 'd_y' to just 'x' and 'y'
    float d_x @ x;
    float d_y @ y;

    Vector2 operator+ (const Vector2& vec) const;
    Vector2 operator- (const Vector2& vec) const;
    Vector2 operator* (const Vector2& vec) const;
    bool operator== (const Vector2& vec) const;

    Vector2();
    Vector2(float x, float y);
};

// do a simple copy of Point to Vector2
$[
CEGUI.Point = CEGUI.Vector2
$]



/***********************************************************************
	Size
***********************************************************************/
class Size
{
	// rename 'd_width' and 'd_height' to just 'width' and 'height'
	float d_width @ width;
	float d_height @ height;

	bool operator== (const Size& sz) const;

	Size();
	Size(float w, float h);
};



/***********************************************************************
	Rect
***********************************************************************/
class Rect
{
	// remove member variable 'd_' prefix
	float d_top @ top;
	float d_bottom @ bottom;
	float d_left @ left;
	float d_right @ right;

	Vector2 getPosition() const;
	float getWidth() const;
	float getHeight() const;
	Size getSize() const;

	Rect getIntersection(const Rect& rect) const;
	bool isPointInRect(const Vector2& p) const;

	void setPosition(const Vector2& p);
	void setWidth(float w);
	void setHeight(float h);
	void setSize(const Size& sz);

	Rect& offset(const Vector2& p);
	Rect& constrainSizeMax(const Size& sz);
	Rect& constrainSizeMin(const Size& sz);
	Rect& constrainSize(const Size& min, const Size& max);

	bool operator== (const Rect& r) const;

	Rect();
	Rect(float l, float t, float r, float b);
};



/***********************************************************************
	colour
***********************************************************************/
class colour
{
	float getAlpha() const;
	float getRed() const;
	float getGreen() const;
	float getBlue() const;
	float getHue() const;
	float getSaturation() const;
	float getLumination() const;

	void set(float r, float g, float b, float a);
	void setAlpha(float a);
	void setRed(float r);
	void setGreen(float g);
	void setBlue(float b);
	void setRGB(float r, float g, float b);
	void setHSL(float hue, float saturation, float luminance, float alpha=1);

	colour operator+ (const colour& c) const;
	colour operator- (const colour& c) const;
	//colour operator* (const colour& c) const; // gives a warning about argb_t to colour conversion
	bool operator== (const colour& c) const;

	colour();
	colour(float r, float g, float b, float a);
};



/***********************************************************************
	ColourRect
***********************************************************************/
class ColourRect
{
	colour d_top_left @ top_left;
	colour d_top_right @ top_right;
	colour d_bottom_left @ bottom_left;
	colour d_bottom_right @ bottom_right;

	void	setAlpha(float alpha);
	void	setTopAlpha(float alpha);
	void	setBottomAlpha(float alpha);
	void	setLeftAlpha(float alpha);
	void	setRightAlpha(float alpha);
	void	modulateAlpha(float alpha);

	void	setColours(const colour& col);

	bool	isMonochromatic() const;

	ColourRect getSubRectangle( float left, float right, float top, float bottom ) const;
	colour getColourAtPoint( float x, float y ) const;

	//ColourRect& operator*= (const ColourRect& other); // no support for *= operators

	ColourRect();
	ColourRect(const colour& col);
	ColourRect(const colour& top_left, const colour& top_right, const colour& bottom_left, const colour& bottom_right);
};



/************************************************************************
    String
*************************************************************************/
class String
{
    static const unsigned long npos;

    unsigned long size() const;
    unsigned long length() const;
    bool empty() const;
    unsigned long capacity() const;

    unsigned long& operator[] (unsigned long i);
    unsigned long& at(unsigned long i);
    string c_str() const;

    void reserve(unsigned long num=0);
    void resize(unsigned long num);
    void resize(unsigned long num, unsigned long codepoint);

    void clear();
    String& erase();
    // default len is different from usual to handle ambiguity issue
    String& erase(unsigned long idx, unsigned long len=1);

    String& replace(unsigned long begin, unsigned long len, const String&s);
    //String& replace(unsigned long begin, unsigned long len, unsigned long codepoint);

    void swap(String& s);
    String& insert(unsigned long pos, const String& s);
    //String& insert(unsigned long pos, unsigned long codepoint);

    unsigned long find(unsigned long codepoint, unsigned long idx=0) const;
    unsigned long rfind(unsigned long codepoint, unsigned long idx=-1) const;
    unsigned long find(const String& sub, unsigned long idx=0) const;
    unsigned long rfind(const String& sub, unsigned long idx=-1) const;

    String substr(unsigned long idx=0, unsigned long len=-1) const;

    void push_back(unsigned long codepoint);

    String();
    String(unsigned long num, unsigned long codepoint);
    String(string s);
    String(const String& s);
};