Example #1
0
//---------------------------------------------------------------------------
void __fastcall TRightsFrame::SetText(UnicodeString value)
{
  if (Text != value)
  {
    UnicodeString RightsStr = value;

    int P = RightsStr.LowerCase().Pos(FAddXToDirectoriesSuffix);
    bool AAddXToDirectories = (P > 0);
    if (AAddXToDirectories)
    {
      RightsStr.Delete(P, FAddXToDirectoriesSuffix.Length());
    }
    RightsStr = DeleteChar(DeleteChar(RightsStr, L'('), L')').Trim();
    TRights R = Rights;
    if (((RightsStr.Length() == 3) || (RightsStr.Length() == 4)) &&
        IsNumber(RightsStr))
    {
      R.Octal = RightsStr;
    }
    else
    {
      R.Text = RightsStr;
    }

    Rights = R;
    AddXToDirectories = AAddXToDirectories;
  }
}
Example #2
0
void kexConsole::ParseKey(int c) {
    switch(c) {
        case KKEY_BACKSPACE:
            BackSpace();
            return;
        case KKEY_DELETE:
            DeleteChar();
            return;
        case KKEY_LEFT:
            MoveTypePos(0);
            return;
        case KKEY_RIGHT:
            MoveTypePos(1);
            return;
        case KKEY_PAGEUP:
            LineScroll(1);
            return;
        case KKEY_PAGEDOWN:
            LineScroll(0);
            return;
    }

    if(c >= KKEY_SPACE && c < KKEY_z) {
        if(typeStrPos >= CON_INPUT_LENGTH) {
            return;
        }

        typeStr[typeStrPos++] = inputKey.GetAsciiKey((char)c, bShiftDown);
        typeStr[typeStrPos] = '\0';
    }
}
Example #3
0
int HoldKeyPressing(TextEdition *te, SDL_Event event)
{
    char c, done=1;
    if (event.type != SDL_KEYDOWN || !te->focus || HasReadOnlyStyle(te->style))
        return 0;

    switch(event.key.keysym.sym)
    {
        case SDLK_DELETE:
            if (te->selection.begin == te->selection.end)
                DeleteChar(te->text, te->cursorPos);
            else DeleteSelection(te);
            TE_UpdateTextEdition(te, 0);
            break;
        case SDLK_BACKSPACE:
            if (te->selection.begin == te->selection.end)
            {
                if (te->cursorPos > 0)
                    DeleteChar(te->text, -- te->cursorPos);
            }
            else DeleteSelection(te);
            TE_UpdateTextEdition(te, 0);
            break;
        case SDLK_RETURN:
        case SDLK_KP_ENTER:
            event.key.keysym.unicode = '\n';
        default:
            if (event.key.keysym.unicode)
            {
                if (event.key.keysym.unicode<256)
                    c = event.key.keysym.unicode;
                else c = '?';

                if (te->selection.begin != te->selection.end)
                    DeleteSelection(te);
                InsertChar(te->text, te->cursorPos, c, te->textLength);
                TE_UpdateTextEdition(te, 0);
                te->cursorPos++;
            }
            else done = 0;

            break;
    }

    return done;
}
//@doc SECEdit
//@mfunc Internal function.  Deletes iCount characters from the text, starting at
//              pTextPos->iOffset.
//
//@rdesc int 
//@parm PTEXTPOS pTextPos
//@parm  int iCount
//@parm  BOOL bSaveUndoRecord
int SECEdit::DeleteString(PTEXTPOS pTextPos, int iCount, BOOL bSaveUndoRecord)
   {
   int i;
   TEXTPOS TextPos;
   UNDORECORD UndoRecord;
	ASSERT(pTextPos);

   TextPos = *pTextPos;

	// it's confusing to SaveUndoRecord if the OE_UNDO_CUT is just one character...
	if (iCount == 1)
		return (DeleteChar(&TextPos, bSaveUndoRecord));

	LPSTR lpString;
   if (bSaveUndoRecord)
      {
      lpString = (LPSTR)SECEditAlloc(iCount+1);
      memcpy(lpString,&pTextPos->pLine->pText[pTextPos->iOffset],iCount);
      }

   int iRval = 0;
   for (i=0;i<iCount;i++)
      {
      iRval = DeleteChar(&TextPos, FALSE);
      if (iRval && (iRval != IDS_OE_JOINLINE))
         break;
		else
			iRval = 0;
      }

   if (bSaveUndoRecord)
   	{
      if (!iRval)
      	{
	      UndoRecord.iRow = GetLineNo(pTextPos->pLine);
	      UndoRecord.iCol = pTextPos->iOffset;
	      UndoRecord.iEndRow = UndoRecord.iRow;
	      UndoRecord.iEndCol = TextPos.iOffset+iCount;
	      UndoRecord.iUndoType = OE_UNDO_CUT;
	      SaveUndoRecord(&UndoRecord, lpString);
      	}
      free(lpString);
      }

   return iRval;
   }
	void TextureAtlasPatternFileLoader::Analyze( char* pData, int len )
	{
		char* pEnd = pData + len;

		char str[ 1024 ];

		// ファイル解析
		while( pData != pEnd ){
			GetLineFromString( &pData, pEnd, str, sizeof( str ) );
			int count = 0;
			AtlasData data;
			bool ok = false;
			MAPIL::ZeroObject( &data, sizeof( data ) );
			for( const char* pToken = ::strtok( str, "," ); pToken; pToken = ::strtok( 0, "," ) ){
				char s[ 1024 ];
				DeleteChar( s, sizeof( s ), pToken, ' ' );
				switch( count ){
					// ID
					case 0:
						if( !IsDigitString( s ) ){
							continue;
						}
						data.m_ID = ::atoi( s );
						break;
					// TexID
					case 1:
						data.m_TexID = ::atoi( s );
						break;
					// X座標
					case 2:
						data.m_PosX = ::atoi( s );
						break;
					// Y座標
					case 3:
						data.m_PosY = ::atoi( s );
						break;
					// 幅
					case 4:
						data.m_Width = ::atoi( s );
						break;
					// 高さ
					case 5:
						data.m_Height = ::atoi( s );
						ok = true;
						break;
					// レジスタ
					default:
						break;
				}
				++count;
			}
			if( ok ){
				m_AtlasData.push_back( data );
			}
		}
	}
Example #6
0
int OpsBarraGame::EscucharRespuesta()
{
    bot.setGrammarFile("./numbers.bnf");
    AISoy1::Sentence sentence=bot.listen();

    char *tmp=strdupa(sentence.sentence().c_str());
    DeleteChar(tmp,'D');

    return Chartoint(tmp);
}
Example #7
0
int TEXTEDITBOX::ProcFunction(PASSPROCVARS Params){
	TCHAR Char;
	//
	switch(Params.uMsg){
	case WM_PAINT:
		RestoreFonts();
		Pass.DDFront->Restore();
		Pass.DDBack->Restore();
		this->EditBoxSurface->Restore();
		DDReLoadBitmap(this->EditBoxSurface, BMP_TEXTEDITBOX);
		this->StorageSurface->Restore();
		break;
	case WM_CHAR:
		switch(Params.wParam){
			case 0x08:  /* backspace */
				DeleteChar();
				break;
			case 0x0A:  /* linefeed */
			case 0x0D:  /* carriage return */
				Info=TEBI_DONE;
				break;
			case 0x1B:  /* escape */
			case 0x09:  /* tab */
				break;
			default:
				//normal character:
				Char=(TCHAR) Params.wParam;
				AddChar(Char);
			break;
		}
		break;
		case WM_KEYDOWN:
		///put it in the box.
		switch(Params.wParam){
			case VK_RETURN:
				break;
			case VK_ESCAPE:
				break;
			case VK_LEFT:
				break;
			case VK_RIGHT:
				break;
		}
		break;
	}

	UpdateBox();
	return 0;
}
Example #8
0
bool LineEdit::Key(dword key, int count) {
	NextUndo();
	switch(key) {
	case K_CTRL_UP:
		ScrollUp();
		return true;
	case K_CTRL_DOWN:
		ScrollDown();
		return true;
	case K_INSERT:
		OverWriteMode(!IsOverWriteMode());
		break;
	}
	bool sel = key & K_SHIFT;
	switch(key & ~K_SHIFT) {
	case K_CTRL_LEFT:
		{
			PlaceCaret(GetPrevWord(cursor), sel);
			break;
		}
	case K_CTRL_RIGHT:
		{
			PlaceCaret(GetNextWord(cursor), sel);
			break;
		}
	case K_LEFT:
		MoveLeft(sel);
		break;
	case K_RIGHT:
		MoveRight(sel);
		break;
	case K_HOME:
		MoveHome(sel);
		break;
	case K_END:
		MoveEnd(sel);
		break;
	case K_UP:
		MoveUp(sel);
		break;
	case K_DOWN:
		MoveDown(sel);
		break;
	case K_PAGEUP:
		MovePageUp(sel);
		break;
	case K_PAGEDOWN:
		MovePageDown(sel);
		break;
	case K_CTRL_PAGEUP:
	case K_CTRL_HOME:
		MoveTextBegin(sel);
		break;
	case K_CTRL_PAGEDOWN:
	case K_CTRL_END:
		MoveTextEnd(sel);
		break;
	case K_CTRL_C:
	case K_CTRL_INSERT:
		Copy();
		break;
	case K_CTRL_A:
		SelectAll();
		break;
	default:
		if(IsReadOnly())
			return MenuBar::Scan(WhenBar, key);
		switch(key) {
		case K_DELETE:
			DeleteChar();
			break;
		case K_BACKSPACE:
		case K_SHIFT|K_BACKSPACE:
			Backspace();
			break;
	   	case K_SHIFT_TAB:
			AlignChar();
			break;
		case K_CTRL_Y:
		case K_CTRL_L:
			if(cutline) {
				CutLine();
				break;
			}
		default:
			if(InsertChar(key, count, true))
				return true;
			return MenuBar::Scan(WhenBar, key);
		}
		return true;
	}
	Sync();
	return true;
}
Example #9
0
void LineEdit::Backspace() {
	if(IsReadOnly() || RemoveSelection() || cursor == 0) return;
	MoveLeft();
	DeleteChar();
	Action();
}
Example #10
0
int TextEdit::handle(char c) {
    int length = strlen(text);

    switch (c) {

    case DEL:
    case BS:

        if (curpos > 0) {
            DeleteChar();
        } else {
            return(kill_previous_newline);
        }
        return(no_op);


    case CONTROL_D:

        if (curpos < length && length > 0) {
            curpos++;
            DeleteChar();
        } else {
            return(kill_newline);
        }
        return(no_op);


    case BACKWARD_CHAR:

        if (curpos > 0) {
            curpos--;
        } else {
            curpos = 0;
            return(previous_line);
        }
        return(no_op);


    case FORWARD_CHAR:

        if (curpos < length) {
            curpos++;
        } else {
            curpos = length;
            return(next_line);
        }
        return(no_op);


    case NEXT_LINE:
    case PREVIOUS_LINE:
    case CARRIAGE_RETURN:
        return(next_line);

    case LINE_FEED:
        return(newline);

    case CONTROL_W:
    case CONTROL_U:

        SetText("");
        SetCurPos(0);
        return(no_op);


    case CONTROL_E:

        curpos = length;
        return(no_op);


    case CONTROL_A:

        curpos = 0;
        return(no_op);

    case CONTROL_C:
    case CONTROL_G:
    case CONTROL_I:
    case CONTROL_K:
    case CONTROL_L:
    case CONTROL_O:
    case CONTROL_Q:
    case CONTROL_R:
    case CONTROL_S:
    case CONTROL_T:
    case CONTROL_V:
    case CONTROL_X:
    case CONTROL_Y:
    case CONTROL_Z:
        return(no_op);


    default:
        InsertToString(c);
        return(no_op);

    }

}