Mass renaming of selector-related functions, and removed some defines which were just cloaking functions with a different name

- GET_SEL32 -> readSelector
- GET_SEL32V -> readSelectorValue
- PUT_SEL32 -> writeSelector
- PUT_SEL32V -> writeSelectorValue
Also, changed some selector-related function names and variables to CamelCase

svn-id: r49317

7 files changed, 121 insertions, 121 deletions

diff --git a/engines/sci/graphics/animate.cpp b/engines/sci/graphics/animate.cpp
index 8a03c9579b..c201b2cfb7 100644
--- a/engines/sci/graphics/animate.cpp
+++ b/engines/sci/graphics/animate.cpp
@@ -92,10 +92,10 @@ bool GfxAnimate::invoke(List *list, int argc, reg_t *argv) {
 			}
 		}
 
-		signal = GET_SEL32V(_s->_segMan, curObject, SELECTOR(signal));
+		signal = readSelectorValue(_s->_segMan, curObject, SELECTOR(signal));
 		if (!(signal & kSignalFrozen)) {
 			// Call .doit method of that object
-			invoke_selector(_s, curObject, g_sci->getKernel()->_selectorCache.doit, kContinueOnInvalidSelector, argc, argv, 0);
+			invokeSelector(_s, curObject, g_sci->getKernel()->_selectorCache.doit, kContinueOnInvalidSelector, argc, argv, 0);
 			// Lookup node again, since the nodetable it was in may have been reallocated
 			curNode = _s->_segMan->lookupNode(curAddress);
 		}
@@ -165,21 +165,21 @@ void GfxAnimate::makeSortedList(List *list) {
 
 		// Get data from current object
 		listEntry->givenOrderNo = listNr;
-		listEntry->viewId = GET_SEL32V(_s->_segMan, curObject, SELECTOR(view));
-		listEntry->loopNo = GET_SEL32V(_s->_segMan, curObject, SELECTOR(loop));
-		listEntry->celNo = GET_SEL32V(_s->_segMan, curObject, SELECTOR(cel));
-		listEntry->paletteNo = GET_SEL32V(_s->_segMan, curObject, SELECTOR(palette));
-		listEntry->x = GET_SEL32V(_s->_segMan, curObject, SELECTOR(x));
-		listEntry->y = GET_SEL32V(_s->_segMan, curObject, SELECTOR(y));
-		listEntry->z = GET_SEL32V(_s->_segMan, curObject, SELECTOR(z));
-		listEntry->priority = GET_SEL32V(_s->_segMan, curObject, SELECTOR(priority));
-		listEntry->signal = GET_SEL32V(_s->_segMan, curObject, SELECTOR(signal));
+		listEntry->viewId = readSelectorValue(_s->_segMan, curObject, SELECTOR(view));
+		listEntry->loopNo = readSelectorValue(_s->_segMan, curObject, SELECTOR(loop));
+		listEntry->celNo = readSelectorValue(_s->_segMan, curObject, SELECTOR(cel));
+		listEntry->paletteNo = readSelectorValue(_s->_segMan, curObject, SELECTOR(palette));
+		listEntry->x = readSelectorValue(_s->_segMan, curObject, SELECTOR(x));
+		listEntry->y = readSelectorValue(_s->_segMan, curObject, SELECTOR(y));
+		listEntry->z = readSelectorValue(_s->_segMan, curObject, SELECTOR(z));
+		listEntry->priority = readSelectorValue(_s->_segMan, curObject, SELECTOR(priority));
+		listEntry->signal = readSelectorValue(_s->_segMan, curObject, SELECTOR(signal));
 		if (getSciVersion() >= SCI_VERSION_1_1) {
 			// Cel scaling
-			listEntry->scaleSignal = GET_SEL32V(_s->_segMan, curObject, SELECTOR(scaleSignal));
+			listEntry->scaleSignal = readSelectorValue(_s->_segMan, curObject, SELECTOR(scaleSignal));
 			if (listEntry->scaleSignal & kScaleSignalDoScaling) {
-				listEntry->scaleX = GET_SEL32V(_s->_segMan, curObject, SELECTOR(scaleX));
-				listEntry->scaleY = GET_SEL32V(_s->_segMan, curObject, SELECTOR(scaleY));
+				listEntry->scaleX = readSelectorValue(_s->_segMan, curObject, SELECTOR(scaleX));
+				listEntry->scaleY = readSelectorValue(_s->_segMan, curObject, SELECTOR(scaleY));
 			} else {
 				listEntry->scaleX = 128;
 				listEntry->scaleY = 128;
@@ -228,11 +228,11 @@ void GfxAnimate::fill(byte &old_picNotValid) {
 		// adjust loop and cel, if any of those is invalid
 		if (listEntry->loopNo >= view->getLoopCount()) {
 			listEntry->loopNo = 0;
-			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(loop), listEntry->loopNo);
+			writeSelectorValue(_s->_segMan, curObject, SELECTOR(loop), listEntry->loopNo);
 		}
 		if (listEntry->celNo >= view->getCelCount(listEntry->loopNo)) {
 			listEntry->celNo = 0;
-			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(cel), listEntry->celNo);
+			writeSelectorValue(_s->_segMan, curObject, SELECTOR(cel), listEntry->celNo);
 		}
 
 		// Create rect according to coordinates and given cel
@@ -241,17 +241,17 @@ void GfxAnimate::fill(byte &old_picNotValid) {
 		} else {
 			view->getCelRect(listEntry->loopNo, listEntry->celNo, listEntry->x, listEntry->y, listEntry->z, &listEntry->celRect);
 		}
-		PUT_SEL32V(_s->_segMan, curObject, SELECTOR(nsLeft), listEntry->celRect.left);
-		PUT_SEL32V(_s->_segMan, curObject, SELECTOR(nsTop), listEntry->celRect.top);
-		PUT_SEL32V(_s->_segMan, curObject, SELECTOR(nsRight), listEntry->celRect.right);
-		PUT_SEL32V(_s->_segMan, curObject, SELECTOR(nsBottom), listEntry->celRect.bottom);
+		writeSelectorValue(_s->_segMan, curObject, SELECTOR(nsLeft), listEntry->celRect.left);
+		writeSelectorValue(_s->_segMan, curObject, SELECTOR(nsTop), listEntry->celRect.top);
+		writeSelectorValue(_s->_segMan, curObject, SELECTOR(nsRight), listEntry->celRect.right);
+		writeSelectorValue(_s->_segMan, curObject, SELECTOR(nsBottom), listEntry->celRect.bottom);
 
 		signal = listEntry->signal;
 
 		// Calculate current priority according to y-coordinate
 		if (!(signal & kSignalFixedPriority)) {
 			listEntry->priority = _ports->kernelCoordinateToPriority(listEntry->y);
-			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(priority), listEntry->priority);
+			writeSelectorValue(_s->_segMan, curObject, SELECTOR(priority), listEntry->priority);
 		}
 
 		if (signal & kSignalNoUpdate) {
@@ -291,14 +291,14 @@ void GfxAnimate::update() {
 
 		if (signal & kSignalNoUpdate) {
 			if (!(signal & kSignalRemoveView)) {
-				bitsHandle = GET_SEL32(_s->_segMan, curObject, SELECTOR(underBits));
+				bitsHandle = readSelector(_s->_segMan, curObject, SELECTOR(underBits));
 				if (_screen->_picNotValid != 1) {
 					_paint16->bitsRestore(bitsHandle);
 					listEntry->showBitsFlag = true;
 				} else	{
 					_paint16->bitsFree(bitsHandle);
 				}
-				PUT_SEL32V(_s->_segMan, curObject, SELECTOR(underBits), 0);
+				writeSelectorValue(_s->_segMan, curObject, SELECTOR(underBits), 0);
 			}
 			signal &= 0xFFFF ^ kSignalForceUpdate;
 			signal &= signal & kSignalViewUpdated ? 0xFFFF ^ (kSignalViewUpdated | kSignalNoUpdate) : 0xFFFF;
@@ -348,7 +348,7 @@ void GfxAnimate::update() {
 					bitsHandle = _paint16->bitsSave(listEntry->celRect, GFX_SCREEN_MASK_VISUAL|GFX_SCREEN_MASK_PRIORITY);
 				else
 					bitsHandle = _paint16->bitsSave(listEntry->celRect, GFX_SCREEN_MASK_ALL);
-				PUT_SEL32(_s->_segMan, curObject, SELECTOR(underBits), bitsHandle);
+				writeSelector(_s->_segMan, curObject, SELECTOR(underBits), bitsHandle);
 			}
 			listEntry->signal = signal;
 		}
@@ -396,7 +396,7 @@ void GfxAnimate::drawCels() {
 		if (!(signal & (kSignalNoUpdate | kSignalHidden | kSignalAlwaysUpdate))) {
 			// Save background
 			bitsHandle = _paint16->bitsSave(listEntry->celRect, GFX_SCREEN_MASK_ALL);
-			PUT_SEL32(_s->_segMan, curObject, SELECTOR(underBits), bitsHandle);
+			writeSelector(_s->_segMan, curObject, SELECTOR(underBits), bitsHandle);
 
 			// draw corresponding cel
 			_paint16->drawCel(listEntry->viewId, listEntry->loopNo, listEntry->celNo, listEntry->celRect, listEntry->priority, listEntry->paletteNo, listEntry->scaleX, listEntry->scaleY);
@@ -432,10 +432,10 @@ void GfxAnimate::updateScreen(byte oldPicNotValid) {
 
 		if (listEntry->showBitsFlag || !(signal & (kSignalRemoveView | kSignalNoUpdate) ||
 										(!(signal & kSignalRemoveView) && (signal & kSignalNoUpdate) && oldPicNotValid))) {
-			lsRect.left = GET_SEL32V(_s->_segMan, curObject, SELECTOR(lsLeft));
-			lsRect.top = GET_SEL32V(_s->_segMan, curObject, SELECTOR(lsTop));
-			lsRect.right = GET_SEL32V(_s->_segMan, curObject, SELECTOR(lsRight));
-			lsRect.bottom = GET_SEL32V(_s->_segMan, curObject, SELECTOR(lsBottom));
+			lsRect.left = readSelectorValue(_s->_segMan, curObject, SELECTOR(lsLeft));
+			lsRect.top = readSelectorValue(_s->_segMan, curObject, SELECTOR(lsTop));
+			lsRect.right = readSelectorValue(_s->_segMan, curObject, SELECTOR(lsRight));
+			lsRect.bottom = readSelectorValue(_s->_segMan, curObject, SELECTOR(lsBottom));
 
 			workerRect = lsRect;
 			workerRect.clip(listEntry->celRect);
@@ -447,10 +447,10 @@ void GfxAnimate::updateScreen(byte oldPicNotValid) {
 				_paint16->bitsShow(lsRect);
 				workerRect = listEntry->celRect;
 			}
-			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(lsLeft), workerRect.left);
-			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(lsTop), workerRect.top);
-			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(lsRight), workerRect.right);
-			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(lsBottom), workerRect.bottom);
+			writeSelectorValue(_s->_segMan, curObject, SELECTOR(lsLeft), workerRect.left);
+			writeSelectorValue(_s->_segMan, curObject, SELECTOR(lsTop), workerRect.top);
+			writeSelectorValue(_s->_segMan, curObject, SELECTOR(lsRight), workerRect.right);
+			writeSelectorValue(_s->_segMan, curObject, SELECTOR(lsBottom), workerRect.bottom);
 			_paint16->bitsShow(workerRect);
 
 			if (signal & kSignalHidden) {
@@ -481,7 +481,7 @@ void GfxAnimate::restoreAndDelete(int argc, reg_t *argv) {
 		signal = listEntry->signal;
 
 		// Finally update signal
-		PUT_SEL32V(_s->_segMan, curObject, SELECTOR(signal), signal);
+		writeSelectorValue(_s->_segMan, curObject, SELECTOR(signal), signal);
 		listIterator++;
 	}
 
@@ -490,16 +490,16 @@ void GfxAnimate::restoreAndDelete(int argc, reg_t *argv) {
 		listEntry = *listIterator;
 		curObject = listEntry->object;
 		// We read out signal here again, this is not by accident but to ensure that we got an up-to-date signal
-		signal = GET_SEL32V(_s->_segMan, curObject, SELECTOR(signal));
+		signal = readSelectorValue(_s->_segMan, curObject, SELECTOR(signal));
 
 		if ((signal & (kSignalNoUpdate | kSignalRemoveView)) == 0) {
-			_paint16->bitsRestore(GET_SEL32(_s->_segMan, curObject, SELECTOR(underBits)));
-			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(underBits), 0);
+			_paint16->bitsRestore(readSelector(_s->_segMan, curObject, SELECTOR(underBits)));
+			writeSelectorValue(_s->_segMan, curObject, SELECTOR(underBits), 0);
 		}
 
 		if (signal & kSignalDisposeMe) {
 			// Call .delete_ method of that object
-			invoke_selector(_s, curObject, g_sci->getKernel()->_selectorCache.delete_, kContinueOnInvalidSelector, argc, argv, 0);
+			invokeSelector(_s, curObject, g_sci->getKernel()->_selectorCache.delete_, kContinueOnInvalidSelector, argc, argv, 0);
 		}
 		listIterator--;
 	}
diff --git a/engines/sci/graphics/compare.cpp b/engines/sci/graphics/compare.cpp
index 36dd2d4aed..3102edc2fa 100644
--- a/engines/sci/graphics/compare.cpp
+++ b/engines/sci/graphics/compare.cpp
@@ -79,12 +79,12 @@ bool GfxCompare::canBeHereCheckRectList(reg_t checkObject, const Common::Rect &c
 	while (curNode) {
 		curObject = curNode->value;
 		if (curObject != checkObject) {
-			signal = GET_SEL32V(_segMan, curObject, SELECTOR(signal));
+			signal = readSelectorValue(_segMan, curObject, SELECTOR(signal));
 			if ((signal & (kSignalIgnoreActor | kSignalRemoveView | kSignalNoUpdate)) == 0) {
-				curRect.left = GET_SEL32V(_segMan, curObject, SELECTOR(brLeft));
-				curRect.top = GET_SEL32V(_segMan, curObject, SELECTOR(brTop));
-				curRect.right = GET_SEL32V(_segMan, curObject, SELECTOR(brRight));
-				curRect.bottom = GET_SEL32V(_segMan, curObject, SELECTOR(brBottom));
+				curRect.left = readSelectorValue(_segMan, curObject, SELECTOR(brLeft));
+				curRect.top = readSelectorValue(_segMan, curObject, SELECTOR(brTop));
+				curRect.right = readSelectorValue(_segMan, curObject, SELECTOR(brRight));
+				curRect.bottom = readSelectorValue(_segMan, curObject, SELECTOR(brBottom));
 				// Check if curRect is within checkRect
 				// TODO: This check is slightly odd, because it means that a rect is not contained
 				// in itself. It may very well be that the original SCI engine did it just
@@ -115,29 +115,29 @@ uint16 GfxCompare::kernelOnControl(byte screenMask, const Common::Rect &rect) {
 void GfxCompare::kernelSetNowSeen(reg_t objectReference) {
 	GfxView *view = NULL;
 	Common::Rect celRect(0, 0);
-	GuiResourceId viewId = (GuiResourceId)GET_SEL32V(_segMan, objectReference, SELECTOR(view));
+	GuiResourceId viewId = (GuiResourceId)readSelectorValue(_segMan, objectReference, SELECTOR(view));
 
 	// HACK: Ignore invalid views for now (perhaps unimplemented text views?)
 	if (viewId == 0xFFFF)	// invalid view
 		return;
 
-	int16 loopNo = GET_SEL32V(_segMan, objectReference, SELECTOR(loop));
-	int16 celNo = GET_SEL32V(_segMan, objectReference, SELECTOR(cel));
-	int16 x = (int16)GET_SEL32V(_segMan, objectReference, SELECTOR(x));
-	int16 y = (int16)GET_SEL32V(_segMan, objectReference, SELECTOR(y));
+	int16 loopNo = readSelectorValue(_segMan, objectReference, SELECTOR(loop));
+	int16 celNo = readSelectorValue(_segMan, objectReference, SELECTOR(cel));
+	int16 x = (int16)readSelectorValue(_segMan, objectReference, SELECTOR(x));
+	int16 y = (int16)readSelectorValue(_segMan, objectReference, SELECTOR(y));
 	int16 z = 0;
 	if (_kernel->_selectorCache.z > -1)
-		z = (int16)GET_SEL32V(_segMan, objectReference, SELECTOR(z));
+		z = (int16)readSelectorValue(_segMan, objectReference, SELECTOR(z));
 
 	// now get cel rectangle
 	view = _cache->getView(viewId);
 	view->getCelRect(loopNo, celNo, x, y, z, &celRect);
 
-	if (lookup_selector(_segMan, objectReference, _kernel->_selectorCache.nsTop, NULL, NULL) == kSelectorVariable) {
-		PUT_SEL32V(_segMan, objectReference, SELECTOR(nsLeft), celRect.left);
-		PUT_SEL32V(_segMan, objectReference, SELECTOR(nsRight), celRect.right);
-		PUT_SEL32V(_segMan, objectReference, SELECTOR(nsTop), celRect.top);
-		PUT_SEL32V(_segMan, objectReference, SELECTOR(nsBottom), celRect.bottom);
+	if (lookupSelector(_segMan, objectReference, _kernel->_selectorCache.nsTop, NULL, NULL) == kSelectorVariable) {
+		writeSelectorValue(_segMan, objectReference, SELECTOR(nsLeft), celRect.left);
+		writeSelectorValue(_segMan, objectReference, SELECTOR(nsRight), celRect.right);
+		writeSelectorValue(_segMan, objectReference, SELECTOR(nsTop), celRect.top);
+		writeSelectorValue(_segMan, objectReference, SELECTOR(nsBottom), celRect.bottom);
 	}
 }
 
@@ -147,10 +147,10 @@ bool GfxCompare::kernelCanBeHere(reg_t curObject, reg_t listReference) {
 	uint16 signal, controlMask;
 	bool result;
 
-	checkRect.left = GET_SEL32V(_segMan, curObject, SELECTOR(brLeft));
-	checkRect.top = GET_SEL32V(_segMan, curObject, SELECTOR(brTop));
-	checkRect.right = GET_SEL32V(_segMan, curObject, SELECTOR(brRight));
-	checkRect.bottom = GET_SEL32V(_segMan, curObject, SELECTOR(brBottom));
+	checkRect.left = readSelectorValue(_segMan, curObject, SELECTOR(brLeft));
+	checkRect.top = readSelectorValue(_segMan, curObject, SELECTOR(brTop));
+	checkRect.right = readSelectorValue(_segMan, curObject, SELECTOR(brRight));
+	checkRect.bottom = readSelectorValue(_segMan, curObject, SELECTOR(brBottom));
 
 	if (!checkRect.isValidRect()) {	// can occur in Iceman - HACK? TODO: is this really occuring in sierra sci? check this
 		warning("kCan(t)BeHere - invalid rect %d, %d -> %d, %d", checkRect.left, checkRect.top, checkRect.right, checkRect.bottom);
@@ -159,8 +159,8 @@ bool GfxCompare::kernelCanBeHere(reg_t curObject, reg_t listReference) {
 
 	adjustedRect = _coordAdjuster->onControl(checkRect);
 
-	signal = GET_SEL32V(_segMan, curObject, SELECTOR(signal));
-	controlMask = GET_SEL32V(_segMan, curObject, SELECTOR(illegalBits));
+	signal = readSelectorValue(_segMan, curObject, SELECTOR(signal));
+	controlMask = readSelectorValue(_segMan, curObject, SELECTOR(illegalBits));
 	result = (isOnControl(GFX_SCREEN_MASK_CONTROL, adjustedRect) & controlMask) ? false : true;
 	if ((result) && (signal & (kSignalIgnoreActor | kSignalRemoveView)) == 0) {
 		List *list = _segMan->lookupList(listReference);
@@ -183,14 +183,14 @@ bool GfxCompare::kernelIsItSkip(GuiResourceId viewId, int16 loopNo, int16 celNo,
 }
 
 void GfxCompare::kernelBaseSetter(reg_t object) {
-	if (lookup_selector(_segMan, object, _kernel->_selectorCache.brLeft, NULL, NULL) == kSelectorVariable) {
-		int16 x = GET_SEL32V(_segMan, object, SELECTOR(x));
-		int16 y = GET_SEL32V(_segMan, object, SELECTOR(y));
-		int16 z = (_kernel->_selectorCache.z > -1) ? GET_SEL32V(_segMan, object, SELECTOR(z)) : 0;
-		int16 yStep = GET_SEL32V(_segMan, object, SELECTOR(yStep));
-		GuiResourceId viewId = GET_SEL32V(_segMan, object, SELECTOR(view));
-		int16 loopNo = GET_SEL32V(_segMan, object, SELECTOR(loop));
-		int16 celNo = GET_SEL32V(_segMan, object, SELECTOR(cel));
+	if (lookupSelector(_segMan, object, _kernel->_selectorCache.brLeft, NULL, NULL) == kSelectorVariable) {
+		int16 x = readSelectorValue(_segMan, object, SELECTOR(x));
+		int16 y = readSelectorValue(_segMan, object, SELECTOR(y));
+		int16 z = (_kernel->_selectorCache.z > -1) ? readSelectorValue(_segMan, object, SELECTOR(z)) : 0;
+		int16 yStep = readSelectorValue(_segMan, object, SELECTOR(yStep));
+		GuiResourceId viewId = readSelectorValue(_segMan, object, SELECTOR(view));
+		int16 loopNo = readSelectorValue(_segMan, object, SELECTOR(loop));
+		int16 celNo = readSelectorValue(_segMan, object, SELECTOR(cel));
 
 		// HACK: Ignore invalid views for now (perhaps unimplemented text views?)
 		if (viewId == 0xFFFF)	// invalid view
@@ -203,10 +203,10 @@ void GfxCompare::kernelBaseSetter(reg_t object) {
 		celRect.bottom = y + 1;
 		celRect.top = celRect.bottom - yStep;
 
-		PUT_SEL32V(_segMan, object, SELECTOR(brLeft), celRect.left);
-		PUT_SEL32V(_segMan, object, SELECTOR(brRight), celRect.right);
-		PUT_SEL32V(_segMan, object, SELECTOR(brTop), celRect.top);
-		PUT_SEL32V(_segMan, object, SELECTOR(brBottom), celRect.bottom);
+		writeSelectorValue(_segMan, object, SELECTOR(brLeft), celRect.left);
+		writeSelectorValue(_segMan, object, SELECTOR(brRight), celRect.right);
+		writeSelectorValue(_segMan, object, SELECTOR(brTop), celRect.top);
+		writeSelectorValue(_segMan, object, SELECTOR(brBottom), celRect.bottom);
 	}
 }
 
diff --git a/engines/sci/graphics/controls.cpp b/engines/sci/graphics/controls.cpp
index f744d6e7f1..26af9741c2 100644
--- a/engines/sci/graphics/controls.cpp
+++ b/engines/sci/graphics/controls.cpp
@@ -143,9 +143,9 @@ void GfxControls::texteditSetBlinkTime() {
 }
 
 void GfxControls::kernelTexteditChange(reg_t controlObject, reg_t eventObject) {
-	uint16 cursorPos = GET_SEL32V(_segMan, controlObject, SELECTOR(cursor));
-	uint16 maxChars = GET_SEL32V(_segMan, controlObject, SELECTOR(max));
-	reg_t textReference = GET_SEL32(_segMan, controlObject, SELECTOR(text));
+	uint16 cursorPos = readSelectorValue(_segMan, controlObject, SELECTOR(cursor));
+	uint16 maxChars = readSelectorValue(_segMan, controlObject, SELECTOR(max));
+	reg_t textReference = readSelector(_segMan, controlObject, SELECTOR(text));
 	Common::String text;
 	uint16 textSize, eventType, eventKey = 0;
 	bool textChanged = false;
@@ -158,14 +158,14 @@ void GfxControls::kernelTexteditChange(reg_t controlObject, reg_t eventObject) {
 
 	if (!eventObject.isNull()) {
 		textSize = text.size();
-		eventType = GET_SEL32V(_segMan, eventObject, SELECTOR(type));
+		eventType = readSelectorValue(_segMan, eventObject, SELECTOR(type));
 
 		switch (eventType) {
 		case SCI_EVENT_MOUSE_PRESS:
 			// TODO: Implement mouse support for cursor change
 			break;
 		case SCI_EVENT_KEYBOARD:
-			eventKey = GET_SEL32V(_segMan, eventObject, SELECTOR(message));
+			eventKey = readSelectorValue(_segMan, eventObject, SELECTOR(message));
 			switch (eventKey) {
 			case SCI_KEY_BACKSPACE:
 				if (cursorPos > 0) {
@@ -207,9 +207,9 @@ void GfxControls::kernelTexteditChange(reg_t controlObject, reg_t eventObject) {
 
 	if (textChanged) {
 		GuiResourceId oldFontId = _text16->GetFontId();
-		GuiResourceId fontId = GET_SEL32V(_segMan, controlObject, SELECTOR(font));
-		rect = Common::Rect(GET_SEL32V(_segMan, controlObject, SELECTOR(nsLeft)), GET_SEL32V(_segMan, controlObject, SELECTOR(nsTop)),
-							  GET_SEL32V(_segMan, controlObject, SELECTOR(nsRight)), GET_SEL32V(_segMan, controlObject, SELECTOR(nsBottom)));
+		GuiResourceId fontId = readSelectorValue(_segMan, controlObject, SELECTOR(font));
+		rect = Common::Rect(readSelectorValue(_segMan, controlObject, SELECTOR(nsLeft)), readSelectorValue(_segMan, controlObject, SELECTOR(nsTop)),
+							  readSelectorValue(_segMan, controlObject, SELECTOR(nsRight)), readSelectorValue(_segMan, controlObject, SELECTOR(nsBottom)));
 		_text16->SetFont(fontId);
 		if (textAddChar) {
 			// We check, if we are really able to add the new char
@@ -241,7 +241,7 @@ void GfxControls::kernelTexteditChange(reg_t controlObject, reg_t eventObject) {
 		}
 	}
 
-	PUT_SEL32V(_segMan, controlObject, SELECTOR(cursor), cursorPos);
+	writeSelectorValue(_segMan, controlObject, SELECTOR(cursor), cursorPos);
 }
 
 int GfxControls::getPicNotValid() {
diff --git a/engines/sci/graphics/coordadjuster.cpp b/engines/sci/graphics/coordadjuster.cpp
index 40ef655be7..422df52f27 100644
--- a/engines/sci/graphics/coordadjuster.cpp
+++ b/engines/sci/graphics/coordadjuster.cpp
@@ -93,18 +93,18 @@ GfxCoordAdjuster32::~GfxCoordAdjuster32() {
 }
 
 void GfxCoordAdjuster32::kernelGlobalToLocal(int16 &x, int16 &y, reg_t planeObject) {
-	//int16 resY = GET_SEL32V(_s->_segMan, planeObj, SELECTOR(resY));
-	//int16 resX = GET_SEL32V(_s->_segMan, planeObj, SELECTOR(resX));
+	//int16 resY = readSelectorValue(_s->_segMan, planeObj, SELECTOR(resY));
+	//int16 resX = readSelectorValue(_s->_segMan, planeObj, SELECTOR(resX));
 	//*x = ( *x * _screen->getWidth()) / resX;
 	//*y = ( *y * _screen->getHeight()) / resY;
-	x -= GET_SEL32V(_segMan, planeObject, SELECTOR(left));
-	y -= GET_SEL32V(_segMan, planeObject, SELECTOR(top));
+	x -= readSelectorValue(_segMan, planeObject, SELECTOR(left));
+	y -= readSelectorValue(_segMan, planeObject, SELECTOR(top));
 }
 void GfxCoordAdjuster32::kernelLocalToGlobal(int16 &x, int16 &y, reg_t planeObject) {
-	//int16 resY = GET_SEL32V(_s->_segMan, planeObj, SELECTOR(resY));
-	//int16 resX = GET_SEL32V(_s->_segMan, planeObj, SELECTOR(resX));
-	x += GET_SEL32V(_segMan, planeObject, SELECTOR(left));
-	y += GET_SEL32V(_segMan, planeObject, SELECTOR(top));
+	//int16 resY = readSelectorValue(_s->_segMan, planeObj, SELECTOR(resY));
+	//int16 resX = readSelectorValue(_s->_segMan, planeObj, SELECTOR(resX));
+	x += readSelectorValue(_segMan, planeObject, SELECTOR(left));
+	y += readSelectorValue(_segMan, planeObject, SELECTOR(top));
 	//*x = ( *x * resX) / _screen->getWidth();
 	//*y = ( *y * resY) / _screen->getHeight();
 }
diff --git a/engines/sci/graphics/frameout.cpp b/engines/sci/graphics/frameout.cpp
index 78253bd913..3cc5ca5447 100644
--- a/engines/sci/graphics/frameout.cpp
+++ b/engines/sci/graphics/frameout.cpp
@@ -54,7 +54,7 @@ GfxFrameout::~GfxFrameout() {
 
 void GfxFrameout::kernelAddPlane(reg_t object) {
 	_planes.push_back(object);
-	int16 planePri = GET_SEL32V(_segMan, object, SELECTOR(priority)) & 0xFFFF;
+	int16 planePri = readSelectorValue(_segMan, object, SELECTOR(priority)) & 0xFFFF;
 	if (planePri > _highPlanePri)
 		_highPlanePri = planePri;
 }
@@ -74,7 +74,7 @@ void GfxFrameout::kernelDeletePlane(reg_t object) {
 	_highPlanePri = 0;
 
 	for (uint32 planeNr = 0; planeNr < _planes.size(); planeNr++) {
-		int16 planePri = GET_SEL32V(_segMan, _planes[planeNr], SELECTOR(priority)) & 0xFFFF;
+		int16 planePri = readSelectorValue(_segMan, _planes[planeNr], SELECTOR(priority)) & 0xFFFF;
 		if (planePri > _highPlanePri)
 			_highPlanePri = planePri;
 	}
@@ -126,29 +126,29 @@ void GfxFrameout::kernelFrameout() {
 
 	for (uint32 planeNr = 0; planeNr < _planes.size(); planeNr++) {
 		planeObject = _planes[planeNr];
-		planePriority = GET_SEL32V(_segMan, planeObject, SELECTOR(priority));
+		planePriority = readSelectorValue(_segMan, planeObject, SELECTOR(priority));
 
 		if (planePriority == -1) // Plane currently not meant to be shown
 			continue;
 
-		planeRect.top = GET_SEL32V(_segMan, planeObject, SELECTOR(top));
-		planeRect.left = GET_SEL32V(_segMan, planeObject, SELECTOR(left));
-		planeRect.bottom = GET_SEL32V(_segMan, planeObject, SELECTOR(bottom));
-		planeRect.right = GET_SEL32V(_segMan, planeObject, SELECTOR(right));
-		planeResY = GET_SEL32V(_segMan, planeObject, SELECTOR(resY));
-		planeResX = GET_SEL32V(_segMan, planeObject, SELECTOR(resX));
+		planeRect.top = readSelectorValue(_segMan, planeObject, SELECTOR(top));
+		planeRect.left = readSelectorValue(_segMan, planeObject, SELECTOR(left));
+		planeRect.bottom = readSelectorValue(_segMan, planeObject, SELECTOR(bottom));
+		planeRect.right = readSelectorValue(_segMan, planeObject, SELECTOR(right));
+		planeResY = readSelectorValue(_segMan, planeObject, SELECTOR(resY));
+		planeResX = readSelectorValue(_segMan, planeObject, SELECTOR(resX));
 
 		planeRect.top = (planeRect.top * _screen->getHeight()) / planeResY;
 		planeRect.left = (planeRect.left * _screen->getWidth()) / planeResX;
 		planeRect.bottom = (planeRect.bottom * _screen->getHeight()) / planeResY;
 		planeRect.right = (planeRect.right * _screen->getWidth()) / planeResX;
 
-		planeBack = GET_SEL32V(_segMan, planeObject, SELECTOR(back));
+		planeBack = readSelectorValue(_segMan, planeObject, SELECTOR(back));
 		if (planeBack) {
 			_paint32->fillRect(planeRect, planeBack);
 		}
 
-		planePictureNr = GET_SEL32V(_segMan, planeObject, SELECTOR(picture));
+		planePictureNr = readSelectorValue(_segMan, planeObject, SELECTOR(picture));
 		if ((planePictureNr != 0xFFFF) && (planePictureNr != 0xFFFE)) {
 			planePicture = new GfxPicture(_resMan, _coordAdjuster, 0, _screen, _palette, planePictureNr, false);
 			planePictureCels = planePicture->getSci32celCount();
@@ -161,19 +161,19 @@ void GfxFrameout::kernelFrameout() {
 		itemEntry = itemData;
 		for (uint32 itemNr = 0; itemNr < _screenItems.size(); itemNr++) {
 			itemObject = _screenItems[itemNr];
-			itemPlane = GET_SEL32(_segMan, itemObject, SELECTOR(plane));
+			itemPlane = readSelector(_segMan, itemObject, SELECTOR(plane));
 			if (planeObject == itemPlane) {
 				// Found an item on current plane
-				itemEntry->viewId = GET_SEL32V(_segMan, itemObject, SELECTOR(view));
-				itemEntry->loopNo = GET_SEL32V(_segMan, itemObject, SELECTOR(loop));
-				itemEntry->celNo = GET_SEL32V(_segMan, itemObject, SELECTOR(cel));
-				itemEntry->x = GET_SEL32V(_segMan, itemObject, SELECTOR(x));
-				itemEntry->y = GET_SEL32V(_segMan, itemObject, SELECTOR(y));
-				itemEntry->z = GET_SEL32V(_segMan, itemObject, SELECTOR(z));
-				itemEntry->priority = GET_SEL32V(_segMan, itemObject, SELECTOR(priority));
-				itemEntry->signal = GET_SEL32V(_segMan, itemObject, SELECTOR(signal));
-				itemEntry->scaleX = GET_SEL32V(_segMan, itemObject, SELECTOR(scaleX));
-				itemEntry->scaleY = GET_SEL32V(_segMan, itemObject, SELECTOR(scaleY));
+				itemEntry->viewId = readSelectorValue(_segMan, itemObject, SELECTOR(view));
+				itemEntry->loopNo = readSelectorValue(_segMan, itemObject, SELECTOR(loop));
+				itemEntry->celNo = readSelectorValue(_segMan, itemObject, SELECTOR(cel));
+				itemEntry->x = readSelectorValue(_segMan, itemObject, SELECTOR(x));
+				itemEntry->y = readSelectorValue(_segMan, itemObject, SELECTOR(y));
+				itemEntry->z = readSelectorValue(_segMan, itemObject, SELECTOR(z));
+				itemEntry->priority = readSelectorValue(_segMan, itemObject, SELECTOR(priority));
+				itemEntry->signal = readSelectorValue(_segMan, itemObject, SELECTOR(signal));
+				itemEntry->scaleX = readSelectorValue(_segMan, itemObject, SELECTOR(scaleX));
+				itemEntry->scaleY = readSelectorValue(_segMan, itemObject, SELECTOR(scaleY));
 				itemEntry->object = itemObject;
 
 				itemEntry->y = ((itemEntry->y * _screen->getHeight()) / planeResY);
@@ -240,12 +240,12 @@ void GfxFrameout::kernelFrameout() {
 				// This doesn't work for SCI2.1 games...
 				if (getSciVersion() == SCI_VERSION_2) {
 					Kernel *kernel = g_sci->getKernel();
-					if (lookup_selector(_segMan, itemEntry->object, kernel->_selectorCache.text, NULL, NULL) == kSelectorVariable) {
-						Common::String text = _segMan->getString(GET_SEL32(_segMan, itemEntry->object, SELECTOR(text)));
-						int16 fontRes = GET_SEL32V(_segMan, itemEntry->object, SELECTOR(font));
+					if (lookupSelector(_segMan, itemEntry->object, kernel->_selectorCache.text, NULL, NULL) == kSelectorVariable) {
+						Common::String text = _segMan->getString(readSelector(_segMan, itemEntry->object, SELECTOR(text)));
+						int16 fontRes = readSelectorValue(_segMan, itemEntry->object, SELECTOR(font));
 						GfxFont *font = new GfxFontFromResource(_resMan, _screen, fontRes);
-						bool dimmed = GET_SEL32V(_segMan, itemEntry->object, SELECTOR(dimmed));
-						uint16 foreColor = GET_SEL32V(_segMan, itemEntry->object, SELECTOR(fore));
+						bool dimmed = readSelectorValue(_segMan, itemEntry->object, SELECTOR(dimmed));
+						uint16 foreColor = readSelectorValue(_segMan, itemEntry->object, SELECTOR(fore));
 						uint16 curX = itemEntry->x;
 						uint16 curY = itemEntry->y;
 						for (uint32 i = 0; i < text.size(); i++) {
diff --git a/engines/sci/graphics/maciconbar.cpp b/engines/sci/graphics/maciconbar.cpp
index 2904bda22b..a06e98ccbf 100644
--- a/engines/sci/graphics/maciconbar.cpp
+++ b/engines/sci/graphics/maciconbar.cpp
@@ -48,7 +48,7 @@ void GfxMacIconBar::drawIcons() {
 	uint32 lastX = 0;
 
 	for (uint32 i = 0; i < _iconBarObjects.size(); i++) {
-		uint32 iconIndex = GET_SEL32V(g_sci->getEngineState()->_segMan, _iconBarObjects[i], SELECTOR(iconIndex));
+		uint32 iconIndex = readSelectorValue(g_sci->getEngineState()->_segMan, _iconBarObjects[i], SELECTOR(iconIndex));
 		Resource *res = g_sci->getResMan()->findResource(ResourceId(kResourceTypeMacIconBarPictN, iconIndex + 1), false);
 		if (!res)
 			continue;
diff --git a/engines/sci/graphics/menu.cpp b/engines/sci/graphics/menu.cpp
index 5e3b419fe3..880e1aba12 100644
--- a/engines/sci/graphics/menu.cpp
+++ b/engines/sci/graphics/menu.cpp
@@ -378,7 +378,7 @@ void GfxMenu::calculateMenuAndItemWidth() {
 }
 
 reg_t GfxMenu::kernelSelect(reg_t eventObject) {
-	int16 eventType = GET_SEL32V(_segMan, eventObject, SELECTOR(type));
+	int16 eventType = readSelectorValue(_segMan, eventObject, SELECTOR(type));
 	int16 keyPress, keyModifier;
 	Common::Point mousePosition;
 	GuiMenuItemList::iterator itemIterator = _itemList.begin();
@@ -390,8 +390,8 @@ reg_t GfxMenu::kernelSelect(reg_t eventObject) {
 
 	switch (eventType) {
 	case SCI_EVENT_KEYBOARD:
-		keyPress = GET_SEL32V(_segMan, eventObject, SELECTOR(message));
-		keyModifier = GET_SEL32V(_segMan, eventObject, SELECTOR(modifiers));
+		keyPress = readSelectorValue(_segMan, eventObject, SELECTOR(message));
+		keyModifier = readSelectorValue(_segMan, eventObject, SELECTOR(modifiers));
 		// If tab got pressed, handle it here as if it was Ctrl-I - at least sci0 also did it that way
 		if (keyPress == SCI_KEY_TAB) {
 			keyModifier = SCI_KEYMOD_CTRL;
@@ -465,7 +465,7 @@ reg_t GfxMenu::kernelSelect(reg_t eventObject) {
 		_ports->setPort(_oldPort);
 
 	if ((itemEntry) || (forceClaimed))
-		PUT_SEL32(_segMan, eventObject, SELECTOR(claimed), make_reg(0, 1));
+		writeSelector(_segMan, eventObject, SELECTOR(claimed), make_reg(0, 1));
 	if (itemEntry)
 		return make_reg(0, (itemEntry->menuId << 8) | (itemEntry->id));
 	return NULL_REG;