void __fastcall TForm1::ApplicationEvents1Message(tagMSG &Msg,
      bool &Handled)
{
 // Memo1->Lines->Add(Msg.wParam);
  const nStep = 1;
  switch(Msg.wParam)
    {
    case 40: Button1->Top += nStep;
             break;
    case 38: Button1->Top -= nStep;
             break;
    case 37: Button1->Left -= nStep;
             break;
    case 39: Button1->Left += nStep;
             break;

    case 83: Button2->Top += nStep;
             break;
    case 87: Button2->Top -= nStep;
             break;
    case 65: Button2->Left -= nStep;
             break;
    case 68: Button2->Left += nStep;
             break;

}

typedef struct {
	int x, y;
	bool b;
} RMove;

RMove moving[2];

void __fastcall TForm1::ApplicationEvents1Message(tagMSG &Msg, bool &Handled)
{
	switch(Msg.message) {
		case WM_KEYDOWN:
			// Ну, ты же понимаешь, что все это можно записать и намного короче,
			// добавив одну-единственную функцию, правда? Это - просто пример...
			switch(Msg.wParam) {
				case 40:
				{
					moving[0].x = 0; moving[0].y = 1;
					Handled = moving[0].b = true; break;
				}
				case 38:
				{
					moving[0].x = 0; moving[0].y = -1;
					Handled = moving[0].b = true; break;
				}
				case 37:
				{
					moving[0].x = -1; moving[0].y = 0;
					Handled = moving[0].b = true; break;
				}
				case 39:
				{
					moving[0].x = 1; moving[0].y = 0;
					Handled = moving[0].b = true; break;
				}

				case 83:
				{
					moving[1].x = 0; moving[1].y = 1;
					Handled = moving[1].b = true;	break;
				}
				case 87:
				{
					moving[1].x = 0; moving[1].y = -1;
					Handled = moving[1].b = true; break;
				}
				case 65:
				{
					moving[1].x = -1; moving[1].y = 0;
					Handled = moving[1].b = true; break;
				}
				case 68:
				{
					moving[1].x = 1; moving[1].y = 0;
					Handled = moving[1].b = true; break;
				}
			}

		break;
		case WM_KEYUP:
			switch(Msg.wParam) {
				case 40: case 38:
				case 37: case 39:
				{
					Handled = true;
					moving[0].b = false; break;
				}
				case 83: case 87:
				case 65: case 68:
				{
					Handled = true;
					moving[1].b = false; break;
				}
			}

		break;
	}
}


void MoveButton(TButton *button, RMove r) {
	const int nStep = 1;
	button->Left += nStep * r.x;
	button->Top += nStep * r.y;
}


// Таймер установлен на 0,1 секунды...
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
	if(moving[0].b) {
		MoveButton(Button1, moving[0]);
	}
	if(moving[1].b) {
		MoveButton(Button2, moving[1]);
	}
}

  ...
}
while(!Terminated);

for(int i = num_threads - 1; i >= 0; i--) {
  thr[i] -> Terminate();
}

const int dirLt = 0;
const int dirRg = 1;
const int dirUp = 2;
const int dirDn = 3;

// Делаем множество направлений
typedef Set<int, dirLt, dirDn> TDir;

class TMyThread : public TThread
{
private:
	TButton *btn;
	TDir FState;
protected:
	void __fastcall Execute();
public:
	__property TDir GetState = {read = FState, nodefault};
	__fastcall bool SetState(TDir& state) {
		FState = state;
		if(state.Empty())
		{
			Suspend();
		}
		else
		{
			Resume();
		}
		return true;
	}

	__fastcall TMyThread(TButton *button, bool CreateSuspended):
		TThread(CreateSuspended)
	{
		btn = button;
	}
};

const int num_threads = 2;
TMyThread *thr[num_threads];


void __fastcall TMyThread::Execute()
{
	const int nStep = 2;

	do {

		int dx = 0, dy = 0;
		for(int dir = dirLt; dir <= dirDn; dir++) {
			// если текущее направление присутствует во множестве
			if(FState.Contains(dir)) {
				// то высчитываем, куда двигаться...
				switch(dir) {
					case dirLt: dx = -nStep; break;
					case dirRg: dx = +nStep; break;
					case dirUp: dy = -nStep; break;
					case dirDn: dy = +nStep; break;
				}

			}
		}

		btn->Left += dx; btn->Top += dy;
		Sleep(5);
	}
	while(!Terminated);
}

// ...

int key_pressed(unsigned int key, int& dir)
{
	unsigned codes[num_threads][4] = {
		{37, 39, 38, 40}, {65, 68, 87, 83}
	};

	for(int i = 0; i < num_threads; i++) {
		for(int j = 0; j < 4; j++) {
			if(codes[i][j] == key) {
				dir = j; return i;
			}
		}
	}
	return -1;
}


void __fastcall TForm1::ApplicationEvents1Message(tagMSG &Msg, bool &Handled)
{
	int thread_n, dir;

	switch(Msg.message) {
		case WM_KEYDOWN:
			if((thread_n = key_pressed(Msg.wParam, dir)) >= 0) {
				Handled = thr[thread_n]->SetState(
					thr[thread_n]->GetState << dir  // добавляем направление во множество
				);
			}
			break;
		case WM_KEYUP:
			if((thread_n = key_pressed(Msg.wParam, dir)) >= 0) {
				Handled = thr[thread_n]->SetState(
					thr[thread_n]->GetState >> dir // "изымаем" направление ...
				);
			}
			break;
	}
}

__property TDir GetState = {read = FState, nodefault};

thr[thread_n]->GetState << dir  

Цитата(volvo @ 2.02.2008 4:22)

TDir GetState() {return FState;};

TDir GetState() {return FState;};

				Handled = thr[thread_n]->SetState(
					thr[thread_n]->GetState() >> dir // <--- вызов функции GetState
				);