kbd.cc

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

	       xmit = true;
//	       pad.pipe( 0, '0' + c );
	    }
	    else pad.frame( 0, c );

	 } else if( ( shift && num ) || ( !shift && !num ) )
	 {
	    c = ( c == 0x47 ) ? 0x66 : 0x6B;

// cast
	    ( c % 2 ) ? que -> enqueue( END ) : que -> enqueue( HOME );
	    xmit = true;
//	    ( c % 2 ) ? pad.end( 0 ) : pad.home( 0 );
	    break;

	 } else {

	    ( c & 8 ) ? pad.bot( 0 ) : pad.top( 0 ); // ( cast() )

	    break;
	 }  // or continue as normal home/end or top/bot

      case 0x66: case 0x6B: // c % 2 == false: home, true: end

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

	    if( !alt )

	       if( !ctrl )
	       {
// cast
	           ( c % 2 ) ? que -> enqueue( END ) : que -> enqueue( HOME );
		   xmit = true;
//	           ( c % 2 ) ? pad.end( 0 ) : pad.home( 0 );
	       }
	       else ( c % 2 ) ? pad.bot( 0 ) : pad.top( 0 );

	    else ( c % 2 ) ? pad.meta_altend( 0 ) : pad.meta_althome( 0 );

	 else if( !alt )

	    if( !ctrl )

	       pad.highlight( 0, 0 ); // represent home/end

            else ( c % 2 ) ? pad.pan( 0, 1, true ) : pad.pan( 0, 7, true );

	 break;

      case 0x49: case 0x51: // kp pgup / pgdn

	 if( alt )
	 {
	    c = ( c == 0x49 ) ? 9 : 3;

	    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-right and down-right

	    break;
	 }
	 else if( ( shift || num ) && !( shift && num ) )
	 {
	    c = ( c > 0x49 ) ? 3 : 9;

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

	 } else if( !ctrl )
	 {
	    ( c == 0x49 ) ? pad.pgup( 0 ) : pad.pgdn( 0 );

	    break;

	 } else {

            ( c == 0x49 ) ? pad.pan( 0, 9, false ) : pad.pan( 0, 3, false );

	    break;
	 }  // continue as normal pgup/dn or pan

      case 0x68: case 0x6D: // pgup/dn

	 if( !alt )

	    if( !ctrl )

	       if( !shift )

		  ( c % 2 ) ? pad.pgdn( 0 ) : pad.pgup( 0 );

	       else pad.highlight( 0, 0 ); // represent home/end

	    else if( !shift )

               ( c % 2 ) ? pad.pan( 0, 3, false ) : pad.pan( 0, 9, false );

            else ( c % 2 ) ? pad.pan( 0, 3, true ) : pad.pan( 0, 9, true );

	 else if( !ctrl && !shift )

	    ( c % 2 ) ? pad.meta_altpgdn( 0 ) : pad.meta_altpgup( 0 );

	 break;

      case 0x52: // kp ins

	 if( alt )
	 {
	    if( !ctrl )
	    {
	       ascii = true;

	       pad.ascii( 0, 0, true );

	       break;
	    }
	    else if( ( shift || num ) && !( shift && num ) )
	    {
	       pad.ctrlalt( 0, c );

	       break;
	    }
	    else pad.core_dump( 0 ); break;
	 }
	 if( pad.mousekeys && !ctrl )
	 {
	    pad.mousekey( 0, 0 ); // represent ins

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

	    else pad.frame( 0, 0 );

	 } else if( !ctrl )
	 {
// cast
	    que -> enqueue( INS );
	    xmit = true;
//	    pad.ins( 0 );
	    break;

	 } else {

	    pad.copy( 0 ); break;

	 }  // or continue as normal ins, copy, or core dump

      case 0x6E: // ins

	 if( !alt )

	    if( !ctrl )

	       if( !shift )
	       {
// cast
		  que -> enqueue( INS );
		  xmit = true;
//		  pad.ins( 0 );
	       }
	       else pad.paste( 0 );

	    else if( !shift )

	       pad.copy( 0 );

	    else pad.exchange( 0 );

	 else if( !ctrl ) pad.frame_new( 0 );

	 else if( !shift )

	    pad.core_dump( 0 );

	 break;

      case 0x53: // kp del

	 if( pad.mousekeys && !ctrl && !alt )
	 {
	    pad.mousekey( 0, 0 ); // represent del

	    break;
	 }
	 else if( ( shift || num ) && !( shift && num ) )
	 {
	    if( !alt )

	       if( !ctrl )
	       {
// cast
		  que -> pipe( '.' );
		  xmit = true;
//		  pad.pipe( 0, '.' );
	       }
	       else pad.ctrlpunc( 0, '.' );

	    break;
	 }
//	 else c = 0x6F; // continue as del, cut, hide, or boot/beep

	 else if( !alt )

	    if( !ctrl ) pad.del( 0 );

	    else pad.cut( 0 );

	 else if( !ctrl ) pad.hide( 0 );

	 else if( !lalt );// pad.beep();

	 else pad.boot( 0 );

	 break;

      case 0x6F: // del

	 if( !alt )

	    if( !ctrl )

	       if( !shift )
	       {
// cast
		  que -> enqueue( DEL );
		  xmit = true;
//		  pad.del( 0 );
	       }

	       else pad.cut( 0 );

	    else if( !shift )

	       pad.cut( 0 );

	    else pad.cut_append( 0 );

	 else if( !ctrl )

	    if( !shift )

	       pad.hide( 0 );

	    else pad.frame_del( 0 );

	 else if( !shift )

	    if( !lalt );// pad.beep();

	    else pad.boot( 0 );

	 break;

      case 0x4C: // kp 5

	 if( alt )
	 {
	    if( !ctrl )
	    {
	       ascii = true;

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

	       break;
	    }
	 }
	 if( pad.mousekeys && !ctrl )
	 {
	    pad.mousekey( 0, 0 ); // represent middle as left button

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

	    else pad.frame( 0, 5 );

	 } else {
// cast
	    que -> arrow( 5 );
	    xmit = true;
//	    pad.arrow( 0, 5 );

	 }  break;

      case 0x4A: case 0x4E: // kp - +

	 if( ctrl && !alt )

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

	       pad.vol( 0, c == 0x4E );

	    else pad.res_change( 0, c == 0x4E );

      case 0x62: case 0x37: // + - * /

	 if( !ctrl && !alt )

	    if( pad.mousekeys )

	       pad.mousekey( 0, 0 ); // represent + - * /

	    else
	    {
// cast
		 que -> pipe( ( c == 0x37 ) ? '*' :
			   ( c == 0x62 ) ? '/' :
			   ( c == 0x4E ) ? '+' : '-' );
		 xmit = true;
//		 pad.pipe( 0, ( c == 0x37 ) ? '*' :
//			   ( c == 0x62 ) ? '/' :
//			   ( c == 0x4E ) ? '+' : '-' );
	    }

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

	    if( !alt ) pad.ctrlmath( 0, ( c == 0x37 ) ? '*' :
				     ( c == 0x62 ) ? '/' :
				     ( c == 0x4E ) ? '+' : '-' );
	    else if( !ctrl )

	       ( c == 0x37 ) ? pad.wider( 0 )
	    :  ( c == 0x62 ) ? pad.narrower( 0 )
	    :  ( c == 0x4E ) ? pad.longer( 0 )
	    :		       pad.shorter( 0 );
	 break;

      case 0x39:

	 if( !ctrl )
	 {
// cast
	    que -> pipe( ' ' );
	    xmit = true;
//	    pad.pipe( 0, ' ' );
	 }
	 else if( !alt ) pad.select( 0, !shift );

	 else pad.ctrlalt( 0, ' ' );

	 break;

      case 0x1C: case 0x60: // return

	 if( !ctrl && !alt )
	 {
// cast
	    que -> enqueue( CR );
	    xmit = true;
//	    pad.cr( 0 );
	 }
	 else if( !shift )

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

	    else if( !ctrl ) pad.full_screen( 0 );

	    else pad.run( 0 );
	 break;

      case 0x0E: // backspace

	 if( !ctrl && !alt )
	 {
// cast
	    que -> enqueue( BS );
	    xmit = true;
//	    pad.bs( 0 );
	 }
	 else if( !shift )

	    // create / delete cell not implemented
	    if( !alt ) //pad.pipe( 127 );
	    {
// cast
	       que -> pipe( 127 );
	       xmit = true;
//	       pad.pipe( 0, 127 );
	    }
	    else if( !ctrl ) pad.frame_del( 0 );

	    else if( lalt ) pad.exit( 0 );
	 break;

      case 0x0F: // horizontal tab
	 if( !alt )
	    if( !ctrl )
	       shift ? pad.ht_back( 0 ) : pad.ht( 0 );
	    else
	       pad.item( 0, !shift );
	 else
	    if( !ctrl )
	       pad.task( 0, !shift );
	    else
	       pad.taskset( 0, !shift );
      }
      keycode = 0;
   }
   que -> strokes--;
}

/*
void kbd::operator=( char c )
{
   switch( keycode )
   {
   case 0x00: switch( c )
      {
      case 00: pad.cbreak(); break;	* ^@ or ^break			* /

      case 01 ... 0x1A:
         pad.ctrl( c ); break;		* ^A ... ^Z			* /

      case 0x1C: pad.prtsc(); break;	* prtsc: ^\			* /

      case 0x1D ... 0x1F:		* ^], ^^, ^_			* /
         pad.ctrl( c ); break;

      case 0x1B: keycode = c; return;

      case ' ': pad.pipe( c ); break;	* 20				* /
      case '0' ... '9':
         pad.pipe( c ); break;		* 30 to 39			* /
      case 'A' ... 'Z':
         pad.pipe( c ); break;		* 41 to 5A			* /
      case 'a' ... 'z':
         pad.pipe( c ); break;		* 61 to 7A			* /
 
      case 0x7F: pad.bs(); break;	* the actual key, not ^H	* /
      } break;

   case 0x01: switch( c )
      {
      case 0x41:
         pad.func( 1, 0 ); break;	* F1-5				* /
      case 0x42:
	 pad.func( 2, 0 ); break;
      case 0x43:
	 pad.func( 3, 0 ); break;
      case 0x44:
	 pad.func( 4, 0 ); break;
      case 0x45:
	 pad.func( 5, 0 ); break;
      } break;
   case 0x02: switch( c )
      {
      case 0x37: pad.func( 6, 0 );	* F6-8				* /
	 keycode = 0xFF; return;
      case 0x38: pad.func( 7, 0 );
	 keycode = 0xFF; return;
      case 0x39: pad.func( 8, 0 );
	 keycode = 0xFF; return;
      case 0x7E: pad.home(); break;	* home				* /
      } break;
   case 0x03: switch( c )
      {
      case 0x30: pad.func( 9, 0 );	* F9-12			* /
	 keycode = 0xFF; return;
      case 0x31: pad.func( 10, 0 );
	 keycode = 0xFF; return;
      case 0x33: pad.func( 11, 0 );
	 keycode = 0xFF; return;
      case 0x34: pad.func( 12, 0 );
	 keycode = 0xFF; return;
      case 0x35: pad.func( 1, 1 );	* shift F1-4			* /
	 keycode = 0xFF; return;
      case 0x36: pad.func( 2, 1 );
	 keycode = 0xFF; return;
      case 0x38: pad.func( 3, 1 );
	 keycode = 0xFF; return;
      case 0x39: pad.func( 4, 1 );
	 keycode = 0xFF; return;
      case 0x7E: pad.ins(); break;	* ins				* /
      } break;
   case 0x04: switch( c )
      {
      case 0x31: pad.func( 5, 1 );	* shift F5-8			* /
	 keycode = 0xFF; return;
      case 0x32: pad.func( 6, 1 );
	 keycode = 0xFF; return;
      case 0x33: pad.func( 7, 1 );
	 keycode = 0xFF; return;
      case 0x34: pad.func( 8, 1 );
	 keycode = 0xFF; return;
      case 0x7E: pad.del(); break;	* del				* /
      } break;
   case 0x1B: keycode = 0x5B; return;
   case 0x5B: switch( c )
      {
      case 0x5B: keycode = 1; return;	* F1-5				* /
      case 0x31: keycode = 2; return;	* F6-8, home			* /
      case 0x32: keycode = 3; return;	* F9-12, shift F1-4, ins	* /
      case 0x33: keycode = 4; return;	* shift F5-8, del		* /
      case 0x34: pad.end(); break;	* end				* /
	 keycode = 0xFF; return;
      case 0x35: pad.pgup(); break;	* pgup, pgdn			* /
	 keycode = 0xFF; return;
      case 0x36: pad.pgdn(); break;
	 keycode = 0xFF; return;
      case 0x41: pad.arrow( 8 ); break;	* arrows			* /
      case 0x42: pad.arrow( 2 ); break;
      case 0x43: pad.arrow( 6 ); break;
      case 0x44: pad.arrow( 4 ); break;
      case 0x47: pad.arrow( 5 ); break;	* middle			* /
      case 0x50: pad.pause(); break;	* pause			* /
      } break;
   }
   keycode = 0;
}
*/