renamed Graphics class to Gfx and Parallaction::_graphics to Parallaction::_gfx to shorten lines and avoid aliasing with framework's Graphics

svn-id: r26111

16 files changed, 363 insertions, 363 deletions

diff --git a/engines/parallaction/animation.cpp b/engines/parallaction/animation.cpp
index 45aa0e71c1..e4971743eb 100644
--- a/engines/parallaction/animation.cpp
+++ b/engines/parallaction/animation.cpp
@@ -108,7 +108,7 @@ Animation *Parallaction::parseAnimation(Script& script, Node *list, char *name)
 			}
 		}
 		if (!scumm_stricmp(_tokens[0], "label")) {
-			_vm->_graphics->makeCnvFromString(&vD0->_zone._label._cnv, _tokens[1]);
+			_vm->_gfx->makeCnvFromString(&vD0->_zone._label._cnv, _tokens[1]);
 		}
 		if (!scumm_stricmp(_tokens[0], "flags")) {
 			uint16 _si = 1;
@@ -129,7 +129,7 @@ Animation *Parallaction::parseAnimation(Script& script, Node *list, char *name)
 			}
 
 			_disk->loadFrames(vC8, &vD0->_cnv);
-//			int16 _ax = _vm->_graphics->loadCnv(vC8, &vD0->_cnv);
+//			int16 _ax = _vm->_gfx->loadCnv(vC8, &vD0->_cnv);
 //			if (_ax == -1) exit(-1);
 		}
 		if (!scumm_stricmp(_tokens[0], "position")) {
@@ -171,7 +171,7 @@ void freeAnimations() {
 	Animation *v4 = (Animation*)_animations._next;
 	while (v4) {
 		freeScript(v4->_program);
-		_vm->_graphics->freeCnv(&v4->_cnv);
+		_vm->_gfx->freeCnv(&v4->_cnv);
 		v4 = (Animation*)v4->_zone._node._next;
 	}
 
@@ -199,10 +199,10 @@ void jobDisplayAnimations(void *parm, Job *j) {
 			if (v18->_zone._flags & kFlagsNoMasked)
 				_si = 3;
 			else
-				_si = _vm->_graphics->queryMask(v18->_zone.pos._position._y + v18->_cnv._height);
+				_si = _vm->_gfx->queryMask(v18->_zone.pos._position._y + v18->_cnv._height);
 
 //			printf("jobDisplayAnimations %s, x: %i, y: %i, w: %i, h: %i\n", v18->_zone._name, v18->_zone.pos._position._x, v18->_zone.pos._position._y, v14._width, v14._height);
-			_vm->_graphics->blitCnv(&v14, v18->_zone.pos._position._x, v18->_zone.pos._position._y, _si, Graphics::kBitBack, Graphics::kMask0);
+			_vm->_gfx->blitCnv(&v14, v18->_zone.pos._position._x, v18->_zone.pos._position._y, _si, Gfx::kBitBack, Gfx::kMask0);
 
 		}
 
@@ -234,7 +234,7 @@ void jobEraseAnimations(void *arg_0, Job *j) {
 		if (((a->_zone._flags & kFlagsActive) == 0) && ((a->_zone._flags & kFlagsRemove) == 0)) continue;
 
  // 	  printf("jobEraseAnimations %s, x: %i, y: %i, w: %i, h: %i\n", a->_zone._name, a->_zone.pos._oldposition._x, a->_zone.pos._oldposition._y, a->_cnv._width, a->_cnv._height);
-		_vm->_graphics->restoreBackground(a->_zone.pos._oldposition._x, a->_zone.pos._oldposition._y, a->_cnv._width, a->_cnv._height);
+		_vm->_gfx->restoreBackground(a->_zone.pos._oldposition._x, a->_zone.pos._oldposition._y, a->_cnv._width, a->_cnv._height);
 		if (arg_0) {
 			a->_zone.pos._oldposition._x = a->_zone.pos._position._x;
 			a->_zone.pos._oldposition._y = a->_zone.pos._position._y;
@@ -575,12 +575,12 @@ void jobRunScripts(void *parm, Job *j) {
 				v18._data1 = NULL; // inst->_opBase._a->_cnv.field_8[inst->_opBase._a->_frame];
 
 				if (inst->_flags & kInstMaskedPut) {
-					uint16 _si = _vm->_graphics->queryMask(inst->_opB._value);
-					_vm->_graphics->blitCnv(&v18, inst->_opA._value, inst->_opB._value, _si, Graphics::kBitBack, Graphics::kMask0 );
-					_vm->_graphics->blitCnv(&v18, inst->_opA._value, inst->_opB._value, _si, Graphics::kBit2, Graphics::kMask0 );
+					uint16 _si = _vm->_gfx->queryMask(inst->_opB._value);
+					_vm->_gfx->blitCnv(&v18, inst->_opA._value, inst->_opB._value, _si, Gfx::kBitBack, Gfx::kMask0 );
+					_vm->_gfx->blitCnv(&v18, inst->_opA._value, inst->_opB._value, _si, Gfx::kBit2, Gfx::kMask0 );
 				} else {
-					_vm->_graphics->flatBlitCnv(&v18, inst->_opA._value, inst->_opB._value, Graphics::kBitBack, v18._data1);
-					_vm->_graphics->flatBlitCnv(&v18, inst->_opA._value, inst->_opB._value, Graphics::kBit2, v18._data1);
+					_vm->_gfx->flatBlitCnv(&v18, inst->_opA._value, inst->_opB._value, Gfx::kBitBack, v18._data1);
+					_vm->_gfx->flatBlitCnv(&v18, inst->_opA._value, inst->_opB._value, Gfx::kBit2, v18._data1);
 				}
 				break;
 
diff --git a/engines/parallaction/callables.cpp b/engines/parallaction/callables.cpp
index d77eb3b4d4..cdbde2367e 100644
--- a/engines/parallaction/callables.cpp
+++ b/engines/parallaction/callables.cpp
@@ -64,14 +64,14 @@ void _c_score(void *parm) {
 
 void _c_fade(void *parm) {
 	byte palette[PALETTE_SIZE];
-	_vm->_graphics->getBlackPalette(palette);
-	_vm->_graphics->setPalette(palette);
+	_vm->_gfx->getBlackPalette(palette);
+	_vm->_gfx->setPalette(palette);
 
-	_vm->_graphics->swapBuffers();
+	_vm->_gfx->swapBuffers();
 
 	for (uint16 _di = 0; _di < 64; _di++) {
-		_vm->_graphics->fadePalette(palette);
-		_vm->_graphics->setPalette(palette);
+		_vm->_gfx->fadePalette(palette);
+		_vm->_gfx->setPalette(palette);
 	}
 
 	_vm->waitTime( 1 );
@@ -207,7 +207,7 @@ void _c_onMouse(void *parm) {
 
 void _c_setMask(void *parm) {
 
-	_vm->_graphics->intGrottaHackMask();
+	_vm->_gfx->intGrottaHackMask();
 
 	return;
 }
@@ -225,16 +225,16 @@ void _c_frankenstein(void *parm) {
 		pal0[i*3+2] = 0;
 	}
 
-	_vm->_graphics->getBlackPalette(pal1);
+	_vm->_gfx->getBlackPalette(pal1);
 
 	for (uint16 _di = 0; _di < 30; _di++) {
 		g_system->delayMillis(20);
-		_vm->_graphics->setPalette(pal0);
+		_vm->_gfx->setPalette(pal0);
 		g_system->delayMillis(20);
-		_vm->_graphics->setPalette(pal1);
+		_vm->_gfx->setPalette(pal1);
 	}
 
-	_vm->_graphics->setPalette(_palette);
+	_vm->_gfx->setPalette(_palette);
 
 	return;
 }
@@ -282,41 +282,41 @@ void _c_finito(void *parm) {
 	cleanInventory();
 	refreshInventory(_vm->_characterName);
 
-	_vm->_graphics->palUnk0(_palette);
+	_vm->_gfx->palUnk0(_palette);
 
 	if (gameCompleted) {
-		_vm->_graphics->setFont("slide");
-		_vm->_graphics->_proportionalFont = false;
-		uint16 _ax = _vm->_graphics->getStringWidth(v4C[_language]);
-		_vm->_graphics->displayString((SCREEN_WIDTH - _ax)/2, 70, v4C[_language]);
-		_ax = _vm->_graphics->getStringWidth(v3C[_language]);
-		_vm->_graphics->displayString((SCREEN_WIDTH - _ax)/2, 100, v3C[_language]);
-		_ax = _vm->_graphics->getStringWidth(v2C[_language]);
-		_vm->_graphics->displayString((SCREEN_WIDTH - _ax)/2, 130, v2C[_language]);
-		_ax = _vm->_graphics->getStringWidth(v1C[_language]);
-		_vm->_graphics->displayString((SCREEN_WIDTH - _ax)/2, 160, v1C[_language]);
-
-		_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBitBack);
-		_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBit2);
+		_vm->_gfx->setFont("slide");
+		_vm->_gfx->_proportionalFont = false;
+		uint16 _ax = _vm->_gfx->getStringWidth(v4C[_language]);
+		_vm->_gfx->displayString((SCREEN_WIDTH - _ax)/2, 70, v4C[_language]);
+		_ax = _vm->_gfx->getStringWidth(v3C[_language]);
+		_vm->_gfx->displayString((SCREEN_WIDTH - _ax)/2, 100, v3C[_language]);
+		_ax = _vm->_gfx->getStringWidth(v2C[_language]);
+		_vm->_gfx->displayString((SCREEN_WIDTH - _ax)/2, 130, v2C[_language]);
+		_ax = _vm->_gfx->getStringWidth(v1C[_language]);
+		_vm->_gfx->displayString((SCREEN_WIDTH - _ax)/2, 160, v1C[_language]);
+
+		_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBitBack);
+		_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBit2);
 		waitUntilLeftClick();
 
 		strcpy(_vm->_location._name, "estgrotta.drki");
 
 		_engineFlags |= kEngineChangeLocation;
 	} else {
-		_vm->_graphics->setFont("slide");
-		_vm->_graphics->_proportionalFont = false;
-		uint16 _ax = _vm->_graphics->getStringWidth(v8C[_language]);
-		_vm->_graphics->displayString((SCREEN_WIDTH - _ax)/2, 70, v8C[_language]);
-		_ax = _vm->_graphics->getStringWidth(v7C[_language]);
-		_vm->_graphics->displayString((SCREEN_WIDTH - _ax)/2, 100, v7C[_language]);
-		_ax = _vm->_graphics->getStringWidth(v6C[_language]);
-		_vm->_graphics->displayString((SCREEN_WIDTH - _ax)/2, 130, v6C[_language]);
-		_ax = _vm->_graphics->getStringWidth(v5C[_language]);
-		_vm->_graphics->displayString((SCREEN_WIDTH - _ax)/2, 160, v5C[_language]);
-
-		_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBitBack);
-		_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBit2);
+		_vm->_gfx->setFont("slide");
+		_vm->_gfx->_proportionalFont = false;
+		uint16 _ax = _vm->_gfx->getStringWidth(v8C[_language]);
+		_vm->_gfx->displayString((SCREEN_WIDTH - _ax)/2, 70, v8C[_language]);
+		_ax = _vm->_gfx->getStringWidth(v7C[_language]);
+		_vm->_gfx->displayString((SCREEN_WIDTH - _ax)/2, 100, v7C[_language]);
+		_ax = _vm->_gfx->getStringWidth(v6C[_language]);
+		_vm->_gfx->displayString((SCREEN_WIDTH - _ax)/2, 130, v6C[_language]);
+		_ax = _vm->_gfx->getStringWidth(v5C[_language]);
+		_vm->_gfx->displayString((SCREEN_WIDTH - _ax)/2, 160, v5C[_language]);
+
+		_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBitBack);
+		_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBit2);
 		waitUntilLeftClick();
 
 		_vm->_menu->selectCharacter();
@@ -351,19 +351,19 @@ void _c_ridux(void *parm) {
 }
 
 void _c_testResult(void *parm) {
-	_vm->_graphics->swapBuffers();
+	_vm->_gfx->swapBuffers();
 	_vm->parseLocation("common");
 
-	_vm->_graphics->setFont("slide");
-	_vm->_graphics->_proportionalFont = false;
+	_vm->_gfx->setFont("slide");
+	_vm->_gfx->_proportionalFont = false;
 
-	uint16 _ax = _vm->_graphics->getStringWidth(_slideText[0]);
-	_vm->_graphics->displayString((SCREEN_WIDTH - _ax)/2, 38, _slideText[0]);
-	_ax = _vm->_graphics->getStringWidth(_slideText[1]);
-	_vm->_graphics->displayString((SCREEN_WIDTH - _ax)/2, 58, _slideText[1]);
+	uint16 _ax = _vm->_gfx->getStringWidth(_slideText[0]);
+	_vm->_gfx->displayString((SCREEN_WIDTH - _ax)/2, 38, _slideText[0]);
+	_ax = _vm->_gfx->getStringWidth(_slideText[1]);
+	_vm->_gfx->displayString((SCREEN_WIDTH - _ax)/2, 58, _slideText[1]);
 
-	_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBitBack);
-	_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBit2);
+	_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBitBack);
+	_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBit2);
 
 	return;
 }
diff --git a/engines/parallaction/dialogue.cpp b/engines/parallaction/dialogue.cpp
index dc76c43d11..4f112bc800 100644
--- a/engines/parallaction/dialogue.cpp
+++ b/engines/parallaction/dialogue.cpp
@@ -186,7 +186,7 @@ char *Parallaction::parseDialogueString(Script &script) {
 	} while (strlen(vD0) == 0);
 
 	vD0[strlen(vD0)-1] = '\0';	// deletes the trailing '0xA' inserted by parseNextLine
-								// this is critical for Graphics::displayBalloonString to work properly
+								// this is critical for Gfx::displayBalloonString to work properly
 
 	char *vCC = (char*)malloc(strlen(vD0)+1);
 	strcpy(vCC, vD0);
@@ -226,11 +226,11 @@ void runDialogue(SpeakData *data) {
 /*
 	// the only character which can have a dialogue inside the museum location is Dino
 	if (!scumm_stricmp(_name, "museum")) {
-		_vm->_graphics->freeCnv( &_characterFrames );
+		_vm->_gfx->freeCnv( &_characterFrames );
 		debugC(1, kDebugDialogue, "runDialogue: special trick for 'museum' location");
 	}
 */
-	_vm->_graphics->setFont("comic");
+	_vm->_gfx->setFont("comic");
 
 	Cnv v6E;
 	StaticCnv v5C, v48;
@@ -268,22 +268,22 @@ void runDialogue(SpeakData *data) {
 		if (scumm_stricmp(v60->_text, "NULL")) {
 			debugC(1, kDebugDialogue, "runDialogue: showing question '%s'", v60->_text);
 
-			_vm->_graphics->flatBlitCnv(
+			_vm->_gfx->flatBlitCnv(
 				&v5C,
 				QUESTION_CHARACTER_X,
 				QUESTION_CHARACTER_Y,
-				Graphics::kBitFront,
+				Gfx::kBitFront,
 				v5C._data1
 			);
 
-			_vm->_graphics->getStringExtent(
+			_vm->_gfx->getStringExtent(
 				v60->_text,
 				MAX_BALLOON_WIDTH,
 				&question_width,
 				&question_height
 			);
 
-			_vm->_graphics->drawBalloon(
+			_vm->_gfx->drawBalloon(
 				QUESTION_BALLOON_X,
 				QUESTION_BALLOON_Y,
 				question_width,
@@ -291,7 +291,7 @@ void runDialogue(SpeakData *data) {
 				v60->_mood & 0x10
 			);
 
-			_vm->_graphics->displayWrappedString(
+			_vm->_gfx->displayWrappedString(
 				v60->_text,
 				QUESTION_BALLOON_X,
 				QUESTION_BALLOON_Y,
@@ -300,7 +300,7 @@ void runDialogue(SpeakData *data) {
 			);
 
 			waitUntilLeftClick();
-			_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+			_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 		}
 
 		if (v60->_answers[0] == NULL) break;
@@ -322,7 +322,7 @@ void runDialogue(SpeakData *data) {
 				// display suitable answers
 				if (((v60->_yesFlags[_si] & v28) == v60->_yesFlags[_si]) && ((v60->_noFlags[_si] & ~v28) == v60->_noFlags[_si])) {
 
-					_vm->_graphics->getStringExtent(
+					_vm->_gfx->getStringExtent(
 						v60->_answers[_si],
 						MAX_BALLOON_WIDTH,
 						&_answerBalloonW[_si],
@@ -334,7 +334,7 @@ void runDialogue(SpeakData *data) {
 						v60->_answers[_si]
 					);
 
-					_vm->_graphics->drawBalloon(
+					_vm->_gfx->drawBalloon(
 						_answerBalloonX[_si],
 						_answerBalloonY[_si],
 						_answerBalloonW[_si],
@@ -344,7 +344,7 @@ void runDialogue(SpeakData *data) {
 
 					_answerBalloonY[_si+1] = 10 + _answerBalloonY[_si] + _answerBalloonH[_si];
 
-					askPassword = _vm->_graphics->displayWrappedString(
+					askPassword = _vm->_gfx->displayWrappedString(
 						v60->_answers[_si],
 						_answerBalloonX[_si],
 						_answerBalloonY[_si],
@@ -379,11 +379,11 @@ void runDialogue(SpeakData *data) {
 
 				debugC(1, kDebugDialogue, "runDialogue: showing answering face (%p)", (const void*)v48._data0);
 
-				_vm->_graphics->flatBlitCnv(
+				_vm->_gfx->flatBlitCnv(
 					&v48,
 					ANSWER_CHARACTER_X,
 					ANSWER_CHARACTER_Y,
-					Graphics::kBitFront,
+					Gfx::kBitFront,
 					v48._data1
 				);
 
@@ -404,9 +404,9 @@ void runDialogue(SpeakData *data) {
 
 					while (askPassword == true) {
 						strcpy(password, ".......");
-						_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+						_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
-						_vm->_graphics->drawBalloon(
+						_vm->_gfx->drawBalloon(
 							_answerBalloonX[0],
 							_answerBalloonY[0],
 							_answerBalloonW[0],
@@ -414,7 +414,7 @@ void runDialogue(SpeakData *data) {
 							1
 						);
 
-						_vm->_graphics->displayWrappedString(
+						_vm->_gfx->displayWrappedString(
 							v60->_answers[0],
 							_answerBalloonX[0],
 							_answerBalloonY[0],
@@ -422,15 +422,15 @@ void runDialogue(SpeakData *data) {
 							3
 						);
 
-						_vm->_graphics->flatBlitCnv(
+						_vm->_gfx->flatBlitCnv(
 							&v48,
 							ANSWER_CHARACTER_X,
 							ANSWER_CHARACTER_Y,
-							Graphics::kBitFront,
+							Gfx::kBitFront,
 							v48._data1
 						);
 
-						_vm->_graphics->displayBalloonString(
+						_vm->_gfx->displayBalloonString(
 							_answerBalloonX[0] + 5,
 							_answerBalloonY[0] + _answerBalloonH[0] - 15,
 							"> ",
@@ -451,7 +451,7 @@ void runDialogue(SpeakData *data) {
 							passwordLen++;
 							password[passwordLen] = '\0';
 
-							_vm->_graphics->displayBalloonString(
+							_vm->_gfx->displayBalloonString(
 								_answerBalloonX[0] + 5,
 								_answerBalloonY[0] + _answerBalloonH[0] - 15,
 								password,
@@ -475,7 +475,7 @@ void runDialogue(SpeakData *data) {
 
 				}
 
-				_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+				_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
 				v34 = v60->_commands[_di];
 				v60 = (Dialogue*)v60->_following._questions[_di];
@@ -494,10 +494,10 @@ void runDialogue(SpeakData *data) {
 	}
 
 	debugC(1, kDebugDialogue, "runDialogue: out of dialogue loop");
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
 	if (scumm_stricmp(data->_name, "yourself") || data->_name[0] == '\0') {
-		_vm->_graphics->freeCnv(&v6E);
+		_vm->_gfx->freeCnv(&v6E);
 		debugC(1, kDebugDialogue, "runDialogue: 2nd character head free'd");
 	}
 
@@ -542,7 +542,7 @@ int16 selectAnswer(Question *q, StaticCnv *cnv) {
 
 	if (numAvailableAnswers == 1) {
 
-		_vm->_graphics->displayWrappedString(
+		_vm->_gfx->displayWrappedString(
 			q->_answers[_di],
 			_answerBalloonX[_di],
 			_answerBalloonY[_di],
@@ -553,11 +553,11 @@ int16 selectAnswer(Question *q, StaticCnv *cnv) {
 		cnv->_data0 = _yourTalk._array[q->_answer_moods[_di] & 0xF];
 //		cnv->_data1 = _yourTalk.field_8[q->_answer_moods[_di] & 0xF];
 
-		_vm->_graphics->flatBlitCnv(
+		_vm->_gfx->flatBlitCnv(
 			cnv,
 			ANSWER_CHARACTER_X,
 			ANSWER_CHARACTER_Y,
-			Graphics::kBitFront,
+			Gfx::kBitFront,
 			cnv->_data1
 		);
 
@@ -575,7 +575,7 @@ int16 selectAnswer(Question *q, StaticCnv *cnv) {
 
 		if (_si != v2) {
 			if (v2 != -1) {
-				_vm->_graphics->displayWrappedString(
+				_vm->_gfx->displayWrappedString(
 					q->_answers[v2],
 					_answerBalloonX[v2],
 					_answerBalloonY[v2],
@@ -584,7 +584,7 @@ int16 selectAnswer(Question *q, StaticCnv *cnv) {
 				);
 			}
 
-			_vm->_graphics->displayWrappedString(
+			_vm->_gfx->displayWrappedString(
 				q->_answers[_si],
 				_answerBalloonX[_si],
 				_answerBalloonY[_si],
@@ -595,11 +595,11 @@ int16 selectAnswer(Question *q, StaticCnv *cnv) {
 			cnv->_data0 = _yourTalk._array[q->_answer_moods[_si] & 0xF];
 //			cnv->_data1 = _yourTalk.field_8[q->_answer_moods[_si] & 0xF];
 
-			_vm->_graphics->flatBlitCnv(
+			_vm->_gfx->flatBlitCnv(
 				cnv,
 				ANSWER_CHARACTER_X,
 				ANSWER_CHARACTER_Y,
-				Graphics::kBitFront,
+				Gfx::kBitFront,
 				cnv->_data1
 			);
 
@@ -648,8 +648,8 @@ int16 getHoverAnswer(int16 x, int16 y, Question *q) {
 //
 void enterDialogue() {
 
-	_vm->_graphics->backupBackgroundMask(Graphics::kMask0);
-	_vm->_graphics->backupBackgroundPath(Graphics::kPath0);
+	_vm->_gfx->backupBackgroundMask(Gfx::kMask0);
+	_vm->_gfx->backupBackgroundPath(Gfx::kPath0);
 
 	return;
 }
@@ -659,8 +659,8 @@ void enterDialogue() {
 //
 void exitDialogue() {
 
-	_vm->_graphics->restoreBackgroundMask(Graphics::kMask0);
-	_vm->_graphics->restoreBackgroundPath(Graphics::kPath0);
+	_vm->_gfx->restoreBackgroundMask(Gfx::kMask0);
+	_vm->_gfx->restoreBackgroundPath(Gfx::kPath0);
 
 	refreshInventory(_vm->_characterName);
 
diff --git a/engines/parallaction/disk.cpp b/engines/parallaction/disk.cpp
index 250b948ca8..bb652129f2 100644
--- a/engines/parallaction/disk.cpp
+++ b/engines/parallaction/disk.cpp
@@ -101,7 +101,7 @@ uint16 Disk::decompressChunk(byte *src, byte *dst, uint16 size) {
 // loads a cnv from an external file
 //
 void Disk::loadExternalCnv(const char *filename, Cnv *cnv) {
-//	printf("Graphics::loadExternalCnv(%s)...", filename);
+//	printf("Gfx::loadExternalCnv(%s)...", filename);
 
 	char path[PATH_LEN];
 
@@ -156,7 +156,7 @@ void Disk::loadExternalStaticCnv(const char *filename, StaticCnv *cnv) {
 }
 
 void Disk::loadCnv(const char *filename, Cnv *cnv) {
-//	printf("Graphics::loadCnv(%s)\n", filename);
+//	printf("Gfx::loadCnv(%s)\n", filename);
 
 	char path[PATH_LEN];
 
@@ -388,12 +388,12 @@ void Disk::unpackBackgroundScanline(byte *src, byte *screen, byte *mask, byte *p
 }
 
 void Disk::loadBackground(const char *filename) {
-//	printf("Graphics::loadBackground(%s)\n", filename);
+//	printf("Gfx::loadBackground(%s)\n", filename);
 
 	if (!_archive.openArchivedFile(filename))
 		errorFileNotFound(filename);
 
-	_vm->_graphics->parseBackground(_archive);
+	_vm->_gfx->parseBackground(_archive);
 
 	byte *bg = (byte*)calloc(1, SCREEN_WIDTH*SCREEN_HEIGHT);
 	byte *mask = (byte*)calloc(1, SCREENMASK_WIDTH*SCREEN_HEIGHT);
@@ -410,9 +410,9 @@ void Disk::loadBackground(const char *filename) {
 		unpackBackgroundScanline(v144, bg+SCREEN_WIDTH*i, mask+SCREENMASK_WIDTH*i, path+SCREENPATH_WIDTH*i);
 	}
 
-	_vm->_graphics->setBackground(bg);
-	_vm->_graphics->setMask(mask);
-	_vm->_graphics->setPath(path);
+	_vm->_gfx->setBackground(bg);
+	_vm->_gfx->setMask(mask);
+	_vm->_gfx->setPath(path);
 
 	free(v4);
 
@@ -439,13 +439,13 @@ void Disk::loadMaskAndPath(const char *name) {
 	byte *maskBuf = (byte*)calloc(1, SCREENMASK_WIDTH*SCREEN_HEIGHT);
 	byte *pathBuf = (byte*)calloc(1, SCREENPATH_WIDTH*SCREEN_HEIGHT);
 
-	_vm->_graphics->parseDepths(_archive);
+	_vm->_gfx->parseDepths(_archive);
 
 	_archive.read(pathBuf, SCREENPATH_WIDTH*SCREEN_HEIGHT);
 	_archive.read(maskBuf, SCREENMASK_WIDTH*SCREEN_HEIGHT);
 
-	_vm->_graphics->setMask(maskBuf);
-	_vm->_graphics->setPath(pathBuf);
+	_vm->_gfx->setMask(maskBuf);
+	_vm->_gfx->setPath(pathBuf);
 
 	return;
 }
diff --git a/engines/parallaction/disk.h b/engines/parallaction/disk.h
index 614cf80069..ae9e448a3c 100644
--- a/engines/parallaction/disk.h
+++ b/engines/parallaction/disk.h
@@ -38,7 +38,7 @@ namespace Parallaction {
 #define DIRECTORY_OFFSET_IN_FILE	0x4000
 
 class Parallaction;
-class Graphics;
+class Gfx;
 class Script;
 
 class Archive : public Common::SeekableReadStream {
@@ -92,7 +92,7 @@ protected:
 	char		  _languageDir[3];
 
 	Parallaction *_vm;
-	Graphics	 *_gfx;
+	Gfx	 *_gfx;
 
 public:
 	Disk(Parallaction *vm);
diff --git a/engines/parallaction/graphics.cpp b/engines/parallaction/graphics.cpp
index 8730bc30bb..77d173a4ec 100644
--- a/engines/parallaction/graphics.cpp
+++ b/engines/parallaction/graphics.cpp
@@ -56,10 +56,10 @@ const byte _glyphWidths[126] = {
   0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x06, 0x05, 0x05, 0x05, 0x05
 };
 
-bool		Graphics::_proportionalFont = false;
-Point		Graphics::_labelPosition[2] = { { 0, 0 }, { 0, 0 } };
-StaticCnv	Graphics::_mouseComposedArrow;
-byte *		Graphics::_buffers[];
+bool		Gfx::_proportionalFont = false;
+Point		Gfx::_labelPosition[2] = { { 0, 0 }, { 0, 0 } };
+StaticCnv	Gfx::_mouseComposedArrow;
+byte *		Gfx::_buffers[];
 
 #define PALETTE_BACKUP	PALETTE_SIZE
 
@@ -113,8 +113,8 @@ byte _resBalloon[2][BALLOON_WIDTH*BALLOON_HEIGHT] = {
 	}
 };
 
-void Graphics::drawBalloon(int16 left, int16 top, uint16 width, uint16 height, uint16 winding) {
-//	printf("Graphics::drawBalloon(%i, %i, %i, %i, %i)...", left, top, width, height, winding);
+void Gfx::drawBalloon(int16 left, int16 top, uint16 width, uint16 height, uint16 winding) {
+//	printf("Gfx::drawBalloon(%i, %i, %i, %i, %i)...", left, top, width, height, winding);
 
 	width+=5;
 	floodFill(0, left, top, left+width, top+height, kBitFront);
@@ -145,7 +145,7 @@ void Graphics::drawBalloon(int16 left, int16 top, uint16 width, uint16 height, u
 //	palette management
 //
 
-void Graphics::setPalette(byte *palette) {
+void Gfx::setPalette(byte *palette) {
 //	printf("setPalette()\n");
 //	memcpy(_palette, palette, PALETTE_SIZE);
 
@@ -163,23 +163,23 @@ void Graphics::setPalette(byte *palette) {
 	return;
 }
 
-void Graphics::getBlackPalette(byte *palette) {
+void Gfx::getBlackPalette(byte *palette) {
 	memcpy(palette, _black_palette, PALETTE_SIZE);
 	return;
 }
 
-void Graphics::palUnk0(byte *palette) {
+void Gfx::palUnk0(byte *palette) {
 #if 0
 	for (uint16 i = 0; i < PALETTE_SIZE; i++) {
 		palette[PALETTE_BACKUP+i] = _palette[i]/2;
 	}
 #endif
-	Graphics::setPalette(palette);
+	Gfx::setPalette(palette);
 
 	return;
 }
 
-void Graphics::buildBWPalette(byte *palette) {
+void Gfx::buildBWPalette(byte *palette) {
 
 	for (uint16 i = 0; i < PALETTE_COLORS; i++) {
 		byte max;
@@ -208,7 +208,7 @@ void Graphics::buildBWPalette(byte *palette) {
 	return;
 }
 
-void Graphics::fadePalette(byte *palette) {
+void Gfx::fadePalette(byte *palette) {
 
 	for (uint16 i = 0; i < PALETTE_SIZE; i++)
 		if (palette[i] < _palette[i]) palette[i]++;
@@ -217,7 +217,7 @@ void Graphics::fadePalette(byte *palette) {
 	return;
 }
 
-void Graphics::quickFadePalette(byte *palette) {
+void Gfx::quickFadePalette(byte *palette) {
 
 	for (uint16 i = 0; i < PALETTE_SIZE; i++) {
 		if (palette[i] == _palette[i]) continue;
@@ -232,8 +232,8 @@ void Graphics::quickFadePalette(byte *palette) {
 //
 //	FIXME: the effect is different from the original
 //
-void Graphics::animatePalette(byte *palette) {
-// printf("Graphics::animatePalette()\n");
+void Gfx::animatePalette(byte *palette) {
+// printf("Gfx::animatePalette()\n");
 
 	byte tmp[3];
 
@@ -281,15 +281,15 @@ void Graphics::animatePalette(byte *palette) {
 
 
 
-void Graphics::updateScreen() {
-//	  printf("Graphics::updateScreen()\n");
+void Gfx::updateScreen() {
+//	  printf("Gfx::updateScreen()\n");
 	g_system->copyRectToScreen(_buffers[kBitFront], SCREEN_WIDTH, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
 	g_system->updateScreen();
 	return;
 }
 
 
-void Graphics::swapBuffers() {
+void Gfx::swapBuffers() {
 	byte *temp = _buffers[kBitFront];
 	_buffers[kBitFront] = _buffers[kBitBack];
 	_buffers[kBitBack] = temp;
@@ -301,7 +301,7 @@ void Graphics::swapBuffers() {
 //
 //	graphic primitives
 //
-void Graphics::clearScreen(Graphics::Buffers buffer) {
+void Gfx::clearScreen(Gfx::Buffers buffer) {
 	memset(_buffers[buffer], 0, SCREEN_WIDTH*SCREEN_HEIGHT);
 
 	if (buffer == kBitFront) updateScreen();
@@ -310,7 +310,7 @@ void Graphics::clearScreen(Graphics::Buffers buffer) {
 }
 
 
-void Graphics::copyScreen(Graphics::Buffers srcbuffer, Graphics::Buffers dstbuffer) {
+void Gfx::copyScreen(Gfx::Buffers srcbuffer, Gfx::Buffers dstbuffer) {
 	memcpy(_buffers[dstbuffer], _buffers[srcbuffer], SCREEN_WIDTH*SCREEN_HEIGHT);
 
 	if (dstbuffer == kBitFront) updateScreen();
@@ -319,7 +319,7 @@ void Graphics::copyScreen(Graphics::Buffers srcbuffer, Graphics::Buffers dstbuff
 }
 
 
-void Graphics::copyRect(Graphics::Buffers srcbuffer, uint16 sx, uint16 sy, Graphics::Buffers dstbuffer, uint16 dx, uint16 dy, uint16 w, uint16 h) {
+void Gfx::copyRect(Gfx::Buffers srcbuffer, uint16 sx, uint16 sy, Gfx::Buffers dstbuffer, uint16 dx, uint16 dy, uint16 w, uint16 h) {
 
 	byte *s = _buffers[srcbuffer] + (sx + sy * SCREEN_WIDTH);
 	byte *d = _buffers[dstbuffer] + (dx + dy * SCREEN_WIDTH);
@@ -338,8 +338,8 @@ void Graphics::copyRect(Graphics::Buffers srcbuffer, uint16 sx, uint16 sy, Graph
 }
 
 
-void Graphics::floodFill(byte color, uint16 left, uint16 top, uint16 right, uint16 bottom, Graphics::Buffers buffer) {
-//	printf("Graphics::floodFill(%i, %i, %i, %i, %i)\n", color, left, top, right, bottom);
+void Gfx::floodFill(byte color, uint16 left, uint16 top, uint16 right, uint16 bottom, Gfx::Buffers buffer) {
+//	printf("Gfx::floodFill(%i, %i, %i, %i, %i)\n", color, left, top, right, bottom);
 
 	byte *d = _buffers[buffer] + (left + top * SCREEN_WIDTH);
 	uint16 w = right - left + 1;
@@ -357,8 +357,8 @@ void Graphics::floodFill(byte color, uint16 left, uint16 top, uint16 right, uint
 }
 
 
-void Graphics::flatBlit(uint16 w, uint16 h, int16 x, int16 y, byte *data, Graphics::Buffers buffer) {
-	debugC(9, kDebugGraphics, "Graphics::flatBlit(%i, %i, %i, %i)", w, h, x, y);
+void Gfx::flatBlit(uint16 w, uint16 h, int16 x, int16 y, byte *data, Gfx::Buffers buffer) {
+	debugC(9, kDebugGraphics, "Gfx::flatBlit(%i, %i, %i, %i)", w, h, x, y);
 
 	// source coordinates
 	int16 left = 0, top = 0;
@@ -384,7 +384,7 @@ void Graphics::flatBlit(uint16 w, uint16 h, int16 x, int16 y, byte *data, Graphi
 	byte *s = data + left + top * w;
 	byte *d = _buffers[buffer] + x + y * SCREEN_WIDTH;
 
-	debugC(9, kDebugGraphics, "Graphics::flatBlit CLIPPED (%i, %i, %i, %i) -> (%i, %i) %p %p", left, top, right, bottom, x, y, (const void*)s, (const void*)d);
+	debugC(9, kDebugGraphics, "Gfx::flatBlit CLIPPED (%i, %i, %i, %i) -> (%i, %i) %p %p", left, top, right, bottom, x, y, (const void*)s, (const void*)d);
 
 	for (uint16 i = top; i < bottom; i++) {
 		for (uint16 j = left; j < right; j++) {
@@ -397,19 +397,19 @@ void Graphics::flatBlit(uint16 w, uint16 h, int16 x, int16 y, byte *data, Graphi
 		d += (SCREEN_WIDTH - right + left);
 	}
 
-	debugC(9, kDebugGraphics, "Graphics::flatBlit BLITTED");
+	debugC(9, kDebugGraphics, "Gfx::flatBlit BLITTED");
 
 	if (buffer == kBitFront) updateScreen();
 
-	debugC(9, kDebugGraphics, "Graphics::flatBlit DONE");
+	debugC(9, kDebugGraphics, "Gfx::flatBlit DONE");
 
 	return;
 
 }
 
 
-void Graphics::blit(uint16 w, uint16 h, int16 x, int16 y, uint16 z, byte *data, Graphics::Buffers buffer, Graphics::Buffers mask) {
-//	printf("Graphics::blit(%i, %i, %i, %i, %i)\n", w, h, x, y, z);
+void Gfx::blit(uint16 w, uint16 h, int16 x, int16 y, uint16 z, byte *data, Gfx::Buffers buffer, Gfx::Buffers mask) {
+//	printf("Gfx::blit(%i, %i, %i, %i, %i)\n", w, h, x, y, z);
 
 	int16 left = 0, top = 0;
 	int16 right = w, bottom = h;
@@ -469,7 +469,7 @@ void jobDisplayLabel(void *parm, Job *j) {
 
 	if (label->_cnv._width == 0)
 		return;
-	_vm->_graphics->flatBlitCnv(&label->_cnv, Graphics::_labelPosition[0]._x, Graphics::_labelPosition[0]._y, Graphics::kBitBack, label->_cnv._data1);
+	_vm->_gfx->flatBlitCnv(&label->_cnv, Gfx::_labelPosition[0]._x, Gfx::_labelPosition[0]._y, Gfx::kBitBack, label->_cnv._data1);
 
 	return;
 }
@@ -496,17 +496,17 @@ void jobEraseLabel(void *parm, Job *j) {
 		_si = SCREEN_WIDTH - label->_cnv._width;
 
 
-	_vm->_graphics->restoreBackground(Graphics::_labelPosition[1]._x, Graphics::_labelPosition[1]._y, label->_cnv._width, label->_cnv._height);
+	_vm->_gfx->restoreBackground(Gfx::_labelPosition[1]._x, Gfx::_labelPosition[1]._y, label->_cnv._width, label->_cnv._height);
 
-	Graphics::_labelPosition[1]._x = Graphics::_labelPosition[0]._x;
-	Graphics::_labelPosition[1]._y = Graphics::_labelPosition[0]._y;
-	Graphics::_labelPosition[0]._x = _si;
-	Graphics::_labelPosition[0]._y = _di;
+	Gfx::_labelPosition[1]._x = Gfx::_labelPosition[0]._x;
+	Gfx::_labelPosition[1]._y = Gfx::_labelPosition[0]._y;
+	Gfx::_labelPosition[0]._x = _si;
+	Gfx::_labelPosition[0]._y = _di;
 
 	return;
 }
 
-void Graphics::initMouse(uint16 arg_0) {
+void Gfx::initMouse(uint16 arg_0) {
 
 	_vm->_disk->loadPointer(&_mouseComposedArrow);
 
@@ -521,7 +521,7 @@ void Graphics::initMouse(uint16 arg_0) {
 	return;
 }
 
-void Graphics::setMousePointer(int16 index) {
+void Gfx::setMousePointer(int16 index) {
 
 	if (index == kCursorArrow) {		// standard mouse pointer
 
@@ -560,18 +560,18 @@ void Graphics::setMousePointer(int16 index) {
 //
 //	Cnv management
 //
-void Graphics::flatBlitCnv(StaticCnv *cnv, int16 x, int16 y, Graphics::Buffers buffer, byte *unused) {
+void Gfx::flatBlitCnv(StaticCnv *cnv, int16 x, int16 y, Gfx::Buffers buffer, byte *unused) {
 	flatBlit(cnv->_width, cnv->_height, x, y, cnv->_data0, buffer);
 	return;
 }
 
 
-void Graphics::blitCnv(StaticCnv *cnv, int16 x, int16 y, uint16 z, Graphics::Buffers buffer, Graphics::Buffers mask) {
+void Gfx::blitCnv(StaticCnv *cnv, int16 x, int16 y, uint16 z, Gfx::Buffers buffer, Gfx::Buffers mask) {
 	blit(cnv->_width, cnv->_height, x, y, z, cnv->_data0,  buffer, mask);
 	return;
 }
 
-void Graphics::backupDoorBackground(DoorData *data, int16 x, int16 y) {
+void Gfx::backupDoorBackground(DoorData *data, int16 x, int16 y) {
 
 	byte *s = _buffers[kBit2] + x + y * SCREEN_WIDTH;
 	byte *d = data->_background;
@@ -586,7 +586,7 @@ void Graphics::backupDoorBackground(DoorData *data, int16 x, int16 y) {
 	return;
 }
 
-void Graphics::backupGetBackground(GetData *data, int16 x, int16 y) {
+void Gfx::backupGetBackground(GetData *data, int16 x, int16 y) {
 
 	byte *t = data->_cnv._data0;
 	byte *s = _buffers[kBitBack] + x + y * SCREEN_WIDTH;
@@ -610,7 +610,7 @@ void Graphics::backupGetBackground(GetData *data, int16 x, int16 y) {
 //
 //	copies a rectangular bitmap on the background
 //
-void Graphics::restoreZoneBackground(byte *data, int16 x, int16 y, uint16 w, uint16 h) {
+void Gfx::restoreZoneBackground(byte *data, int16 x, int16 y, uint16 w, uint16 h) {
 
 	StaticCnv cnv;
 
@@ -630,7 +630,7 @@ void Graphics::restoreZoneBackground(byte *data, int16 x, int16 y, uint16 w, uin
 //
 //	strings
 //
-void Graphics::displayString(uint16 x, uint16 y, const char *text) {
+void Gfx::displayString(uint16 x, uint16 y, const char *text) {
 	if (text == NULL)
 		return;
 
@@ -654,7 +654,7 @@ void Graphics::displayString(uint16 x, uint16 y, const char *text) {
 }
 
 
-void Graphics::displayBalloonString(uint16 x, uint16 y, const char *text, byte color) {
+void Gfx::displayBalloonString(uint16 x, uint16 y, const char *text, byte color) {
 
 	uint16 len = strlen(text);
 
@@ -688,8 +688,8 @@ void Graphics::displayBalloonString(uint16 x, uint16 y, const char *text, byte c
 
 
 
-bool Graphics::displayWrappedString(char *text, uint16 x, uint16 y, uint16 maxwidth, byte color) {
-//	printf("Graphics::displayWrappedString(%s, %i, %i, %i, %i)...", text, x, y, maxwidth, color);
+bool Gfx::displayWrappedString(char *text, uint16 x, uint16 y, uint16 maxwidth, byte color) {
+//	printf("Gfx::displayWrappedString(%s, %i, %i, %i, %i)...", text, x, y, maxwidth, color);
 
 	uint16 lines = 0;
 	bool rv = false;
@@ -736,7 +736,7 @@ bool Graphics::displayWrappedString(char *text, uint16 x, uint16 y, uint16 maxwi
 
 
 
-uint16 Graphics::getStringWidth(const char *text) {
+uint16 Gfx::getStringWidth(const char *text) {
 	if (text == NULL) return 0;
 
 	uint16 len = strlen(text);
@@ -757,7 +757,7 @@ uint16 Graphics::getStringWidth(const char *text) {
 }
 
 
-void Graphics::getStringExtent(char *text, uint16 maxwidth, int16* width, int16* height) {
+void Gfx::getStringExtent(char *text, uint16 maxwidth, int16* width, int16* height) {
 
 	uint16 lines = 0;
 	uint16 w = 0;
@@ -794,7 +794,7 @@ void Graphics::getStringExtent(char *text, uint16 maxwidth, int16* width, int16*
 }
 
 
-void Graphics::setFont(const char* name) {
+void Gfx::setFont(const char* name) {
 	freeCnv(&_font);
 	_vm->_disk->loadFont(name, &_font);
 }
@@ -803,7 +803,7 @@ void Graphics::setFont(const char* name) {
 //	backups background mask
 //
 //
-void Graphics::backupBackgroundMask(Graphics::Buffers mask) {
+void Gfx::backupBackgroundMask(Gfx::Buffers mask) {
 
 	byte *s = _buffers[mask];
 	byte *d = _maskBackup;
@@ -816,7 +816,7 @@ void Graphics::backupBackgroundMask(Graphics::Buffers mask) {
 //	restores background mask
 //
 //
-void Graphics::restoreBackgroundMask(Graphics::Buffers mask) {
+void Gfx::restoreBackgroundMask(Gfx::Buffers mask) {
 
 	byte *s = _maskBackup;
 	byte *d = _buffers[mask];
@@ -829,7 +829,7 @@ void Graphics::restoreBackgroundMask(Graphics::Buffers mask) {
 //	backups background path
 //
 //
-void Graphics::backupBackgroundPath(Graphics::Buffers path) {
+void Gfx::backupBackgroundPath(Gfx::Buffers path) {
 
 	byte *s = _buffers[path];
 	byte *d = _pathBackup;
@@ -842,7 +842,7 @@ void Graphics::backupBackgroundPath(Graphics::Buffers path) {
 //
 //	restores background path
 //
-void Graphics::restoreBackgroundPath(Graphics::Buffers path) {
+void Gfx::restoreBackgroundPath(Gfx::Buffers path) {
 
 	byte *s = _pathBackup;
 	byte *d = _buffers[path];
@@ -853,7 +853,7 @@ void Graphics::restoreBackgroundPath(Graphics::Buffers path) {
 }
 
 
-void Graphics::restoreBackground(int16 left, int16 top, uint16 width, uint16 height) {
+void Gfx::restoreBackground(int16 left, int16 top, uint16 width, uint16 height) {
 //	printf("restoreBackground(%i, %i, %i, %i)\n", left, top, width, height);
 
 	if (left < 0) left = 0;
@@ -871,7 +871,7 @@ void Graphics::restoreBackground(int16 left, int16 top, uint16 width, uint16 hei
 }
 
 
-void Graphics::makeCnvFromString(StaticCnv *cnv, char *text) {
+void Gfx::makeCnvFromString(StaticCnv *cnv, char *text) {
 //	printf("makeCnvFromString('%s')\n", text);
 
 	uint16 len = strlen(text);
@@ -903,7 +903,7 @@ void Graphics::makeCnvFromString(StaticCnv *cnv, char *text) {
 //
 //	internal character mapping
 //
-byte Graphics::mapChar(byte c) {
+byte Gfx::mapChar(byte c) {
 
 	if (c == 0xA5) return 0x5F;
 	if (c == 0xDF) return 0x60;
@@ -914,8 +914,8 @@ byte Graphics::mapChar(byte c) {
 }
 
 
-void Graphics::freeCnv(Cnv *cnv) {
-//	printf("Graphics::freeCnv()\n");
+void Gfx::freeCnv(Cnv *cnv) {
+//	printf("Gfx::freeCnv()\n");
 
 	if (!cnv) return;
 	if (cnv->_count == 0) return;
@@ -939,7 +939,7 @@ void Graphics::freeCnv(Cnv *cnv) {
 
 
 
-void Graphics::freeStaticCnv(StaticCnv *cnv) {
+void Gfx::freeStaticCnv(StaticCnv *cnv) {
 //	printf("free_static_cnv()\n");
 
 	if (!cnv) return;
@@ -951,7 +951,7 @@ void Graphics::freeStaticCnv(StaticCnv *cnv) {
 	return;
 }
 
-void Graphics::parseDepths(Common::SeekableReadStream &stream) {
+void Gfx::parseDepths(Common::SeekableReadStream &stream) {
 	_bgLayers[0] = stream.readByte();
 	_bgLayers[1] = stream.readByte();
 	_bgLayers[2] = stream.readByte();
@@ -959,7 +959,7 @@ void Graphics::parseDepths(Common::SeekableReadStream &stream) {
 }
 
 
-void Graphics::parseBackground(Common::SeekableReadStream &stream) {
+void Gfx::parseBackground(Common::SeekableReadStream &stream) {
 
 	stream.read(_palette, PALETTE_SIZE);
 
@@ -983,21 +983,21 @@ void Graphics::parseBackground(Common::SeekableReadStream &stream) {
 
 }
 
-void Graphics::setBackground(byte *background) {
+void Gfx::setBackground(byte *background) {
 	memcpy(_buffers[kBitBack], background, SCREEN_WIDTH*SCREEN_HEIGHT);
 	copyScreen(kBitBack, kBit2);
 }
 
-void Graphics::setMask(byte *mask) {
+void Gfx::setMask(byte *mask) {
 	memcpy(_buffers[kMask0], mask, SCREENMASK_WIDTH*SCREEN_HEIGHT);
 }
 
-void Graphics::setPath(byte *path) {
+void Gfx::setPath(byte *path) {
 	memcpy(_buffers[kPath0], path, SCREENPATH_WIDTH*SCREEN_HEIGHT);
 }
 
 
-void Graphics::copyRect(Graphics::Buffers dstbuffer, uint16 x, uint16 y, uint16 w, uint16 h, byte *src, uint16 pitch) {
+void Gfx::copyRect(Gfx::Buffers dstbuffer, uint16 x, uint16 y, uint16 w, uint16 h, byte *src, uint16 pitch) {
 
 	byte *d = _buffers[dstbuffer] + x + SCREEN_WIDTH * y;
 	byte *s = src;
@@ -1013,7 +1013,7 @@ void Graphics::copyRect(Graphics::Buffers dstbuffer, uint16 x, uint16 y, uint16
 }
 
 
-void Graphics::drawBorder(Graphics::Buffers buffer, uint16 x, uint16 y, uint16 w, uint16 h, byte color) {
+void Gfx::drawBorder(Gfx::Buffers buffer, uint16 x, uint16 y, uint16 w, uint16 h, byte color) {
 
 	byte *d = _buffers[buffer] + x + SCREEN_WIDTH * y;
 
@@ -1030,7 +1030,7 @@ void Graphics::drawBorder(Graphics::Buffers buffer, uint16 x, uint16 y, uint16 w
 	return;
 }
 
-void Graphics::grabRect(Graphics::Buffers srcbuffer, byte *dst, uint16 x, uint16 y, uint16 w, uint16 h, uint16 pitch) {
+void Gfx::grabRect(Gfx::Buffers srcbuffer, byte *dst, uint16 x, uint16 y, uint16 w, uint16 h, uint16 pitch) {
 
 	byte *s = _buffers[srcbuffer] + x + SCREEN_WIDTH * y;
 
@@ -1045,7 +1045,7 @@ void Graphics::grabRect(Graphics::Buffers srcbuffer, byte *dst, uint16 x, uint16
 }
 
 
-void Graphics::maskOpNot(uint16 x, uint16 y, uint16 unused, Graphics::Buffers mask) {
+void Gfx::maskOpNot(uint16 x, uint16 y, uint16 unused, Gfx::Buffers mask) {
 
 	uint16 _ax = x + y * SCREEN_WIDTH;
 	_buffers[mask][_ax >> 2] &= ~(3 << ((_ax & 3) << 1));
@@ -1055,7 +1055,7 @@ void Graphics::maskOpNot(uint16 x, uint16 y, uint16 unused, Graphics::Buffers ma
 
 
 
-void Graphics::maskClearRectangle(uint16 left, uint16 top, uint16 right, uint16 bottom, Graphics::Buffers mask) {
+void Gfx::maskClearRectangle(uint16 left, uint16 top, uint16 right, uint16 bottom, Gfx::Buffers mask) {
 
 	uint16 _di = left/4 + top*80;
 
@@ -1071,13 +1071,13 @@ void Graphics::maskClearRectangle(uint16 left, uint16 top, uint16 right, uint16
 //	HACK
 //	this routine is only invoked from the 'intgrotta scenario'
 //
-void Graphics::intGrottaHackMask() {
+void Gfx::intGrottaHackMask() {
 	memset(_buffers[kMask0] + 3600, 0, 3600);
 	_bgLayers[1] = 500;
 	return;
 }
 
-uint16 Graphics::queryPath(uint16 x, uint16 y) {
+uint16 Gfx::queryPath(uint16 x, uint16 y) {
 
 	byte *v6 = _buffers[kPath0];
 
@@ -1088,7 +1088,7 @@ uint16 Graphics::queryPath(uint16 x, uint16 y) {
 
 }
 
-int16 Graphics::queryMask(int16 v) {
+int16 Gfx::queryMask(int16 v) {
 
 	for (uint16 _si = 0; _si < 3; _si++) {
 		if (_bgLayers[_si+1] > v) return _si;
@@ -1097,7 +1097,7 @@ int16 Graphics::queryMask(int16 v) {
 	return 3;
 }
 
-void Graphics::initBuffers() {
+void Gfx::initBuffers() {
 
 	_buffers[kBitFront] = (byte*)malloc(SCREEN_SIZE);
 	_buffers[kBitBack]	= (byte*)malloc(SCREEN_SIZE);
@@ -1114,7 +1114,7 @@ void Graphics::initBuffers() {
 }
 
 
-Graphics::Graphics(Parallaction* vm) :
+Gfx::Gfx(Parallaction* vm) :
 	_vm(vm) {
 
 	g_system->beginGFXTransaction();
@@ -1137,7 +1137,7 @@ Graphics::Graphics(Parallaction* vm) :
 	return;
 }
 
-Graphics::~Graphics() {
+Gfx::~Gfx() {
 
 	free(_buffers[kMask0]);
 	free(_buffers[kPath0]);
diff --git a/engines/parallaction/graphics.h b/engines/parallaction/graphics.h
index a2e248af0b..3026d921c7 100644
--- a/engines/parallaction/graphics.h
+++ b/engines/parallaction/graphics.h
@@ -64,7 +64,7 @@ class Parallaction;
 struct DoorData;
 struct GetData;
 
-class Graphics {
+class Gfx {
 
 public:
 	enum Buffers {
@@ -108,27 +108,27 @@ public:
 	int16 queryMask(int16 v);
 	void intGrottaHackMask();
 	void restoreBackground(int16 left, int16 top, uint16 width, uint16 height);
-	void backupBackgroundMask(Graphics::Buffers mask);
-	void restoreBackgroundMask(Graphics::Buffers mask);
-	void backupBackgroundPath(Graphics::Buffers path);
-	void restoreBackgroundPath(Graphics::Buffers path);
+	void backupBackgroundMask(Gfx::Buffers mask);
+	void restoreBackgroundMask(Gfx::Buffers mask);
+	void backupBackgroundPath(Gfx::Buffers path);
+	void restoreBackgroundPath(Gfx::Buffers path);
 
 	// intro
-	void maskClearRectangle(uint16 left, uint16 top, uint16 right, uint16 bottom, Graphics::Buffers mask);
-	void maskOpNot(uint16 x, uint16 y, uint16 unused, Graphics::Buffers mask);
+	void maskClearRectangle(uint16 left, uint16 top, uint16 right, uint16 bottom, Gfx::Buffers mask);
+	void maskOpNot(uint16 x, uint16 y, uint16 unused, Gfx::Buffers mask);
 
 	// low level
 	void swapBuffers();
 	void updateScreen();
-	void clearScreen(Graphics::Buffers buffer);
-	void copyScreen(Graphics::Buffers srcbuffer, Graphics::Buffers dstbuffer);
-	void copyRect(Graphics::Buffers srcbuffer, uint16 sx, uint16 sy, Graphics::Buffers dstbuffer, uint16 dx, uint16 dy, uint16 w, uint16 h);
-	void copyRect(Graphics::Buffers dstbuffer, uint16 x, uint16 y, uint16 w, uint16 h, byte *src, uint16 pitch);
-	void grabRect(Graphics::Buffers srcbuffer, byte *dst, uint16 x, uint16 y, uint16 w, uint16 h, uint16 pitch);
-	void drawBorder(Graphics::Buffers buffer, uint16 x, uint16 y, uint16 w, uint16 h, byte color);
-	void floodFill(byte color, uint16 left, uint16 top, uint16 right, uint16 bottom, Graphics::Buffers buffer);
-	void flatBlitCnv(StaticCnv *cnv, int16 x, int16 y, Graphics::Buffers buffer, byte *unused);
-	void blitCnv(StaticCnv *cnv, int16 x, int16 y, uint16 z, Graphics::Buffers buffer, Graphics::Buffers mask);
+	void clearScreen(Gfx::Buffers buffer);
+	void copyScreen(Gfx::Buffers srcbuffer, Gfx::Buffers dstbuffer);
+	void copyRect(Gfx::Buffers srcbuffer, uint16 sx, uint16 sy, Gfx::Buffers dstbuffer, uint16 dx, uint16 dy, uint16 w, uint16 h);
+	void copyRect(Gfx::Buffers dstbuffer, uint16 x, uint16 y, uint16 w, uint16 h, byte *src, uint16 pitch);
+	void grabRect(Gfx::Buffers srcbuffer, byte *dst, uint16 x, uint16 y, uint16 w, uint16 h, uint16 pitch);
+	void drawBorder(Gfx::Buffers buffer, uint16 x, uint16 y, uint16 w, uint16 h, byte color);
+	void floodFill(byte color, uint16 left, uint16 top, uint16 right, uint16 bottom, Gfx::Buffers buffer);
+	void flatBlitCnv(StaticCnv *cnv, int16 x, int16 y, Gfx::Buffers buffer, byte *unused);
+	void blitCnv(StaticCnv *cnv, int16 x, int16 y, uint16 z, Gfx::Buffers buffer, Gfx::Buffers mask);
 
 	// palette
 	void animatePalette(byte *palette);
@@ -140,8 +140,8 @@ public:
 	void fadePalette(byte *palette);
 
 	// init
-	Graphics(Parallaction* vm);
-	virtual ~Graphics();
+	Gfx(Parallaction* vm);
+	virtual ~Gfx();
 
 	void setMousePointer(int16 index);
 
@@ -169,8 +169,8 @@ protected:
 	//
 	byte mapChar(byte c);
 
-	void flatBlit(uint16 w, uint16 h, int16 x, int16 y, byte *data, Graphics::Buffers buffer);
-	void blit(uint16 w, uint16 h, int16 x, int16 y, uint16 z, byte *data, Graphics::Buffers buffer, Graphics::Buffers mask);
+	void flatBlit(uint16 w, uint16 h, int16 x, int16 y, byte *data, Gfx::Buffers buffer);
+	void blit(uint16 w, uint16 h, int16 x, int16 y, uint16 z, byte *data, Gfx::Buffers buffer, Gfx::Buffers mask);
 
 
 	void initBuffers();
diff --git a/engines/parallaction/intro.cpp b/engines/parallaction/intro.cpp
index de5910d71d..a24842b885 100644
--- a/engines/parallaction/intro.cpp
+++ b/engines/parallaction/intro.cpp
@@ -132,16 +132,16 @@ void _c_startIntro(void *parm) {
 
 void _c_endIntro(void *parm) {
 
-	_vm->_graphics->setFont("slide");
-	_vm->_graphics->_proportionalFont = false;
+	_vm->_gfx->setFont("slide");
+	_vm->_gfx->_proportionalFont = false;
 
 	uint16 _di;
 	for (uint16 _si = 0; _si < 7; _si++) {
-		_di = _vm->_graphics->getStringWidth(_credits[_si]._role);
-		_vm->_graphics->displayString((SCREEN_WIDTH - _di)/2, 80, _credits[_si]._role);
+		_di = _vm->_gfx->getStringWidth(_credits[_si]._role);
+		_vm->_gfx->displayString((SCREEN_WIDTH - _di)/2, 80, _credits[_si]._role);
 
-		_di = _vm->_graphics->getStringWidth(_credits[_si]._name);
-		_vm->_graphics->displayString((SCREEN_WIDTH - _di)/2, 100, _credits[_si]._name);
+		_di = _vm->_gfx->getStringWidth(_credits[_si]._name);
+		_vm->_gfx->displayString((SCREEN_WIDTH - _di)/2, 100, _credits[_si]._name);
 
 		for (uint16 v2 = 0; v2 < 100; v2++) {
 			_vm->updateInput();
@@ -149,7 +149,7 @@ void _c_endIntro(void *parm) {
 				_vm->waitTime( 1 );
 		}
 
-		_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+		_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 	}
 
 	waitUntilLeftClick();
@@ -168,27 +168,27 @@ void _c_moveSheet(void *parm) {
 		x -= 16;
 
 	uint16 _ax = (x + 32 > 319) ? 319 : (x + 32);
-	_vm->_graphics->floodFill(1, x, 47, _ax, 199, Graphics::kBitBack);
-	_vm->_graphics->floodFill(1, x, 47, _ax, 199, Graphics::kBit2);
+	_vm->_gfx->floodFill(1, x, 47, _ax, 199, Gfx::kBitBack);
+	_vm->_gfx->floodFill(1, x, 47, _ax, 199, Gfx::kBit2);
 
 	if (x >= 104) return;
 
 	_ax = (x + 247 > 319) ? 319 : (x + 247);
-	_vm->_graphics->floodFill(12, x+215, 47, _ax, 199, Graphics::kBitBack);
-	_vm->_graphics->floodFill(12, x+215, 47, _ax, 199, Graphics::kBit2);
+	_vm->_gfx->floodFill(12, x+215, 47, _ax, 199, Gfx::kBitBack);
+	_vm->_gfx->floodFill(12, x+215, 47, _ax, 199, Gfx::kBit2);
 
 	return;
 }
 
 
-void introFunc1(uint16 oldX, uint16 oldY, uint16 newX, uint16 newY, Graphics::Buffers mask) {
+void introFunc1(uint16 oldX, uint16 oldY, uint16 newX, uint16 newY, Gfx::Buffers mask) {
 
 	uint16 unused = 0;
 	int16 dx = newX - oldX;
 	int16 dy = newY - oldY;
 
-	_vm->_graphics->maskOpNot(oldX, oldY, unused, mask);
-	_vm->_graphics->maskOpNot(newX, newY, unused, mask);
+	_vm->_gfx->maskOpNot(oldX, oldY, unused, mask);
+	_vm->_gfx->maskOpNot(newX, newY, unused, mask);
 
 	if (abs(dx) >= abs(dy)) {
 
@@ -200,7 +200,7 @@ void introFunc1(uint16 oldX, uint16 oldY, uint16 newX, uint16 newY, Graphics::Bu
 					oldY++;
 					v4 -= dx;
 				}
-				_vm->_graphics->maskOpNot(i + oldX, oldY, unused, mask);
+				_vm->_gfx->maskOpNot(i + oldX, oldY, unused, mask);
 			}
 		}
 
@@ -211,7 +211,7 @@ void introFunc1(uint16 oldX, uint16 oldY, uint16 newX, uint16 newY, Graphics::Bu
 					oldY++;
 					v4 -= abs(dx);
 				}
-				_vm->_graphics->maskOpNot(oldX - i, oldY, unused, mask);
+				_vm->_gfx->maskOpNot(oldX - i, oldY, unused, mask);
 			}
 		}
 
@@ -222,7 +222,7 @@ void introFunc1(uint16 oldX, uint16 oldY, uint16 newX, uint16 newY, Graphics::Bu
 					oldY--;
 					v4 -= abs(dx);
 				}
-				_vm->_graphics->maskOpNot(oldX - i, oldY, unused, mask);
+				_vm->_gfx->maskOpNot(oldX - i, oldY, unused, mask);
 			}
 		}
 
@@ -233,7 +233,7 @@ void introFunc1(uint16 oldX, uint16 oldY, uint16 newX, uint16 newY, Graphics::Bu
 					oldY--;
 					v4 -= dx;
 				}
-				_vm->_graphics->maskOpNot(i + oldX, oldY, unused, mask);
+				_vm->_gfx->maskOpNot(i + oldX, oldY, unused, mask);
 			}
 		}
 
@@ -250,7 +250,7 @@ void introFunc1(uint16 oldX, uint16 oldY, uint16 newX, uint16 newY, Graphics::Bu
 					oldX++;
 					v4 -= dy;
 				}
-				_vm->_graphics->maskOpNot(oldX, i + oldY, unused, mask);
+				_vm->_gfx->maskOpNot(oldX, i + oldY, unused, mask);
 			}
 		}
 
@@ -261,7 +261,7 @@ void introFunc1(uint16 oldX, uint16 oldY, uint16 newX, uint16 newY, Graphics::Bu
 					oldX--;
 					v4 -= dy;
 				}
-				_vm->_graphics->maskOpNot(oldX, i + oldY, unused, mask);
+				_vm->_gfx->maskOpNot(oldX, i + oldY, unused, mask);
 			}
 		}
 
@@ -272,7 +272,7 @@ void introFunc1(uint16 oldX, uint16 oldY, uint16 newX, uint16 newY, Graphics::Bu
 					oldX--;
 					v4 -= abs(dy);
 				}
-				_vm->_graphics->maskOpNot(oldX, oldY - i, unused, mask);
+				_vm->_gfx->maskOpNot(oldX, oldY - i, unused, mask);
 			}
 		}
 
@@ -283,7 +283,7 @@ void introFunc1(uint16 oldX, uint16 oldY, uint16 newX, uint16 newY, Graphics::Bu
 					oldX++;
 					v4 -= abs(dy);
 				}
-				_vm->_graphics->maskOpNot(oldX, oldY - i, unused, mask);
+				_vm->_gfx->maskOpNot(oldX, oldY - i, unused, mask);
 			}
 		}
 
@@ -303,7 +303,7 @@ void _c_sketch(void *parm) {
 	uint16 _2 = _rightHandPositions[2*(index-1)+1];
 	uint16 _1 = _rightHandPositions[2*(index-1)];
 
-	introFunc1(_1, _2, _3, _4, Graphics::kMask0 );
+	introFunc1(_1, _2, _3, _4, Gfx::kMask0 );
 
 	_rightHandAnim->_zone.pos._position._x = _rightHandPositions[index*2];
 	_rightHandAnim->_zone.pos._position._y = _rightHandPositions[index*2+1] - 20;
@@ -318,11 +318,11 @@ void _c_sketch(void *parm) {
 
 void _c_shade(void *parm) {
 
-	_vm->_graphics->maskClearRectangle(_rightHandAnim->_zone.pos._position._x - 36,
+	_vm->_gfx->maskClearRectangle(_rightHandAnim->_zone.pos._position._x - 36,
 		_rightHandAnim->_zone.pos._position._y - 36,
 		_rightHandAnim->_zone.pos._position._x,
 		_rightHandAnim->_zone.pos._position._y,
-		Graphics::kMask0 );
+		Gfx::kMask0 );
 
 	return;
 
diff --git a/engines/parallaction/inventory.cpp b/engines/parallaction/inventory.cpp
index fdd0b3ea10..2aa2f8c818 100644
--- a/engines/parallaction/inventory.cpp
+++ b/engines/parallaction/inventory.cpp
@@ -31,7 +31,7 @@
 namespace Parallaction {
 
 //
-//	inventory is kept in Graphics::kBit3 at 0 offset
+//	inventory is kept in Gfx::kBit3 at 0 offset
 //	it is a grid made of (at most) 30 cells, 24x24 pixels each,
 //	arranged in 6 lines
 //
@@ -187,8 +187,8 @@ void drawInventoryItem(uint16 pos, InventoryItem *item) {
 	uint16 line = pos / INVENTORY_ITEMS_PER_LINE;
 	uint16 col = pos % INVENTORY_ITEMS_PER_LINE;
 
-	_vm->_graphics->copyRect(
-		Graphics::kBit3,
+	_vm->_gfx->copyRect(
+		Gfx::kBit3,
 		col * INVENTORYITEM_WIDTH,
 		line * _yourObjects._height,
 		INVENTORYITEM_WIDTH,
@@ -213,8 +213,8 @@ void highlightInventoryItem(int16 pos, byte color) {
 	uint16 line = pos / INVENTORY_ITEMS_PER_LINE;
 	uint16 col = pos % INVENTORY_ITEMS_PER_LINE;
 
-	_vm->_graphics->drawBorder(
-		Graphics::kBit3,
+	_vm->_gfx->drawBorder(
+		Gfx::kBit3,
 		col * INVENTORYITEM_WIDTH,
 		line * _yourObjects._height,
 		INVENTORYITEM_WIDTH,
@@ -234,8 +234,8 @@ void extractInventoryGraphics(int16 pos, byte *dst) {
 	int16 line = pos / INVENTORY_ITEMS_PER_LINE;
 	int16 col = pos % INVENTORY_ITEMS_PER_LINE;
 
-	_vm->_graphics->grabRect(
-		Graphics::kBit3,
+	_vm->_gfx->grabRect(
+		Gfx::kBit3,
 		dst,
 		col * INVENTORYITEM_WIDTH,
 		line * _yourObjects._height,
@@ -256,11 +256,11 @@ void jobShowInventory(void *parm, Job *j) {
 
 	_numInvLines = (_numInvLines + 4) / INVENTORY_ITEMS_PER_LINE;
 
-	_vm->_graphics->copyRect(
-		Graphics::kBit3,
+	_vm->_gfx->copyRect(
+		Gfx::kBit3,
 		0,
 		0,
-		Graphics::kBitBack,
+		Gfx::kBitBack,
 		_invPosition._x,
 		_invPosition._y,
 		INVENTORY_WIDTH,
@@ -289,11 +289,11 @@ void jobHideInventory(void *parm, Job *j) {
 		_engineFlags &= ~kEngineMouse;
 	}
 
-	_vm->_graphics->copyRect(
-		Graphics::kBit2,
+	_vm->_gfx->copyRect(
+		Gfx::kBit2,
 		_invPosition._x,
 		_invPosition._y,
-		Graphics::kBitBack,
+		Gfx::kBitBack,
 		_invPosition._x,
 		_invPosition._y,
 		INVENTORY_WIDTH,
diff --git a/engines/parallaction/location.cpp b/engines/parallaction/location.cpp
index e00aec63aa..c61ed61666 100644
--- a/engines/parallaction/location.cpp
+++ b/engines/parallaction/location.cpp
@@ -42,8 +42,8 @@ void Parallaction::parseLocation(const char *filename) {
     debugC(1, kDebugLocation, "parseLocation('%s')", filename);
 
 	uint16 _si = 1;
-	_vm->_graphics->_proportionalFont = false;
-	_vm->_graphics->setFont("topaz");
+	_vm->_gfx->_proportionalFont = false;
+	_vm->_gfx->setFont("topaz");
 
 	_locationScript = _disk->loadLocation(filename);
 
@@ -258,7 +258,7 @@ void switchBackground(const char* background, const char* mask) {
 
 	uint16 v2 = 0;
 	if (!scumm_stricmp(background, "final")) {
-		_vm->_graphics->clearScreen(Graphics::kBitBack);
+		_vm->_gfx->clearScreen(Gfx::kBitBack);
 		for (uint16 _si = 0; _si <= 93; ) {
 			palette[_si] = v2;
 			palette[_si+1] = v2;
@@ -267,7 +267,7 @@ void switchBackground(const char* background, const char* mask) {
 			_si += 3;
 		}
 
-		_vm->_graphics->palUnk0(palette);
+		_vm->_gfx->palUnk0(palette);
 	}
 
 	_vm->_disk->loadScenery(background, mask);
@@ -282,18 +282,18 @@ extern Job     *_jEraseLabel;
 void Parallaction::showSlide(const char *name) {
 
 	_disk->loadSlide(name);
-	_graphics->palUnk0(_palette);
-	_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+	_gfx->palUnk0(_palette);
+	_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
 	debugC(1, kDebugLocation, "changeLocation: new background set");
 
-	_graphics->_proportionalFont = false;
-	_graphics->setFont("slide");
+	_gfx->_proportionalFont = false;
+	_gfx->setFont("slide");
 
 	uint16 _ax = strlen(_slideText[0]);
 	_ax <<= 3;	// text width
 	uint16 _dx = (SCREEN_WIDTH - _ax) >> 1; // center text
-	_graphics->displayString(_dx, 14, _slideText[0]); // displays text on screen
+	_gfx->displayString(_dx, 14, _slideText[0]); // displays text on screen
 
 	waitUntilLeftClick();
 
@@ -381,7 +381,7 @@ void Parallaction::changeLocation(char *location) {
 	strcpy(_saveData1, list[0].c_str());
 	parseLocation(list[0].c_str());
 
-	_graphics->copyScreen(Graphics::kBitBack, Graphics::kBit2);
+	_gfx->copyScreen(Gfx::kBitBack, Gfx::kBit2);
 	debugC(1, kDebugLocation, "changeLocation: new location '%s' parsed", _saveData1);
 
 	_yourself._zone.pos._oldposition._x = -1000;
@@ -400,14 +400,14 @@ void Parallaction::changeLocation(char *location) {
 
 	byte palette[PALETTE_SIZE];
 	for (uint16 _si = 0; _si < PALETTE_SIZE; _si++) palette[_si] = 0;
-	_graphics->palUnk0(palette);
-	_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+	_gfx->palUnk0(palette);
+	_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 	if (_location._commands) {
 		runCommands(_location._commands);
 		runJobs();
-		_graphics->swapBuffers();
+		_gfx->swapBuffers();
 		runJobs();
-		_graphics->swapBuffers();
+		_gfx->swapBuffers();
 	}
 
 	if (_location._comment) {
@@ -416,9 +416,9 @@ void Parallaction::changeLocation(char *location) {
 	}
 
 	runJobs();
-	_graphics->swapBuffers();
+	_gfx->swapBuffers();
 
-	_graphics->palUnk0(_palette);
+	_gfx->palUnk0(_palette);
 	if (_location._aCommands) {
 		runCommands(_location._aCommands);
 		debugC(1, kDebugLocation, "changeLocation: location acommands run");
@@ -445,22 +445,22 @@ void Parallaction::doLocationEnterTransition() {
 	byte v60[PALETTE_SIZE];
 	if (_localFlags[_currentLocationIndex] & kFlagsVisited) return; // visited
 
-	_vm->_graphics->buildBWPalette(v60);
-	_vm->_graphics->setPalette(v60);
+	_vm->_gfx->buildBWPalette(v60);
+	_vm->_gfx->setPalette(v60);
 
 	jobRunScripts(NULL, NULL);
 	jobEraseAnimations(NULL, NULL);
 	jobDisplayAnimations(NULL, NULL);
 
-	_vm->_graphics->setFont("comic");
-	_vm->_graphics->swapBuffers();
-	_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBitBack);
+	_vm->_gfx->setFont("comic");
+	_vm->_gfx->swapBuffers();
+	_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBitBack);
 
 	int16 v7C, v7A;
-	_vm->_graphics->getStringExtent(_vm->_location._comment, 130, &v7C, &v7A);
-	_vm->_graphics->floodFill(0, 5, 5, 10 + v7C, 5 + v7A, Graphics::kBitFront);
-	_vm->_graphics->floodFill(1, 6, 6, 9 + v7C, 4 + v7A, Graphics::kBitFront);
-	_vm->_graphics->displayWrappedString(_vm->_location._comment, 3, 5, 130, 0);
+	_vm->_gfx->getStringExtent(_vm->_location._comment, 130, &v7C, &v7A);
+	_vm->_gfx->floodFill(0, 5, 5, 10 + v7C, 5 + v7A, Gfx::kBitFront);
+	_vm->_gfx->floodFill(1, 6, 6, 9 + v7C, 4 + v7A, Gfx::kBitFront);
+	_vm->_gfx->displayWrappedString(_vm->_location._comment, 3, 5, 130, 0);
 
 	// FIXME: ???
 #if 0
@@ -471,13 +471,13 @@ void Parallaction::doLocationEnterTransition() {
 
 	waitUntilLeftClick();
 
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront );
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront );
 
 	// fades maximum intensity palette towards approximation of main palette
 	for (uint16 _si = 0; _si<6; _si++) {
 		waitTime( 1 );
-		_vm->_graphics->quickFadePalette(v60);
-		_vm->_graphics->setPalette(v60);
+		_vm->_gfx->quickFadePalette(v60);
+		_vm->_gfx->setPalette(v60);
 	}
 
 	debugC(1, kDebugLocation, "doLocationEnterTransition completed");
diff --git a/engines/parallaction/menu.cpp b/engines/parallaction/menu.cpp
index acc4cbfeab..5783f943a5 100644
--- a/engines/parallaction/menu.cpp
+++ b/engines/parallaction/menu.cpp
@@ -102,40 +102,40 @@ Menu::~Menu() {
 void Menu::start() {
 
 	_vm->_disk->selectArchive("disk1");
-	_vm->_graphics->_proportionalFont = false;
+	_vm->_gfx->_proportionalFont = false;
 
-	_vm->_graphics->setFont("slide");
+	_vm->_gfx->setFont("slide");
 
 	_vm->_disk->loadSlide("intro");
-	_vm->_graphics->palUnk0(_palette);
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+	_vm->_gfx->palUnk0(_palette);
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
 	g_system->delayMillis(2000);
 
 	_vm->_disk->loadSlide("minintro");
-	_vm->_graphics->palUnk0(_palette);
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+	_vm->_gfx->palUnk0(_palette);
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
 	g_system->delayMillis(2000);
 
 	_vm->_disk->loadSlide("lingua");
-	_vm->_graphics->palUnk0(_palette);
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+	_vm->_gfx->palUnk0(_palette);
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
-	_vm->_graphics->displayString(60, 30, "SELECT LANGUAGE");
+	_vm->_gfx->displayString(60, 30, "SELECT LANGUAGE");
 
-	_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBitBack);
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBit2);
+	_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBitBack);
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBit2);
 	_language = chooseLanguage();
 
 	_vm->_disk->setLanguage(_language);
 
 	_vm->_disk->loadSlide("restore");
-	_vm->_graphics->palUnk0(_palette);
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+	_vm->_gfx->palUnk0(_palette);
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBit2);
-//	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBit3);
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBit2);
+//	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBit3);
 
 	if (selectGame() == 0) {
 		newGame();
@@ -150,22 +150,22 @@ void Menu::newGame() {
 	const char **v14 = introMsg3;
 
 	_vm->_disk->loadScenery("test", NULL);
-	_vm->_graphics->palUnk0(_palette);
-	_vm->_graphics->swapBuffers();
+	_vm->_gfx->palUnk0(_palette);
+	_vm->_gfx->swapBuffers();
 
-	uint16 _ax = (SCREEN_WIDTH - _vm->_graphics->getStringWidth(v14[0])) / 2;
-	_vm->_graphics->displayString(_ax, 50, v14[0]);
+	uint16 _ax = (SCREEN_WIDTH - _vm->_gfx->getStringWidth(v14[0])) / 2;
+	_vm->_gfx->displayString(_ax, 50, v14[0]);
 
-	_ax = (SCREEN_WIDTH - _vm->_graphics->getStringWidth(v14[1])) / 2;
-	_vm->_graphics->displayString(_ax, 70, v14[1]);
+	_ax = (SCREEN_WIDTH - _vm->_gfx->getStringWidth(v14[1])) / 2;
+	_vm->_gfx->displayString(_ax, 70, v14[1]);
 
-	_ax = (SCREEN_WIDTH - _vm->_graphics->getStringWidth(v14[2])) / 2;
-	_vm->_graphics->displayString(_ax, 100, v14[2]);
+	_ax = (SCREEN_WIDTH - _vm->_gfx->getStringWidth(v14[2])) / 2;
+	_vm->_gfx->displayString(_ax, 100, v14[2]);
 
-	_ax = (SCREEN_WIDTH - _vm->_graphics->getStringWidth(v14[3])) / 2;
-	_vm->_graphics->displayString(_ax, 120, v14[3]);
+	_ax = (SCREEN_WIDTH - _vm->_gfx->getStringWidth(v14[3])) / 2;
+	_vm->_gfx->displayString(_ax, 120, v14[3]);
 
-	_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBitBack);
+	_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBitBack);
 
 
 	_mouseButtons = kMouseNone;
@@ -192,7 +192,7 @@ uint16 Menu::chooseLanguage() {
 
 	do {
 		_engine->updateInput();
-		_vm->_graphics->swapBuffers();
+		_vm->_gfx->swapBuffers();
 
 		uint16 _di = _mousePos._x;
 		uint16 v2 = _mousePos._y;
@@ -231,7 +231,7 @@ uint16 Menu::selectGame() {
 	while (_mouseButtons != kMouseLeftUp) {
 
 		_engine->updateInput();
-		_vm->_graphics->swapBuffers();
+		_vm->_gfx->swapBuffers();
 		_engine->waitTime( 1 );
 
 		_si = 0;
@@ -241,17 +241,17 @@ uint16 Menu::selectGame() {
 		if (_si == _di) continue;
 
 		_di = _si;
-		_vm->_graphics->copyScreen(Graphics::kBit2, Graphics::kBitFront);
+		_vm->_gfx->copyScreen(Gfx::kBit2, Gfx::kBitFront);
 
 		if (_si != 0) {
 			// load a game
-			_vm->_graphics->displayString(60, 30, loadGameMsg[_language]);
+			_vm->_gfx->displayString(60, 30, loadGameMsg[_language]);
 		} else {
 			// new game
-			_vm->_graphics->displayString(60, 30, newGameMsg[_language]);
+			_vm->_gfx->displayString(60, 30, newGameMsg[_language]);
 		}
 
-		_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBitBack);
+		_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBitBack);
 
 	}
 
@@ -289,30 +289,30 @@ void Menu::selectCharacter() {
 	_engine->changeCursor(kCursorArrow);
 	_vm->_midiPlayer->stop();
 
-	_vm->_graphics->_proportionalFont = false;
-	_vm->_graphics->setFont("slide");
+	_vm->_gfx->_proportionalFont = false;
+	_vm->_gfx->setFont("slide");
 
 	_vm->_disk->selectArchive("disk1");
 	_vm->_disk->loadSlide("password");	// loads background into kBitBack buffer
 
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);	//
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBit2);		//
-	_vm->_graphics->palUnk0(_palette);
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);	//
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBit2);		//
+	_vm->_gfx->palUnk0(_palette);
 
 	while (askPassword == true) {
 
 		askPassword = false;
 		_di = 0;
 
-		_vm->_graphics->displayString(60, 30, introMsg1[_language]);			// displays message
-		_vm->_graphics->copyScreen(Graphics::kBitFront, Graphics::kBitBack);
+		_vm->_gfx->displayString(60, 30, introMsg1[_language]);			// displays message
+		_vm->_gfx->copyScreen(Gfx::kBitFront, Gfx::kBitBack);
 
 		while (_di < 6) {
 
 			_mouseButtons = kMouseNone;
 			do {
 				_engine->updateInput();
-				_vm->_graphics->swapBuffers();
+				_vm->_gfx->swapBuffers();
 				_engine->waitTime(1);
 			} while (_mouseButtons != kMouseLeftUp);	// waits for left click
 
@@ -330,10 +330,10 @@ void Menu::selectCharacter() {
 
 				if (!r.contains(x, y)) continue;
 
-				_vm->_graphics->grabRect(Graphics::kBitFront, v14._data0, _si * BLOCK_X_OFFSET + BLOCK_X, BLOCK_Y - _si * BLOCK_Y_OFFSET, BLOCK_WIDTH, BLOCK_HEIGHT, BLOCK_WIDTH);
+				_vm->_gfx->grabRect(Gfx::kBitFront, v14._data0, _si * BLOCK_X_OFFSET + BLOCK_X, BLOCK_Y - _si * BLOCK_Y_OFFSET, BLOCK_WIDTH, BLOCK_HEIGHT, BLOCK_WIDTH);
 
-				_vm->_graphics->flatBlitCnv(&v14, _di * SLOT_WIDTH + SLOT_X, SLOT_Y, Graphics::kBitBack, 0);
-				_vm->_graphics->flatBlitCnv(&v14, _di * SLOT_WIDTH + SLOT_X, SLOT_Y, Graphics::kBitFront, 0);
+				_vm->_gfx->flatBlitCnv(&v14, _di * SLOT_WIDTH + SLOT_X, SLOT_Y, Gfx::kBitBack, 0);
+				_vm->_gfx->flatBlitCnv(&v14, _di * SLOT_WIDTH + SLOT_X, SLOT_Y, Gfx::kBitFront, 0);
 
 				beep();
 
@@ -352,12 +352,12 @@ void Menu::selectCharacter() {
 
 		if (askPassword == false) break;
 
-		_vm->_graphics->copyScreen(Graphics::kBit2, Graphics::kBitFront);
-		_vm->_graphics->displayString(60, 30, introMsg2[_language]);
+		_vm->_gfx->copyScreen(Gfx::kBit2, Gfx::kBitFront);
+		_vm->_gfx->displayString(60, 30, introMsg2[_language]);
 
 		g_system->delayMillis(2000);
 
-		_vm->_graphics->copyScreen(Graphics::kBit2, Graphics::kBitFront);
+		_vm->_gfx->copyScreen(Gfx::kBit2, Gfx::kBitFront);
 	}
 
 
@@ -372,8 +372,8 @@ void Menu::selectCharacter() {
 	}
 
 	byte palette[PALETTE_SIZE];
-	_vm->_graphics->getBlackPalette(palette);
-	_vm->_graphics->setPalette(palette);
+	_vm->_gfx->getBlackPalette(palette);
+	_vm->_gfx->setPalette(palette);
 
 	_engineFlags |= kEngineChangeLocation;
 
diff --git a/engines/parallaction/parallaction.cpp b/engines/parallaction/parallaction.cpp
index 020b143e44..dc858020ad 100644
--- a/engines/parallaction/parallaction.cpp
+++ b/engines/parallaction/parallaction.cpp
@@ -253,7 +253,7 @@ int Parallaction::init() {
 	_yourself._zone._label._text = strdup("yourself");
 
 	addNode(&_animations, &_yourself._zone._node);
-	_graphics = new Graphics(this);
+	_gfx = new Gfx(this);
 
 	int midiDriver = MidiDriver::detectMusicDriver(MDT_MIDI | MDT_ADLIB | MDT_PREFER_MIDI);
 	MidiDriver *driver = MidiDriver::createMidi(midiDriver);
@@ -398,14 +398,14 @@ void Parallaction::runGame() {
 	_jRunScripts = addJob(jobRunScripts, 0, kPriority15);
 	addJob(jobDisplayAnimations, 0, kPriority3);
 
-	_graphics->copyScreen(Graphics::kBitBack, Graphics::kBit2);
+	_gfx->copyScreen(Gfx::kBitBack, Gfx::kBit2);
 
 	if (_location._commands)
 		runCommands(_location._commands);
 
 	runJobs();
 
-	_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+	_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
 	if (_location._comment)
 		doLocationEnterTransition();
@@ -454,11 +454,11 @@ void Parallaction::runGame() {
 		runJobs();
 
 		if ((_engineFlags & kEnginePauseJobs) == 0 || (_engineFlags & kEngineInventory)) {
-			_graphics->swapBuffers();
+			_gfx->swapBuffers();
 			byte palette[PALETTE_SIZE];
 			memcpy(palette, _palette, sizeof(palette));
-			_graphics->animatePalette(palette);
-			_graphics->setPalette(palette);
+			_gfx->animatePalette(palette);
+			_gfx->setPalette(palette);
 		}
 
 	}
@@ -476,10 +476,10 @@ void Parallaction::processInput(InputData *data) {
 	switch (data->_event) {
 	case kEvEnterZone:
 		debugC(2, kDebugInput, "processInput: kEvEnterZone");
-		_graphics->_labelPosition[1]._x = -1000;
-		_graphics->_labelPosition[1]._y = -1000;
-		_graphics->_labelPosition[0]._x = -1000;
-		_graphics->_labelPosition[0]._y = -1000;
+		_gfx->_labelPosition[1]._x = -1000;
+		_gfx->_labelPosition[1]._y = -1000;
+		_gfx->_labelPosition[0]._x = -1000;
+		_gfx->_labelPosition[0]._y = -1000;
 		_jDrawLabel = addJob(&jobDisplayLabel, (void*)data->_label, kPriority0);
 		_jEraseLabel = addJob(&jobEraseLabel, (void*)data->_label, kPriority20);
 		break;
@@ -745,7 +745,7 @@ void Parallaction::changeCursor(int32 index) {
 		_activeItem._id = _inventory[index]._id;
 	}
 
-	_graphics->setMousePointer(index);
+	_gfx->setMousePointer(index);
 
 	return;
 }
@@ -754,14 +754,14 @@ void Parallaction::changeCursor(int32 index) {
 
 void freeCharacterFrames() {
 
-	_vm->_graphics->freeCnv(&_characterFrames);
+	_vm->_gfx->freeCnv(&_characterFrames);
 
 	if (!IS_DUMMY_CHARACTER(_vm->_characterName)) {
-		_vm->_graphics->freeCnv(&_miniCharacterFrames);
+		_vm->_gfx->freeCnv(&_miniCharacterFrames);
 		_vm->freeTable(_objectsNames);
-		_vm->_graphics->freeCnv(&_yourTalk);
-		_vm->_graphics->freeStaticCnv(&_yourHead);
-		_vm->_graphics->freeCnv(&_yourObjects);
+		_vm->_gfx->freeCnv(&_yourTalk);
+		_vm->_gfx->freeStaticCnv(&_yourHead);
+		_vm->_gfx->freeCnv(&_yourObjects);
 	}
 
 	return;
diff --git a/engines/parallaction/parallaction.h b/engines/parallaction/parallaction.h
index 61cd91424d..ebdbb0050b 100644
--- a/engines/parallaction/parallaction.h
+++ b/engines/parallaction/parallaction.h
@@ -233,7 +233,7 @@ enum {
 
 
 
-class Graphics;
+class Gfx;
 class Menu;
 class MidiPlayer;
 
@@ -296,7 +296,7 @@ public:
 
 	MidiPlayer *_midiPlayer;
 
-	Graphics*	_graphics;
+	Gfx*	_gfx;
 	Menu*	_menu;
 	char	_characterName[30];
 	Disk*	_disk;
diff --git a/engines/parallaction/staticres.cpp b/engines/parallaction/staticres.cpp
index d3ff33a711..9a233b6a6a 100644
--- a/engines/parallaction/staticres.cpp
+++ b/engines/parallaction/staticres.cpp
@@ -24,7 +24,7 @@
 
 namespace Parallaction {
 
-byte Graphics::_mouseArrow[256] = {
+byte Gfx::_mouseArrow[256] = {
 	0x12, 0x11, 0x11, 0x11, 0x13, 0x12, 0x12, 0x12, 0x13, 0x12, 0x12, 0x11, 0x13, 0x12, 0x12, 0x00,
 	0x13, 0x12, 0x12, 0x11, 0x13, 0x12, 0x12, 0x12, 0x13, 0x12, 0x12, 0x12, 0x13, 0x12, 0x12, 0x12,
 	0x13, 0x12, 0x12, 0x12, 0x13, 0x12, 0x12, 0x12, 0x13, 0x12, 0x12, 0x13, 0x13, 0x13, 0x12, 0x00,
diff --git a/engines/parallaction/walk.cpp b/engines/parallaction/walk.cpp
index 03910bdc55..8c456f595f 100644
--- a/engines/parallaction/walk.cpp
+++ b/engines/parallaction/walk.cpp
@@ -231,7 +231,7 @@ WalkNode *buildWalkPath(uint16 x, uint16 y) {
 
 
 uint16 queryPath(uint16 x, uint16 y) {
-	return _vm->_graphics->queryPath(x, y);
+	return _vm->_gfx->queryPath(x, y);
 }
 
 
diff --git a/engines/parallaction/zone.cpp b/engines/parallaction/zone.cpp
index b537ad7c1e..c656e48140 100644
--- a/engines/parallaction/zone.cpp
+++ b/engines/parallaction/zone.cpp
@@ -103,7 +103,7 @@ void Parallaction::parseZone(Script &script, Node *list, char *name) {
 		}
 		if (!scumm_stricmp(_tokens[0], "label")) {
 //			printf("label: %s", _tokens[1]);
-			_vm->_graphics->makeCnvFromString(&z->_label._cnv, _tokens[1]);
+			_vm->_gfx->makeCnvFromString(&z->_label._cnv, _tokens[1]);
 		}
 		if (!scumm_stricmp(_tokens[0], "flags")) {
 			uint16 _si = 1;
@@ -159,7 +159,7 @@ void freeZones(Node *list) {
 		case kZoneDoor:
 			free(z->u.door->_location);
 			free(z->u.door->_background);
-			_vm->_graphics->freeCnv(&z->u.door->_cnv);
+			_vm->_gfx->freeCnv(&z->u.door->_cnv);
 			free(z->u.door);
 			break;
 
@@ -170,7 +170,7 @@ void freeZones(Node *list) {
 
 		case kZoneGet:
 			free(z->u.get->_backup);
-			_vm->_graphics->freeStaticCnv(&z->u.get->_cnv);
+			_vm->_gfx->freeStaticCnv(&z->u.get->_cnv);
 			free(z->u.get);
 			break;
 
@@ -188,7 +188,7 @@ void freeZones(Node *list) {
 
 		free(z->_label._text);
 		z->_label._text = NULL;
-		_vm->_graphics->freeStaticCnv(&z->_label._cnv);
+		_vm->_gfx->freeStaticCnv(&z->_label._cnv);
 		freeCommands(z->_commands);
 
 		z=(Zone*)z->_node._next;
@@ -294,9 +294,9 @@ void Parallaction::parseZoneTypeBlock(Script &script, Zone *z) {
 //				vE0._data1 = doorcnv->field_8[_ax];
 
 				u->door->_background = (byte*)malloc(vE0._width*vE0._height);
-				_graphics->backupDoorBackground(u->door, z->_limits._left, z->_limits._top);
+				_gfx->backupDoorBackground(u->door, z->_limits._left, z->_limits._top);
 
-				_graphics->flatBlitCnv(&vE0, z->_limits._left, z->_limits._top, Graphics::kBitBack, vE0._data1);
+				_gfx->flatBlitCnv(&vE0, z->_limits._left, z->_limits._top, Gfx::kBitBack, vE0._data1);
 			}
 
 			if (!scumm_stricmp(_tokens[0],	"startpos")) {
@@ -314,8 +314,8 @@ void Parallaction::parseZoneTypeBlock(Script &script, Zone *z) {
 				u->get->_backup = (byte*)malloc(vE4->_width*vE4->_height);
 
 				if ((z->_flags & kFlagsRemove) == 0) {
-					_graphics->backupGetBackground(u->get, z->_limits._left, z->_limits._top);
-					_graphics->flatBlitCnv(vE4, z->_limits._left, z->_limits._top, Graphics::kBitBack, vE4->_data1);
+					_gfx->backupGetBackground(u->get, z->_limits._left, z->_limits._top);
+					_gfx->flatBlitCnv(vE4, z->_limits._left, z->_limits._top, Gfx::kBitBack, vE4->_data1);
 				}
 			}
 
@@ -372,17 +372,17 @@ void displayCharacterComment(ExamineData *data) {
 	v3C._data0 = _yourTalk._array[0];
 	v3C._data1 = NULL; //_yourTalk.field_8[0];
 
-	_vm->_graphics->setFont("comic");
-	_vm->_graphics->flatBlitCnv(&v3C, 190, 80, Graphics::kBitFront, v3C._data1);
+	_vm->_gfx->setFont("comic");
+	_vm->_gfx->flatBlitCnv(&v3C, 190, 80, Gfx::kBitFront, v3C._data1);
 
 	int16 v26, v28;
-	_vm->_graphics->getStringExtent(data->_description, 130, &v28, &v26);
-	_vm->_graphics->drawBalloon(140, 10, v28, v26, 0);
-	_vm->_graphics->displayWrappedString(data->_description, 140, 10, 130, 0);
+	_vm->_gfx->getStringExtent(data->_description, 130, &v28, &v26);
+	_vm->_gfx->drawBalloon(140, 10, v28, v26, 0);
+	_vm->_gfx->displayWrappedString(data->_description, 140, 10, 130, 0);
 
 	waitUntilLeftClick();
 
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
 	return;
 }
@@ -403,22 +403,22 @@ void displayItemComment(ExamineData *data) {
 	char v68[PATH_LEN];
 	strcpy(v68, data->_filename);
 	_vm->_disk->loadStatic(v68, &data->_cnv);
-	_vm->_graphics->flatBlitCnv(&data->_cnv, 140, (SCREEN_HEIGHT - data->_cnv._height)/2, Graphics::kBitFront, data->_cnv._data1);
-	_vm->_graphics->freeStaticCnv(&data->_cnv);
+	_vm->_gfx->flatBlitCnv(&data->_cnv, 140, (SCREEN_HEIGHT - data->_cnv._height)/2, Gfx::kBitFront, data->_cnv._data1);
+	_vm->_gfx->freeStaticCnv(&data->_cnv);
 
 	int16 v6A = 0, v6C = 0;
 
-	_vm->_graphics->setFont("comic");
-	_vm->_graphics->getStringExtent(data->_description, 130, &v6C, &v6A);
-	_vm->_graphics->drawBalloon(0, 90, v6C, v6A, 0);
-	_vm->_graphics->flatBlitCnv(&_yourHead, 100, 152, Graphics::kBitFront, _yourHead._data1);
-	_vm->_graphics->displayWrappedString(data->_description, 0, 90, 130, 0);
+	_vm->_gfx->setFont("comic");
+	_vm->_gfx->getStringExtent(data->_description, 130, &v6C, &v6A);
+	_vm->_gfx->drawBalloon(0, 90, v6C, v6A, 0);
+	_vm->_gfx->flatBlitCnv(&_yourHead, 100, 152, Gfx::kBitFront, _yourHead._data1);
+	_vm->_gfx->displayWrappedString(data->_description, 0, 90, 130, 0);
 
 	jobEraseAnimations((void*)1, NULL);
 
 	waitUntilLeftClick();
 
-	_vm->_graphics->copyScreen(Graphics::kBitBack, Graphics::kBitFront);
+	_vm->_gfx->copyScreen(Gfx::kBitBack, Gfx::kBitFront);
 
 	return;
 }
@@ -487,14 +487,14 @@ void jobToggleDoor(void *parm, Job *j) {
 		v14._width = v18->_width;
 		v14._height = v18->_height;
 
-		_vm->_graphics->restoreZoneBackground(z->u.door->_background, z->_limits._left, z->_limits._top, v18->_width, v18->_height);
+		_vm->_gfx->restoreZoneBackground(z->u.door->_background, z->_limits._left, z->_limits._top, v18->_width, v18->_height);
 
 		uint16 _ax = (z->_flags & kFlagsClosed ? 0 : 1);
 
 		v14._data0 = v18->_array[_ax];
 
-		_vm->_graphics->flatBlitCnv(&v14, z->_limits._left, z->_limits._top, Graphics::kBitBack, v14._data1);
-		_vm->_graphics->flatBlitCnv(&v14, z->_limits._left, z->_limits._top, Graphics::kBit2, v14._data1);
+		_vm->_gfx->flatBlitCnv(&v14, z->_limits._left, z->_limits._top, Gfx::kBitBack, v14._data1);
+		_vm->_gfx->flatBlitCnv(&v14, z->_limits._left, z->_limits._top, Gfx::kBit2, v14._data1);
 	}
 
 	count++;
@@ -522,7 +522,7 @@ void jobRemovePickedItem(void *parm, Job *j) {
 	static uint16 count = 0;
 
 	if (z->u.get->_cnv._width != 0) {
-		_vm->_graphics->restoreZoneBackground(z->u.get->_backup, z->_limits._left, z->_limits._top, z->u.get->_cnv._width, z->u.get->_cnv._height);
+		_vm->_gfx->restoreZoneBackground(z->u.get->_backup, z->_limits._left, z->_limits._top, z->u.get->_cnv._width, z->u.get->_cnv._height);
 	}
 
 	count++;
@@ -541,11 +541,11 @@ void jobDisplayDroppedItem(void *parm, Job *j) {
 
 	if (&z->u.get->_cnv != NULL) {
 		if (z->u.get->_cnv._data0 != NULL) {
-			_vm->_graphics->backupGetBackground(z->u.get, z->_limits._left, z->_limits._top);
+			_vm->_gfx->backupGetBackground(z->u.get, z->_limits._left, z->_limits._top);
 		}
 
-		_vm->_graphics->flatBlitCnv(&z->u.get->_cnv, z->_limits._left, z->_limits._top, Graphics::kBitBack, z->u.get->_cnv._data1);
-		_vm->_graphics->flatBlitCnv(&z->u.get->_cnv, z->_limits._left, z->_limits._top, Graphics::kBit2, z->u.get->_cnv._data1);
+		_vm->_gfx->flatBlitCnv(&z->u.get->_cnv, z->_limits._left, z->_limits._top, Gfx::kBitBack, z->u.get->_cnv._data1);
+		_vm->_gfx->flatBlitCnv(&z->u.get->_cnv, z->_limits._left, z->_limits._top, Gfx::kBit2, z->u.get->_cnv._data1);
 	}
 
 	j->_count++;