gwidgets.h

来自「一个由Mike Gashler完成的机器学习方面的includes neural」· C头文件 代码 · 共 1,090 行 · 第 1/2 页

/*
	Copyright (C) 2006, Mike Gashler

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	see http://www.gnu.org/copyleft/lesser.html
*/

#ifndef __GWIDGETS_H__
#define __GWIDGETS_H__

#include "GImage.h"
#include "GString.h"

class GIntArray;
class GPointerArray;
class GWidgetAtomic;
class GWidgetCanvas;
class GWidgetGroup;
class GWidget;
class GWidgetListBox;
class GWidgetTextButton;
class GWidgetTextTab;
class GWidgetImageButton;
class GWidgetVCRButton;
class GWidgetHorizScrollBar;
class GWidgetVertScrollBar;
class GWidgetTextLabel;
class GWidgetFileSystemBrowser;
class GWidgetSliderTab;
class GWidgetTextBox;
class GWidgetPolarLineGraph;
class GWidgetPolarBarGraph;
class GWidgetVertSlider;



class GWidgetStyle
{
protected:
	int m_nButtonFontSize;
	int m_nLabelFontSize;
	float m_fButtonFontWidth;
	float m_fLabelFontWidth;
	GColor m_cButtonTextColor;
	GColor m_cLabelTextColor;
	GColor m_cButtonPressedTextColor;
	GColor m_cTextBoxBorderColor;
	GColor m_cTextBoxTextColor;
	GImage m_bufferImage;

public:
	GWidgetStyle();
	~GWidgetStyle();

	GColor GetTextBoxBorderColor() { return m_cTextBoxBorderColor; }
	GColor GetTextBoxTextColor() { return m_cTextBoxBorderColor; }
	GColor GetTextBoxSelectedTextColor() { return m_cButtonTextColor; }
	int GetListBoxLineHeight() { return 16; }
	int GetDefaultScrollBarSize() { return 16; }
	void DrawButtonText(GImage* pImage, int x, int y, int w, int h, GString* pString, bool pressed);
	void DrawLabelText(GImage* pImage, int x, int y, int w, int h, GString* pString, bool alignLeft, GColor c);
	void DrawHorizCurvedOutSurface(GImage* pImage, int x, int y, int w, int h, GColor col = 0xff0000ff);
	void DrawHorizCurvedInSurface(GImage* pImage, int x, int y, int w, int h, GColor col = 0xff0000ff);
	void DrawVertCurvedOutSurface(GImage* pImage, int x, int y, int w, int h, GColor col = 0xff0000ff);
	void DrawVertCurvedInSurface(GImage* pImage, int x, int y, int w, int h, GColor col = 0xff0000ff);
	void DrawCursor(GImage* pImage, int x, int y, int w, int h);

	// This method lets you draw a widget clipped by some rect. Note that
	// it uses a persistent buffer image to facilitate this. It doesn't
	// clear the image, so if your widget doesn't draw over its entire
	// rect, you'll see garbage from previous uses
	void DrawClipped(GImage* pCanvas, int x, int y, GWidget* pWidget, GRect* pClipRect);
};




// The base class of all GUI widgets
class GWidget
{
friend class GWidgetGroup;
public:
	enum WidgetType
	{
		Animation,
		Canvas,
		CheckBox,
		Custom,
		Dialog,
		FileSystemBrowser,
		Grid,
		HScrollBar,
		ListBox,
		ListBoxItem,
		PolarChart,
		ProgressBar,
		SliderTab,
		TextBox,
		TextButton,
		TextLabel,
		TextTab,
		VCRButton,
		VertSlider,
		VScrollBar,
	};

protected:
	GRect m_rect;
	GWidgetGroup* m_pParent;
	GWidgetStyle* m_pStyle;
	int m_nID; // for use by the owning parent
#ifdef _DEBUG
	unsigned int m_nDebugCheck;
#endif // _DEBUG

public:
	GWidget(GWidgetGroup* m_pParent, int x, int y, int w, int h);
	virtual ~GWidget();

	virtual WidgetType GetType() = 0;
	virtual bool IsAtomicWidget() = 0;
	virtual void Draw(GImage* pCanvas, int x, int y) = 0;
	void SetPos(int x, int y);
	GRect* GetRect() { return &m_rect; }
	int GetID() { return m_nID; }
	GWidgetGroup* GetParent() { return m_pParent; }
#ifdef _DEBUG
	bool DebugCheck();
#endif // _DEBUG
};





// The base class of all atomic widgets (widgets that are not composed of other widgets).
class GWidgetAtomic : public GWidget
{
friend class GWidgetDialog;
public:
	GWidgetAtomic(GWidgetGroup* pParent, int x, int y, int w, int h);
	virtual ~GWidgetAtomic();

	virtual bool IsAtomicWidget() { return true; }
	virtual void OnChar(char c);
	virtual void OnMouseMove(int dx, int dy);
	virtual void OnGetFocus() {}
	virtual void OnLoseFocus() {}

protected:
	virtual void Grab(int button, int x, int y) {}
	virtual void Release(int button) {}
};






// The base class of all widgets that are composed of other widgets
class GWidgetGroup : public GWidget
{
friend class GWidget;
friend class GWidgetAtomic;
protected:
	GPointerArray* m_pWidgets;
	GPointerArray* m_pDirtyChildren;
	GIntArray* m_pDirtyBits;

public:
	GWidgetGroup(GWidgetGroup* pParent, int x, int y, int w, int h);
	virtual ~GWidgetGroup();

	virtual bool IsAtomicWidget() { return false; }
	virtual GWidgetStyle* GetStyle() { return m_pParent->GetStyle(); }
	virtual GWidgetAtomic* FindAtomicWidget(int x, int y);
	virtual void OnDestroyWidget(GWidget* pWidget);
	int GetChildWidgetCount();
	GWidget* GetChildWidget(int n);
	virtual void Tattle(GWidget* pChild);

	virtual void OnPushTextButton(GWidgetTextButton* pButton)
	{
		if(m_pParent)
			m_pParent->OnPushTextButton(pButton);
	}

	virtual void OnReleaseTextButton(GWidgetTextButton* pButton)
	{
		if(m_pParent)
			m_pParent->OnReleaseTextButton(pButton);
	}

	virtual void OnReleaseImageButton(GWidgetImageButton* pButton)
	{
		if(m_pParent)
			m_pParent->OnReleaseImageButton(pButton);
	}

	virtual void OnPushVCRButton(GWidgetVCRButton* pButton)
	{
		if(m_pParent)
			m_pParent->OnPushVCRButton(pButton);
	}

	virtual void OnHorizScroll(GWidgetHorizScrollBar* pScrollBar)
	{
		if(m_pParent)
			m_pParent->OnHorizScroll(pScrollBar);
	}

	virtual void OnVertScroll(GWidgetVertScrollBar* pScrollBar)
	{
		if(m_pParent)
			m_pParent->OnVertScroll(pScrollBar);
	}

	virtual void OnClickTextLabel(GWidgetTextLabel* pLabel)
	{
		if(m_pParent)
			m_pParent->OnClickTextLabel(pLabel);
	}

	virtual void OnSelectFilename(GWidgetFileSystemBrowser* pBrowser, const char* szFilename)
	{
		if(m_pParent)
			m_pParent->OnSelectFilename(pBrowser, szFilename);
	}

	virtual void OnChangeListSelection(GWidgetListBox* pListBox)
	{
		if(m_pParent)
			m_pParent->OnChangeListSelection(pListBox);
	}

	virtual void OnTextBoxTextChanged(GWidgetTextBox* pTextBox)
	{
		if(m_pParent)
			m_pParent->OnTextBoxTextChanged(pTextBox);
	}

	virtual void OnTextBoxPressEnter(GWidgetTextBox* pTextBox)
	{
		if(m_pParent)
			m_pParent->OnTextBoxPressEnter(pTextBox);
	}

	virtual void OnChar(char c)
	{
		if(m_pParent)
			m_pParent->OnChar(c);
	}

	virtual void OnClickTab(GWidgetSliderTab* pTab)
	{
		if(m_pParent)
			m_pParent->OnClickTab(pTab);
	}

	virtual void OnSlideTab(GWidgetSliderTab* pTab, int dx, int dy)
	{
		if(m_pParent)
			m_pParent->OnSlideTab(pTab, dx, dy);
	}

	virtual void OnChangePolarLineGraphSelection(GWidgetPolarLineGraph* pChart)
	{
		if(m_pParent)
			m_pParent->OnChangePolarLineGraphSelection(pChart);
	}

	virtual void OnChangePolarBarGraphSelection(GWidgetPolarBarGraph* pChart)
	{
		if(m_pParent)
			m_pParent->OnChangePolarBarGraphSelection(pChart);
	}

	virtual void OnVertSliderMove(GWidgetVertSlider* pSlider)
	{
		if(m_pParent)
			m_pParent->OnVertSliderMove(pSlider);
	}

	virtual void OnCanvasMouseDown(GWidgetCanvas* pCanvas, int button, int x, int y)
	{
		if(m_pParent)
			m_pParent->OnCanvasMouseDown(pCanvas, button, x, y);
	}

	virtual void OnCanvasMouseUp(GWidgetCanvas* pCanvas, int button, int x, int y)
	{
		if(m_pParent)
			m_pParent->OnCanvasMouseUp(pCanvas, button, x, y);
	}

	virtual void OnCanvasMouseMove(GWidgetCanvas* pCanvas, int x, int y, bool bPressed)
	{
		if(m_pParent)
			m_pParent->OnCanvasMouseMove(pCanvas, x, y, bPressed);
	}

	virtual void OnSelectTextTab(GWidgetTextTab* pTab)
	{
		if(m_pParent)
			m_pParent->OnSelectTextTab(pTab);
	}

protected:
	void AddWidget(GWidget* pWidget);
	//void UpdateChildOntoMyCanvas(GWidget* pChild, GColor cBackground);
	bool GetDirtyBit(int nBit);
	void SetDirtyBit(int nBit, bool bValue);
	void SetClean();
};







// A form or dialog
class GWidgetDialog : public GWidgetGroup
{
protected:
	GImage m_image;
	GWidgetAtomic* m_pGrabbedWidget;
	GWidgetAtomic* m_pFocusWidget;
	GColor m_cBackground;
	int m_prevMouseX;
	int m_prevMouseY;

public:
	GWidgetDialog(int w, int h, GColor cBackground);
	virtual ~GWidgetDialog();

	virtual WidgetType GetType() { return Dialog; }
	virtual GWidgetStyle* GetStyle() { return m_pStyle; }
	GWidgetAtomic* GetGrabbedWidget() { return m_pGrabbedWidget; }
	GWidgetAtomic* GetFocusWidget() { return m_pFocusWidget; }
	void GrabWidget(GWidgetAtomic* pWidget, int button, int mouseX, int mouseY);
	void SetFocusWidget(GWidgetAtomic* pWidget);
	void ReleaseWidget(int button);
	virtual void OnDestroyWidget(GWidget* pWidget);
	void HandleChar(char c);
	bool HandleMousePos(int x, int y);
	virtual void Draw(GImage* pCanvas, int x, int y);
	GImage* GetImage();
};




// A button with text on it
class GWidgetTextButton : public GWidgetAtomic
{
protected:
	GString m_text;
	bool m_pressed;

public:
	GWidgetTextButton(GWidgetGroup* pParent, int x, int y, int w, int h, GString* pText);
	GWidgetTextButton(GWidgetGroup* pParent, int x, int y, int w, int h, const char* szText);
	virtual ~GWidgetTextButton();

	virtual WidgetType GetType() { return TextButton; }
	virtual void Draw(GImage* pCanvas, int x, int y);
	void SetText(GString* pText);
	void SetText(const char* szText);
	bool IsPressed() { return m_pressed; }

protected:
	virtual void Grab(int button, int x, int y);
	virtual void Release(int button);
};





// Represents a tab (ie for tabbed menus, etc.)
class GWidgetTextTab : public GWidgetAtomic
{
protected:
	GString m_text;
	GColor m_cBackground;
	bool m_selected;

public:
	GWidgetTextTab(GWidgetGroup* pParent, int x, int y, int w, int h, const char* szText, GColor cBackground = 0xff6600aa);
	virtual ~GWidgetTextTab();

	virtual WidgetType GetType() { return TextTab; }
	virtual void Draw(GImage* pCanvas, int x, int y);
	void SetText(GString* pText);
	void SetText(const char* szText);
	bool IsSelected() { return m_selected; }
	void SetSelected(bool selected);

protected:
	virtual void Grab(int button, int x, int y);
	virtual void Release(int button);
};





// A button with an image on it. The left half of the image is the
// unpressed image and the right half is the pressed image.
class GWidgetImageButton : public GWidgetAtomic
{
protected:
	GImage m_image;
	bool m_pressed;

public:
	GWidgetImageButton(GWidgetGroup* pParent, int x, int y, GImage* pImage);
	virtual ~GWidgetImageButton();

	virtual WidgetType GetType() { return TextButton; }
	virtual void Draw(GImage* pCanvas, int x, int y);
	bool IsPressed() { return m_pressed; }

protected:
	virtual void Grab(int button, int x, int y);
	virtual void Release(int button);
};





// An image with multiple frames
class GWidgetAnimation : public GWidgetAtomic
{
protected:
	GImage m_image;
	int m_nFrames;
	int m_nFrame;

public:
	GWidgetAnimation(GWidgetGroup* pParent, int x, int y, GImage* pImage, int nFrames);
	virtual ~GWidgetAnimation();

	virtual WidgetType GetType() { return Animation; }
	virtual void Draw(GImage* pCanvas, int x, int y);
	void SetFrame(int nFrame);
};





// A text label
class GWidgetTextLabel : public GWidgetAtomic
{
protected:
	GString m_text;
	bool m_alignLeft;
	GColor m_cBackground;
	GColor m_cForeground;

public:
	GWidgetTextLabel(GWidgetGroup* pParent, int x, int y, int w, int h, GString* pText, GColor c = 0xffffffff, GColor background = 0x00000000);
	GWidgetTextLabel(GWidgetGroup* pParent, int x, int y, int w, int h, const char* szText, GColor c = 0xffffffff, GColor background = 0x00000000);
	virtual ~GWidgetTextLabel();

	virtual WidgetType GetType() { return TextLabel; }
	virtual void Draw(GImage* pCanvas, int x, int y);
	GString* GetText() { return &m_text; }
	void SetText(GString* pText);
	void SetText(const char* szText);

	// Sets the text color
	void SetForegroundColor(GColor c);

	// The default background color is transparent. If you want an opaque
	// or semi-opaque background then you should call this method.
	void SetBackgroundColor(GColor c);

	// Specifies whether the text is left-justified (true) or right-justified (false)
	void SetAlignLeft(bool bAlignLeft);

protected:
	virtual void Grab(int button, int x, int y);
	virtual void Release(int button);
};




// A button with a common icon on it
class GWidgetVCRButton : public GWidgetAtomic
{
public:
	enum VCR_Type
	{
		ArrowLeft,
		ArrowRight, // Play
		ArrowUp,
		ArrowDown,
		Square,  // Stop
	};

protected:
	VCR_Type m_eType;
	bool m_pressed;

public:
	GWidgetVCRButton(GWidgetGroup* pParent, int x, int y, int w, int h, VCR_Type eType);
	virtual ~GWidgetVCRButton();

	virtual WidgetType GetType() { return VCRButton; }
	virtual void Draw(GImage* pCanvas, int x, int y);
	void SetType(VCR_Type eType);
	bool IsPressed() { return m_pressed; }

protected:
	virtual void Grab(int button, int x, int y);
	virtual void Release(int button);
	void DrawIcon(GImage* pCanvas, int nHorizOfs, int nVertOfs);
};






class GWidgetProgressBar : public GWidgetAtomic
{
protected:
	float m_fProgress;

public:
	GWidgetProgressBar(GWidgetGroup* pParent, int x, int y, int w, int h);
	virtual ~GWidgetProgressBar();

	virtual WidgetType GetType() { return ProgressBar; }
	virtual void Draw(GImage* pCanvas, int x, int y);
	void SetProgress(float fProgress);