kbd.cc

initial working phase of the design of said editor, featuring multicasting, advanced linux keyboard

#include "kbd.h"
#include "kbd_tty.h"
#include <stdlib.h>			// NULL
#include <stdio.h>

kbd::kbd() : kbd_tty()
{
   if( settings == NULL )		// NULL by whose definition?
      good = false;
   else
      good = true;

   keycode = 0;

   ctrl = lalt = alt = shift = false;	// fixme
   caps = num = scrl = false;		// fixme
   ascii = false;

   que = NULL;
   xmit = false;
}

kbd::kbd( int h ) : kbd_tty( h )
{
   if( settings == NULL )		// NULL by whose definition?
      good = false;
   else
      good = true;

   que = NULL;
   xmit = false;
}

kbd::~kbd()
{
//  close( handle );			// let's not close the standard input!
}

//  while( write( handle, &c, 1 ) < 0 )
//    if( errno != EINTR ) {good = false;break;}

void kbd::operator=( char c )
{
   if( c & 0x80 )
   {
      switch( c & 0x7F )
      {
      case 0x38:
	 pad.meta( 0, ( alt = lalt = false ));
	 break;
      case 0x64:
	 pad.ascii( 0, 0, false );
	 pad.meta( 0, ( alt = false ));
	 break;
      case 0x1D: case 0x61:
	 pad.fire( 0, ( ctrl = false ));
	 break;
      case 0x2A: case 0x36:
	 if( !pad.shiftlock )
	    pad.accel( 0, ( shift = false ));
	 break;
      }
   } else
   {  char lcase; int locks;

      switch( c )
      {
      case 0x38:
      {
	 bool newly = !lalt;
	 pad.meta( 0, ( alt = lalt = true ));
	 if( ctrl && newly ) pad.beep();
      } break;
      case 0x64:
	 pad.meta( 0, ( alt = 1 ));
	 break;
      case 0x1D: case 0x61:
      {
	 bool newly = !ctrl;
	 pad.fire( 0, ( ctrl = 1 ));
	 if( lalt && newly ) pad.beep();
      } break;
      case 0x2A: case 0x36:
	 pad.accel( 0, ( shift = 1 ));
	 break;

      case 0x3A:
	 locks = ( ( scrl << 2 )
	       + ( num << 1 ) + !caps );
	 if( alt ) pad.altlock( 0, locks );
	 else if( shift ) {
	    if( ( pad.shiftlock = !pad.shiftlock ) == false )
	       shift = false; }
	 else { caps = !caps;
	    leds( locks );
	    pad.lock( 0, locks ); }
	 break;
      case 0x45: num = !num;
	 locks = ( ( scrl << 2 )
	       + ( num << 1 ) + caps );
	 leds( locks );
	 if( alt ) pad.altlock( 0, locks );
	 else if( ctrl && shift )
	    pad.mousekeys = !pad.mousekeys;
	 else pad.lock( 0, locks );
	 break;
      case 0x46: scrl = !scrl;
	 locks = ( ( scrl << 2 )
	       + ( num << 1 ) + caps );
	 leds( locks );
	 if( alt ) pad.altlock( 0, locks );
	 else if( ctrl ) pad.pan( 0, 0, false ); // represent hold
	 else pad.lock( 0, locks ); break;

      case 0x3B ... 0x44: c += 0x12;
      case 0x57: case 0x58: c -= 0x4c;
	 if( ctrl && lalt && !shift )
	 {
	    chvt( c );
	 }
	 else
	 {
// cast
	      que -> func( c );
	      xmit = true;
//	      pad.func( 0, c, alt << 2
//			+ ctrl << 1
//			+ shift );
	 }
	 break;

      case 0x77: // pause

	 if( !alt ) if( !ctrl )

	    pad.pause( 0 ); // !shift (to un-pause)

	    else pad.cbreak( 0 );
	 break;

      case 0x63: // print screen

	 if( !alt )
	    if( !shift )
	       if( !ctrl ) pad.pause( 0 );
	       else pad.snap_copy( 0 );
	    else if( !ctrl ) pad.snapshot( 0 );
	 else
	    if( !shift )
	       if( !ctrl ) pad.sysrq( 0 );
	       else if( lalt ) chvt( 6 ); // a way to get last vt ?
	 break;

      case 0x01: // esc

	 if( !ctrl && !alt ) pad.esc( 0 );

	 else if( ( shift && num ) || ( !shift && !num ) )

	    if( !alt ) pad.meta_ctrlesc( 0 );

	    else pad.meta_altesc( 0 );
	 break;

      case 0x02 ... 0x0B: // 1...9 and 0

	 if( c == 0x0B ) c -= 10; c--;

	 if( alt ) pad.meta_altnum( 0, c );

	 else if( ctrl ) pad.meta_ctrlnum( 0, c );

	 else if( ( !shift && !num )
		|| ( shift && num ) )
	 {
// cast
	    que -> pipe( '0' + c );
	    xmit = true;
//	    pad.pipe( 0, '0' + c );
	 }

	 else
	 {
// cast
	    que -> pipe( ")!@#$%^&*("[ c ] );
	    xmit = true;
//	    pad.pipe( 0, ")!@#$%^&*("[ c ] );
	 }
	 break;

      case 0x10 ... 0x19:
      case 0x1E ... 0x26:
      case 0x2C ... 0x32:
	 lcase = "qwertyuiop    asdfghjkl     zxcvbnm"[ c - 0x10 ];
	 if( ( !shift && !caps )
	     || ( shift && caps ) )
	    if( !alt )
	       if( !ctrl )
	       {
// cast
		  que -> pipe( lcase );
		  xmit = true;
//		  pad.pipe( 0, lcase );
	       }
	       else
		  pad.ctrl( 0, lcase - 0x60 );
	    else
	       if( !ctrl )
		  pad.hash( 0, lcase );
	       else
		  pad.ctrlalt( 0, lcase );
	 else
	 {  int ucase = lcase - 0x20;

	    if( !alt )
	       if( !ctrl )
	       {
// cast
		  que -> pipe( ucase );
		  xmit = true;
//		  pad.pipe( 0, ucase );
	       }
	       else
	       {
// cast
		  que -> pipe( ucase - 0x41 );
		  xmit = true;
//		  pad.pipe( 0, ucase - 0x41 );
	       }
	    else
	       if( !ctrl )
		  if( !ascii || ucase > 'F' )
		  {
		     ascii = false;

		     // fixme: grab the rest of the buffer?
		     pad.hash( 0, ucase );
		  }
		  else
		     pad.ascii_hex( 0, ucase - 55 );
	       else
		  pad.ctrlalt( 0, ucase );
	 }
	 break;

      case 0x0C:
	 if( !shift )
	 {  que -> pipe( '-' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( '_' );
	    xmit = true;
	 }
	 break;

      case 0x0D:
	 if( !shift )
	 {  que -> pipe( '=' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( '+' );
	    xmit = true;
	 }
	 break;

      case 0x1A:
	 if( !shift )
	 {  que -> pipe( '[' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( '{' );
	    xmit = true;
	 }
	 break;

      case 0x1B:
	 if( !shift )
	 {  que -> pipe( ']' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( '}' );
	    xmit = true;
	 }
	 break;

      case 0x27:
	 if( !shift )
	 {  que -> pipe( ';' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( ':' );
	    xmit = true;
	 }
	 break;

      case 0x28:
	 if( !shift )
	 {  que -> pipe( '\'' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( '"' );
	    xmit = true;
	 }
	 break;

      case 0x29:
	 if( !shift )
	 {  que -> pipe( '`' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( '~' );
	    xmit = true;
	 }
	 break;

      case 0x2B:
	 if( !shift )
	 {  que -> pipe( '\\' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( '|' );
	    xmit = true;
	 }
	 break;

      case 0x33:
	 if( !shift )
	 {  que -> pipe( ',' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( '<' );
	    xmit = true;
	 }
	 break;

      case 0x34:
	 if( !shift )
	 {  que -> pipe( '.' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( '>' );
	    xmit = true;
	 }
	 break;

      case 0x35:
	 if( !shift )
	 {  que -> pipe( '/' );
	    xmit = true;
	 }
	 else
	 {  que -> pipe( '?' );
	    xmit = true;
	 }
	 break;

      case 0x48: case 0x4B: case 0x4D: case 0x50:

	 if( alt )
	 {
	    if( c > 0x4D ) c--;
	    if( c > 0x48 ) c--;
	    c = 0x50 - c;

	    if( !ctrl )
	    {
	       ascii = true;

	       pad.ascii( 0, c, true );
	    }
	    else if( ( shift || num ) && !( shift && num ) )

	       pad.ctrlalt( 0, c );

	    break;
	 }
	 if( pad.mousekeys && !ctrl )
	 {
	    if( c < 0x4B ) c++; c /= 3; c -= 24;

	    pad.mousekey( 0, c );

	    break;
	 }
	 else if( ctrl )

	    if( ( !shift && !num ) || ( shift && num ) )
	    {
	       if( c > 0x4B ) c++; c /= 3; c -= 24;

	       pad.skip( 0, c );

	       break;
	    }
	    else
	    {
	       if( c > 0x4D ) c--;
	       if( c > 0x48 ) c--;
	       c = 0x50 - c;

	       pad.frame( 0, c );

	       break;
	    }
	 else if( ( shift || num ) && !( shift && num ) )
	 {
// cast
	    que -> pipe( ( c == 0x48 ) ? '8' // check original
		      : ( c == 0x4B ) ? '4'
		      : ( c == 0x4D ) ? '6' : '2' );
	    xmit = true;
//	    pad.pipe( 0, ( c == 0x48 ) ? '8' // check original
//		      : ( c == 0x4B ) ? '4'
//		      : ( c == 0x4D ) ? '6' : '2' );
	    break;

	 } else { // no ctrl, alt, or shift/num

	    if( c > 0x4B ) c++;
	    c /= 3; c *= 2; c += 0x37;
	    if( c > 0x69 ) c--;
// cast
	    que -> arrow( ( c == 0x67 ) ? 8
		     : ( c == 0x69 ) ? 4
		     : ( c == 0x6A ) ? 6 : 2 );
	    xmit = true;
//	    pad.arrow( 0, ( c == 0x67 ) ? 8
//		     : ( c == 0x69 ) ? 4
//		     : ( c == 0x6A ) ? 6 : 2 );
	    break;
	 } // ...or continue as an arrow

      case 0x67: case 0x69: case 0x6A: case 0x6C:

	 if( !shift ) // numlock has no effect here

	    if( !alt )

	       if( !ctrl )
	       {
// cast
		  que -> arrow( ( c == 0x67 ) ? 8
			   : ( c == 0x69 ) ? 4
			   : ( c == 0x6A ) ? 6 : 2 );
		  xmit = true;
//		  pad.arrow( 0, ( c == 0x67 ) ? 8
//			   : ( c == 0x69 ) ? 4
//			   : ( c == 0x6A ) ? 6 : 2 );
	       }
               else
               {
		  if( c == 0x69 )
		  {  que -> enqueue( PAN_LEFT );
		     xmit = true;
		  }
		  if( c == 0x6A )
		  {  que -> enqueue( PAN_RIGHT );
		     xmit = true;
		  }
//		  pad.pan( 0, ( c == 0x67 ) ? 8
//			 : ( c == 0x69 ) ? 4
//			 : ( c == 0x6A ) ? 6 : 2, false );
               }

	    else if( lalt )

	       chvt( 7 ); // find way to tell which is current terminal

	    else
	    {
	       if( c < 0x6A ) c--; c /= 2; c -= 0x33;

	       pad.meta_altarrow( 0, c );
	    }
	 else if( !ctrl )

	    if( alt )

	       switch( c )
	       {
	       case 0x69: case 0x6A:

		  pad.indent( 0, c-- % 2 );
		  break;

	       case 0x67: case 0x6C:

		  pad.highlight( 0, 0 ); // for a way to represent alt-up/down
	       }
	    else pad.highlight( 0, 0 ); // for a way to represent arrow

         else if( !alt )
         {
	    if( c == 0x69 )
	    {  que -> enqueue( PAN_LEFT );
	       xmit = true;
	    }
	    if( c == 0x6A )
	    {  que -> enqueue( PAN_RIGHT );
	       xmit = true;
	    }
//	    pad.pan( 0, ( c == 0x67 ) ? 8
//		   : ( c == 0x69 ) ? 4
//		   : ( c == 0x6A ) ? 6 : 2, true );
         }

	 break;

      case 0x47: case 0x4F: // c & 8 == false: home, true: end

	 if( alt )
	 {
//	    c--; c /= 4; c *= 3; c = 61 - c;

	    c = ( c == 0x47 ) ? 7 : 1;

	    if( !ctrl )
	    {
	       ascii = true;

	       pad.ascii( 0, c, true );
	    }
	    else if( ( shift || num ) && !( shift && num ) )

	       pad.ctrlalt( 0, c );

	    break;
	 }
	 if( pad.mousekeys && !ctrl )
	 {
	    pad.mousekey( 0, 0 ); // represent up-left and down-left

	    break;
	 }
	 else if( ( shift || num ) && !( shift && num ) )
	 {
	    c = ( c & 8 ) ? 1 : 7;

	    if( !ctrl )
	    {
// cast
	       que -> pipe( '0' + c );