修复了所有回调函数不检测空引用就执行的bug；修复了EFont某些情况下崩溃的bug；修复了EButton没有获取启用和禁用状态的函数的bug；修复了EButton不显示禁用状态的bug；更新了EButton的监听方法；增加了EButtonToggle开关按钮类。

ConsoleDemo/main.cpp

@@ -4,21 +4,31 @@ int main()
 {
 	EApp app;
 
-	if (app.init(L"Easy2D Demo", 640, 640))
+	if (app.init(L"Easy2D Demo", 640, 480))
 	{
 		app.showConsole();
 		auto scene = new EScene();
 
-		auto sprite = new ESprite(L"haha.png");
+		// 创建一个文本
-		// 获取窗口宽度
+		auto btnNormal = new EText(L"开");
-		float width = EApp::getWidth();
+		auto btnSelected = new EText(L"开");
-		// 获取窗口高度
+		btnSelected->movePosY(2);
-		float height = EApp::getHeight();
+		auto btnNormal2 = new EText(L"关");
-		// 移动精灵的位置
+		auto btnSelected2 = new EText(L"关");
-		sprite->setPos(width / 2 + sprite->getWidth(), height / 2);
+		btnSelected2->movePosY(2);
-		scene->add(sprite);
+		// 创建一个按钮
+		auto button = new EButtonToggle(btnNormal, btnNormal2, btnSelected, btnSelected2);
+		button->setCallback([=]() {
+			//button->setEnable(false);
+		});
+		button->toggle();
+		button->setPos(EApp::getWidth() / 2, EApp::getHeight() / 2);
+		scene->add(button);
 
-		scene->getRoot()->runAction(new EActionLoop(new EActionRotateBy(1, 60)));
+		// 创建按钮
+		auto button2 = new EButton(new EText(L"关闭"), [=]() { button->setEnable(!button->isEnable()); });
+		button2->setPos(40, 40);
+		scene->add(button2);
 
 		app.enterScene(scene);
 

Easy2D/Common/EFont.cpp

@@ -12,6 +12,7 @@ e2d::EFont::EFont()
 }
 
 e2d::EFont::EFont(EString fontFamily, float fontSize /* = 22 */, UINT32 color /* = EColor::WHITE */, UINT32 fontWeight, bool italic /* = false */)
+	: EFont()
 {
 	this->setFamily(fontFamily);
 	this->setSize(fontSize);

Easy2D/Easy2D.vcxproj

@@ -235,6 +235,7 @@
     <ClCompile Include="Manager\EPhysicsManager.cpp" />
     <ClCompile Include="Manager\ETimerManager.cpp" />
     <ClCompile Include="Node\EButton.cpp" />
+    <ClCompile Include="Node\EButtonToggle.cpp" />
     <ClCompile Include="Node\ENode.cpp" />
     <ClCompile Include="Node\ESprite.cpp" />
     <ClCompile Include="Node\ESpriteFrame.cpp" />

Easy2D/Easy2D.vcxproj.filters

@@ -210,6 +210,9 @@
     <ClCompile Include="Listener\EListenerPhysicsCollision.cpp">
       <Filter>Listener</Filter>
     </ClCompile>
+    <ClCompile Include="Node\EButtonToggle.cpp">
+      <Filter>Node</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Win\winbase.h">

Easy2D/Listener/EListenerKeyboard.cpp

@@ -3,29 +3,34 @@
 
 e2d::EListenerKeyboard::EListenerKeyboard()
 	: EListener()
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerKeyboard::EListenerKeyboard(const EString & name)
 	: EListener(name)
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerKeyboard::EListenerKeyboard(const KEY_LISTENER_CALLBACK & callback)
 	: EListener()
+	, m_Callback(callback)
 {
-	m_Callback = callback;
 }
 
 e2d::EListenerKeyboard::EListenerKeyboard(const EString & name, const KEY_LISTENER_CALLBACK & callback)
 	: EListener(name)
+	, m_Callback(callback)
 {
-	m_Callback = callback;
 }
 
 void e2d::EListenerKeyboard::_callOn()
 {
-	m_Callback();
+	if (m_Callback)
+	{
+		m_Callback();
+	}
 }
 
 void e2d::EListenerKeyboard::setCallback(const KEY_LISTENER_CALLBACK & callback)

Easy2D/Listener/EListenerKeyboardPress.cpp

@@ -24,6 +24,9 @@ void e2d::EListenerKeyboardPress::_callOn()
 {
 	if (EKeyboardMsg::getMsg() == EKeyboardMsg::KEYBOARD_MSG::KEY_DOWN)
 	{
-		m_Callback();
+		if (m_Callback)
+		{
+			m_Callback();
+		}
 	}
 }

Easy2D/Listener/EListenerMouse.cpp

@@ -3,29 +3,34 @@
 
 e2d::EListenerMouse::EListenerMouse()
 	: EListener()
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerMouse::EListenerMouse(const EString & name)
 	: EListener(name)
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerMouse::EListenerMouse(const MOUSE_LISTENER_CALLBACK & callback)
 	: EListener()
+	, m_Callback(callback)
 {
-	m_Callback = callback;
 }
 
 e2d::EListenerMouse::EListenerMouse(const EString & name, const MOUSE_LISTENER_CALLBACK & callback)
 	: EListener(name)
+	, m_Callback(callback)
 {
-	m_Callback = callback;
 }
 
 void e2d::EListenerMouse::_callOn()
 {
-	m_Callback();
+	if (m_Callback)
+	{
+		m_Callback();
+	}
 }
 
 void e2d::EListenerMouse::setCallback(const MOUSE_LISTENER_CALLBACK & callback)

Easy2D/Listener/EListenerMouseClick.cpp

@@ -3,12 +3,14 @@
 e2d::EListenerMouseClick::EListenerMouseClick()
 	: EListenerMouse()
 	, m_bPressed(false)
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerMouseClick::EListenerMouseClick(const EString & name)
 	: EListenerMouse(name)
 	, m_bPressed(false)
+	, m_Callback(nullptr)
 {
 }
 
@@ -35,7 +37,10 @@ void e2d::EListenerMouseClick::_callOn()
 	}
 	else if (m_bPressed && EMouseMsg::getMsg() == EMouseMsg::LBUTTON_UP)
 	{
-		m_Callback(EMouseMsg::getPos());
+		if (m_Callback)
+		{
+			m_Callback(EMouseMsg::getPos());
+		}
 		m_bPressed = false;
 	}
 }

Easy2D/Listener/EListenerMouseDoubleClick.cpp

@@ -3,12 +3,14 @@
 e2d::EListenerMouseDoubleClick::EListenerMouseDoubleClick()
 	: EListenerMouse()
 	, m_bPressed(false)
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerMouseDoubleClick::EListenerMouseDoubleClick(const EString & name)
 	: EListenerMouse(name)
 	, m_bPressed(false)
+	, m_Callback(nullptr)
 {
 }
 
@@ -38,7 +40,10 @@ void e2d::EListenerMouseDoubleClick::_callOn()
 	}
 	else if (m_bPressed && EMouseMsg::getMsg() == EMouseMsg::LBUTTON_UP)
 	{
-		m_Callback(EMouseMsg::getPos());
+		if (m_Callback)
+		{
+			m_Callback(EMouseMsg::getPos());
+		}
 		m_bPressed = false;
 	}
 }

Easy2D/Listener/EListenerMouseDrag.cpp

@@ -2,11 +2,13 @@
 
 e2d::EListenerMouseDrag::EListenerMouseDrag()
 	: EListenerMouse()
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerMouseDrag::EListenerMouseDrag(const EString & name)
 	: EListenerMouse(name)
+	, m_Callback(nullptr)
 {
 }
 
@@ -31,7 +33,10 @@ void e2d::EListenerMouseDrag::_callOn()
 	}
 	else if (EMouseMsg::isLButtonDown() && EMouseMsg::getMsg() == EMouseMsg::MOVE)
 	{
-		m_Callback(m_Begin, EMouseMsg::getPos());
+		if (m_Callback)
+		{
+			m_Callback(m_Begin, EMouseMsg::getPos());
+		}
 	}
 }
 

Easy2D/Listener/EListenerMousePress.cpp

@@ -2,11 +2,13 @@
 
 e2d::EListenerMousePress::EListenerMousePress()
 	: EListenerMouse()
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerMousePress::EListenerMousePress(const EString & name)
 	: EListenerMouse(name)
+	, m_Callback(nullptr)
 {
 }
 
@@ -27,7 +29,10 @@ void e2d::EListenerMousePress::_callOn()
 	if (EMouseMsg::getMsg() == EMouseMsg::LBUTTON_DOWN ||
 		EMouseMsg::getMsg() == EMouseMsg::LBUTTON_DBLCLK)
 	{
-		m_Callback(EMouseMsg::getPos());
+		if (m_Callback)
+		{
+			m_Callback(EMouseMsg::getPos());
+		}
 	}
 }
 

Easy2D/Listener/EListenerPhysics.cpp

@@ -4,33 +4,34 @@
 
 e2d::EListenerPhysics::EListenerPhysics()
 	: EListener()
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerPhysics::EListenerPhysics(const EString & name)
 	: EListener(name)
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerPhysics::EListenerPhysics(const PHYSICS_LISTENER_CALLBACK & callback)
 	: EListener()
+	, m_Callback(callback)
 {
-	m_Callback = callback;
 }
 
 e2d::EListenerPhysics::EListenerPhysics(const EString & name, const PHYSICS_LISTENER_CALLBACK & callback)
 	: EListener(name)
+	, m_Callback(callback)
 {
-	m_Callback = callback;
 }
 
 void e2d::EListenerPhysics::_callOn()
 {
-	m_Callback(
+	if (m_Callback)
-		EPhysicsMsg::getActiveGeometry()->getParentNode(),
+	{
-		EPhysicsMsg::getPassiveGeometry()->getParentNode(),
+		m_Callback();
-		EPhysicsMsg::getMsg()
+	}
-	);
 }
 
 void e2d::EListenerPhysics::setCallback(const PHYSICS_LISTENER_CALLBACK & callback)

Easy2D/Listener/EListenerPhysicsCollision.cpp

@@ -3,24 +3,26 @@
 
 e2d::EListenerPhysicsCollision::EListenerPhysicsCollision()
 	: EListenerPhysics()
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerPhysicsCollision::EListenerPhysicsCollision(const EString & name)
 	: EListenerPhysics(name)
+	, m_Callback(nullptr)
 {
 }
 
 e2d::EListenerPhysicsCollision::EListenerPhysicsCollision(const COLLISION_LISTENER_CALLBACK & callback)
 	: EListenerPhysics()
+	, m_Callback(callback)
 {
-	this->m_Callback = callback;
 }
 
 e2d::EListenerPhysicsCollision::EListenerPhysicsCollision(const EString & name, const COLLISION_LISTENER_CALLBACK & callback)
 	: EListenerPhysics(name)
+	, m_Callback(callback)
 {
-	this->m_Callback = callback;
 }
 
 void e2d::EListenerPhysicsCollision::_callOn()
@@ -29,9 +31,9 @@ void e2d::EListenerPhysicsCollision::_callOn()
 		EPhysicsMsg::getMsg() == EPhysicsMsg::CONTAINS || 
 		EPhysicsMsg::getMsg() == EPhysicsMsg::IS_CONTAINED)
 	{
-		m_Callback(
+		if (m_Callback)
-			EPhysicsMsg::getActiveGeometry()->getParentNode(),
+		{
-			EPhysicsMsg::getPassiveGeometry()->getParentNode()
+			m_Callback();
-		);
+		}
 	}
 }

Easy2D/Node/EButton.cpp

@@ -4,15 +4,15 @@
 #include "..\Win\winbase.h"
 
 e2d::EButton::EButton()
-	: m_Callback([] {})
+	: m_Callback((const BUTTON_CLICK_CALLBACK &)nullptr)
 	, m_eStatus(STATUS::NORMAL)
-	, m_bIsDisable(false)
+	, m_bEnable(true)
 	, m_bIsSelected(false)
 	, m_pNormal(nullptr)
 	, m_pMouseover(nullptr)
 	, m_pSelected(nullptr)
 	, m_pDisabled(nullptr)
-	, m_pDisplayed(nullptr)
+	, m_pListener(nullptr)
 {
 }
 
@@ -50,174 +50,206 @@ e2d::EButton::EButton(ENode * normal, ENode * mouseover, ENode * selected, ENode
 	this->setCallback(callback);
 }
 
+bool e2d::EButton::isEnable() const
+{
+	return m_bEnable;
+}
+
 void e2d::EButton::setNormal(ENode * normal)
 {
-	if (normal)
+	if (normal != m_pNormal)
 	{
+		// 移除旧的
 		if (m_pNormal)
 		{
 			this->removeChild(m_pNormal);
 		}
+		// 添加新的
+		if (normal)
+		{
+			this->addChild(normal);
+		}
 		m_pNormal = normal;
-		this->addChild(m_pNormal);
+		_updateVisiable();
 	}
 }
 
 void e2d::EButton::setMouseOver(ENode * mouseover)
 {
-	if (mouseover)
+	if (mouseover != m_pNormal)
 	{
+		// 移除旧的
 		if (m_pMouseover)
 		{
 			this->removeChild(m_pMouseover);
 		}
+		// 添加新的
+		if (mouseover)
+		{
+			this->addChild(mouseover);
+		}
 		m_pMouseover = mouseover;
-		this->addChild(m_pMouseover);
+		_updateVisiable();
 	}
 }
 
 void e2d::EButton::setSelected(ENode * selected)
 {
-	if (selected)
+	if (selected != m_pNormal)
 	{
+		// 移除旧的
 		if (m_pSelected)
 		{
 			this->removeChild(m_pSelected);
 		}
+		// 添加新的
+		if (selected)
+		{
+			this->addChild(selected);
+		}
 		m_pSelected = selected;
-		this->addChild(m_pSelected);
+		_updateVisiable();
 	}
 }
 
 void e2d::EButton::setDisabled(ENode * disabled)
 {
-	if (disabled)
+	if (disabled != m_pNormal)
 	{
+		// 移除旧的
 		if (m_pDisabled)
 		{
 			this->removeChild(m_pDisabled);
 		}
+		// 添加新的
+		if (disabled)
+		{
+			this->addChild(disabled);
+		}
 		m_pDisabled = disabled;
-		this->addChild(m_pDisabled);
+		_updateVisiable();
 	}
 }
 
-void e2d::EButton::setDisable(bool disable)
+void e2d::EButton::setEnable(bool bEnable)
 {
-	m_bIsDisable = disable;
+	if (m_bEnable != bEnable)
+	{
+		m_bEnable = bEnable;
+		_updateStatus();
+	}
 }
 
 void e2d::EButton::setCallback(const BUTTON_CLICK_CALLBACK & callback)
 {
+	WARN_IF(m_pNormal == nullptr, "EButton cannot work without something to show. Please set its normal displayed.");
+	
 	m_Callback = callback;
 
-	// 停止其他监听器
+	if (m_pListener == nullptr)
-	EMsgManager::stopAllMouseListenersBindedWith(this);
+	{
-	// 新建一个监听器
+		m_pListener = new EListenerMouse(std::bind(&EButton::_updateStatus, this));
-	auto listener = new EListenerMouse(std::bind(&EButton::_listenerCallback, this));
+		m_pListener->setAlwaysWorking(true);
-	listener->setAlwaysWorking(true);
+		EMsgManager::bindListener(m_pListener, this);
-	EMsgManager::bindListener(listener, this);
+	}
 }
 
-void e2d::EButton::_callOn()
+void e2d::EButton::_setStatus(STATUS status)
 {
-	if (!m_bVisiable)
+	if (m_eStatus != status)
 	{
-		return;
+		m_eStatus = status;
+		_updateVisiable();
 	}
+}
 
-	if (m_bTransformChildrenNeeded)
+void e2d::EButton::_updateVisiable()
+{
+	if (m_pNormal) m_pNormal->setVisiable(false);
+	if (m_pMouseover) m_pMouseover->setVisiable(false);
+	if (m_pSelected) m_pSelected->setVisiable(false);
+	if (m_pDisabled) m_pDisabled->setVisiable(false);
+
+	if (m_bEnable)
 	{
-		_updateTransform(this);
+		if (m_eStatus == STATUS::SELECTED && m_pSelected)
-	}
-
-	if (!m_vChildren.empty())
-	{
-		GetRenderTarget()->SetTransform(m_Matri);
-
-		if (m_eStatus == STATUS::DISABLED && m_pDisabled)
 		{
-			m_pDisabled->_callOn();
+			m_pSelected->setVisiable(true);
-		}
-		else if (m_eStatus == STATUS::SELECTED && m_pSelected)
-		{
-			m_pSelected->_callOn();
 		}
 		else if (m_eStatus == STATUS::MOUSEOVER && m_pMouseover)
 		{
-			m_pMouseover->_callOn();
+			m_pMouseover->setVisiable(true);
 		}
-		else if (m_pNormal)
+		else
 		{
-			m_pNormal->_callOn();
+			if (m_pNormal) m_pNormal->setVisiable(true);
+		}
+	}
+	else
+	{
+		if (m_pDisabled)
+		{
+			m_pDisabled->setVisiable(true);
+		}
+		else
+		{
+			if (m_pNormal) m_pNormal->setVisiable(true);
 		}
 	}
 }
 
-void e2d::EButton::_listenerCallback()
+void e2d::EButton::_updateStatus()
 {
-	if (!m_bIsDisable)
+	if (m_bEnable && m_pNormal)
 	{
-		if (!m_pDisplayed)
+		ENode * pMouseover = m_pMouseover ? m_pMouseover : m_pNormal;
-		{
+		ENode * pSelected = m_pSelected ? m_pSelected : m_pNormal;
-			m_pDisplayed = m_pNormal;
-		}
 
-		if (EMouseMsg::getMsg() == EMouseMsg::LBUTTON_DOWN &&
+		if (EMouseMsg::getMsg() == EMouseMsg::LBUTTON_UP)
-			m_pDisplayed &&
-			m_pDisplayed->isPointIn(EMouseMsg::getPos()))
-		{
-			// 鼠标左键按下，且位于按钮内时，标记 m_bIsSelected 为 true
-			m_bIsSelected = true;
-		}
-		else if (EMouseMsg::getMsg() == EMouseMsg::LBUTTON_UP)
 		{
 			// 鼠标左键抬起时，判断鼠标坐标是否在按钮内部
 			if (m_bIsSelected &&
-				m_pDisplayed &&
+				pSelected->isPointIn(EMouseMsg::getPos()))
-				m_pDisplayed->isPointIn(EMouseMsg::getPos()))
 			{
-				m_Callback();
+				_runCallback();
-				m_eStatus = STATUS::NORMAL;
-				m_pDisplayed = m_pNormal;
 			}
 			// 标记 m_bIsSelected 为 false
 			m_bIsSelected = false;
 		}
 
-		if (EMouseMsg::isLButtonDown() &&
+		if (EMouseMsg::getMsg() == EMouseMsg::LBUTTON_DOWN)
-			m_bIsSelected && 
-			m_pSelected && 
-			m_pSelected->isPointIn(EMouseMsg::getPos()))
 		{
-			// 鼠标左键按下，且按钮是被选中的状态，且鼠标
+			if (pMouseover->isPointIn(EMouseMsg::getPos()))
-			// 在按钮内时，按钮状态变为 SELECTED
+			{
-			m_eStatus = STATUS::SELECTED;
+				// 鼠标左键按下，且位于按钮内时，标记 m_bIsSelected 为 true
-			m_pDisplayed = m_pSelected;
+				m_bIsSelected = true;
+				_setStatus(STATUS::SELECTED);
+				return;
+			}
 		}
-		else if (EMouseMsg::getMsg() == EMouseMsg::MOVE &&
+
-			m_pDisplayed &&
+		if (m_bIsSelected && EMouseMsg::isLButtonDown())
-			m_pDisplayed->isPointIn(EMouseMsg::getPos()) &&
-			m_pMouseover)
 		{
-			m_eStatus = STATUS::MOUSEOVER;
+			if (pSelected->isPointIn(EMouseMsg::getPos()))
-			m_pDisplayed = m_pMouseover;
+			{
+				_setStatus(STATUS::SELECTED);
+				return;
+			}
 		}
-		else
+		else if (m_pNormal->isPointIn(EMouseMsg::getPos()))
 		{
-			m_eStatus = STATUS::NORMAL;
+			_setStatus(STATUS::MOUSEOVER);
-			m_pDisplayed = m_pNormal;
+			return;
-		}
-	}
-	else
-	{
-		if (m_pDisplayed)
-		{
-			m_eStatus = STATUS::DISABLED;
-		}
-		else
-		{
-			m_eStatus = STATUS::NORMAL;
 		}
+
+		_setStatus(STATUS::NORMAL);
+	}
+}
+
+void e2d::EButton::_runCallback()
+{
+	if (m_Callback)
+	{
+		m_Callback();
 	}
 }

Easy2D/Node/EButtonToggle.cpp

@@ -0,0 +1,290 @@
+#include "..\enodes.h"
+#include "..\elisteners.h"
+#include "..\emanagers.h"
+#include "..\Win\winbase.h"
+
+e2d::EButtonToggle::EButtonToggle()
+	: EButton()
+	, m_bToggle(true)
+	, m_pNormalOn(nullptr)
+	, m_pMouseoverOn(nullptr)
+	, m_pSelectedOn(nullptr)
+	, m_pDisabledOn(nullptr)
+	, m_pNormalOff(nullptr)
+	, m_pMouseoverOff(nullptr)
+	, m_pSelectedOff(nullptr)
+	, m_pDisabledOff(nullptr)
+{
+}
+
+e2d::EButtonToggle::EButtonToggle(ENode * toggleOnNormal, ENode * toggleOffNormal, const BUTTON_CLICK_CALLBACK & callback)
+	: EButtonToggle()
+{
+	this->setNormal(toggleOnNormal);
+	this->setNormalOff(toggleOffNormal);
+	this->setCallback(callback);
+}
+
+e2d::EButtonToggle::EButtonToggle(ENode * toggleOnNormal, ENode * toggleOffNormal, ENode * toggleOnSelected, ENode * toggleOffSelected, const BUTTON_CLICK_CALLBACK & callback)
+	: EButtonToggle()
+{
+	this->setNormal(toggleOnNormal);
+	this->setNormalOff(toggleOffNormal);
+	this->setSelected(toggleOnSelected);
+	this->setSelectedOff(toggleOffSelected);
+	this->setCallback(callback);
+}
+
+e2d::EButtonToggle::EButtonToggle(ENode * toggleOnNormal, ENode * toggleOffNormal, ENode * toggleOnMouseOver, ENode * toggleOffMouseOver, ENode * toggleOnSelected, ENode * toggleOffSelected, const BUTTON_CLICK_CALLBACK & callback)
+	: EButtonToggle()
+{
+	this->setNormal(toggleOnNormal);
+	this->setNormalOff(toggleOffNormal);
+	this->setMouseOver(toggleOnMouseOver);
+	this->setMouseOverOff(toggleOffMouseOver);
+	this->setSelected(toggleOnSelected);
+	this->setSelectedOff(toggleOffSelected);
+	this->setCallback(callback);
+}
+
+e2d::EButtonToggle::EButtonToggle(ENode * toggleOnNormal, ENode * toggleOffNormal, ENode * toggleOnMouseOver, ENode * toggleOffMouseOver, ENode * toggleOnSelected, ENode * toggleOffSelected, ENode * toggleOnDisabled, ENode * toggleOffDisabled, const BUTTON_CLICK_CALLBACK & callback)
+	: EButtonToggle()
+{
+	this->setNormal(toggleOnNormal);
+	this->setNormalOff(toggleOffNormal);
+	this->setMouseOver(toggleOnMouseOver);
+	this->setMouseOverOff(toggleOffMouseOver);
+	this->setSelected(toggleOnSelected);
+	this->setSelectedOff(toggleOffSelected);
+	this->setDisabled(toggleOnDisabled);
+	this->setDisabledOff(toggleOffDisabled);
+	this->setCallback(callback);
+}
+
+void e2d::EButtonToggle::toggle()
+{
+	m_bToggle = !m_bToggle;
+	_updateToggle();
+	_updateVisiable();
+}
+
+bool e2d::EButtonToggle::isToggleOn() const
+{
+	return m_bToggle;
+}
+
+void e2d::EButtonToggle::setToggle(bool toggle)
+{
+	if (m_bToggle != toggle)
+	{
+		m_bToggle = toggle;
+		_updateToggle();
+	}
+}
+
+void e2d::EButtonToggle::setNormal(ENode * normal)
+{
+	if (normal != m_pNormalOn)
+	{
+		// 移除旧的
+		if (m_pNormalOn)
+		{
+			this->removeChild(m_pNormalOn);
+		}
+		// 添加新的
+		if (normal)
+		{
+			this->addChild(normal);
+		}
+		m_pNormalOn = normal;
+
+		_updateToggle();
+		_updateVisiable();
+	}
+}
+
+void e2d::EButtonToggle::setMouseOver(ENode * mouseover)
+{
+	if (mouseover != m_pMouseoverOn)
+	{
+		// 移除旧的
+		if (m_pMouseoverOn)
+		{
+			this->removeChild(m_pMouseoverOn);
+		}
+		// 添加新的
+		if (mouseover)
+		{
+			this->addChild(mouseover);
+		}
+		m_pMouseoverOn = mouseover;
+
+		_updateToggle();
+		_updateVisiable();
+	}
+}
+
+void e2d::EButtonToggle::setSelected(ENode * selected)
+{
+	if (selected != m_pSelectedOn)
+	{
+		// 移除旧的
+		if (m_pSelectedOn)
+		{
+			this->removeChild(m_pSelectedOn);
+		}
+		// 添加新的
+		if (selected)
+		{
+			this->addChild(selected);
+		}
+		m_pSelectedOn = selected;
+
+		_updateToggle();
+		_updateVisiable();
+	}
+}
+
+void e2d::EButtonToggle::setDisabled(ENode * disabled)
+{
+	if (disabled != m_pDisabledOn)
+	{
+		// 移除旧的
+		if (m_pDisabledOn)
+		{
+			this->removeChild(m_pDisabledOn);
+		}
+		// 添加新的
+		if (disabled)
+		{
+			this->addChild(disabled);
+		}
+		m_pDisabledOn = disabled;
+
+		_updateToggle();
+		_updateVisiable();
+	}
+}
+
+void e2d::EButtonToggle::setNormalOff(ENode * normal)
+{
+	if (normal != m_pNormalOff)
+	{
+		// 移除旧的
+		if (m_pNormalOff)
+		{
+			this->removeChild(m_pNormalOff);
+		}
+		// 添加新的
+		if (normal)
+		{
+			this->addChild(normal);
+		}
+		m_pNormalOff = normal;
+
+		_updateToggle();
+		_updateVisiable();
+	}
+}
+
+void e2d::EButtonToggle::setMouseOverOff(ENode * mouseover)
+{
+	if (mouseover != m_pMouseoverOff)
+	{
+		// 移除旧的
+		if (m_pMouseoverOff)
+		{
+			this->removeChild(m_pMouseoverOff);
+		}
+		// 添加新的
+		if (mouseover)
+		{
+			this->addChild(mouseover);
+		}
+		m_pMouseoverOff = mouseover;
+
+		_updateToggle();
+		_updateVisiable();
+	}
+}
+
+void e2d::EButtonToggle::setSelectedOff(ENode * selected)
+{
+	if (selected != m_pSelectedOff)
+	{
+		// 移除旧的
+		if (m_pSelectedOff)
+		{
+			this->removeChild(m_pSelectedOff);
+		}
+		// 添加新的
+		if (selected)
+		{
+			this->addChild(selected);
+		}
+		m_pSelectedOff = selected;
+
+		_updateToggle();
+		_updateVisiable();
+	}
+}
+
+void e2d::EButtonToggle::setDisabledOff(ENode * disabled)
+{
+	if (disabled != m_pDisabledOff)
+	{
+		// 移除旧的
+		if (m_pDisabledOff)
+		{
+			this->removeChild(m_pDisabledOff);
+		}
+		// 添加新的
+		if (disabled)
+		{
+			this->addChild(disabled);
+		}
+		m_pDisabledOff = disabled;
+
+		_updateToggle();
+		_updateVisiable();
+	}
+}
+
+void e2d::EButtonToggle::_updateToggle()
+{
+	if (m_bToggle)
+	{
+		m_pNormal = m_pNormalOn;
+		m_pMouseover = m_pMouseoverOn;
+		m_pSelected = m_pSelectedOn;
+		m_pDisabled = m_pDisabledOn;
+
+		if (m_pNormalOff) m_pNormalOff->setVisiable(false);
+		if (m_pMouseoverOff) m_pMouseoverOff->setVisiable(false);
+		if (m_pSelectedOff) m_pSelectedOff->setVisiable(false);
+		if (m_pDisabledOff) m_pDisabledOff->setVisiable(false);
+	}
+	else
+	{
+		m_pNormal = m_pNormalOff;
+		m_pMouseover = m_pMouseoverOff;
+		m_pSelected = m_pSelectedOff;
+		m_pDisabled = m_pDisabledOff;
+
+		if (m_pNormalOn) m_pNormalOn->setVisiable(false);
+		if (m_pMouseoverOn) m_pMouseoverOn->setVisiable(false);
+		if (m_pSelectedOn) m_pSelectedOn->setVisiable(false);
+		if (m_pDisabledOn) m_pDisabledOn->setVisiable(false);
+	}
+}
+
+void e2d::EButtonToggle::_runCallback()
+{
+	m_bToggle = !m_bToggle;
+	_updateToggle();
+
+	if (m_Callback)
+	{
+		m_Callback();
+	}
+}

Easy2D/Tool/ETimer.cpp

@@ -6,7 +6,7 @@ e2d::ETimer::ETimer()
 	: m_bRunning(false)
 	, m_nRunTimes(0)
 	, m_pParentNode(nullptr)
-	, m_Callback([](int) {})
+	, m_Callback(nullptr)
 	, m_nInterval(0)
 	, m_nRepeatTimes(0)
 	, m_bAtOnce(false)
@@ -96,7 +96,10 @@ void e2d::ETimer::_callOn()
 		return;
 	}
 
-	m_Callback(m_nRunTimes);
+	if (m_Callback)
+	{
+		m_Callback(m_nRunTimes);
+	}
 	m_nRunTimes++;
 }
 

Easy2D/enodes.h

@@ -8,6 +8,7 @@ class EText;
 class ESprite;
 class EAction;
 class EButton;
+class EButtonToggle;
 class EGeometry;
 
 class ENode :
@@ -15,6 +16,7 @@ class ENode :
 {
 	friend EScene;
 	friend EButton;
+	friend EButtonToggle;
 	friend EGeometry;
 
 public:
@@ -661,82 +663,210 @@ public:
 
 	// 创建按钮
 	EButton(
-		ENode * normal,
+		ENode * normal,		/* 普通状态 */
-		const BUTTON_CLICK_CALLBACK & callback
+		const BUTTON_CLICK_CALLBACK & callback = nullptr
 	);
 
 	// 创建按钮
 	EButton(
-		ENode * normal,
+		ENode * normal,		/* 普通状态 */
-		ENode * selected,
+		ENode * selected,	/* 鼠标按下状态 */
-		const BUTTON_CLICK_CALLBACK & callback
+		const BUTTON_CLICK_CALLBACK & callback = nullptr
 	);
 
 	// 创建按钮
 	EButton(
-		ENode * normal,
+		ENode * normal,		/* 普通状态 */
-		ENode * mouseover,
+		ENode * mouseover,	/* 鼠标移入状态 */
-		ENode * selected,
+		ENode * selected,	/* 鼠标按下状态 */
-		const BUTTON_CLICK_CALLBACK & callback
+		const BUTTON_CLICK_CALLBACK & callback = nullptr
 	);
 
 	// 创建按钮
 	EButton(
-		ENode * normal,
+		ENode * normal,		/* 普通状态 */
-		ENode * mouseover,
+		ENode * mouseover,	/* 鼠标移入状态 */
-		ENode * selected,
+		ENode * selected,	/* 鼠标移入状态 */
-		ENode * disabled,
+		ENode * disabled,	/* 按钮禁用状态 */
-		const BUTTON_CLICK_CALLBACK & callback
+		const BUTTON_CLICK_CALLBACK & callback = nullptr
+	);
+
+	// 获取按钮状态是启用还是禁用
+	bool isEnable() const;
+
+	// 设置按钮启用或禁用
+	void setEnable(
+		bool bEnable
 	);
 
 	// 设置一般情况下显示的按钮
-	void setNormal(
+	virtual void setNormal(
 		ENode * normal
 	);
 
 	// 设置鼠标移入按钮时显示的按钮
-	void setMouseOver(
+	virtual void setMouseOver(
 		ENode * mouseover
 	);
 
 	// 设置鼠标选中按钮时显示的按钮
-	void setSelected(
+	virtual void setSelected(
 		ENode * selected
 	);
 
 	// 设置按钮被禁用时显示的按钮
-	void setDisabled(
+	virtual void setDisabled(
 		ENode * disabled
 	);
 
-	// 设置按钮禁用
-	void setDisable(
-		bool disable
-	);
-
 	// 设置回调函数
 	void setCallback(
 		const BUTTON_CLICK_CALLBACK & callback
 	);
 
 protected:
-	// 渲染按钮
+	enum STATUS { NORMAL, MOUSEOVER, SELECTED };
-	virtual void _callOn() override;
 
-	// 鼠标消息监听
+	// 设置按钮状态
-	void _listenerCallback();
+	virtual void _setStatus(STATUS status);
+
+	// 刷新按钮显示
+	virtual void _updateVisiable();
+
+	// 刷新按钮状态
+	virtual void _updateStatus();
+
+	// 执行按钮回调函数
+	virtual void _runCallback();
 
 protected:
-	enum STATUS { NORMAL, MOUSEOVER, SELECTED, DISABLED };
 	STATUS	m_eStatus;
 	ENode * m_pNormal;
 	ENode * m_pMouseover;
 	ENode * m_pSelected;
 	ENode * m_pDisabled;
-	ENode * m_pDisplayed;
+	bool	m_bEnable;
-	bool	m_bIsDisable;
 	bool	m_bIsSelected;
+	EListenerMouse * m_pListener;
 	BUTTON_CLICK_CALLBACK m_Callback;
 };
 
+
+class EButtonToggle :
+	public EButton
+{
+public:
+	// 创建一个空的开关按钮
+	EButtonToggle();
+
+	// 创建开关按钮
+	EButtonToggle(
+		ENode * toggleOnNormal,
+		ENode * toggleOffNormal,
+		const BUTTON_CLICK_CALLBACK & callback = nullptr
+	);
+
+	// 创建开关按钮
+	EButtonToggle(
+		ENode * toggleOnNormal,
+		ENode * toggleOffNormal,
+		ENode * toggleOnSelected,
+		ENode * toggleOffSelected,
+		const BUTTON_CLICK_CALLBACK & callback = nullptr
+	);
+
+	// 创建开关按钮
+	EButtonToggle(
+		ENode * toggleOnNormal,
+		ENode * toggleOffNormal,
+		ENode * toggleOnMouseOver,
+		ENode * toggleOffMouseOver,
+		ENode * toggleOnSelected,
+		ENode * toggleOffSelected,
+		const BUTTON_CLICK_CALLBACK & callback = nullptr
+	);
+
+	// 创建开关按钮
+	EButtonToggle(
+		ENode * toggleOnNormal,
+		ENode * toggleOffNormal,
+		ENode * toggleOnMouseOver,
+		ENode * toggleOffMouseOver,
+		ENode * toggleOnSelected,
+		ENode * toggleOffSelected,
+		ENode * toggleOnDisabled,
+		ENode * toggleOffDisabled,
+		const BUTTON_CLICK_CALLBACK & callback = nullptr
+	);
+
+	// 切换开关状态
+	void toggle();
+
+	// 获取开关状态
+	bool isToggleOn() const;
+
+	// 打开或关闭开关
+	void setToggle(
+		bool toggle
+	);
+
+	// 设置按钮打开状态下显示的按钮
+	virtual void setNormal(
+		ENode * normal
+	) override;
+
+	// 设置按钮打开状态下，鼠标移入按钮时显示的按钮
+	virtual void setMouseOver(
+		ENode * mouseover
+	) override;
+
+	// 设置按钮打开状态下，鼠标选中按钮时显示的按钮
+	virtual void setSelected(
+		ENode * selected
+	) override;
+
+	// 设置按钮打开状态下，被禁用时显示的按钮
+	virtual void setDisabled(
+		ENode * disabled
+	) override;
+
+	// 设置按钮关闭状态下显示的按钮
+	void setNormalOff(
+		ENode * normal
+	);
+
+	// 设置按钮关闭状态下，鼠标移入按钮时显示的按钮
+	void setMouseOverOff(
+		ENode * mouseover
+	);
+
+	// 设置按钮关闭状态下，鼠标选中按钮时显示的按钮
+	void setSelectedOff(
+		ENode * selected
+	);
+
+	// 设置按钮关闭状态下，按钮被禁用时显示的按钮
+	void setDisabledOff(
+		ENode * disabled
+	);
+
+protected:
+	// 刷新按钮开关
+	virtual void _updateToggle();
+
+	// 执行按钮回调函数
+	virtual void _runCallback() override;
+
+protected:
+	ENode * m_pNormalOn;
+	ENode * m_pNormalOff;
+	ENode * m_pMouseoverOn;
+	ENode * m_pMouseoverOff;
+	ENode * m_pSelectedOn;
+	ENode * m_pSelectedOff;
+	ENode * m_pDisabledOn;
+	ENode * m_pDisabledOff;
+	bool	m_bToggle;
+};
+
 }

Easy2D/etypedef.h

@@ -132,18 +132,18 @@ typedef std::function<void()> MOUSE_LISTENER_CALLBACK;
 typedef std::function<void(EPoint mousePos)> MOUSE_CLICK_LISTENER_CALLBACK;
 
 // 鼠标按下消息监听回调函数（参数为按下位置）
-typedef MOUSE_CLICK_LISTENER_CALLBACK MOUSE_PRESS_LISTENER_CALLBACK;
+typedef MOUSE_CLICK_LISTENER_CALLBACK  MOUSE_PRESS_LISTENER_CALLBACK;
 
 // 鼠标双击消息监听回调函数（参数为双击位置）
-typedef MOUSE_CLICK_LISTENER_CALLBACK MOUSE_DBLCLK_LISTENER_CALLBACK;
+typedef MOUSE_CLICK_LISTENER_CALLBACK  MOUSE_DBLCLK_LISTENER_CALLBACK;
 
 // 鼠标拖动消息监听回调函数（参数为拖动前位置和拖动后位置）
 typedef std::function<void(EPoint begin, EPoint end)> MOUSE_DRAG_LISTENER_CALLBACK;
 
-// 物理世界消息监听器回调函数（参数：主动方、被动方、两方关系）
+// 物理世界消息监听器回调函数
-typedef std::function<void(ENode *active, ENode *passive, int relation)> PHYSICS_LISTENER_CALLBACK;
+typedef std::function<void()> PHYSICS_LISTENER_CALLBACK;
 
-// 碰撞消息监听器回调函数（参数：主动方、被动方）
+// 碰撞消息监听器回调函数
-typedef std::function<void(ENode *active, ENode *passive)> COLLISION_LISTENER_CALLBACK;
+typedef PHYSICS_LISTENER_CALLBACK  COLLISION_LISTENER_CALLBACK;
 
 }