/*
	FinalSun/FinalAlert 2 Mission Editor

	Copyright (C) 1999-2024 Electronic Arts, Inc.
	Authored by Matthias Wagner

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

// ViewObjects.cpp: Implementierungsdatei
//

#include "stdafx.h"
#include "FinalSun.h"
#include "ViewObjects.h"
#include "FinalSunDlg.h"
#include "structs.h"
#include "mapdata.h"
#include "variables.h"
#include "functions.h"
#include "inlines.h"
#include "rtpdlg.h"
#include "TubeTool.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CViewObjects

const int valadded = 10000;

IMPLEMENT_DYNCREATE(CViewObjects, CTreeView)

CViewObjects::CViewObjects()
{
	m_ready = FALSE;

}

CViewObjects::~CViewObjects()
{
}


BEGIN_MESSAGE_MAP(CViewObjects, CTreeView)
	//{{AFX_MSG_MAP(CViewObjects)
	ON_NOTIFY_REFLECT(TVN_SELCHANGED, OnSelchanged)
	ON_WM_CREATE()
	ON_NOTIFY_REFLECT(TVN_KEYDOWN, OnKeydown)
	ON_WM_KEYDOWN()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


extern int overlay_number[];
extern CString overlay_name[];
extern BOOL overlay_visible[];
extern BOOL overlay_trail[];


extern int overlay_count;


extern ACTIONDATA AD;

/////////////////////////////////////////////////////////////////////////////
// Zeichnung CViewObjects 

void CViewObjects::OnDraw(CDC* pDC)
{
	CDocument* pDoc = GetDocument();
	// ZU ERLEDIGEN: Code zum Zeichnen hier einfügen
}

/////////////////////////////////////////////////////////////////////////////
// Diagnose CViewObjects

#ifdef _DEBUG
void CViewObjects::AssertValid() const
{
	CTreeView::AssertValid();
}

void CViewObjects::Dump(CDumpContext& dc) const
{
	CTreeView::Dump(dc);
}
#endif //_DEBUG

CString GetTheaterLanguageString(LPCSTR lpString)
{
	CString s = lpString;
	CString t = lpString;

	if ((tiledata) == &t_tiledata) t += "TEM";
	if ((tiledata) == &s_tiledata) t += "SNO";
	if ((tiledata) == &u_tiledata) t += "URB";
	if ((tiledata) == &un_tiledata) t += "UBN";
	if ((tiledata) == &l_tiledata) t += "LUN";
	if ((tiledata) == &d_tiledata) t += "DES";

	CString res = GetLanguageStringACP(t);
	if (res.GetLength() == 0) res = GetLanguageStringACP(s);

	return res;
}

/////////////////////////////////////////////////////////////////////////////
// Behandlungsroutinen für Nachrichten CViewObjects 


void CViewObjects::OnSelchanged(NMHDR* pNMHDR, LRESULT* pResult)
{
	CIniFile& ini = Map->GetIniFile();

	NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;

	int val = pNMTreeView->itemNew.lParam;
	if (val < 0) { // return;
		if (val == -2) {
			AD.reset();
			((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW);
		}
		return;
	}

	if (val < valadded) {
		// standard selection (maybe erasing etc)
		switch (val) {
		case 10: // erase field
		{
			AD.mode = ACTIONMODE_ERASEFIELD;
			break;
		}
		case 20: // waypoint stuff now
		{
			AD.mode = ACTIONMODE_WAYPOINT;
			AD.type = 0;
			break;
		}
		case 21:
		{
			AD.mode = 3;
			AD.type = 1;
			break;
		}
		case 22:
		{
			AD.mode = 3;
			AD.type = 2;
			break;
		}
		case 23:
		case 24:
		case 25:
		case 26:
		case 27:
		case 28:
		case 29:
		case 30:
		{
			AD.mode = 3;
			AD.type = 3 + val - 23;
			break;
		}
		case 36: // celltag stuff
		{
			AD.mode = 4;
			AD.type = 0;
			break;
		}
		case 37:
		{
			AD.mode = 4;
			AD.type = 1;
			break;
		}
		case 38:
		{
			AD.mode = 4;
			AD.type = 2;
			break;
		}
		case 40: // node stuff
		{
			AD.mode = 5;
			AD.type = 0;
			break;
		}
		case 41:
		{
			AD.mode = 5;
			AD.type = 1;
			break;
		}
		case 42:
		{
			AD.mode = 5;
			AD.type = 2;
			break;
		}
		case 50:
		{
			AD.mode = ACTIONMODE_MAPTOOL;
			AD.tool.reset(new AddTubeTool(*Map, *((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview, true));
			break;
		}
		case 51:
		{
			AD.mode = ACTIONMODE_MAPTOOL;
			AD.tool.reset(new ModifyTubeTool(*Map, *((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview, true));
			break;
		}
		case 52:
		{
			AD.mode = ACTIONMODE_MAPTOOL;
			AD.tool.reset(new AddTubeTool(*Map, *((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview, false));
			break;
		}
		case 53:
		{
			AD.mode = ACTIONMODE_MAPTOOL;
			AD.tool.reset(new ModifyTubeTool(*Map, *((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview, false));
			break;
		}
		case 54:
		{
			AD.mode = ACTIONMODE_MAPTOOL;
			AD.tool.reset(new RemoveTubeTool(*Map, *((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview));
			break;
		}

		case 61:
			if (!tiledata_count) break;
			AD.type = 0;
			AD.mode = ACTIONMODE_SETTILE;
			AD.data = 0;
			AD.z_data = 0;
			HandleBrushSize(0);
			break;

		case 62:
			int i;
			if (!tiledata_count) {
				break;
			}
			for (i = 0; i < (*tiledata_count); i++) {
				if ((*tiledata)[i].wTileSet == tiles->GetInteger("General", "SandTile")) {
					break;
				}
			}
			AD.type = i;
			AD.mode = ACTIONMODE_SETTILE;
			AD.data = 0;
			AD.z_data = 0;
			HandleBrushSize(i);
			break;
		case 63:
			if (!tiledata_count) {
				break;
			}
			for (i = 0; i < (*tiledata_count); i++) {
				if ((*tiledata)[i].wTileSet == tiles->GetInteger("General", "RoughTile")) {
					break;
				}
			}
			AD.type = i;
			AD.mode = ACTIONMODE_SETTILE;
			AD.data = 0;
			AD.z_data = 0;
			HandleBrushSize(i);
			break;
		case 64:
			if (!tiledata_count) break;
			for (i = 0; i < (*tiledata_count); i++)
				if ((*tiledata)[i].wTileSet == waterset) break;

			if (((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_x < 2 ||
				((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_y < 2) {

				((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.m_BrushSize = 1;
				((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.UpdateData(FALSE);
				((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_x = 2;
				((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_y = 2;
			}

			AD.type = i;
			AD.mode = ACTIONMODE_SETTILE;
			AD.data = 1;	 // use water placement logic
			AD.z_data = 0;
			break;
		case 65:
			if (!tiledata_count) {
				break;
			}
			for (i = 0; i < (*tiledata_count); i++) {
				if ((*tiledata)[i].wTileSet == tiles->GetInteger("General", "GreenTile")) {
					break;
				}
			}
			AD.type = i;
			AD.mode = ACTIONMODE_SETTILE;
			AD.data = 0;
			AD.z_data = 0;
			HandleBrushSize(i);
			break;
		case 66:
			if (!tiledata_count) {
				break;
			}
			for (i = 0; i < (*tiledata_count); i++) {
				if ((*tiledata)[i].wTileSet == tiles->GetInteger("General", "PaveTile")) {
					break;
				}
			}
			AD.type = i;
			AD.mode = ACTIONMODE_SETTILE;
			AD.data = 0;
			AD.z_data = 0;
			HandleBrushSize(i);
			break;
		case 67:
			if (!tiledata_count) {
				break;
			}
			for (i = 0; i < (*tiledata_count); i++) {
				if ((*tiledata)[i].wTileSet == g_data.GetInteger("NewUrbanInfo", "Morphable2")) {
					break;
				}
			}
			AD.type = i;
			AD.mode = ACTIONMODE_SETTILE;
			AD.data = 0;
			AD.z_data = 0;
			HandleBrushSize(i);
			break;


		}
	} else {
		int subpos = val % valadded;
		int pos = val / valadded;

		AD.mode = 1;
		AD.type = pos;
		AD.data = subpos;

		if (pos == 1) {
			CString sec = "InfantryTypes";

			if (subpos < rules[sec].Size()) {
				// standard unit!

				AD.data_s = rules[sec].Nth(subpos).second;
			} else {

				AD.data_s = ini[sec].Nth(subpos - rules[sec].Size()).second;
			}
		} else if (pos == 2) {
			CString sec = "BuildingTypes";

			if (subpos < rules[sec].Size()) {
				// standard unit!
				AD.data_s = rules[sec].Nth(subpos).second;
			} else {
				AD.data_s = ini[sec].Nth(subpos - rules[sec].Size()).second;
			}
		} else if (pos == 3) {
			CString sec = "AircraftTypes";

			if (subpos < rules[sec].Size()) {
				// standard unit!

				AD.data_s = rules[sec].Nth(subpos).second;
			} else {
				AD.data_s = ini[sec].Nth(subpos - rules[sec].Size()).second;
			}
		} else if (pos == 4) {
			CString sec = "VehicleTypes";

			if (subpos < rules[sec].Size()) {
				// standard unit!
				AD.data_s = rules[sec].Nth(subpos).second;
			} else {
				AD.data_s = ini[sec].Nth(subpos - rules[sec].Size()).second;
			}
		} else if (pos == 5) {

			CString sec = "TerrainTypes";

			if (subpos == 999) {

				CRTPDlg dlg;
				if (dlg.DoModal() == IDOK) {
					AD.mode = ACTIONMODE_RANDOMTERRAIN;
				}
			} else {
				if (subpos < rules[sec].Size()) {
					// standard unit!
					AD.data_s = rules[sec].Nth(subpos).second;
				} else {
					AD.data_s = ini[sec].Nth(subpos - rules[sec].Size()).second;
				}
			}
		} else if (pos == 6) {
			if (subpos < 100) {
				// general overlay functions!
				if (subpos == 1) {
					AD.data = 31;
					AD.data2 = atoi(InputBox("Please enter the value (0-255) of the overlay. Don´t exceed this range.", "Set overlay manually"));

				} else if (subpos == 2) {
					AD.data = 32;
					AD.data2 = atoi(InputBox("Please enter the value (0-255) of the overlay-data. Don´t exceed this range.", "Set overlay manually"));

				}

			} else {
				AD.data2 = subpos % 100;
				AD.data = subpos / 100;
				if (AD.data >= 30) {
					AD.data = 30;
					AD.data2 = subpos % 1000;
				}
			}
		} else if (pos == 7) {
			// set owner
			//if(ini.find(MAPHOUSES)!=ini.end() && ini[MAPHOUSES].Size()>0)
			if (ini[MAPHOUSES].Size() > 0) {
				AD.data_s = ini[MAPHOUSES].Nth(subpos).second;
			} else {
				AD.data_s = rules[HOUSES].Nth(subpos).second;
			}

			currentOwner = AD.data_s;
		}
#ifdef SMUDGE_SUPP
		else if (pos == 8) {


			CString sec = "SmudgeTypes";

			if (subpos < rules[sec].Size()) {
				// standard unit!
				AD.data_s = rules[sec].Nth(subpos).second;
			} else {
				AD.data_s = ini[sec].Nth(subpos - rules[sec].Size()).second;
			}

		}
#endif


	}



	*pResult = 0;
}

__inline HTREEITEM TV_InsertItemW(HWND hWnd, WCHAR* lpString, int len, HTREEITEM hInsertAfter, HTREEITEM hParent, int param)
{
	if (!lpString) return NULL;

	TVINSERTSTRUCTW tvis;
	tvis.hInsertAfter = hInsertAfter;
	tvis.hParent = hParent;
	tvis.itemex.mask = TVIF_PARAM | TVIF_TEXT;
	tvis.itemex.cchTextMax = len;
	tvis.itemex.pszText = lpString;
	tvis.itemex.lParam = param;

	// MW 07/17/2001: Updated to use Ascii if Unicode fails:
	HTREEITEM res = (HTREEITEM)::SendMessage(hWnd, TVM_INSERTITEMW, 0, ((LPARAM)(&tvis)));

	if (!res) {
		// failed... Probably because of missing Unicode support

		// convert text to ascii, then add it
		BYTE* lpAscii = new(BYTE[len + 1]);
		BOOL bUsedDefault;
		memset(lpAscii, 0, len + 1);
		WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK,
			lpString, len + 1, (LPSTR)lpAscii, len + 1, NULL, &bUsedDefault);

		TVINSERTSTRUCT tvis;
		tvis.hInsertAfter = hInsertAfter;
		tvis.hParent = hParent;
		tvis.itemex.mask = TVIF_PARAM | TVIF_TEXT;
		tvis.itemex.cchTextMax = len;
		tvis.itemex.lParam = param;
		tvis.itemex.pszText = (char*)lpAscii;

		res = TreeView_InsertItem(hWnd, &tvis);

		delete[] lpAscii;
	}

	return res;
}

using vecSideNodeInfo = std::vector<std::pair<CString, TechnoTypeMask>>;
vecSideNodeInfo collectSides()
{
	vecSideNodeInfo ret;

	auto toType = [](const CString& str) -> TechnoTypeMask {
		return TechnoTypeMask(atoi(str));
	};

	CString typeStr;
	for (auto& [seq, def] : g_data["Sides"]) {
		auto const commaPos = def.Find(',');
		//now parse real type
		if (commaPos >= 0) {
			typeStr = def.Mid(commaPos + 1);
			ret.push_back({ def.Mid(0, commaPos), toType(typeStr) });
		}
	}

	return ret;
}

void CViewObjects::UpdateDialog()
{
	OutputDebugString("Objectbrowser redrawn\n");

	CTreeCtrl& tree = GetTreeCtrl();
	CIniFile& ini = Map->GetIniFile();

	tree.Select(0, TVGN_CARET);
	tree.DeleteAllItems();

	CString sTreeRoots[15];
	sTreeRoots[0] = GetLanguageStringACP("InfantryObList");
	sTreeRoots[1] = GetLanguageStringACP("VehiclesObList");
	sTreeRoots[2] = GetLanguageStringACP("AircraftObList");
	sTreeRoots[3] = GetLanguageStringACP("StructuresObList");
	sTreeRoots[4] = GetLanguageStringACP("TerrainObList");
	sTreeRoots[5] = GetLanguageStringACP("OverlayObList");
	sTreeRoots[6] = GetLanguageStringACP("WaypointsObList");
	sTreeRoots[7] = GetLanguageStringACP("CelltagsObList");
	sTreeRoots[8] = GetLanguageStringACP("BaseNodesObList");
	sTreeRoots[9] = GetLanguageStringACP("TunnelObList");
	sTreeRoots[10] = GetLanguageStringACP("DelObjObList");
	sTreeRoots[11] = GetLanguageStringACP("ChangeOwnerObList");
	sTreeRoots[12] = GetLanguageStringACP("StartpointsObList");
	sTreeRoots[13] = GetLanguageStringACP("GroundObList");
	sTreeRoots[14] = GetLanguageStringACP("SmudgesObList");

	int i = 0;

	//TV_InsertItemW(tree.m_hWnd, L"HELLO", 5, TVI_LAST, TVI_ROOT, -2);
	auto const translatedNoObj = GetLanguageStringACP("NothingObList");
	HTREEITEM first = tree.InsertItem(TVIF_PARAM | TVIF_TEXT,
		translatedNoObj, i, i, 0, 0, -2, TVI_ROOT, TVI_LAST);

	HTREEITEM rootitems[15];

	// we want the change owner at the top

	if (!Map->IsMultiplayer() || !theApp.m_Options.bEasy)
		rootitems[11] = tree.InsertItem(TVIF_PARAM | TVIF_TEXT,
			sTreeRoots[11], i, i, 0, 0, i, TVI_ROOT, TVI_LAST);


	for (i = 0; i < 10; i++) {
		BOOL bAllow = TRUE;
		if (theApp.m_Options.bEasy) {
			if (i >= 6 && i <= 9)
				bAllow = FALSE;
		}

		// no tunnels in ra2 mode
		if (editor_mode == ra2_mode && i == 9 && !g_data.GetBool("Debug", "AllowTunnels")) {
			bAllow = FALSE;
		}

		if (bAllow) {
			rootitems[i] = tree.InsertItem(TVIF_PARAM | TVIF_TEXT,
				sTreeRoots[i], i, i, 0, 0, i, TVI_ROOT, TVI_LAST);
		}
	}


	rootitems[13] = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, sTreeRoots[13], 13, 13, 0, 0, 13, TVI_ROOT, first);

	rootitems[12] = tree.InsertItem(TVIF_PARAM | TVIF_TEXT,
		sTreeRoots[12], 12, 12, 0, 0, 12, TVI_ROOT, TVI_LAST);

	rootitems[10] = tree.InsertItem(TVIF_PARAM | TVIF_TEXT,
		sTreeRoots[10], 10, 10, 0, 0, 10, TVI_ROOT, TVI_LAST);

#ifdef SMUDGE_SUPP
	rootitems[14] = tree.InsertItem(TVIF_PARAM | TVIF_TEXT,
		sTreeRoots[14], 14, 14, 0, 0, 10, TVI_ROOT, rootitems[4]);
#endif


	HTREEITEM structhouses[64];
#ifdef RA2_MODE
	HTREEITEM hAllied = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("Allied"), 0, 0, 0, 0, -1, rootitems[3], TVI_LAST);
	HTREEITEM hSoviet = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("Soviet"), 0, 0, 0, 0, -1, rootitems[3], TVI_LAST);
	HTREEITEM hYuri = NULL;
	if (yuri_mode) {
		hYuri = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("Yuri"), 0, 0, 0, 0, -1, rootitems[3], TVI_LAST);
	}

	for (i = 0; i < sides.size(); i++) {
		if (sides[i].orig_n == 0)
			structhouses[i] = hAllied;
		else if (yuri_mode && sides[i].orig_n == 2)
			structhouses[i] = hYuri;
		else
			structhouses[i] = hSoviet;

	}

	structhouses[sides.size()] = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("Other"), 0, 0, 0, 0, -1, rootitems[3], TVI_LAST);
#else
	for (i = 0; i < sides.size(); i++) {
		structhouses[i] = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, sides[i].name, 0, 0, 0, 0, -1, rootitems[3], TVI_LAST);
	}
	structhouses[sides.size()] = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, "Other", 0, 0, 0, 0, -1, rootitems[3], TVI_LAST);
#endif


	if (!theApp.m_Options.bEasy) {
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("CreateWaypObList"), 0, 0, 0, 0, 20, rootitems[6], TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("CreateSpecWaypObList"), 0, 0, 0, 0, 22, rootitems[6], TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DelWaypObList"), 0, 0, 0, 0, 21, rootitems[6], TVI_LAST);
	}


	int e;
	int max = 8;
	//if(ini.find(HOUSES)!=ini.end() && ini.find(MAPHOUSES)!=ini.end())
	if (!Map->IsMultiplayer())
		max = 1;
	else {

	}
	for (e = 0; e < max; e++) {
		CString ins = GetLanguageStringACP("StartpointsPlayerObList");
		char c[50];
		itoa(e + 1, c, 10);
		ins = TranslateStringVariables(1, ins, c);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, ins, 0, 0, 0, 0, 23 + e, rootitems[12], TVI_LAST);
	}
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("StartpointsDelete"), 0, 0, 0, 0, 21, rootitems[12], TVI_LAST);



	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetTheaterLanguageString("GroundClearObList"), 0, 0, 0, 0, 61, rootitems[13], TVI_LAST);
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetTheaterLanguageString("GroundSandObList"), 0, 0, 0, 0, 62, rootitems[13], TVI_LAST);
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetTheaterLanguageString("GroundRoughObList"), 0, 0, 0, 0, 63, rootitems[13], TVI_LAST);
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetTheaterLanguageString("GroundGreenObList"), 0, 0, 0, 0, 65, rootitems[13], TVI_LAST);
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetTheaterLanguageString("GroundPaveObList"), 0, 0, 0, 0, 66, rootitems[13], TVI_LAST);
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetTheaterLanguageString("GroundWaterObList"), 0, 0, 0, 0, 64, rootitems[13], TVI_LAST);
#ifdef RA2_MODE
	if (Map->GetTheater() == THEATER3)
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetTheaterLanguageString("GroundPave2ObList"), 0, 0, 0, 0, 67, rootitems[13], TVI_LAST);
#endif

	if (!theApp.m_Options.bEasy) {
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("CreateCelltagObList"), 0, 0, 0, 0, 36, rootitems[7], TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DelCelltagObList"), 0, 0, 0, 0, 37, rootitems[7], TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("CelltagPropObList"), 0, 0, 0, 0, 38, rootitems[7], TVI_LAST);
	}

	if (!theApp.m_Options.bEasy) {
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("CreateNodeNoDelObList"), 0, 0, 0, 0, 40, rootitems[8], TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("CreateNodeDelObList"), 0, 0, 0, 0, 41, rootitems[8], TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DelNodeObList"), 0, 0, 0, 0, 42, rootitems[8], TVI_LAST);
	}


	HTREEITEM deleteoverlay = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DelOvrlObList"), 0, 0, 0, 0, -1, rootitems[5], TVI_LAST);
	HTREEITEM tiberium = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("GrTibObList"), 0, 0, 0, 0, -1, rootitems[5], TVI_LAST);
	//HTREEITEM bluetiberium=tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("BlTibObList"), 0,0,0,0, -1, rootitems[5], TVI_LAST );
#ifndef RA2_MODE
	HTREEITEM veinhole = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("VeinholeObList"), 0, 0, 0, 0, -1, rootitems[5], TVI_LAST);
#endif
	HTREEITEM bridges = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("BridgesObList"), 0, 0, 0, 0, -1, rootitems[5], TVI_LAST);
	HTREEITEM alloverlay = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("OthObList"), 0, 0, 0, 0, -1, rootitems[5], TVI_LAST);
	HTREEITEM everyoverlay = NULL;

	if (!theApp.m_Options.bEasy) {
		everyoverlay = tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("AllObList"), 0, 0, 0, 0, -1, rootitems[5], TVI_LAST);
	}


	if (!theApp.m_Options.bEasy) {
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("OvrlManuallyObList"), 0, 0, 0, 0, valadded * 6 + 1, rootitems[5], TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("OvrlDataManuallyObList"), 0, 0, 0, 0, valadded * 6 + 2, rootitems[5], TVI_LAST);
	}

	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DelOvrl0ObList"), 0, 0, 0, 0, valadded * 6 + 100 + 0, deleteoverlay, TVI_LAST);
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DelOvrl1ObList"), 0, 0, 0, 0, valadded * 6 + 100 + 1, deleteoverlay, TVI_LAST);
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DelOvrl2ObList"), 0, 0, 0, 0, valadded * 6 + 100 + 2, deleteoverlay, TVI_LAST);
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DelOvrl3ObList"), 0, 0, 0, 0, valadded * 6 + 100 + 3, deleteoverlay, TVI_LAST);

	//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DrawRanTibObList"), 0,0,0,0, valadded*6+200+0, tiberium, TVI_LAST );
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DrawTibObList"), 0, 0, 0, 0, valadded * 6 + 200 + 10, tiberium, TVI_LAST);
	//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("IncTibSizeObList"), 0,0,0,0, valadded*6+200+20, tiberium, TVI_LAST );
	//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DecTibSizeObList"), 0,0,0,0, valadded*6+200+21, tiberium, TVI_LAST );

	//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DrawRanTibObList"), 0,0,0,0, valadded*6+300+0, bluetiberium, TVI_LAST );
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DrawTib2ObList"), 0, 0, 0, 0, valadded * 6 + 300 + 10, tiberium, TVI_LAST);
	//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("IncTibSizeObList"), 0,0,0,0, valadded*6+300+20, bluetiberium, TVI_LAST );
	//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DecTibSizeObList"), 0,0,0,0, valadded*6+300+21, bluetiberium, TVI_LAST );
#ifndef RA2_MODE
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("VeinholeObList"), 0, 0, 0, 0, valadded * 6 + 400 + 0, veinhole, TVI_LAST);
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("VeinsObList"), 0, 0, 0, 0, valadded * 6 + 400 + 1, veinhole, TVI_LAST);
#endif

	if (Map->GetTheater() != THEATER4 && Map->GetTheater() != THEATER5) {
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("SmallBridgeObList"), 0, 0, 0, 0, valadded * 6 + 500 + 1, bridges, TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("BigBridgeObList"), 0, 0, 0, 0, valadded * 6 + 500 + 0, bridges, TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("BigTrackBridgeObList"), 0, 0, 0, 0, valadded * 6 + 500 + 2, bridges, TVI_LAST);
#ifdef RA2_MODE
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("SmallConcreteBridgeObList"), 0, 0, 0, 0, valadded * 6 + 500 + 3, bridges, TVI_LAST);
#endif
	} else {
		if (Map->GetTheater() == THEATER5) {
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("SmallBridgeObList"), 0, 0, 0, 0, valadded * 6 + 500 + 1, bridges, TVI_LAST);
#ifdef RA2_MODE
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("SmallConcreteBridgeObList"), 0, 0, 0, 0, valadded * 6 + 500 + 3, bridges, TVI_LAST);
#endif
		}

	}

#ifndef RA2_MODE
	if (!theApp.m_Options.bEasy && isTrue(g_data["Debug"]["AllowTunnels"])) {
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("NewTunnelObList"), 0, 0, 0, 0, 50, rootitems[9], TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("ModifyTunnelObList"), 0, 0, 0, 0, 51, rootitems[9], TVI_LAST);
		if (isTrue(g_data["Debug"]["AllowUnidirectionalTunnels"])) {
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("NewTunnelSingleObList"), 0, 0, 0, 0, 52, rootitems[9], TVI_LAST);
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("ModifyTunnelSingleObList"), 0, 0, 0, 0, 53, rootitems[9], TVI_LAST);
		}
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DelTunnelObList"), 0, 0, 0, 0, 54, rootitems[9], TVI_LAST);
	}
#else
	if (!theApp.m_Options.bEasy && g_data.GetBool("Debug", "AllowTunnels")) {
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("NewTunnelObList"), 0, 0, 0, 0, 50, rootitems[9], TVI_LAST);
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("ModifyTunnelObList"), 0, 0, 0, 0, 51, rootitems[9], TVI_LAST);
		if (g_data.GetBool("Debug", "AllowUnidirectionalTunnels")) {
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("NewTunnelSingleObList"), 0, 0, 0, 0, 52, rootitems[9], TVI_LAST);
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("ModifyTunnelSingleObList"), 0, 0, 0, 0, 53, rootitems[9], TVI_LAST);
		}
		tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("DelTunnelObList"), 0, 0, 0, 0, 54, rootitems[9], TVI_LAST);
	}
#endif

	if (!theApp.m_Options.bEasy || !Map->IsMultiplayer()) {
		if (ini[MAPHOUSES].Size() > 0) {
			for (i = 0; i < ini[MAPHOUSES].Size(); i++) {
#ifdef RA2_MODE
				auto const& name = ini[MAPHOUSES].Nth(i).second;
				if (!name.CompareNoCase("nod") || !name.CompareNoCase("gdi")) {
					continue;
				}
#endif	

				tree.InsertItem(TVIF_PARAM | TVIF_TEXT, TranslateHouse(name, TRUE), 0, 0, 0, 0, valadded * 7 + i, rootitems[11], TVI_LAST);
			}

		} else {
			for (i = 0; i < rules[HOUSES].Size(); i++) {
				//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, CCStrings[*rules[HOUSES].Nth(i)].cString, 
				//0,0,0,0, valadded*7+i, rootitems[11], TVI_LAST );
#ifdef RA2_MODE
				auto const& name = rules[HOUSES].Nth(i).second;
				if (!name.CompareNoCase("nod") || !name.CompareNoCase("gdi")) {
					continue;
				}
#endif	
				TV_InsertItemW(tree.m_hWnd, CCStrings[name].wString, CCStrings[name].len, TVI_LAST, rootitems[11], valadded * 7 + i);
			}
		}
	} else {
		// change owner to neutral
		if (ini[MAPHOUSES].Size() > 0) {
			if (ini[MAPHOUSES].FindValue("Neutral") >= 0)
				currentOwner = "Neutral";
			else
				currentOwner = ini[MAPHOUSES].Nth(0).second;
		} else
			currentOwner = "Neutral";

	}


	for (i = 0; i < overlay_count; i++) {
		if (overlay_visible[i] && (!yr_only[i] || yuri_mode)) {
			if (!overlay_trdebug[i] || g_data.GetBool("Debug", "EnableTrackLogic"))
				tree.InsertItem(TVIF_PARAM | TVIF_TEXT, TranslateStringACP(overlay_name[i]), 0, 0, 0, 0, valadded * 6 + 3000 + overlay_number[i], alloverlay, TVI_LAST);
		}
	}

	e = 0;
	if (!theApp.m_Options.bEasy) {
		for (i = 0; i < rules["OverlayTypes"].Size(); i++) {
			// it seems there is somewhere a bug that lists empty overlay ids... though they are not in the rules.ini
			// so this here is the workaround:
			auto const& unitname = rules["OverlayTypes"].Nth(i).second;
			auto id = unitname;
			//if(strchr(id,' ')!=NULL){ id[strchr(id,' ')-id;};		
			if (id.Find(' ') >= 0) {
				id = id.Left(id.Find(' '));
			}
			if (id.GetLength() > 0) {


#ifdef RA2_MODE
				if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateRA2"].FindValue(unitname) >= 0) continue;
				if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowRA2"].FindValue(unitname) >= 0) continue;
				if (Map->GetTheater() == THEATER2 && g_data["IgnoreUrbanRA2"].FindValue(unitname) >= 0) continue;
				if (Map->GetTheater() == THEATER3 && g_data["IgnoreNewUrbanRA2"].FindValue(unitname) >= 0) continue;
				if (Map->GetTheater() == THEATER4 && g_data["IgnoreLunarRA2"].FindValue(unitname) >= 0) continue;
				if (Map->GetTheater() == THEATER5 && g_data["IgnoreDesertRA2"].FindValue(unitname) >= 0) continue;
#else
				if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateTS"].FindValue(unitname) >= 0) continue;
				if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowTS"].FindValue(unitname) >= 0) continue;
#endif

#ifdef RA2_MODE
				if ((i >= 39 && i <= 60) || (i >= 180 && i <= 201) || i == 239 || i == 178 || i == 167 || i == 126
					|| (i >= 122 && i <= 125) || i == 1 || (i >= 0x03 && i <= 0x17) || (i >= 0x3d && i <= 0x43)
					|| (i >= 0x4a && i <= 0x65) || (i >= 0xcd && i <= 0xec)) {
					if (!g_data.GetBool("Debug", "DisplayAllOverlay")) {
						e++;
						continue;
					}
				}


#endif

				CString val = unitname;
#ifdef RA2_MODE
				val.Replace("TIB", "ORE");
#endif

				tree.InsertItem(TVIF_PARAM | TVIF_TEXT, val, 0, 0, 0, 0, valadded * 6 + 3000 + e, everyoverlay, TVI_LAST);
				e++;
			}
		}
	}


	for (i = 0; i < rules["InfantryTypes"].Size(); i++) {
		auto const& unitname = rules["InfantryTypes"].Nth(i).second;

		if (unitname.IsEmpty()) {
			continue;
		}

#ifdef RA2_MODE
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER2 && g_data["IgnoreUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER3 && g_data["IgnoreNewUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER4 && g_data["IgnoreLunarRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER5 && g_data["IgnoreDesertRA2"].FindValue(unitname) >= 0) continue;
#else
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateTS"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowTS"].FindValue(unitname) >= 0) continue;
#endif

#ifdef RA2_MODE
		if (g_data["IgnoreRA2"].FindValue(unitname) >= 0) continue;
#else
		if (g_data["IgnoreTS"].FindValue(unitname) >= 0) continue;
#endif

		WCHAR* addedString = Map->GetUnitName(unitname);
		if (!addedString) continue;

		//addedString=TranslateStringACP(addedString);

		//addedString+=" (";
		//addedString+=unitname+")";

		TV_InsertItemW(tree.m_hWnd, addedString, wcslen(addedString), TVI_LAST, rootitems[0], valadded * 1 + i);

		//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, addedString, 0,0,0,0, valadded*1+i, rootitems[0], TVI_LAST );
	}
	// okay, now the user-defined types:
	auto const& infTypeSec = ini["InfantryTypes"];
	for (i = 0; i < infTypeSec.Size(); i++) {
		auto const& id = infTypeSec.Nth(i).second;
		if (id.IsEmpty()) {
			continue;
		}

		if (strlen(ini[id]["Name"]) > 0) {
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, ini[id]["Name"], 0, 0, 0, 0, valadded * 1 + rules["InfantryTypes"].Size() + i, rootitems[0], TVI_LAST);
		} else {
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, (id + " NOTDEFINED"), 0, 0, 0, 0, valadded * 1 + rules["InfantryTypes"].Size() + i, rootitems[0], TVI_LAST);
		}
	}

	CString theater = Map->GetTheater();


	auto needed_terrain = TheaterChar::None;
	if (tiledata == &s_tiledata) {
		needed_terrain = TheaterChar::A;
	} else if (tiledata == &t_tiledata) {
		needed_terrain = TheaterChar::T;
	}
	auto const& bldTypeSec = rules["BuildingTypes"];
	for (i = 0; i < bldTypeSec.Size(); i++) {

		auto const& unitname = bldTypeSec.Nth(i).second;

		if (unitname.IsEmpty()) {
			continue;
		}

#ifdef RA2_MODE
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER2 && g_data["IgnoreUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER3 && g_data["IgnoreNewUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER4 && g_data["IgnoreLunarRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER5 && g_data["IgnoreDesertRA2"].FindValue(unitname) >= 0) continue;
#else
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateTS"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowTS"].FindValue(unitname) >= 0) continue;
#endif

#ifdef RA2_MODE
		if (g_data["IgnoreRA2"].FindValue(unitname) >= 0) continue;
#else
		if (g_data["IgnoreTS"].FindValue(unitname) >= 0) continue;
#endif
		if (!g_data.GetBool("Debug", "ShowBuildingsWithToTile") && !rules[unitname]["ToTile"].IsEmpty()) {
			continue;
		}

		WCHAR* addedString = Map->GetUnitName(unitname);
		if (!addedString) {
			continue;
		}

		CString owner = rules[unitname]["Owner"];
		int baseplanningside = -1;
#ifdef RA2_MODE
		baseplanningside = -1;
#endif
		baseplanningside = rules.GetInteger(unitname, "AIBasePlanningSide", baseplanningside);
		baseplanningside = g_data.GetInteger(unitname, "AIBasePlanningSide", baseplanningside);


		int id = Map->GetBuildingID(unitname);
		if (id < 0 /*|| (buildinginfo[id].pic[0].bTerrain!=0 && buildinginfo[id].pic[0].bTerrain!=needed_terrain)*/)
			continue;

		if (theater == THEATER0 && !buildinginfo[id].bTemp) { /*MessageBox("Ignored", unitname,0);*/ continue; }
		if (theater == THEATER1 && !buildinginfo[id].bSnow) { /*MessageBox("Ignored", unitname,0);*/ continue; }
		if (theater == THEATER2 && !buildinginfo[id].bUrban) { /*MessageBox("Ignored", unitname,0);*/ continue; }

		// check if mapfile contains other value for owner
		owner = ini.GetStringOr(unitname, "Owner", owner);

		//addedString=TranslateStringACP(addedString);

		//addedString+=" (";
		//addedString+=unitname+")";

		BOOL addedfor[3] = { FALSE,FALSE,FALSE };

		// MW fixed below for YR... uhhh...
		int e;
		BOOL bAdded = FALSE;
		for (e = 0; e < sides.size(); e++) {
			//MessageBox(sides[e].name);

			if (isIncluded(owner, sides[e].name)) {

#ifdef RA2_MODE
				if (!addedfor[sides[e].orig_n])
#endif
					if (baseplanningside == -1 || baseplanningside == sides[e].orig_n) {

						//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, addedString, 0,0,0,0, valadded*2+i, structhouses[e], TVI_LAST );
						TV_InsertItemW(tree.m_hWnd, addedString, wcslen(addedString), TVI_LAST, structhouses[e], valadded * 2 + i);
						bAdded = TRUE;
						addedfor[sides[e].orig_n] = TRUE;

					}
			}


		}

		if (bAdded == FALSE) {
			//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, addedString, 0,0,0,0, valadded*2+i, structhouses[e+1], TVI_LAST );
			TV_InsertItemW(tree.m_hWnd, addedString, wcslen(addedString), TVI_LAST, structhouses[sides.size()], valadded * 2 + i);
		}
	}

	// okay, now the user-defined types:
	auto const& localbldTypeSec = ini["BuildingTypes"];
	for (i = 0; i < localbldTypeSec.Size(); i++) {
		auto const& typeId = localbldTypeSec.Nth(i).second;
		if (localbldTypeSec.Nth(i).second.IsEmpty()) {
			continue;
		}

		int id = Map->GetBuildingID(typeId);
		if (id < 0 || (buildinginfo[id].pic[0].bTerrain != TheaterChar::None && buildinginfo[id].pic[0].bTerrain != needed_terrain)) {
			continue;
		}

		int e = 2;
		BOOL bAdded = FALSE;
		auto owner = ini[typeId]["Owner"];
		owner.MakeUpper();

		auto const& name = ini[typeId]["Name"];
		if (!name.IsEmpty()) {
			auto const& addedString = name;
			int e;
			for (e = 0; e < sides.size(); e++) {
				if (isIncluded(owner, sides[e].name)) {
					tree.InsertItem(TVIF_PARAM | TVIF_TEXT, addedString, 0, 0, 0, 0, valadded * 2 + i, structhouses[e], TVI_LAST);
					bAdded = TRUE;
				} else if (e == sides.size() - 1 && bAdded == FALSE) {
					tree.InsertItem(TVIF_PARAM | TVIF_TEXT, addedString, 0, 0, 0, 0, valadded * 2 + i, structhouses[e + 1], TVI_LAST);
				}
			}
		} else {
			CString addedString = (typeId + " UNDEFINED");
			BOOL addedfor[2] = { FALSE,FALSE };

			int e;
			for (e = 0; e < sides.size(); e++) {
#ifdef RA2_MODE
				if (!addedfor[sides[e].orig_n])
#endif
					if (isIncluded(owner, sides[e].name) || (yuri_mode && e == 2 && owner == "YuriCountry")) {
						tree.InsertItem(TVIF_PARAM | TVIF_TEXT, addedString, 0, 0, 0, 0, valadded * 2 + i, structhouses[e], TVI_LAST);
						bAdded = TRUE;
						addedfor[sides[e].orig_n] = TRUE;

					} else if (e == sides.size() - 1 && bAdded == FALSE) {
						tree.InsertItem(TVIF_PARAM | TVIF_TEXT, addedString, 0, 0, 0, 0, valadded * 2 + i, structhouses[e + 1], TVI_LAST);
					}
			}
		}

	}


	auto const& aircraftTypeSec = rules["AircraftTypes"];
	for (i = 0; i < aircraftTypeSec.Size(); i++) {
		auto const& unitname = aircraftTypeSec.Nth(i).second;
		if (unitname.IsEmpty()) {
			continue;
		}

#ifdef RA2_MODE
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER2 && g_data["IgnoreUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER3 && g_data["IgnoreNewUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER4 && g_data["IgnoreLunarRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER5 && g_data["IgnoreDesertRA2"].FindValue(unitname) >= 0) continue;
#else
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateTS"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowTS"].FindValue(unitname) >= 0) continue;
#endif

#ifdef RA2_MODE
		if (g_data["IgnoreRA2"].FindValue(unitname) >= 0) continue;
#else
		if (g_data["IgnoreTS"].FindValue(unitname) >= 0) continue;
#endif

		WCHAR* addedString = Map->GetUnitName(unitname);
		if (!addedString) continue;

		//addedString=TranslateStringACP(addedString);

		//addedString+=" (";
		//addedString+=unitname+")";

		TV_InsertItemW(tree.m_hWnd, addedString, wcslen(addedString), TVI_LAST, rootitems[2], valadded * 3 + i);

		//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, addedString, 0,0,0,0, valadded*3+i, rootitems[2], TVI_LAST );
	}

	// okay, now the user-defined types:
	auto const localAircraftTypeSec = ini["AircraftTypes"];
	for (i = 0; i < localAircraftTypeSec.Size(); i++) {
		auto const& typeId = localAircraftTypeSec.Nth(i).second;
		if (typeId.IsEmpty()) {
			continue;
		}

		auto const& name = ini[typeId]["Name"];
		if (!name.IsEmpty()) {
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, name, 0, 0, 0, 0, valadded * 3 + i + rules["AircraftTypes"].Size(), rootitems[2], TVI_LAST);
		} else {
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, (typeId + " NOTDEFINED"), 0, 0, 0, 0, valadded * 3 + i + rules["AircraftTypes"].Size(), rootitems[2], TVI_LAST);
		}
	}


	auto const& vehTypeSec = rules["VehicleTypes"];
	for (i = 0; i < vehTypeSec.Size(); i++) {
		auto const& unitname = vehTypeSec.Nth(i).second;
		if (unitname.GetLength() == 0) {
			continue;
		}
#ifdef RA2_MODE
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER2 && g_data["IgnoreUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER3 && g_data["IgnoreNewUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER4 && g_data["IgnoreLunarRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER5 && g_data["IgnoreDesertRA2"].FindValue(unitname) >= 0) continue;
#else
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateTS"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowTS"].FindValue(unitname) >= 0) continue;
#endif

#ifdef RA2_MODE
		if (g_data["IgnoreRA2"].FindValue(unitname) >= 0) continue;
#else
		if (g_data["IgnoreTS"].FindValue(unitname) >= 0) continue;
#endif

		WCHAR* addedString = Map->GetUnitName(unitname);
		if (!addedString) continue;

		//addedString=TranslateStringACP(addedString);

		//addedString+=" (";
		//addedString+=unitname+")";

		TV_InsertItemW(tree.m_hWnd, addedString, wcslen(addedString), TVI_LAST, rootitems[1], valadded * 4 + i);

		//tree.InsertItem(TVIF_PARAM | TVIF_TEXT, addedString, 0,0,0,0, valadded*4+i, rootitems[1], TVI_LAST );
	}
	// okay, now the user-defined types:
	auto const localVehTypeSec = ini["VehicleTypes"];
	for (i = 0; i < localVehTypeSec.Size(); i++) {
		auto const& typeId = localVehTypeSec.Nth(i).second;
		if (typeId.IsEmpty()) {
			continue;
		}
		auto const& name = ini[typeId]["Name"];
		if (!name.IsEmpty()) {
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, name, 0, 0, 0, 0, valadded * 4 + i + rules["VehicleTypes"].Size(), rootitems[1], TVI_LAST);
		} else {
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, (typeId + " NOTDEFINED"), 0, 0, 0, 0, valadded * 4 + i + rules["VehicleTypes"].Size(), rootitems[1], TVI_LAST);
		}
	}


#ifdef RA2_MODE
	HTREEITEM hTrees = tree.InsertItem(GetLanguageStringACP("TreesObList"), rootitems[4], TVI_LAST);
	HTREEITEM hTL = tree.InsertItem(GetLanguageStringACP("TrafficLightsObList"), rootitems[4], TVI_LAST);
	HTREEITEM hSigns = tree.InsertItem(GetLanguageStringACP("SignsObList"), rootitems[4], TVI_LAST);
	HTREEITEM hLightPosts = tree.InsertItem(GetLanguageStringACP("LightPostsObList"), rootitems[4], TVI_LAST);
#endif

	// random tree placer
#ifdef RA2_MODE
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("RndTreeObList"), 0, 0, 0, 0, valadded * 5 + 999, hTrees, TVI_LAST);
#else
	tree.InsertItem(TVIF_PARAM | TVIF_TEXT, GetLanguageStringACP("RndTreeObList"), 0, 0, 0, 0, valadded * 5 + 999, rootitems[4], TVI_LAST);
#endif

	auto const& terrainTypeSec = rules["TerrainTypes"];
	for (i = 0; i < terrainTypeSec.Size(); i++) {
		auto const& unitname = terrainTypeSec.Nth(i).second;
		CString addedString = Map->GetUnitName(unitname);

#ifdef RA2_MODE
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER2 && g_data["IgnoreUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER3 && g_data["IgnoreNewUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER4 && g_data["IgnoreLunarRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER5 && g_data["IgnoreDesertRA2"].FindValue(unitname) >= 0) continue;
#else
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateTS"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowTS"].FindValue(unitname) >= 0) continue;
#endif

#ifdef RA2_MODE
		if (g_data["IgnoreRA2"].FindValue(unitname) >= 0) continue;
#else
		if (g_data["IgnoreTS"].FindValue(unitname) >= 0) continue;
#endif
#ifdef RA2_MODE
		if (g_data["IgnoreTerrainRA2"].FindValue(unitname) >= 0) continue;
#else
		if (g_data["IgnoreTerrainTS"].FindValue(unitname) >= 0) continue;
#endif

		addedString = TranslateStringACP(addedString);

		UINT flags = MF_STRING;

		HTREEITEM howner = rootitems[4];

#ifdef RA2_MODE
		if (unitname.Find("SIGN") >= 0) howner = hSigns;
		if (unitname.Find("TRFF") >= 0) howner = hTL;
		if (unitname.Find("TREE") >= 0) howner = hTrees;
		if (unitname.Find("LT") >= 0) howner = hLightPosts;
#endif

#ifdef RA2_MODE
		if (howner == hTrees) {
			int TreeMin = atoi(g_data[Map->GetTheater() + "Limits"]["TreeMin"]);
			int TreeMax = atoi(g_data[Map->GetTheater() + "Limits"]["TreeMax"]);

			CString id = unitname;
			id.Delete(0, 4);
			int n = atoi(id);

			if (n<TreeMin || n>TreeMax) continue;
		}
#endif

		if (unitname.GetLength() > 0 && unitname != "VEINTREE" && unitname.Find("ICE") < 0 && unitname.Find("BOXES") < 0 && unitname.Find("SPKR") < 0) // out with it :-)
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, (addedString + " (" + unitname + ")"), 0, 0, 0, 0, valadded * 5 + i, howner, TVI_LAST);
	}

#ifdef SMUDGE_SUPP
	auto const& smudgeTypeSec = rules["SmudgeTypes"];
	for (i = 0; i < smudgeTypeSec.Size(); i++) {
		auto const& unitname = smudgeTypeSec.Nth(i).second;
		CString addedString = unitname;

#ifdef RA2_MODE
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER2 && g_data["IgnoreUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER3 && g_data["IgnoreNewUrbanRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER4 && g_data["IgnoreLunarRA2"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER5 && g_data["IgnoreDesertRA2"].FindValue(unitname) >= 0) continue;
#else
		if (Map->GetTheater() == THEATER0 && g_data["IgnoreTemperateTS"].FindValue(unitname) >= 0) continue;
		if (Map->GetTheater() == THEATER1 && g_data["IgnoreSnowTS"].FindValue(unitname) >= 0) continue;
#endif

#ifdef RA2_MODE
		if (g_data["IgnoreRA2"].FindValue(unitname) >= 0) continue;
#else
		if (g_data["IgnoreTS"].FindValue(unitname) >= 0) continue;
#endif

		addedString = TranslateStringACP(addedString);

		UINT flags = MF_STRING;

		HTREEITEM howner = rootitems[14];


		if (unitname.GetLength() > 0) {
			tree.InsertItem(TVIF_PARAM | TVIF_TEXT, unitname, 0, 0, 0, 0, valadded * 8 + i, howner, TVI_LAST);
		}
	}
#endif



	OutputDebugString("Objectbrowser redraw finished\n");


}

int CViewObjects::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	lpCreateStruct->style |= TVS_HASLINES | TVS_HASBUTTONS | TVS_LINESATROOT | TVS_SHOWSELALWAYS;
	if (CTreeView::OnCreate(lpCreateStruct) == -1)
		return -1;


	return 0;
}

void CViewObjects::OnInitialUpdate()
{
	CTreeView::OnInitialUpdate();


	m_ready = TRUE;
}

void CViewObjects::OnKeydown(NMHDR* pNMHDR, LRESULT* pResult)
{
	TV_KEYDOWN* pTVKeyDown = (TV_KEYDOWN*)pNMHDR;
	// TODO: Code für die Behandlungsroutine der Steuerelement-Benachrichtigung hier einfügen

	*pResult = 0;
}

void CViewObjects::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	// TODO: Code für die Behandlungsroutine für Nachrichten hier einfügen und/oder Standard aufrufen

	// CTreeView::OnKeyDown(nChar, nRepCnt, nFlags);
}

void CViewObjects::HandleBrushSize(int iTile)
{
	if (iTile >= *tiledata_count) {
		return;
	}

	for (auto const& [n, val] : g_data["StdBrushSize"]) {
		if ((*tiles)["General"].FindIndex(n) >= 0) {
			int tset = tiles->GetInteger("General", n);
			if (tset == (*tiledata)[iTile].wTileSet) {
				int bs = atoi(val);
				((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.m_BrushSize = bs - 1;
				((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.UpdateData(FALSE);
				((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_x = bs;
				((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_y = bs;
			}
		}
	}

}