unsigned char* cbm_input(unsigned char len,unsigned char cursor){
	unsigned char key=0;
	unsigned char* eingabestring=calloc(len,1);
	unsigned char eglen;

	if(NULL!=eingabestring){
		if(kbhit()){cgetc();}
		while(('\n'!=key)){
			eglen=strlen(eingabestring);
			putchar(cursor);
			key=cgetc();
			switch(key){
				case CH_DEL:{
					if(0<eglen){
						eingabestring[eglen-1]='\0';
						putchar(CH_DEL);
						break;
					}
				}
				case CH_ENTER:{break;}
				default:{
					if(len>eglen){
						eingabestring[eglen]=key;
						putchar(key);
					}
				}
			}
		}
		putchar(' ');
		/*clrscr();
		write_room_info();
		write_death();*/
	}
	return eingabestring;
}

uint16_t cgeti(CFILE *f)
{
   uint16_t a, b;
	a = cgetc(f);
	b = cgetc(f);
	return (b << 8) | (a);
}

int main(void)
{
	char c;
        NEWLINE;

        cursor (1);
	PRINTF("enter key (cursor on): ");
	c = cgetc();
        NEWLINE;

        cursor (0);
	PRINTF("enter key (cursor off): ");
	c = cgetc();
        NEWLINE;

	PRINTF("enter key (cursor on): ");
        cursor (1);
	c = cgetc();
        NEWLINE;

	PRINTF("enter key (cursor off): ");
        cursor (0);
	c = cgetc();
        NEWLINE;

        PRINTF("hit any key to exit...");
        c = cgetc();
        NEWLINE;

	return(0);
}

uint32_t cgetl(CFILE *f)
{
   uint32_t a, b, c, d;
	a = cgetc(f);
	b = cgetc(f);
	c = cgetc(f);
	d = cgetc(f);
	return (d << 24) | (c << 16) | (b << 8) | (a);
}

bool loadGame(tUpdatePosCallback callback)
{
    bool isValid = false;
    bool result = false;
    FILE *saveFile= fopen(SAVE_GAME_FILE, "rb");
    
    if (saveFile == NULL) {
#ifdef LOAD_GAME_DEBUG
        printf("Cannot open save game file\n");
        cgetc();
#endif
        return false;
    }
    
    if ((fread(&isValid, sizeof(isValid), 1, saveFile) != 1) ||
        (!isValid)) {
        fclose(saveFile);
#ifdef LOAD_GAME_DEBUG
        printf("Save is not valid\n");
        cgetc();
#endif
        return false;
    }
    
    if (fread(&theGame, sizeof(theGame), 1, saveFile) != 1) {
        fclose(saveFile);
        deleteGame();
#ifdef LOAD_GAME_DEBUG
        printf("Unable to read game from save\n");
        cgetc();
#endif
        return false;
    }
    
    theGame.callback = callback;
    
    // The saved start time is an elapsed time.  Convert it back into a start time relative to now.
    if (theGame.startTime != 0xffffffff) {
        theGame.startTime = _systime() - theGame.startTime;
    }
    
    theGame.puzzle = loadPuzzle(saveFile);
    
    fclose(saveFile);
    deleteGame();
    
    if (theGame.puzzle == NULL) {
#ifdef LOAD_GAME_DEBUG
        printf("Unable to read puzzle from save\n");
        cgetc();
#endif
        return false;
    }
    
    return true;
}

int main (void)
{
	static byte rowNumber, columnNumber, synthesizing;
	static byte rowBit, columnBits, lastColumnBits[8], changedColumnBits;

     /* If we have a character, remove it from the buffer */
    if (kbhit ()) {
       	cgetc ();
    }

	resetSound();
    setUpScreen();
	synthesizing=TRUE;

    //main loop
    while(synthesizing)
    {
		//do keyboard scan
		for (rowNumber = 0; rowNumber <= KeyRows-1; rowNumber++)
		{
			rowBit = 1 << rowNumber;
			
			CIA1.pra = ~rowBit; 		//write the row we want to read
			columnBits = ~CIA1.prb;   	//read the keys pressed in the row
									
			if (lastColumnBits[rowNumber] != columnBits)
			{
				changedColumnBits=lastColumnBits[rowNumber]^columnBits;
				lastColumnBits[rowNumber]=columnBits;
				
				for(columnNumber = 0; 
					columnNumber<= KeyColumns-1 && changedColumnBits != 0; 
					columnNumber++)
				{
					if(changedColumnBits & 1)
					{
						changeFunctionStatus(functionMatrix[rowNumber][columnNumber], 
											columnBits & 1);
					}
					changedColumnBits >>= 1;
					columnBits >>= 1;
				}				
			}
		}

		if(kbhit()){
			if (cgetc()==13)
				synthesizing=FALSE;
		}
    }

char * main_menu ()
{
    bool valid;

    cursor(true);
    for (;;)
    {
        MENU("Dir / ");
        MENU("Load / ");
        MENU("Input ? ");
        valid = false;

        while (!valid)
        {
            switch (toupper (cgetc ()))
            {
            case 'D':
                valid = true;
                printf ("D\r\n\r\n");
                dir ();
                printf ("\r\n");
                break;
            case 'L':
                puts ("L\r\n");
                printf ("Filename? ");
                gets(filename);
                puts ("\r\n");
                return filename;
            case 'I':
                printf ("I\r\n\r\n");
                return 0;
            }
        }
    }
}

void process_checkbox(tgui_Window *win, tgui_Obj *obj){
int x, y;
char key;

    x=win->x1 + 1 + obj->x;
    y=win->y1 + 2 + obj->y;

	gotoxy(x+1,y);
	cursor(1);
	revers(1);
	if (obj->state==0) cputc(' ');
	else cputc('X');

	do {
		gotoxy(x+1,y);
	    revers(1);
	    if (obj->state==0) cputc(' ');
	    else cputc('X');
	    gotoxy(x+1, y);
	    key=cgetc();

	    if (key==' ') {
	        if(obj->state == 0 ) obj->state =1;
			else obj->state = 0;
		}

	} while (key != CH_ENTER);

		gotoxy(x+1,y);
	    revers(0);
	    if (obj->state==0) cputc(' ');
	    else cputc('X');
	cursor(0);

}  // process_checkbox

void main (void)
{
    log ("Calling overlay 1 from main");

    /* The symbols _OVERLAY1_LOAD__ and _OVERLAY1_SIZE__ were generated by the
     * linker. They contain the overlay area address and size specific to a
     * certain program.
     */
    if (loadfile ("ovrldemo.1", _OVERLAY1_LOAD__, _OVERLAY1_SIZE__)) {

        /* The linker makes sure that the call to foo() ends up at the right mem
         * addr. However it's up to user to make sure that the - right - overlay
         * is actually loaded before making the the call.
         */
        foo ();
    }

    log ("Calling overlay 2 from main");

    /* Replacing one overlay with another one can only happen from the main
     * program. This implies that an overlay can never load another overlay.
     */
    if (loadfile ("ovrldemo.2", _OVERLAY2_LOAD__, _OVERLAY2_SIZE__)) {
        bar ();
    }

    log ("Calling overlay 3 from main");
    if (loadfile ("ovrldemo.3", _OVERLAY3_LOAD__, _OVERLAY3_SIZE__)) {
        foobar ();
    }

    cgetc ();
}

static char GetKeyUpdate (void)
/* Wait for a key updating the windows in the background */
{
    static unsigned char Win;

    /* While there are no keys... */
    while (!kbhit ()) {

        switch (Win) {

            case 0:
                UpdateAsm ();
                break;

            case 1:
                UpdateStack ();
                break;

            case 2:
                UpdateCStack ();
                break;

            case 3:
                UpdateDump ();
                break;
        }

        Win = (Win + 1) & 0x03;

    }

    /* We have a key - return it */
    return cgetc ();
}

static void refreshLevel(tLevel level)
{
    bool waiting = true;
    
    videomode(VIDEOMODE_80x24);
    mixedTextMode();
    speakLevelComplete();
    
    gotoxy(0, 0);
    cprintf(      "               Completed level %u!!", level);
    cputsxy(0, 2, "               Press space to continue to the next level...");
    
    while (waiting) {
        switch (cgetc()) {
            case ' ':
                waiting = false;
                break;
                
            default:
                badThingHappened();
                break;
        }
    }
    
    showAndClearDblLoRes();
    speakGetReady();
}

uint8_t display_control_line(uint8_t line_count)
{
    char c;

    revers(true);
    cputs("--More--");
    revers(false);
    c = tolower(cgetc());
    erase_backward(8);
    switch (c) {
        case 'b':
            /* Go back one page.*/
            break;
        case ' ':
            /* Print the next page.*/
            line_count = 0;
            break;
        case 'q':
            /* Quit.*/
            exit(EXIT_SUCCESS);
        case CARRIAGE_RETURN:
            /* Display one more line. */
            line_count -= 1;
            break;
    }
    return line_count;
}

static void save_anim() {
    switch_to_console_screen();
    if (prompt_open("save", CBM_WRITE, TYPE_USR)) {
        const char curr_screen_saved = curr_screen;

        const char version = 3;
        mycbm_write(MY_LFN, &version, 1);  // Version.
        ++end_frame;
        mycbm_write(MY_LFN, &end_frame, 1);  // Frame count.
        --end_frame;

        for (curr_screen = 0; curr_screen <= end_frame; ++curr_screen) {
            lz77_write_screen();
        }
        curr_screen = curr_screen_saved;

        mycbm_close(MY_LFN);
        if (_oserror) {
            textcolor(COLOR_RED);
            cputs("disk full?");
            cgetc();
        }
    }
    redraw_edit_screen();
    show_cursor();
    invalidate_loaded_anim();
}

/*
 * get_input_terminated_by() reads input (handling backspace correctly) until
 * a terminator of |terminators| is encountered or |out| is full (outlen-1
 * characters were read).
 *
 * get_input_terminated_by() returns the terminator it encountered.
 *
 */
input_terminator_t get_input_terminated_by(input_terminator_mask_t terminators, char *out, BYTE outlen) {
	BYTE i = strlen(out);
	BYTE c, x, y;
	x = wherex() - i;
	y = wherey();
	while (1) {
		c = cgetc();
		if (((terminators & INPUT_TERMINATOR_RETURN) == INPUT_TERMINATOR_RETURN) && (c == PETSCII_CR)) {
			return INPUT_TERMINATOR_RETURN;
		} else if (((terminators & INPUT_TERMINATOR_SPACE) == INPUT_TERMINATOR_SPACE) && (c == PETSCII_SP)) {
			return INPUT_TERMINATOR_SPACE;
		} else if (c == PETSCII_DEL) {
			/* If you are at the left-most position, do nothing */
			if (i == 0)
				continue;
			out[--i] = '\0';
			cputcxy(x+i, y, ' ');
			gotoxy(x+i, y);
			continue;
		}
		if (i == (outlen-1)) {
			continue;
		}
		cputc(c);
		out[i++] = c;
	}
}

int main() {
    clrscr();
    bordercolor(0);
    bgcolor(6);

    renderMenu(100);

    textcolor(7);
    gotoxy(0, 1);
    updateStatus(' ');
    cursor(1);
    while(1) {
        char c;
/*
        uint8_t row;
        uint8_t col;
        for (row = 0;  row < 16;  row++) {
            gotoxy(0, row + 3);
            cprintf("%3d ", row * 16);
            for (col = 0;  col < 16;  col++) {
                cputc(row * 16 + col);
                cputc(' ');
            }
        }
*/
        c = cgetc();

        if (c == 20) {
            // backspace
        } else if (c == 13) {
            // Return
        } else if (c == 157) {
            // Left
            uint8_t xpos = wherex() - 1;
            gotox(xpos);
        } else if (c == 29) {
            // Right
            uint8_t xpos = wherex() + 1;
            gotox(xpos);
        } else if (c == 17) {
            // Down
            uint8_t ypos = wherey() + 1;
            gotoy(ypos);
        } else if (c == 145) {
            // Up
            uint8_t ypos = wherey() - 1;
            gotoy(ypos);
        } else if (c == 19) {
            // Pos1
        } else if (c == 3) {
            // ESC -> Menu
            processMenu();
        } else {
            cputc(c);
        }        

        
        updateStatus(c);
    }
}

void processMenu() {
    uint8_t c = 0;
    uint8_t current = 0;

    cursor(0);
    while(1) {
        renderMenu(current);

        c = cgetc();
        if (c == 157) {
            // Left
            if (current == 0) {
                current = menuSize - 1;
            } else {
                current--;
            }
        } else if (c == 29) {
            // Right
            current++;
            if (current >= menuSize) {
                current = 0;
            }
        } else if (c == 3) {
            break;
        }
    }

    renderMenu(100);
    cursor(1);
    revers(0);
}

/*---------------------------------------------------------------------------*/
static
PT_THREAD(handle_output(void))
{
  ctk_arch_key_t c;
  char *ptr;
  
  PT_BEGIN(&s.outpt);
  
  while(1) {
    PT_WAIT_UNTIL(&s.outpt, (ctk_mode_get() == CTK_MODE_EXTERNAL) &&
		  kbhit());


    ptr = s.outputbuf;
    s.len = 0;    
    while(kbhit() && s.len < sizeof(s.outputbuf)) {
      c = cgetc();
      *ptr = c;
      ++ptr;
      ++s.len;   
    }

    PT_WAIT_THREAD(&s.outpt, send());
  }
  PT_END(&s.outpt);      
}

static void endGame(void)
{
    videomode(VIDEOMODE_80x24);
    mixedTextMode();
    
    speakNoMoreMoves();
    
    cputsxy(0, 0, "               No more moves  -  GAME OVER!!");
    gotoxy(0,1);
    cprintf(      "               You made it to level %u", getLevel());
    cputsxy(0, 3, "                    Play again (Y/N)?");
    
    while (true) {
        switch (cgetc()) {
            case 'y':
            case 'Y':
                return;
                
            case 'n':
            case 'N':
            case CH_ESC:
            case 'q':
            case 'Q':
                quitGame();
                break;
                
            default:
                badThingHappened();
                break;
        }
    }
}

static void copy() {
    remember_screen();  // Saves edit screen to SCREEN_BASE area.

    CLIP_X1 = cur_x;
    CLIP_X2 = cur_x;
    CLIP_Y1 = cur_y;
    CLIP_Y2 = cur_y;

    for (;;) {
        redraw_edit_screen();
        paint_copy_mark();
poll_key:
        switch (cgetc()) {
            case CH_CURS_DOWN:
                if (CLIP_Y2 < 24) ++CLIP_Y2;
                break;
            case CH_CURS_UP:
                if (CLIP_Y2) --CLIP_Y2;
                break;
            case CH_CURS_RIGHT:
                if (CLIP_X2 < 39) ++CLIP_X2;
                break;
            case CH_CURS_LEFT:
                if (CLIP_X2) --CLIP_X2;
                break;
            case CH_F5:
                goto done;
            default:
                goto poll_key;
        }
    }

done:
    redraw_edit_screen();
    memcpy(CLIPBOARD, DISPLAY_BASE, 40 * 25);
    memcpy(CLIPBOARD + 40 * 25, (char*)0xd800, 40 * 25);

    if (CLIP_X1 == CLIP_X2 && CLIP_Y1 == CLIP_Y2) {
        // Copies entire screen. Flashes screen to give some kind of feedback.
        *(char*)0xd021 ^= 0xf;
        {
            unsigned long now = clock();
            while (now + 8 != clock()) {}
        }
        *(char*)0xd021 ^= 0xf;
    } else {
        // Order coordinates.
        if (CLIP_X1 > CLIP_X2) {
            const char tmp = CLIP_X1;
            CLIP_X1 = CLIP_X2;
            CLIP_X2 = tmp;
        }
        if (CLIP_Y1 > CLIP_Y2) {
            const char tmp = CLIP_Y1;
            CLIP_Y1 = CLIP_Y2;
            CLIP_Y2 = tmp;
        }
    }
}

static void AskForDisk (const char* Name, unsigned char Drive)
/* Ask the user to insert a specific disk */
{
    ClearLine ();
    cprintf ("\rInsert %s Disk into Drive %d !", Name, Drive);

    cgetc ();
}