Removes the ArrayList classes, and replaces all instances with std::vector implementations.

11 files changed, 148 insertions, 143 deletions

diff --git a/nGenEx/ActiveWindow.cpp b/nGenEx/ActiveWindow.cpp
index 2830325..756912b 100644
--- a/nGenEx/ActiveWindow.cpp
+++ b/nGenEx/ActiveWindow.cpp
@@ -12,6 +12,7 @@
 	Window class

 */

 

+#include <vector>

 #include "MemDebug.h"

 #include "ActiveWindow.h"

 #include "EventDispatch.h"

@@ -174,10 +175,10 @@ ActiveWindow::DoLayout()
 // +--------------------------------------------------------------------+

 

 void

-ActiveWindow::UseLayout(const ArrayList& min_x,

-const ArrayList& min_y,

-const FloatList& weight_x,

-const FloatList& weight_y)

+ActiveWindow::UseLayout(const std::vector<DWORD>& min_x,

+const std::vector<DWORD>& min_y,

+const std::vector<float>& weight_x,

+const std::vector<float>& weight_y)

 {

 	if (!layout)

 	layout = new(__FILE__,__LINE__) Layout;

@@ -187,10 +188,10 @@ const FloatList& weight_y)
 }

 

 void

-ActiveWindow::UseLayout(const FloatList& min_x,

-const FloatList& min_y,

-const FloatList& weight_x,

-const FloatList& weight_y)

+ActiveWindow::UseLayout(const std::vector<float>& min_x,

+const std::vector<float>& min_y,

+const std::vector<float>& weight_x,

+const std::vector<float>& weight_y)

 {

 	if (!layout)

 	layout = new(__FILE__,__LINE__) Layout;

diff --git a/nGenEx/ActiveWindow.h b/nGenEx/ActiveWindow.h
index 6be3bfb..b08cd26 100644
--- a/nGenEx/ActiveWindow.h
+++ b/nGenEx/ActiveWindow.h
@@ -15,13 +15,13 @@
 #ifndef ActiveWindow_h

 #define ActiveWindow_h

 

+#include <vector>

 #include "Types.h"

 #include "Color.h"

 #include "Geometry.h"

 #include "Bitmap.h"

 #include "Window.h"

 #include "EventTarget.h"

-#include "ArrayList.h"

 #include "List.h"

 #include "Text.h"

 

@@ -132,20 +132,20 @@ public:
 	virtual void      Show();

 	virtual void      Hide();

 	virtual void      MoveTo(const Rect& r);

-	virtual void      UseLayout(const ArrayList& min_x,

-	const ArrayList& min_y,

-	const FloatList& weight_x,

-	const FloatList& weight_y);

-	virtual void      UseLayout(const FloatList& min_x,

-	const FloatList& min_y,

-	const FloatList& weight_x,

-	const FloatList& weight_y);

+	virtual void      UseLayout(const std::vector<DWORD>& min_x,

+		const std::vector<DWORD>& min_y,

+		const std::vector<float>& weight_x,

+		const std::vector<float>& weight_y);

+	virtual void      UseLayout(const std::vector<float>& min_x,

+		const std::vector<float>& min_y,

+		const std::vector<float>& weight_x,

+		const std::vector<float>& weight_y);

 	virtual void      UseLayout(int     ncols,

-	int     nrows,

-	int*    min_x,

-	int*    min_y,

-	float*  weight_x,

-	float*  weight_y);

+		int     nrows,

+		int*    min_x,

+		int*    min_y,

+		float*  weight_x,

+		float*  weight_y);

 	virtual void      DoLayout();

 

 	// Event Target Interface:

diff --git a/nGenEx/FormDef.h b/nGenEx/FormDef.h
index c483a35..1fad78d 100644
--- a/nGenEx/FormDef.h
+++ b/nGenEx/FormDef.h
@@ -15,11 +15,11 @@
 #ifndef FormDef_h

 #define FormDef_h

 

+#include <vector>

 #include "Types.h"

 #include "Geometry.h"

 #include "Color.h"

 #include "Text.h"

-#include "ArrayList.h"

 #include "List.h"

 

 // +--------------------------------------------------------------------+

@@ -66,10 +66,10 @@ class LayoutDef
 public:

 	static const char* TYPENAME() { return "LayoutDef"; }

 

-	ArrayList   x_mins;

-	ArrayList   y_mins;

-	FloatList   x_weights;

-	FloatList   y_weights;

+	std::vector<DWORD>   x_mins;

+	std::vector<DWORD>   y_mins;

+	std::vector<float>   x_weights;

+	std::vector<float>   y_weights;

 };

 

 // +--------------------------------------------------------------------+

diff --git a/nGenEx/Layout.cpp b/nGenEx/Layout.cpp
index b7a38bb..afca9e7 100644
--- a/nGenEx/Layout.cpp
+++ b/nGenEx/Layout.cpp
@@ -34,8 +34,8 @@ Layout::DoLayout(ActiveWindow* panel)
 	if (cols.size() < 1 || rows.size() < 1)

 	return false;

 

-	ArrayList   cell_x;

-	ArrayList   cell_y;

+	std::vector<DWORD>   cell_x;

+	std::vector<DWORD>   cell_y;

 

 	ScaleWeights();

 	CalcCells(panel->Width(), panel->Height(), cell_x, cell_y);

@@ -94,31 +94,30 @@ Layout::DoLayout(ActiveWindow* panel)
 void

 Layout::ScaleWeights()

 {

-	int   i;

 	float total = 0;

 

-	for (i = 0; i < col_weights.size(); i++)

-	total += col_weights[i];

+	for (auto cwi = col_weights.begin(); cwi != col_weights.end(); ++cwi)

+		total += *cwi;

 

 	if (total > 0) {

-		for (i = 0; i < col_weights.size(); i++)

-		col_weights[i] = col_weights[i] / total;

+		for (auto cwi = col_weights.begin(); cwi != col_weights.end(); ++cwi)

+			*cwi = *cwi / total;

 	}

 

 	total = 0;

-	for (i = 0; i < row_weights.size(); i++)

-	total += row_weights[i];

+	for (auto rwi = row_weights.begin(); rwi != row_weights.end(); ++rwi)

+		total += *rwi;

 

 	if (total > 0) {

-		for (i = 0; i < row_weights.size(); i++)

-		row_weights[i] = row_weights[i] / total;

+		for (auto rwi = row_weights.begin(); rwi != row_weights.end(); ++rwi)

+			*rwi = *rwi / total;

 	}

 }

 

 // +--------------------------------------------------------------------+

 

 void

-Layout::CalcCells(DWORD w, DWORD h, ArrayList& cell_x, ArrayList& cell_y)

+	Layout::CalcCells(DWORD w, DWORD h, std::vector<DWORD>& cell_x, std::vector<DWORD>& cell_y)

 {

 	DWORD       x     = 0;

 	DWORD       y     = 0;

@@ -126,30 +125,29 @@ Layout::CalcCells(DWORD w, DWORD h, ArrayList& cell_x, ArrayList& cell_y)
 	DWORD       min_y = 0;

 	DWORD       ext_x = 0;

 	DWORD       ext_y = 0;

-	int         i;

 

-	for (i = 0; i < cols.size(); i++)

-	min_x += cols[i];

+	for (auto cit = cols.begin(); cit != cols.end(); ++cit)

+		min_x += *cit;

 

-	for (i = 0; i < rows.size(); i++)

-	min_y += rows[i];

+	for (auto rit = rows.begin(); rit != rows.end(); ++rit)

+		min_y += *rit;

 

 	if (min_x < w)

-	ext_x = w - min_x;

+		ext_x = w - min_x;

 

 	if (min_y < h)

-	ext_y = h - min_y;

+		ext_y = h - min_y;

 

-	cell_x.append(x);

-	for (i = 0; i < cols.size(); i++) {

-		x += cols[i] + (DWORD) (ext_x * col_weights[i]);

-		cell_x.append(x);

+	cell_x.push_back(x);

+	for (auto cit = cols.begin(); cit != cols.end(); ++cit) {

+		x += *cit + (DWORD) (ext_x * col_weights[cit - cols.begin()]);

+		cell_x.push_back(x);

 	}

 

-	cell_y.append(y);

-	for (i = 0; i < rows.size(); i++) {

-		y += rows[i] + (DWORD) (ext_y * row_weights[i]);

-		cell_y.append(y);

+	cell_y.push_back(y);

+	for (auto rit = rows.begin(); rit != rows.end(); ++rit) {

+		y += *rit + (DWORD) (ext_y * row_weights[rit - rows.begin()]);

+		cell_y.push_back(y);

 	}

 }

 

@@ -168,55 +166,62 @@ Layout::Clear()
 void

 Layout::AddCol(DWORD min_width, float col_factor)

 {

-	cols.append(min_width);

-	col_weights.append(col_factor);

+	cols.push_back(min_width);

+	col_weights.push_back(col_factor);

 }

 

 void

 Layout::AddRow(DWORD min_height, float row_factor)

 {

-	rows.append(min_height);

-	row_weights.append(row_factor);

+	rows.push_back(min_height);

+	row_weights.push_back(row_factor);

 }

 

 void

-Layout::SetConstraints(const ArrayList& min_x,

-const ArrayList& min_y,

-const FloatList& weight_x,

-const FloatList& weight_y)

+Layout::SetConstraints(const std::vector<DWORD>& min_x,

+const std::vector<DWORD>& min_y,

+const std::vector<float>& weight_x,

+const std::vector<float>& weight_y)

 {

 	Clear();

 

-	if (min_x.size() == weight_x.size() && 

-			min_y.size() == weight_y.size()) {

+	if (min_x.size() == weight_x.size() && min_y.size() == weight_y.size()) {

+		for (auto iter = min_x.begin(); iter != min_x.end(); ++iter)

+			cols.push_back(*iter);

 

-		cols.append(min_x);

-		rows.append(min_y);

+		for (auto iter = min_y.begin(); iter != min_y.end(); ++iter)

+			rows.push_back(*iter);

 

-		col_weights.append(weight_x);

-		row_weights.append(weight_y);

+		for (auto iter = weight_x.begin(); iter != weight_x.end(); ++iter)

+			col_weights.push_back(*iter);

+

+		for (auto iter = weight_y.begin(); iter != weight_y.end(); ++iter)

+			row_weights.push_back(*iter);

 	}

 }

 

 void

-Layout::SetConstraints(const FloatList& min_x,

-const FloatList& min_y,

-const FloatList& weight_x,

-const FloatList& weight_y)

+Layout::SetConstraints(const std::vector<float>& min_x,

+const std::vector<float>& min_y,

+const std::vector<float>& weight_x,

+const std::vector<float>& weight_y)

 {

 	Clear();

 

 	if (min_x.size() == weight_x.size() && 

 			min_y.size() == weight_y.size()) {

 

-		for (int i = 0; i < min_x.size(); i++)

-		cols.append((DWORD) min_x[i]);

+		for (auto iter = min_x.begin(); iter != min_x.begin(); ++iter)

+			cols.push_back((DWORD) *iter);

+

+		for (auto iter = min_y.begin(); iter != min_y.begin(); ++iter)

+			rows.push_back((DWORD) *iter);

 

-		for (int i = 0; i < min_y.size(); i++)

-		rows.append((DWORD) min_y[i]);

+		for (auto iter = weight_x.begin(); iter != weight_x.end(); ++iter)

+			col_weights.push_back(*iter);

 

-		col_weights.append(weight_x);

-		row_weights.append(weight_y);

+		for (auto iter = weight_y.begin(); iter != weight_y.end(); ++iter)

+			row_weights.push_back(*iter);

 	}

 }

 

@@ -234,13 +239,13 @@ const float*   weight_y)
 		int i = 0;

 

 		for (i = 0; i < ncols; i++) {

-			cols.append(min_x[i]);

-			col_weights.append(weight_x[i]);

+			cols.push_back(min_x[i]);

+			col_weights.push_back(weight_x[i]);

 		}

 

 		for (i = 0; i < nrows; i++) {

-			rows.append(min_y[i]);

-			row_weights.append(weight_y[i]);

+			rows.push_back(min_y[i]);

+			row_weights.push_back(weight_y[i]);

 		}

 	}

 }

diff --git a/nGenEx/Layout.h b/nGenEx/Layout.h
index 8986719..94fd627 100644
--- a/nGenEx/Layout.h
+++ b/nGenEx/Layout.h
@@ -16,7 +16,6 @@
 #define Layout_h

 

 #include "ActiveWindow.h"

-#include "ArrayList.h"

 

 // +--------------------------------------------------------------------+

 

@@ -34,15 +33,15 @@ public:
 	virtual void   AddCol(DWORD min_width,  float col_factor);

 	virtual void   AddRow(DWORD min_height, float row_factor);

 

-	virtual void   SetConstraints(const ArrayList& min_x,

-	const ArrayList& min_y,

-	const FloatList& weight_x,

-	const FloatList& weight_y);

+	virtual void   SetConstraints(const std::vector<DWORD>& min_x,

+	const std::vector<DWORD>& min_y,

+	const std::vector<float>& weight_x,

+	const std::vector<float>& weight_y);

 

-	virtual void   SetConstraints(const FloatList& min_x,

-	const FloatList& min_y,

-	const FloatList& weight_x,

-	const FloatList& weight_y);

+	virtual void   SetConstraints(const std::vector<float>& min_x,

+	const std::vector<float>& min_y,

+	const std::vector<float>& weight_x,

+	const std::vector<float>& weight_y);

 

 	virtual void   SetConstraints(int            ncols,

 	int            nrows,

@@ -54,12 +53,12 @@ public:
 

 protected:

 	virtual void   ScaleWeights();

-	virtual void   CalcCells(DWORD w, DWORD h, ArrayList& cell_x, ArrayList& cell_y);

+	virtual void   CalcCells(DWORD w, DWORD h, std::vector<DWORD>& cell_x, std::vector<DWORD>& cell_y);

 

-	ArrayList   cols;

-	ArrayList   rows;

-	FloatList   col_weights;

-	FloatList   row_weights;

+	std::vector<DWORD>   cols;

+	std::vector<DWORD>   rows;

+	std::vector<float>   col_weights;

+	std::vector<float>   row_weights;

 };

 

 #endif Layout_h

diff --git a/nGenEx/ParseUtil.cpp b/nGenEx/ParseUtil.cpp
index 6e64e39..01e8370 100644
--- a/nGenEx/ParseUtil.cpp
+++ b/nGenEx/ParseUtil.cpp
@@ -390,7 +390,7 @@ bool GetDefArray(double* dst, int size, TermDef* def, const char* file)
 

 // +--------------------------------------------------------------------+

 

-bool GetDefArray(ArrayList& array, TermDef* def, const char* file)

+bool GetDefArray(std::vector<DWORD>& array, TermDef* def, const char* file)

 {

 	if (!def || !def->term()) {

 		Print("WARNING: missing ARRAY TermDef in '%s'\n", file);

@@ -404,7 +404,7 @@ bool GetDefArray(ArrayList& array, TermDef* def, const char* file)
 		array.clear();

 

 		for (int i = 0; i < nelem; i++)

-		array.append((DWORD) (val->elements()->at(i)->isNumber()->value()));

+			array.push_back((DWORD) (val->elements()->at(i)->isNumber()->value()));

 

 		return true;

 	}

@@ -415,7 +415,7 @@ bool GetDefArray(ArrayList& array, TermDef* def, const char* file)
 	return false;

 }

 

-bool GetDefArray(FloatList& array, TermDef* def, const char* file)

+bool GetDefArray(std::vector<float>& array, TermDef* def, const char* file)

 {

 	if (!def || !def->term()) {

 		Print("WARNING: missing ARRAY TermDef in '%s'\n", file);

@@ -429,7 +429,7 @@ bool GetDefArray(FloatList& array, TermDef* def, const char* file)
 		array.clear();

 

 		for (int i = 0; i < nelem; i++)

-		array.append((float) (val->elements()->at(i)->isNumber()->value()));

+			array.push_back((float) (val->elements()->at(i)->isNumber()->value()));

 

 		return true;

 	}

diff --git a/nGenEx/ParseUtil.h b/nGenEx/ParseUtil.h
index 4f43a02..701bc18 100644
--- a/nGenEx/ParseUtil.h
+++ b/nGenEx/ParseUtil.h
@@ -15,10 +15,10 @@
 #ifndef ParseUtil_h

 #define ParseUtil_h

 

+#include <vector>

 #include "Types.h"

 #include "Geometry.h"

 #include "Color.h"

-#include "ArrayList.h"

 

 #include "Text.h"

 #include "Parser.h"

@@ -44,8 +44,8 @@ bool GetDefTime(int& dst, TermDef* def, const char* file);
 bool GetDefArray(int*    dst, int size, TermDef* def, const char* file);

 bool GetDefArray(float*  dst, int size, TermDef* def, const char* file);

 bool GetDefArray(double* dst, int size, TermDef* def, const char* file);

-bool GetDefArray(ArrayList& array,      TermDef* def, const char* file);

-bool GetDefArray(FloatList& array,      TermDef* def, const char* file);

+bool GetDefArray(std::vector<DWORD>& array,      TermDef* def, const char* file);

+bool GetDefArray(std::vector<float>& array,      TermDef* def, const char* file);

 

 // +--------------------------------------------------------------------+

 

diff --git a/nGenEx/VideoDX9Enum.cpp b/nGenEx/VideoDX9Enum.cpp
index 9ec92b5..68f5264 100644
--- a/nGenEx/VideoDX9Enum.cpp
+++ b/nGenEx/VideoDX9Enum.cpp
@@ -258,13 +258,13 @@ VideoDX9Enum::Enumerate()
 		Print("----------------------------------------\n\n");

 	}

 

-	allowed_adapter_format_list.append(D3DFMT_X8R8G8B8);

-	allowed_adapter_format_list.append(D3DFMT_X1R5G5B5);

-	allowed_adapter_format_list.append(D3DFMT_R5G6B5);

-	allowed_adapter_format_list.append(D3DFMT_A2R10G10B10);

+	allowed_adapter_format_list.push_back(D3DFMT_X8R8G8B8);

+	allowed_adapter_format_list.push_back(D3DFMT_X1R5G5B5);

+	allowed_adapter_format_list.push_back(D3DFMT_R5G6B5);

+	allowed_adapter_format_list.push_back(D3DFMT_A2R10G10B10);

 

 	VideoDX9AdapterInfo* adapter_info = 0;

-	ArrayList            adapter_format_list;

+	std::vector<D3DFORMAT> adapter_format_list;

 	UINT                 num_adapters = d3d->GetAdapterCount();

 

 	for (UINT ordinal = 0; ordinal < num_adapters; ordinal++) {

@@ -279,8 +279,8 @@ VideoDX9Enum::Enumerate()
 		// Also build a temporary list of all display adapter formats.

 		adapter_format_list.clear();

 

-		for (int iaaf = 0; iaaf < allowed_adapter_format_list.size(); iaaf++) {

-			D3DFORMAT allowed_adapter_format = (D3DFORMAT) allowed_adapter_format_list[iaaf];

+		for (size_t iaaf = 0; iaaf < allowed_adapter_format_list.size(); iaaf++) {

+			D3DFORMAT allowed_adapter_format = allowed_adapter_format_list[iaaf];

 			UINT      num_adapter_modes      = d3d->GetAdapterModeCount(ordinal, allowed_adapter_format);

 			

 			for (UINT mode = 0; mode < num_adapter_modes; mode++) {

@@ -302,8 +302,16 @@ VideoDX9Enum::Enumerate()
 

 				adapter_info->display_mode_list.append(dx9_display_mode);

 

-				if (!adapter_format_list.contains(display_mode.Format))

-				adapter_format_list.append(display_mode.Format);

+				bool contains_display_mode = false;

+				for (auto afli = adapter_format_list.begin(); afli != adapter_format_list.end(); ++afli) {

+					if (*afli == display_mode.Format) {

+						contains_display_mode = true;

+						break;

+					}

+				}

+				if (!contains_display_mode)

+					adapter_format_list.push_back(display_mode.Format);

+				

 			}

 		}

 

@@ -350,7 +358,7 @@ VideoDX9Enum::Enumerate()
 // +--------------------------------------------------------------------+

 

 HRESULT  

-VideoDX9Enum::EnumerateDevices(VideoDX9AdapterInfo* adapter_info, ArrayList& adapter_format_list)

+VideoDX9Enum::EnumerateDevices(VideoDX9AdapterInfo* adapter_info, std::vector<D3DFORMAT>& adapter_format_list)

 {

 	HRESULT              hr          = E_FAIL;

 	const D3DDEVTYPE     dtypes[3]   = { D3DDEVTYPE_HAL, D3DDEVTYPE_SW, D3DDEVTYPE_REF };

@@ -399,7 +407,7 @@ VideoDX9Enum::EnumerateDevices(VideoDX9AdapterInfo* adapter_info, ArrayList& ada
 // +--------------------------------------------------------------------+

 

 HRESULT  

-VideoDX9Enum::EnumerateDeviceCombos(VideoDX9DeviceInfo* device_info, ArrayList& adapter_format_list)

+VideoDX9Enum::EnumerateDeviceCombos(VideoDX9DeviceInfo* device_info, std::vector<D3DFORMAT>& adapter_format_list)

 {

 	const D3DFORMAT back_buffer_formats[] = {

 		D3DFMT_A8R8G8B8,

@@ -414,8 +422,8 @@ VideoDX9Enum::EnumerateDeviceCombos(VideoDX9DeviceInfo* device_info, ArrayList&
 

 	// See which adapter formats are supported by this device

 	D3DFORMAT a_fmt;

-	for (int i = 0; i < adapter_format_list.size(); i++) {

-		a_fmt = (D3DFORMAT) adapter_format_list[i];

+	for (size_t i = 0; i < adapter_format_list.size(); i++) {

+		a_fmt = adapter_format_list[i];

 		

 		D3DFORMAT b_fmt;

 		for (int n = 0; n < 6; n++) {

@@ -524,7 +532,7 @@ VideoDX9Enum::BuildDepthStencilFormatList(VideoDX9DeviceCombo* device_combo)
 							device_combo->back_buffer_format,

 							fmt))) {

 

-				device_combo->depth_stencil_fmt_list.append(fmt);

+				device_combo->depth_stencil_fmt_list.push_back(fmt);

 			}

 		}

 	}

@@ -564,8 +572,8 @@ VideoDX9Enum::BuildMultiSampleTypeList(VideoDX9DeviceCombo* device_combo)
 						multisample_type,

 						&multisample_qual))) {

 

-			device_combo->multisample_type_list.append(multisample_type);

-			device_combo->multisample_qual_list.append(multisample_qual);

+			device_combo->multisample_type_list.push_back(multisample_type);

+			device_combo->multisample_qual_list.push_back(multisample_qual);

 		}

 	}

 }

@@ -573,10 +581,10 @@ VideoDX9Enum::BuildMultiSampleTypeList(VideoDX9DeviceCombo* device_combo)
 void  

 VideoDX9Enum::BuildDSMSConflictList(VideoDX9DeviceCombo* device_combo)

 {

-	for (int i = 0; i < device_combo->depth_stencil_fmt_list.size(); i++) {

+	for (size_t i = 0; i < device_combo->depth_stencil_fmt_list.size(); i++) {

 		D3DFORMAT depth_format = (D3DFORMAT) device_combo->depth_stencil_fmt_list[i];

 

-		for (int n = 0; n < device_combo->multisample_type_list.size(); n++) {

+		for (size_t n = 0; n < device_combo->multisample_type_list.size(); n++) {

 			D3DMULTISAMPLE_TYPE multisample_type = (D3DMULTISAMPLE_TYPE) device_combo->multisample_type_list[n];

 

 			if (FAILED(d3d->CheckDeviceMultiSampleType(device_combo->adapter_ordinal,

@@ -602,17 +610,17 @@ VideoDX9Enum::BuildVertexProcessingTypeList(VideoDX9DeviceInfo* device_info, Vid
 {

 	if ((device_info->caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) != 0) {

 		if ((device_info->caps.DevCaps & D3DDEVCAPS_PUREDEVICE) != 0) {

-			device_combo->vertex_processing_list.append(PURE_HARDWARE_VP);

+			device_combo->vertex_processing_list.push_back(PURE_HARDWARE_VP);

 		}

 

-		device_combo->vertex_processing_list.append(HARDWARE_VP);

+		device_combo->vertex_processing_list.push_back(HARDWARE_VP);

 

 		if (uses_mixed_vp) {

-			device_combo->vertex_processing_list.append(MIXED_VP);

+			device_combo->vertex_processing_list.push_back(MIXED_VP);

 		}

 	}

 

-	device_combo->vertex_processing_list.append(SOFTWARE_VP);

+	device_combo->vertex_processing_list.push_back(SOFTWARE_VP);

 }

 

 void  

@@ -641,7 +649,7 @@ VideoDX9Enum::BuildPresentIntervalList(VideoDX9DeviceInfo* device_info, VideoDX9
 		if (interval == D3DPRESENT_INTERVAL_DEFAULT ||

 				(device_info->caps.PresentationIntervals & interval)) {

 

-			device_combo->present_interval_list.append(interval);

+			device_combo->present_interval_list.push_back(interval);

 		}

 	}

 }

diff --git a/nGenEx/VideoDX9Enum.h b/nGenEx/VideoDX9Enum.h
index 57e00cd..e4e6f54 100644
--- a/nGenEx/VideoDX9Enum.h
+++ b/nGenEx/VideoDX9Enum.h
@@ -18,8 +18,8 @@
 #include <d3d9.h>

 

 #include "Video.h"

-#include "ArrayList.h"

 #include "List.h"

+#include <vector>

 

 // +--------------------------------------------------------------------+

 

@@ -72,8 +72,8 @@ public:
 	bool     req_fullscreen;

 

 private:

-	HRESULT  EnumerateDevices(VideoDX9AdapterInfo* adapter_info, ArrayList& adapter_format_list);

-	HRESULT  EnumerateDeviceCombos(VideoDX9DeviceInfo* device_info, ArrayList& adapter_format_list);

+	HRESULT  EnumerateDevices(VideoDX9AdapterInfo* adapter_info, std::vector<D3DFORMAT>& adapter_format_list);

+	HRESULT  EnumerateDeviceCombos(VideoDX9DeviceInfo* device_info, std::vector<D3DFORMAT>& adapter_format_list);

 

 	void     BuildDepthStencilFormatList(VideoDX9DeviceCombo* device_combo);

 	void     BuildMultiSampleTypeList(VideoDX9DeviceCombo* device_combo);

@@ -82,7 +82,7 @@ private:
 	void     BuildPresentIntervalList(VideoDX9DeviceInfo* device_info, VideoDX9DeviceCombo* device_combo);

 

 	IDirect3D9*                d3d;

-	ArrayList                  allowed_adapter_format_list;

+	std::vector<D3DFORMAT>     allowed_adapter_format_list;

 

 	List<VideoDX9AdapterInfo>  adapter_info_list;

 	int                        adapter_index;

@@ -170,11 +170,11 @@ struct VideoDX9DeviceCombo
 	D3DFORMAT            back_buffer_format;

 	bool                 is_windowed;

 

-	ArrayList            vertex_processing_list;

-	ArrayList            depth_stencil_fmt_list;

-	ArrayList            multisample_type_list;

-	ArrayList            multisample_qual_list;

-	ArrayList            present_interval_list;

+	std::vector<int>					vertex_processing_list;

+	std::vector<D3DFORMAT>				depth_stencil_fmt_list;

+	std::vector<D3DMULTISAMPLE_TYPE>	multisample_type_list;

+	std::vector<DWORD>					multisample_qual_list;

+	std::vector<DWORD>					present_interval_list;

 

 	List<VideoDX9FormatConflict> conflict_list;

 };

diff --git a/nGenEx/nGenEx.vcxproj b/nGenEx/nGenEx.vcxproj
index 29d4c0a..ddb89e3 100644
--- a/nGenEx/nGenEx.vcxproj
+++ b/nGenEx/nGenEx.vcxproj
@@ -346,7 +346,6 @@
   <ItemGroup>

     <ClCompile Include="ActiveWindow.cpp" />

     <ClCompile Include="Archive.cpp" />

-    <ClCompile Include="..\FoundationEx\ArrayList.cpp" />

     <ClCompile Include="AviFile.cpp" />

     <ClCompile Include="Bitmap.cpp" />

     <ClCompile Include="Bmp.cpp" />

@@ -430,7 +429,6 @@
   <ItemGroup>

     <ClInclude Include="ActiveWindow.h" />

     <ClInclude Include="Archive.h" />

-    <ClInclude Include="..\FoundationEx\ArrayList.h" />

     <ClInclude Include="AviFile.h" />

     <ClInclude Include="Bitmap.h" />

     <ClInclude Include="Bmp.h" />

diff --git a/nGenEx/nGenEx.vcxproj.filters b/nGenEx/nGenEx.vcxproj.filters
index e5049f1..3b4e538 100644
--- a/nGenEx/nGenEx.vcxproj.filters
+++ b/nGenEx/nGenEx.vcxproj.filters
@@ -17,9 +17,6 @@
     <ClCompile Include="Archive.cpp">

       <Filter>Source Files</Filter>

     </ClCompile>

-    <ClCompile Include="..\FoundationEx\ArrayList.cpp">

-      <Filter>Source Files</Filter>

-    </ClCompile>

     <ClCompile Include="AviFile.cpp">

       <Filter>Source Files</Filter>

     </ClCompile>

@@ -265,9 +262,6 @@
     <ClInclude Include="Archive.h">

       <Filter>Header Files</Filter>

     </ClInclude>

-    <ClInclude Include="..\FoundationEx\ArrayList.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

     <ClInclude Include="AviFile.h">

       <Filter>Header Files</Filter>

     </ClInclude>