keyboardappview.cpp

On screen keyboard source code in Linux

        case 'd': code = '/'; break;
        case 'f': code = '?'; break;
        case 'g': code = '['; break;
        case 'h': code = ']'; break;
        case 'j': code = '{'; break;
        case 'k': code = '}'; break;
        case 'l': code = '\\'; break;
        case ';': code = '|'; break;
        case '\'': code = '='; break;
        }
    }

    /* numlock keys */
    if (num_shift) {
        switch (code) {
        case 'q': code = '1'; break;
        case 'w': code = '2'; break;
        case 'e': code = '3'; break;
        case 'r': code = '4'; break;
        case 't': code = '5'; break;
        case 'y': code = '6'; break;
        case 'u': code = '7'; break;
        case 'i': code = '8'; break;
        case 'o': code = '9'; break;
        case 'p': code = '0'; break;
        case '-': code = '/'; break;
        case 'j': code = '4'; break;
        case 'k': code = '5'; break;
        case 'l': code = '6'; break;
        case ';': code = '*'; break;
        case 'm': code = '1'; break;
        case ',': code = '2'; break;
        case '.': code = '3'; break;
        case EKeyUpArrow: code = '-'; break;
        case EKeyLeftFunc: code = '0'; break;
        case EKeyLeftArrow: code = '.'; break;
        case EKeyDownArrow: code = '+'; break;
        case EKeyRightArrow: code = '='; break;
        }
    } else if (code == EKeyLeftFunc) code = 0;

    /* I still have to manually shift characters, even with mod */
    if (shift || capslock) {
        if ((code >= 'a') && (code <= 'z')) code -= ('a'-'A');
    }

    /* send keydown event */
    aEvent.Set(TRawEvent::EKeyDown, scode);
    ccoeenv->WsSession().SimulateRawEvent(aEvent);

    /* send keypress event */
    TKeyEvent aKeyEvent;
    aKeyEvent.iCode = code;
    /* trying to autorepeat a code=0 crashes */
    if (code) aKeyEvent.iModifiers = EModifierAutorepeatable;
    else aKeyEvent.iModifiers = 0;
    aKeyEvent.iRepeats = 0;
    aKeyEvent.iScanCode = scode;
    ccoeenv->WsSession().SimulateKeyEvent(aKeyEvent);

    /*
     * 10 second timer.  When it expires I will force a keyup.  The timer
     * is reset whenever we receive a repeat signal from the keyboard.  This
     * timer is 10 seconds because the Pocketop keyboard doesn't send any
     * keep-alive signal.  So I will make 10 seconds be the longest key hold
     * to keep a communications break from turning into an endless repeat.
     */
    iForceBreakTimer->Cancel();
    iForceBreakTimer->Start(10*1000*1000, 10*1000*1000,
        TCallBack(ForceBreakTick, this));
}

void CKeyboardAppView::thinkoutside(unsigned char raw, TBool forcebreak)
{    
    TRawEvent aEvent;

    CCoeEnv *ccoeenv=CCoeEnv::Static();

    if (forcebreak) {
        if (lastscode != -1) {
            /* send keyup event */
            aEvent.Set(TRawEvent::EKeyUp, lastscode);
            ccoeenv->WsSession().SimulateRawEvent(aEvent);
            lastscode = -1;
        }
        return;
    }
	
    /*
     * ThinkOutside IrDA protocol.  0xffc0 scancode 3bytesofstuff(prob crc).
     *
     * I'm going to wait for 0xffc0 then interpret the scancode and ignore
     * until the next 0xffc0.
     */
    switch (thinkoutside_state) {
    case 0:
        if (raw == 0xff) thinkoutside_state = 1;
        return;
    case 1:
        if (raw == 0xc0) thinkoutside_state = 2;
        return;
    case 2:
        thinkoutside_state = 0;
        if ((raw == 0x5c)) { /* repeat indicator */
            /* reset the timer so it doesn't forcebreak on us */
            iForceBreakTimer->Cancel();
            iForceBreakTimer->Start(1*1000*1000, 1*1000*1000,
                TCallBack(ForceBreakTick, this));
            return;
        }
        break;
    }

    if ((raw&0x80) && (lastscode != -1)) {
        /* send keyup event */
        aEvent.Set(TRawEvent::EKeyUp, lastscode);
        ccoeenv->WsSession().SimulateRawEvent(aEvent);
        lastscode = -1;
    }

    unsigned char cook;
    unsigned int modifier = EModifierAutorepeatable;

    cook = (unsigned char)(raw&0x7f);
    if (cook >= sizeof(thinkoutside_plain)) return;
    TInt code=thinkoutside_plain[cook];

    switch (code) {
    case EKeyLeftShift:
        shift = (bool)!(raw&0x80);
        code = 0;
        break;
    case EKeyRightShift:
        shift = (bool)!(raw&0x80);
        code = 0;
        break;
    case EKeyLeftFunc:
        func = (bool)!(raw&0x80);
        code = 0;
        break;
    case EKeyRightFunc:
        pt_shift = (bool)!(raw&0x80);
        code = 0;
        break;
    case EKeyCapsLock:
        if (!(raw&0x80)) capslock = !capslock; /* toggle */
        code = 0;
        break;
    case EKeyLeftCtrl: 
        ctrl = (bool)!(raw&0x80);
        code = 0;
        break;
    case EKeyLeftAlt:
        alt = (bool)!(raw&0x80);
        code = 0;
        break;
    }

    if (raw&0x80) return; /* high-bit on is break code */
    if (!code) return;

	if (capslock) 
	{
		if (shift) // capslock and shift annihilate themselves
			modifier |= EModifierShift;
		else 
			code = thinkoutside_shifted[cook];
	}
	else if (shift)
	{
		code = thinkoutside_shifted[cook];
		modifier |= EModifierShift;
	}

    if (pt_shift) {
        code = thinkoutside_func2[cook];    
        modifier |= EModifierRightFunc;
    }
    
    if (alt) {
    	modifier |= EModifierAlt;
    }

    if (func) {
        code = thinkoutside_func[cook];
        modifier |= EModifierLeftFunc;
    }

    if (ctrl) {
        code = CTRL(code);
        modifier |= EModifierCtrl;
    }
    TInt scode=0;
    /* send keydown event */
    aEvent.Set(TRawEvent::EKeyDown, scode);
    ccoeenv->WsSession().SimulateRawEvent(aEvent);
    lastscode = scode;

    /* send keypress event */
    TKeyEvent aKeyEvent;
    aKeyEvent.iCode = code;
    /* trying to autorepeat a code=0 crashes */
    if (!code) 
    	aKeyEvent.iModifiers = 0;
    else
    	aKeyEvent.iModifiers = modifier;
    
    aKeyEvent.iRepeats = 0;
    aKeyEvent.iScanCode = scode;
    ccoeenv->WsSession().SimulateKeyEvent(aKeyEvent);

    /*
     * 1 second timer.  When it expires I will force a keyup.  The timer
     * is reset whenever we receive a repeat signal from the keyboard.
     */
    iForceBreakTimer->Cancel();
    iForceBreakTimer->Start(1*1000*1000, 1*1000*1000,
        TCallBack(ForceBreakTick, this));
}



void CKeyboardAppView::targus(unsigned char raw, TBool forcebreak)
{    
    TRawEvent aEvent;

    CCoeEnv *ccoeenv=CCoeEnv::Static();

    if (forcebreak) {
        if (lastscode != -1) {
            /* send keyup event */
            aEvent.Set(TRawEvent::EKeyUp, lastscode);
            ccoeenv->WsSession().SimulateRawEvent(aEvent);
            lastscode = -1;
        }
        return;
    }
	
    /*
     * targus IrDA protocol:
     * down:  0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xc0 scancode 0xc1
     * I use the thinkoutside state machine.
     */
    switch (thinkoutside_state) {
    case 0:
        if (raw == 0xff) thinkoutside_state = 1;
        return;
    case 1:
        if (raw == 0xc0) thinkoutside_state = 2;
        return;
    case 2:
        thinkoutside_state = 0;
        break;
    }

    if ((raw&0x80) && (lastscode != -1)) {
        /* send keyup event */
        aEvent.Set(TRawEvent::EKeyUp, lastscode);
        ccoeenv->WsSession().SimulateRawEvent(aEvent);
        lastscode = -1;
    }

    unsigned char cook;

    cook = (unsigned char)(raw&0x7f);
    if (cook >= sizeof(targus_lut)) return;
    TInt code=targus_lut[cook];

    TInt scode=0;
    switch (code) {
    case EKeyLeftShift:
        shift = (bool)!(raw&0x80);
        code = 0;
        break;
    case EKeyRightShift:
        shift = (bool)!(raw&0x80);
        code = 0;
        break;
    case EKeyLeftFunc:
        func = (bool)!(raw&0x80);
        code = 0;
        break;
    case EKeyNumLock:
    		if(shift) 
    		{
		    	if (!(raw&0x80)) 
		    	  num_shift = !num_shift; /* toggle */
    		}
    		else 
    		{
	        num_shift = (bool)!(raw&0x80);
    		}
        code = 0;
        break;
    case EKeyCapsLock:
        if (!(raw&0x80)) capslock = !capslock; /* toggle */
        code = 0;
        break;
    case EKeyLeftCtrl:
        ctrl = (bool)!(raw&0x80);
        code = EKeyLeftCtrl;
        break;
    case EKeyLeftAlt:
        alt = (bool)!(raw&0x80);
        code = EKeyLeftAlt;
        break;
    }

    if (raw&0x80) 
    { /* high-bit on is break code */
        /* send keyup event */
        aEvent.Set(TRawEvent::EKeyUp, scode);
        ccoeenv->WsSession().SimulateRawEvent(aEvent);
        return;
    }
    if (!code && !scode) return;

    /* make it into control chars if needed */
    if (ctrl) 
    {
        if ((code >= 'a') && (code <= 'z')) 
          code = code-'a'+1;
        if ((code >= '[') && (code <= '_')) 
          code = code-'A';
    }

    if (shift && !func) 
    {
        /* other chars */
        switch (code) {
        case '-': code = '_'; break;
        case ';': code = ':'; break;
        case '\'': code = 0x22; break;
        case '1': code = '!'; break;
        case '2': code = '@'; break;
        case '3': code = '#'; break;
        case '4': code = '$'; break;
        case '5': code = '%'; break;
        case '6': code = '^'; break;
        case '7': code = '&'; break;
        case '8': code = '*'; break;
        case '9': code = '('; break;
        case '0': code = ')'; break;
        case '=': code = '+'; break;
        case '`': code = '~'; break;
        case '/': code = '?'; break;
        case ',': code = '<'; break;
        case '.': code = '>'; break;
        case '\\': code = '|'; break;
        case '[': code = '{'; break;
        case ']': code = '}'; break;
        case 'l': code = '\\'; break;
        case EKeyTab: code = EKeyVerticalTab; break;
        case EKeyApplication0: code = EKeyApplication4; break;
        case EKeyApplication1: code = EKeyApplication5; break;
        case EKeyApplication2: code = EKeyApplication6; break;
        case EKeyApplication3: code = EKeyApplication7; break;
  			case EKeyUpArrow: code = EKeyPageUp; break;
	  		case EKeyLeftArrow: code = EKeyHome; break;
		  	case EKeyDownArrow: code = EKeyPageDown; break;
			  case EKeyRightArrow: code = EKeyEnd; break;
        }
    }
    
    /* punct keys */
    if (func && shift) 
  	{
		  switch (code) 
		  {
        case '1': code = EKeyF11; break;
        case '2': code = EKeyF12; break;
        case '3': code = EKeyF13; break;
        case '4': code = EKeyF14; break;
        case '5': code = EKeyF15; break;
        case '6': code = EKeyF16; break;
        case '7': code = EKeyF17; break;
        case '8': code = EKeyF18; break;
        case '9': code = EKeyF19; break;
        case '0': code = EKeyF20; break;
      }
	  }

    /* func keys */
  	if (func && !shift) 
    {
        switch (code) {
        case 'e': code =  0x20AC; break;
        case 'r': code = '