CnC_Remastered_Collection

LIST.H (21114B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header: /CounterStrike/LIST.H 1     3/03/97 10:25a Joe_bostic $ */
 /***********************************************************************************************
  ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
  ***********************************************************************************************
  *                                                                                             *
  *                 Project Name : Command & Conquer                                            *
  *                                                                                             *
  *                    File Name : LIST.H                                                       *
  *                                                                                             *
  *                   Programmer : Joe L. Bostic                                                *
  *                                                                                             *
  *                   Start Date : 01/15/95                                                     *
  *                                                                                             *
  *                  Last Update : January 15, 1995 [JLB]                                       *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  * Functions:                                                                                  *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #ifndef LIST_H
 #define LIST_H
 
 #include "control.h"
 #include "shapebtn.h"
 #include "slider.h"
 
 
 /***************************************************************************
  * ListClass -- Like a Windows ListBox structure									*
  *                                                                         *
  * INPUT:      int x -- x position of gadget											*
  *					int y -- y position of gadget											*
  *					int w -- width of gadget												*
  *					int h -- height of gadget												*
  *					UWORD flags -- see enumeration choices								*
  *                                                                         *
  * OUTPUT:     none.																			*
  * WARNINGS:														   						*
  * HISTORY:    01/03/1995 MML : Created.                                   *
  *=========================================================================*/
 class ListClass : public ControlClass
 {
 	public:
 		ListClass(int id, int x, int y, int w, int h, TextPrintType flags, void const * up, void const * down);
 		ListClass(ListClass const & list);
 		virtual ~ListClass(void);
 
 		virtual int Add_Item(char const * text);
 		virtual int Add_Item(int text);
 		virtual int Add_Scroll_Bar(void);
 		virtual void Bump(int up);
 		virtual int Count(void) const {return List.Count();};
 		virtual int Current_Index(void) const;
 		virtual char const * Current_Item(void) const;
 		virtual int Draw_Me(int forced);
 		virtual char const * Get_Item(int index) const;
 		virtual int Step_Selected_Index(int forward);
 		virtual void Flag_To_Redraw(void);
 
 		virtual void Peer_To_Peer(unsigned flags, KeyNumType & key, ControlClass & whom);
 		virtual void Remove_Item(char const * text);
 		virtual void Remove_Item(int);
 		virtual int  Remove_Scroll_Bar(void);
 		virtual void Set_Selected_Index(int index);
 		virtual void Set_Selected_Index(char const * text);
 		virtual void Set_Tabs(int const * tabs);
 		virtual int  Set_View_Index(int index);
 		virtual void Step(int up);
 		virtual void Set_Position(int x, int y);
 
 		/*
 		** These overloaded list routines handle adding/removing the scroll bar
 		** automatically when the list box is added or removed.
 		*/
 		virtual LinkClass & Add(LinkClass & object);
 		virtual LinkClass & Add_Tail(LinkClass & object);
 		virtual LinkClass & Add_Head(LinkClass & object);
 		virtual GadgetClass * Remove(void);
 
 	protected:
 		virtual int  Action(unsigned flags, KeyNumType &key);
 		virtual void Draw_Entry(int index, int x, int y, int width, int selected);
 
 		/*
 		**	This controls what the text looks like. It uses the basic TPF_ flags that
 		**	are used to control Fancy_Text_Print().
 		*/
 		TextPrintType TextFlags;
 
 		/*
 		**	This is a series of tabstop pixel positions to use when processing any
 		**	<TAB> characters found in a list box string. The tabs are a series of
 		**	pixel offsets from the starting pixel position of the text.
 		*/
 		int const *Tabs;
 
 		/*
 		**	The actual list of text pointers is maintained by this list manager. The pointers
 		**	are stored in EMS. The text that is pointed to may also be in EMS.
 		*/
 		DynamicVectorClass<char const *> List;
 
 		/*
 		**	This is the total pixel height of a standard line of text. This is greatly
 		**	influenced by the TextFlags value.
 		*/
 		int LineHeight;
 
 		/*
 		**	This is the number of text lines that can fit within the list box.
 		*/
 		int LineCount;
 
 		/*
 		**	If the slider bar has been created, these point to the respective gadgets
 		**	that it is composed of.
 		*/
 		unsigned IsScrollActive:1;
 		ShapeButtonClass UpGadget;
 		ShapeButtonClass DownGadget;
 		SliderClass ScrollGadget;
 
 		/*
 		**	This is the currently selected index. It is highlighted.
 		*/
 		int SelectedIndex;
 
 		/*
 		**	This specifies the line (index) that is at the top of the list box.
 		*/
 		int CurrentTopIndex;
 };
 
 
 template<class T>
 class TListClass : public ControlClass
 {
 	public:
 		TListClass(int id, int x, int y, int w, int h, TextPrintType flags, void const * up, void const * down);
 		TListClass(TListClass<T> const & list);
 		virtual ~TListClass(void);
 		T operator [] (int index) const {return(List[index]);};
 		T & operator [] (int index) {return(List[index]);};
 
 		virtual int Add_Item(T text);
 		virtual int Add_Scroll_Bar(void);
 		virtual void Insert_Item(T item);
 		virtual void Bump(int up);
 		virtual int Count(void) const {return List.Count();};
 		virtual int Current_Index(void) const;
 		virtual T Current_Item(void) const;
 		virtual int Draw_Me(int forced);
 		virtual int Step_Selected_Index(int forward);
 		virtual void Flag_To_Redraw(void);
 		virtual T Get_Item(int index) const {return(List[index]);};
 
 		virtual void Peer_To_Peer(unsigned flags, KeyNumType & key, ControlClass & whom);
 		virtual void Remove_Item(T);
 		virtual void Remove_Index(int);
 		virtual int  Remove_Scroll_Bar(void);
 		virtual void Set_Selected_Index(int index);
 		virtual void Set_Selected_Index(T item);
 		virtual void Set_Tabs(int const * tabs);
 		virtual int  Set_View_Index(int index);
 		virtual void Step(int up);
 		virtual void Set_Position(int x, int y);
 
 		/*
 		** These overloaded list routines handle adding/removing the scroll bar
 		** automatically when the list box is added or removed.
 		*/
 		virtual LinkClass & Add(LinkClass & object);
 		virtual LinkClass & Add_Tail(LinkClass & object);
 		virtual LinkClass & Add_Head(LinkClass & object);
 		virtual GadgetClass * Remove(void);
 
 	protected:
 		virtual int  Action(unsigned flags, KeyNumType &key);
 
 		/*
 		**	This controls what the text looks like. It uses the basic TPF_ flags that
 		**	are used to control Fancy_Text_Print().
 		*/
 		TextPrintType TextFlags;
 
 		/*
 		**	This is a series of tabstop pixel positions to use when processing any
 		**	<TAB> characters found in a list box string. The tabs are a series of
 		**	pixel offsets from the starting pixel position of the text.
 		*/
 		int const * Tabs;
 
 		/*
 		**	The actual list of text pointers is maintained by this list manager.
 		*/
 		DynamicVectorClass<T> List;
 
 		/*
 		**	This is the total pixel height of a standard line of text. This is greatly
 		**	influenced by the TextFlags value.
 		*/
 		int LineHeight;
 
 		/*
 		**	This is the number of text lines that can fit within the list box.
 		*/
 		int LineCount;
 
 		/*
 		**	If the slider bar has been created, these point to the respective gadgets
 		**	that it is composed of.
 		*/
 		unsigned IsScrollActive:1;
 		ShapeButtonClass UpGadget;
 		ShapeButtonClass DownGadget;
 		SliderClass ScrollGadget;
 
 		/*
 		**	This is the currently selected index. It is highlighted.
 		*/
 		int SelectedIndex;
 
 		/*
 		**	This specifies the line (index) that is at the top of the list box.
 		*/
 		int CurrentTopIndex;
 };
 
 template<class T>
 TListClass<T>::TListClass(int id, int x, int y, int w, int h, TextPrintType flags, void const * up, void const * down) :
 	ControlClass(id, x, y, w, h, LEFTPRESS | LEFTRELEASE | KEYBOARD, false),
 	UpGadget(0, up, x+w, y),
 	DownGadget(0, down, x+w, y+h),
 	ScrollGadget(0, x+w, y, 0, h, true),
 	TextFlags(flags),
 	Tabs(0),
 	IsScrollActive(false),
 	SelectedIndex(0),
 	CurrentTopIndex(0)
 {
 	/*
 	**	Set preliminary values for the slider related gadgets. They don't automatically
 	**	appear at this time, but there are some values that can be pre-filled in.
 	*/
 	UpGadget.X -= UpGadget.Width;
 	DownGadget.X -= DownGadget.Width;
 	DownGadget.Y -= DownGadget.Height;
 	ScrollGadget.X -= max(UpGadget.Width, DownGadget.Width);
 	ScrollGadget.Y = Y+UpGadget.Height;
 	ScrollGadget.Height -= UpGadget.Height + DownGadget.Height;
 	ScrollGadget.Width = max(UpGadget.Width, DownGadget.Width);
 
 	/*
 	**	Set the list box to a default state.
 	*/
 	Fancy_Text_Print(TXT_NONE, 0, 0, TBLACK, TBLACK, TextFlags);
 	LineHeight = FontHeight+FontYSpacing-1;
 	LineCount = (h-1) / LineHeight;
 }
 
 template<class T>
 TListClass<T>::TListClass(TListClass<T> const & list) :
 	ControlClass(list),
 	TextFlags(list.TextFlags),
 	Tabs(list.Tabs),
 	List(list.List),
 	LineHeight(list.LineHeight),
 	LineCount(list.LineCount),
 	IsScrollActive(list.IsScrollActive),
 	UpGadget(list.UpGadget),
 	DownGadget(list.DownGadget),
 	ScrollGadget(list.ScrollGadget),
 	SelectedIndex(list.SelectedIndex),
 	CurrentTopIndex(list.CurrentTopIndex)
 {
 	UpGadget.Make_Peer(*this);
 	DownGadget.Make_Peer(*this);
 	ScrollGadget.Make_Peer(*this);
 }
 
 template<class T>
 void TListClass<T>::Set_Position(int x, int y)
 {
 	UpGadget.X = x + Width - UpGadget.Width;
 	UpGadget.Y = y;
 	DownGadget.X = x + Width - DownGadget.Width;
 	DownGadget.Y = y + Height - DownGadget.Height;
 	ScrollGadget.X = x + Width - max(UpGadget.Width, DownGadget.Width);
 	ScrollGadget.Y = y + UpGadget.Height;
 	ScrollGadget.Height = Height - (UpGadget.Height + DownGadget.Height);
 	ScrollGadget.Width = max(UpGadget.Width, DownGadget.Width);
 }
 
 template<class T>
 TListClass<T>::~TListClass(void)
 {
 	Remove_Scroll_Bar();
 }
 
 template<class T>
 void TListClass<T>::Insert_Item(T item)
 {
 	if (Current_Index() >= Count()) {
 		List.Add(item);
 	} else {
 		List.Add(item);
 
 		/*
 		**	Move all trailing items upward.
 		*/
 		for (int index = List.Count()-1; index >= Current_Index(); index--) {
 			List[index+1] = List[index];
 		}
 
 		/*
 		**	Insert the new item into the location at the current index.
 		*/
 		List[Current_Index()] = item;
 	}
 }
 
 
 template<class T>
 int TListClass<T>::Add_Item(T text)
 {
 //	if (text) {
 		List.Add(text);
 		Flag_To_Redraw();
 
 		/*
 		**	Add scroll gadget if the list gets too large to display all of the items
 		**	at the same time.
 		*/
 		if (List.Count() > LineCount) {
 			Add_Scroll_Bar();
 		}
 
 		/*
 		**	Tell the slider that there is one more entry in the list.
 		*/
 		if (IsScrollActive) {
 			ScrollGadget.Set_Maximum(List.Count());
 		}
 //	}
 	return(List.Count() - 1);
 }
 
 template<class T>
 void TListClass<T>::Remove_Index(int index)
 {
 	if ((unsigned)index < List.Count()) {
 		List.Delete(index);
 
 		/*
 		**	If the list is now small enough to display completely within the list box region,
 		**	then delete the slider gadget (if they are present).
 		*/
 		if (List.Count() <= LineCount) {
 			Remove_Scroll_Bar();
 		}
 
 		/*
 		**	Tell the slider that there is one less entry in the list.
 		*/
 		if (IsScrollActive) {
 			ScrollGadget.Set_Maximum(List.Count());
 		}
 
 		/*
 		** If we just removed the selected entry, select the previous one
 		*/
 		if (SelectedIndex >= List.Count()) {
 			SelectedIndex--;
 			if (SelectedIndex < 0) {
 				SelectedIndex = 0;
 			}
 		}
 
 		/*
 		** If we just removed the top-displayed entry, step up one item
 		*/
 		if (CurrentTopIndex >= List.Count()) {
 			CurrentTopIndex--;
 			if (CurrentTopIndex < 0)
 				CurrentTopIndex = 0;
 			if (IsScrollActive)
 				ScrollGadget.Step(1);
 		}
 	}
 }
 
 template<class T>
 void TListClass<T>::Remove_Item(T text)
 {
 	Remove_Index(List.ID(text));
 }
 
 template<class T>
 int TListClass<T>::Action(unsigned flags, KeyNumType & key)
 {
 	if (flags & LEFTRELEASE) {
 		key = KN_NONE;
 		flags &= (~LEFTRELEASE);
 		ControlClass::Action(flags, key);
 		return(true);
 	} else {
 
 		/*
 		** Handle keyboard events here.
 		*/
 		if (flags & KEYBOARD) {
 
 			/*
 			**	Process the keyboard character. If indicated, consume this keyboard event
 			**	so that the edit gadget ID number is not returned.
 			*/
 			if (key == KN_UP) {
 				Step_Selected_Index(-1);
 				key = KN_NONE;
 			} else if (key == KN_DOWN) {
 				Step_Selected_Index(1);
 				key = KN_NONE;
 			} else {
 				flags &= ~KEYBOARD;
 			}
 
 		} else {
 
 			int index = Get_Mouse_Y() - (Y+1);
 			index = index / LineHeight;
 			SelectedIndex = CurrentTopIndex + index;
 			SelectedIndex = min(SelectedIndex, List.Count()-1);
 		}
 	}
 	return(ControlClass::Action(flags, key));
 }
 
 template<class T>
 int TListClass<T>::Draw_Me(int forced)
 {
 	if (GadgetClass::Draw_Me(forced)) {
 
 		/*
 		**	Turn off the mouse.
 		*/
 		if (LogicPage == &SeenBuff) {
 			Conditional_Hide_Mouse(X, Y, X+Width, Y+Height);
 		}
 
 		Draw_Box(X, Y, Width, Height, BOXSTYLE_BOX, true);
 
 		/*
 		**	Draw List.
 		*/
 		if (List.Count()) {
 			for (int index = 0; index < LineCount; index++)  {
 				int line = CurrentTopIndex + index;
 
 				if (List.Count() > line) {
 
 					/*
 					**	Prints the text and handles right edge clipping and tabs.
 					*/
 					List[line]->Draw_It(line, X+1, Y+(LineHeight*index)+1, Width-2, LineHeight, (line == SelectedIndex), TextFlags);
 //					List[index].Draw_It(line, X+1, Y+(LineHeight*index)+1, Width-2, LineHeight, (line == SelectedIndex), TextFlags);
 //					Draw_Entry(line, X+1, Y+(LineHeight*index)+1, Width-2, (line == SelectedIndex));
 				}
 			}
 		}
 
 		/*
 		**	Turn on the mouse.
 		*/
 		if (LogicPage == &SeenBuff) {
 			Conditional_Show_Mouse();
 		}
 		return(true);
 	}
 	return(false);
 }
 
 template<class T>
 void TListClass<T>::Bump(int up)
 {
 	if (IsScrollActive) {
 		if (ScrollGadget.Step(up)) {
 			CurrentTopIndex = ScrollGadget.Get_Value();
 			Flag_To_Redraw();
 		}
 	}
 }
 
 template<class T>
 void TListClass<T>::Step(int up)
 {
 	if (IsScrollActive) {
 		if (ScrollGadget.Step(up)) {
 			CurrentTopIndex = ScrollGadget.Get_Value();
 			Flag_To_Redraw();
 		}
 	}
 }
 
 #ifdef NEVER
 template<class T>
 T TListClass<T>::Get_Item(int index) const
 {
 	index = min(index, List.Count());
 	return(List[index]);
 }
 #endif
 
 template<class T>
 T TListClass<T>::Current_Item(void) const
 {
 	static T _temp;
 	if (List.Count() <= SelectedIndex) {
 		return(_temp);
 	}
 	return(List[SelectedIndex]);
 }
 
 template<class T>
 int TListClass<T>::Current_Index(void) const
 {
 	return(SelectedIndex);
 }
 
 template<class T>
 void TListClass<T>::Peer_To_Peer(unsigned flags, KeyNumType &, ControlClass & whom)
 {
 	if (flags & LEFTRELEASE) {
 		if (&whom == &UpGadget) {
 			Step(true);
 		}
 		if (&whom == &DownGadget) {
 			Step(false);
 		}
 	}
 
 	/*
 	**	The slider has changed, so reflect the current list position
 	**	according to the slider setting.
 	*/
 	if (&whom == &ScrollGadget) {
 		Set_View_Index(ScrollGadget.Get_Value());
 	}
 }
 
 template<class T>
 int TListClass<T>::Set_View_Index(int index)
 {
 	index = Bound(index, 0, List.Count() - LineCount);
 	if (index != CurrentTopIndex) {
 		CurrentTopIndex = index;
 		Flag_To_Redraw();
 		if (IsScrollActive) {
 			ScrollGadget.Set_Value(CurrentTopIndex);
 		}
 		return(true);
 	}
 	return(false);
 }
 
 template<class T>
 int TListClass<T>::Add_Scroll_Bar(void)
 {
 	if (!IsScrollActive) {
 		IsScrollActive = true;
 
 		/*
 		**	Everything has been created successfully. Flag the list box to be
 		**	redrawn because it now must be made narrower to accomodate the new
 		**	slider gadgets.
 		*/
 		Flag_To_Redraw();
 		Width -= ScrollGadget.Width;
 
 		/*
 		**	Tell the newly created gadgets that they should inform this list box
 		**	whenever they get touched. In this way, the list box will automatically
 		**	be updated under control of the slider buttons.
 		*/
 		UpGadget.Make_Peer(*this);
 		DownGadget.Make_Peer(*this);
 		ScrollGadget.Make_Peer(*this);
 
 		/*
 		**	Add these newly created gadgets to the same gadget list that the
 		**	list box is part of.
 		*/
 		UpGadget.Add(*this);
 		DownGadget.Add(*this);
 		ScrollGadget.Add(*this);
 
 		/*
 		**	Make sure these added gadgets get redrawn at the next opportunity.
 		*/
 		UpGadget.Flag_To_Redraw();
 		DownGadget.Flag_To_Redraw();
 		ScrollGadget.Flag_To_Redraw();
 
 		/*
 		**	Inform the slider of the size of the window and the current view position.
 		*/
 		ScrollGadget.Set_Maximum(List.Count());
 		ScrollGadget.Set_Thumb_Size(LineCount);
 		ScrollGadget.Set_Value(CurrentTopIndex);
 
 		/*
 		**	Return with success flag.
 		*/
 		return(true);
 	}
 	return(false);
 }
 
 template<class T>
 int TListClass<T>::Remove_Scroll_Bar(void)
 {
 	if (IsScrollActive) {
 		IsScrollActive = false;
 		Width += ScrollGadget.Width;
 		ScrollGadget.Remove();
 		UpGadget.Remove();
 		DownGadget.Remove();
 		Flag_To_Redraw();
 		return(true);
 	}
 	return(false);
 }
 
 template<class T>
 void TListClass<T>::Set_Tabs(int const * tabs)
 {
 	Tabs = tabs;
 }
 
 #ifdef NEVER
 template<class T>
 void TListClass<T>::Draw_Entry(int index, int x, int y, int width, int selected)
 {
 	if (TextFlags & TPF_6PT_GRAD) {
 		TextPrintType flags = TextFlags;
 
 		if (selected) {
 			flags = flags | TPF_BRIGHT_COLOR;
 			LogicPage->Fill_Rect(x, y, x + width - 1, y + LineHeight - 1, CC_GREEN_SHADOW);
 		} else {
 			if (!(flags & TPF_USE_GRAD_PAL)) {
 				flags = flags | TPF_MEDIUM_COLOR;
 			}
 		}
 
 		Conquer_Clip_Text_Print(List[index], x, y, CC_GREEN, TBLACK, flags, width, Tabs);
 
 	} else {
 		Conquer_Clip_Text_Print(List[index], x, y, (selected ? BLUE : WHITE), TBLACK, TextFlags, width, Tabs);
 	}
 }
 #endif
 
 template<class T>
 LinkClass & TListClass<T>::Add(LinkClass & list)
 {
 	/*
 	**	Add the scroll bar gadgets if they're active.
 	*/
 	if (IsScrollActive) {
 		ScrollGadget.Add(list);
 		DownGadget.Add(list);
 		UpGadget.Add(list);
 	}
 
 	/*
 	**	Add myself to the list, then return.
 	*/
 	return(ControlClass::Add(list));
 }
 
 template<class T>
 LinkClass & TListClass<T>::Add_Head(LinkClass & list)
 {
 	/*
 	**	Add the scroll bar gadgets if they're active.
 	*/
 	if (IsScrollActive) {
 		ScrollGadget.Add_Head(list);
 		DownGadget.Add_Head(list);
 		UpGadget.Add_Head(list);
 	}
 
 	/*
 	**	Add myself to the list, then return.
 	*/
 	return(ControlClass::Add_Head(list));
 }
 
 template<class T>
 LinkClass & TListClass<T>::Add_Tail(LinkClass & list)
 {
 	/*
 	**	Add myself to the list.
 	*/
 	ControlClass::Add_Tail(list);
 
 	/*
 	**	Add the scroll bar gadgets if they're active.
 	*/
 	if (IsScrollActive) {
 		UpGadget.Add_Tail(list);
 		DownGadget.Add_Tail(list);
 		ScrollGadget.Add_Tail(list);
 	}
 
 	return(Head_Of_List());
 }
 
 template<class T>
 GadgetClass * TListClass<T>::Remove(void)
 {
 	/*
 	**	Remove the scroll bar if it's active
 	*/
 	if (IsScrollActive) {
 		ScrollGadget.Remove();
 		DownGadget.Remove();
 		UpGadget.Remove();
 	}
 
 	/*
 	**	Remove myself & return
 	*/
 	return(ControlClass::Remove());
 }
 
 template<class T>
 void TListClass<T>::Set_Selected_Index(int index)
 {
    if ((unsigned)index < List.Count()) {
 		SelectedIndex = index;
 		Flag_To_Redraw();
 		if (SelectedIndex < CurrentTopIndex) {
 			Set_View_Index(SelectedIndex);
 		}
 		if (SelectedIndex >= CurrentTopIndex+LineCount) {
 			Set_View_Index(SelectedIndex-(LineCount-1));
 		}
    }
 }
 
 template<class T>
 int TListClass<T>::Step_Selected_Index(int step)
 {
 	int old = SelectedIndex;
 
 	Set_Selected_Index(old + step);
 	return(old);
 }
 
 template<class T>
 void TListClass<T>::Flag_To_Redraw(void)
 {
 	if (IsScrollActive) {
 		UpGadget.Flag_To_Redraw();
 		DownGadget.Flag_To_Redraw();
 		ScrollGadget.Flag_To_Redraw();
 	}
 	ControlClass::Flag_To_Redraw();
 }
 
 template<class T>
 void TListClass<T>::Set_Selected_Index(T text)
 {
 	for (int index = 0; index < Count(); index++) {
 		if (text == Get_Item(index)) {
 			Set_Selected_Index(index);
 			break;
 		}
 	}
 }
 
 
 #endif