Console CLI application to Draw Ascii Art to a File (SetConsoleCursorPosition)

Question

I'd like to write to a text file such that whenever a user hits a key, the file gets updated with an Ascii character somewhere specific in the file (not appended at the end), and not shown on the screen.

While the following code worked when outputing to the console window, I can't get it to write correctly to a file:

HANDLE hConsole = NULL;
void gotoxy ( int x, int y )
{
    COORD c = { x, y };
    SetConsoleCursorPosition ( hConsole, c );
}

int main(array<System::String ^> ^args)
{
    hConsole = GetStdHandle (STD_OUTPUT_HANDLE); 
    String^ fileName = "textfile.txt";
    StreamWriter^ sw = gcnew StreamWriter(fileName);
    gotoxy ( 50, 75 );
    sw->WriteLine("This line is not being written to the 50th column,and 75th row");
    //Console::WriteLine("This displays at the corrct position");
    sw->Close();    
    return 0;
 }

I saw a way of mirroring the console to a log, but is there a way to write to a file without showing on the console? (Mirroring console output to a file)

Answer 1

Think of the console as a 80x25 character array. When you were doing SetConsoleCursorPosition, you were moving to a spot within that array, and then writing text to that location. Now, do that same thing with a buffer you manage manually, and then write the buffer out to disk.

Something along these lines:

const int ROWS = 25;
const int COLUMNS = 80;
array<Char> buffer = gcnew array<Char>(COLUMNS * ROWS);
int activeLoc;

void SetBufferCursorPosition(int x, int y)
{
    activeLoc = y * COLUMNS + x;
}

void WriteBufferChar(Char c)
{
    buffer[activeLoc++] = c;
}

void WriteBufferString(String^ s)
{
    Array::Copy(buffer, activeLoc, s->ToCharArray(), 0, s->Length);
    activeLoc += s->Length;
}

void WriteToDisk()
{
    // Using StreamWriter without the '^', which gives us stack semantics, 
    // the C++/CLI rough equivalent of C#'s using statement.
    StreamWriter sw("textfile.txt");
    for(int i = 0; i < ROWS; i++)
    {
        sw->WriteLine(buffer, i * COLUMNS, COLUMNS);
    }
}

• Char instead of char because we want the .Net System::Char, not the C++ unmanaged char. Char is 16 bits wide, char is only 8.
• I used a one-dimensional array of size 80*25 instead of a two dimensional because I think you want to simulate the behavior where a long string printed at the end of the line would continue to the next line.
• I didn't handle buffer overruns. In particular, you might want to do something with that in WriteBufferString.
  • You could copy the portion of the string that doesn't overrun.
  • You could manually wrap to the beginning of the buffer (i.e., the top of the screen).
  • You could move all characters backwards in the array by 80 characters (i.e., scrolling the screen by one line).