A resource is an object that cannot be defined in C++
terms but that is needed to complete a program. In the strict sense, it is
text that contains a series of terms or words that the program can
interpret through code. Examples of resources are menus, icons, cursors,
dialog boxes, sounds, etc.
There are various means of creating a resource and the
approach you use depends on the resource. For example, some resources are
completely text-based, such is the case for the String Table or the
Accelerator Table. Some other resources must be designed, such is the case
for icons and cursors. Some other resources can be imported from another,
more elaborate application, such is the case for high graphic pictures.
Yet some resources can be a combination of different resources. |
As mentioned already, resources are not a C++ concept
but a Microsoft Windows theory of completing an application. Therefore,
the programming environment you use may or may not provide you with the
means of creating certain resources. Some environments like Borland C++
Builder or Visual C++ (6 and .NET) are complete with (almost) anything you
need to create (almost) any type of resources. Some other environments may
appear incomplete, allowing you to create only some resources, the other
resources must be created using an external application not provided; such
is the case for C++BuilderX. Upon creating a resource,
you must save it. Some resources are created as their own file, such is
the case for pictures, icons, cursors, sound, etc. Each of these resources
has a particular extension depending on the resource. After creating the
resources, you must add them to a file that has the extension .rc. Some
resources are listed in this file using a certain syntax. That's the case
for icons, cursors, pictures, sounds, etc. Some other resources must be
created directly in this file because these resources are text-based;
that's the case for menus, strings, accelerators, version numbers, etc. After
creating the resource file, you must compile it. Again, some environments,
such as Microsoft Visual C++, do this automatically when you execute the
application. Some other environments may require you to explicitly compile
the resource. That's the case for Borland C++ Builder and C++BuilderX.
(The fact that these environments require that you compile the resource is
not an anomaly. For example, if you create a Windows application that is
form-based in C++ Builder 6 or Delphi, you can easily add the resources
and they are automatically compiled and added to the application. If you
decide to create a Win32 application, C++ Builder believes that you want
to completely control your application; so, it lets you decide when and
how to compile a resource. This means that it simply gives you more
control).
Practical Learning: Introducing Windows Resources
|
|
- If you are using Borland C++ Builder, create a new Win32 application using Console Wizard as we did in
Lesson 1
- Save the project as Resources1 in a new folder called Resources1
- Save
the unit as Exercise.cpp
- If you are using Microsoft Visual C++,
- Create a new Win32 Application as done the previous time. Save the project as
Resources1 and
- Create a new C++ Source file named Exercise.cpp
- Implement the source file as follows(for Borland C++ Builder, only
add the parts that are not in the code):
//---------------------------------------------------------------------------
#include <windows.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
//---------------------------------------------------------------------------
LPCTSTR ClsName = L"FundApp";
LPCTSTR WndName = L"Resources Fundamentals";
LRESULT CALLBACK WndProcedure(HWND hWnd, UINT uMsg,
WPARAM wParam, LPARAM lParam);
//---------------------------------------------------------------------------
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
MSG Msg;
HWND hWnd;
WNDCLASSEX WndClsEx;
// Create the application window
WndClsEx.cbSize = sizeof(WNDCLASSEX);
WndClsEx.style = CS_HREDRAW | CS_VREDRAW;
WndClsEx.lpfnWndProc = WndProcedure;
WndClsEx.cbClsExtra = 0;
WndClsEx.cbWndExtra = 0;
WndClsEx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
WndClsEx.hCursor = LoadCursor(NULL, IDC_ARROW);
WndClsEx.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
WndClsEx.lpszMenuName = NULL;
WndClsEx.lpszClassName = ClsName;
WndClsEx.hInstance = hInstance;
WndClsEx.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
// Register the application
RegisterClassEx(&WndClsEx);
// Create the window object
hWnd = CreateWindowEx(0,
ClsName,
WndName,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL,
NULL,
hInstance,
NULL);
// Find out if the window was created
if( !hWnd ) // If the window was not created,
return FALSE; // stop the application
// Display the window to the user
ShowWindow(hWnd, nCmdShow);// SW_SHOWNORMAL);
UpdateWindow(hWnd);
// Decode and treat the messages
// as long as the application is running
while( GetMessage(&Msg, NULL, 0, 0) )
{
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
return Msg.wParam;
}
//---------------------------------------------------------------------------
LRESULT CALLBACK WndProcedure(HWND hWnd, UINT Msg,
WPARAM wParam, LPARAM lParam)
{
switch(Msg)
{
case WM_DESTROY:
PostQuitMessage(WM_QUIT);
break;
default:
// Process the left-over messages
return DefWindowProc(hWnd, Msg, wParam, lParam);
}
// If something was not done, let it go
return 0;
}
//---------------------------------------------------------------------------
- Execute the application to test it
|
|