Win32 Console Applications - Part 4.
So far all of the console output I have shown have been in black and white. This part of the tutorial demonstrates how I did this!
Now, before you start getting all excited, let me say from the start, the range of colours available is not huge. You may want to compile and run these programs for yourself, the .jpg's I use on the web site show up fine on the monitor connected to the machine I am using now, but when viewed on my older machine, appear very dark and fuzzy.
We will use the Win32 API function SetConsoleTextAttribute(). This function takes 2 arguments. The first is the standard output handle, we have covered that already. The second is a 16bit WORD bit mask containg 0 or more bits.
It is not necessary to concern yourself over the values of the various bits. There are a series of constants defined in windows.h, (actually in wincon.h but that is included in windows.h), which symbolically allow you to build the required value, it is very easy. Look at this program and it's output.
#include <windows.h>
#include <iostream.h>
int main()
{
HANDLE hOut;
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hOut,
FOREGROUND_RED);
cout << "This text is red." << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_GREEN);
cout << "This text is green." << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_BLUE);
cout << "This text is blue." << endl;
return 0;
}
A dingy red green and blue. Being bits, they can be OR'd together to make combinations, the next program shows the result of OR'ing the bits together.
#include <windows.h>
#include <iostream.h>
int main()
{
HANDLE hOut;
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hOut,
FOREGROUND_RED |
FOREGROUND_GREEN);
cout << "This text is yellow." << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_GREEN |
FOREGROUND_BLUE);
cout << "This text is cyan." << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_BLUE |
FOREGROUND_RED);
cout << "This text is magenta." << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_RED |
FOREGROUND_GREEN |
FOREGROUND_BLUE);
cout << "This text is white." << endl;
return 0;
}
The bitwise OR operator "|" combines the requested bits. Thus red | green gives yellow, green | blue gives cyan, blue | red gives magenta and all three combined gives white. The order is unimportant, red | blue gives the same result as blue | red.
Another bit that can be OR'd in is FOREGROUND_INTENSITY. All the colours I've shown so far are a bit dim, adding the intensity bit brightens them up. This program shows the use and results of the intensity bit.
#include <windows.h>
#include <iostream>
using namespace std;
int main()
{
HANDLE hOut;
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hOut,
FOREGROUND_RED);
cout << "Red " << flush;
SetConsoleTextAttribute(hOut,
FOREGROUND_RED |
FOREGROUND_INTENSITY);
cout << "Red" << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_GREEN);
cout << "Green " << flush;
SetConsoleTextAttribute(hOut,
FOREGROUND_GREEN |
FOREGROUND_INTENSITY);
cout << "Green" << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_BLUE);
cout << "Blue " << flush;
SetConsoleTextAttribute(hOut,
FOREGROUND_BLUE |
FOREGROUND_INTENSITY);
cout << "Blue" << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_RED |
FOREGROUND_GREEN);
cout << "Yellow " << flush;
SetConsoleTextAttribute(hOut,
FOREGROUND_RED |
FOREGROUND_GREEN |
FOREGROUND_INTENSITY);
cout << "Yellow" << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_GREEN |
FOREGROUND_BLUE);
cout << "Cyan " << flush;
SetConsoleTextAttribute(hOut,
FOREGROUND_GREEN |
FOREGROUND_BLUE |
FOREGROUND_INTENSITY);
cout << "Cyan" << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_BLUE |
FOREGROUND_RED);
cout << "Magenta " << flush;
SetConsoleTextAttribute(hOut,
FOREGROUND_BLUE |
FOREGROUND_RED |
FOREGROUND_INTENSITY);
cout << "Magenta" << endl;
SetConsoleTextAttribute(hOut,
FOREGROUND_RED |
FOREGROUND_GREEN |
FOREGROUND_BLUE);
cout << "White " << flush;
SetConsoleTextAttribute(hOut,
FOREGROUND_RED |
FOREGROUND_GREEN |
FOREGROUND_BLUE |
FOREGROUND_INTENSITY);
cout << "White" << endl;
return 0;
}
Black is also a colour, and is made by having no foreground colors set, no red and no green and no blue is nothing, is black. So in all we have 15 colours. I did warn you not to get excited.
In addition to changing the foreground colour, we can also change the background colour. The same colours are available.
#include <windows.h>
#include <iostream>
using namespace std;
int main()
{
HANDLE hOut;
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hOut,
BACKGROUND_RED);
cout << "Red " << flush;
SetConsoleTextAttribute(hOut,
BACKGROUND_RED |
BACKGROUND_INTENSITY);
cout << "Red " << endl;
SetConsoleTextAttribute(hOut,
BACKGROUND_GREEN);
cout << "Green " << flush;
SetConsoleTextAttribute(hOut,
BACKGROUND_GREEN |
BACKGROUND_INTENSITY);
cout << "Green " << endl;
SetConsoleTextAttribute(hOut,
BACKGROUND_BLUE);
cout << "Blue " << flush;
SetConsoleTextAttribute(hOut,
BACKGROUND_BLUE |
BACKGROUND_INTENSITY);
cout << "Blue " << endl;
SetConsoleTextAttribute(hOut,
BACKGROUND_RED |
BACKGROUND_GREEN);
cout << "Yellow " << flush;
SetConsoleTextAttribute(hOut,
BACKGROUND_RED |
BACKGROUND_GREEN |
BACKGROUND_INTENSITY);
cout << "Yellow " << endl;
SetConsoleTextAttribute(hOut,
BACKGROUND_GREEN |
BACKGROUND_BLUE);
cout << "Cyan " << flush;
SetConsoleTextAttribute(hOut,
BACKGROUND_GREEN |
BACKGROUND_BLUE |
BACKGROUND_INTENSITY);
cout << "Cyan " << endl;
SetConsoleTextAttribute(hOut,
BACKGROUND_BLUE |
BACKGROUND_RED);
cout << "Magenta " << flush;
SetConsoleTextAttribute(hOut,
BACKGROUND_BLUE |
BACKGROUND_RED |
BACKGROUND_INTENSITY);
cout << "Magenta " << endl;
SetConsoleTextAttribute(hOut,
BACKGROUND_RED |
BACKGROUND_GREEN |
BACKGROUND_BLUE);
cout << "White " << flush;
SetConsoleTextAttribute(hOut,
BACKGROUND_RED |
BACKGROUND_GREEN |
BACKGROUND_BLUE |
BACKGROUND_INTENSITY);
cout << "White " << endl;
return 0;
}
A space character will just show up as the coloured background. That is how I made the Danish flag at the top of this section.
It is possible to set both the foreground and background colours, here for example, I set the background to low intensity yellow and the foreground to high intensity cyan.
#include <windows.h>
#include <iostream>
using namespace std;
int main()
{
HANDLE hOut;
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hOut,
BACKGROUND_GREEN |
BACKGROUND_RED |
FOREGROUND_GREEN |
FOREGROUND_BLUE |
FOREGROUND_INTENSITY);
cout << "Intense Cyan on yellow background." << endl;
return 0;
}
You can use any combination you like of the available colours, although obviously, setting the foreground and background colour to the same value is a little pointless. Remember also, that setting no foreground bits gives black text, and no background bits, a black background.
A common "gotcha" is forgetting that both the foreground AND background must be set at each call. If you want to write first in green then in red on a yellow background you must set the background in both calls, otherwise the function assumes you want to return to a black background.
#include <windows.h>
#include <iostream>
using namespace std;
int main()
{
HANDLE hOut;
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hOut,
BACKGROUND_GREEN |
BACKGROUND_RED |
FOREGROUND_GREEN |
FOREGROUND_INTENSITY);
cout << "Green " << flush;
SetConsoleTextAttribute(hOut,
BACKGROUND_GREEN |
BACKGROUND_RED |
FOREGROUND_RED |
FOREGROUND_INTENSITY);
cout << "Red" << endl;
return 0;
}
If you are going to do a lot of colour changes, rather than OR'ing everything together each time, you may prefer to do it once using a #define. Here, I #define FRI to be Foreground Red Intense, BC to be Background Cyan, FW to Foreground White and BNULL to Background "Nothing" i.e. black. Using these in a small test program does not really make much difference, but in large programs with many colour changes, the code can be much shorter using this technique.
#include <windows.h>
#include <iostream>
using namespace std;
#define FRI FOREGROUND_RED |\
FOREGROUND_INTENSITY
#define FW FOREGROUND_RED |\
FOREGROUND_GREEN |\
FOREGROUND_BLUE
#define BC BACKGROUND_GREEN |\
BACKGROUND_BLUE
#define BNULL 0
int main()
{
HANDLE hOut;
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
cout << "Normal " << flush;
SetConsoleTextAttribute(hOut,
FRI | BC);
cout <<"coloured" << flush;
SetConsoleTextAttribute(hOut,
FW | BNULL);
cout << " and back." << endl;
return 0;
}
Note the backslashes in the #defines, this is necessary when extending a #define onto more than one line. You don't have to do this of course if you are happy with long lines/horizontal scrolling. Finally, in this section, here is a header file that contains a full set of #defines. To use it, copy the code and paste it into a file with a .h extension, say "ShortColours.h" for example. Put a copy of this file into the same directory as your code file, and include it into your program like this.
#include "ShortColours.h"
Enclosing the header file name in quotes rather than a less than/greater than pair tells the compiler to look in the same directory as the code.
#ifndef SHORTCOLOURS_H
#define SHORTCOLOURS_H
#define FW FOREGROUND_RED | \
FOREGROUND_GREEN | \
FOREGROUND_BLUE
#define FR FOREGROUND_RED
#define FG FOREGROUND_GREEN
#define FB FOREGROUND_BLUE
#define FY FOREGROUND_RED | \
FOREGROUND_GREEN
#define FC FOREGROUND_GREEN | \
FOREGROUND_BLUE
#define FM FOREGROUND_BLUE | \
FOREGROUND_RED
#define FWI FOREGROUND_RED | \
FOREGROUND_GREEN | \
FOREGROUND_BLUE | \
FOREGROUND_INTENSITY
#define FRI FOREGROUND_RED | \
FOREGROUND_INTENSITY
#define FGI FOREGROUND_GREEN | \
FOREGROUND_INTENSITY
#define FBI FOREGROUND_BLUE | \
FOREGROUND_INTENSITY
#define FYI FOREGROUND_RED | \
FOREGROUND_GREEN | \
FOREGROUND_INTENSITY
#define FCI FOREGROUND_GREEN | \
FOREGROUND_BLUE | \
FOREGROUND_INTENSITY
#define FMI FOREGROUND_BLUE | \
FOREGROUND_RED | \
FOREGROUND_INTENSITY
#define FNULL 0
#define BW BACKGROUND_RED | \
BACKGROUND_GREEN | \
BACKGROUND_BLUE
#define BR BACKGROUND_RED
#define BG BACKGROUND_GREEN
#define BB BACKGROUND_BLUE
#define BY BACKGROUND_RED | \
BACKGROUND_GREEN
#define BC BACKGROUND_GREEN | \
BACKGROUND_BLUE
#define BM BACKGROUND_BLUE | \
BACKGROUND_RED
#define BWI BACKGROUND_RED | \
BACKGROUND_GREEN | \
BACKGROUND_BLUE | \
BACKGROUND_INTENSITY
#define BRI BACKGROUND_RED | \
BACKGROUND_INTENSITY
#define BGI BACKGROUND_GREEN | \
BACKGROUND_INTENSITY
#define BBI BACKGROUND_BLUE | \
BACKGROUND_INTENSITY
#define BYI BACKGROUND_RED | \
BACKGROUND_GREEN | \
BACKGROUND_INTENSITY
#define BCI BACKGROUND_GREEN | \
BACKGROUND_BLUE | \
BACKGROUND_INTENSITY
#define BMI BACKGROUND_BLUE | \
BACKGROUND_RED | \
BACKGROUND_INTENSITY
#define BNULL 0
#endif
This program produces the same output as the last.
#include <windows.h>
#include <iostream>
#include "ShortColours.h"
using namespace std;
int main()
{
HANDLE hOut;
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
cout << "Normal " << flush;
SetConsoleTextAttribute(hOut,
FRI | BC);
cout <<"coloured" << flush;
SetConsoleTextAttribute(hOut,
FW | BNULL);
cout << " and back." << endl;
return 0;
}
The colour support is not great, but at the end of the day, it can be good enough. Consider, there are probably many of you that have played, or at least seen "BattleChess", where the pieces animated battle when one captured another. I bet nobody played it for long, because after you've seen the animations, they simply slow the game down, and the AI behind the graphics was actually not very good.
You build a really good chess playing AI and put it behind a simple interface like this, people will use it over and over, because, it is good enough to get the job done.
In part 2 of the tutorial, I showed you how to use ReadConsoleOutputCharacter() to retrieve the characters at one or more screen buffer locations. By itself, it is not capable of recovering the foreground and background attributes those characters were written with. This information is also available, the API routine used is ReadConsoleOutputAttribute(), and is really very similar to ReadConsoleOutputCharacter(). The prototype is shown here.
BOOL ReadConsoleOutputAttribute(
HANDLE hConsoleOutput,
LPWORD lpAttribute,
DWORD nLength,
COORD dwReadCoord,
LPDWORD lpNumberOfAttrsRead
);
This program sets the foreground colout to FOREGROUND_GREEN | FOREGROUND_RED and outputs a string. It then uses ReadConsoleOutputAttribute() to retrieve the attribute of the character at (4,0). The result is 6, this is because FOREGROUND_GREEN is defined to have the value 0x0002 and FOREGROUND_RED 0x0004. 2+4=6. It may be tempting to use the numerical values rather than the defined constants, but this is not a good idea. At some time in the future, MicroSoft may change the values associated with the constants, (unlikely, but a reserved possibility). Using the constants, the code will still work, use the values and the results may be unpredictable.
#include <windows.h>
#include <iostream.h>
int main()
{
HANDLE hOut;
WORD Attribute;
COORD Where;
unsigned long NumRead;
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hOut,
FOREGROUND_GREEN |
FOREGROUND_RED);
cout << "This text is yellow." << endl;
Where.X = 4;
Where.Y = 0;
ReadConsoleOutputAttribute(hOut,
&Attribute,
1,
Where,
&NumRead);
cout << "Attribute is " << Attribute << endl;
return 0;
}
The output looks like this.
In the next part of the tutorial, we'll investigate keyboard and mouse events.