Exemple #1
0
void CATextField::analyzeString(const char * text, int len)
{
	std::string strLeft = m_sText.substr(0, m_iCurPos);
	std::string strRight = m_sText.substr(m_iCurPos, m_sText.size());

	for (int i = 0; i < len; i++)
	{
		TextAttribute t;
		
		int iStrLen1 = getStringLength(strLeft);
		if (text[i] >= 0 && text[i] <= 127)
		{
			t.charSize = 1;
			strLeft += text[i];
		}
		else
		{
			t.charSize = 3;
			strLeft += text[i++];
			strLeft += text[i++];
			strLeft += text[i];
		}
		int iStrLen2 = getStringLength(strLeft);

		t.charlength = iStrLen2 - iStrLen1;

		m_vTextFiledChars.insert(m_vTextFiledChars.begin() + (getStringCharCount(strLeft)-1), t);
		m_iCurPos += t.charSize;
	}
	m_sText = strLeft + strRight;
	m_curSelCharRange = std::make_pair(m_iCurPos, m_iCurPos);
}
Exemple #2
0
	void analyzeString(const char * text, int len)
	{
		std::string strLeft = m_sText.substr(0, m_iCurPos);
		std::string strRight = m_sText.substr(m_iCurPos, m_sText.size());
		std::string cszNewText(text, len);

		std::u32string cszU32Text;
		StringUtils::UTF8ToUTF32(cszNewText, cszU32Text);
		
		for (int i = 0; i < cszU32Text.size(); i++)
		{
			std::u32string c;
			c += cszU32Text[i];

			TextAttribute t;

			int iStrLen1 = getStringLength(strLeft);

			std::string str;
			StringUtils::UTF32ToUTF8(c, str);

			strLeft += str;
			t.charSize = str.size();

			int iStrLen2 = getStringLength(strLeft);

			t.charlength = iStrLen2 - iStrLen1;

			m_vTextFiledChars.insert(m_vTextFiledChars.begin() + (getStringCharCount(strLeft) - 1), t);
			m_iCurPos += t.charSize;
		}

		m_sText = strLeft + strRight;
		m_curSelCharRange = std::make_pair(m_iCurPos, m_iCurPos);
	}
Exemple #3
0
	DRect getZZCRect(bool* l=0, bool* r=0)
	{
		int l1 = getStringLength(m_sText.substr(0, m_curSelCharRange.first));
		int l2 = getStringLength(m_sText.substr(m_curSelCharRange.first, m_curSelCharRange.second - m_curSelCharRange.first));
		int ld = getDtStrLength();

		bool ll = (l1 + m_iString_o_length) >= 0;
		bool rr = (l1 + m_iString_o_length + l2 + ld) <= m_iLabelWidth;

		int dd = 0;
		if (ll && rr)
		{
			dd = l2;
		}
		else if (ll)
		{
			dd = m_iLabelWidth - (l1 + m_iString_o_length + ld);
		}
		else if (rr)
		{
			dd = l1 + m_iString_o_length + l2;
		}
		else dd = m_iLabelWidth;

		if (l != NULL)
		{
			*l = ll;
		}
		if (r != NULL)
		{
			*r = rr;
		}
		int y = (m_obContentSize.height - m_obRect.size.height) / 2;
		return DRect((ll ? (l1 + m_iString_o_length) : 0) + ld, y, dd, m_iFontHeight);
	}
	std::vector<DRect> getZZCRect()
	{
		DSize size = getFrame().size;
		std::pair<int, int> t1 = getLineAndPos(m_curSelCharRange.first);
		std::pair<int, int> t2 = getLineAndPos(m_curSelCharRange.second);

		std::string s1 = m_szText.substr(t1.second, m_curSelCharRange.first - t1.second);
		if (!s1.empty() && s1[0] == '\n') s1.erase(0, 1);
		int l1 = getStringLength(s1);

		std::string s2 = m_szText.substr(t2.second, m_curSelCharRange.second - t2.second);
		if (!s2.empty() && s2[0] == '\n') s2.erase(0, 1);
		int l2 = getStringLength(s2);

		std::vector<DRect> vr;
		if (t1.first == t2.first)
		{
			vr.push_back(DRect(l1, m_iLineHeight*1.25f*t1.first, l2 - l1, m_iLineHeight));
		}
		else
		{
			vr.push_back(DRect(l1, m_iLineHeight*1.25f*t1.first, size.width - l1, m_iLineHeight*1.25f));

			int i = t1.first + 1;
			for (; i < t2.first; i++)
			{
				vr.push_back(DRect(0, m_iLineHeight*1.25f*i, size.width, m_iLineHeight*1.25f));
			}
			vr.push_back(DRect(0, m_iLineHeight*1.25f*i, l2, m_iLineHeight));
		}
		return vr;
	}
Exemple #5
0
void ATOM_Edit::deleteString( size_t start,size_t end )
{
	// 只读情况,不允许输入
	if(EDITTYPE_READONLY & _editType)
	{
		return;
	}
	int s,t;
	s = min(start,end);
	t = max(start,end);
	ATOM_STRING str = ATOM_Wide2Ansi (_string.c_str(), _string.size());
	if(t > _string.size())
	{
		end = ATOM_STRING::npos;
	}
	str.erase(s,t-s);
	_string = ATOM_Ansi2Wide(str.c_str(), strlen(str.c_str())); 
	calcTextLayout ();
	_textDirty = false;
	if(_cursor<0)
	{
		_cursor = 0;
	}
	if(_cursor > getStringLength())
	{
		_cursor = getStringLength();
	}
	_cusorOldPosition = _cusorNewPosition;
	ATOM_EditTextChangedEvent event(getId(), _text->getString());
	_parent->handleEvent(&event);

}
Exemple #6
0
CCRect CATextField::getZZCRect(bool* l, bool* r)
{
	int l1 = getStringLength(m_sText.substr(0, m_curSelCharRange.first));
	int l2 = getStringLength(m_sText.substr(m_curSelCharRange.first, m_curSelCharRange.second-m_curSelCharRange.first));

	bool ll = (l1 + m_iString_left_offX) >= 0;
	bool rr = (l1 + m_iString_left_offX + l2) <= m_iLabelWidth;

	int dd = 0;
	if (ll && rr)
	{
		dd = l2;
	}
	else if (ll)
	{
		dd = m_iLabelWidth - (l1 + m_iString_left_offX);
	}
	else if (rr)
	{
		dd = l1 + m_iString_left_offX + l2;
	}
	else dd = m_iLabelWidth;
	
	if (l != NULL)
	{
		*l = ll;
	}
	if (r != NULL)
	{
		*r = rr;
	}

	return CCRect((ll ? (l1 + m_iString_left_offX) : 0) + m_iHoriMargins, m_iVertMargins, dd, m_iFontHeight);
}
Exemple #7
0
int getMaxStringLength(char string[][81], const int number_of_string)
{
    int max = 0;
    for (int i = 0; i < number_of_string; ++i)
        if (getStringLength(string[i]) > max)
            max = getStringLength(string[i]);
    return max;
}
void test_generate_base85_password () {
    char* password = generatePassword(12, BASE85);
    int i=0;
    for(i=0;i<getStringLength(password);i++)
        CU_ASSERT_TRUE(containsChar(base85,password[i]));
    
    CU_ASSERT_EQUAL(getStringLength(password),12);
}
Exemple #9
0
static bool MutableString_equals (const void * const _self, const void *const _other) {
	const struct String *self = _self;
	const struct String *other = _other;
	int result = ( _self == _other );
	if ( ! result && (getStringLength(self) == getStringLength(other)) && self->text && other->text)
		result = (strcmp(self->text, other->text) == 0);
	return result;
}
void test_generate_base64_password () {
    char* password = generatePassword(12, BASE64);
    int i=0;
    for(i=0;i<getStringLength(password);i++)
        CU_ASSERT_TRUE(containsChar(base64,password[i]));
    printf("len: %d", getStringLength(password));
    CU_ASSERT_EQUAL(getStringLength(password),12);
        
}
//----------------------------------------------------------------------------//
String IconvStringTranscoder::stringFromUTF16(const uint16* input) const
{
#if CEGUI_STRING_CLASS == CEGUI_STRING_CLASS_UNICODE
    IconvHelper ich("UTF-8", "UTF-16");
    return iconvTranscode<String, utf8>(
        ich, reinterpret_cast<const char*>(input),
        getStringLength(input) * sizeof(uint16));
#else
    IconvHelper ich("WCHAR_T", "UTF-16");
    return stringFromStdWString(iconvTranscode<std::wstring, wchar_t>(
        ich, reinterpret_cast<const char*>(input), getStringLength(input)));
#endif
}
Exemple #12
0
static void MutableString_appendString(void *const _self, const void *const _other) {
	struct MutableString *self = _self;
	struct String *stringSelf = _self;
	const struct MutableString *other = _other;
	const char *otherText = getStringText(other);
	
	UInteger selfLength = getStringLength(self);
	UInteger otherLength = getStringLength(other);
	
	if ( __ensureCapacity(self, selfLength + otherLength + 1) == -1 ) { errno = ENOMEM; return; };
	
	char *selfText = (char *)getStringText(self);
	strncat(selfText, otherText, otherLength);
	stringSelf->length += otherLength;
}
Exemple #13
0
int getIndex(char *c) {

	int len = getStringLength(c);
	//printf("%s %s\n", "string ", c);
	if(*(c + len - 1) =='\n') {
		len--;
	}
	int counter = 0;
	int currentIndex = len - 1;

	while(*(c + currentIndex) != ' ') {
		currentIndex--;
		counter++;
	}
	currentIndex++;
	//printf("%s %d\n", "size of countr ", counter);
	char *substring = (char *)malloc((counter + 1) * sizeof(char));

	for(int i = 0; i < counter; i++) {
		*(substring + i) =  *(c + currentIndex + i); 
	}
	*(substring + counter) = '\0';

	//printf("%s %s\n", "substring", substring);
	int resultIndex = convertStringToInt(substring);
	//printf("%d\n", resultIndex);


	free(substring);
	return resultIndex;
}
Exemple #14
0
void CATextField::adjustCursorMoveForward()
{
    this->updateImage();

    m_iString_l_length = getStringLength(m_sText.substr(0, m_iCurPos));
    m_iString_r_length = m_cImageSize.width - m_iString_l_length;

    if (m_iString_l_length + m_iString_left_offX > m_iLabelWidth)
    {
        m_iString_left_offX = m_iLabelWidth - m_iString_l_length;
    }

    CCRect r = CCRectMake(0, 0, m_cImageSize.width, m_cImageSize.height);
    r.origin.x = -m_iString_left_offX;
    r.size.width = getStringViewLength();
    this->setImageRect(r);
    if (m_nInputType == KEY_BOARD_INPUT_PASSWORD)
    {
        //float mPmarkWidth = MIN(m_obContentSize.width, getCursorX());
        m_pCursorMark->setCenterOrigin(CCPoint(this->getImageRect().size.width + m_iHoriMargins, m_obContentSize.height / 2));
    }
    else
    {
        float mPmarkWidth = MIN(m_obContentSize.width, getCursorX());
        m_pCursorMark->setCenterOrigin(CCPoint(mPmarkWidth + m_iHoriMargins, m_obContentSize.height / 2));
    }
}
Exemple #15
0
/** Returns the number of bytes necessary to store a string vector.
 *  \param vs std::vector<std::string>
 */
int STVRMessage::getStringVectorLength(const std::vector<std::string>& vs)
{
    int len=getShortLength();
    for(unsigned int i=0; i<vs.size(); i++)
        len += getStringLength(vs[i]);
    return len;
}   // getStringVectorLength
Exemple #16
0
void CATextView::calculateSelChars(const CCPoint& point, int& l, int& r, int& p)
{
	float y = point.y + m_pContainerView->getContentOffset().y;
	int iCurLine = getCurrentByPointY(y);
	int iHalfCharSize = 0;
	int iStartPos = 0;
	if (!m_vLinesTextView.empty())
	{
		p = iStartPos = m_vLinesTextView[iCurLine].iStartCharPos;
		std::vector<TextAttribute>& v = m_vLinesTextView[iCurLine].TextAttrVect;
		for (int i = 0, iStringLeftX = 0; i < v.size(); i++)
		{
			TextAttribute& t = v[i];
			if (point.x >= iStringLeftX - iHalfCharSize && point.x < iStringLeftX + t.charlength / 2)
			{
				break;
			}

			iStringLeftX += t.charlength;
			p += t.charSize;
			iHalfCharSize = t.charlength / 2;
		}
	}

	std::string s = m_szText.substr(iStartPos, p - iStartPos);
	if (!s.empty() && s[0] == '\n')
	{
		s.erase(0, 1);
	}
	l = iCurLine;
	r = getStringLength(s);
}
Exemple #17
0
int main(void)
{
    int i, j;
    char string[5][81];

#if 0
    /* No use if not get use of fgets */
    int max_length_of_string;
    puts("Please enter the max length of the string(<81):");
    scanf("%d", &max_length_of_string);
    if (max_length_of_string >= 81 || max_length_of_string <= 0) {
        puts("Error, now exit.");
        return 1;
    }
#endif

    puts("Please enter 5 strings, one line one string:");
    for (i = 0; i < 5; ++i)
        gets(string[i]);

    for (i = 0; i < 5; ++i)
        if (getStringLength(string[i]) < getMaxStringLength(string, 5))
            fillStringByBlanks(string[i], getMaxStringLength(string, 5));

    for (i = 0; i < 5; ++i) {
        for (j = 0; string[i][j]; ++j)
            putchar(string[i][j]);
        putchar('\n');
    }

    return 0;
}
Exemple #18
0
document_attachment_ptr Document::getAttachment(const char* name, bool includeBody) {    
    document_attachment_ptr attachment;
    
    auto attachmentsObj = obj_->getObject("_attachments", false);
    if (!!attachmentsObj) {        
        auto attachmentObj = attachmentsObj->getObject(name, false);
        if (!!attachmentObj) {
            auto contentType = attachmentObj->getString("content_type");
            auto digest = attachmentObj->getString("digest");

            if (includeBody) {
                auto encodedData = attachmentObj->getString("data");
                auto encodedDataSize = attachmentObj->getStringLength("data");
                auto data = Base64Helper::Decode(encodedData, encodedDataSize);
                attachment = DocumentAttachment::Create(name, contentType, digest, std::move(data));
            } else {
                int lengthIndex = -1;
                auto size = attachmentObj->getType("length", lengthIndex) == rs::scriptobject::ScriptObjectType::UInt32 ? 
                    attachmentObj->getUInt32(lengthIndex) : attachmentObj->getUInt64(lengthIndex);

                attachment = DocumentAttachment::Create(name, contentType, digest, Base64Helper::buffer_type{}, size);
            }
        }
    }
    
    return attachment;
}
Exemple #19
0
std::vector<document_attachment_ptr> Document::getAttachments() {
    std::vector<document_attachment_ptr> attachments;
    
    auto attachmentsObj = obj_->getObject("_attachments", false);
    if (!!attachmentsObj) {
        auto count = attachmentsObj->getCount();        
        attachments.reserve(count);
        
        for (decltype(count) i = 0; i < count; ++i) {
            auto type = attachmentsObj->getType(i);
            if (type == rs::scriptobject::ScriptObjectType::Object) {
                auto name = attachmentsObj->getName(i);
                auto attachmentObj = attachmentsObj->getObject(i);
                
                auto contentType = attachmentObj->getString("content_type");
                auto digest = attachmentObj->getString("digest");
                
                auto encodedData = attachmentObj->getString("data");
                auto encodedDataSize = attachmentObj->getStringLength("data");
                auto data = Base64Helper::Decode(encodedData, encodedDataSize);
                
                auto attachment = DocumentAttachment::Create(name, contentType, digest, std::move(data));
                attachments.push_back(attachment);
            }
        }
    }
    
    return attachments;
}
Exemple #20
0
void ATOM_Edit::setCursor(int cursor, bool select)
{
	ATOM_STACK_TRACE(ATOM_Edit::setCursor);

	size_t length = getStringLength();
	if(select)
	{
		if(_selectStart < 0 || _selectStart > length)
		{
			_selectStart = _cursor;
		}
	}
	else
	{
		_selectStart = -1;
	}

	if(_cursor == _startPosition && cursor < _cursor)
	{
		_startPosition = cursor;
	}
	int oldPosition = _cursor;

	_cursor = cursor;
	if(_cursor<0)
	{
		_cursor = 0;
	}
	if(_cursor > length)
	{
		_cursor = length;
	}

	_textDirty = true;
}
 /** Constructor, takes the name of the kart name and the host id.
  *  \param kart_name Name of the kart.
  *  \param host_id Id of the host who selected this character.
  */
 CharacterConfirmMessage(const std::string &kart_name, int host_id)
     : Message(Message::MT_CHARACTER_CONFIRM) 
 {
     allocate(getStringLength(kart_name) + getCharLength());
     addString(kart_name);
     addChar(host_id);
 }   // CharacterConfirmMessage
Exemple #22
0
void Decimal::getStringX(size32_t & length, char * & buffer) const
{
    unsigned len = getStringLength();
    buffer = (char *)malloc(len);
    unsigned written = doGetString(buffer);
    assertex(len == written);
    length = len;
}
Exemple #23
0
void Label::draw()
{
    const double size = _height / 1.9;
    const double space = (_width - getStringLength(size, _text)) / 2.;
    glTranslated(space, (_height - size) / 2., 0.);
    drawString(size, _text);
    glTranslated(-space, -(_height - size) / 2., 0.);
}
Exemple #24
0
char * Decimal::getCString() const
{
    unsigned len = getStringLength();
    char * buffer = (char *)malloc(len+1);
    unsigned written = doGetString(buffer);
    assertex(len == written);
    buffer[len] = 0;
    return buffer;
}
void test_twofish_decrypt_encrypt_wrong_size() {
    char *key = "ldlelslelslelslslflellalelslssl";
    char *plainText = "ldlelslelslelslslflelslalelslsslldlelslelslelslslflelslallslssl";
    enum EncryptionAlgorithm algorithm = TWOFISH;
    initCryptographyModule();
    int plainTextSize = getStringLength(plainText);
    char *cipherText = encryptString(plainText,plainTextSize, key, algorithm);
    CU_ASSERT_EQUAL(cipherText, NULL);
    freeCryptographyModuleMemory();
}
Exemple #26
0
void fillStringByBlanks(char* string, const int max_length_of_string)
{
    int i = max_length_of_string;
    int j = getStringLength(string);
    while (j >= 0)
        string[i--] = string[j--];
    while (i >= 0)
        string[i--] = ' ';
    return;
}
int main(int argc, char **argv) {
  char *inputNumber = argv[1];
  char *srcBase = argv[2];
  char *destBase = argv[3];
  int srcBaseInt = convertCharNumberToInt(srcBase);
  int destBaseInt = convertCharNumberToInt(destBase);
  long inputNumberLong = convertToDecimal(inputNumber, srcBaseInt,0,getStringLength(inputNumber));
  printf("Conversion of %s base %s to base %s is : %s\n",inputNumber, srcBase, destBase, convertDecimalToBase(inputNumberLong, destBaseInt));
  return 0;
}
int convertCharNumberToInt(char *number) {
  int i;
  int place = 1;
  int sum = 0;
  for (i = getStringLength(number) - 1; number[i]; i--) {
    int temp = convertCharToNumber(number[i]);
    sum = sum + (temp * place);
    place = place * 10;
  }
  return sum;
}
void test_twofish_decrypt_encrypt_null() {
    char *key = NULL;
    char *plainText = NULL;
    enum EncryptionAlgorithm algorithm = TWOFISH;
    initCryptographyModule();
    int plainTextSize = getStringLength(plainText);
    char *cipherText = encryptString(plainText,plainTextSize, key, algorithm);
    char *plainText2 = decryptString(cipherText,plainTextSize, key, algorithm);
    CU_ASSERT_EQUAL(plainText, NULL);
    CU_ASSERT_EQUAL(plainText2, NULL);
    freeCryptographyModuleMemory();
}
Exemple #30
0
char* rotateString(char string[]){
	int length = getStringLength(string);
	char last = string[0];
	int i;
	for(i = 0; i<length-1; i++){
		string[i] = string[i+1];
	}
	string[length-1] = last;

	return string;

}