#ifdef PRECOMPILEDHEADERS
	#include "Strategic All.h"
	#include "GameSettings.h"
#else
	#include "Map Screen Interface Map Inventory.h"
	#include "Render Dirty.h"
	#include "vobject.h"
	#include "Utilities.h"
	#include "WCheck.h"
	#include "sysutil.h"
	#include "Map Screen Interface Border.h"
	#include "Map Screen Interface.h"
	#include "Map Screen Interface Map.h"
	#include "Items.h"
	#include "Interface Items.h"
	#include "Cursor Control.h"
	#include "Interface Utils.h"
	#include "Text.h"
	#include "Font Control.h"
	#include "strategicmap.h"
	#include "Tactical Save.h"
	#include "Overhead.h"
	#include "english.h"
	#include "Multi Language Graphic Utils.h"
	#include "GameSettings.h"
	#include "Radar Screen.h"
	#include "message.h"
	#include "weapons.h"
	#include "finances.h"
	#include "Game Clock.h"
	#include "Sound Control.h"
	#include "interface panels.h"
	#include "wordwrap.h"
	#include "Soldier macros.h"
#endif

#include "ShopKeeper Interface.h"
#include "ArmsDealerInvInit.h"
#include <algorithm>
#include "InterfaceItemImages.h"
#include "SaveLoadGame.h"//dnl ch51 081009
#include "Map Information.h"//dnl ch51 091009
#include "Interface Items.h"

//forward declarations of common classes to eliminate includes
class OBJECTTYPE;
class SOLDIERTYPE;

//dnl ch51 081009
UINT8 gInventoryPoolIndex = '0';
std::vector<WORLDITEM> pInventoryPoolListQ[INVPOOLLISTNUM];
INT32 iCurrentInventoryPoolPageQ[INVPOOLLISTNUM]={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
INT32 iLastInventoryPoolPageQ[INVPOOLLISTNUM]={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

extern BOOLEAN SaveWorldItemsToTempItemFile( INT16 sMapX, INT16 sMapY, INT8 bMapZ, UINT32 uiNumberOfItems, WORLDITEM* pData );

#define MAP_INV_X_OFFSET						(((SCREEN_WIDTH - 261) - 380) / 2)

// status bar colors
#define DESC_STATUS_BAR FROMRGB( 201, 172,  133 )
#define DESC_STATUS_BAR_SHADOW FROMRGB( 140, 136,  119 )

// page display positions
#define MAP_INVENTORY_POOL_PAGE_X				(MAP_INV_X_OFFSET + 506)
#define MAP_INVENTORY_POOL_PAGE_Y				(SCREEN_HEIGHT - 121 - 23)	//336
#define MAP_INVENTORY_POOL_PAGE_WIDTH			46
#define MAP_INVENTORY_POOL_PAGE_HEIGHT			13

// the number of items
#define MAP_INVENTORY_POOL_NUMBER_X				(MAP_INV_X_OFFSET + 436)
#define MAP_INVENTORY_POOL_NUMBER_WIDTH			40

// location
#define MAP_INVENTORY_POOL_LOC_X				(MAP_INV_X_OFFSET + 326)
#define MAP_INVENTORY_POOL_LOC_WIDTH			40

// delay for flash of item
#define DELAY_FOR_HIGHLIGHT_ITEM_FLASH			200

// inventory slot font
#define MAP_IVEN_FONT							SMALLCOMPFONT
// HEADROCK HAM 5: Item names use variable fonts.
INT32	MAP_INVEN_NAME_FONT	= SMALLCOMPFONT;

// the position of the background graphic
#define INVEN_POOL_X 261
#define INVEN_POOL_Y 0

// inventory Graphic Offset X and y
#define MAP_INVENTORY_POOL_SLOT_OFFSET_X 2
#define MAP_INVENTORY_POOL_SLOT_OFFSET_Y 5

// height of map inventory pool bar
// HEADROCK HAM 5: Changed to variables
UINT16 ITEMDESC_ITEM_STATUS_HEIGHT_INV_POOL = 20;
UINT16 ITEMDESC_ITEM_STATUS_WIDTH_INV_POOL = 2;

// map bar offsets
// HEADROCK HAM 5: Changed to variables
INT16 ITEMDESC_ITEM_STATUS_INV_POOL_OFFSET_X = 5;
INT16 ITEMDESC_ITEM_STATUS_INV_POOL_OFFSET_Y = 22;

// HEADROCK HAM 5: For now I just need a Y.
INT16 ITEMDESC_ITEM_NAME_POOL_OFFSET_Y = 3;

// inventory pool slot positions and sizes
//#define MAP_INVENTORY_POOL_SLOT_START_X 271
//#define MAP_INVENTORY_POOL_SLOT_START_Y 36
// HEADROCK HAM 5: Changed to variables
UINT16 MAP_INVEN_SLOT_WIDTH = 65;
UINT16 MAP_INVEN_SPACE_BTWN_SLOTS = 72;
UINT16 MAP_INVEN_SLOT_HEIGHT = 32;
UINT16 MAP_INVEN_SLOT_IMAGE_HEIGHT = 24;

// Number of inventory slots in 1024x768
#define MAP_INVENTORY_POOL_MAX_SLOTS 170

INT32 MAP_INV_SLOT_COLS;			// Number of vertical slots
INT32 MAP_INVENTORY_POOL_SLOT_COUNT;

INT32 MAP_INVENTORY_POOL_SLOT_START_X;
INT32 MAP_INVENTORY_POOL_SLOT_START_Y;

// the current highlighted item
INT32 iCurrentlyHighLightedItem = -1;
BOOLEAN fFlashHighLightInventoryItemOnradarMap = FALSE;

// whether we are showing the inventory pool graphic
BOOLEAN fShowMapInventoryPool = FALSE;
// HEADROCK HAM 5: Flag telling us whether we've already redrawn the screen to show
// sector inventory sale prices.
UINT8 gubRenderedMapInventorySalePrices = FALSE;

// the v-object index value for the background
UINT32 guiMapInventoryPoolBackground;
// HEADROCK HAM 5: Graphic for map inventory slots
UINT32 guiMapInventoryPoolSlot;

// inventory pool list
std::vector<WORLDITEM> pInventoryPoolList;

// current page of inventory
INT32 iCurrentInventoryPoolPage = 0;
INT32 iLastInventoryPoolPage = 0;

INT32 sObjectSourceGridNo = 0;
INT8  sObjectSourseSoldierID = -1;

// number of unseen items in sector
UINT32 uiNumberOfUnSeenItems = 0;


// the inventory slots
//MOUSE_REGION MapInventoryPoolSlots[ MAP_INVENTORY_POOL_SLOT_COUNT ];
MOUSE_REGION MapInventoryPoolSlots[ MAP_INVENTORY_POOL_MAX_SLOTS ];
MOUSE_REGION MapInventoryPoolMask;
// HEADROCK HAM 5: This rectangle describes the inventory. It is used to limit cursor movement while waiting for zoom input.
SGPRect MapInventoryRect;

//BOOLEAN fMapInventoryItemCompatable[ MAP_INVENTORY_POOL_SLOT_COUNT ];
BOOLEAN fMapInventoryItemCompatable[ MAP_INVENTORY_POOL_MAX_SLOTS ];
// HEADROCK HAM 5: Same idea as above, this flags items as being candidates for appearing in Zoomed mode.
BOOLEAN gfMapInventoryItemToZoom[ MAP_INVENTORY_POOL_MAX_SLOTS ];

BOOLEAN fChangedInventorySlots = FALSE;

// the unseen items list...have to save this
WORLDITEM *pUnSeenItems = NULL;

// save list to write to temp file
WORLDITEM *pSaveList = NULL;

INT32 giFlashHighlightedItemBaseTime = 0;
INT32 giCompatibleItemBaseTime = 0;

// the buttons and images
// HEADROCK HAM 5: Increased for new inventory buttons
UINT32 guiMapInvenArrowButtonImage[ 2 ];
UINT32 guiMapInvenArrowButton[ 2 ];

UINT32 guiMapInvenDoneButtonImage;
UINT32 guiMapInvenDoneButton;

UINT32 guiMapInvenZoomButtonImage;
UINT32 guiMapInvenZoomButton;

UINT32 guiMapInvenSortButtonImage[4];
UINT32 guiMapInvenSortButton[4];

UINT32 guiMapInvenFilterButtonImage[9];
UINT32 guiMapInvenFilterButton[9];



BOOLEAN gfCheckForCursorOverMapSectorInventoryItem = FALSE;

// HEADROCK HAM 5: Map Inventory ZOOM
BOOLEAN fMapInventoryZoom = FALSE;
// HEADROCK HAM 5: This flag tells us that we're waiting for player zoom region selection. It affects the
// behavior of inventory slot regions.
BOOLEAN fWaitingForZoomInput = FALSE;

// HEADROCK HAM 5: This is the minimum desired number of inventory items. Unless we reset this to -1, there will be
// exactly as many item pages as we had previously when checking inventory resize.
INT32 giDesiredNumMapInventorySlots = -1;

// HEADROCK HAM 5: This is an inventory filter. It is a bit array, reacting to an item's Class.
UINT32 guiMapInventoryFilter = IC_MAPFILTER_ALL;

// HEADROCK HAM 5: Constants and variables for the filter popup menu.
BOOLEAN gfMapInventoryFilterPopupInitialized = FALSE;
POPUP*  gMapInventoryFilterPopup;
BOOLEAN gfMapInventoryFilterPopupVisible = FALSE;
BOOLEAN gfQueueRecreateMapInventoryFilterMenu = FALSE;

extern int PLAYER_INFO_Y;
extern int INV_REGION_Y;

extern BOOLEAN fShowInventoryFlag;
extern BOOLEAN fMapScreenBottomDirty;

extern BOOLEAN ReduceStringLength( STR16 pString, UINT32 uiWidthToFitIn, UINT32 uiFont );

extern OBJECTTYPE gItemPointer;

extern OBJECTTYPE * gpItemPointer;

// outside vidieo objects for cursor
extern UINT32 guiExternVo;
extern UINT16 gusExternVoSubIndex;

extern	MOUSE_REGION    gMPanelRegion;

// HEADROCK HAM 5: Because BigItem graphics are not loaded into memory by default, we need to load them to
// display the large map inventory. We save their indexes in this array:
typedef struct
{
	UINT16 usItem;
	INT32 iGraphicNum;
} BIGITEMSLOTGRAPHICS;

BIGITEMSLOTGRAPHICS giMapInventoryBigItemGraphics[ MAP_INVENTORY_POOL_MAX_SLOTS ];

// map inventory callback
void MapInvenPoolSlots(MOUSE_REGION * pRegion, INT32 iReason );
void MapInvenPoolSlotsMove( MOUSE_REGION * pRegion, INT32 iReason  );
void CreateMapInventoryPoolSlots( void );
void DestroyMapInventoryPoolSlots( void );
void CreateMapInventoryButtons( void );
void DestroyMapInventoryButtons( void );
void DestroyStash( void );
void BuildStashForSelectedSector( INT16 sMapX, INT16 sMapY, INT16 sMapZ );
void BeginInventoryPoolPtr( OBJECTTYPE *pInventorySlot );
BOOLEAN PlaceObjectInInventoryStash( OBJECTTYPE *pInventorySlot, OBJECTTYPE *pItemPtr );
void RenderItemsForCurrentPageOfInventoryPool( void );
BOOLEAN RenderItemInPoolSlot( INT32 iCurrentSlot, INT32 iFirstSlotOnPage );
void UpdateHelpTextForInvnentoryStashSlots( void );
void MapInventoryPoolPrevBtn( GUI_BUTTON *btn, INT32 reason );
void MapInventoryPoolNextBtn( GUI_BUTTON *btn, INT32 reason );
void DisplayPagesForMapInventoryPool( void );
void DrawNumberOfIventoryPoolItems( void );
void CreateMapInventoryPoolDoneButton( void );
void DestroyInventoryPoolDoneButton( void );
void MapInventoryPoolDoneBtn( GUI_BUTTON *btn, INT32 reason );
// HEADROCK HAM 5: Callback for inventory zoom
void MapInventoryPoolZoomBtn( GUI_BUTTON *btn, INT32 reason );
// HEADROCK HAM 5: Sort ammo button callback
void MapInventoryPoolStackAndMergeBtn( GUI_BUTTON *btn, INT32 reason );
void MapInventoryPoolSortAmmoBtn( GUI_BUTTON *btn, INT32 reason );
void MapInventoryPoolSortAttachmentsBtn( GUI_BUTTON *btn, INT32 reason );
void MapInventoryPoolEjectAmmoBtn( GUI_BUTTON *btn, INT32 reason );
// HEADROCK HAM 5: Preliminary Filter Button
void MapInventoryPoolFilterBtn( GUI_BUTTON *btn, INT32 reason );
void DisplayCurrentSector( void );
void ResizeInventoryList( void );
void ClearUpTempUnSeenList( void );
void SaveSeenAndUnseenItems( void );
void DrawTextOnMapInventoryBackground( void );
void DrawTextOnSectorInventory( void );
INT32 GetTotalNumberOfItemsInSectorStash( void );
void HandleMapSectorInventory( void );
void ResetMapSectorInventoryPoolHighLights( void );
void ReBuildWorldItemStashForLoadedSector( INT32 iNumberSeenItems, INT32 iNumberUnSeenItems, WORLDITEM *pSeenItemsList, WORLDITEM *pUnSeenItemsList );
BOOLEAN IsMapScreenWorldItemVisibleInMapInventory( WORLDITEM *pWorldItem );
BOOLEAN IsMapScreenWorldItemInvisibleInMapInventory( WORLDITEM *pWorldItem );
void CheckGridNoOfItemsInMapScreenMapInventory();
INT32 MapScreenSectorInventoryCompare( const void *pNum1, const void *pNum2);
void SortSectorInventory( std::vector<WORLDITEM>& pInventory, UINT32 uiSizeOfArray );
BOOLEAN CanPlayerUseSectorInventory( SOLDIERTYPE *pSelectedSoldier );

extern void MAPEndItemPointer( );
extern	BOOLEAN GetCurrentBattleSectorXYZAndReturnTRUEIfThereIsABattle( INT16 *psSectorX, INT16 *psSectorY, INT16 *psSectorZ );
extern BOOLEAN MAPInternalInitItemDescriptionBox( OBJECTTYPE *pObject, UINT8 ubStatusIndex, SOLDIERTYPE *pSoldier );

void DeleteAllItemsInInventoryPool();
void DeleteItemsOfType( UINT16 usItemType );
// HEADROCK HAM 5: flag to indicate that all items in the stack will be sold. This is primarily used to
// figure out the price of the top item in the stack rather than just all of them.
INT32 SellItem( OBJECTTYPE& object, BOOLEAN fAll, BOOLEAN useModifier = TRUE );

// HEADROCK HAM 5: Resets the coordinates and sizes of inventory slots.
void ResetMapInventoryOffsets(void);
// HEADROCK HAM 5: Handles loading and unloading Big Item images.
void LoadAllMapInventoryBigItemGraphics();
void LoadMapInventoryBigItemGraphic( INT32 iCounter );
void UnloadAllMapInventoryBigItemGraphics();
void UnloadMapInventoryBigItemGraphic( INT32 iCounter );
void ResetAllMapInventoryBigItemGraphics();
// HEADROCK HAM 5: Handles map inventory zoom/unzoom to specific page.
void HandleMapInventoryZoom( UINT32 iPage, INT32 iCounter );
void HandleMapInventoryUnzoom( UINT32 iPage );
// HEADROCK HAM 5: Function to get the number of slots when zoomed.
UINT16 GetInventorySlotCount( BOOLEAN fZoomed );
void CancelInventoryZoomInput( BOOLEAN fButtonOff );

void AnimateZoomInventory ( UINT16 iLocationInPool, UINT16 iCounter, INT32 iStartX, INT32 iStartY, UINT32 uiOrigWidth, UINT32 uiOrigHeight );
// HEADROCK HAM 5: This does the same thing as CTRL-SHIFT-A in the tactical view, except it sorts
// the currently-opened sector inventory ammo.
void SortSectorInventoryAmmo(bool useBoxes);
void SortSectorInventoryEjectAmmo();
void SortSectorInventorySeparateAttachments();
void SortSectorInventoryStackAndMerge(bool ammoOnly);
// HEADROCK HAM 5: A quick function to rebuilt the Seen and Unseen item pools without saving the inventory.
void RefreshSeenAndUnseenPools();
void CreateMapInventoryFilterMenu( );
void MapInventoryFilterMenuPopup_FilterToggle( UINT32 uiFlags );
void MapInventoryFilterMenuPopup_FilterSet(UINT32 uiFlags );
void MapInventoryFilterMenuPopup_Hide( void );
BOOLEAN MapInventoryFilterMenuPopup_OptionOff( void );
void MapInventoryFilterToggle( UINT32 uiFlags );
void MapInventoryFilterSet( UINT32 uiFlags );
void HandleSetFilterButtons();

// load the background panel graphics for inventory
BOOLEAN LoadInventoryPoolGraphic( void )
{
	VOBJECT_DESC    VObjectDesc;

	// load the file
	VObjectDesc.fCreateFlags=VOBJECT_CREATE_FROMFILE;

	if (iResolution >= _640x480 && iResolution < _800x600)
	{
		MAP_INV_SLOT_COLS = 8;
		MAP_INVENTORY_POOL_SLOT_COUNT = 40;
		MAP_INVENTORY_POOL_SLOT_START_X = 269 + xResOffset;
		MAP_INVENTORY_POOL_SLOT_START_Y = 51;
		sprintf( VObjectDesc.ImageFile, "INTERFACE\\sector_inventory.sti" );
	}
	else if (iResolution < _1024x768)
	{
		MAP_INV_SLOT_COLS = 11;
		MAP_INVENTORY_POOL_SLOT_COUNT = 77;
		MAP_INVENTORY_POOL_SLOT_START_X = (SCREEN_WIDTH - INTERFACE_WIDTH)/2 + 278 + xResOffset;
		MAP_INVENTORY_POOL_SLOT_START_Y = 62;
		sprintf( VObjectDesc.ImageFile, "INTERFACE\\sector_inventory_800x600.sti" );
	}
	else
	{
		MAP_INV_SLOT_COLS = 17;
		MAP_INVENTORY_POOL_SLOT_COUNT = MAP_INVENTORY_POOL_MAX_SLOTS;
		MAP_INVENTORY_POOL_SLOT_START_X = (SCREEN_WIDTH - INTERFACE_WIDTH)/2 + 282 + xResOffset;
		MAP_INVENTORY_POOL_SLOT_START_Y = 50;
		sprintf( VObjectDesc.ImageFile, "INTERFACE\\sector_inventory_1024x768.sti" );
	}

	// add to V-object index
	CHECKF(AddVideoObject(&VObjectDesc, &guiMapInventoryPoolBackground));

	// HEADROCK HAM 5: Load individual slot pics.
	sprintf( VObjectDesc.ImageFile, "INTERFACE\\sector_inventory_slot.sti" );
	CHECKF(AddVideoObject(&VObjectDesc, &guiMapInventoryPoolSlot));

	// HEADROCK HAM 5: Take this opportunity to load BigItem asterisks.
	sprintf( VObjectDesc.ImageFile, "INTERFACE\\Attachment_Asterisks.sti" );
	CHECKF(AddVideoObject(&VObjectDesc, &guiAttachmentAsterisks));

	return( TRUE );
}



// remove background panel graphics for inventory
void RemoveInventoryPoolGraphic( void )
{
	// remove from v-object index
	if( guiMapInventoryPoolBackground )
	{
		DeleteVideoObjectFromIndex( guiMapInventoryPoolBackground );
		guiMapInventoryPoolBackground = 0;
	}

	// HEADROCK HAM 5: Remove slot image
	if (guiMapInventoryPoolSlot)
	{
		DeleteVideoObjectFromIndex( guiMapInventoryPoolSlot );
		guiMapInventoryPoolSlot = 0;
	}
	
	// HEADROCK HAM 5: Remove asterisks
	if (guiAttachmentAsterisks)
	{
		DeleteVideoObjectFromIndex( guiAttachmentAsterisks );
		guiAttachmentAsterisks = 0;
	}

	return;
}

// blit the background panel for the inventory
void BlitInventoryPoolGraphic( void )
{
	HVOBJECT hHandle;

	// blit inventory pool graphic to the screen
	GetVideoObject(&hHandle, guiMapInventoryPoolBackground);
	BltVideoObject( guiSAVEBUFFER , hHandle, 0,(SCREEN_WIDTH - INTERFACE_WIDTH)/2 + INVEN_POOL_X, INVEN_POOL_Y , VO_BLT_SRCTRANSPARENCY,NULL );

	// HEADROCK HAM 5: Draw inventory slots
	BlitInventoryPoolSlotGraphics();

	// resize list
	ResizeInventoryList( );


	// now the items
	RenderItemsForCurrentPageOfInventoryPool( );

	// now update help text
	UpdateHelpTextForInvnentoryStashSlots( );

	// show which page and last page
	DisplayPagesForMapInventoryPool( );

	// draw number of items in current inventory
	DrawNumberOfIventoryPoolItems( );

	// display current sector inventory pool is at
	DisplayCurrentSector( );

	DrawTextOnMapInventoryBackground( );

	// re render buttons
	MarkButtonsDirty( );

	// which buttons will be active and which ones not
	HandleButtonStatesWhileMapInventoryActive( );

	// Invalidate
	RestoreExternBackgroundRect(xResOffset + MAP_BORDER_X, MAP_BORDER_Y, SCREEN_WIDTH - MAP_BORDER_X - 2 * xResOffset, SCREEN_HEIGHT - 121 - 2 * yResOffset);

	return;
}

// HEADROCK HAM 5: Blit all map inventory item slots
void BlitInventoryPoolSlotGraphics( void )
{
	INT16 sX, sY;
	HVOBJECT hHandle;

	// blit inventory pool graphic to the screen
	GetVideoObject(&hHandle, guiMapInventoryPoolSlot);
		
	for( INT32 iCounter = 0; iCounter < MAP_INVENTORY_POOL_SLOT_COUNT ; iCounter++ )
	{
		sX = ( INT16 )( MAP_INVENTORY_POOL_SLOT_OFFSET_X + MAP_INVENTORY_POOL_SLOT_START_X + ( ( MAP_INVEN_SPACE_BTWN_SLOTS ) * ( iCounter / MAP_INV_SLOT_COLS ) ) );
		sY = ( INT16 )( MAP_INVENTORY_POOL_SLOT_START_Y + ( ( MAP_INVEN_SLOT_HEIGHT ) * ( iCounter % ( MAP_INV_SLOT_COLS ) ) ) );

		BltVideoObject( guiSAVEBUFFER , hHandle, fMapInventoryZoom, sX, sY , VO_BLT_SRCTRANSPARENCY,NULL );
	}
	
	return;
}

void RenderItemsForCurrentPageOfInventoryPool( void )
{
	INT32 iCounter = 0;

	// go through list of items on this page and place graphics to screen
	for( iCounter = 0; iCounter < MAP_INVENTORY_POOL_SLOT_COUNT ; iCounter++ )
	{
		RenderItemInPoolSlot( iCounter, ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) );
	}

	return;
}


BOOLEAN RenderItemInPoolSlot( INT32 iCurrentSlot, INT32 iFirstSlotOnPage )
{
	// render item in this slot of the list
	INT16 sCenX, sCenY, usWidth, usHeight, sX, sY;
	HVOBJECT hHandle;
	ETRLEObject		*pTrav;
	CHAR16 sString[ 64 ];
	INT16 sWidth = 0, sHeight = 0;
	INT16 sOutLine = 0;
	BOOLEAN fOutLine = FALSE;

	// check if anything there

	if( pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object.exists() == false )
	{
		// HEADROCK HAM 5: Have to return false.
		return ( FALSE );
	}

	GetVideoObject( &hHandle, GetInterfaceGraphicForItem( &(Item[ pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object.usItem ] ) ) );

	UINT16 usGraphicNum = g_bUsePngItemImages ? 0 : Item[pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object.usItem ].ubGraphicNum;
	pTrav = &( hHandle->pETRLEObject[ usGraphicNum ] );
	usHeight				= (UINT16)pTrav->usHeight;
	usWidth					= (UINT16)pTrav->usWidth;

	// set sx and sy
	sX = ( INT16 )( MAP_INVENTORY_POOL_SLOT_OFFSET_X + MAP_INVENTORY_POOL_SLOT_START_X + ( ( MAP_INVEN_SPACE_BTWN_SLOTS ) * ( iCurrentSlot / MAP_INV_SLOT_COLS ) ) );
	sY = 	( INT16 )( MAP_INVENTORY_POOL_SLOT_START_Y + ( ( MAP_INVEN_SLOT_HEIGHT ) * ( iCurrentSlot % ( MAP_INV_SLOT_COLS ) ) ) );

	// CENTER IN SLOT!
	sCenX = sX + ( abs( MAP_INVEN_SPACE_BTWN_SLOTS - usWidth ) / 2 ) - pTrav->sOffsetX;
	sCenY = sY + ( abs( MAP_INVEN_SLOT_HEIGHT - 5 - usHeight ) / 2 ) - pTrav->sOffsetY;


	if( fMapInventoryItemCompatable[ iCurrentSlot ] || gfMapInventoryItemToZoom[ iCurrentSlot ] )
	{
		fOutLine = TRUE;
		// Determine Color
		if ( fMapInventoryItemCompatable[ iCurrentSlot ] )
		{
			sOutLine = Get16BPPColor( FROMRGB( 255, 255, 255 ) );
		}
		else if ( gfMapInventoryItemToZoom[ iCurrentSlot ] )
		{
			sOutLine = Get16BPPColor( FROMRGB( 255, 255, 55 ) );
		}
	}
	else
	{
		sOutLine = us16BPPItemCyclePlacedItemColors[ 0 ];
		fOutLine = FALSE;
	}

	SetFontDestBuffer( guiSAVEBUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );

	if(UsingNewInventorySystem() == true && gpItemPointer != NULL)
	{
		int itemSlotLimit = ItemSlotLimit(gpItemPointer, STACK_SIZE_LIMIT);
		RenderPocketItemCapacity( guiSAVEBUFFER, itemSlotLimit, STACK_SIZE_LIMIT, 0, &pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object, (sX + 7), sY );
	}

	if (fMapInventoryZoom)
	{
		// Check whether the correct graphic exists.
		if (giMapInventoryBigItemGraphics[ iCurrentSlot ].iGraphicNum == -1 || 
			giMapInventoryBigItemGraphics[ iCurrentSlot ].usItem != pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object.usItem )
		{
			UnloadMapInventoryBigItemGraphic( iCurrentSlot );
			LoadMapInventoryBigItemGraphic( iCurrentSlot );
		}
		// Retest
		if (giMapInventoryBigItemGraphics[ iCurrentSlot ].usItem > 0 && giMapInventoryBigItemGraphics[ iCurrentSlot ].iGraphicNum > -1)
		{
			MAPINVRenderItem( guiSAVEBUFFER, NULL, &(pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object), (UINT32)giMapInventoryBigItemGraphics[ iCurrentSlot ].iGraphicNum, 
				sX + 5, sY, MAP_INVEN_SLOT_WIDTH, MAP_INVEN_SLOT_IMAGE_HEIGHT, fOutLine, sOutLine );
		}
	}
	else
	{
		INVRenderItem( guiSAVEBUFFER, NULL, &(pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object),
			(INT16)(sX + 7), sY, 60, 25, DIRTYLEVEL2, NULL, 0, fOutLine, sOutLine );//67
	}

	SetFontDestBuffer( FRAME_BUFFER, 0,0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );


	if( pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object.exists() == false )
	{
		return ( FALSE );
	}

	// now draw bar for condition
	// Display ststus
	DrawItemUIBarEx( &( pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object ), 0,
		(INT16)( ITEMDESC_ITEM_STATUS_INV_POOL_OFFSET_X + MAP_INVENTORY_POOL_SLOT_START_X + ( ( MAP_INVEN_SPACE_BTWN_SLOTS ) * ( iCurrentSlot / MAP_INV_SLOT_COLS ) ) ),
		( INT16 )( ITEMDESC_ITEM_STATUS_INV_POOL_OFFSET_Y + MAP_INVENTORY_POOL_SLOT_START_Y + ( ( MAP_INVEN_SLOT_HEIGHT ) * ( iCurrentSlot % ( MAP_INV_SLOT_COLS ) ) ) )
		, ITEMDESC_ITEM_STATUS_WIDTH_INV_POOL, ITEMDESC_ITEM_STATUS_HEIGHT_INV_POOL, 	Get16BPPColor( DESC_STATUS_BAR ), Get16BPPColor( DESC_STATUS_BAR_SHADOW ), TRUE, guiSAVEBUFFER );


	//
	// if the item is not reachable, or if the selected merc is not in the current sector
	//
	if( !( pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].usFlags & WORLD_ITEM_REACHABLE ) ||
			!(( Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ].sSectorX == sSelMapX ) &&
				( Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ].sSectorY == sSelMapY ) &&
				( Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ].bSectorZ == iCurrentMapSectorZ )
			) )
	{
		//Shade the item, but only if it is an active item!
		if ( pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object.exists() == true) {
			DrawHatchOnInventory( guiSAVEBUFFER, sX, sY, MAP_INVEN_SLOT_WIDTH, MAP_INVEN_SLOT_IMAGE_HEIGHT );
		}
	}


	// the name

	wcscpy( sString, ShortItemNames[ pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object.usItem ] );

	if( StringPixLength( sString, MAP_INVEN_NAME_FONT ) >= ( MAP_INVEN_SLOT_WIDTH ) )
	{
		ReduceStringLength( sString, ( INT16 )( MAP_INVEN_SLOT_WIDTH - StringPixLength( L" ...", MAP_INVEN_NAME_FONT ) ), MAP_INVEN_NAME_FONT );
	}

	FindFontCenterCoordinates( (INT16)( 4 + MAP_INVENTORY_POOL_SLOT_START_X + ( ( MAP_INVEN_SPACE_BTWN_SLOTS ) * ( iCurrentSlot / MAP_INV_SLOT_COLS ) ) ),
		0, MAP_INVEN_SLOT_WIDTH, 0,
		sString, MAP_INVEN_NAME_FONT,
		&sWidth, &sHeight );

	SetFontDestBuffer( guiSAVEBUFFER, 0,0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );

	SetFont( MAP_INVEN_NAME_FONT );
	SetFontForeground( FONT_WHITE );
	SetFontBackground( FONT_BLACK );

	// HEADROCK HAM 5: Offset is now changeable.
	mprintf( sWidth,
		( INT16 )( ITEMDESC_ITEM_NAME_POOL_OFFSET_Y + ITEMDESC_ITEM_STATUS_INV_POOL_OFFSET_Y + MAP_INVENTORY_POOL_SLOT_START_Y + ( ( MAP_INVEN_SLOT_HEIGHT ) * ( iCurrentSlot % ( MAP_INV_SLOT_COLS ) ) ) )
	, sString );

	// HEADROCK HAM 5: If ALT is pressed, draw sale price.
	if( _KeyDown( ALT ) )
	{
		INT32 iPrice;
		if ( _KeyDown( SHIFT ) )
		{
			iPrice = SellItem( pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object, TRUE );
		}
		else
		{
			iPrice = SellItem( pInventoryPoolList[ iCurrentSlot + iFirstSlotOnPage ].object, FALSE );
		}
		
		swprintf( sString, L"$%d", iPrice );

		UINT32 uiSalePriceFont = (fMapInventoryZoom ? FONT12ARIAL : FONT10ARIAL);
		UINT16 usFontHeight = GetFontHeight( uiSalePriceFont );

		SetFontDestBuffer( guiSAVEBUFFER, 0,0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );

		SetFont( uiSalePriceFont );
		SetFontForeground( FONT_RED );
		SetFontBackground( FONT_BLACK );

		INT16 sOffsetX = (fMapInventoryZoom ? 12 : 10);
		INT16 sOffsetY = (fMapInventoryZoom ? 5 : 3);

		sX = (INT16)( sOffsetX + MAP_INVENTORY_POOL_SLOT_START_X + ( ( MAP_INVEN_SPACE_BTWN_SLOTS ) * ( iCurrentSlot / MAP_INV_SLOT_COLS ) ) );
		sY = (INT16)( sOffsetY + MAP_INVENTORY_POOL_SLOT_START_Y + ( ( MAP_INVEN_SLOT_HEIGHT ) * ( iCurrentSlot % MAP_INV_SLOT_COLS ) ) );

		mprintf( sX, sY, sString );

	}

	SetFontDestBuffer( FRAME_BUFFER, 0,0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );

	return( TRUE );
}


void UpdateHelpTextForInvnentoryStashSlots( void )
{
	CHAR16 pStr[ 512 ];
	INT32 iCounter = 0;
	INT32 iFirstSlotOnPage = ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT );


	// run through list of items in slots and update help text for mouse regions
	for( iCounter = 0; iCounter < MAP_INVENTORY_POOL_SLOT_COUNT; iCounter++ )
	{
		if( pInventoryPoolList[ iCounter + iFirstSlotOnPage ].object.exists() == true )
		{
			GetHelpTextForItem( pStr , &( pInventoryPoolList[ iCounter + iFirstSlotOnPage ].object ), NULL );
			SetRegionFastHelpText( &(MapInventoryPoolSlots[ iCounter ] ), pStr );

			/*
			// set text for current item
			if( pInventoryPoolList[ iCounter + iFirstSlotOnPage ].object.usItem == MONEY )
			{
				swprintf( pStr, L"$%ld", pInventoryPoolList[ iCounter + iFirstSlotOnPage ].object[0]->data.money.uiMoneyAmount );
				SetRegionFastHelpText( &(MapInventoryPoolSlots[ iCounter ]), pStr );
			}
			else
			{
				SetRegionFastHelpText( &(MapInventoryPoolSlots[ iCounter ]), ItemNames[ pInventoryPoolList[ iCounter + iFirstSlotOnPage ].object.usItem ] );
			}
			*/
		}
		else
		{
			//OK, for each item, set dirty text if applicable!
			SetRegionFastHelpText( &(MapInventoryPoolSlots[ iCounter ]), L"" );
		}
	}

	return;
}



// create and remove buttons for inventory
void CreateDestroyMapInventoryPoolButtons( BOOLEAN fExitFromMapScreen )
{
	static BOOLEAN fCreated = FALSE;

/* player can leave items underground, no?
	if( iCurrentMapSectorZ )
	{
		fShowMapInventoryPool = FALSE;
	}
*/

	if( ( fShowMapInventoryPool ) && ( fCreated == FALSE ) )
	{
		// HEADROCK HAM 5: Reset the offsets!
		ResetMapInventoryOffsets();

		if( ( gWorldSectorX == sSelMapX ) && ( gWorldSectorY == sSelMapY ) && ( gbWorldSectorZ == iCurrentMapSectorZ ) )
		{
			// handle all reachable before save
			HandleAllReachAbleItemsInTheSector( gWorldSectorX, gWorldSectorY, gbWorldSectorZ );
		}

		// destroy buttons for map border
		DeleteMapBorderButtons( );

		// delete map level markers regions
		DeleteMouseRegionsForLevelMarkers( );

		fCreated = TRUE;

		// also create the inventory slot
		CreateMapInventoryPoolSlots( );

		// create buttons
		CreateMapInventoryButtons( );

		// build stash
		BuildStashForSelectedSector( sSelMapX, sSelMapY, ( INT16 )( iCurrentMapSectorZ ) );

		// HEADROCK HAM 5: Reset all BigItem image numbers, just in case.
		ResetAllMapInventoryBigItemGraphics();

		CreateMapInventoryPoolDoneButton( );

		fMapPanelDirty = TRUE;
		fMapScreenBottomDirty = TRUE;
	}
	else if( ( fShowMapInventoryPool == FALSE ) && ( fCreated == TRUE ) )
	{
		if(gGameExternalOptions.fEnableInventoryPoolQ)//dnl ch51 081009
			SwitchToInventoryPoolQ(0);

		// check fi we are in fact leaving mapscreen
		if( fExitFromMapScreen == FALSE )
		{
			// recreate mapborder buttons
			CreateButtonsForMapBorder( );

			// recreate map level markers regions
			CreateMouseRegionsForLevelMarkers( );
		}
		fCreated = FALSE;

		// destroy the map inventory slots
		DestroyMapInventoryPoolSlots( );

		// destroy map inventory buttons
		DestroyMapInventoryButtons( );

		DestroyInventoryPoolDoneButton( );

		// HEADROCK HAM 5: Destroy big item graphics.
		if (fMapInventoryZoom)
		{
			UnloadAllMapInventoryBigItemGraphics();
		}
		// HEADROCK HAM 5: Cancel zoom input request, if active.
		if (fWaitingForZoomInput)
		{
			CancelInventoryZoomInput( FALSE ); // Must be false, because the button doesn't exist anymore!
		}

		// Reset number of desired slots so we recalculate page size entirely on the next open.
		giDesiredNumMapInventorySlots = -1;

		// clear up unseen list
		ClearUpTempUnSeenList( );

		// now save results
		SaveSeenAndUnseenItems( );

		DestroyStash( );

		// HEADROCK HAM 5: Filters!
		guiMapInventoryFilter = IC_MAPFILTER_ALL;

		fMapPanelDirty = TRUE;
		fTeamPanelDirty = TRUE;
		fCharacterInfoPanelDirty = TRUE;
		// HEADROCK HAM 3.6: Yet again, make sure to refresh the bottom panel on closing.
		fMapScreenBottomDirty = TRUE;

		//CHRISL: close stack popup and item description windows
		DeleteItemStackPopup();
		if ( gfInItemDescBox )
		{
			DeleteItemDescriptionBox();
		}
		//DEF: added to remove the 'item blip' from staying on the radar map
		iCurrentlyHighLightedItem = -1;

		// re render radar map
		RenderRadarScreen( );
	}

	// do our handling here
	HandleMapSectorInventory( );

}


void CancelSectorInventoryDisplayIfOn( BOOLEAN fExitFromMapScreen )
{
	if ( fShowMapInventoryPool )
	{
		// get rid of sector inventory mode & buttons
		fShowMapInventoryPool = FALSE;
		CreateDestroyMapInventoryPoolButtons( fExitFromMapScreen );
	}
}



void ClearUpTempUnSeenList( void )
{
	// save these items and all the others
	if( pUnSeenItems == NULL )
	{
		return;
	}

	// build the list based on this
	pSaveList = pUnSeenItems;
	pUnSeenItems = NULL;

	return;
}

void SaveSeenAndUnseenItems( void )
{
	WORLDITEM *pSeenItemsList = NULL;
	UINT32 iCounter = 0;
	INT32 iItemCount = 0;
	INT32 iTotalNumberItems = 0;

	// allocate space
	iTotalNumberItems = GetTotalNumberOfItems( );

	// if there are seen items, build a temp world items list of them and save them
	if( iTotalNumberItems > 0 )
	{
		pSeenItemsList = new WORLDITEM[ iTotalNumberItems ];

		// copy
		for( iCounter = 0; iCounter < pInventoryPoolList.size(); iCounter++ )
		{
			if( pInventoryPoolList[ iCounter ].object.exists() == true )
			{
				// copy object stuff
				pSeenItemsList[ iItemCount ] = pInventoryPoolList[ iCounter ];

				// check if item actually lives at a gridno
				// if not, check predicessor, iItemCount is not 0
				if( pSeenItemsList[ iItemCount ].sGridNo == 0 )
				{
					if( iItemCount > 0 )
					{
						// borrow from predicessor
						pSeenItemsList[ iItemCount ].sGridNo = pSeenItemsList[ iItemCount - 1 ].sGridNo;
					}
					else
					{
						// get entry grid location
					}
				}
				pSeenItemsList[ iItemCount ].fExists = TRUE;
				pSeenItemsList[ iItemCount ].bVisible = TRUE;
				iItemCount++;
			}
		}
	}

	// if this is the loaded sector handle here
	if( ( gWorldSectorX == sSelMapX ) && ( gWorldSectorY == sSelMapY ) && ( gbWorldSectorZ == ( INT8 ) ( iCurrentMapSectorZ ) ) )
	{
		ReBuildWorldItemStashForLoadedSector( iItemCount, uiNumberOfUnSeenItems, pSeenItemsList, pSaveList );
	}
	else
	{
		// now copy over unseen and seen
		if( uiNumberOfUnSeenItems > 0 )
		{
			// over write file and copy unseen
			AddWorldItemsToUnLoadedSector( sSelMapX, sSelMapY, ( INT8 )( iCurrentMapSectorZ ), 0, uiNumberOfUnSeenItems, pSaveList, TRUE );

			// check if seen items exist too
			if( iItemCount > 0 )
			{
				AddWorldItemsToUnLoadedSector( sSelMapX, sSelMapY, ( INT8 )( iCurrentMapSectorZ ), 0, iItemCount, pSeenItemsList, FALSE );
			}

		}
		else if( iItemCount > 0 )
		{
			// copy only seen items
			AddWorldItemsToUnLoadedSector( sSelMapX, sSelMapY, ( INT8 )( iCurrentMapSectorZ ), 0, iItemCount, pSeenItemsList, TRUE );
		}
		else
		{
			// get rid of the file
			SaveWorldItemsToTempItemFile( sSelMapX, sSelMapY, ( INT8 )( iCurrentMapSectorZ ), 0, NULL );
			return;
		}
	}

	// now clear out seen list
	if( pSeenItemsList != NULL )
	{
		delete[]( pSeenItemsList );
		pSeenItemsList = NULL;
	}

	// clear out unseen list
	if( pSaveList != NULL )
	{
		delete[]( pSaveList );
		pSaveList = NULL;
	}

	uiNumberOfUnSeenItems = 0;
	iItemCount = 0;
}



// the screen mask bttn callaback...to disable the inventory and lock out the map itself
void MapInvenPoolScreenMaskCallback(MOUSE_REGION * pRegion, INT32 iReason )
{

	if( ( iReason & MSYS_CALLBACK_REASON_RBUTTON_UP ) )
	{
		fShowMapInventoryPool = FALSE;
	}

	return;
}

void CreateMapInventoryPoolSlots( )
{
	INT32 iCounter = 0;
	INT16 sX = 0, sY = 0;
	INT16 sXA = 0, sYA = 0;
	INT16 sULX = 0, sULY = 0;
	INT16 sBRX = 0, sBRY = 0;

	MSYS_DefineRegion( &MapInventoryPoolMask,
			MAP_INVENTORY_POOL_SLOT_START_X, 0, SCREEN_WIDTH - MAP_INVENTORY_POOL_SLOT_START_X, SCREEN_HEIGHT - 120,
			MSYS_PRIORITY_HIGH, MSYS_NO_CURSOR, MSYS_NO_CALLBACK, MapInvenPoolScreenMaskCallback);

	for( iCounter = 0; iCounter < MAP_INVENTORY_POOL_SLOT_COUNT; iCounter++ )
	{
		sX = ( iCounter / MAP_INV_SLOT_COLS );
		sY = ( iCounter % ( MAP_INV_SLOT_COLS ) );

		sXA = sX + 1;
		sYA = sY + 1;

		sULX = MAP_INVENTORY_POOL_SLOT_START_X + 4;
		sULY = MAP_INVENTORY_POOL_SLOT_START_Y + 1;

		sULX += ( INT16 ) ( sX * MAP_INVEN_SPACE_BTWN_SLOTS  );
		sULY += ( INT16 ) ( ( sY * MAP_INVEN_SLOT_HEIGHT ) );

		sBRX = ( INT16 ) ( MAP_INVENTORY_POOL_SLOT_START_X + ( sXA * MAP_INVEN_SPACE_BTWN_SLOTS ) );
		sBRY = ( INT16 ) ( MAP_INVENTORY_POOL_SLOT_START_Y + ( sYA * MAP_INVEN_SLOT_HEIGHT ) ) - 1;

		MSYS_DefineRegion( &MapInventoryPoolSlots[ iCounter ],
			sULX, sULY, sBRX, sBRY,
			MSYS_PRIORITY_HIGH, MSYS_NO_CURSOR, MapInvenPoolSlotsMove, MapInvenPoolSlots );

		MSYS_SetRegionUserData( &MapInventoryPoolSlots[iCounter], 0, iCounter );

	}
}


void DestroyMapInventoryPoolSlots( void )
{
	INT32 iCounter = 0;

	for( iCounter = 0; iCounter < MAP_INVENTORY_POOL_SLOT_COUNT; iCounter++ )
	{
		MSYS_RemoveRegion(  &MapInventoryPoolSlots[ iCounter ] );
	}

	// remove map inventory mask
	MSYS_RemoveRegion( &MapInventoryPoolMask );

}

void MapInvenPoolSlotsMove( MOUSE_REGION * pRegion, INT32 iReason  )
{
	INT32 iCounter = 0;


	iCounter = MSYS_GetRegionUserData( pRegion, 0 );

	// HEADROCK HAM 5: While in inventory zoom input mode, we do not draw item compatibility. Instead, mousing
	// over the inventory shows which items from the current page will appear on the zoomed page. This information
	// is calculated below.
	if (!fMapInventoryZoom && fWaitingForZoomInput)
	{
		//iCounter indicates the position of our item in the current (unzoomed) pool page.

		// Get the total number of slots shown on each Zoomed Page.
		UINT16 usSlotsOnZoomedPage = GetInventorySlotCount( TRUE );

		// Find our item's location in the entire sector pool.
		UINT16 usItemLocationInPool = iCounter + (iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT);
		
		// Which page would it be on when zoomed?
		UINT16 usZoomedPage = usItemLocationInPool / usSlotsOnZoomedPage;
		// Which position would it be in on that page?
		UINT16 usPlaceOnZoomedPage = usItemLocationInPool % usSlotsOnZoomedPage;

		// Alright, now lets figure out what the first item on that page will be.
		INT16 sFirstItemToHilite = (usZoomedPage * usSlotsOnZoomedPage);
		// Where is it on the page we're looking at currently?
		sFirstItemToHilite = sFirstItemToHilite - (iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT);
		// We're not interested in items that are not currently on the screen...
		sFirstItemToHilite = __max(0, sFirstItemToHilite );

		// And which is the last item that will be on the zoomed page?
		INT16 sLastItemToHilite = ((usZoomedPage+1) * usSlotsOnZoomedPage) - 1;
		// Where is it on the page we're looking at currently?
		sLastItemToHilite = sLastItemToHilite - (iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT);
		// We're not interested in items that are not currently on the screen...
		sLastItemToHilite = __min(((iCurrentInventoryPoolPage+1) * MAP_INVENTORY_POOL_SLOT_COUNT), sLastItemToHilite );

		// Run from the first to the last item, setting them to have an outline displayed.
		BOOLEAN fAnyObjectsExist = FALSE;
		for (UINT16 x = 0; x < MAP_INVENTORY_POOL_SLOT_COUNT; x++)
		{
			if (x >= sFirstItemToHilite && x <= sLastItemToHilite)
			{
				gfMapInventoryItemToZoom[x] = TRUE;
			}
			else
			{
				gfMapInventoryItemToZoom[x] = FALSE;
			}
		}

		/*
		for (UINT8 x = ubColumnOfFirstItem; x <= ubColumnOfLastItem; x++)
		{
			INT16 top = 0;
			INT16 bottom = 0;
			INT16 left = 0;
			INT16 right = 0;

			if (x == ubColumnOfFirstItem)
			{
				top = ( INT16 )( MAP_INVENTORY_POOL_SLOT_START_Y + ( MAP_INVEN_SLOT_HEIGHT * ubPositionFirstItem ) );
			}
			else
			{
				top = ( INT16 )( MAP_INVENTORY_POOL_SLOT_START_Y );
			}

			if (x == ubColumnOfLastItem)
			{
				bottom = ( INT16 )( MAP_INVENTORY_POOL_SLOT_START_Y + ( MAP_INVEN_SLOT_HEIGHT * (ubPositionLastItem+1) ) );
			}
			else
			{
				bottom = ( INT16 )( MAP_INVENTORY_POOL_SLOT_START_Y + ( MAP_INVEN_SLOT_HEIGHT * (MAP_INV_SLOT_COLS+1) ) );
			}
				
			left = ( INT16 )( MAP_INVENTORY_POOL_SLOT_OFFSET_X + MAP_INVENTORY_POOL_SLOT_START_X + ( MAP_INVEN_SPACE_BTWN_SLOTS * x ) );
			right = ( INT16 )( MAP_INVENTORY_POOL_SLOT_OFFSET_X + MAP_INVENTORY_POOL_SLOT_START_X + ( MAP_INVEN_SPACE_BTWN_SLOTS * (x+1) ) );

			INT16 sColor = Get16BPPColor( FROMRGB( 255, 255, 255 ) );
			DrawItemOutlineZoomedInventory( left, top, right, bottom, sColor, guiSAVEBUFFER );
		}
		*/

		fMapPanelDirty = TRUE;
	}
	else
	{
		if( iReason & MSYS_CALLBACK_REASON_GAIN_MOUSE )
		{
			iCurrentlyHighLightedItem = iCounter;
			fChangedInventorySlots = TRUE;
			gfCheckForCursorOverMapSectorInventoryItem = TRUE;
		}
		else if( iReason & MSYS_CALLBACK_REASON_LOST_MOUSE )
		{
			iCurrentlyHighLightedItem = -1;
			fChangedInventorySlots = TRUE;
			gfCheckForCursorOverMapSectorInventoryItem = FALSE;

			// re render radar map
			RenderRadarScreen( );
		}
	}
}


void MapInvenPoolSlots(MOUSE_REGION * pRegion, INT32 iReason )
{
	// btn callback handler for assignment screen mask region
	INT32 iCounter = 0;
	UINT16 usOldItemIndex, usNewItemIndex;
	INT32 iOldNumberOfObjects = 0;
	INT16 sDistanceFromObject = 0;
	SOLDIERTYPE *pSoldier = NULL;
	CHAR16 sString[ 128 ];
	extern OBJECTTYPE	*gpItemDescObject;

	iCounter = MSYS_GetRegionUserData( pRegion, 0 );

	if( ( iReason & MSYS_CALLBACK_REASON_RBUTTON_UP ) )
	{
		// HEADROCK HAM 5: If in Zoom Input mode, cancel it
		if (fWaitingForZoomInput)
		{
			CancelInventoryZoomInput( TRUE );
			
			return;
		}
		if(gGameExternalOptions.fSectorDesc == TRUE)
		{
			//CHRISL: Make it possible to right click and pull up stack popup and/or item description boxes
			WORLDITEM	* twItem = &(pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ]);
			bool	fValidPointer = false;
			//CHRISL: Try to update InSector value so we don't have to "activate" a sector
			if(MercPtrs[gCharactersList[bSelectedInfoChar].usSolID]->sSectorX == sSelMapX && MercPtrs[gCharactersList[bSelectedInfoChar].usSolID]->sSectorY == sSelMapY && MercPtrs[gCharactersList[bSelectedInfoChar].usSolID]->bSectorZ == iCurrentMapSectorZ && !MercPtrs[gCharactersList[bSelectedInfoChar].usSolID]->flags.fBetweenSectors)
			{
				MercPtrs[gCharactersList[bSelectedInfoChar].usSolID]->bInSector=TRUE;
			}
			else
			{
				// HEADROCK HAM 5: Unreachable items will never show an infobox.
				return;
			}
			// HEADROCK HAM 5: Unreachable items will never show an infobox.
			if (!(twItem->usFlags & WORLD_ITEM_REACHABLE))
			{
				return;
			}
			if ( !InSectorStackPopup( ) && !InItemStackPopup( ) /*&& !InItemDescriptionBox( ) */ && !InKeyRingPopup( ) && twItem->object.exists() == true && (bSelectedInfoChar != -1 && gCharactersList[bSelectedInfoChar].fValid) )
			{
				if(OK_CONTROL_MERC( MercPtrs[gCharactersList[bSelectedInfoChar].usSolID] ))
				{
					//CHRISL: The old setup had a flaw I didn't consider.  if, for some reason, the ItemSlotLimit = 0
					//	nothing might happen.  Now we setup a flag to determine if our cursor is value for the item we're
					//	clicking on.  If it's not valid, we can't do anything so all conditions rely on it being true.
					//if(ItemSlotLimit( &twItem->object, STACK_SIZE_LIMIT ) == 1)
					if(gpItemPointer == NULL)
						fValidPointer = true;
					else
					{
						if(gpItemPointer->usItem == twItem->object.usItem)
							fValidPointer = true;
						if(ValidAttachment(gpItemPointer->usItem, &(twItem->object)) == TRUE)
							fValidPointer = true;
						if(ValidAmmoType(twItem->object.usItem, gpItemPointer->usItem) == TRUE)
							fValidPointer = true;
					}
					if(twItem->object.ubNumberOfObjects == 1 && fValidPointer)
					{
						fShowInventoryFlag = TRUE;

						if (InItemDescriptionBox( ))
						{
							DeleteItemDescriptionBox();
						}
						// HEADROCK HAM 5: Sector Inventory Item Desc Box no longer accessible during combat.
						
						if( !CanPlayerUseSectorInventory( &(Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ]) ) )
						{
							DoScreenIndependantMessageBox( New113HAMMessage[ 22 ], MSG_BOX_FLAG_OK, NULL );
							return;
						}
						else
						{
							MAPInternalInitItemDescriptionBox( &twItem->object, 0, MercPtrs[gCharactersList[bSelectedInfoChar].usSolID] );
						}
					}
					else if(fValidPointer)
					{
						InitSectorStackPopup( MercPtrs[gCharactersList[bSelectedInfoChar].usSolID], twItem, iCounter, (SCREEN_WIDTH - INTERFACE_WIDTH)/2, -10, 261, ( SCREEN_HEIGHT - PLAYER_INFO_Y ) );
						fTeamPanelDirty=TRUE;
						fInterfacePanelDirty = DIRTYLEVEL2;
					}
				}
			}
		}
		else
		{
			if ( gpItemPointer == NULL )
			{
				fShowMapInventoryPool = FALSE;
			}
			// else do nothing
		}
	}
	else if( iReason & MSYS_CALLBACK_REASON_LBUTTON_UP )
	{
		// HEADROCK HAM 5: If in Zoom Input mode, enter zoom mode using this item's location to determine
		// which page we want to view.
		if (fWaitingForZoomInput)
		{
			// Figure out which page we need to display.
			UINT16 usSlotsOnZoomedPage = GetInventorySlotCount( TRUE );
			UINT16 usItemLocationInPool = iCounter + (iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT);
			UINT16 usTargetPage = usItemLocationInPool / usSlotsOnZoomedPage;

			giDesiredNumMapInventorySlots = (__max(usTargetPage * usSlotsOnZoomedPage, (UINT16)(pInventoryPoolList.size() / usSlotsOnZoomedPage) + usSlotsOnZoomedPage));

			CancelInventoryZoomInput( FALSE );
			HandleMapInventoryZoom( usTargetPage, iCounter );

			return;	
		}

		// check if item in cursor, if so, then swap, and no item in curor, pick up, if item in cursor but not box, put in box

		if ( gpItemPointer == NULL )
		{
			// Return if empty
			if ( pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].object.exists() == false )
				return;
			// CHRISL: Also return if the item we've clicked on is currently displayed in the item description box
			if(InItemDescriptionBox( ) && gpItemDescObject == &pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].object)
				return;
		}



		// is this item reachable
		if( !(  pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].usFlags & WORLD_ITEM_REACHABLE ) )
		{
			if ( pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].object.exists() == true )
			{
				// not reachable
				DoMapMessageBox( MSG_BOX_BASIC_STYLE, gzLateLocalizedString[38], MAP_SCREEN, MSG_BOX_FLAG_OK, NULL );
				return;
			}
		}


		// check if selected merc is in this sector, if not, warn them and leave

		// valid character?
		if( gCharactersList[ bSelectedInfoChar ].fValid == FALSE )
		{
			DoMapMessageBox( MSG_BOX_BASIC_STYLE, pMapInventoryErrorString[ 1 ], MAP_SCREEN, MSG_BOX_FLAG_OK, NULL );
			return;
		}



		//if( fShowInventoryFlag )
		{
			// not in sector?
			if( ( Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ].sSectorX != sSelMapX ) ||
					( Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ].sSectorY != sSelMapY ) ||
					( Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ].bSectorZ != iCurrentMapSectorZ ) ||
					( Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ].flags.fBetweenSectors ) )
			{
				if ( gpItemPointer == NULL )
				{
					swprintf( sString, pMapInventoryErrorString[ 2 ], Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ].name );
				}
				else
				{
					swprintf( sString, pMapInventoryErrorString[ 5 ], Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ].name );
				}
				DoMapMessageBox( MSG_BOX_BASIC_STYLE, sString, MAP_SCREEN, MSG_BOX_FLAG_OK, NULL );
				return;
			}
		}


		// If we do not have an item in hand, start moving it
		if ( gpItemPointer == NULL )
		{


			// Return if empty
			if ( pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].object.exists() == false )
				return;

			// if in battle inform player they will have to do this in tactical
//			if( ( ( gTacticalStatus.fEnemyInSector ) ||( ( sSelMapX == gWorldSectorX ) && ( sSelMapY == gWorldSectorY ) && ( iCurrentMapSectorZ == gbWorldSectorZ ) && ( gTacticalStatus.uiFlags & INCOMBAT ) ) ) )
			if( !CanPlayerUseSectorInventory( &Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ] ) )
			{
				DoMapMessageBox( MSG_BOX_BASIC_STYLE, pMapInventoryErrorString[ 3 ], MAP_SCREEN, MSG_BOX_FLAG_OK, NULL );
				return;
			}

			sObjectSourceGridNo = pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].sGridNo;
			sObjectSourseSoldierID = pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].soldierID;

			// check if this is the loaded sector, if so, then notify player, can't do anything
			if( ( sSelMapX == gWorldSectorX )&&( gWorldSectorY == sSelMapY ) &&(gbWorldSectorZ == iCurrentMapSectorZ ) )
			{
				// notify
				pSoldier = &( Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ] );

				sDistanceFromObject = PythSpacesAway( sObjectSourceGridNo, pSoldier->sGridNo);

			/*	if( sDistanceFromObject > MAX_DISTANCE_TO_PICKUP_ITEM )
				{
					// see for the loaded sector if the merc is cloase enough?
					swprintf( sString, pMapInventoryErrorString[ 0 ], Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ].name );
					DoMapMessageBox( MSG_BOX_BASIC_STYLE, sString, MAP_SCREEN, MSG_BOX_FLAG_OK, NULL );
					return;
				}
				*/
			}

			BeginInventoryPoolPtr( &( pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].object ) );
		}
		else
		{

			// if in battle inform player they will have to do this in tactical
//			if( ( gTacticalStatus.fEnemyInSector ) ||( ( sSelMapX == gWorldSectorX ) && ( sSelMapY == gWorldSectorY ) && ( iCurrentMapSectorZ == gbWorldSectorZ ) && ( gTacticalStatus.uiFlags & INCOMBAT ) ) )
			if( !CanPlayerUseSectorInventory( &Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ] ) )
			{
				DoMapMessageBox( MSG_BOX_BASIC_STYLE, pMapInventoryErrorString[ 4 ], MAP_SCREEN, MSG_BOX_FLAG_OK, NULL );
				return;
			}

			usOldItemIndex = pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].object.usItem;
			usNewItemIndex = gpItemPointer->usItem;
			iOldNumberOfObjects =  pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].object.ubNumberOfObjects;

			//CHRISL: Allow CTRL+LMB to clean up stacks just like we do with personal inventory
			//Curretly, screen isn't automatically refreshing.  You have to move your cursor after CTRL+LMB to see the results.
			if ( _KeyDown(CTRL) )
			{
				CleanUpStack( &( pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].object ), gpItemPointer );
				if ( gpItemPointer->exists() == false )
				{
					MAPEndItemPointer( );
				}
				return;
			}

			// Else, try to place here
			if ( PlaceObjectInInventoryStash( &( pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].object ), gpItemPointer ) )
			{
				// HEADROCK HAM 5: A LOT of functions rely on these flags being set. So set them!!
				pInventoryPoolList[(iCurrentInventoryPoolPage*MAP_INVENTORY_POOL_SLOT_COUNT)+iCounter].bVisible = TRUE;
				pInventoryPoolList[(iCurrentInventoryPoolPage*MAP_INVENTORY_POOL_SLOT_COUNT)+iCounter].fExists = TRUE;
				if(gGameExternalOptions.fEnableInventoryPoolQ)//dnl ch51 091009
				{
					if(!GridNoOnVisibleWorldTile(sObjectSourceGridNo))
						sObjectSourceGridNo = gMapInformation.sCenterGridNo;
				}

				//CHRISL: Make sure we put the item at the same level as the merc
				if(gpItemPointerSoldier->exists() == true)
					pInventoryPoolList[(iCurrentInventoryPoolPage*MAP_INVENTORY_POOL_SLOT_COUNT)+iCounter].ubLevel = gpItemPointerSoldier->pathing.bLevel;

				// set as reachable and set gridno
				pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].usFlags |= WORLD_ITEM_REACHABLE;

				// if loaded sector, grab grid no of dropping soldier
				//if( ( sSelMapX == gWorldSectorX )&&( gWorldSectorY == sSelMapY ) &&(gbWorldSectorZ == iCurrentMapSectorZ ) )
				//{
					// nothing here before, then place here
					if( iOldNumberOfObjects == 0 )
					{
						if(TileIsOutOfBounds(sObjectSourceGridNo))
						{
							pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].usFlags |= WORLD_ITEM_GRIDNO_NOT_SET_USE_ENTRY_POINT;
							pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].sGridNo = sObjectSourceGridNo;
						}
						else
						{
							pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].sGridNo = sObjectSourceGridNo;
						}
						if( sObjectSourseSoldierID != -1 )
							pInventoryPoolList[ ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) + iCounter ].soldierID = sObjectSourseSoldierID;
					}
				//}

				// Check if it's the same now!
				if ( gpItemPointer->exists() == false )
				{
					MAPEndItemPointer( );
				}
				else
				{
					// update ptr
					// now set the cursor
					guiExternVo = GetInterfaceGraphicForItem( &(Item[ gpItemPointer->usItem ]) );
					gusExternVoSubIndex = g_bUsePngItemImages ? 0 : Item[ gpItemPointer->usItem ].ubGraphicNum;

					fMapInventoryItem = TRUE;
					MSYS_ChangeRegionCursor( &gMPanelRegion , EXTERN_CURSOR );
					SetCurrentCursorFromDatabase( EXTERN_CURSOR );
				}

/*
				if ( fShowInventoryFlag && bSelectedInfoChar >= 0 )
				{
					ReevaluateItemHatches( MercPtrs[ gCharactersList[ bSelectedInfoChar ].usSolID ], FALSE );
				}
				*/
			}
		}

		// dirty region, force update
		fMapPanelDirty = TRUE;
	}
}

void CreateMapInventoryButtons( void )
{
	guiMapInvenArrowButtonImage[ 0 ]=  LoadButtonImage( "INTERFACE\\map_screen_bottom_arrows.sti" , 10, 1, -1, 3, -1 );
	guiMapInvenArrowButton[ 0 ] = QuickCreateButton( guiMapInvenArrowButtonImage[ 0 ], (MAP_INV_X_OFFSET + 559), (SCREEN_HEIGHT - 144 - 2 * yResOffset),
									BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
									(GUI_CALLBACK)BtnGenericMouseMoveButtonCallback, (GUI_CALLBACK)MapInventoryPoolNextBtn );


	guiMapInvenArrowButtonImage[ 1 ]=  LoadButtonImage( "INTERFACE\\map_screen_bottom_arrows.sti" ,9, 0, -1, 2, -1 );
	guiMapInvenArrowButton[ 1 ] = QuickCreateButton( guiMapInvenArrowButtonImage[ 1 ], (MAP_INV_X_OFFSET + 487), (SCREEN_HEIGHT - 144 - 2 * yResOffset),
									BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
									(GUI_CALLBACK)BtnGenericMouseMoveButtonCallback, (GUI_CALLBACK)MapInventoryPoolPrevBtn );

	// set up fast help text
	SetButtonFastHelpText( guiMapInvenArrowButton[ 0 ], pMapScreenInvenButtonHelpText[ 0 ] );
	SetButtonFastHelpText( guiMapInvenArrowButton[ 1 ], pMapScreenInvenButtonHelpText[ 1 ] );

	// HEADROCK HAM 5: Zoom Button
	// Currently available only at 800x600 resolution or higher. There is simply not enough space for more than 6
	// bigitem slots on 640x480.
	if (iResolution >= _800x600 )
	{
		guiMapInvenZoomButtonImage =  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 0, 0, -1, 1, -1 );
		guiMapInvenZoomButton = QuickCreateButton( guiMapInvenZoomButtonImage, INVEN_POOL_X+10 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolZoomBtn );

		SetButtonFastHelpText( guiMapInvenZoomButton, pMapScreenInvenButtonHelpText[ 3 ] );
		// Set to current selected state.
		if (fMapInventoryZoom)
		{
			ButtonList[ guiMapInvenZoomButton ]->uiFlags |= (BUTTON_CLICKED_ON);
		}
	}

	if (iResolution >= _800x600 )
	{
		// HEADROCK HAM 5: Stack and Merge button
		guiMapInvenSortButtonImage[ 0 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 16, 14, -1, 15, -1 );
		guiMapInvenSortButton[ 0 ] = QuickCreateButton( guiMapInvenSortButtonImage[ 0 ], INVEN_POOL_X+55 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolStackAndMergeBtn );

		SetButtonFastHelpText( guiMapInvenSortButton[ 0 ], pMapScreenInvenButtonHelpText[ 4 ] );

		// HEADROCK HAM 5: Sort Ammo Button
		guiMapInvenSortButtonImage[ 1 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 4, 2, -1, 3, -1 );
		guiMapInvenSortButton[ 1 ] = QuickCreateButton( guiMapInvenSortButtonImage[ 1 ], INVEN_POOL_X+85 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolSortAmmoBtn );

		SetButtonFastHelpText( guiMapInvenSortButton[ 1 ], pMapScreenInvenButtonHelpText[ 5 ] );

		// HEADROCK HAM 5: Sort Attachments Button
		guiMapInvenSortButtonImage[ 2 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 10, 8, -1, 9, -1 );
		guiMapInvenSortButton[ 2 ] = QuickCreateButton( guiMapInvenSortButtonImage[ 2 ], INVEN_POOL_X+115 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolSortAttachmentsBtn );

		SetButtonFastHelpText( guiMapInvenSortButton[ 2 ], pMapScreenInvenButtonHelpText[ 6 ] );

		// HEADROCK HAM 5: Sort Attachments Button
		guiMapInvenSortButtonImage[ 3 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 13, 11, -1, 12, -1 );
		guiMapInvenSortButton[ 3 ] = QuickCreateButton( guiMapInvenSortButtonImage[ 3 ], INVEN_POOL_X+145 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolEjectAmmoBtn );

		SetButtonFastHelpText( guiMapInvenSortButton[ 3 ], pMapScreenInvenButtonHelpText[ 7 ] );
	}

	// HEADROCK HAM 5: Filter Toggle Button
	if (iResolution >= _800x600 )
	{
		guiMapInvenFilterButtonImage[ 0 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 7, 5, -1, 6, -1 );
		guiMapInvenFilterButton[ 0 ] = QuickCreateButton( guiMapInvenFilterButtonImage[ 0 ], INVEN_POOL_X+190 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolFilterBtn );

		SetButtonFastHelpText( guiMapInvenFilterButton[ 0 ], pMapScreenInvenButtonHelpText[ 8 ] );
		ButtonList[ guiMapInvenFilterButton[ 0 ] ]->UserData[0] = 0;
		ButtonList[ guiMapInvenFilterButton[ 0 ] ]->UserData[1] = IC_MAPFILTER_ALL;
		ButtonList[ guiMapInvenFilterButton[ 0 ] ]->UserData[2] = 0;
		ButtonList[ guiMapInvenFilterButton[ 0 ] ]->UserData[3] = 0;

		guiMapInvenFilterButtonImage[ 1 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 20, 20, -1, 21, -1 );
		guiMapInvenFilterButton[ 1 ] = QuickCreateButton( guiMapInvenFilterButtonImage[ 1 ], INVEN_POOL_X+225 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolFilterBtn );

		SetButtonFastHelpText( guiMapInvenFilterButton[ 1 ], pMapScreenInvenButtonHelpText[ 9 ] );
		ButtonList[ guiMapInvenFilterButton[ 1 ] ]->UserData[0] = 1;
		ButtonList[ guiMapInvenFilterButton[ 1 ] ]->UserData[1] = IC_MAPFILTER_GUN;
		ButtonList[ guiMapInvenFilterButton[ 1 ] ]->UserData[2] = 0;
		ButtonList[ guiMapInvenFilterButton[ 1 ] ]->UserData[3] = IC_MAPFILTER_GUN;

		guiMapInvenFilterButtonImage[ 2 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 22, 22, -1, 23, -1 );
		guiMapInvenFilterButton[ 2 ] = QuickCreateButton( guiMapInvenFilterButtonImage[ 2 ], INVEN_POOL_X+225 + xResOffset, INVEN_POOL_Y+24,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolFilterBtn );

		SetButtonFastHelpText( guiMapInvenFilterButton[ 2 ], pMapScreenInvenButtonHelpText[ 10 ] );
		ButtonList[ guiMapInvenFilterButton[ 2 ] ]->UserData[0] = 1;
		ButtonList[ guiMapInvenFilterButton[ 2 ] ]->UserData[1] = IC_MAPFILTER_AMMO;
		ButtonList[ guiMapInvenFilterButton[ 2 ] ]->UserData[2] = 0;
		ButtonList[ guiMapInvenFilterButton[ 2 ] ]->UserData[3] = IC_MAPFILTER_AMMO;

		guiMapInvenFilterButtonImage[ 3 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 24, 24, -1, 25, -1 );
		guiMapInvenFilterButton[ 3 ] = QuickCreateButton( guiMapInvenFilterButtonImage[ 3 ], INVEN_POOL_X+255 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolFilterBtn );

		SetButtonFastHelpText( guiMapInvenFilterButton[ 3 ], pMapScreenInvenButtonHelpText[ 11 ] );
		ButtonList[ guiMapInvenFilterButton[ 3 ] ]->UserData[0] = 1;
		ButtonList[ guiMapInvenFilterButton[ 3 ] ]->UserData[1] = IC_MAPFILTER_EXPLOSV;
		ButtonList[ guiMapInvenFilterButton[ 3 ] ]->UserData[2] = 0;
		ButtonList[ guiMapInvenFilterButton[ 3 ] ]->UserData[3] = IC_MAPFILTER_EXPLOSV;

		guiMapInvenFilterButtonImage[ 4 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 26, 26, -1, 27, -1 );
		guiMapInvenFilterButton[ 4 ] = QuickCreateButton( guiMapInvenFilterButtonImage[ 4 ], INVEN_POOL_X+255 + xResOffset, INVEN_POOL_Y+24,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolFilterBtn );

		SetButtonFastHelpText( guiMapInvenFilterButton[ 4 ], pMapScreenInvenButtonHelpText[ 12 ] );
		ButtonList[ guiMapInvenFilterButton[ 4 ] ]->UserData[0] = 1;
		ButtonList[ guiMapInvenFilterButton[ 4 ] ]->UserData[1] = IC_MAPFILTER_MELEE;
		ButtonList[ guiMapInvenFilterButton[ 4 ] ]->UserData[2] = 0;
		ButtonList[ guiMapInvenFilterButton[ 4 ] ]->UserData[3] = IC_MAPFILTER_MELEE;

		guiMapInvenFilterButtonImage[ 5 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 28, 28, -1, 29, -1 );
		guiMapInvenFilterButton[ 5 ] = QuickCreateButton( guiMapInvenFilterButtonImage[ 5 ], INVEN_POOL_X+285 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolFilterBtn );

		SetButtonFastHelpText( guiMapInvenFilterButton[ 5 ], pMapScreenInvenButtonHelpText[ 13 ] );
		ButtonList[ guiMapInvenFilterButton[ 5 ] ]->UserData[0] = 1;
		ButtonList[ guiMapInvenFilterButton[ 5 ] ]->UserData[1] = IC_MAPFILTER_ARMOR;
		ButtonList[ guiMapInvenFilterButton[ 5 ] ]->UserData[2] = 0;
		ButtonList[ guiMapInvenFilterButton[ 5 ] ]->UserData[3] = IC_MAPFILTER_ARMOR;

		guiMapInvenFilterButtonImage[ 6 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 30, 30, -1, 31, -1 );
		guiMapInvenFilterButton[ 6 ] = QuickCreateButton( guiMapInvenFilterButtonImage[ 6 ], INVEN_POOL_X+285 + xResOffset, INVEN_POOL_Y+24,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolFilterBtn );

		SetButtonFastHelpText( guiMapInvenFilterButton[ 6 ], pMapScreenInvenButtonHelpText[ 14 ] );
		ButtonList[ guiMapInvenFilterButton[ 6 ] ]->UserData[0] = 1;
		ButtonList[ guiMapInvenFilterButton[ 6 ] ]->UserData[1] = IC_MAPFILTER_LBE;
		ButtonList[ guiMapInvenFilterButton[ 6 ] ]->UserData[2] = 0;
		ButtonList[ guiMapInvenFilterButton[ 6 ] ]->UserData[3] = IC_MAPFILTER_LBE;

		guiMapInvenFilterButtonImage[ 7 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 32, 32, -1, 33, -1 );
		guiMapInvenFilterButton[ 7 ] = QuickCreateButton( guiMapInvenFilterButtonImage[ 7 ], INVEN_POOL_X+315 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolFilterBtn );

		SetButtonFastHelpText( guiMapInvenFilterButton[ 7 ], pMapScreenInvenButtonHelpText[ 15 ] );
		ButtonList[ guiMapInvenFilterButton[ 7 ] ]->UserData[0] = 1;
		ButtonList[ guiMapInvenFilterButton[ 7 ] ]->UserData[1] = IC_MAPFILTER_KIT;
		ButtonList[ guiMapInvenFilterButton[ 7 ] ]->UserData[2] = 0;
		ButtonList[ guiMapInvenFilterButton[ 7 ] ]->UserData[3] = IC_MAPFILTER_KIT;

		guiMapInvenFilterButtonImage[ 8 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 34, 34, -1, 35, -1 );
		guiMapInvenFilterButton[ 8 ] = QuickCreateButton( guiMapInvenFilterButtonImage[ 8 ], INVEN_POOL_X+315 + xResOffset, INVEN_POOL_Y+24,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolFilterBtn );

		SetButtonFastHelpText( guiMapInvenFilterButton[ 8 ], pMapScreenInvenButtonHelpText[ 16 ] );
		ButtonList[ guiMapInvenFilterButton[ 8 ] ]->UserData[0] = 1;
		ButtonList[ guiMapInvenFilterButton[ 8 ] ]->UserData[1] = IC_MAPFILTER_MISC;
		ButtonList[ guiMapInvenFilterButton[ 8 ] ]->UserData[2] = 0;
		ButtonList[ guiMapInvenFilterButton[ 8 ] ]->UserData[3] = IC_MAPFILTER_MISC;

		/*
		guiMapInvenFilterButtonImage[ 9 ]=  LoadButtonImage( "INTERFACE\\sector_inventory_buttons.sti" , 19, 17, -1, 18, -1 );
		guiMapInvenFilterButton[ 9 ] = QuickCreateButton( guiMapInvenFilterButtonImage[ 9 ], INVEN_POOL_X+349 + xResOffset, INVEN_POOL_Y+10,
											BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
											NULL, (GUI_CALLBACK)MapInventoryPoolFilterBtn );

		SetButtonFastHelpText( guiMapInvenFilterButton[ 9 ], pMapScreenInvenButtonHelpText[ 17 ] );
		ButtonList[ guiMapInvenFilterButton[ 9 ] ]->UserData[0] = 0;
		ButtonList[ guiMapInvenFilterButton[ 9 ] ]->UserData[1] = 0;
		*/
	}

	//reset the current inventory page to be the first page
	iCurrentInventoryPoolPage = 0;

	HandleSetFilterButtons();

	return;
}


void DestroyMapInventoryButtons( void )
{
	// Page Arrow Buttons
	RemoveButton( guiMapInvenArrowButton[ 0 ] );
	RemoveButton( guiMapInvenArrowButton[ 1 ] );
	UnloadButtonImage( guiMapInvenArrowButtonImage[ 0 ] );
	UnloadButtonImage( guiMapInvenArrowButtonImage[ 1 ] );

	// HEADROCK HAM 5: Destroy Inventory Zoom Button
	if (iResolution >= _800x600 )
	{
		RemoveButton( guiMapInvenZoomButton );
		UnloadButtonImage( guiMapInvenZoomButtonImage );
	}

	// HEADROCK HAM 5: Auto-Sort buttons
	if (iResolution >= _800x600 )
	{
		RemoveButton( guiMapInvenSortButton[ 0 ] );
		UnloadButtonImage( guiMapInvenSortButtonImage[ 0 ] );
		RemoveButton( guiMapInvenSortButton[ 1 ] );
		UnloadButtonImage( guiMapInvenSortButtonImage[ 1 ] );
		RemoveButton( guiMapInvenSortButton[ 2 ] );
		UnloadButtonImage( guiMapInvenSortButtonImage[ 2 ] );
		RemoveButton( guiMapInvenSortButton[ 3 ] );
		UnloadButtonImage( guiMapInvenSortButtonImage[ 3 ] );
	}
	// HEADROCK HAM 5: Filter button
	if (iResolution >= _800x600 )
	{
		for (INT32 iCounter = 0; iCounter < 9; iCounter++)
		{
			RemoveButton( guiMapInvenFilterButton[ iCounter ] );
			UnloadButtonImage( guiMapInvenFilterButtonImage[ iCounter ] );
		}

		/*
		// Destroy the popup.
		delete(gMapInventoryFilterPopup);
		gMapInventoryFilterPopup = NULL;
		gfMapInventoryFilterPopupInitialized = FALSE;
		gfMapInventoryFilterPopupVisible = FALSE;
		*/
	}
	return;
}


void BuildStashForSelectedSector( INT16 sMapX, INT16 sMapY, INT16 sMapZ )
{
	INT32 iSize = 0;
	UINT32 uiItemCount = 0;
	UINT32 uiTotalNumberOfItems = 0, uiTotalNumberOfRealItems = 0;
	WORLDITEM * pTotalSectorList = NULL;
	INT32 iCounter = 0;
	UINT32	uiTotalNumberOfSeenItems=0;

//	#ifdef _DEBUG
		BOOLEAN fReturn = TRUE;
//	#endif

	// get size of the current stash in sector (count stacks as one item)
	iSize = GetSizeOfStashInSector( sMapX, sMapY, sMapZ, TRUE );

	// round off .. we want at least 1 free page of space...
	iSize = ((iSize / MAP_INVENTORY_POOL_SLOT_COUNT) + 1) * MAP_INVENTORY_POOL_SLOT_COUNT;

	// allocate space for list
	pInventoryPoolList.clear();
	pInventoryPoolList.resize( iSize );

	iLastInventoryPoolPage = ( ( iSize - 1 ) / MAP_INVENTORY_POOL_SLOT_COUNT );


	uiNumberOfUnSeenItems = 0;

	// now laod these items into memory, based on fact if sector is in fact loaded
	if( ( sMapX == gWorldSectorX )&&( gWorldSectorY == sMapY ) &&(gbWorldSectorZ == sMapZ ) )
	{
		// sector loaded, just copy from list
		for( iCounter = 0; ( UINT32 )( iCounter ) < guiNumWorldItems; iCounter++ )
		{
			// check if visible, if so, then copy over object type
			// if visible to player, then state fact

/*
			if( gWorldItems[ iCounter].bVisible == 1 &&
					gWorldItems[ iCounter ].fExists &&
					gWorldItems[ iCounter ].object.usItem != SWITCH &&
					gWorldItems[ iCounter ].object.bTrap <= 0 )
*/
			if( IsMapScreenWorldItemVisibleInMapInventory( &gWorldItems[ iCounter ] ) )
			{
				// one more item
				pInventoryPoolList[ uiItemCount ] = gWorldItems[ iCounter ];
				uiItemCount++;
			}
		}


		uiTotalNumberOfSeenItems = uiItemCount;


			// now allocate space for all the unseen items
		if( guiNumWorldItems > uiItemCount )
		{
			pUnSeenItems = new WORLDITEM[ guiNumWorldItems - uiItemCount ];

			uiItemCount = 0;

			// now copy over
			for( iCounter = 0; ( UINT32 )iCounter < guiNumWorldItems; iCounter++ )
			{
				if( IsMapScreenWorldItemInvisibleInMapInventory( &gWorldItems[ iCounter ] ) )
				{
					// one more item
					pUnSeenItems[ uiItemCount ] = gWorldItems[ iCounter ];

					uiItemCount++;
				}
			}

			// copy over number of unseen
			uiNumberOfUnSeenItems = uiItemCount;
		}
	}
	else
	{
		// not loaded, load
		// get total number, visable and invisible
		fReturn = GetNumberOfWorldItemsFromTempItemFile( sMapX, sMapY, ( INT8 )( sMapZ ), &( uiTotalNumberOfItems ), FALSE );
		Assert( fReturn );

		fReturn = GetNumberOfActiveWorldItemsFromTempFile( sMapX, sMapY, ( INT8 )( sMapZ ), &( uiTotalNumberOfRealItems ) );
		Assert( fReturn );

		if( uiTotalNumberOfRealItems > 0 )
		{
			// allocate space for the list
			pTotalSectorList = new WORLDITEM[ uiTotalNumberOfItems ];


			// now load into mem
			LoadWorldItemsFromTempItemFile(  sMapX,  sMapY, ( INT8 ) ( sMapZ ), pTotalSectorList );

		}


		// now run through list and
		for( iCounter = 0; ( UINT32 )( iCounter )< uiTotalNumberOfRealItems; iCounter++ )
		{
			// if visible to player, then state fact
/*
			if( pTotalSectorList[ iCounter].bVisible == 1 &&
					pTotalSectorList[ iCounter].fExists &&
					pTotalSectorList[ iCounter].object.usItem != SWITCH &&
					pTotalSectorList[ iCounter].object.bTrap <= 0 )
*/


			//TEST!!  If the item exists, and is NOT VALID, report it
			if( pTotalSectorList[ iCounter].fExists &&  pTotalSectorList[ iCounter].object.usItem > MAXITEMS )
			{
				ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_BETAVERSION, L"The %d item in the list is NOT valid. Please send save.  DF 1.", iCounter );
			}


			if( IsMapScreenWorldItemVisibleInMapInventory( &pTotalSectorList[ iCounter] ) )
			{
				// one more item
				pInventoryPoolList[ uiItemCount ] = pTotalSectorList[ iCounter ];

				uiItemCount++;
			}
		}

		uiTotalNumberOfSeenItems = uiItemCount;

		// now allocate space for all the unseen items
		if( uiTotalNumberOfRealItems > uiItemCount )
		{
			pUnSeenItems = new WORLDITEM[ uiTotalNumberOfRealItems - uiItemCount ];

			uiItemCount = 0;

			// now copy over
			for( iCounter = 0; ( UINT32 )iCounter < uiTotalNumberOfItems; iCounter++ )
			{
				if( IsMapScreenWorldItemInvisibleInMapInventory( &pTotalSectorList[ iCounter] ) )
				{
					// one more item
					pUnSeenItems[ uiItemCount ] = pTotalSectorList[ iCounter ];

					uiItemCount++;
				}
			}

			// copy over number of unseen
			uiNumberOfUnSeenItems = uiItemCount;
		}

		// if anything was alloced, then get rid of it
		if( uiTotalNumberOfRealItems > 0 )
		{
				delete[]( pTotalSectorList );
		}
	}

	//Check to see if any of the items in the list have a gridno of NOWHERE and the entry point flag NOT set
	CheckGridNoOfItemsInMapScreenMapInventory();

	//Sort the sector invenrtory
	SortSectorInventory( pInventoryPoolList, uiTotalNumberOfSeenItems );
}

void ReBuildWorldItemStashForLoadedSector( INT32 iNumberSeenItems, INT32 iNumberUnSeenItems, WORLDITEM *pSeenItemsList, WORLDITEM *pUnSeenItemsList )
{
	INT32 iTotalNumberOfItems = 0;
	INT32 iCurrentItem = 0;
	INT32 iCounter = 0;
	INT32 iRemainder = 0;
	UINT32	uiTotalNumberOfVisibleItems=0;
	WORLDITEM * pTotalList = NULL;

	// clear out the list
	TrashWorldItems( );

	// get total number of items
	iTotalNumberOfItems = iNumberUnSeenItems + iNumberSeenItems;

	iRemainder = iTotalNumberOfItems % 10;

	// if there is a remainder, then add onto end of list
	if( iRemainder )
	{
		iTotalNumberOfItems += 10 - iRemainder;
	}

	// allocate space for items
	pTotalList = new WORLDITEM[ iTotalNumberOfItems ];

	// place seen items in the world
	for( iCounter = 0; iCounter < iNumberSeenItems; iCounter++ )
	{
		pTotalList[ iCurrentItem ] = pSeenItemsList[ iCounter ];
		iCurrentItem++;
	}

	// now store the unseen item list
	for( iCounter = 0; iCounter < iNumberUnSeenItems; iCounter++ )
	{
		pTotalList[ iCurrentItem ] = pUnSeenItemsList[ iCounter ];
		iCurrentItem++;
	}

	RefreshItemPools( pTotalList, iTotalNumberOfItems );

	//Count the total number of visible items
	for( iCounter = 0; iCounter < iNumberSeenItems; iCounter++ )
	{
		uiTotalNumberOfVisibleItems += pSeenItemsList[ iCounter ].object.ubNumberOfObjects;
	}

	//reset the visible item count in the sector info struct
	SetNumberOfVisibleWorldItemsInSectorStructureForSector( gWorldSectorX, gWorldSectorY, gbWorldSectorZ , uiTotalNumberOfVisibleItems );

	// clear out allocated space for total list
	delete[]( pTotalList );

	// reset total list
	pTotalList = NULL;

	return;
}

void DestroyStash( void )
{
	// clear out stash
	pInventoryPoolList.clear();

}

INT32 GetSizeOfStashInSector( INT16 sMapX, INT16 sMapY, INT16 sMapZ, BOOLEAN fCountStacksAsOne )
{
	// get # of items in sector that are visible to the player
	UINT32 uiTotalNumberOfItems = 0, uiTotalNumberOfRealItems = 0;
	WORLDITEM * pTotalSectorList = NULL;
	UINT32 uiItemCount = 0;
	INT32 iCounter = 0;
	BOOLEAN fReturn = TRUE;

	if( ( sMapX == gWorldSectorX ) && ( sMapY == gWorldSectorY) && ( sMapZ == gbWorldSectorZ ) )
	{
		uiTotalNumberOfItems = guiNumWorldItems;

		// now run through list and
		for( iCounter = 0; ( UINT32 )( iCounter )< uiTotalNumberOfItems; iCounter++ )
		{
			// if visible to player, then state fact
//			if( gWorldItems[ iCounter ].bVisible == 1 && gWorldItems[ iCounter ].fExists )
			if( IsMapScreenWorldItemVisibleInMapInventory( &gWorldItems[ iCounter ] ) )
			{
				// add it
				if ( fCountStacksAsOne )
				{
					uiItemCount++;
				}
				else
				{
					uiItemCount += gWorldItems[ iCounter ].object.ubNumberOfObjects;
				}
			}
		}
	}
	else
	{
		// get total number, visable and invisible
		fReturn = GetNumberOfActiveWorldItemsFromTempFile( sMapX, sMapY, ( INT8 )( sMapZ ), &( uiTotalNumberOfRealItems ) );
		Assert( fReturn );

		fReturn = GetNumberOfWorldItemsFromTempItemFile( sMapX, sMapY, ( INT8 )( sMapZ ), &( uiTotalNumberOfItems ), FALSE );
		Assert( fReturn );

		if( uiTotalNumberOfItems > 0 )
		{
			// allocate space for the list
			pTotalSectorList = new WORLDITEM[ uiTotalNumberOfItems ];

				// now load into mem
			LoadWorldItemsFromTempItemFile(  sMapX,  sMapY, ( INT8 ) ( sMapZ ), pTotalSectorList );
		}

		// now run through list and
		for( iCounter = 0; ( UINT32 )( iCounter )< uiTotalNumberOfRealItems; iCounter++ )
		{
			// if visible to player, then state fact
//			if( pTotalSectorList[ iCounter ].bVisible == 1 && pTotalSectorList[ iCounter ].fExists )
			if( IsMapScreenWorldItemVisibleInMapInventory( &pTotalSectorList[ iCounter ] ) )
			{
				// add it
				if ( fCountStacksAsOne )
				{
					uiItemCount++;
				}
				else
				{
					uiItemCount += pTotalSectorList[ iCounter ].object.ubNumberOfObjects;
				}
			}
		}

		// if anything was alloced, then get rid of it
		if( pTotalSectorList != NULL )
		{
			delete[]( pTotalSectorList );
			pTotalSectorList = NULL;

			#ifdef JA2BETAVERSION
			if( uiTotalNumberOfItems == 0 )
			{
				ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_BETAVERSION, L"pTotalSectorList is NOT NULL when uiTotalNumberOfRealItems is %d.", uiTotalNumberOfRealItems );
			}
			#endif
		}
	}


	return( uiItemCount );
}



void BeginInventoryPoolPtr( OBJECTTYPE *pInventorySlot )
{
	BOOLEAN fOk = FALSE;
	BOOLEAN fSELLALL = gGameExternalOptions.fSellAll;

	// If not null return
	if ( gpItemPointer != NULL )
	{
		return;
	}

	// if shift key get all

	if (_KeyDown( SHIFT ))
	{
		// Remove all from soldier's slot
		fOk = (0 == pInventorySlot->MoveThisObjectTo(gItemPointer,-1,0,NUM_INV_SLOTS,MAX_OBJECTS_PER_SLOT));
	}
	else
	{
		fOk = (0 == pInventorySlot->MoveThisObjectTo(gItemPointer, 1));
	}

	if (fOk)
	{
		if (pInventorySlot->exists() == false) {
			pInventorySlot->initialize();
		}
		// Dirty interface
		fMapPanelDirty = TRUE;
		gpItemPointer = &gItemPointer;

		if ( _KeyDown ( CTRL ))//MM: Pass item to selected merc.  Delete if none selected.
		{
			SOLDIERTYPE *pSoldier = &Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ];
			bool placedObject = false;

			if(pSoldier->exists() == true)
			{
				if(pSoldier->flags.uiStatusFlags & SOLDIER_VEHICLE)
				{
					for(int x = 0; x<NUM_INV_SLOTS-1; x++)
					{
						if(vehicleInv[x] == FALSE)
							continue;

						if(pSoldier->inv[x].exists() == true)
						{
							if(pSoldier->inv[x].usItem == gpItemPointer->usItem)
							{
								pSoldier->inv[x].AddObjectsToStack(*gpItemPointer, gpItemPointer->ubNumberOfObjects, pSoldier, x);
								placedObject = true;
								break;
							}
						}
						else
						{
							gpItemPointer->MoveThisObjectTo(pSoldier->inv[x], gpItemPointer->ubNumberOfObjects, pSoldier, x);
							placedObject = true;
							break;
						}
					}
				}
				else
				{
					if (AutoPlaceObject(pSoldier,gpItemPointer,FALSE)) //doesn't work for vehicles :p
						placedObject = true;
				}

				if (placedObject)
				{
					fShowInventoryFlag = true;
					fTeamPanelDirty = TRUE;
					fInterfacePanelDirty = DIRTYLEVEL2;
					fMapInventoryItem = FALSE;
					gpItemPointer = NULL;
				}
				else // can't seem to get the code to just leave the item alone after it's been clicked on, so just pick it up...
				{
					gpItemPointerSoldier = NULL;

					// now set the cursor
					guiExternVo = GetInterfaceGraphicForItem( &(Item[ gpItemPointer->usItem ]) );
					gusExternVoSubIndex = g_bUsePngItemImages ? 0 : Item[ gpItemPointer->usItem ].ubGraphicNum;

					fMapInventoryItem = TRUE;
					MSYS_ChangeRegionCursor( &gMPanelRegion , EXTERN_CURSOR );
					SetCurrentCursorFromDatabase( EXTERN_CURSOR );

					if ( fShowInventoryFlag && bSelectedInfoChar >= 0 )
					{
						ReevaluateItemHatches( MercPtrs[ gCharactersList[ bSelectedInfoChar ].usSolID ], FALSE );
						fTeamPanelDirty = TRUE;
					}
				}
			}
			else
			{
				gpItemPointer = NULL;
				fMapInventoryItem = FALSE;

				if ( _KeyDown ( 89 )) //Lalien: delete all items of this type on Ctrl+Y
				{
					DeleteItemsOfType( gItemPointer.usItem );
					ScreenMsg( FONT_MCOLOR_LTRED, MSG_INTERFACE, New113Message[MSG113_DELETE_ALL] );
				}
				else {
					ScreenMsg( FONT_MCOLOR_LTRED, MSG_INTERFACE, New113Message[MSG113_DELETED] );
				}
			}
			if ( fShowMapInventoryPool )
				HandleButtonStatesWhileMapInventoryActive();
		}
		else if ( _KeyDown ( ALT ) && fSELLALL)//Sell Item
		{
			// HEADROCK HAM 5: Added argument
			INT32 iPrice = SellItem( gItemPointer, TRUE );
		    PlayJA2Sample( COMPUTER_BEEP2_IN, RATE_11025, 15, 1, MIDDLEPAN );
			gpItemPointer = NULL;
			fMapInventoryItem = FALSE;
			if ( _KeyDown ( 89 )) //Lalien: sell all items of this type on Alt+Y
			{
				for( UINT32 iNumber = 0 ; iNumber <  pInventoryPoolList.size() ; ++iNumber)
				{
					// WANNE: Fix by Headrock
					//if ( pInventoryPoolList[ iNumber ].object.usItem == gItemPointer.usItem )
					if ( pInventoryPoolList[ iNumber ].object.usItem == gItemPointer.usItem && pInventoryPoolList[ iNumber ].usFlags & WORLD_ITEM_REACHABLE)
					{
						// HEADROCK HAM 5: Added argument
						iPrice += SellItem( pInventoryPoolList[ iNumber ].object, TRUE );
						DeleteObj( &pInventoryPoolList [ iNumber ].object );
					}
				}
			}
			//ADB you can sell items for 0, but that's not fair
			//and it's not easy to stop the sale so make the price 1
			// HEADROCK HAM 5: Fair Schmair. They can now see that the sale value is $0 anyway, it's up to them.
			//if (iPrice == 0) {
			//	iPrice = 1;
			//}

			if ( _KeyDown ( 89 )) //Lalien: sell all items of this type on Alt+Y
			{
				ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, New113Message[MSG113_SOLD_ALL] );
			}
			else {
				ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, New113Message[MSG113_SOLD] );
			}

			// HEADROCK HAM 5: No transaction if no money.
			if (iPrice > 0)
			{
				AddTransactionToPlayersBook( SOLD_ITEMS, 0, GetWorldTotalMin(), iPrice );
			}

			if ( fShowMapInventoryPool )
				HandleButtonStatesWhileMapInventoryActive();
		}
		else
		{
			gpItemPointerSoldier = NULL;

			// now set the cursor
			guiExternVo = GetInterfaceGraphicForItem( &(Item[ gpItemPointer->usItem ]) );
			gusExternVoSubIndex = g_bUsePngItemImages ? 0 : Item[ gpItemPointer->usItem ].ubGraphicNum;

			fMapInventoryItem = TRUE;
			MSYS_ChangeRegionCursor( &gMPanelRegion , EXTERN_CURSOR );
			SetCurrentCursorFromDatabase( EXTERN_CURSOR );

			if ( fShowInventoryFlag && bSelectedInfoChar >= 0 )
			{
				ReevaluateItemHatches( MercPtrs[ gCharactersList[ bSelectedInfoChar ].usSolID ], FALSE );
				fTeamPanelDirty = TRUE;
			}
		}
	}
}

BOOLEAN PlaceObjectInInventoryStash( OBJECTTYPE *pInventorySlot, OBJECTTYPE *pItemPtr )
{
	// if there is something there, swap it, if they are of the same type and stackable then add to the count
	if (pInventorySlot->exists() == false)
	{
		// placement in an empty slot
		pItemPtr->MoveThisObjectTo(*pInventorySlot);
	}
	else
	{
		if (pItemPtr->usItem == pInventorySlot->usItem && ItemSlotLimit(pItemPtr, STACK_SIZE_LIMIT) >= 2)
		{
			// stacking
			pInventorySlot->AddObjectsToStack(*pItemPtr);
		}
		else
		{
			SwapObjs( pItemPtr, pInventorySlot );
		}
	}
	return( TRUE );
}


BOOLEAN AutoPlaceObjectInInventoryStash( OBJECTTYPE *pItemPtr, INT32 sGridNo )
{
	OBJECTTYPE *pInventorySlot;
	INT32		cnt = 0;

	//CHRISL: I'm not sure why this never fails.  Maybe it just isn't used often.  But if we try and look for index
	//	pInventoryPoolList.size() we're going to crash since "size()" returns the total number of indecies in human terms (1-xxx)
	//	but we have to start with 0.  In other words, size() might return a value of 10 but those are numbers 0-9.

	while(1)
	{
		//if we run out of indecies before running out of items to place, make new indecies
		if(cnt == pInventoryPoolList.size())
		{
			ResizeInventoryList();
		}
		pInventorySlot = &pInventoryPoolList[cnt].object;
		if(pInventorySlot->usItem == pItemPtr->usItem)
		{
			pInventorySlot->AddObjectsToStack(*pItemPtr);
		}
		else if(pInventorySlot->exists() == false)
		{
			pItemPtr->MoveThisObjectTo(*pInventorySlot);
			if(sGridNo != 0)
			{
				pInventoryPoolList[cnt].sGridNo = sGridNo;
				pInventoryPoolList[cnt].usFlags = 512;
				pInventoryPoolList[cnt].bVisible = 1;
				pInventoryPoolList[cnt].fExists = TRUE;
			}
		}
		else
		{
			cnt++;
			continue;
		}
		if(pItemPtr->exists() == false)
		{
			break;
		}
		else
		{
			cnt++;
		}
	}


	// if there is something there, swap it, if they are of the same type and stackable then add to the count
//	pInventorySlot =  &( pInventoryPoolList[ pInventoryPoolList.size() ].object );

	// placement in an empty slot
	// could be wrong type of object for slot... need to check...
	// but assuming it isn't
//	pItemPtr->MoveThisObjectTo(*pInventorySlot);

	return( TRUE );
}

void MapInventoryPoolNextBtn( GUI_BUTTON *btn, INT32 reason )
{
		if(reason & MSYS_CALLBACK_REASON_LBUTTON_DWN )
	{
	  btn->uiFlags|=(BUTTON_CLICKED_ON);
	}
	else if(reason & MSYS_CALLBACK_REASON_LBUTTON_UP )
  {
    if (btn->uiFlags & BUTTON_CLICKED_ON)
		{
      btn->uiFlags&=~(BUTTON_CLICKED_ON);

			// if can go to next page, go there
			if( iCurrentInventoryPoolPage < ( iLastInventoryPoolPage ) )
			{
				iCurrentInventoryPoolPage++;
				fMapPanelDirty = TRUE;
			}
		}
	}
}

void MapInventoryPoolPrevBtn( GUI_BUTTON *btn, INT32 reason )
{
		if(reason & MSYS_CALLBACK_REASON_LBUTTON_DWN )
	{
	  btn->uiFlags|=(BUTTON_CLICKED_ON);
	}
	else if(reason & MSYS_CALLBACK_REASON_LBUTTON_UP )
  {
    if (btn->uiFlags & BUTTON_CLICKED_ON)
		{
      btn->uiFlags&=~(BUTTON_CLICKED_ON);

			// if can go to next page, go there
			if( iCurrentInventoryPoolPage > 0 )
			{
				iCurrentInventoryPoolPage--;
				fMapPanelDirty = TRUE;
			}
		}
	}
}


void MapInventoryPoolDoneBtn( GUI_BUTTON *btn, INT32 reason )
{
	if(reason & MSYS_CALLBACK_REASON_LBUTTON_DWN )
	{
		btn->uiFlags|=(BUTTON_CLICKED_ON);
	}
	else if(reason & MSYS_CALLBACK_REASON_LBUTTON_UP )
	{
		if (btn->uiFlags & BUTTON_CLICKED_ON)
		{
			btn->uiFlags&=~(BUTTON_CLICKED_ON);

			if (gfInItemDescBox)
			{
				DoMapMessageBox( MSG_BOX_BASIC_STYLE, gzLateLocalizedString[64], MAP_SCREEN, MSG_BOX_FLAG_OK, NULL );
			}
			else
			{
				// done
				fShowMapInventoryPool = FALSE;
			}
		}
	}
}

// HEADROCK HAM 5: Sort ammo button callback
void MapInventoryPoolSortAmmoBtn( GUI_BUTTON *btn, INT32 reason )
{
	if (reason & MSYS_CALLBACK_REASON_LBUTTON_DWN || reason & MSYS_CALLBACK_REASON_RBUTTON_DWN)
	{
		if (!(btn->uiFlags & (BUTTON_CLICKED_ON)))
		{
			btn->uiFlags |= (BUTTON_CLICKED_ON);
		}
	}
	if (reason & MSYS_CALLBACK_REASON_LBUTTON_UP)
	{
		if (btn->uiFlags & (BUTTON_CLICKED_ON))
		{
			SortSectorInventoryAmmo(false);
			btn->uiFlags &=~ (BUTTON_CLICKED_ON);
		}
	}
	if (reason & MSYS_CALLBACK_REASON_RBUTTON_UP)
	{
		if (btn->uiFlags & (BUTTON_CLICKED_ON))
		{
			SortSectorInventoryAmmo(true);
			btn->uiFlags &=~ (BUTTON_CLICKED_ON);
		}
	}
}

// HEADROCK HAM 5: Stack and merge button callback
void MapInventoryPoolStackAndMergeBtn( GUI_BUTTON *btn, INT32 reason )
{
	if (reason & MSYS_CALLBACK_REASON_LBUTTON_DWN)
	{
		if (!(btn->uiFlags & (BUTTON_CLICKED_ON)))
		{
			btn->uiFlags |= (BUTTON_CLICKED_ON);
		}
	}
	if (reason & MSYS_CALLBACK_REASON_LBUTTON_UP)
	{
		if (btn->uiFlags & (BUTTON_CLICKED_ON))
		{
			SortSectorInventoryStackAndMerge(false);
			btn->uiFlags &=~ (BUTTON_CLICKED_ON);
		}
	}
}

// HEADROCK HAM 5: Sort attachments button callback
void MapInventoryPoolSortAttachmentsBtn( GUI_BUTTON *btn, INT32 reason )
{
	if (reason & MSYS_CALLBACK_REASON_LBUTTON_DWN)
	{
		if (!(btn->uiFlags & (BUTTON_CLICKED_ON)))
		{
			btn->uiFlags |= (BUTTON_CLICKED_ON);
		}
	}
	if (reason & MSYS_CALLBACK_REASON_LBUTTON_UP)
	{
		if (btn->uiFlags & (BUTTON_CLICKED_ON))
		{
			SortSectorInventorySeparateAttachments();
			btn->uiFlags &=~ (BUTTON_CLICKED_ON);
		}
	}
}

// HEADROCK HAM 5: Eject Ammo button callback
void MapInventoryPoolEjectAmmoBtn( GUI_BUTTON *btn, INT32 reason )
{
	if (reason & MSYS_CALLBACK_REASON_LBUTTON_DWN)
	{
		if (!(btn->uiFlags & (BUTTON_CLICKED_ON)))
		{
			btn->uiFlags |= (BUTTON_CLICKED_ON);
		}
	}
	if (reason & MSYS_CALLBACK_REASON_LBUTTON_UP)
	{
		if (btn->uiFlags & (BUTTON_CLICKED_ON))
		{
			SortSectorInventoryEjectAmmo();
			btn->uiFlags &=~ (BUTTON_CLICKED_ON);
		}
	}
}

// HEADROCK HAM 5: Preliminary Filter Button
void MapInventoryPoolFilterBtn( GUI_BUTTON *btn, INT32 reason )
{
	if (reason & MSYS_CALLBACK_REASON_LBUTTON_DWN ||
		reason & MSYS_CALLBACK_REASON_RBUTTON_DWN )
	{
		if (!(btn->uiFlags & (BUTTON_CLICKED_ON)))
		{
			// Set as "clicked on", but do nothing until the mouse is released.
			btn->uiFlags |= (BUTTON_CLICKED_ON);
		}
	}
	if (reason & MSYS_CALLBACK_REASON_LBUTTON_UP)
	{
		if (btn->uiFlags & (BUTTON_CLICKED_ON))
		{
			if (btn->UserData[0] == 0)
			{
				MapInventoryFilterSet( btn->UserData[1] );
			}
			else
			{
				MapInventoryFilterToggle( btn->UserData[1] );
			}

			// HEADROCK HAM 5: Disabled for now, as we've got buttons for this.
			//CreateMapInventoryFilterMenu( );
		}
	}
	if (reason & MSYS_CALLBACK_REASON_RBUTTON_UP)
	{
		if (btn->uiFlags & (BUTTON_CLICKED_ON))
		{
			if (btn->UserData[2] == 0)
			{
				MapInventoryFilterSet( btn->UserData[3] );
			}
			else
			{
				MapInventoryFilterToggle( btn->UserData[3] );
			}

			// HEADROCK HAM 5: Disabled for now, as we've got buttons for this.
			//CreateMapInventoryFilterMenu( );
		}
	}
}

// HEADROCK HAM 5: Zoom button.
// This button handles toggling between the small-scale inventory (items shown at normal size, similar to merc's inventory)
// and the big-item inventory (which shows BigItem pics and is therefore much easier to examine in detail).
// A click on the button initiates "zoom input" mode, allowing the player to decide which part of the small-scale
// inventory he would like to examine more closely. While in this mode, you may flip inventory pages or close the inventory
// altogether, but may not move the mouse outside the map inventory region. Right-click will cancel this mode 
// automatically.
void MapInventoryPoolZoomBtn( GUI_BUTTON *btn, INT32 reason )
{
	// Only left-click interacts with this button.
	if(reason & MSYS_CALLBACK_REASON_LBUTTON_UP )
	{
		// Is the button already pressed?
		if (btn->uiFlags & BUTTON_CLICKED_ON)
		{
			// Are we still waiting for zoom input? If so, the button is depressed, but we are still not
			// in zoomed mode.
			if (fWaitingForZoomInput)
			{
				// Turn off Zoom Input mode.
				CancelInventoryZoomInput(TRUE);
			}
			// If zoomed, unzoom.
			if (fMapInventoryZoom)
			{
				// What is the number of the first item on the current inventory page?
				UINT16 usFirstItem = iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT;
				UINT16 usNumSlotsOnUnzoomedPage = GetInventorySlotCount( FALSE );
				UINT16 usNewPage = (UINT16)(usFirstItem / usNumSlotsOnUnzoomedPage);
				HandleMapInventoryUnzoom( usNewPage );
			}
			
			// Turn the button off so it can be clicked again.
			btn->uiFlags &=~(BUTTON_CLICKED_ON);
		}
		else
		{
			// This will initiate Zoom Input mode.
			if (!fWaitingForZoomInput)
			{
				// Turn the button on do indicate that it has been pressed.
				btn->uiFlags |= (BUTTON_CLICKED_ON);

				// Calculate the number of inventory rows and columns we have on-screen currently.
				INT16 sRows = ( MAP_INVENTORY_POOL_SLOT_COUNT / MAP_INV_SLOT_COLS );
				INT16 sCols = ( MAP_INV_SLOT_COLS );

				// Calculate the size of the inventory portion. Unfortunately there are still no constants
				// for this.
				MapInventoryRect.iLeft = MAP_INVENTORY_POOL_SLOT_START_X+4;
				MapInventoryRect.iRight = MAP_INVENTORY_POOL_SLOT_START_X + (sRows * MAP_INVEN_SPACE_BTWN_SLOTS);
				MapInventoryRect.iTop = 5;
				MapInventoryRect.iBottom = MAP_INVENTORY_POOL_SLOT_START_Y + (sCols * MAP_INVEN_SLOT_HEIGHT) + 54;
				// Restrict mouse movement to this area only. This will avoid interacting with unexpected portions of
				// the screen, allowing us to better control confirming or exiting Zoom Input mode.
				RestrictMouseCursor( &MapInventoryRect );

				// Notify to the rest of the program that we are inside zoom input mode. In particular, inventory
				// slots will behave differently when clicked or right-clicked while this flag is set.
				fWaitingForZoomInput = 1;
			}
			else
			{
				// Zoom Input mode was active, which isn't supposed to happen because the button was off. Still, make
				// sure the zoom input is canceled so we can go on without errors.
				CancelInventoryZoomInput( TRUE );
			}
		}
	}
}

void DisplayPagesForMapInventoryPool( void )
{
	// get the current and last pages and display them
	CHAR16 sString[ 32 ];
	INT16 sX, sY;

	SetFont( COMPFONT );
	SetFontForeground( 183 );
	SetFontBackground( FONT_BLACK );

	// set the buffer
	SetFontDestBuffer( guiSAVEBUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );

	// grab current and last pages
	swprintf( sString, L"%d / %d", iCurrentInventoryPoolPage + 1, iLastInventoryPoolPage + 1 );

	// grab centered coords
	FindFontCenterCoordinates(MAP_INVENTORY_POOL_PAGE_X, MAP_INVENTORY_POOL_PAGE_Y - 2 * yResOffset, MAP_INVENTORY_POOL_PAGE_WIDTH ,MAP_INVENTORY_POOL_PAGE_HEIGHT ,sString , MAP_SCREEN_FONT, &sX, &sY);

	mprintf( sX, sY, sString );

	SetFontDestBuffer( FRAME_BUFFER, 0,0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );
}

INT32 GetTotalNumberOfItemsInSectorStash( void )
{
	INT32 iCount = 0;

	// run through list of items and find out how many are there
	for( UINT32 iCounter = 0; iCounter < pInventoryPoolList.size(); iCounter++ )
	{
		if( pInventoryPoolList[ iCounter].object.exists() == true )
		{
			iCount += pInventoryPoolList[ iCounter].object.ubNumberOfObjects;
		}
	}

	return iCount;
}


INT32 GetTotalNumberOfItems( void )
{
	INT32 iCount = 0;

	// run through list of items and find out how many are there
	for(UINT32 iCounter = 0; iCounter < pInventoryPoolList.size(); iCounter++ )
	{
		if( pInventoryPoolList[ iCounter].object.exists() == true )
		{
			iCount++;
		}
	}

	return iCount;
}


void DrawNumberOfIventoryPoolItems( void )
{
	INT32 iNumberOfItems = 0;
	CHAR16 sString[ 32 ];
	INT16 sX, sY;


	iNumberOfItems = GetTotalNumberOfItemsInSectorStash( );

	// get number of items
	swprintf( sString, L"%d", iNumberOfItems );

	// set font stuff
	SetFont( COMPFONT );
	SetFontForeground( 183 );
	SetFontBackground( FONT_BLACK );

	// set the buffer
	SetFontDestBuffer( guiSAVEBUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );

	// grab centered coords
	FindFontCenterCoordinates(MAP_INVENTORY_POOL_NUMBER_X, MAP_INVENTORY_POOL_PAGE_Y - 2 * yResOffset, MAP_INVENTORY_POOL_NUMBER_WIDTH ,MAP_INVENTORY_POOL_PAGE_HEIGHT ,sString , MAP_SCREEN_FONT, &sX, &sY);

	mprintf( sX, sY, sString );

	SetFontDestBuffer( FRAME_BUFFER, 0,0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );

	return;
}


void CreateMapInventoryPoolDoneButton( void )
{
	// create done button
	guiMapInvenDoneButtonImage=  LoadButtonImage( "INTERFACE\\done_button.sti" , -1, 0, -1, 1, -1 );
	guiMapInvenDoneButton = QuickCreateButton( guiMapInvenDoneButtonImage, MAP_INV_X_OFFSET + 587 , (yResSize - 147),
								BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
								(GUI_CALLBACK)BtnGenericMouseMoveButtonCallback, (GUI_CALLBACK)MapInventoryPoolDoneBtn );

	// set up fast help text
	SetButtonFastHelpText( guiMapInvenDoneButton, pMapScreenInvenButtonHelpText[ 2 ] );

	return;
}

void DestroyInventoryPoolDoneButton( void )
{
	// destroy ddone button

	RemoveButton( guiMapInvenDoneButton );
	UnloadButtonImage( guiMapInvenDoneButtonImage );


	return;
}


void DisplayCurrentSector( void )
{
	// grab current sector being displayed
	CHAR16 sString[ 32 ];
	INT16 sX, sY;

	swprintf( sString, L"%s%s%s", pMapVertIndex[ sSelMapY ], pMapHortIndex[ sSelMapX ], pMapDepthIndex[ iCurrentMapSectorZ ] );

	// set font stuff
	SetFont( COMPFONT );
	SetFontForeground( 183 );
	SetFontBackground( FONT_BLACK );

	// set the buffer
	SetFontDestBuffer( guiSAVEBUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );

	// grab centered coords
	FindFontCenterCoordinates(MAP_INVENTORY_POOL_LOC_X, MAP_INVENTORY_POOL_PAGE_Y - 2 * yResOffset, MAP_INVENTORY_POOL_LOC_WIDTH ,MAP_INVENTORY_POOL_PAGE_HEIGHT ,sString , MAP_SCREEN_FONT, &sX, &sY);

	mprintf( sX, sY, sString );

	SetFontDestBuffer( FRAME_BUFFER, 0,0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );
}

// HEADROCK HAM 5: Following some issues with the resizing of the map inventory - especially due to switching
// between zoomed and unzoomed move, but possibly some pre-existing issues as well. Also, this function is now
// significantly more readable.
void ResizeInventoryList( void )
{
	// If we've got no items in this sector...
	if (pInventoryPoolList.empty() == true ) 
	{
		// Resize the list to at least one page in size, containing no items.
		giDesiredNumMapInventorySlots = __max(giDesiredNumMapInventorySlots, MAP_INVENTORY_POOL_SLOT_COUNT);
		pInventoryPoolList.resize(giDesiredNumMapInventorySlots);
		iLastInventoryPoolPage = (giDesiredNumMapInventorySlots / MAP_INVENTORY_POOL_SLOT_COUNT) - 1;

		// Done!
		return;
	}

	// NEVER create an inventory that's SMALLER than the one we're looking at.
	giDesiredNumMapInventorySlots = __max(giDesiredNumMapInventorySlots, ((iCurrentInventoryPoolPage+1) * MAP_INVENTORY_POOL_SLOT_COUNT));

	// Lets see how many item slots we're going to need
	int activeSlotsOnPage = 0;
	int activeSlotsTotal = 0;
	INT32 x = 1;
	INT32 ListSize = pInventoryPoolList.size(); // Current size, so we can run through it all.
	UINT32 iNumEmptySlots = 0;
	UINT32 iNumEmptySlotsAtEnd = 0;
	// Run through the entire sector inventory, collecting data.
	for (x = 0; x < ListSize; x++) 
	{
		//don't test fExists because that hasn't been set yet, test object.exists
		if (pInventoryPoolList[x].object.exists() == true) 
		{
			// Item exists. Increase the count of valid items.
			activeSlotsTotal++;
			// Since the last item we (just now) checked exists, lets reset the count of how many 
			// slots are empty at the end of the inventory array.
			iNumEmptySlotsAtEnd = 0;
			
			// Now count the number of items found since the end of the "previous" page.
			// We constantly assume that we're looking at the end of the last page. If we find more
			// items beyond this, that means there's yet another page to check, and so on until
			// we actually reach the end of the array.
			if (x % MAP_INVENTORY_POOL_SLOT_COUNT == 0 )
			{
				// Reset the counter, this is the first item on a new page.
				activeSlotsOnPage = 1;
			}
			else
			{
				// Increase the counter, building up towards the end of the page.
				activeSlotsOnPage++;
			}

		}
		else
		{
			// Found an empty slot. 
			// Increase the number of empty slots we've encountered...
			iNumEmptySlots++;
			// Increase the number of slots encountered since the last valid item.
			iNumEmptySlotsAtEnd++;
		}
	}

	// Truncate. This makes sure we don't have a page full of empty slots. If we need one, we'll add it later.
	// 1. Find out how many redundant empty slots we have at the end.
	INT32 iNumSlotsToRemove = iNumEmptySlotsAtEnd - (iNumEmptySlotsAtEnd % MAP_INVENTORY_POOL_SLOT_COUNT);
	// 2. Reduce the number of required slots at the end to make the last page.
	iNumEmptySlotsAtEnd -= iNumSlotsToRemove;
	// 3. Reduce the total number of empty slots encountered by the same amount.
	iNumEmptySlots -= iNumSlotsToRemove;
	// 4. The difference between these two values is the number of empty slots strewn between valid items.
	// We need to count them separately because for all intents and purposes, we count them as valid items.
	INT32 iNumEmptySlotsWithin = iNumEmptySlots - iNumEmptySlotsAtEnd;

	// Calculate the minimum size of the inventory, including both valid items and empty slots between them,
	// but not the extra slots required to make a round number of pages.
	ListSize = activeSlotsTotal + iNumEmptySlotsWithin;
	
	// Now find out the minimal number of slots required to make a round number of pages.
	INT32 iOptimalSizeWithExtraEmptySlots = ((ListSize / MAP_INVENTORY_POOL_SLOT_COUNT) + 1) * MAP_INVENTORY_POOL_SLOT_COUNT;

	// This simply ensures we don't make more extra empty slots at the end than is absolutely necessary.
	iNumEmptySlotsAtEnd = __min(MAP_INVENTORY_POOL_SLOT_COUNT - 1, iOptimalSizeWithExtraEmptySlots - ListSize);

	////////////////////////////////////////////////////////////////////////////
	// Now we resize the inventory to its full intended size.
	// 
	// Note that below we use __max to make sure that we're not decreasing the number of pages while the inventory
	// screen is open. In other words, the number of pages will not shrink unless we explicitly say it can. This
	// can lead to having 0 items on 14 pages, for example if we delete all items from a huge sector inventory. However,
	// this is fine because the extra pages will disappear when we reopen this inventory - and until then we avoid
	// any issues that may arise from checking invalid inventory slots. A more experienced programmer might be able
	// to reduce the size of the inventory while we work, but that would require more wizardry - and is not actually
	// necessary to begin with. It's actually better and safer this way!
	BOOLEAN fExtraPage = FALSE;
	if (iNumEmptySlotsAtEnd >= 3 )
	{
		// Lots of empty slots at the end, so we don't need to increase the number of pages.
		pInventoryPoolList.resize( __max(iOptimalSizeWithExtraEmptySlots, giDesiredNumMapInventorySlots) );
	}
	else 
	{
		// We want 1 extra blank page at the end, so we add the number of slots required to make that page.
		pInventoryPoolList.resize( __max(iOptimalSizeWithExtraEmptySlots + MAP_INVENTORY_POOL_SLOT_COUNT, giDesiredNumMapInventorySlots ) );
		fExtraPage = TRUE;
	}

	// Set this value so that the inventory does not shrink later. If we zoom or close the inventory, this will be
	// automatically reset to force a complete recalculation - which is ok because we're recalculating everything in
	// such a case anyway.
	giDesiredNumMapInventorySlots = pInventoryPoolList.size();

	// Calculate the number of pages we've got.
	//iLastInventoryPoolPage = ( ( pInventoryPoolList.size()  - 1 ) / MAP_INVENTORY_POOL_SLOT_COUNT );
	iLastInventoryPoolPage = ( ( iOptimalSizeWithExtraEmptySlots - 1 ) / MAP_INVENTORY_POOL_SLOT_COUNT ) + fExtraPage;
	iCurrentInventoryPoolPage = __min(iCurrentInventoryPoolPage, iLastInventoryPoolPage);

	return;
}

void DrawTextOnMapInventoryBackground( void )
{
	UINT16 usStringHeight;

	SetFont( MAP_IVEN_FONT );
	SetFontBackground( FONT_BLACK );
	SetFontForeground( FONT_BEIGE );

	// set the buffer
	SetFontDestBuffer( guiSAVEBUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );

	//Calculate the height of the string, as it needs to be vertically centered.
	usStringHeight = DisplayWrappedString(MAP_INV_X_OFFSET + 268, (SCREEN_HEIGHT - 138 - 2 * yResOffset), 53, 1, MAP_IVEN_FONT, FONT_BEIGE, pMapInventoryStrings[ 0 ], FONT_BLACK, FALSE, RIGHT_JUSTIFIED | DONT_DISPLAY_TEXT );
	DisplayWrappedString(MAP_INV_X_OFFSET + 268, (UINT16)((SCREEN_HEIGHT - 138 - 2 * yResOffset) - (usStringHeight / 2) ), 53, 1, MAP_IVEN_FONT, FONT_BEIGE, pMapInventoryStrings[ 0 ], FONT_BLACK, FALSE, RIGHT_JUSTIFIED );

	//Calculate the height of the string, as it needs to be vertically centered.
	usStringHeight = DisplayWrappedString( MAP_INV_X_OFFSET + 369, (SCREEN_HEIGHT - 138 - 2 * yResOffset), 65, 1, MAP_IVEN_FONT, FONT_BEIGE, pMapInventoryStrings[ 1 ], FONT_BLACK, FALSE, RIGHT_JUSTIFIED | DONT_DISPLAY_TEXT );
	DisplayWrappedString(MAP_INV_X_OFFSET + 369, (UINT16)((SCREEN_HEIGHT - 138 - 2 * yResOffset) - (usStringHeight / 2) ), 65, 1, MAP_IVEN_FONT, FONT_BEIGE, pMapInventoryStrings[ 1 ], FONT_BLACK, FALSE, RIGHT_JUSTIFIED );

	// Only display the text in 640x480
	if (iResolution < _800x600)
	{
		DrawTextOnSectorInventory( );
	}

	SetFontDestBuffer( FRAME_BUFFER, 0,0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );

	return;
}


void HandleButtonStatesWhileMapInventoryActive( void )
{

	// are we even showing the amp inventory pool graphic?
	if( fShowMapInventoryPool == FALSE )
	{
		return;
	}

	// last page, go no further
	if( iCurrentInventoryPoolPage == iLastInventoryPoolPage )
	{
		DisableButton( guiMapInvenArrowButton[ 0 ] );
	}
	else
	{
		EnableButton( guiMapInvenArrowButton[ 0 ] );
	}

	// first page, can't go back any
	if( iCurrentInventoryPoolPage == 0 )
	{
		DisableButton( guiMapInvenArrowButton[ 1 ] );
	}
	else
	{
		EnableButton( guiMapInvenArrowButton[ 1 ] );
	}

	// item picked up ..disable button
	if( gMPanelRegion.Cursor == EXTERN_CURSOR )
	{
		DisableButton( guiMapInvenDoneButton );
		DisableButton( guiMapInvenSortButton[ 0 ] );
		DisableButton( guiMapInvenSortButton[ 1 ] );
		DisableButton( guiMapInvenSortButton[ 2 ] );
		DisableButton( guiMapInvenSortButton[ 3 ] );
	}
	else
	{
		EnableButton( guiMapInvenDoneButton );
		EnableButton( guiMapInvenSortButton[ 0 ] );
		EnableButton( guiMapInvenSortButton[ 1 ] );
		EnableButton( guiMapInvenSortButton[ 2 ] );
		EnableButton( guiMapInvenSortButton[ 3 ] );
	}

	// Selected Merc is in sector? Or is in combat?
	if(MercPtrs[gCharactersList[bSelectedInfoChar].usSolID]->sSectorX != sSelMapX ||
		MercPtrs[gCharactersList[bSelectedInfoChar].usSolID]->sSectorY != sSelMapY || 
		MercPtrs[gCharactersList[bSelectedInfoChar].usSolID]->bSectorZ != iCurrentMapSectorZ ||
		MercPtrs[gCharactersList[bSelectedInfoChar].usSolID]->flags.fBetweenSectors ||
		!CanPlayerUseSectorInventory( &(Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ]) ) ) 
	{
		DisableButton( guiMapInvenSortButton[ 0 ] );
		DisableButton( guiMapInvenSortButton[ 1 ] );
		DisableButton( guiMapInvenSortButton[ 2 ] );
		DisableButton( guiMapInvenSortButton[ 3 ] );
	}
}


void DrawTextOnSectorInventory( void )
{
	INT16 sX = 0, sY = 0;
	CHAR16 sString[ 64 ];

	// parse the string
	swprintf( sString, zMarksMapScreenText[ 11 ] );

	if(gGameExternalOptions.fEnableInventoryPoolQ && gInventoryPoolIndex != '0')//dnl ch51 081009
		swprintf(sString, L"Inventory Pool %c", gInventoryPoolIndex);

	
	SetFontDestBuffer( guiSAVEBUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );
	FindFontCenterCoordinates( (SCREEN_WIDTH - INTERFACE_WIDTH)/2 + 271, 18, xResSize - 271, GetFontHeight( FONT14ARIAL ), sString, FONT14ARIAL, &sX, &sY );
	
	SetFont( FONT14ARIAL );
	SetFontForeground( FONT_WHITE );
	SetFontBackground( FONT_BLACK );

	mprintf( sX, sY, sString );

	SetFontDestBuffer( FRAME_BUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );
}


void HandleFlashForHighLightedItem( void )
{
	INT32 iCurrentTime = 0;
	INT32 iDifference = 0;


	// if there is an invalid item, reset
	if( iCurrentlyHighLightedItem == -1 )
	{
		fFlashHighLightInventoryItemOnradarMap = FALSE;
		giFlashHighlightedItemBaseTime = 0;
	}

	// get the current time
	iCurrentTime = GetJA2Clock();

	// if there basetime is uninit
	if( giFlashHighlightedItemBaseTime == 0 )
	{
		giFlashHighlightedItemBaseTime = iCurrentTime;
	}


	iDifference = iCurrentTime - giFlashHighlightedItemBaseTime;

	if( iDifference > DELAY_FOR_HIGHLIGHT_ITEM_FLASH )
	{
		// reset timer
		giFlashHighlightedItemBaseTime = iCurrentTime;

		// flip flag
		fFlashHighLightInventoryItemOnradarMap = !fFlashHighLightInventoryItemOnradarMap;

		// re render radar map
		RenderRadarScreen( );

	}
}

void HandleMouseInCompatableItemForMapSectorInventory( INT32 iCurrentSlot )
{
	SOLDIERTYPE *pSoldier = NULL;
	static BOOLEAN fItemWasHighLighted = FALSE;

	if( iCurrentSlot == -1 )
	{
		giCompatibleItemBaseTime = 0;
	}

	if( fChangedInventorySlots == TRUE )
	{
		giCompatibleItemBaseTime = 0;
		fChangedInventorySlots = FALSE;
	}

	// reset the base time to the current game clock
	if( giCompatibleItemBaseTime == 0 )
	{
		giCompatibleItemBaseTime = GetJA2Clock( );

		if( fItemWasHighLighted == TRUE )
		{
			fTeamPanelDirty = TRUE;
			fMapPanelDirty = TRUE;
			fItemWasHighLighted = FALSE;
		}
	}

	ResetCompatibleItemArray( );
	ResetMapSectorInventoryPoolHighLights( );

	if( iCurrentSlot == -1 )
	{
		return;
	}

	// Check also that we're not beyond the resize.
	if (pInventoryPoolList.size() < (UINT32)(iCurrentSlot + ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) ))
	{
		return;
	}

	// given this slot value, check if anything in the displayed sector inventory or on the mercs inventory is compatable
	if( fShowInventoryFlag )
	{
		// check if any compatable items in the soldier inventory matches with this item
		if( gfCheckForCursorOverMapSectorInventoryItem )
		{
			pSoldier = &Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ];
			if( pSoldier )
			{
				if( HandleCompatibleAmmoUIForMapScreen( pSoldier, iCurrentSlot + ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ), TRUE, FALSE ) )
				{
					if( GetJA2Clock( ) - giCompatibleItemBaseTime > 100 )
					{
						if( fItemWasHighLighted == FALSE )
						{
							fTeamPanelDirty = TRUE;
							fItemWasHighLighted = TRUE;
						}
					}
				}
			}
		}
		else
		{
			giCompatibleItemBaseTime = 0;
		}
	}


	// now handle for the sector inventory
	if( fShowMapInventoryPool )
	{
		// check if any compatable items in the soldier inventory matches with this item
		if( gfCheckForCursorOverMapSectorInventoryItem )
		{
			if( HandleCompatibleAmmoUIForMapInventory( pSoldier, iCurrentSlot, ( iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT ) , TRUE, FALSE ) )
			{
				if( GetJA2Clock( ) - giCompatibleItemBaseTime > 100 )
				{
					if( fItemWasHighLighted == FALSE )
					{
						fItemWasHighLighted = TRUE;
						fMapPanelDirty = TRUE;
					}
				}
			}
		}
		else
		{
			giCompatibleItemBaseTime = 0;
		}
	}


	return;
}

void ResetMapSectorInventoryPoolHighLights( void )
{
	INT32 iCounter = 0;

	// now reset the highlight list for the map sector inventory
	for ( iCounter = 0; iCounter < MAP_INVENTORY_POOL_SLOT_COUNT; iCounter++ )
	{
		if ( fMapInventoryItemCompatable[ iCounter ] )
		{
			fMapInventoryItemCompatable[ iCounter ] = FALSE;
		}
	}

	return;
}
void HandleMapSectorInventory( void )
{
	// handle mouse in compatable item map sectors inventory
	// HEADROCK HAM 5: This shouldn't fire when doing Inventory Zoom
	if (!fWaitingForZoomInput)
	{
		HandleMouseInCompatableItemForMapSectorInventory( iCurrentlyHighLightedItem );
	}

	return;
}


//CJC look here to add/remove checks for the sector inventory
BOOLEAN IsMapScreenWorldItemVisibleInMapInventory( WORLDITEM *pWorldItem )
{
	if( pWorldItem->bVisible == 1 &&
		pWorldItem->fExists &&
		pWorldItem->object.exists() == true &&
		pWorldItem->object.usItem != SWITCH &&
		pWorldItem->object.usItem != ACTION_ITEM &&
		pWorldItem->object[0]->data.bTrap <= 0 )
	{
		// HEADROCK HAM 5: Map Inventory Filters are applied here. The item in question
		// has to match one of the Item Classes defined in this global Flags variable.
		if (Item[pWorldItem->object.usItem].usItemClass & guiMapInventoryFilter)
		{
			return ( TRUE );
		}
		else
		{
			return( FALSE );
		}
	}

	return( FALSE );
}

//CJC look here to add/remove checks for the sector inventory
BOOLEAN IsMapScreenWorldItemInvisibleInMapInventory( WORLDITEM *pWorldItem )
{
	if( pWorldItem->fExists &&
		pWorldItem->object.exists() == true &&
		!IsMapScreenWorldItemVisibleInMapInventory( pWorldItem ) )
	{
		return( TRUE );
	}

	return( FALSE );
}

//Check to see if any of the items in the list have a gridno of NOWHERE and the entry point flag NOT set
void CheckGridNoOfItemsInMapScreenMapInventory()
{
	INT32 iCnt;
	UINT32 uiNumFlagsNotSet = 0;
	INT32	 iTotalNumberItems = GetTotalNumberOfItems( );


	for( iCnt=0; iCnt<iTotalNumberItems; iCnt++)
	{
		if( ( TileIsOutOfBounds(pInventoryPoolList[ iCnt ].sGridNo) )&& !( pInventoryPoolList[ iCnt ].usFlags & WORLD_ITEM_GRIDNO_NOT_SET_USE_ENTRY_POINT ) )		
		{
			//set the flag
			pInventoryPoolList[ iCnt ].usFlags |= WORLD_ITEM_GRIDNO_NOT_SET_USE_ENTRY_POINT;

			//count the number
			uiNumFlagsNotSet++;
		}
	}


	//loop through all the UNSEEN items
	for( iCnt=0; iCnt<(INT32)uiNumberOfUnSeenItems; iCnt++)
	{		
		if (TileIsOutOfBounds(pUnSeenItems[ iCnt ].sGridNo) && !( pUnSeenItems[ iCnt ].usFlags & WORLD_ITEM_GRIDNO_NOT_SET_USE_ENTRY_POINT ) )
		{
			//set the flag
			pUnSeenItems[ iCnt ].usFlags |= WORLD_ITEM_GRIDNO_NOT_SET_USE_ENTRY_POINT;

			//count the number
			uiNumFlagsNotSet++;
		}
	}

#ifdef JA2BETAVERSION
	if( uiNumFlagsNotSet > 0 )
	{
		ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_BETAVERSION, L"Item with invalid gridno doesnt have flag set.", uiNumFlagsNotSet );
	}
#endif
}


void SortSectorInventory( std::vector<WORLDITEM>& pInventory, UINT32 uiSizeOfArray )
{
	//first, compress the inventory by stacking like items that are reachable, while moving empty items towards the back
	for (std::vector<WORLDITEM>::iterator iter = pInventory.begin(); iter != pInventory.end(); ++iter) {
		//if object exists, we want to try to stack it
		if (iter->fExists && iter->object.exists() == true) {

			//ADB TODO if it is active and reachable etc, alternatively if it's on the same gridNo
#if 0
			if (iter->object.ubNumberOfObjects < ItemSlotLimit( iter->object.usItem, STACK_SIZE_LIMIT )) {
				std::vector<WORLDITEM>::iterator second = iter;
				for (++second; second != pInventory.end(); ++second) {
					if (second->object.usItem == iter->object.usItem
						&& second->object.exists() == true) {
						iter->object.AddObjectsToStack(second->object, second->object.ubNumberOfObjects);
						if (iter->object.ubNumberOfObjects >= ItemSlotLimit( iter->object.usItem, STACK_SIZE_LIMIT )) {
							break;
						}
					}
				}
			}
#endif
		}
		else {
			//object does not exist, so compress the list
			std::vector<WORLDITEM>::iterator second = iter;
			for (++second; second != pInventory.end(); ++second) {
				if (second->fExists && second->object.exists() == true) {
					*iter = *second;
					second->initialize();
					break;
				}
			}
			if (second == pInventory.end()) {
				//we reached the end of the list without finding any active item, so we can break out of this loop too!
				break;
			}
		}
	}

	//once compressed, we need only sort the existing items
	//all empty items should be at the back!!!
	std::vector<WORLDITEM>::iterator endSort = pInventory.begin();
	for (unsigned int x = 1; x < pInventory.size(); ++x) {
		if (pInventory[x].fExists && pInventory[x].object.exists() == true) {
			++endSort;
		}
		else {
			break;
		}
	}
	++endSort;

	//ADB I'm not sure qsort will work with OO data, so replace it with stl sort, which is faster anyways
	std::sort(pInventory.begin(), endSort);

	//then compress it by removing the empty objects, we know they are at the back
	//we want the size to equal x * MAP_INVENTORY_POOL_SLOT_COUNT
	for (unsigned int x = 1; x <= pInventory.size() / MAP_INVENTORY_POOL_SLOT_COUNT && pInventory.size() > x * MAP_INVENTORY_POOL_SLOT_COUNT; ++x) {
		if (pInventory[x * MAP_INVENTORY_POOL_SLOT_COUNT].fExists == false
			&& pInventory[x * MAP_INVENTORY_POOL_SLOT_COUNT].object.exists() == false) {
			//we have found a page where the first item on the page does not exist, resize to this
			//we may have just cut off a blank page leaving the previous page full with no place to put
			//any new objects, but ResizeInventoryList after this will take care of that.
			pInventory.resize(x * MAP_INVENTORY_POOL_SLOT_COUNT);
		}
	}
}


INT32 MapScreenSectorInventoryCompare( const void *pNum1, const void *pNum2)
{
	WORLDITEM *pFirst = (WORLDITEM *)pNum1;
	WORLDITEM *pSecond = (WORLDITEM *)pNum2;
	UINT16	usItem1Index;
	UINT16	usItem2Index;
	UINT16		ubItem1Quality;
	UINT16		ubItem2Quality;
/*
	if(gGameExternalOptions.fEnableInventoryPoolQ)//dnl??? ch51 081009
	{
		if(pFirst->object.usItem == 0)
			return(1);
		else if(pSecond->object.usItem == 0)
			return(-1);
	}
*/
	usItem1Index = pFirst->object.usItem;
	usItem2Index = pSecond->object.usItem;

	ubItem1Quality = pFirst->object[0]->data.objectStatus;
	ubItem2Quality = pSecond->object[0]->data.objectStatus;

	return( CompareItemsForSorting( usItem1Index, usItem2Index, ubItem1Quality, ubItem2Quality ) );
}

BOOLEAN CanPlayerUseSectorInventory( SOLDIERTYPE *pSelectedSoldier )
{
	INT16	sSectorX, sSectorY, sSectorZ;

	//Get the sector that has a battle
	BOOLEAN fInCombat = GetCurrentBattleSectorXYZAndReturnTRUEIfThereIsABattle( &sSectorX, &sSectorY, &sSectorZ );

	//if there is a battle going on
	if( fInCombat )
	{
		//if the selected map is the one with the combat
		if( ( ( sSelMapX == sSectorX ) &&
					( sSelMapY == sSectorY ) &&
					( iCurrentMapSectorZ == sSectorZ )
				)
			)
		{
			return( FALSE );
		}
	}

	return( TRUE );
}

//dnl ch51 081009 start
BOOLEAN	LoadInventoryPoolQ (UINT8 ubSaveGameID)
{
	BOOLEAN ret;
	INT32 i, j, iTotNumSlots;
	CHAR8 tmpbuf[1024];
	UINT32 uiNumBytesRead;
	HWFILE hFile = 0;

	if(MAP_INVENTORY_POOL_SLOT_COUNT <= 0)
	{
		if (iResolution >= _640x480 && iResolution < _800x600)
			MAP_INVENTORY_POOL_SLOT_COUNT = 40;
		else if (iResolution < _1024x768)
			MAP_INVENTORY_POOL_SLOT_COUNT = 77;
		else
			MAP_INVENTORY_POOL_SLOT_COUNT = 170;
	}
	
	ret = FALSE;
	CreateSavedGameFileNameFromNumber(ubSaveGameID, tmpbuf);
	strcat(tmpbuf, ".IPQ");
	
	//MM:  This check is sometimes required while debugging a save game from release mode
	if (FileExists(tmpbuf))
		hFile = FileOpen(tmpbuf, FILE_ACCESS_READ|FILE_OPEN_EXISTING, FALSE);

	if(hFile == 0)
		return(TRUE);
	
	MemFreeInventoryPoolQ();
	FileRead(hFile, iCurrentInventoryPoolPageQ+1, (INVPOOLLISTNUM-1)*sizeof(INT32), &uiNumBytesRead);
	if(uiNumBytesRead != (INVPOOLLISTNUM-1)*sizeof(INT32))
		goto ERR;
	FileRead(hFile, iLastInventoryPoolPageQ+1, (INVPOOLLISTNUM-1)*sizeof(INT32), &uiNumBytesRead);
	if(uiNumBytesRead != (INVPOOLLISTNUM-1)*sizeof(INT32))
		goto ERR;
	for(i=1; i<INVPOOLLISTNUM; i++)
	{
		FileRead(hFile, &j, sizeof(INT32), &uiNumBytesRead);
		if(uiNumBytesRead != sizeof(INT32))
			goto ERR;
		if(j == 0)
			continue;
		iTotNumSlots = j;
		if(MAP_INVENTORY_POOL_SLOT_COUNT != (j/(iLastInventoryPoolPageQ[i]+1)))
		{
			iLastInventoryPoolPageQ[i] = j / MAP_INVENTORY_POOL_SLOT_COUNT + 1;
			j = iLastInventoryPoolPageQ[i] * MAP_INVENTORY_POOL_SLOT_COUNT;
			iCurrentInventoryPoolPageQ[i] = 0;
		}
		pInventoryPoolListQ[i].resize(j);
		for(j=0; j<iTotNumSlots; j++)
			if(!pInventoryPoolListQ[i][j].Load(hFile))
				goto ERR;
	}
	ret = TRUE;
ERR:
	if(ret == FALSE)
		MemFreeInventoryPoolQ();
	FileClose(hFile);
	return(ret);
}

BOOLEAN MemFreeInventoryPoolQ(void)
{
	INT32 i;

	for(i=1; i<INVPOOLLISTNUM; i++)
	{
		pInventoryPoolListQ[i].clear();
		iCurrentInventoryPoolPageQ[i] = 0;
		iLastInventoryPoolPageQ[i] = 0;
	}
	return(TRUE);
}

BOOLEAN SaveInventoryPoolQ(UINT8 ubSaveGameID)
{
	BOOLEAN ret;
	INT32 i, j;
	CHAR8 tmpbuf[1024];
	UINT32 uiNumBytesWritten;
	HWFILE hFile;

	if(MAP_INVENTORY_POOL_SLOT_COUNT <= 0)
	{
		if (iResolution >= _640x480 && iResolution < _800x600)
			MAP_INVENTORY_POOL_SLOT_COUNT = 40;
		else if (iResolution < _1024x768)
			MAP_INVENTORY_POOL_SLOT_COUNT = 77;
		else
			MAP_INVENTORY_POOL_SLOT_COUNT = 170;
	}
	
	ret = FALSE;
	CreateSavedGameFileNameFromNumber(ubSaveGameID, tmpbuf);
	strcat(tmpbuf, ".IPQ");
	hFile = FileOpen(tmpbuf, FILE_ACCESS_WRITE|FILE_OPEN_ALWAYS, FALSE);
	if(hFile == 0)
		goto ERR;
	FileWrite(hFile, iCurrentInventoryPoolPageQ+1, (INVPOOLLISTNUM-1)*sizeof(INT32), &uiNumBytesWritten);
	if(uiNumBytesWritten != (INVPOOLLISTNUM-1)*sizeof(INT32))
		goto ERR;
	FileWrite(hFile, iLastInventoryPoolPageQ+1, (INVPOOLLISTNUM-1)*sizeof(INT32), &uiNumBytesWritten);
	if(uiNumBytesWritten != (INVPOOLLISTNUM-1)*sizeof(INT32))
		goto ERR;
	for(i=1; i<INVPOOLLISTNUM; i++)
	{
		j = pInventoryPoolListQ[i].size();
		FileWrite(hFile, &j, sizeof(INT32), &uiNumBytesWritten);
		if(uiNumBytesWritten != sizeof(INT32))
			goto ERR;
		for(j=0; j<(INT32)pInventoryPoolListQ[i].size(); j++)
			if(!pInventoryPoolListQ[i][j].Save(hFile, TRUE))
				goto ERR;
	}
	ret = TRUE;
ERR:
	FileClose(hFile);
	return(ret);
}

BOOLEAN SortInventoryPoolQ(void)
{
	if(pInventoryPoolList.size() > 0)
	{
		for(INT32 iSlotCounter=0; iSlotCounter<(INT32)pInventoryPoolList.size(); iSlotCounter++)
			if(pInventoryPoolList[iSlotCounter].object.usItem == NOTHING && pInventoryPoolList[iSlotCounter].object.exists() == false)
			{
				pInventoryPoolList[iSlotCounter].fExists = FALSE;
				pInventoryPoolList[iSlotCounter].bVisible = FALSE;
			}
		SortSectorInventory(pInventoryPoolList, pInventoryPoolList.size());
		iLastInventoryPoolPage = (pInventoryPoolList.size() - 1) / MAP_INVENTORY_POOL_SLOT_COUNT;
		if(iCurrentInventoryPoolPage > iLastInventoryPoolPage)
			iCurrentInventoryPoolPage = iLastInventoryPoolPage;
	}
	fMapPanelDirty = TRUE;
	return(TRUE);
}

BOOLEAN SwitchToInventoryPoolQ(UINT8 newidx)
{
	UINT8 curidx;

	curidx = gInventoryPoolIndex & 0x0F;
	pInventoryPoolListQ[curidx] = pInventoryPoolList;
	iCurrentInventoryPoolPageQ[curidx] = iCurrentInventoryPoolPage;
	iLastInventoryPoolPageQ[curidx] = iLastInventoryPoolPage;

	newidx &= 0x0F;
	if (pInventoryPoolListQ[newidx].empty() == true)
		pInventoryPoolListQ[newidx].resize(MAP_INVENTORY_POOL_SLOT_COUNT);
	pInventoryPoolList = pInventoryPoolListQ[newidx];
	iCurrentInventoryPoolPage = iCurrentInventoryPoolPageQ[newidx];
	iLastInventoryPoolPage = iLastInventoryPoolPageQ[newidx];

	gInventoryPoolIndex = newidx | 0x30;
	fMapPanelDirty = TRUE;

	return(TRUE);
}

BOOLEAN CopySectorInventoryToInventoryPoolQ(UINT8 idx)
{
	INT32 iSlotCounter, iSlotCounterQ;

	idx = gInventoryPoolIndex & 0x0F;
	if(idx <= 0 || idx >= INVPOOLLISTNUM)
		return(FALSE);
	SwitchToInventoryPoolQ('0');
	iSlotCounterQ = 0;
	for(iSlotCounter=0; iSlotCounter<(INT32)pInventoryPoolList.size(); iSlotCounter++)
	{
		if(pInventoryPoolList[iSlotCounter].bVisible==1 && pInventoryPoolList[iSlotCounter].fExists && pInventoryPoolList[iSlotCounter].usFlags&WORLD_ITEM_REACHABLE && pInventoryPoolList[iSlotCounter].object.usItem != NOTHING)
		{
			while(1)
			{
				if(iSlotCounterQ >= (INT32)pInventoryPoolListQ[idx].size())
				{
					pInventoryPoolListQ[idx].resize(pInventoryPoolListQ[idx].size() + MAP_INVENTORY_POOL_SLOT_COUNT);
					iLastInventoryPoolPageQ[idx] = (pInventoryPoolListQ[idx].size() - 1) / MAP_INVENTORY_POOL_SLOT_COUNT;
				}
				if(pInventoryPoolListQ[idx][iSlotCounterQ].object.usItem == NOTHING)
				{
					pInventoryPoolListQ[idx][iSlotCounterQ] = pInventoryPoolList[iSlotCounter];
					DeleteObj(&pInventoryPoolList[iSlotCounter].object);
					iSlotCounterQ++;
					break;
				}
				iSlotCounterQ++;
			}
		}
	}
	SwitchToInventoryPoolQ(idx|'0');
	return(TRUE);
}

BOOLEAN CopySectorInventoryToInventoryPoolQs(UINT8 idx)
{
	UINT8 defaultidx;
	INT32 iSlotCounter, iSlotCounterQ[INVPOOLLISTNUM];

	idx = gInventoryPoolIndex & 0x0F;
	if(!(idx == 0 || idx == 8 || idx == 9))// Only from these inventories items could be separate to 1-7
		return(FALSE);
	defaultidx = idx;
	memset(iSlotCounterQ, 0, sizeof(iSlotCounterQ));
	for(iSlotCounter=0; iSlotCounter<(INT32)pInventoryPoolList.size(); iSlotCounter++)
	{
		if(pInventoryPoolList[iSlotCounter].bVisible==1 && pInventoryPoolList[iSlotCounter].fExists && pInventoryPoolList[iSlotCounter].usFlags&WORLD_ITEM_REACHABLE && pInventoryPoolList[iSlotCounter].object.usItem != NOTHING)
		{
			UINT32 usItemClass = Item[pInventoryPoolList[iSlotCounter].object.usItem].usItemClass;
			if(usItemClass == IC_GUN || usItemClass == IC_LAUNCHER)
				idx = 1;
			else if(usItemClass == IC_AMMO || usItemClass == IC_BELTCLIP)
				idx = 2;
			else if(usItemClass == IC_BOMB || usItemClass == IC_GRENADE)
				idx = 3;
			else if(usItemClass == IC_BLADE || usItemClass == IC_THROWING_KNIFE || usItemClass == IC_THROWN || usItemClass == IC_PUNCH)
				idx = 4;
			else if(usItemClass == IC_ARMOUR || usItemClass == IC_LBEGEAR)
				idx = 5;
			else if(usItemClass == IC_MEDKIT || usItemClass == IC_KIT || usItemClass == IC_APPLIABLE)
				idx = 6;
			else if(usItemClass == IC_NONE || usItemClass == IC_FACE || usItemClass == IC_KEY || usItemClass == IC_MISC || usItemClass == IC_MONEY || usItemClass == IC_TENTACLES)
				idx = 7;
			else
				idx = defaultidx;
			while(1)
			{
				if(iSlotCounterQ[idx] >= (INT32)pInventoryPoolListQ[idx].size())
				{
					pInventoryPoolListQ[idx].resize(pInventoryPoolListQ[idx].size() + MAP_INVENTORY_POOL_SLOT_COUNT);
					iLastInventoryPoolPageQ[idx] = (pInventoryPoolListQ[idx].size() - 1) / MAP_INVENTORY_POOL_SLOT_COUNT;
				}
				if(pInventoryPoolListQ[idx][iSlotCounterQ[idx]].object.usItem == NOTHING)
				{
					pInventoryPoolListQ[idx][iSlotCounterQ[idx]] = pInventoryPoolList[iSlotCounter];
					DeleteObj(&pInventoryPoolList[iSlotCounter].object);
					pInventoryPoolList[iSlotCounter].fExists = FALSE;
					pInventoryPoolList[iSlotCounter].bVisible = FALSE;
					iSlotCounterQ[idx]++;
					break;
				}
				iSlotCounterQ[idx]++;
			}
		}
	}
	fMapPanelDirty = TRUE;
	return(TRUE);
}
//dnl ch51 081009 finish

void DeleteAllItemsInInventoryPool()
{
	pInventoryPoolList.clear();

	fMapPanelDirty = TRUE;

	ClearUpTempUnSeenList( );
	SaveSeenAndUnseenItems();

	iCurrentInventoryPoolPage = 0;
	iLastInventoryPoolPage = 0;

	DestroyStash();
	BuildStashForSelectedSector( sSelMapX, sSelMapY, iCurrentMapSectorZ);
}


void DeleteItemsOfType( UINT16 usItemType )
{
	for( UINT32 iNumber = 0 ; iNumber <  pInventoryPoolList.size() ; ++iNumber)
	{
		if ( pInventoryPoolList [ iNumber ].object.usItem == usItemType )
		{
			DeleteObj( &pInventoryPoolList [ iNumber ].object );
		}
	}

}

extern UINT8 CurrentPlayerProgressPercentage(void);

// HEADROCK HAM 5: Added argument
INT32 SellItem( OBJECTTYPE& object, BOOLEAN fAll, BOOLEAN useModifier )
{
	INT32 iPrice = 0;
	INT16 iPriceModifier = gGameExternalOptions.iPriceModifier;
	UINT16 usItemType = object.usItem;
	UINT16 itemPrice = Item[usItemType].usPrice;

	// HEADROCK HAM 5: Controls whether we price the top object or all objects in the stack.
	UINT8 ubNumberOfObjects;
	if (!fAll)
	{
		ubNumberOfObjects = 1;
	}
	else
	{
		ubNumberOfObjects = object.ubNumberOfObjects;
	}

	//CHRISL: make price modifier based on current game progress
	if(iPriceModifier == 0)
	{
		iPriceModifier = __max(1, (INT16)((CurrentPlayerProgressPercentage()/5)+.5));
	}
	else if(iPriceModifier == -1)
	{
		iPriceModifier = __max(1, (INT16)(((100-CurrentPlayerProgressPercentage())/5)+.5));
	}

	if( Item[ usItemType ].usItemClass == IC_AMMO )
	{
		//we are selling ammo
		UINT16 magSize = Magazine[ Item[ usItemType ].ubClassIndex ].ubMagSize;
		for (UINT8 ubLoop = 0; ubLoop < object.ubNumberOfObjects; ubLoop++)
		{
			iPrice += (INT32)( itemPrice * (float) object[ubLoop]->data.ubShotsLeft / magSize );
		}
	}
	//CHRISL: If we're dealing with money, we want to use the money's amount and just return that value with no modification
	else if(Item[usItemType].usItemClass == IC_MONEY)
	{
		for (UINT8 ubLoop = 0; ubLoop < object.ubNumberOfObjects; ubLoop++)
		{
			iPrice += (INT32)(object[ubLoop]->data.money.uiMoneyAmount);
		}
		return iPrice;
	}
	else if(Item[usItemType].usItemClass == IC_LBEGEAR && UsingNewInventorySystem() == true)
	{
		//CHRISL: If we're selling an LBE Item, we need to verify if it's an LBENODE, first.  If it is, we need to sell
		//	everything stored in the LBENODE before we sell teh LBE Item itself.
		for(UINT8 ubLoop = 0; ubLoop < object.ubNumberOfObjects; ubLoop++)
		{
			if(object.IsActiveLBE(ubLoop) == true)
			{
				LBENODE* pLBE = object.GetLBEPointer(ubLoop);
				if(pLBE)
				{
					for(unsigned int x = 0; x < pLBE->inv.size(); x++)
					{
						if(pLBE->inv[x].exists() == true)
						{
							// HEADROCK HAM 5: Added argument
							iPrice += SellItem(pLBE->inv[x], TRUE, FALSE);
						}
					}
				}
			}
			iPrice += ( itemPrice * object[ubLoop]->data.objectStatus / 100 );
			for (attachmentList::iterator iter = object[ubLoop]->attachments.begin(); iter != object[ubLoop]->attachments.end(); ++iter) {
				if(iter->exists())
				{
					// HEADROCK HAM 5: Added argument
					iPrice += SellItem(*iter, TRUE, FALSE);
				}
			}
		}
	}
	else
	{
		//we are selling a gun or something - it could be stacked or single, and if single it could have attachments
		for (UINT8 ubLoop = 0; ubLoop < object.ubNumberOfObjects; ubLoop++)
		{
			iPrice += ( itemPrice * object[ubLoop]->data.objectStatus / 100 );
			for (attachmentList::iterator iter = object[ubLoop]->attachments.begin(); iter != object[ubLoop]->attachments.end(); ++iter) {
				if(iter->exists())
				{
					// HEADROCK HAM 5: Added argument
					iPrice += SellItem(*iter, TRUE, FALSE);
				}
			}
		}

	}

	if( iPriceModifier > 1 && useModifier == TRUE) {
		iPrice /= iPriceModifier;
	}

	return iPrice;
}

// HEADROCK HAM 5: This function handles altering the coordinates and sizes of all map inventory slots. This is used
// for a switch between Small and Large inventory item display ("zoom").
void ResetMapInventoryOffsets( void )
{
	if ( !fMapInventoryZoom )
	{
		//////////////////////////////////////////////
		// ZOOM OFF

		if (iResolution >= _640x480 && iResolution < _800x600)
		{
			MAP_INV_SLOT_COLS = 8;
			MAP_INVENTORY_POOL_SLOT_START_X = 269 + xResOffset;
			MAP_INVENTORY_POOL_SLOT_START_Y = 51;
		}
		else if (iResolution >= _800x600 && iResolution < _1024x768)
		{
			MAP_INV_SLOT_COLS = 11;
			MAP_INVENTORY_POOL_SLOT_START_X = 278 + xResOffset;
			MAP_INVENTORY_POOL_SLOT_START_Y = 62;
		}
		else if (iResolution >= _1024x768)
		{
			MAP_INV_SLOT_COLS = 17;
			MAP_INVENTORY_POOL_SLOT_START_X = 282 + xResOffset;
			MAP_INVENTORY_POOL_SLOT_START_Y = 50;
		}
		MAP_INVENTORY_POOL_SLOT_COUNT = GetInventorySlotCount( FALSE );

		ITEMDESC_ITEM_STATUS_HEIGHT_INV_POOL = 20;
		ITEMDESC_ITEM_STATUS_WIDTH_INV_POOL = 2;
		ITEMDESC_ITEM_STATUS_INV_POOL_OFFSET_X = 5;
		ITEMDESC_ITEM_STATUS_INV_POOL_OFFSET_Y = 22;

		ITEMDESC_ITEM_NAME_POOL_OFFSET_Y = 3;

		MAP_INVEN_SLOT_WIDTH = 65;
		MAP_INVEN_SPACE_BTWN_SLOTS = 72;
		MAP_INVEN_SLOT_HEIGHT = 32;
		MAP_INVEN_SLOT_IMAGE_HEIGHT = 24;

		MAP_INVEN_NAME_FONT = SMALLCOMPFONT;

	}
	else
	{
		////////////////////////////////////
		// ZOOM ON

		if (iResolution >= _640x480 && iResolution < _800x600)
		{
			MAP_INV_SLOT_COLS = 3;
			MAP_INVENTORY_POOL_SLOT_START_X = 269 + xResOffset;
			MAP_INVENTORY_POOL_SLOT_START_Y = 51;
		}
		else if (iResolution >= _800x600 && iResolution < _1024x768)
		{
			MAP_INV_SLOT_COLS = 5;
			MAP_INVENTORY_POOL_SLOT_START_X = 278 + xResOffset;
			MAP_INVENTORY_POOL_SLOT_START_Y = 62;
		}
		else if (iResolution >= _1024x768)
		{
			MAP_INV_SLOT_COLS = 8;
			MAP_INVENTORY_POOL_SLOT_START_X = 282 + xResOffset;
			MAP_INVENTORY_POOL_SLOT_START_Y = 50;
		}

		MAP_INVENTORY_POOL_SLOT_COUNT = GetInventorySlotCount( TRUE );
		ITEMDESC_ITEM_STATUS_HEIGHT_INV_POOL = 40;
		ITEMDESC_ITEM_STATUS_WIDTH_INV_POOL = 3;
		ITEMDESC_ITEM_STATUS_INV_POOL_OFFSET_X = 5;
		ITEMDESC_ITEM_STATUS_INV_POOL_OFFSET_Y = 44;

		ITEMDESC_ITEM_NAME_POOL_OFFSET_Y = 10;

		MAP_INVEN_SLOT_WIDTH = 129;
		MAP_INVEN_SPACE_BTWN_SLOTS = 135;
		MAP_INVEN_SLOT_HEIGHT = 67;
		MAP_INVEN_SLOT_IMAGE_HEIGHT = 49;

		MAP_INVEN_NAME_FONT = FONT10ARIAL;
	}
}

// HEADROCK HAM 5: Load the BigItem graphics for all items on this page of the sector inventory.
// Because BigItem graphics are not kept in memory by default, we need to load them now in order to display all items
// on the screen. Note that this function will run every time the contents of the inventory are changed, in order to
// ensure that new items now appearing on the screen have their BigItem pics accessible.
void LoadAllMapInventoryBigItemGraphics()
{
	INT32 iCounter = 0;

	// Go through each and every slot that exists on the screen.
	for( iCounter = 0; iCounter < MAP_INVENTORY_POOL_SLOT_COUNT ; iCounter++ )
	{
		LoadMapInventoryBigItemGraphic( iCounter );
	}
}

// HEADROCK HAM 5: This function loads a specific BigItem graphic for one of the items in the Sector Inventory.
// This is done because BigItem graphics are not stored in memory - this function allows us to access one of them,
// using only its position in the inventory.
void LoadMapInventoryBigItemGraphic( INT32 iCounter )
{
	// Get the item's absolute position in the sector inventory
	INT32 iItemNum = iCounter + (iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT);
	UINT32 uiItemGraphic;
	// Does the item exist? (If not, it's an empty slot and requires no graphics)
	if (pInventoryPoolList[ iItemNum ].object.exists())
	{
		// Load the graphic from the STI
		LoadTileGraphicForItem( &(Item[ pInventoryPoolList[ iItemNum ].object.usItem ]), &uiItemGraphic );
		// Record the number of graphic used, so we can easily access it later. The array contains only images
		// for the items currently on the screen, so [0] is always the item in the top-left corner.
		giMapInventoryBigItemGraphics[ iCounter ].iGraphicNum = (INT32)uiItemGraphic;
		giMapInventoryBigItemGraphics[ iCounter ].usItem = pInventoryPoolList[ iItemNum ].object.usItem;
	}
	else
	{
		// Empty slot. Reset the number so we don't try to unload the picture here.
		giMapInventoryBigItemGraphics[ iCounter ].iGraphicNum = -1;
		giMapInventoryBigItemGraphics[ iCounter ].usItem = 0;
	}
}

// HEADROCK HAM 5: Unload all BigItem graphics from memory.
// We run this every time the zoomed inventory (or the entire inventory) is closed.
void UnloadAllMapInventoryBigItemGraphics()
{
	for (INT32 iCounter = 0; iCounter < MAP_INVENTORY_POOL_MAX_SLOTS; iCounter++)
	{
		UnloadMapInventoryBigItemGraphic( iCounter );
	}
}

void UnloadMapInventoryBigItemGraphic( INT32 iCounter )
{
	// Skip slots that have no item graphic assigned to them.
	if (giMapInventoryBigItemGraphics [ iCounter ].iGraphicNum > -1)
	{
		DeleteVideoObjectFromIndex( (UINT32)giMapInventoryBigItemGraphics[ iCounter ].iGraphicNum );
		giMapInventoryBigItemGraphics[ iCounter ].iGraphicNum = -1;
		giMapInventoryBigItemGraphics[ iCounter ].usItem = 0;
	}
}

void ResetAllMapInventoryBigItemGraphics()
{
	for (INT32 iCounter = 0; iCounter < MAP_INVENTORY_POOL_MAX_SLOTS; iCounter++)
	{
		giMapInventoryBigItemGraphics[ iCounter ].iGraphicNum = -1;
		giMapInventoryBigItemGraphics[ iCounter ].usItem = 0;
	}
}

// HEADROCK HAM 5: Handle switch to Zoomed inventory on given page.
void HandleMapInventoryZoom( UINT32 iPage, INT32 iCounter )
{
	// Set the zoom flag. This tells the program to draw all items using their large images, and also ensures
	// that all coordinates are set to show large slots.
	fMapInventoryZoom = 1;

	// Erase all of these flags to stop items from being outlined.
	for (UINT16 x = 0; x < MAP_INVENTORY_POOL_MAX_SLOTS; x++)
	{
		gfMapInventoryItemToZoom[x] = FALSE;
	}

	// Before resetting the pool slots, lets determine the position and size of the slot we're about to
	// zoom into. We'll use this for animations.
	INT32 iStartX = (INT32)( MAP_INVENTORY_POOL_SLOT_OFFSET_X + MAP_INVENTORY_POOL_SLOT_START_X + ( ( MAP_INVEN_SPACE_BTWN_SLOTS ) * ( iCounter / MAP_INV_SLOT_COLS ) ) );
	INT32 iStartY = (INT32)( MAP_INVENTORY_POOL_SLOT_START_Y + ( ( MAP_INVEN_SLOT_HEIGHT ) * ( iCounter % ( MAP_INV_SLOT_COLS ) ) ) );
	UINT32 iOrigWidth = MAP_INVEN_SLOT_WIDTH;
	UINT32 iOrigHeight = MAP_INVEN_SLOT_HEIGHT;
	UINT16 iLocationInPool = iCounter + (iCurrentInventoryPoolPage * MAP_INVENTORY_POOL_SLOT_COUNT);

	// Destroy all pool slots...
	DestroyMapInventoryPoolSlots();
	// Reinit the coordinates and sizes for the larger inventory...
	ResetMapInventoryOffsets();
	// Recreate all pool slots...
	CreateMapInventoryPoolSlots( );

	// Set current page
	iCurrentInventoryPoolPage = iPage;

	// Load all BigItem graphics for the current page.
	ResetAllMapInventoryBigItemGraphics();

	AnimateZoomInventory ( iLocationInPool, iCounter, iStartX, iStartY, iOrigWidth, iOrigHeight );

	ResizeInventoryList();

	// Flag as dirty for re-render.
	fMapPanelDirty = TRUE;
}

// HEADROCK HAM 5: Handle switch to Unzoomed inventory on given page.
void HandleMapInventoryUnzoom( UINT32 iPage )
{
	// Reset zoom flag
	fMapInventoryZoom = 0;

	giDesiredNumMapInventorySlots = -1;

	// Load all BigItem graphics for the current page.
	UnloadAllMapInventoryBigItemGraphics();

	// Destroy all pool slots, reinit all inventory coordinates and variables, then recreate slots.
	DestroyMapInventoryPoolSlots();
	ResetMapInventoryOffsets();
	CreateMapInventoryPoolSlots( );

	// Set current page
	iCurrentInventoryPoolPage = iPage;

	// Flag as dirty for re-render.
	fMapPanelDirty = TRUE;
}

// HEADROCK HAM 5: This function tells us how many slots there will be in the zoomed inventory. We run this
// both when creating the zoomed inventory, as well as when trying to calculate which items from unzoomed mode
// will appear in zoomed mode.
UINT16 GetInventorySlotCount( BOOLEAN fZoomed )
{
	if (!fZoomed)
	{
		if (iResolution >= _640x480 && iResolution < _800x600)
		{
			return 40;
		}
		if (iResolution >= _800x600 && iResolution < _1024x768)
		{
			return 77;
		}
		if (iResolution >= _1024x768)
		{
			return MAP_INVENTORY_POOL_MAX_SLOTS;
		}
	}
	else
	{
		if (iResolution >= _640x480 && iResolution < _800x600)
		{
			return 6;
		}
		if (iResolution >= _800x600 && iResolution < _1024x768)
		{
			return 15;
		}
		if (iResolution >= _1024x768)
		{
			return 40;
		}
	}

	// Error!
	AssertMsg( 0, "Zoomed Inventory error: Encountered unknown resolution setting." );
	return 0;
}

// HEADROCK HAM 5: This is a callback function that will cancel inventory zoom input.
void CancelInventoryZoomInput( BOOLEAN fButtonOff )
{
	// Are we being asked to turn the Zoom Button off?
	if (fButtonOff)
	{
		// Do it by referencing the button and toggling its flag manually.
		ButtonList[ guiMapInvenZoomButton ]->uiFlags &=~ (BUTTON_CLICKED_ON);
	}

	// Erase all of these flags to stop items from being outlined.
	for (UINT16 x = 0; x < MAP_INVENTORY_POOL_MAX_SLOTS; x++)
	{
		gfMapInventoryItemToZoom[x] = FALSE;
	}

	// Reset flag to inform the program that we are no longer expecting zoom input. Slot Mouse-Regions will now
	// behave normally.
	fWaitingForZoomInput = 0;
	// Free up the mouse!
	FreeMouseCursor();
}

// HEADROCK HAM 5: This function handles animation from Unzoomed inventory mode to Zoomed inventory mode.
// The animation takes an entire "slot" from the inventory view, and moves and stretches it to the exact
// location and dimensions it'll have in "zoomed" mode. This is similar to the zooming of the Laptop transition.
void AnimateZoomInventory ( UINT16 iLocationInPool, UINT16 iCounter, INT32 iStartX, INT32 iStartY, UINT32 uiOrigWidth, UINT32 uiOrigHeight )
{
	// We get here after already having set the offsets for the zoomed mode. We use one now to determine
	// the position of our slot within the zoomed page - which will open as soon as this animation is done.
	// Therefore, we're getting the animation's destination coordinates.
	UINT16 iCounterZoomed = iLocationInPool % MAP_INVENTORY_POOL_SLOT_COUNT;

	// Declarations
	SGPRect SrcRect, CurRect, StartRect, DstRect;
	INT32 iPercentage;
	UINT32 uiStartTime, uiTimeRange, uiCurrTime;
	INT32 iX, iY, iWidth, iHeight;
	INT16 sCenX, sCenY, usWidth, usHeight, sX, sY;
	INT16 sWidth = 0, sHeight = 0;
	ETRLEObject	*pTrav;
	HVOBJECT hHandle;
	INT32 iRealPercentage;

	// Make the mouse cursor disappear for now. It'll automatically restore itself when the animation is done.
	// Disabled for now...
	//SetCurrentCursorFromDatabase( VIDEO_NO_CURSOR );

	// First lets copy the entire screen into the SAVEBUFFER. By doing this we can ensure that the background
	// gets redrawn under our moving sprite.
	BlitBufferToBuffer( FRAME_BUFFER, guiSAVEBUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT );
	// For extra "cool" effect, we'll be making one slot "disappear", by blitting a part of the inventory
	// pool graphic on top of it. This'll give the impression that our slot is actually moving away from its
	// original location, leaving a hole behind it!
	// Get the pool graphic...
	GetVideoObject(&hHandle, guiMapInventoryPoolBackground);
	// Blit to the EXTRABUFFER
	BltVideoObject( guiEXTRABUFFER , hHandle, 0,INVEN_POOL_X, INVEN_POOL_Y , VO_BLT_SRCTRANSPARENCY,NULL );
	// Copy a piece of it back into the frame.
	BlitBufferToBuffer( guiEXTRABUFFER, guiSAVEBUFFER, iStartX, iStartY, uiOrigWidth, uiOrigHeight );

	// Not really necessary, but I'm not sure if I should remove it.
	RestoreBackgroundRects();

	// STEP 1: We make our sprite. This is done by drawing a slot to the top-left corner of the EXTRABUFFER,
	// then drawing our item on it. We'll be copying it back with every frame, at a new destination and
	// size.
	
	// Draw a big-item slot to 0,0.
	GetVideoObject(&hHandle, guiMapInventoryPoolSlot);
	sX = 0;
	sY = 0;
	BltVideoObject( guiEXTRABUFFER , hHandle, 1, sX, sY , VO_BLT_SRCTRANSPARENCY,NULL );

	// Does the object exist?
	if (pInventoryPoolList[ iLocationInPool ].object.exists() )
	{
		// We draw the BigItem graphic on top of the slot.

		// Get the BigItem Graphic for the item.
		LoadMapInventoryBigItemGraphic( iCounterZoomed );
		GetVideoObject( &hHandle, (UINT32)giMapInventoryBigItemGraphics[ iCounterZoomed ].iGraphicNum );
		// Calculate size
		pTrav = &( hHandle->pETRLEObject[ 0 ] );
		usHeight				= (UINT16)pTrav->usHeight;
		usWidth					= (UINT16)pTrav->usWidth;
		// Mandatory offsets...
		sX = 5;
		sY = 1;
		// Find the X,Y for the BigItem Image, so that it would center on the slot.
		sCenX = sX + ( abs(MAP_INVEN_SLOT_WIDTH - usWidth) / 2 ) - pTrav->sOffsetX;
		sCenY = sY + ( abs(MAP_INVEN_SLOT_IMAGE_HEIGHT - usHeight) / 2 ) - pTrav->sOffsetY;
		// Blit to the EXTRABUFFER
		BltVideoObject( guiEXTRABUFFER , hHandle, 0, sCenX, sCenY , VO_BLT_SRCTRANSPARENCY,NULL );

		// We print the item name below the item graphic
		CHAR16 sString[ 64 ];
		wcscpy( sString, ShortItemNames[ pInventoryPoolList[ iLocationInPool ].object.usItem ] );
		if( StringPixLength( sString, MAP_INVEN_NAME_FONT ) >= ( MAP_INVEN_SLOT_WIDTH ) )
		{
			ReduceStringLength( sString, ( INT16 )( MAP_INVEN_SLOT_WIDTH - StringPixLength( L" ...", MAP_INVEN_NAME_FONT ) ), MAP_INVEN_NAME_FONT );
		}
		INT16 iFontWidth = 0;
		INT16 iFontHeight = 0;
		FindFontCenterCoordinates( 2,
			0, MAP_INVEN_SLOT_WIDTH, 0,
			sString, MAP_INVEN_NAME_FONT,
			&iFontWidth, &iFontHeight );

		// Blit to the EXTRABUFFER
		SetFontDestBuffer( guiEXTRABUFFER, 0,0, SCREEN_WIDTH, SCREEN_HEIGHT, FALSE );
		SetFont( MAP_INVEN_NAME_FONT );
		SetFontForeground( FONT_WHITE );
		SetFontBackground( FONT_BLACK );

		mprintf( iFontWidth, ITEMDESC_ITEM_NAME_POOL_OFFSET_Y + ITEMDESC_ITEM_STATUS_INV_POOL_OFFSET_Y, sString );
	}

	// Set the size of the EXTRABUFFER region we want to copy and use as a sprite.
	SrcRect.iLeft =	0;
	SrcRect.iTop = 0;
	SrcRect.iRight = MAP_INVEN_SLOT_WIDTH;
	SrcRect.iBottom = MAP_INVEN_SLOT_HEIGHT;

	// STEP 2: The inventory is now stored in the SAVEBUFFER, and our sprite is in the EXTRABUUFFER.
	// Lets calculate the position and size of the sprite at the start of the animation and at its end.

	// Set the size of the sprite when it starts moving. Topleft should be the top left corner of the slot in
	// the unzoomed inventory, width and height correspond to the size of an unzoomed slot.
	// We get this info from outside the function, because we can't calculate it now that the offsets have
	// already been changed.
	StartRect.iLeft =	iStartX;
	StartRect.iTop =	iStartY;
	StartRect.iRight = iStartX + uiOrigWidth;
	StartRect.iBottom = iStartY + uiOrigHeight;

	// The destination is the top left corner of the slot in zoomed view. Its height and width are defined by
	// the size of a zoomed slot. Again, since we've already altered all the offsets, we can use them now to calculate
	// that position and size.
	DstRect.iLeft = (INT32)( MAP_INVENTORY_POOL_SLOT_OFFSET_X + MAP_INVENTORY_POOL_SLOT_START_X + ( ( MAP_INVEN_SPACE_BTWN_SLOTS ) * ( iCounterZoomed / MAP_INV_SLOT_COLS ) ) );
	DstRect.iTop = (INT32)( MAP_INVENTORY_POOL_SLOT_START_Y + ( ( MAP_INVEN_SLOT_HEIGHT ) * ( iCounterZoomed % ( MAP_INV_SLOT_COLS ) ) ) );
	DstRect.iRight = DstRect.iLeft + MAP_INVEN_SLOT_WIDTH;
	DstRect.iBottom = DstRect.iTop + MAP_INVEN_SLOT_HEIGHT;

	// Calculate Deltas
	
	// Movement of the sprite's top-left corner
	INT32 iDeltaX = DstRect.iLeft - StartRect.iLeft;
	INT32 iDeltaY = DstRect.iTop - StartRect.iTop;
	// Change in width and height
	INT32 iDeltaWidth = (DstRect.iRight - DstRect.iLeft) - (StartRect.iRight - StartRect.iLeft);
	INT32 iDeltaHeight = (DstRect.iBottom - DstRect.iTop) - (StartRect.iBottom - StartRect.iTop);

	// Set transition time and other variables.
	uiTimeRange = 400;
	iPercentage = iRealPercentage = 0;
	uiStartTime = GetJA2Clock();

	// Loud click!
	PlayJA2Sample( 202, RATE_11025, HIGHVOLUME, 1, MIDDLEPAN );

	//////////////////////////////////////////////////////////////////////////////////////////////////////
	// ANIMATE
	
	while( iPercentage < 100	)
	{
		// The animation process is quite simple, and is done in a more simple fashion than the Laptop transition
		// as well - though the principle is the same.
		// We first blit the background into the frame buffer to draw it on the screen. Then we calculate the current
		// size and position of the sprite, and blit it to the frame buffer as well.
		// By tracking the time on the clock we can figure out where the sprite should be at any given time,
		// how large it should be, and also use effects to make it look cooler.
		
		// First of all, blit the Map Inventory back from the SAVEBUFFER into the FRAMEBUFFER, so that it gets
		// drawn on the screen as a background. We don't need to draw the entire screen - at least not yet...
		BlitBufferToBuffer( guiSAVEBUFFER, FRAME_BUFFER, INVEN_POOL_X, INVEN_POOL_Y, SCREEN_WIDTH-INVEN_POOL_X, SCREEN_HEIGHT-INVEN_POOL_Y);

		// Get the current time
		uiCurrTime = GetJA2Clock();
		// Compare it to the current time to get a percentage. This signifies how much of the animation has been
		// done.
		iPercentage = (uiCurrTime-uiStartTime) * 100 / uiTimeRange;
		// Can't be more than 100%, duh.
		iPercentage = min( iPercentage, 100 );

		// To make a "falling" effect, we bias the percentage. I'm not sure how the maths work, but they do.
		INT32 iScalePercentage = iPercentage;
		INT32 iFactor = (iScalePercentage - 50) * 2;
		if( iScalePercentage < 50 )
			iScalePercentage = (UINT32)(iScalePercentage + iScalePercentage * iFactor * 0.01 + 0.5);
		else
			iScalePercentage = (UINT32)(iScalePercentage + (100-iScalePercentage) * iFactor * 0.01 + 0.5);

		// Find the width and height the sprite at this time.
		iWidth = (INT32)(uiOrigWidth + (INT32)(( iDeltaWidth * iScalePercentage ) / 100));
		iHeight = (INT32)(uiOrigHeight + (INT32)(( iDeltaHeight * iScalePercentage ) / 100));
		// Find the sprite's current X,Y coordinates
		iX = (INT32)(iStartX + (INT32)(( iDeltaX * iScalePercentage ) / 100));
		iY = (INT32)(iStartY + (INT32)(( iDeltaY * iScalePercentage ) / 100));

		// Set the position and size of the rectangle on which we'll draw this sprite.
		CurRect.iLeft = iX;
		CurRect.iRight = iX + iWidth;
		CurRect.iTop = iY;
		CurRect.iBottom = iY + iHeight;

		// Stretch the image of the sprite, still stored in the EXTRABUFFER, to its correct
		// size and position on the FRAMEBUFFER, essentially drawing it on the screen on top of
		// the background.
		BltStretchVideoSurface( FRAME_BUFFER, guiEXTRABUFFER, 0, 0, 0, &SrcRect, &CurRect );

		// Something....
		InvalidateScreen();

		// Some other thing...
		RefreshScreen( NULL );
	}
	// Unload the image of the item we just animated. Yeah, we'll be using it in two seconds for drawing
	// the zoomed inventory page, but it's safer if it doesn't exist in memory anymore. I'm not good enough
	// to figure out whether this is necessary :)
	UnloadMapInventoryBigItemGraphic( iCounterZoomed );

	// Dirty!
	fMapPanelDirty=TRUE;
}

// HEADROCK HAM 5: This function sorts all ammo items in the inventory into crates. It is the same operation
// performed when pressing CTRL+SHIFT+A in the Tactical screen, except it works directly with the sector
// inventory. Most of the function was ripped from that function - with several significant changes. For one,
// the program never looks at any mercs' crates-in-hand.
void SortSectorInventoryAmmo(bool useBoxes)
{
	
	// Declarations
	INT32		crateItem;
	bool		mergeSuccessful, ammoPresent;
	OBJECTTYPE	newCrate;
	int loopCount = 0;

	SOLDIERTYPE * pSoldier = &(Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ]);
	
	AssertMsg( pSoldier != NULL, "Sector Inventory: Attempting ammo sort without valid selected soldier?" );

	//MM: added for ammo boxes
	ammoPresent = true;
	UINT8 magType = AMMO_CRATE;
	if (useBoxes)
		magType = AMMO_BOX;

	// Get the original size of the inventory.
	UINT32 uiOrigInvSize = pInventoryPoolList.size();

	while (ammoPresent && loopCount <= 10 )
	{
		// Start scanning through the entire Sector Inventory pool.
		for(UINT32 iInvCounter = 0; iInvCounter < uiOrigInvSize; iInvCounter++)
		{
			// Set values
			crateItem = 0;
			mergeSuccessful = false;

			// Skip objects that don't exist (empty slots)
			if(pInventoryPoolList[iInvCounter].object.exists() == false)
			{
				continue;
			}
		
			// Store a pointer to this object and record its item number
			OBJECTTYPE *pCurObject = &(pInventoryPoolList[iInvCounter].object);
			UINT16 usCurItem = pCurObject->usItem;

			// If the object....
			if(Item[usCurItem].usItemClass & IC_AMMO && // Is an ammo item
				Magazine[Item[usCurItem].ubClassIndex].ubMagType != magType && // MM: Is not current crate/box selection
				pInventoryPoolList[iInvCounter].usFlags & WORLD_ITEM_REACHABLE && // Is reachable
				!(pInventoryPoolList[iInvCounter].usFlags & WORLD_ITEM_ARMED_BOMB) ) // Is not boobytrapped!
			{
				// We have a valid, ammo item - one or more magazines. We'll want to dump as much ammo from them
				// as possible into crates. 

				// Look through all items in the game to try and find an ammocrate that can contain this kind of ammo.
				for(int iCrateLoop = 0; iCrateLoop < MAXITEMS; iCrateLoop++)
				{
					// Is it the right ammo crate?
					if( Item[iCrateLoop].usItemClass == IC_AMMO &&
						Magazine[Item[iCrateLoop].ubClassIndex].ubMagType == magType && // An ammo crate or box
						Magazine[Item[iCrateLoop].ubClassIndex].ubCalibre == Magazine[Item[usCurItem].ubClassIndex].ubCalibre && //Same caliber
						Magazine[Item[iCrateLoop].ubClassIndex].ubAmmoType == Magazine[Item[usCurItem].ubClassIndex].ubAmmoType ) // Same ammotype
					{
						// Found a crate for this ammo.
						crateItem = iCrateLoop;
						break;
					}
				}

				// Have we found a crate?
				if(crateItem != 0)
				{
					// Excellent. Let see if a crate like this already exists in the Sector Inventory.
					for(UINT32 iInvCounter2=0; iInvCounter2 < pInventoryPoolList.size(); iInvCounter2++)
					{
						// Non-empty slots please...
						if(pInventoryPoolList[iInvCounter2].object.exists() == true)
						{
							// Is it our crate item?
							if (pInventoryPoolList[iInvCounter2].object.usItem == crateItem)
							{
								// Try pouring our ammo into this crate.
								DistributeStatus(pCurObject, &(pInventoryPoolList[iInvCounter2].object), Magazine[Item[crateItem].ubClassIndex].ubMagSize);
								// If the ammo magazine disappeared, that means we were successful in passing all
								// ammo from it to the crate.
								if(pCurObject->ubNumberOfObjects < 1)
								{
									mergeSuccessful = true;
									// Delete the magazine, it's empty anyway.
									DeleteObj( pCurObject );
									break;
								}
								// If we've reched this point, then we've still got ammo to distribute. Keep
								// looking through the inventory for additional crates to dump it into.
							}
						}
					}
					// Did we find enough crates and dumped all our ammo into them?
					if(mergeSuccessful == false)
					{
						// Hmm, so we need to create a new crate.
						CreateAmmo(crateItem, &newCrate, 0);
						// Dump all the ammo into it.
						DistributeStatus(pCurObject, &newCrate, Magazine[Item[crateItem].ubClassIndex].ubMagSize);
						// Place it in the sector inventory.
						AutoPlaceObjectToWorld( pSoldier, &newCrate, true );
						// Ran out of magazines?
						if(pCurObject->ubNumberOfObjects < 1)
						{
							// Excellent, we're done.
							mergeSuccessful = true;
							// Delete this magazine item.
							DeleteObj( pCurObject );
						}
					}
				}
			}
		}

		// if we added to / created a box/crate, then we're fine to reset this
		if ( mergeSuccessful )
			loopCount = 0;

		//MM: loop through ammo multiple times, as boxes and crates may take a few passes to fill
		ammoPresent = false;
		for(unsigned int i = 0; i < pInventoryPoolList.size(); i++)
		{
			if(Item[pInventoryPoolList[i].object.usItem].usItemClass == IC_AMMO && pInventoryPoolList[i].bVisible == TRUE && pInventoryPoolList[i].fExists && (pInventoryPoolList[i].usFlags & WORLD_ITEM_REACHABLE) && !(pInventoryPoolList[i].usFlags & WORLD_ITEM_ARMED_BOMB))
			{
				if(Magazine[Item[pInventoryPoolList[i].object.usItem].ubClassIndex].ubMagType == magType)
					continue;

				loopCount++;
				ammoPresent = true;
				break;
			}
		}

		SortSectorInventoryStackAndMerge(true);
	}
	// FINISHED
	CHAR16 pStr[500];
	swprintf( pStr, gzMapInventorySortingMessage[ 0 ], 'A' + sSelMapY - 1, sSelMapX );
	ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, pStr );

	// Dirty!
	fMapPanelDirty=TRUE;
}

// HEADROCK HAM 5: This function removed all ammunition from each item in the sector inventory. It is the same
// as the SHIFT+F function, except it deals directly with the sector inventory pool rather than the WorldItems list.
void SortSectorInventoryEjectAmmo()
{
	OBJECTTYPE gTempObject;
	
	SOLDIERTYPE * pSoldier = &(Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ]);

	for ( UINT32 uiLoop = 0; uiLoop < pInventoryPoolList.size(); uiLoop++ ) //for all items in sector
	{
		if ( pInventoryPoolList[uiLoop].bVisible == TRUE && // Visible
			pInventoryPoolList[uiLoop].object.exists() == true && // Exists
			pInventoryPoolList[uiLoop].usFlags & WORLD_ITEM_REACHABLE && // Reachable
			!(pInventoryPoolList[uiLoop].usFlags & WORLD_ITEM_ARMED_BOMB) ) // Not booby-trapped!
		{
			if (Item[ pInventoryPoolList[uiLoop].object.usItem ].usItemClass & IC_GUN) // Is a gun?
			{
				// Iterate through stacks
				for (int x = 0; x < pInventoryPoolList[uiLoop].object.ubNumberOfObjects; ++x) 
				{
					//Remove magazine
					if ( (pInventoryPoolList[uiLoop].object[x]->data.gun.usGunAmmoItem != NONE) && (pInventoryPoolList[uiLoop].object[x]->data.gun.ubGunShotsLeft > 0) )
					{
						CreateAmmo(pInventoryPoolList[uiLoop].object[x]->data.gun.usGunAmmoItem, &gTempObject, pInventoryPoolList[uiLoop].object[x]->data.gun.ubGunShotsLeft);
						pInventoryPoolList[uiLoop].object[x]->data.gun.ubGunShotsLeft = 0;
						pInventoryPoolList[uiLoop].object[x]->data.gun.usGunAmmoItem = NONE;
						// HEADROCK HAM 3.5: Clear ammo type
						pInventoryPoolList[uiLoop].object[x]->data.gun.ubGunAmmoType = NONE;

						// put it on the ground
						AutoPlaceObjectToWorld( pSoldier, &gTempObject, true );

						// Check...
						if (&gTempObject != NULL)
						{
							DeleteObj( &gTempObject );
						}
					}
				}
			}
		}
	}
	// "FINISHED"
	CHAR16 pStr[500];
	swprintf( pStr, gzMapInventorySortingMessage[ 2 ], 'A' + sSelMapY - 1, sSelMapX );
	ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, pStr );

	// Dirty!
	fMapPanelDirty=TRUE;
}

void SortSectorInventorySeparateAttachments()
{

	OBJECTTYPE gTempObject;
	
	SOLDIERTYPE * pSoldier = &(Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ]);

	for ( UINT32 uiLoop = 0; uiLoop < pInventoryPoolList.size(); uiLoop++ ) //for all items in sector
	{
		if ( pInventoryPoolList[uiLoop].bVisible == TRUE && // Visible
			pInventoryPoolList[uiLoop].object.exists() == true && // Exists
			pInventoryPoolList[uiLoop].usFlags & WORLD_ITEM_REACHABLE && // Reachable
			!(pInventoryPoolList[uiLoop].usFlags & WORLD_ITEM_ARMED_BOMB) ) // Not booby-trapped!
		{

			// Iterate through stacks
			for (int x = 0; x < pInventoryPoolList[uiLoop].object.ubNumberOfObjects; ++x) 
			{
				UINT8 cnt = 0, uiLoopCnt = 0;

				while(pInventoryPoolList[uiLoop].object[x]->attachments.size() != cnt)
				{
					gTempObject = *(pInventoryPoolList[uiLoop].object[x]->GetAttachmentAtIndex(cnt));

					//WarmSteel - This actually still works with NAS, be it by accident
					if (pInventoryPoolList[uiLoop].object.RemoveAttachment(&gTempObject,0,x))
					{
						AutoPlaceObjectToWorld( pSoldier, &gTempObject, true );
						if (&gTempObject != NULL)
						{
							DeleteObj( &gTempObject );
						}
					}
					else
					{
						cnt++;
					}

					uiLoopCnt ++;

					// Failsafe
					if(uiLoopCnt > 100)
					{
						break;
					}
				}
			}
		}
	}
	// "FINISHED"
	CHAR16 pStr[500];
	swprintf( pStr, gzMapInventorySortingMessage[ 1 ], 'A' + sSelMapY - 1, sSelMapX );
	ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, pStr );

	// Dirty!
	fMapPanelDirty=TRUE;
}

// HEADROCK HAM 5: This function sorts all inventory items into stacks. It is similar to a hotkey-driven
// function that normally runs only in tactical mode, except it has been altered to work directly with the
// sector inventory pool.
void SortSectorInventoryStackAndMerge(bool ammoOnly )
{
	OBJECTTYPE * StackObject;
	
	SOLDIERTYPE * pSoldier = &(Menptr[ gCharactersList[ bSelectedInfoChar ].usSolID ]);

	// Run through sector inventory.
	for ( UINT32 uiLoop = 0; uiLoop < pInventoryPoolList.size(); uiLoop++ )
	{
		if ( pInventoryPoolList[ uiLoop ].bVisible == TRUE && // Visible
			pInventoryPoolList[ uiLoop ].object.exists() == true && // Exists
			pInventoryPoolList[ uiLoop ].usFlags & WORLD_ITEM_REACHABLE &&  // Reachable
			!(pInventoryPoolList[ uiLoop ].usFlags & WORLD_ITEM_ARMED_BOMB) ) // Not boobytrapped!
		{
			if ( ammoOnly && Item[pInventoryPoolList[uiLoop].object.usItem].usItemClass != IC_AMMO )
				continue;

			// Set this as the stack into which we'll try to pool all other items of this type.
			StackObject = &(pInventoryPoolList[uiLoop].object);
			UINT16 usStackItem = StackObject->usItem;

			// Check whether there are any other objects of the same type that we can add to this stack.
			// We run only forward through the inventory, thus skipping any stacks that have already been checked.
			for(UINT32 i = uiLoop+1; i < pInventoryPoolList.size(); i++)
			{
				// Did we encounter a valid item of the same type?
				if(pInventoryPoolList[i].object.usItem == usStackItem && // Same type
					pInventoryPoolList[i].bVisible == TRUE && // Visible
					pInventoryPoolList[i].object.exists() == true && // Exists
					pInventoryPoolList[i].usFlags & WORLD_ITEM_REACHABLE && // Reachable
					!(pInventoryPoolList[i].usFlags & WORLD_ITEM_ARMED_BOMB) ) // Not boobytrapped!
				{
					// Add it to the stack!
					StackObject->AddObjectsToStack(pInventoryPoolList[i].object, -1, NULL, NUM_INV_SLOTS, MAX_OBJECTS_PER_SLOT, false);

					// Have we removed all items from the secondary stack?
					if( pInventoryPoolList[i].object.exists() == false )
					{
						// Destroy it. 
						DeleteObj( &(pInventoryPoolList[i].object) );
					}
				}
			}
			//merge items in stack
			CleanUpStack(StackObject, NULL);

			// Pick up the stack, and place it back into the inventory. That will sort items back into any empty
			// slots.

			// Create a new object, same as this stack.
			OBJECTTYPE TempStack;
			TempStack.initialize();
			TempStack = pInventoryPoolList[ uiLoop ].object;

			// Erase the original from its position in the inventory.
			pInventoryPoolList[ uiLoop ].bVisible = FALSE;
			pInventoryPoolList[ uiLoop ].fExists = FALSE;
			DeleteObj( &(pInventoryPoolList[ uiLoop ].object) );

			// Place the duplicate into the inventory, filling any gaps.
			AutoPlaceObjectToWorld( pSoldier, &TempStack, TRUE );
			if (TempStack.exists() == true )
			{
				DeleteObj( &TempStack );
			}
		}
	}
	// "FINISHED"
	CHAR16 pStr[500];
	swprintf( pStr, gzMapInventorySortingMessage[ 3 ], 'A' + sSelMapY - 1, sSelMapX );
	ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, pStr );

	// Dirty!
	fMapPanelDirty = TRUE;
}

// HEADROCK HAM 5: This is a helper function that puts together all seen and unseen items from the two
// sector-inventory pools, and then rebuilds the pool. By changing the flags used by the function that tests
// whether an item should appear in the "SEEN" list, we can create filters to show or hide specific items.
//
// NOTE: Never run this function when the pool is closed or not yet created!
void RefreshSeenAndUnseenPools()
{
	INT32 iItemCount = 0;

	// Create a new itemlist to contain all items in the sector. This is a CPU-cheap alternative to saving them
	// into the tempfile WorldItems list.
	WORLDITEM *pItemsList = NULL;
	// What is the number of items currently seen in the Sector Inventory?
	INT32 iTotalNumberSeenItems = GetTotalNumberOfItems( );
	// The number of Unseen items is stored in a global, so lets use it to figure out how many items are in
	// this sector inventory IN TOTAL.
	INT32 iTotalNumItems = iTotalNumberSeenItems + uiNumberOfUnSeenItems;

	// Any items?
	if( iTotalNumItems > 0 )
	{
		// Point to a new array that will hold all these items.
		pItemsList = new WORLDITEM[ iTotalNumItems ];

		///////////////////
		// Copy all items from the SEEN inventory
		//
		// These are basically the items seen in the sector inventory view at the moment. The are stored in the
		// main inventory list, the pInventoryPoolList. Lets go through each item on this list.
		for( UINT32 iCounter = 0; iCounter < pInventoryPoolList.size(); iCounter++ )
		{
			// Does it exist? (skip empty slots)
			if( pInventoryPoolList[ iCounter ].object.exists() == true )
			{
				// Copy it into the master pool.
				pItemsList[ iItemCount ] = pInventoryPoolList[ iCounter ];

				// Set it as true and existing... though I'm pretty sure this is unnecessary.
				pItemsList[ iItemCount ].fExists = TRUE;
				pItemsList[ iItemCount ].bVisible = TRUE;
				// Count the number of items we've copied over.
				iItemCount++;
			}
		}
		/////////////////
		// Copy all items from the UNSEEN inventory
		//
		// Unseen items are stored in memory, and their quantity is also stored. This is a
		// separate list from the main inventory.
		// Originally this list only contained items which have not yet been spotted by any
		// merc, including buried items etc. With filters, they now include all items that
		// have been filtered out during the previous Stash Build.
		for( UINT32 iCounter = 0; iCounter < uiNumberOfUnSeenItems; iCounter++ )
		{
			// Skip any empty slots... though there shouldn't be any.
			if (pUnSeenItems[ iCounter ].object.exists() == true )
			{
				// Copy into the master list.
				pItemsList[ iItemCount ] = pUnSeenItems[ iCounter ];

				// Count the number of items we've copied over.
				iItemCount++;
			}
		}
	}

	// Clear both the SEEN and UNSEEN lists.
	pInventoryPoolList.clear();
	pUnSeenItems = NULL;

	INT32 iCurItem = 0;
	INT32 iNumUnseenItems = 0;

	// Do we have any items in the inventory?
	if (iItemCount > 0)
	{
		//////////////////////////////////////////////
		// SPLIT APART
		//
		// We now run through our master item list, splitting the items between the new SEEN
		// and UNSEEN inventories. This is where filters come into play.

		// Start with the SEEN list (the primary inventory). Make it large enough to contain
		// all the items, just in case.
		pInventoryPoolList.resize( iItemCount );

		// Run through the master pool...
		for (INT32 iCounter = 0; iCounter < iItemCount; iCounter++)
		{
			// Is the item visible? This takes into account FILTERS, which make items "invisible"
			// by class.
			if (IsMapScreenWorldItemVisibleInMapInventory( &pItemsList[ iCounter ] ))
			{
				// Add it to the SEEN list - the Sector Inventory Pool.
				pInventoryPoolList[ iCurItem ] = pItemsList[ iCounter ];
				iCurItem++;
			}
		}

		// If we have not yet processed all the items, it means that some are invisible.
		// How many UNSEEN items are there?
		iNumUnseenItems = iItemCount - iCurItem;

		if( iNumUnseenItems > 0 )
		{
			// Put them in the UNSEEN list.

			// Create a new UNSEEN pool of this size.
			pUnSeenItems = new WORLDITEM[ iNumUnseenItems ];

			iCurItem = 0;

			// Run through the master inventory.
			for( INT32 iCounter = 0; iCounter < iItemCount; iCounter++ )
			{
				// If item is NOT visible (including filters)
				if( IsMapScreenWorldItemInvisibleInMapInventory( &pItemsList[ iCounter ] ) )
				{
					// Add it to the UNSEEN pool.
					pUnSeenItems[ iCurItem ] = pItemsList[ iCounter ];

					iCurItem++;
				}
			}
		}
	}

	// Resize properly. This function makes sure that we have exactly as many pages as we need:
	// to contain all the items, to have empty enough space at the end, AND to avoid crashes
	// due to the sudden change in inventory size.
	ResizeInventoryList();

	// Store the number of unseen items in memory!
	uiNumberOfUnSeenItems = iNumUnseenItems;

	// Finally, resort the inventory.
	SortSectorInventory( pInventoryPoolList, pInventoryPoolList.size() );

}

void CreateMapInventoryFilterMenu( )
{
	///////////////////////////
	// CONSTRUCT POPUP MENU
	///////////////////////////
	// If we already have a popup, destroy it first. This ensures we get a fresh menu each time.
	if ( gfMapInventoryFilterPopupInitialized )
	{
		delete(gMapInventoryFilterPopup);
		gMapInventoryFilterPopup = NULL;
		gfMapInventoryFilterPopupInitialized = FALSE;
		gfMapInventoryFilterPopupVisible = FALSE;
	}

	POPUP_OPTION *pOption;
	UINT32 uiFlags;

	// create a popup
	gMapInventoryFilterPopup = new POPUP("MAP INVENTORY FILTER MENU POPUP");	// at this point the name is used mainly for debug output
	
	// add a callback that lets the keyboard handler know we're done (and ready to pop up again)
	gMapInventoryFilterPopup->setCallback(POPUP_CALLBACK_HIDE, new popupCallbackFunction<void,void>( &MapInventoryFilterMenuPopup_Hide ) );
	
	CHAR16 pStr[300];

	// Create menu to toggle groups of item classes on and off individually.

	swprintf( pStr, gzMapInventoryFilterOptions[ 0 ] );
	// Add option: "SHOW ALL"
	uiFlags = IC_MAPFILTER_ALL;
	pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &MapInventoryFilterMenuPopup_FilterSet, uiFlags ) );
	if (guiMapInventoryFilter == IC_MAPFILTER_ALL)
	{
		// Set this option off.
		pOption->setAvail(new popupCallbackFunction<bool,TransformInfoStruct*>( &MapInventoryFilterMenuPopup_OptionOff, NULL ));
	}
	// Add the option to the menu.
	gMapInventoryFilterPopup->addOption( *pOption );

	if (guiMapInventoryFilter & IC_MAPFILTER_GUN)
	{
		// Hide guns
		swprintf( pStr, L"%s *", gzMapInventoryFilterOptions[ 1 ]  );
	}
	else
	{
		// Show guns
		swprintf( pStr, gzMapInventoryFilterOptions[ 1 ]  );
	}
	uiFlags = IC_MAPFILTER_GUN;
	pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &MapInventoryFilterMenuPopup_FilterToggle, uiFlags ) );
	gMapInventoryFilterPopup->addOption( *pOption );

	if (guiMapInventoryFilter & IC_MAPFILTER_AMMO)
	{
		// Hide guns
		swprintf( pStr, L"%s *", gzMapInventoryFilterOptions[ 2 ]  );
	}
	else
	{
		// Show guns
		swprintf( pStr, gzMapInventoryFilterOptions[ 2 ] );
	}
	uiFlags = IC_MAPFILTER_AMMO;
	pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &MapInventoryFilterMenuPopup_FilterToggle, uiFlags ) );
	gMapInventoryFilterPopup->addOption( *pOption );

	if (guiMapInventoryFilter & IC_MAPFILTER_EXPLOSV)
	{
		// Hide guns
		swprintf( pStr, L"%s *", gzMapInventoryFilterOptions[ 3 ] );
	}
	else
	{
		// Show guns
		swprintf( pStr, gzMapInventoryFilterOptions[ 3 ] );
	}
	uiFlags = IC_MAPFILTER_EXPLOSV;
	pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &MapInventoryFilterMenuPopup_FilterToggle, uiFlags ) );
	gMapInventoryFilterPopup->addOption( *pOption );

	if (guiMapInventoryFilter & IC_MAPFILTER_MELEE)
	{
		// Hide guns
		swprintf( pStr, L"%s *", gzMapInventoryFilterOptions[ 4 ] );
	}
	else
	{
		// Show guns
		swprintf( pStr, gzMapInventoryFilterOptions[ 4 ] );
	}
	uiFlags = IC_MAPFILTER_MELEE;
	pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &MapInventoryFilterMenuPopup_FilterToggle, uiFlags ) );
	gMapInventoryFilterPopup->addOption( *pOption );

	if (guiMapInventoryFilter & IC_MAPFILTER_ARMOR)
	{
		// Hide guns
		swprintf( pStr, L"%s *", gzMapInventoryFilterOptions[ 5 ] );
	}
	else
	{
		// Show guns
		swprintf( pStr, gzMapInventoryFilterOptions[ 5 ] );
	}
	uiFlags = IC_MAPFILTER_ARMOR;
	pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &MapInventoryFilterMenuPopup_FilterToggle, uiFlags ) );
	gMapInventoryFilterPopup->addOption( *pOption );

	if (guiMapInventoryFilter & IC_MAPFILTER_LBE)
	{
		// Hide guns
		swprintf( pStr, L"%s *", gzMapInventoryFilterOptions[ 6 ] );
	}
	else
	{
		// Show guns
		swprintf( pStr, gzMapInventoryFilterOptions[ 6 ] );
	}
	uiFlags = IC_MAPFILTER_LBE;
	pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &MapInventoryFilterMenuPopup_FilterToggle, uiFlags ) );
	gMapInventoryFilterPopup->addOption( *pOption );

	if (guiMapInventoryFilter & IC_MAPFILTER_KIT)
	{
		// Hide guns
		swprintf( pStr, L"%s *", gzMapInventoryFilterOptions[ 7 ] );
	}
	else
	{
		// Show guns
		swprintf( pStr, gzMapInventoryFilterOptions[ 7 ] );
	}
	uiFlags = IC_MAPFILTER_KIT;
	pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &MapInventoryFilterMenuPopup_FilterToggle, uiFlags ) );
	gMapInventoryFilterPopup->addOption( *pOption );

	if (guiMapInventoryFilter & IC_MAPFILTER_MISC)
	{
		// Hide guns
		swprintf( pStr, L"%s *", gzMapInventoryFilterOptions[ 8 ] );
	}
	else
	{
		// Show guns
		swprintf( pStr, gzMapInventoryFilterOptions[ 8 ] );
	}
	uiFlags = IC_MAPFILTER_MISC;
	pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &MapInventoryFilterMenuPopup_FilterToggle, uiFlags ) );
	gMapInventoryFilterPopup->addOption( *pOption );

	swprintf( pStr, gzMapInventoryFilterOptions[ 9 ] );
	// Add option: "HIDE ALL"
	uiFlags = 0;
	pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &MapInventoryFilterMenuPopup_FilterSet, uiFlags ) );
	if (guiMapInventoryFilter == 0)
	{
		// Set this option off.
		pOption->setAvail(new popupCallbackFunction<bool,TransformInfoStruct*>( &MapInventoryFilterMenuPopup_OptionOff, NULL ));
	}
	// Add the option to the menu.
	gMapInventoryFilterPopup->addOption( *pOption );


	UINT16 usPosX;
	UINT16 usPosY;

	usPosX = ButtonList[guiMapInvenFilterButton[ 0 ]]->XLoc;
	usPosY = ButtonList[guiMapInvenFilterButton[ 0 ]]->Area.RegionBottomRightY;

	gMapInventoryFilterPopup->setPosition( usPosX, usPosY );

	gfMapInventoryFilterPopupInitialized = TRUE;
	gfMapInventoryFilterPopupVisible = TRUE;
	gfQueueRecreateMapInventoryFilterMenu = FALSE;
	gMapInventoryFilterPopup->show();
}

// HEADROCK HAM 5: This function alters the Map Inventory Filter, by applying the argument as a flag toggle
// (XOR) to the current filter set.
// As a result of the alteration, some items will disappear from view - though they are still kept in 
// memory as "Unseen" items.
void MapInventoryFilterMenuPopup_FilterToggle( UINT32 uiFlags )
{
	// Hide the Filter Menu pop-up.
	if (gMapInventoryFilterPopup != NULL && gfMapInventoryFilterPopupInitialized == TRUE)
	{
		gMapInventoryFilterPopup->hide();
	}
	
	// Alter the filter based on the flags we want. This is a XOR operation, so we're basically
	// toggling the correct bits in the filter on-and-off. The bits correspond to the various
	// item classes - though they are often toggled in groups (i.e. Guns + Launchers, Kits + Medkits + Camokits, etc.)
	guiMapInventoryFilter ^= uiFlags;
	// The refresh function moves the necessary items from the Seen to the Unseen inventories, and vice versa.
	RefreshSeenAndUnseenPools();

	BlitInventoryPoolGraphic( );

	// Toggling these flags back on serves to cause the menu to stay open - yet refresh its options. As a result,
	// we can keep clicking on the various options to see the items appear/disappear, and the options change to indicate
	// this as well.
	gfMapInventoryFilterPopupVisible = TRUE;
	gfQueueRecreateMapInventoryFilterMenu = TRUE;
}

// HEADROCK HAM 5: This function alters the Map Inventory Filter, by applying the argument as a flag set
// (=) to the current filter set.
// As a result of the alteration, some items will disappear from view - though they are still kept in 
// memory as "Unseen" items.
void MapInventoryFilterMenuPopup_FilterSet( UINT32 uiFlags )
{
	// Hide the Filter Menu pop-up.
	if (gMapInventoryFilterPopup != NULL && gfMapInventoryFilterPopupInitialized == TRUE)
	{
		gMapInventoryFilterPopup->hide();
	}
	
	// Alter the filter based on the flags we want. This is a XOR operation, so we're basically
	// toggling the correct bits in the filter on-and-off. The bits correspond to the various
	// item classes - though they are often toggled in groups (i.e. Guns + Launchers, Kits + Medkits + Camokits, etc.)
	guiMapInventoryFilter = uiFlags;
	// The refresh function moves the necessary items from the Seen to the Unseen inventories, and vice versa.
	RefreshSeenAndUnseenPools();

	BlitInventoryPoolGraphic( );

	// Toggling these flags back on serves to cause the menu to stay open - yet refresh its options. As a result,
	// we can keep clicking on the various options to see the items appear/disappear, and the options change to indicate
	// this as well.
	gfMapInventoryFilterPopupVisible = TRUE;
	gfQueueRecreateMapInventoryFilterMenu = TRUE;
}

void MapInventoryFilterMenuPopup_Hide( void )
{
	// When the pop-up goes away, the button that spawned it is popped back to the OFF position.
	ButtonList[ guiMapInvenFilterButton[ 0 ] ]->uiFlags &=~ (BUTTON_CLICKED_ON);

	// Signal the renderer to stop drawing this menu.
	gfMapInventoryFilterPopupVisible = FALSE;
	// Dirty!
	fMapPanelDirty = TRUE;
}

BOOLEAN MapInventoryFilterMenuPopup_OptionOff( void )
{
	// Turns an option off by always returning FALSE
	return FALSE;
}

// HEADROCK HAM 5: Alternative functions that alter the inventory filter without the need for a popup.
void MapInventoryFilterToggle( UINT32 uiFlags )
{
	// Alter the filter based on the flags we want. This is a XOR operation, so we're basically
	// toggling the correct bits in the filter on-and-off. The bits correspond to the various
	// item classes - though they are often toggled in groups (i.e. Guns + Launchers, Kits + Medkits + Camokits, etc.)
	guiMapInventoryFilter ^= uiFlags;
	// The refresh function moves the necessary items from the Seen to the Unseen inventories, and vice versa.
	RefreshSeenAndUnseenPools();

	BlitInventoryPoolGraphic( );

	HandleSetFilterButtons();
}

void MapInventoryFilterSet( UINT32 uiFlags )
{
	// Alter the filter based on the flags we want. This is a XOR operation, so we're basically
	// toggling the correct bits in the filter on-and-off. The bits correspond to the various
	// item classes - though they are often toggled in groups (i.e. Guns + Launchers, Kits + Medkits + Camokits, etc.)
	guiMapInventoryFilter = uiFlags;
	// The refresh function moves the necessary items from the Seen to the Unseen inventories, and vice versa.
	RefreshSeenAndUnseenPools();

	BlitInventoryPoolGraphic( );

	HandleSetFilterButtons();
}

// HEADROCK HAM 5: Handle toggling the buttons on and off depending on which filters are shown.
void HandleSetFilterButtons()
{
	// Show/Hide All button always off.
	ButtonList[guiMapInvenFilterButton[ 0 ]]->uiFlags &=~ (BUTTON_CLICKED_ON);

	// Guns
	if (guiMapInventoryFilter & IC_MAPFILTER_GUN)
	{
		ButtonList[guiMapInvenFilterButton[ 1 ]]->uiFlags |= (BUTTON_CLICKED_ON);
	}
	else
	{
		ButtonList[guiMapInvenFilterButton[ 1 ]]->uiFlags &=~ (BUTTON_CLICKED_ON);
	}

	// Ammo
	if (guiMapInventoryFilter & IC_MAPFILTER_AMMO)
	{
		ButtonList[guiMapInvenFilterButton[ 2 ]]->uiFlags |= (BUTTON_CLICKED_ON);
	}
	else
	{
		ButtonList[guiMapInvenFilterButton[ 2 ]]->uiFlags &=~ (BUTTON_CLICKED_ON);
	}

	// Explosives
	if (guiMapInventoryFilter & IC_MAPFILTER_EXPLOSV)
	{
		ButtonList[guiMapInvenFilterButton[ 3 ]]->uiFlags |= (BUTTON_CLICKED_ON);
	}
	else
	{
		ButtonList[guiMapInvenFilterButton[ 3 ]]->uiFlags &=~ (BUTTON_CLICKED_ON);
	}

	// Melee Weapons
	if (guiMapInventoryFilter & IC_MAPFILTER_MELEE)
	{
		ButtonList[guiMapInvenFilterButton[ 4 ]]->uiFlags |= (BUTTON_CLICKED_ON);
	}
	else
	{
		ButtonList[guiMapInvenFilterButton[ 4 ]]->uiFlags &=~ (BUTTON_CLICKED_ON);
	}

	// Armor
	if (guiMapInventoryFilter & IC_MAPFILTER_ARMOR)
	{
		ButtonList[guiMapInvenFilterButton[ 5 ]]->uiFlags |= (BUTTON_CLICKED_ON);
	}
	else
	{
		ButtonList[guiMapInvenFilterButton[ 5 ]]->uiFlags &=~ (BUTTON_CLICKED_ON);
	}

	// LBEs
	if (guiMapInventoryFilter & IC_MAPFILTER_LBE)
	{
		ButtonList[guiMapInvenFilterButton[ 6 ]]->uiFlags |= (BUTTON_CLICKED_ON);
	}
	else
	{
		ButtonList[guiMapInvenFilterButton[ 6 ]]->uiFlags &=~ (BUTTON_CLICKED_ON);
	}

	// Kits
	if (guiMapInventoryFilter & IC_MAPFILTER_KIT)
	{
		ButtonList[guiMapInvenFilterButton[ 7 ]]->uiFlags |= (BUTTON_CLICKED_ON);
	}
	else
	{
		ButtonList[guiMapInvenFilterButton[ 7 ]]->uiFlags &=~ (BUTTON_CLICKED_ON);
	}

	// Misc. Items
	if (guiMapInventoryFilter & IC_MAPFILTER_MISC)
	{
		ButtonList[guiMapInvenFilterButton[ 8 ]]->uiFlags |= (BUTTON_CLICKED_ON);
	}
	else
	{
		ButtonList[guiMapInvenFilterButton[ 8 ]]->uiFlags &=~ (BUTTON_CLICKED_ON);
	}
}