cocos2dx3.6 实现带光标的输入框（二);光标可移动

最新推荐文章于 2023-02-02 14:08:52 发布
最新推荐文章于 2023-02-02 14:08:52 发布
阅读量3.4k 收藏 3
点赞数 1
分类专栏： Cocos2dx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adroitly/article/details/46739989
版权

现在光标终于可移动了，然后其实主要是逻辑问题，也没什么技术含量，所以总是一大堆位置判断！再者自己能力比较水，所以代码比较挫，这里代码只有更新那部分，具体的回车什么的自己去弄就好了，其实跟这个思想差不多吧！个人觉得。

代码：

CursorTextField.h

#ifndef _CursorTextField_H_
#define _CursorTextField_H_

#include "cocos2d.h"

USING_NS_CC;

class CursorTextField : public TextFieldTTF, public TextFieldDelegate
{
private:


	// 点击开始位置
	Point m_beginPos;
	// 光标精灵
	Sprite * m_pCursorSprite;
	// 光标动画
	Action *m_pCursorAction;
	// 光标坐标
	Point m_cursorPos;
	//输入框长度
	float inputFrameWidth;
	//允许输入的最大字符数Unicode
	float inputMaxLength;
	int m_Sprite_Posi = 0;
	// 输入框总内容
	std::string m_pInputText;
	std::string inpuText; //当前输入框内容
	int fontsize = 0;
	std::string fontName;
	int nowtextlenght = 0;
	void setTextPosi(std::string , bool is_add = true);
public:
	CursorTextField();
	~CursorTextField();
	static CursorTextField * getinstance();
	// static
	static CursorTextField * textFieldWithPlaceHolder(cocos2d::Node * node , const char *placeholder, const char *fontName, float fontSize);
	// Layer
	void onEnter();
	void onExit();
	bool init();
	// 初始化光标精灵
	void initCursorSprite(int nHeight);
	virtual void setPositionX(Node *node , float x);

	// TextFieldDelegate
	virtual bool onTextFieldAttachWithIME(TextFieldTTF *pSender) override;
	virtual bool onTextFieldDetachWithIME(TextFieldTTF * pSender) override;
	virtual bool onTextFieldInsertText(cocos2d::TextFieldTTF*  sender, const char * text, size_t nLen) override;
	virtual bool onTextFieldDeleteBackward(cocos2d::TextFieldTTF*  sender, const char * delText, size_t nLen) override;



	virtual void setPosition(const Point& pos);
	virtual void setPosition(float &x, float &y);

	void setCursorPositionX(float x); // 设置光标x位置
	// 把光标添加到和输入框一起的层中
	void AddCursor(Node *node);
	// Layer Touch
	bool onTouchBegan(Touch *pTouch, Event *pEvent);
	void onTouchEnded(Touch *pTouch, Event *pEvent);
	void onKeyPressed(cocos2d::EventKeyboard::KeyCode, cocos2d::Event*);
	void onKeyReleased(cocos2d::EventKeyboard::KeyCode, cocos2d::Event*);

	// 判断是否点击在TextField处
	bool isInTextField(Touch *pTouch);
	// 得到TextField矩形
	Rect getRect();

	// 打开输入法
	void openIME();
	// 关闭输入法
	void closeIME();

	std::string split_text(std::string name, int len , int start);

	const char* getInputText();
	void setInpuntText(char* text);
	void setInputWidth(float width);
	void setInputMaxLength(float length);


	cocos2d::Node * parentNode;


	void BlickSpriteLeft();

	void BlickSpriteRight();
	void KeyDelete();
	float getLabelWidth(std::string str , std::string fontName, float fontsize);
	int getPosifromText(std::string str, int posi);
	int getPosiformPosi(std::string str, float posi);

	void MyRemoveFromParent();
protected:
	EventListenerTouchOneByOne * listener;
};

#endif

CursorTextField.cpp 

#include "CursorTextField.h"

#include "MyCharSet.h"
#include "MyKeyInsert.h"

const static float DELTA = 0.5f;

using namespace cocos2d;
using namespace std;
static CursorTextField * _CursorTextField;
CursorTextField::CursorTextField()
{
	TextFieldTTF();

	m_pCursorSprite = NULL;
	m_Sprite_Posi = 0;
}

CursorTextField::~CursorTextField()
{
}

CursorTextField * CursorTextField::getinstance()
{
	return _CursorTextField;
}

void CursorTextField::onEnter()
{
	TextFieldTTF::onEnter();
	listener = EventListenerTouchOneByOne::create();
	listener->setSwallowTouches(true);
	listener->onTouchBegan = CC_CALLBACK_2(CursorTextField::onTouchBegan, this);
	listener->onTouchEnded = CC_CALLBACK_2(CursorTextField::onTouchEnded, this);
	Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, this);
	KeyInsert::getinstence()->addKeyBordClick(this);
	this->setDelegate(this);
}

CursorTextField * CursorTextField::textFieldWithPlaceHolder(Node * node , const char *placeholder, const char *fontName, float fontSize)
{
	_CursorTextField = new (std::nothrow)CursorTextField();
	_CursorTextField->parentNode = node;
	if (_CursorTextField && ((TextFieldTTF*)_CursorTextField)->initWithPlaceHolder(placeholder, fontName, fontSize))
	{
		_CursorTextField->fontsize = fontSize;
		_CursorTextField->fontName = fontName;
		_CursorTextField->autorelease();
		if (placeholder)
		{
			_CursorTextField->setPlaceHolder(placeholder);
		}
		_CursorTextField->init();
		_CursorTextField->initCursorSprite(fontSize);
		_CursorTextField->setHorizontalAlignment(kCCTextAlignmentLeft);
		return _CursorTextField;
	}
	CC_SAFE_DELETE(_CursorTextField);
	return NULL;
}

bool CursorTextField::init(){
	this->inputFrameWidth = 400;
	this->inputMaxLength = 16;
	inpuText = "";
	return true;
}
void CursorTextField::initCursorSprite(const int mHeight)
{
	int column = 2;
	int nHeight = 20;
	int pixels[50][2];
	for (int i = 0; i < nHeight; ++i)
	{
		for (int j = 0; j < column; ++j)
		{
			pixels[i][j] = 0xffffffff;
		}
	}
	Texture2D* texture = new Texture2D();
	texture->initWithData(pixels, 20, Texture2D::PixelFormat::RGB888, 4, mHeight, CCSizeMake(column, nHeight));
	m_pCursorSprite = Sprite::createWithTexture(texture);
	texture->autorelease();
	if (m_pCursorSprite == nullptr)
	{
		CCLOG("NULL");
	}
	//m_pCursorSprite->setColor(Color3B(255, 0, 0));
	Size winSize = getContentSize();
	m_pCursorSprite->setVisible(false);
	parentNode->addChild(m_pCursorSprite);
	m_pCursorAction = RepeatForever::create(Sequence::create(FadeOut::create(0.25f), FadeIn::create(0.25f), NULL));
	m_pCursorSprite->runAction(m_pCursorAction);
	//m_pInputText = new std::string();
}

void CursorTextField::setPositionX(Node * node, float x)
{
	int i = 0;
	int count = 0;
	float width = 0.0;
	std::string str;
	if (m_Sprite_Posi <= 0)
	{
		width = 0.0;
		m_Sprite_Posi = 0;
	}
	else
	{
		std::string ss;
		for (i = 0; i < inpuText.size();)
		{
			ss = split_text(inpuText, 1, i);
			i += ss.length();
			str.append(ss);
			count++;
			if (count == m_Sprite_Posi)
			{
				break;
			}
		}
		width = getLabelWidth(str, _CursorTextField->fontName, _CursorTextField->fontsize);
	}
	width += x;
	node->setPositionX(width);
}

void CursorTextField::setPosition(float &x, float &y)
{
	Point posi(x, y);
	setPosition(posi);
}

void CursorTextField::setPosition(const Point& pos)
{
	TextFieldTTF::setPosition(pos);
	// 设置光标位置
	if (NULL != m_pCursorSprite)
	{
		Size winSize = getContentSize();
		m_cursorPos = ccp(0, 0/*winSize.height / 2*/);
		m_cursorPos = m_cursorPos + pos;
		m_pCursorSprite->setPosition(m_cursorPos.x + m_pCursorSprite->getContentSize().width , m_cursorPos.y + m_pCursorSprite->getContentSize().height / 2.0);
	}
}


void CursorTextField::setCursorPositionX(float x) // 设置光标x位置
{
	Point pt = getPosition(); // 获取输入框位置
	x += pt.x;
	setPositionX(m_pCursorSprite , x);
}
// 把光标添加到和输入框一起的层中
void CursorTextField::AddCursor(Node *node)
{
	if (NULL != node && NULL != m_pCursorSprite)
	{
		node->addChild(m_pCursorSprite);
		m_pCursorSprite->setPositionY(getContentSize().height / 2.0);
		m_pCursorSprite->runAction(m_pCursorAction);
	}
}

bool CursorTextField::onTouchBegan(cocos2d::Touch *pTouch, cocos2d::Event *pEvent)
{
	m_beginPos = pTouch->getLocation();
	return true;
}

Rect CursorTextField::getRect()
{
	Size check;
	check.width = fontsize;
	Size size = getContentSize() + check;
	return  CCRectMake(0, -size.height / 2, inputFrameWidth, size.height);
}

//获取输入框内容
const char* CursorTextField::getInputText(){
	const char* text = m_pInputText.c_str();
	return text;
}

//设置输入框内容
void CursorTextField::setInpuntText(char* text){
	m_pInputText = "";
	setString(text);
	setPositionX(m_pCursorSprite, this->getPosition().x);
	inpuText = "";
}

//设置输入框宽度 一旦字符串宽度超度这个长度 字符串会自动向左缩进
void CursorTextField::setInputWidth(float width){
	this->inputFrameWidth = width;
}

//设置输入宽显示的最大字符数量Unicode
void CursorTextField::setInputMaxLength(float length){
	this->inputMaxLength = length;
}

//判断点击事件，是否响应在输入框范围内
bool CursorTextField::isInTextField(cocos2d::Touch *pTouch)
{
	return getRect().containsPoint(convertTouchToNodeSpaceAR(pTouch));
}

void CursorTextField::onTouchEnded(cocos2d::Touch *pTouch, cocos2d::Event *pEvent)
{
	Point endPos = pTouch->getLocation();
	// 判断是否为点击事件
	if (::abs(endPos.x - m_beginPos.x) > DELTA ||
		::abs(endPos.y - m_beginPos.y))
	{
		// 不是点击事件
		m_beginPos.x = m_beginPos.y = -1;
		return;
	}
	// 判断是打开输入法还是关闭输入法
	isInTextField(pTouch) ? openIME() : closeIME();
	if (m_pCursorSprite->isVisible())
	{
		//开始所在字节
		int len = getPosiformPosi(inpuText, m_pCursorSprite->getPositionX());
		//结束所在的字节
		int endlen = getPosiformPosi(inpuText, endPos.x);
		m_pCursorSprite->setPositionX(this->getPositionX() + getLabelWidth(inpuText.substr(0, endlen), fontName, fontsize));

		int i = 0;
		int count = 0;
		//点了前面,mposi减去字符
		if (len > endlen)
		{
			count = 0;
			for (i = endlen; i < len;)
			{
				std::string temp = split_text(inpuText, 1, i);
				count++;
				i += temp.length();
			}
			m_Sprite_Posi -= count;
		}
		//原来位置
		else if (len == endlen)
		{
		}
		//点了后面,mposi加上字符
		else
		{
			count = 0;
			for (i = len; i < endlen;)
			{
				std::string temp = split_text(inpuText, 1, i);
				count++;
				i += temp.length();
			}
			m_Sprite_Posi += count;
		}
	}
}


//弹出手机键盘时响应事件
bool CursorTextField::onTextFieldAttachWithIME(cocos2d::TextFieldTTF *pSender)
{
	if (m_pInputText.empty()) {
		return false;
	}
	//setPositionX(m_pCursorSprite , this->getPosition().x);
	return false;
}

//当有输入进来时响应
//@param pSender 发送事件对象
//@param text 输入内容
//@param  内容字节长度


bool CursorTextField::onTextFieldInsertText(cocos2d::TextFieldTTF* sender, const char * text, size_t nLen)
{
	//log("OUT   ====   %s =Length= %d", text , nLen);
	int j = 0 ;
	std::string mytext = text;
	for (j = 0; j < mytext.size();)
	{
		std::string sText = m_pInputText.c_str();
		wchar_t* wText = new wchar_t[200];
		char t[200];
		memset(t, 0, sizeof(t));
		strcpy(t, sText.c_str());
		int unisize = 0;
		int codenum = MyCharSet::getinstence()->utf8_to_unicode((uint8_t*)t, (uint16_t **)wText, &unisize);
		//当字符数量超过规定值 不做处理
		if (codenum >= inputMaxLength && inputMaxLength != 0)
		{
			codenum = inputMaxLength;
			CC_SAFE_DELETE_ARRAY(wText);
			return true;
		}
		nowtextlenght++;
		std::string ss = split_text(mytext, 1, j);
		j += ss.length();
		//屏蔽回车输入
		if (ss == "\n")
		{
			CC_SAFE_DELETE_ARRAY(wText);
			continue;
		}
		std::string mmss = "";
		std::string mystr;
		int i = 0;
		//根据字符位置插入
		if (m_Sprite_Posi != 0)
		{
			
			int count = 0;
			for (i = 0; i < m_pInputText.size();)
			{
				mmss = split_text(m_pInputText, 1, i);
				i += mmss.length();
				mystr.append(mmss);
				count++;
				if (count == m_Sprite_Posi)
				{
					break;
				}
			}
		}
		//字符位置相加
		m_Sprite_Posi++;
		mystr.append(ss);
		mystr.append(m_pInputText.substr(i));
		//输入框总内容就是两个相加
		m_pInputText.clear();
		//inpuText.clear();
		m_pInputText.append(mystr);
		//inpuText.append(mystr);
		//输入框当前字符串添加
		//inpuText.append(ss);
		setTextPosi(ss, true);
		CC_SAFE_DELETE_ARRAY(wText);
		//AndroidShowtext(mychar, 1);
	}
	return true;
}


//当有输入进来时响应
//@param pSender 发送事件对象
//@param text 删除内容
//@param  内容字节长度

bool CursorTextField::onTextFieldDeleteBackward(cocos2d::TextFieldTTF* sender, const char * delText, size_t nLen)
{
	std::string ss;
	if (m_Sprite_Posi != 0)
	{
		int i = 0;
		int count = 0;
		for (i = 0; i < m_pInputText.size();)
		{
			ss = split_text(m_pInputText, 1, i);
			i += ss.length();
			count++;
			if (count == m_Sprite_Posi)
			{
				m_pInputText.erase(i - ss.length(), ss.length());
				//inpuText.erase(i - ss.length(), ss.length());
				break;
			}
		}
	}
	//字符位置减1
	m_Sprite_Posi--;
	//m_pInputText.resize(m_pInputText.size() - nLen);
	if (m_pInputText.size() <= 0)
	{
		m_Sprite_Posi = 0;
	}
	if (m_Sprite_Posi < 0)
	{
		m_Sprite_Posi = 0;
	}
	setTextPosi(ss , false);
	
	return true;
}

void CursorTextField::setTextPosi(std::string ss , bool is_add)
{
	if (inputFrameWidth <= 0)
	{
		inputFrameWidth = _CursorTextField->inputFrameWidth;
	}
	if (!is_add)
	{
		if (m_pInputText.empty())
		{
			m_Sprite_Posi = 0;
			m_pCursorSprite->setPositionX(m_pCursorSprite->getPositionX() - getLabelWidth(ss, fontName, fontsize));
			setString("");
			inpuText.clear();
			return;
		}
		std::string localText = inpuText;
		int i = getPosifromText(m_pInputText, m_Sprite_Posi);
		int inlength = getPosiformPosi(inpuText, m_pCursorSprite->getPositionX());	
		if (inlength == 0)
		{
			return;
		}
		std::string mystr;
		std::string instr;
		if (i >= inlength)
		{
			int reposi = i - inlength;
			for (i = 0; i < m_pInputText.length();)
			{
				std::string temp = split_text(m_pInputText, 1, i);
				if (i <= reposi && reposi < temp.length() + i)
				{
					break;
				}
				else
				{
					i += temp.length();
				}
			}
			mystr = m_pInputText.substr(i, 1);
			if (!mystr.empty())
			{
				if (mystr[0] < 0)
				{
					mystr = m_pInputText.substr(i, 3);
				}
				else
				{
					mystr = m_pInputText.substr(i, 1);
				}
			}
		}
		
		//当前输入框剔除
		std::string deletestr;
		if (inlength - 3 >= 0)
		{
			int reposi = inlength;
			for (i = 0; i < inpuText.length();)
			{
				std::string temp = split_text(inpuText, 1, i);
				if (i <= reposi && reposi <= temp.length() + i)
				{
					break;
				}
				else
				{
					i += temp.length();
				}
			}
			deletestr = inpuText.substr(i, 3);
			if (deletestr[0] < 0)
			{
				inpuText.erase(inlength - 3, 3);
			}
			else if (!deletestr.empty())
			{
				deletestr = inpuText.substr(inlength - 1, 1);
				inpuText.erase(inlength - 1, 1);
			}
			//log("%s   %s", inpuText.c_str(), deletestr.c_str());
		}
		else
		{
			deletestr = inpuText.substr(0, 3);
			if (deletestr[0] < 0)
			{
				inpuText.erase(inlength - 3, 3);
			}
			else if (!deletestr.empty())
			{
				deletestr = inpuText.substr(inlength - 1, 1);
				inpuText.erase(inlength - 1, 1);
			}
		}
		if (mystr.empty())
		{
			instr = m_pInputText.substr(inpuText.length() , 1);
			if (!instr.empty())
			{
				if (instr[0] < 0)
				{
					instr = m_pInputText.substr(inpuText.length(), 3);
				}
				else
				{
					//instr.erase(1, 2);
					instr = m_pInputText.substr(inpuText.length(), 1);
				}
			}
			inpuText.append(instr);
		}
		std::string lastins = mystr;
		mystr.append(inpuText);
		inpuText = mystr;
		if (lastins.empty())
		{
			m_pCursorSprite->setPositionX(m_pCursorSprite->getPositionX() - getLabelWidth(deletestr, fontName, fontsize));
		}
		else if (!instr.empty())
		{
			float reposi = getLabelWidth(deletestr, fontName, fontsize) - getLabelWidth(instr, fontName, fontsize);
			m_pCursorSprite->setPositionX(m_pCursorSprite->getPositionX() + reposi);
		}
		else if (!lastins.empty())
		{
			float reposi = getLabelWidth(lastins, fontName, fontsize) - getLabelWidth(deletestr, fontName, fontsize);
			m_pCursorSprite->setPositionX(m_pCursorSprite->getPositionX() + reposi);
		}
		setString(inpuText);
	}
	else
	{
		std::string localText = m_pInputText;
		setString(m_pInputText);
		//如果总字符串的长度大于指定宽度
		if (getLabelWidth(m_pInputText , fontName , fontsize) > inputFrameWidth){
			int inlength = getPosiformPosi(inpuText, m_pCursorSprite->getPositionX());
			//光标在0处,需要获取到当前输入框最后一个字符,
			if (inlength == 0)
			{
				std::string mystr = ss;
				mystr.append(inpuText);
				inpuText = mystr;
				std::string str = inpuText.substr(inpuText.length() - 1);
				if (str[0] < 0)
				{
					inpuText.resize(inpuText.length() - 3);
				}
				else
				{
					inpuText.resize(inpuText.length() - 1);
				}
				setString(inpuText);
				m_pCursorSprite->setPositionX(m_pCursorSprite->getPositionX() + getLabelWidth(ss, fontName, fontsize));
				return;
			}
			//光标在末尾,需要获取第一个字符
			else if (inlength == inpuText.length())
			{
				inpuText.append(ss);
				std::string str = inpuText.substr(0, 3);
				if (str[0] < 0)
				{
					inpuText.erase(0, 3);
				}
				else
				{
					str.erase(1, 2);
					inpuText.erase(0, 1);
				}
				setString(inpuText);
				float x = getLabelWidth(str, fontName, fontsize) - getLabelWidth(ss, fontName, fontsize);
				m_pCursorSprite->setPositionX(m_pCursorSprite->getPositionX() - x);
				return;
			}
			//在字符两段切割
			std::string last = inpuText.substr(0 , inlength);
			std::string next = inpuText.substr(inlength);
			//字符相连
			inpuText = last;
			inpuText.append(ss);
			inpuText.append(next);
			std::string temp = inpuText.substr(0, 3);
			if (temp[0] < 0 )
			{
				inpuText.erase(0, 3);
			}
			else
			{
				inpuText.erase(0, 1);
				temp = inpuText.substr(0, 1);
			}
			float reposi = getLabelWidth(ss, fontName, fontsize) - getLabelWidth(temp, fontName, fontsize);
			m_pCursorSprite->setPositionX(m_pCursorSprite->getPositionX() + reposi);
			setString(inpuText);

		}
		else{
			//小于，直接设置显示总字符串
			int startCur = 0;
			setString(m_pInputText);
			inpuText = m_pInputText;
			std::string showinput;
			for (int j = 0; j < m_pInputText.size();)
			{
				std::string nowstr = split_text(m_pInputText , 1 ,j);
				showinput.append(nowstr);
				j += nowstr.length();
				startCur++;
				if (startCur == m_Sprite_Posi)
				{
					break;
				}
			}
			startCur = 0;
			m_pCursorSprite->setPositionX(this->getPosition().x + getLabelWidth(showinput, fontName, fontsize));
		}
		//设置光标位置
		//setPositionX(m_pCursorSprite, this->getPosition().x);
	}
}

bool CursorTextField::onTextFieldDetachWithIME(cocos2d::TextFieldTTF *pSender)
{
	return false;
}

void CursorTextField::openIME()
{
	m_pCursorSprite->setVisible(true);
#if ( CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
	setString(m_pInputText);
#endif
	((TextFieldTTF *)this)->attachWithIME();
}

void CursorTextField::closeIME()
{
	m_pCursorSprite->setVisible(false);
	//auto pTextField = (TextFieldTTF *)pRet;
	((TextFieldTTF *)this)->detachWithIME();
}

void CursorTextField::onExit()
{
	TextFieldTTF::onExit();
	Director::getInstance()->getEventDispatcher()->removeEventListener(listener);
	KeyInsert::getinstence()->destoryinstence();
}
//根据位置分割字符，并返回字符
std::string CursorTextField::split_text(std::string name, int len , int start)
{
	int i = start;
	std::string str;
	if (name[i] < 0)
	{
		i++;
	}
	if (start == i)
	{
		str = name.substr(start, 1);
	}
	else
	{
		str = name.substr(start, 3);
	}
	//log("mysubstr   %s", str.c_str());
	return str;
}
//向左移
void CursorTextField::BlickSpriteLeft()
{
	if (!_CursorTextField->m_pCursorSprite->isVisible())
	{
		return;
	}
	float posix = _CursorTextField->m_pCursorSprite->getPosition().x;
	float contextsizeposi = _CursorTextField->m_pCursorSprite->getContentSize().width / 2;
	float parentposi = _CursorTextField->getPosition().x;
	std::string str;
	//光标已在输入框最左边
	if (posix - parentposi <= contextsizeposi)
	{
		if (_CursorTextField->m_pInputText == _CursorTextField->inpuText || _CursorTextField->m_Sprite_Posi == 0)
		{
			return;
		}
		int mlength = _CursorTextField->getPosifromText(_CursorTextField->m_pInputText, _CursorTextField->m_Sprite_Posi);
		//光标在所有字符的最左边
		if (mlength <= 0)
		{
			return;
		}
		//选取光标前一个字符
		str = _CursorTextField->m_pInputText.substr(mlength - 1, 1);
		if (str[0] < 0)
		{
			str = _CursorTextField->m_pInputText.substr(mlength - 3, 3);
		}
		std::string mystr = _CursorTextField->inpuText.substr(_CursorTextField->inpuText.length() - 1, 1);
		//剔除最后一个字符
		if (mystr[0] < 0)
		{
			_CursorTextField->inpuText.resize(_CursorTextField->inpuText.length() - 3);
		}
		else
		{
			_CursorTextField->inpuText.resize(_CursorTextField->inpuText.length() - 1);
		}
		//字符相加
		str.append(_CursorTextField->inpuText);
		_CursorTextField->inpuText = str;
		_CursorTextField->setString(_CursorTextField->inpuText);
	}
	else
	{
		//只是移动
		int nlength = _CursorTextField->getPosiformPosi(_CursorTextField->inpuText, _CursorTextField->m_pCursorSprite->getPositionX());
		str = _CursorTextField->inpuText.substr(nlength - 1, 1);
		if (str[0] < 0)
		{
			str = _CursorTextField->inpuText.substr(nlength - 3, 3);
		}
		float nowposi = _CursorTextField->getLabelWidth(str, _CursorTextField->fontName, _CursorTextField->fontsize);
		_CursorTextField->m_pCursorSprite->setPositionX(_CursorTextField->m_pCursorSprite->getPositionX() - nowposi);

	}
	//光标所在所有字符中减一
	_CursorTextField->m_Sprite_Posi--;
	if (_CursorTextField->m_Sprite_Posi < 0)
	{
		_CursorTextField->m_Sprite_Posi = 0;
	}
	
}
//向右与左类似
void CursorTextField::BlickSpriteRight()
{
	if (!_CursorTextField->m_pCursorSprite->isVisible())
	{
		return;
	}
	float posix = _CursorTextField->m_pCursorSprite->getPosition().x;
	float contextsizeposi = _CursorTextField->m_pCursorSprite->getContentSize().width / 2;
	float parentposi = _CursorTextField->getPosition().x + _CursorTextField->getLabelWidth(_CursorTextField->inpuText , _CursorTextField->fontName , _CursorTextField->fontsize);
	std::string str;
	if (posix + contextsizeposi >= parentposi)
	{
		if (_CursorTextField->m_pInputText == _CursorTextField->inpuText || _CursorTextField->m_Sprite_Posi >= _CursorTextField->nowtextlenght)
		{
			return;
		}
		int mlength = _CursorTextField->getPosifromText(_CursorTextField->m_pInputText, _CursorTextField->m_Sprite_Posi);
		if (mlength == _CursorTextField->m_pInputText.length())
		{
			return;
		}
		str = _CursorTextField->m_pInputText.substr(mlength, 1);
		if (str[0] < 0)
		{
			str = _CursorTextField->m_pInputText.substr(mlength, 3);
		}
		std::string mystr = _CursorTextField->inpuText.substr(0, 1);
		if (mystr[0] < 0)
		{
			mystr = _CursorTextField->inpuText.substr(0, 3);
			_CursorTextField->inpuText.erase(0, 3);
		}
		else
		{
			_CursorTextField->inpuText.erase(0, 1);
		}
		_CursorTextField->inpuText.append(str);
		//位移差
		float posix = getLabelWidth(str, _CursorTextField->fontName, _CursorTextField->fontsize) - getLabelWidth(mystr , _CursorTextField->fontName ,_CursorTextField->fontsize);
		_CursorTextField->m_pCursorSprite->setPositionX(_CursorTextField->m_pCursorSprite->getPositionX() + posix);
		_CursorTextField->setString(_CursorTextField->inpuText);
	}
	else
	{
		int nlength = _CursorTextField->getPosiformPosi(_CursorTextField->inpuText, _CursorTextField->m_pCursorSprite->getPositionX());
		str = _CursorTextField->inpuText.substr(nlength, 1);
		if (str[0] < 0)
		{
			str = _CursorTextField->inpuText.substr(nlength, 3);
		}
		float nowposi = _CursorTextField->getLabelWidth(str, _CursorTextField->fontName, _CursorTextField->fontsize);
		_CursorTextField->m_pCursorSprite->setPositionX(_CursorTextField->m_pCursorSprite->getPositionX() + nowposi);

	}
	_CursorTextField->m_Sprite_Posi++;


}

void CursorTextField::KeyDelete()
{
	if (!_CursorTextField->m_pCursorSprite->isVisible())
	{
		return;
	}
	int nlength = _CursorTextField->getPosiformPosi(_CursorTextField->inpuText, _CursorTextField->m_pCursorSprite->getPositionX());
	int mlength = _CursorTextField->getPosifromText(_CursorTextField->m_pInputText, _CursorTextField->m_Sprite_Posi);
	std::string inlast;
	std::string innext;
	std::string insMNext;
	std::string insMLast;
	if (mlength == _CursorTextField->m_pInputText.length())
	{
		return;
	}
	std::string in_str = _CursorTextField->inpuText.substr(nlength, 3);
	std::string im_str = _CursorTextField->m_pInputText.substr(mlength, 3);
	if (in_str[0] < 0)
	{
		_CursorTextField->inpuText.erase(nlength, 3);
	}
	else
	{
		_CursorTextField->inpuText.erase(nlength, 1);
	}
	if (im_str[0] < 0)
	{
		_CursorTextField->m_pInputText.erase(mlength, 3);
	}
	else
	{
		_CursorTextField->m_pInputText.erase(mlength, 1);
	}
	insMNext = _CursorTextField->m_pInputText.substr(mlength + _CursorTextField->inpuText.length() - nlength, 1);
	if (insMNext[0] >= 0)
	{
		insMNext = _CursorTextField->m_pInputText.substr(mlength + _CursorTextField->inpuText.length() - nlength, 1);
	}
	else
	{
		insMNext = _CursorTextField->m_pInputText.substr(mlength + _CursorTextField->inpuText.length() - nlength, 3);
	}
	if (insMNext.empty() && mlength != nlength)
	{
		if (mlength - nlength - 3 < 0)
		{
			insMLast = _CursorTextField->m_pInputText.substr(mlength - nlength - 1, 1);
		}
		else
		{
			int lenposi = mlength - nlength;
			int i;
			for (i = 0; i < _CursorTextField->m_pInputText.length();)
			{
				std::string temp = _CursorTextField->split_text(_CursorTextField->m_pInputText, 1, i);
				if (i <= lenposi && lenposi < i + temp.length())
				{
					break;
				}
				i += temp.length();
			}
			lenposi = i;
			insMLast = _CursorTextField->m_pInputText.substr(lenposi - 3, 3);
			if (insMLast[2] >= 0)
			{
				insMLast = _CursorTextField->m_pInputText.substr(lenposi - 1, 1);
			}
		}
	}
	std::string myallstr;
	myallstr.append(insMLast);
	myallstr.append(_CursorTextField->inpuText);
	myallstr.append(insMNext);
	_CursorTextField->inpuText = myallstr;
	_CursorTextField->setString(_CursorTextField->inpuText);
	if (!insMLast.empty())
	{
		_CursorTextField->m_pCursorSprite->setPositionX(_CursorTextField->m_pCursorSprite->getPositionX() + _CursorTextField->getLabelWidth(insMLast, _CursorTextField->fontName, _CursorTextField->fontsize));
	}
}
//根据string获取字符宽度
float CursorTextField::getLabelWidth(std::string str, std::string fontName, float fontsize)
{
	if (str.empty())
	{
		return 0;
	}
	LabelTTF * label = LabelTTF::create(str, fontName, fontsize);
	float nowposi = label->getContentSize().width;
	return nowposi;
}

//根据字符位置返回字节位置
int CursorTextField::getPosifromText(std::string str, int posi)
{
	int count = 0;
	int i;
	for (i = 0; i < str.length();)
	{
		std::string mystr = split_text(str, 1, i);
		i += mystr.length();
		count++;
		if (count == posi)
		{
			return i;
		}
	}
	return 0;
}
//根据坐标位置返回字节位置
int CursorTextField::getPosiformPosi(std::string str, float posi)
{
	std::string mystr;
	std::string temp;
	float parentPosi = this->getPositionX();
	float reposi = posi - parentPosi;
	if (parentPosi + getLabelWidth(str , fontName ,fontsize) <= posi)
	{
		return str.length();
	}
	if (reposi <= 0)
	{
		return 0;
	}
	int i = 0;
	float last, next;
	for (i = 0; i < str.length();)
	{
		 temp = split_text(str, 1, i);
		 last = getLabelWidth(mystr, fontName, fontsize);
		 next = getLabelWidth(mystr.append(temp), fontName, fontsize);
		 if (last <= reposi && next > reposi)
		 {
			 return i;
		 }
		 else if (next == reposi)
		 {
			 return i + temp.length();
		 }
		 i += temp.length();
	}
	return 0;
}

void CursorTextField::MyRemoveFromParent()
{
	if (_CursorTextField)
	{
		m_pCursorSprite->stopAllActions();
		parentNode->removeChild(m_pCursorSprite);
		parentNode->removeChild(_CursorTextField);
		_CursorTextField = NULL;
	}
}

MyKeyInsert.h

#pragma once

//#include "cocos2d.h"
#include "CursorTextField.h"

class KeyInsert : public CursorTextField
{
public:

	KeyInsert();
	~KeyInsert();
	static KeyInsert * getinstence();
	static void destoryinstence();
	void addKeyBordClick(cocos2d::Node * node);
	cocos2d::Node * parentNode;
	cocos2d::EventListenerKeyboard * _keyBordListener;
	void onKeyPressed(cocos2d::EventKeyboard::KeyCode, cocos2d::Event*);
	void onKeyReleased(cocos2d::EventKeyboard::KeyCode,cocos2d::Event*);
private:

};




 

 

 MyKeyInsert.cpp 

 

#include "MyKeyInsert.h"

USING_NS_CC;

static KeyInsert * _KeyInsert = NULL;

KeyInsert::KeyInsert()
{
	_KeyInsert = this;
	_KeyInsert->autorelease();
}

KeyInsert::~KeyInsert()
{
}

KeyInsert * KeyInsert::getinstence()
{
	if (_KeyInsert == NULL)
	{
		_KeyInsert = new (std::nothrow)KeyInsert();
	}
	return _KeyInsert;
}

void KeyInsert::destoryinstence()
{
	Director::getInstance()->getEventDispatcher()->removeEventListener(_KeyInsert->_keyBordListener);
	CC_SAFE_RELEASE(_KeyInsert);
}

void KeyInsert::addKeyBordClick(cocos2d::Node * node)
{
	_KeyInsert->parentNode = node;
	_KeyInsert->_keyBordListener = EventListenerKeyboard::create();
	_KeyInsert->_keyBordListener->onKeyPressed = CC_CALLBACK_2(KeyInsert::onKeyPressed, this);
	_KeyInsert->_keyBordListener->onKeyReleased = CC_CALLBACK_2(KeyInsert::onKeyReleased, this);
	Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(_keyBordListener, _KeyInsert->parentNode);
}

void KeyInsert::onKeyPressed(EventKeyboard::KeyCode keycode, Event* event)
{
	switch (keycode)
	{
	case EventKeyboard::KeyCode::KEY_LEFT_ARROW:
		//log("Left");
		BlickSpriteLeft();
		break;
	case EventKeyboard::KeyCode::KEY_RIGHT_ARROW:
		//log("right");
		BlickSpriteRight();
		break;
	case EventKeyboard::KeyCode::KEY_DELETE :
		KeyDelete();
		break;
	case EventKeyboard::KeyCode::KEY_UP_ARROW:
		log("Up");
		break;
	case EventKeyboard::KeyCode::KEY_DOWN_ARROW:
		log("DOWN");
		break;
	default:
		break;
	}
}

void KeyInsert::onKeyReleased(EventKeyboard::KeyCode keycode, Event* event)
{
	//log("BBB");
}

 

 具体效果自己去测试！我偷了下懒，那就是不是限定位置而是限定字符！ 

 

 

 


                

        

        

    




    

      

        

            

              
                
                  我是-处女座
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    3
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
cocos带光标的输入框

				
			

			

				

					07-12
				

			

		

		

			
				
cocos2dx中优化的带光标的输入框支持中英文输入，添加密码模式，自动转换成*号

			
		

	



                

              
                



	

		

			

				
					
win快捷键_挥泪告别鼠标，我终究还是学会了Windows快捷键

				
			

			

				

					weixin_39575410的博客
				

				

					11-16
					
					330
					
				

			

		

		

			
				
年少时，觉得不用鼠标操作电脑很厉害，但苦于没有学习途径，连复制粘贴的快捷键都不知道，来来去去都是上下左右和回车键； 多年后，经过一系列摸爬滚打，精心总结了一套Windows实用的快捷键，今天就分享出来了。 大家觉得还不错的话，请光速点赞、收藏、评论。(纯干货，看到就是赚到 一、通用快捷键1、 Ctrl + A： 选中所有项2、 Ctrl + C / Ctrl + Insert： 复制选中项3、 C...

			
		

	



                


  
              

                


	

		

			

				
					
cocos2d-x带触摸控制与光标输入框

				
			

			

				

					w20175357的专栏
				

				

					03-28
					
					1866
					
				

			

		

		

			
				
1、为什么写这篇博文
      这是我在CSDN上面写得第一篇博客呢，至于我为什么写这一篇博客呢？或许很大一部分是因为感觉很新鲜吧，当然其他的原因也有啊，比如，这样的话自己写得东西当误删或者什么的弄丢了的话，再就可以很轻松的从CSDN上面找到。好了，简介就这样吧。
2、为什么要把cocos-2dx带触摸控制输入框写上来
      我现在在初学cocos2d-x的内容，其中很多的东西都还不

			
		

	





	

		

			

				
					
Cocos2d-x学习（四）：带光标的输入框

					
热门推荐

				
			

			

				

					oneRain88的专栏
				

				

					05-16
					
					5万+
					
				

			

		

		

			
				
cocos2d-x为我们提供了一个跨平台的输入框，CCTextFieldTTF，初看时感觉提供的功能很少，当看到tests中TextInputTest这个例子的时候，感觉它的使用还真是很复杂，其原因无非是一些设置和判断的繁琐。不过话说回来了，输入框最主要的是跨平台监听输入，而不是样式！至于我们想要做的，就是根据游戏的需要相对封装一个简单的输入框而已！
今天我就以一个简单的带光标的输入框为例子，简

			
		

	



		

			
		



	

		

			

				
					
【转载】cocoscreator里的editbox如何设置光标居中

				
			

			

				

					Kade's Code
				

				

					08-16
					
					1321
					
				

			

		

		

			
				
原文链接https://blog.csdn.net/zhang1991xin/article/details/87170377

editBox:cc.EditBox
editBox._impl._edTxt.style[“text-align”] = “center”(直接使用h5原生的写法)


			
		

	





	

		

			

				
					
cocoscreator-Editbox安卓输入上顶

				
			

			

				

					Lu1030017255的博客
				

				

					10-15
					
					885
					
				

			

		

		

			
				
Cocos2dxEditBox.java
private void registKeyboardVisible() {
            getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
                @Override
                public void onGlobalLayout() {
               

			
		

	





	

		

			

				
					
cocos creator 3D学习（二）总是浮在屏幕最前面的操作按钮及其他

				
			

			

				

					judykang123的博客
				

				

					09-03
					
					871
					
				

			

		

		

			
				
目录创建添加矩形组件添加canvas组件放入2D的图片+处理
创建
在层级管理器中的Scene里创建一个Canvas，会在属性检查器里自带一个Node组件
设置，设置Node的position为（480,320,1），Scale为（1,1,1）
添加矩形组件
给Canvas一个cc.UITransformComponent矩形组件，ContentSize尺寸为（960,640），AnchorPoint锚点为（0.5,0.5），优先级Priority为0（因为这里没有其他的canvas，所以优先级不用管）
添

			
		

	





	

		

			

				
					
【Cocos新手入门】使用 cocos creator 创建单行文本输入框及多行文本输入框

				
			

			

				

					任聪聪的博客
				

				

					02-02
					
					1403
					
				

			

		

		

			
				
本篇文章主要讲解使用 cocos creator 创建单行文本输入框及多行文本输入框，并绑定文本框获取文本输入数据的方法。作者：任聪聪日期：2023年2月2日cocos引擎版本2.4.3。

			
		

	





	

		

			

				
					
cocos2d-x 输入框 简单实现

				
			

			

				

					Reno的专栏
				

				

					09-14
					
					2546
					
				

			

		

		

			
				
我记得我新手的时候，输入框的实现感觉非常困难，也一直用别人写好的输入框，但是最近由于项目的一些要求，
要做些改进。发现之前他们写的代码太乱，很多代码都可以省略，也因此想自己写一下。
我主要实现的功能：
1）： 带光标，参考网上的人写的
2）： 密码框
3）： 输入框中是否含有中文
4）： 还有一些简单的设置最大宽度，得到输入框的值等等；


主要方法的实现：
1）
//初始化

			
		

	





	

		

			

				
					
cocos2dx lua TextField 输入框 使用指南 BY 小曲奇～

				
			

			

				

					catalpeak的博客
				

				

					08-29
					
					1012
					
				

			

		

		

			
				
cocos2dx TextField by 小曲奇～

简介

输入框承担了用户向内存中写入数据的角色
cocos2dx 集成的可调用的输入框分为两种1


1.CC命名空间下的 TextFieldTTF 类
2.CC->UI命名空间下的 UICCTextField 类


前者继承自 label类 和 IMEDelegate类（键盘监听类）
后者继承自 TextFieldTTF  类 和 TextFieldDelegate 类（只属于TextField的键盘监听类）
如果分不清这二者 可以简单的理解

			
		

	





	

		

			

				
					
cocos2dx带光标的多行输入框

				
			

			

				

					10-27
				

			

		

		

			
				
cocos2dx 自带的CCTextField控件 没有输入光标，而且只能输入单行文字，多行输入并可以让光标在输入位置闪烁一直是一个比较麻烦的事情。这里就实现了多行输入，光标准确的指示输入位置。

			
		

	





	

		

			

				
					
cocos2dx 聊天框，带换行光标

				
			

			

				

					07-11
				

			

		

		

			
				
这个小Demo是从网上找到的工程该来的。
由于支持换行，而且需要带光标，找了好久也没有现成的代码可用，也只能自己瞎改。
光标的位置计算,采用了3个CCTextfiled作为计算参考，而且在输入每个字符的时候都会创建，效率自己不会很高。
代码是改的，很垃圾。
由于改别人的代码，非自己脑力所谓，所以设置下载金币了，各位大神如果有好的建议一定要指点我哦

			
		

	





	

		

			

				
					
cocos2dx输入框带光标类

				
			

			

				

					02-17
				

			

		

		

			
				
下载后，加入工程中，实例化设置坐标和框大小就可以调用。我的博客中有使用方法！

			
		

	





	

		

			

				
					
cocos2d-x带光标的输入框

				
			

			

				

					05-16
				

			

		

		

			
				
封装cocos2d-x中的CCTextFieldTTF为带光标的输入框

			
		

	





	

		

			

				
					
cocos2dx 3.6 api

				
			

			

				

					12-07
				

			

		

		

			
				
cocos2dx 3.6 API，不要这么全好不好！

			
		

	





	

		

			

				
					
【cocos2d-x笔记】文本输入，调用虚拟键盘

				
			

			

				

					小小少年
				

				

					12-10
					
					1409
					
				

			

		

		

			
				
直接贴代码
#ifndef CursorInputDemo_CursorTextField_h
#define CursorInputDemo_CursorTextField_h

#include "cocos2d.h"

USING_NS_CC;

class CursorTextField: public CCTextFieldTTF, public CCTextFieldDelegate

			
		

	





	

		

			

				
					
cocos2d Android 平台EditBox 2.x升级到3.12 输入框使用 原生控件 可以复制 粘贴

				
			

			

				

					Phan_Chen的博客
				

				

					11-12
					
					2470
					
				

			

		

		

			
				
因项目需求，cocos2d 3.10以下版本中的 editbox 都是使用 ttf 来显示 文字的，使用 ttf 显示的话 很多原生的功能 其实都不好做。比如说 表情，复制，粘贴。(光标其实还容易 可以自己弄个 action) ，目前的很多游戏 聊天系统(其实现在很多的第三方聊天sdk) 或者 输入框系列 体验都很好的。为了追求品质 提高体验做的人性化。然后 又不能 直接
 从2.x 直接升级到

			
		

	





	

		

			

				
					
CocosCreator快捷键

				
			

			

				

					xinsong520的博客
				

				

					07-20
					
					8371
					
				

			

		

		

			
				
存盘 Ctrl+s
注释代码 Ctrl+/
取消注释 Ctrl+\(Eclipse3已经都合并到Ctrl+/了)
代码辅助 Alt+/
快速修复 Ctrl+1
代码格式化 Ctrl+Shift+f
整理导入 Ctrl+Shift+o
切换窗口 Ctrl+f6
ctrl+shift+M 导入未引用的包
ctrl+w 关闭单个窗口
F3 跳转到类、变量的声明
F11 运行上次程序

			
		

	





	

		

			

				
					
cocos2d-x中带光标的输入框（CCTextFieldTTF）（这个不完善，后期再继续研究）

				
			

			

				

					nothing的专栏
				

				

					11-09
					
					6476
					
				

			

		

		

			
				
原创作品，允许转载，转载时请务必以超链接形式标明文章原始出处 、作者信息和本声明。否则将追究法律责任。
http://blog.csdn.net/azhou_hui/article/details/8167881
 
cocos2d-x中输入框实现的效果很不好，完全没法和cocos2d比。必须自己再去封装。下面的这个还不完善，目前先做到这
 
（1）CursorTextField.h

			
		

	





	

		

			

				
					
Cocos 节点朝向指定位置节点

					
最新发布

				
			

			

				

					05-26
				

			

		

		

			
				
要让一个节点朝向指定位置节点，可以使用以下步骤：

1. 获取目标节点和当前节点的位置信息。

```cpp
auto targetPos = targetNode->getPosition();
auto currentPos = currentNode->getPosition();
```

2. 计算出目标节点与当前节点之间的向量。

```cpp
auto direction = targetPos - currentPos;
```

3. 计算出向量的方向角度。

```cpp
auto angleRadians = atan2(direction.y, direction.x);
auto angleDegrees = CC_RADIANS_TO_DEGREES(angleRadians);
```

4. 旋转当前节点到目标节点的方向。

```cpp
currentNode->setRotation(-angleDegrees);
```

其中，第四步中要注意将角度取负数，因为 Cocos 中节点的旋转方向是逆时针的，而计算出来的角度是顺时针的。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值