CnC_Remastered_Collection

MAPEDTM.CPP (28987B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header: /CounterStrike/MAPEDTM.CPP 1     3/03/97 10:25a Joe_bostic $ */
 /***************************************************************************
  **   C O N F I D E N T I A L --- W E S T W O O D    S T U D I O S        **
  ***************************************************************************
  *                                                                         *
  *                 Project Name : Command & Conquer                        *
  *                                                                         *
  *                    File Name : MAPEDTM.CPP                              *
  *                                                                         *
  *                   Programmer : Bill Randolph                            *
  *                                                                         *
  *                   Start Date : December 7, 1994                         *
  *                                                                         *
  *                  Last Update : May 7, 1996 [JLB]                        *
  *                                                                         *
  *-------------------------------------------------------------------------*
  * Functions:                                                              *
  *   MapEditClass::Draw_Member -- Draws a member of the team dialog box.   *
  *   MapEditClass::Handle_Teams -- main team-dialog-handling function      *
  *   MapEditClass::Select_Team -- user selects a team from a list          *
  *   MapEditClass::Team_Members -- user picks makeup of a team             *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #include "function.h"
 
 #ifdef SCENARIO_EDITOR
 
 
 /***************************************************************************
  * MapEditClass::Handle_Teams -- main team-dialog-handling function        *
  *                                                                         *
  * INPUT:                                                                  *
  *      none.                                                              *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      none.                                                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   12/08/1994 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::Handle_Teams(char const * caption)
 {
 	int rc;
 
 	/*
 	**	Team dialog processing loop:
 	**	- Invoke the team selection dialog. If a team's selected, break
 	**	  & return
 	**	- If user wants to edit the current team, do so
 	**	- If user wants to create new team, new a TeamTypeClass & edit it
 	**	- If user wants to delete team, delete the current team
 	**	- Keep looping until 'OK'
 	*/
 	for (;;) {
 
 		/*
 		**	Select team
 		*/
 		rc = Select_Team(caption);
 
 		/*
 		**	'OK'; break
 		*/
 		if (rc == 0) {
 			break;
 		} else {
 
 			/*
 			**	'Edit'
 			*/
 			if (rc == 1 && CurTeam) {
 				if (CurTeam->Edit()) {
 					Changed = 1;
 				}
 				HidPage.Clear();
 				Flag_To_Redraw(true);
 				Render();
 			} else {
 
 				/*
 				**	'New'
 				*/
 				if (rc == 2) {
 
 					/*
 					**	Create a new team
 					*/
 					CurTeam = new TeamTypeClass();
 					if (CurTeam) {
 						/*
 						**	delete it if user cancels
 						*/
 						if (!CurTeam->Edit()) {
 							delete CurTeam;
 							CurTeam = NULL;
 						} else {
 							Changed = 1;
 						}
 						HidPage.Clear();
 						Flag_To_Redraw(true);
 						Render();
 					} else {
 
 						/*
 						**	Unable to create; issue warning
 						*/
 						WWMessageBox().Process("No more teams available.");
 						HidPage.Clear();
 						Flag_To_Redraw(true);
 						Render();
 					}
 				} else {
 
 					/*
 					**	'Delete'
 					*/
 					if (rc==3) {
 						if (CurTeam) {
 							Detach_This_From_All(CurTeam->As_Target(), true);
 							delete CurTeam;
 							//CurTeam->Remove();
 							CurTeam = NULL;
 						}
 					}
 				}
 			}
 		}
 	}
 }
 
 
 /***************************************************************************
  * MapEditClass::Select_Team -- user selects a team from a list            *
  *                                                                         *
  *    ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿           *
  *    ³                         Teams                          ³           *
  *    ³    ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄ¿    ³           *
  *    ³    ³ Name     House    Class:Count,Class:Count  ³³    ³           *
  *    ³    ³ Name     House    Class:Count,Class:Count  ÃÄ´    ³           *
  *    ³    ³ Name     House    Class:Count,Class:Count  ³ ³    ³           *
  *    ³    ³ Name     House    Class:Count,Class:Count  ³ ³    ³           *
  *    ³    ³                                            ³ ³    ³           *
  *    ³    ³                                            ³ ³    ³           *
  *    ³    ³                                            ÃÄ´    ³           *
  *    ³    ³                                            ³³    ³           *
  *    ³    ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÙ    ³           *
  *    ³                                                        ³           *
  *    ³      [Edit]        [New]        [Delete]      [OK]     ³           *
  *    ³                                                        ³           *
  *    ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ           *
  *                                                                         *
  * INPUT:                                                                  *
  *      none.                                                              *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      0 = OK, 1 = Edit, 2 = New, 3 = Delete                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      Uses HIDBUFF.                                                      *
  *                                                                         *
  * HISTORY:                                                                *
  *   12/08/1994 BR : Created.                                              *
  *   05/07/1996 JLB : Streamlined and sorted team list.                    *
  *=========================================================================*/
 int MapEditClass::Select_Team(char const * )
 {
 	/*
 	**	Dialog & button dimensions
 	*/
 	enum {
 		D_DIALOG_W = 400,											// dialog width
 		D_DIALOG_H = 250,											// dialog height
 		D_DIALOG_X = 0,				// centered x-coord
 		D_DIALOG_Y = 0,				// centered y-coord
 //		D_DIALOG_CX = D_DIALOG_X + (D_DIALOG_W / 2),		// coord of x-center
 
 		D_TXT8_H = 11,												// ht of 8-pt text
 		D_MARGIN = 25,												// margin width/height
 
 		D_LIST_W = (D_DIALOG_W-(D_MARGIN*2))-20,
 		D_LIST_X = D_DIALOG_X + (D_DIALOG_W-D_LIST_W)/2,
 		D_LIST_Y = D_DIALOG_Y + 20,
 		D_LIST_H = (D_DIALOG_H-50)-D_LIST_Y,
 
 		BUTTON_W = 45,
 		BUTTON_H = 9,
 
 		D_EDIT_W = BUTTON_W,
 		D_EDIT_H = BUTTON_H,
 		D_EDIT_X = D_DIALOG_X + D_DIALOG_W - (((D_EDIT_W+10)*4)+25),
 		D_EDIT_Y = D_DIALOG_Y + D_DIALOG_H - 20 - D_EDIT_H,
 
 		D_NEW_W = BUTTON_W,
 		D_NEW_H = BUTTON_H,
 		D_NEW_X = D_EDIT_X + D_EDIT_W + 10,
 		D_NEW_Y = D_DIALOG_Y + D_DIALOG_H - 20 - D_NEW_H,
 
 		D_DELETE_W = BUTTON_W,
 		D_DELETE_H = BUTTON_H,
 		D_DELETE_X = D_NEW_X + D_NEW_W + 10,
 		D_DELETE_Y = D_DIALOG_Y + D_DIALOG_H - 20 - D_DELETE_H,
 
 		D_OK_W = BUTTON_W,
 		D_OK_H = BUTTON_H,
 		D_OK_X = D_DELETE_X + D_DELETE_W + 10,
 		D_OK_Y = D_DIALOG_Y + D_DIALOG_H - 20 - D_OK_H,
 
 		TEAMTXT_LEN = 43,				// max length of a team entry
 	};
 
 	/*
 	**	Button enumerations:
 	*/
 	enum {
 		TEAM_LIST=100,
 		BUTTON_EDIT,
 		BUTTON_NEW,
 		BUTTON_DELETE,
 		BUTTON_OK,
 	};
 
 	/*
 	**	Dialog variables
 	*/
 	bool edit_team = false;						// true = user wants to edit
 	bool new_team = false;						// true = user wants to new
 	bool del_team = false;						// true = user wants to new
 	static int tabs[] = {35, 60, 80, 100};	// list box tab stops
 	RemapControlType * scheme = GadgetClass::Get_Color_Scheme();
 
 	/*
 	**	Buttons
 	*/
 	GadgetClass * commands = NULL;				// the button list
 
 	TListClass<CCPtr<TeamTypeClass> > teamlist (TEAM_LIST,
 		D_LIST_X, D_LIST_Y, D_LIST_W, D_LIST_H,
 		TPF_EFNT | TPF_NOSHADOW,
 		MFCD::Retrieve("EBTN-UP.SHP"),
 		MFCD::Retrieve("EBTN-DN.SHP"));
 
 	TextButtonClass editbtn (BUTTON_EDIT, "Edit", TPF_EBUTTON, D_EDIT_X, D_EDIT_Y, D_EDIT_W);
 	TextButtonClass newbtn (BUTTON_NEW, "New", TPF_EBUTTON, D_NEW_X, D_NEW_Y, D_NEW_W);
 	TextButtonClass deletebtn (BUTTON_DELETE, "Delete", TPF_EBUTTON, D_DELETE_X, D_DELETE_Y, D_DELETE_W);
 	TextButtonClass okbtn (BUTTON_OK, "OK", TPF_EBUTTON, D_OK_X, D_OK_Y, D_OK_W);
 
 	/*
 	**	Initialize
 	*/
 	Set_Logic_Page(SeenBuff);
 
 	/*
 	**	Fill in team names
 	*/
 	for (int index = 0; index < TeamTypes.Count(); index++) {
 		teamlist.Add_Item(TeamTypes.Ptr(index));
 	}
 
 	PNBubble_Sort(&teamlist[0], teamlist.Count());
 
 	if (!CurTeam || !CurTeam->IsActive) CurTeam = NULL;
 
 	if (CurTeam) {
 		teamlist.Set_Selected_Index(CurTeam);
 		CurTeam = teamlist.Current_Item();
 	} else {
 		teamlist.Set_Selected_Index(0);
 		if (TeamTypes.Count()) {
 			CurTeam = teamlist.Current_Item();
 		}
 	}
 
 	/*
 	**	Create the list
 	*/
 	commands = &teamlist;
 	editbtn.Add_Tail(*commands);
 	newbtn.Add_Tail(*commands);
 	deletebtn.Add_Tail(*commands);
 	okbtn.Add_Tail(*commands);
 
 	/*
 	**	Init tab stops for list
 	*/
 	teamlist.Set_Tabs(tabs);
 
 	/*
 	**	Main Processing Loop
 	*/
 	bool display = true;
 	bool process = true;
 	while (process) {
 
 		/*
 		**	Invoke game callback
 		*/
 		Call_Back();
 
 		/*
 		**	Refresh display if needed
 		*/
 		if (display /*&& LogicPage->Lock()*/) {
 			Hide_Mouse();
 			Dialog_Box(D_DIALOG_X, D_DIALOG_Y, D_DIALOG_W, D_DIALOG_H);
 			Draw_Caption(TXT_TEAM_EDIT, D_DIALOG_X, D_DIALOG_Y, D_DIALOG_W);
 			commands->Draw_All();
 			Show_Mouse();
 			display = false;
 //			LogicPage->Unlock();
 		}
 
 		/*
 		**	Get user input
 		*/
 		KeyNumType input = commands->Input();
 
 		/*
 		**	Process input
 		*/
 		switch (input) {
 			case (TEAM_LIST | KN_BUTTON):
 				CurTeam = teamlist.Current_Item();
 				break;
 
 			case (BUTTON_EDIT | KN_BUTTON):
 				if (teamlist.Count()) {
 					process = false;
 					edit_team = true;
 				}
 				break;
 
 			case (BUTTON_NEW | KN_BUTTON):
 				process = false;
 				new_team = true;
 				break;
 
 			case (BUTTON_DELETE | KN_BUTTON):
 				process = false;
 				del_team = true;
 				break;
 
 			case (KN_RETURN):
 			case (BUTTON_OK | KN_BUTTON):
 				process = false;
 				break;
 		}
 	}
 
 	/*
 	**	Redraw the display
 	*/
 	HidPage.Clear();
 	Flag_To_Redraw(true);
 	Render();
 
 	if (edit_team) return(1);
 	if (new_team) return(2);
 	if (del_team) return(3);
 	return(0);
 }
 
 
 /***************************************************************************
  * MapEditClass::Team_Members -- user picks makeup of a team               *
  *                                                                         *
  * Team members are rendered in a 24 x 24 area; the Window coordinates     *
  * have to be set to this area when the object's 'Display()' routine is    *
  * called. Thus, the dialog's window coords have to be divisible by        *
  * 24. The height of the dialog is computed based on how many objects      *
  * there are in it.                                                        *
  *                                                                         *
  * 10 pixels are left between rows of objects, so the # of that type of    *
  * object can be displayed underneath the object.                          *
  *                                                                         *
  *  ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿                    *
  *  ³                 Team Members                    ³                    *
  *  ³                                                 ³                    *
  *  ³  ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿  ³                    *
  *  ³  ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³  ³                    *
  *  ³  ÃÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄ´  ³                    *
  *  ³  ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³  ³                    *
  *  ³  ÃÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄ´  ³                    *
  *  ³  ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³  ³                    *
  *  ³  ÃÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄ´  ³                    *
  *  ³  ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³  ³                    *
  *  ³  ÃÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄ´  ³                    *
  *  ³  ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³  ³                    *
  *  ³  ÃÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄÅÄÄÄ´  ³                    *
  *  ³  ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³   ³  ³                    *
  *  ³  ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ  ³                    *
  *  ³               [OK]      [Cancel]                ³                    *
  *  ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ                    *
  *                                                                         *
  * INPUT:                                                                  *
  *      house      house to display objects for                            *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      0 = OK, -1 = cancel                                                *
  *                                                                         *
  * WARNINGS:                                                               *
  *      CurTeam must NOT be NULL when this function is called.             *
  *      This routine uses HIDBUFF for data storage.                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   12/07/1994 BR : Created.                                              *
  *=========================================================================*/
 //#define TEENSY_WEENSY
 /*
 **	Dialog & button dimensions
 */
 enum {
 	D_DIALOG_W = 640,
 	D_DIALOG_X = 0,
 	D_DIALOG_CX = D_DIALOG_X + (D_DIALOG_W / 2),
 
 	D_TXT6_H = 7,
 	D_MARGIN = 7,
 
 #ifdef TEENSY_WEENSY
 	D_PICTURE_W = 32,
 	D_PICTURE_H = 24,
 #else
 	D_PICTURE_W = 64,
 	D_PICTURE_H = 48,
 #endif
 	D_ROW_H = (D_PICTURE_H + 3),
 
 	D_OK_W = 50,
 	D_OK_H = 9,
 	D_OK_X = D_DIALOG_CX - 5 - D_OK_W,
 	D_OK_Y = 0,
 
 	D_CANCEL_W = 50,
 	D_CANCEL_H = 9,
 	D_CANCEL_X = D_DIALOG_CX + 5,
 	D_CANCEL_Y = 0,
 
 };
 
 int MapEditClass::Team_Members(HousesType house)
 {
 	/*
 	**	Button enumerations:
 	*/
 	enum {
 		BUTTON_OK = 100,
 		BUTTON_CANCEL,
 	};
 
 	/*
 	**	Redraw values: in order from "top" to "bottom" layer of the dialog
 	**	(highest enum is the lowest layer). Each section of the map checks
 	**	the requested redraw level to see if it's supposed to draw; if it's
 	**	>= its level, it redraws.
 	*/
 	typedef enum {
 		REDRAW_NONE = 0,
 		REDRAW_BUTTONS,
 		REDRAW_BACKGROUND,
 		REDRAW_ALL = REDRAW_BACKGROUND
 	} RedrawType;
 	RedrawType display;							// requested redraw level
 	bool process;									// loop while true
 
 	/*
 	**	Dialog variables
 	*/
 	KeyNumType input;								// user input
 	bool cancel = false;							// true = user cancels
 	RemapControlType * scheme = GadgetClass::Get_Color_Scheme();
 
 	/*
 	**	Team display variables
 	*/
 	const TechnoTypeClass **teamclass;		// array of team classes
 	int *teamcount;								// array of class counts
 	int numcols;									// # units displayed horizontally
 	int numrows;									// # units displayed vertically
 
 	/*
 	**	Dialog dimensions.
 	*/
 	int dlg_y;
 	int dlg_h;										// dialog height
 	int msg_y;										// y-coord for object names
 
 	int curclass = -1;			// current index into 'teamclass'; can be invalid!
 										// (is based on current mouse position)
 	int numclasses;				// current # classes in the team (limited to <=5)
 	int maxclasses;				// max # classes available
 	int i,j;
 
 	/*
 	**	Values for timing when mouse held down.
 	*/
 	int lheld = 0;
 	int rheld = 0;
 	long tdelay[3] = {5, 20, 0};
 	int tindex = 0;
 	long heldtime;
 
 	/*
 	**	Buttons.
 	*/
 	ControlClass * commands;
 
 	TextButtonClass okbtn (BUTTON_OK, TXT_OK, TPF_CENTER | TPF_EFNT | TPF_NOSHADOW, D_OK_X, D_OK_Y, D_OK_W, D_OK_H);
 	TextButtonClass cancelbtn (BUTTON_CANCEL, TXT_CANCEL, TPF_CENTER | TPF_EFNT | TPF_NOSHADOW, D_CANCEL_X, D_CANCEL_Y, D_CANCEL_W, D_CANCEL_H);
 
 	/*
 	**	Set up the team data arrays (ObjectTypeClass pointers & count)
 	*/
 #ifdef WIN32
 	teamclass = (const TechnoTypeClass **)SysMemPage.Get_Buffer();
 	teamcount = (int *)SysMemPage.Get_Buffer() + MAX_TEAM_CLASSES * sizeof (ObjectTypeClass *);
 #else
 	teamclass = (const TechnoTypeClass **)HidPage.Get_Buffer();
 	teamcount = (int *)HidPage.Get_Buffer() + MAX_TEAM_CLASSES * sizeof (ObjectTypeClass *);
 #endif
 
 	/*
 	**	Fill in the ObjectTypeClass array with all available object type ptrs,
 	**	checking to be sure this house can own the object
 	*/
 	i = 0;
 	for (InfantryType i_id = INFANTRY_FIRST; i_id < INFANTRY_COUNT; i_id++) {
 		teamclass[i] = &InfantryTypeClass::As_Reference(i_id);
 		i++;
 	}
 
 	for (AircraftType a_id = AIRCRAFT_FIRST; a_id < AIRCRAFT_COUNT; a_id++) {
 		teamclass[i] = &AircraftTypeClass::As_Reference(a_id);
 		i++;
 	}
 
 	for (UnitType u_id = UNIT_FIRST; u_id < UNIT_COUNT; u_id++) {
 		teamclass[i] = &UnitTypeClass::As_Reference(u_id);
 		i++;
 	}
 
 	for (VesselType v_id = VESSEL_FIRST; v_id < VESSEL_COUNT; v_id++) {
 		teamclass[i] = &VesselTypeClass::As_Reference(v_id);
 		i++;
 	}
 
 	/*
 	**	Save max # classes.
 	*/
 	maxclasses = i;
 
 	/*
 	**	Fill in the 'count' array with data from the current team:
 	**	- For every class in the current team, find that class type in the
 	**	  'teamclass' array & set its count value
 	*/
 	for (j = 0; j < maxclasses; j++) {
 		teamcount[j] = 0;
 	}
 
 	/*
 	**	Loop through all classes in the team.
 	*/
 	for (i = 0; i < CurTeam->ClassCount; i++) {
 
 		/*
 		**	Find this class in our array.
 		*/
 		for (j = 0; j < maxclasses; j++) {
 
 			/*
 			**	Set the count; detect a match between the team's class & the
 			**	'teamclass' array entry by comparing the actual pointers; typeid
 			**	won't work because E1 & E2 are the same type class.
 			*/
 			if (CurTeam->Members[i].Class == teamclass[j]) {
 				teamcount[j] = CurTeam->Members[i].Quantity;
 				break;
 			}
 		}
 	}
 	numclasses = CurTeam->ClassCount;
 
 	/*
 	**	Set up the dialog dimensions based on number of classes we have to draw
 	**
 	**	Compute picture rows & cols.
 	*/
 	numcols = (D_DIALOG_W - 16) / D_PICTURE_W;
 	numrows = (maxclasses + numcols - 1) / numcols;
 
 	/*
 	**	Dialog's height = top margin + label + picture rows + margin + label + margin + btn
 	*/
 	dlg_h = 400;
 	dlg_y = 0;
 	msg_y = dlg_y+dlg_h - 26 - 15;
 
 	okbtn.Y = dlg_y + dlg_h - D_MARGIN - D_OK_H - 15;
 	cancelbtn.Y = dlg_y + dlg_h - D_MARGIN - D_CANCEL_H - 15;
 
 	/*
 	**	Draw to SeenPage.
 	*/
 	Set_Logic_Page(SeenBuff);
 
 	/*
 	**	Make sure 'house' is valid.
 	*/
 //	if (house!=HOUSE_GOOD && house!=HOUSE_BAD && house != HOUSE_MULTI1 &&
 //		house != HOUSE_MULTI2 && house != HOUSE_MULTI3 && house != HOUSE_MULTI4 ) {
 //		if (Scen.ScenPlayer == SCEN_PLAYER_MPLAYER) {
 //			house = HOUSE_MULTI1;
 //		} else {
 //			house = HOUSE_GOOD;
 //		}
 //	}
 
 	/*
 	**	Create the list.
 	*/
 	commands = &okbtn;
 	cancelbtn.Add_Tail(*commands);
 
 	/*
 	**	Main Processing Loop.
 	*/
 	display = REDRAW_ALL;
 	process = true;
 	while (process) {
 
 		/*
 		**	Invoke game callback.
 		*/
 		Call_Back();
 
 		/*
 		**	Refresh display if needed.
 		*/
 		if (display) {
 
 			/*
 			**	Display the dialog box.
 			*/
 			Hide_Mouse();
 			if (display >= REDRAW_BACKGROUND) {
 
 				/*
 				**	Display the constant background of this dialog.
 				*/
 				Dialog_Box(D_DIALOG_X, dlg_y, D_DIALOG_W, dlg_h);
 				Draw_Caption(TXT_TEAM_MEMBERS, D_DIALOG_X, dlg_y, D_DIALOG_W);
 
 				/*
 				**	Draw the objects.
 				*/
 				for (i = 0; i < maxclasses; i++) {
 
 					/*
 					**	Display the object along with any count value for it.
 					*/
 					Draw_Member(teamclass[i], i, teamcount[i], house);
 				}
 
 				if ((unsigned)curclass < maxclasses) {
 					Fancy_Text_Print(teamclass[curclass]->Full_Name(),
 						D_DIALOG_X + D_DIALOG_W / 2, msg_y,
 						&ColorRemaps[PCOLOR_BROWN], TBLACK,
 						TPF_CENTER|TPF_EFNT|TPF_NOSHADOW);
 				}
 			}
 
 			/*
 			**	Redraw the buttons.
 			*/
 			if (display >= REDRAW_BUTTONS) {
 				commands->Draw_All();
 			}
 			Show_Mouse();
 			display = REDRAW_NONE;
 		}
 
 		/*
 		**	Get user input.
 		*/
 		input = commands->Input();
 
 		/*
 		**	Process input.
 		*/
 		switch (input) {
 
 			/*
 			**	Mouse buttons set or clear 'held' values
 			*/
 			case (KN_LMOUSE):
 				if (curclass >= 0 && curclass < maxclasses) {
 					lheld = 1;
 					tindex = 2;
 					heldtime = 0;
 				}
 				break;
 
 			case (KN_RMOUSE):
 				if (curclass >= 0 && curclass < maxclasses) {
 					rheld = 1;
 					tindex = 2;
 					heldtime = 0;
 				}
 				break;
 
 			case ((int)KN_LMOUSE | (int)KN_RLSE_BIT):
 				lheld = 0;
 				break;
 
 			case ((int)KN_RMOUSE | (int)KN_RLSE_BIT):
 				rheld = 0;
 				break;
 
 			/*
 			**	OK: save values & return.
 			*/
 			case (BUTTON_OK | KN_BUTTON):
 				process = false;
 				break;
 
 			/*
 			**	Cancel: abort & return.
 			*/
 			case (BUTTON_CANCEL | KN_BUTTON):
 				cancel = true;
 				process = false;
 				break;
 
 			default:
 				/*
 				**	Compute new 'curclass' based on mouse position.
 				*/
 				i = (Get_Mouse_X() - 32 - D_DIALOG_X) / D_PICTURE_W +
 					((Get_Mouse_Y() - (dlg_y+8+11)) / D_ROW_H) * numcols;
 
 				/*
 				**	If it's changed, update class label.
 				*/
 				if (i != curclass) {
 
 					curclass = i;
 
 					/*
 					**	Clear out the previously printed name of the item.
 					*/
 					Hide_Mouse();
 					LogicPage->Fill_Rect(D_DIALOG_X + 32, msg_y, D_DIALOG_X + D_DIALOG_W - 64, msg_y + D_TXT6_H, BLACK);
 
 					if ((unsigned)curclass < maxclasses) {
 						Fancy_Text_Print(teamclass[curclass]->Full_Name(),
 							D_DIALOG_X + D_DIALOG_W / 2, msg_y, scheme, TBLACK, TPF_CENTER|TPF_EFNT|TPF_NOSHADOW);
 					}
 
 					/*
 					**	Force buttons to not be held.
 					*/
 					lheld = 0;
 					rheld = 0;
 					Show_Mouse();
 				}
 				break;
 		}
 
 		/*
 		**	Check for a 'held' mouse button; if it's down, and the correct
 		**	amount of time has gone by, increment/decrement the count for the
 		**	current class.
 		*/
 		if (lheld) {
 
 			/*
 			**	The first time in, TickCount - heldtime will be larger than
 			**	tdelay[2], so we increment the count immediately; then, we decrement
 			**	tindex to go to the next time delay, which is longer; then, decr.
 			**	again to go to the 1st time delay which is the shortest.
 			*/
 			if (TickCount - heldtime > tdelay[tindex]) {
 				heldtime = TickCount;
 				if (tindex) {
 					tindex--;
 				}
 
 				/*
 				**	Detect addition of a new class.
 				*/
 				if (teamcount[curclass]==0) {
 
 					/*
 					**	Don't allow more classes than we can handle.
 					*/
 					if (numclasses == TeamTypeClass::MAX_TEAM_CLASSCOUNT) {
 						continue;
 					}
 					numclasses++;
 				}
 				teamcount[curclass]++;
 
 				/*
 				**	Update number label.
 				*/
 				Draw_Member(teamclass[curclass], curclass, teamcount[curclass], house);
 			}
 
 		} else {
 
 			if (rheld) {
 
 				/*
 				**	The first time in, TickCount - heldtime will be larger than
 				**	tdelay[2], so we increment the count immediately; then, we decrement
 				**	tindex to go to the next time delay, which is longer; then, decr.
 				**	again to go to the 1st time delay which is the shortest.
 				*/
 				if (TickCount - heldtime > tdelay[tindex]) {
 					if (tindex) {
 						tindex--;
 					}
 					heldtime = TickCount;
 
 					if (teamcount[curclass] > 0) {
 						teamcount[curclass]--;
 
 						/*
 						**	Detect removal of a class.
 						*/
 						if (teamcount[curclass] == 0) {
 							numclasses--;
 						}
 					}
 
 					/*
 					**	Update number label.
 					*/
 					Draw_Member(teamclass[curclass], curclass, teamcount[curclass], house);
 				}
 			}
 		}
 	}
 
 	/*
 	**	Copy data into team.
 	*/
 	if (!cancel) {
 		CurTeam->ClassCount = numclasses;
 		i = 0;		// current team class index
 		for (j = 0; j < maxclasses; j++) {
 			if (teamcount[j] > 0) {
 				CurTeam->Members[i].Quantity = teamcount[j];
 				CurTeam->Members[i].Class = teamclass[j];
 				i++;
 			}
 		}
 	}
 
 	/*
 	**	Redraw the display.
 	*/
 	HidPage.Clear();
 	Flag_To_Redraw(true);
 	Render();
 
 	if (cancel) return(-1);
 	return(0);
 }
 
 
 /***********************************************************************************************
  * MapEditClass::Draw_Member -- Draws a member of the team dialog box.                         *
  *                                                                                             *
  *    This routine will display the cameo image of the potential team member. In the corner,   *
  *    it will show the current quantity of this member for the current team being edited.      *
  *                                                                                             *
  * INPUT:   ptr   -- Pointer to the member object type.                                        *
  *                                                                                             *
  *          index -- The index into the team dialog box array of selectable objects. This is   *
  *                   used to determine the correct X and Y offsets to draw.                    *
  *                                                                                             *
  *          quant -- The quantity number to display in the corner of the image.                *
  *                                                                                             *
  *          house -- The owner of this object.                                                 *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/02/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 void MapEditClass::Draw_Member(TechnoTypeClass const * ptr, int index, int quant, HousesType house)
 {
 	int numcols = (D_DIALOG_W - 64) / D_PICTURE_W;
 	int col = index % numcols;
 	int row = index / numcols;
 	int dlg_y = 0;
 	int x = D_DIALOG_X + 32 + col * D_PICTURE_W;
 	int y = dlg_y + 8 + 13 + row * D_ROW_H;
 	RemapControlType * scheme = GadgetClass::Get_Color_Scheme();
 
 	/*
 	**	Change the window to this box.
 	*/
 	WindowList[WINDOW_EDITOR][WINDOWX] = x;
 	WindowList[WINDOW_EDITOR][WINDOWY] = y;
 	WindowList[WINDOW_EDITOR][WINDOWWIDTH] = D_PICTURE_W;
 	WindowList[WINDOW_EDITOR][WINDOWHEIGHT] = D_PICTURE_H;
 	Change_Window((int)WINDOW_EDITOR);
 
 	Hide_Mouse();
 	Draw_Box(x, y, D_PICTURE_W, D_PICTURE_H, BOXSTYLE_DOWN, true);
 	ptr->Display(WinW/2, WinH>>1, WINDOW_EDITOR, house);
 	if (quant > 0) {
 		Fancy_Text_Print("%d", x+1, y+1, scheme, TBLACK, TPF_8POINT|TPF_DROPSHADOW, quant);
 //		Fancy_Text_Print("%d", x+1, y+D_PICTURE_H-8, scheme, TBLACK, TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_DROPSHADOW, quant);
 	}
 	Show_Mouse();
 }
 
 
 #endif