Provide variables "gui::horPad" and "gui::vertPad" to GUI scripts

they are set before onActivate and also whenever the (Doom3 SDL) window
size changes, in that case additionally the "UpdateWindowSize" Named
Event is called in the script, in case you wanna do anything special
in that case:

  onNamedEvent UpdateWindowSize {
    set "print" "UpdateWindowSize - horPad:" "gui::horPad"
          "vertPad:" "gui::vertPad";
  }

horPad is the width of the padding border (empty space) between the
  left/right border of Doom3's SDL window and a centered
  (cstAnchor CST_ANCHOR_CENTER_CENTER) full-sized windowDef in virtual
  pixels (in the Doom3 GUI coordinate system, which usually is 640x480).
vertPad is the same for the padding border between the top/bottom border
  and a centered full-sized windowDef

One of those values will always be 0.

So for example if you play Doom3 at 1600x1200 (a 4:3 resolution like
640x480) both horPad and vertPad are 0.
If you play at 1680x1050 (16:10 resolution) and your windowDef Desktop
is 640x480 (the default), horPad is 64 (and vertPad is  0), because
there are 64 virtual pixels between the left window border and a
centered 640x480 windowDef (and also between the centered windowDef
and the right window border.

gui::horPad and gui::vertPad are useful for filling those otherwise
empty padding areas with windowDefs that you anchor to the corresponding
points of the window (like CST_ANCHOR_LEFT and CST_ANCHOR_RIGHT when
there's horizontal padding) that have just the right size.

Example of a green rectangle filling parts of the left padding area,
but not touching the center area (10 virtual pixels distance):

  windowDef leftPadFiller {
    cstAnchor  CST_ANCHOR_LEFT
    rect   0, 200, "gui::horPad" - 10, 40
    backColor 0, 1, 0, 1
  }

neo/ui/UserInterface.cpp

@@ -251,6 +251,8 @@ idUserInterfaceLocal::idUserInterfaceLocal() {
 	//so the reg eval in gui parsing doesn't get bogus values
 	time = 0;
 	refs = 1;
+	timeStamp = 0;
+	lastGlWidth = lastGlHeight = 0;
 }
 
 idUserInterfaceLocal::~idUserInterfaceLocal() {
@@ -527,6 +529,18 @@ void idUserInterfaceLocal::Redraw( int _time ) {
 		return;
 	}
 	if ( !loading && desktop ) {
+		if ( desktop->GetFlags() & WIN_MENUGUI ) {
+			// if the (SDL) window size has changed, calculate and set the
+			// "gui::horPad" and "gui::vertPad" window variables accordingly
+			if ( MaybeSetPaddingWinVars() ) {
+				// tell the GUI script about it in case it wants to handle the size change in
+				// some way (though usually it's enough to use sth like
+				// `rect 0, 200, "gui::horPad", 100"` and `cstAnchor  CST_ANCHOR_LEFT`
+				// for a windowDef that should fill part of the left side)
+				HandleNamedEvent( "UpdateWindowSize" );
+			}
+		}
+
 		time = _time;
 		uiManagerLocal.dc.PushClipRect( uiManagerLocal.screenRect );
 		desktop->Redraw( 0, 0 );
@@ -629,6 +643,12 @@ const char *idUserInterfaceLocal::Activate(bool activate, int _time) {
 			Sys_SetInteractiveIngameGuiActive( activate, this );
 		} // DG end
 		activateStr = "";
+
+		if ( desktop->GetFlags() & WIN_MENUGUI ) {
+			// DG: calculate and set the "gui::horPad" and "gui::vertPad"
+			//     window variables so the GUI can use them
+			MaybeSetPaddingWinVars(true);
+		}
 		desktop->Activate( activate, activateStr );
 		return activateStr;
 	}
@@ -819,3 +839,39 @@ void idUserInterfaceLocal::SetCursor( float x, float y ) {
 	cursorX = x;
 	cursorY = y;
 }
+
+
+bool idUserInterfaceLocal::MaybeSetPaddingWinVars(bool force) {
+	if ( desktop == NULL ) {
+		return false;
+	}
+	int glWidth, glHeight;
+	renderSystem->GetGLSettings(glWidth, glHeight);
+	if (glWidth <= 0 || glHeight <= 0 || (!force && glWidth == lastGlWidth && glHeight == lastGlHeight) ) {
+		return false;
+	}
+	lastGlWidth = glWidth;
+	lastGlHeight = glHeight;
+
+	float glAspectRatio = (float)glWidth / (float)glHeight;
+	const float vidAspectRatio = (float)VIRTUAL_WIDTH / (float)VIRTUAL_HEIGHT;
+
+	const float desktopWidth  = desktop->forceAspectWidth;
+	const float desktopHeight = desktop->forceAspectHeight;
+
+	float horizPadding = 0;
+	float vertPadding = 0;
+
+	if (glAspectRatio >= vidAspectRatio) {
+		float modWidth = desktopHeight * glAspectRatio;
+		horizPadding = 0.5f * (modWidth - desktopWidth);
+	} else {
+		float modHeight = desktopWidth / glAspectRatio;
+		vertPadding = 0.5f * (modHeight - desktopHeight);
+	}
+
+	SetStateFloat( "horPad", horizPadding );
+	SetStateFloat( "vertPad", vertPadding );
+
+	return true;
+}

neo/ui/UserInterfaceLocal.h

@@ -115,6 +115,17 @@ private:
 	int							time;
 
 	int							refs;
+
+	// DG: used so we can notify GUI scripts about changes in side padding.
+	//  Relevant if they use cstAnchor, so they can know how big padding on the left/right
+	//  or above/below a centered windowDef with full 640x480 size is.
+	//  Then they can adjust the sizes of windowDefs anchored to left/right or upper/lower borders
+	//  to fill up the gap
+	// if force=true, the variables are set no matter if the size has changed or not
+	// returns true if the windowSize has changed and thus the variables were updated, otherwise false
+	bool						MaybeSetPaddingWinVars(bool force=false);
+	int							lastGlWidth;
+	int							lastGlHeight;
 };
 
 class idUserInterfaceManagerLocal : public idUserInterfaceManager {