/*===========================================================================
    C++ class definitions exported from UnrealScript.
    This is automatically generated by the tools.
    DO NOT modify this manually! Edit the corresponding .uc files instead!
===========================================================================*/
#if SUPPORTS_PRAGMA_PACK
#pragma pack (push,4)
#endif

#ifndef XINTERFACE_API
#define XINTERFACE_API DLL_IMPORT
#endif

#ifndef NAMES_ONLY
#define AUTOGENERATE_NAME(name) extern XINTERFACE_API FName XINTERFACE_##name;
#define AUTOGENERATE_FUNCTION(cls,idx,name)
#endif

AUTOGENERATE_NAME(AlignThumb)
AUTOGENERATE_NAME(ButtonPressed)
AUTOGENERATE_NAME(ButtonReleased)
AUTOGENERATE_NAME(ChangeFocus)
AUTOGENERATE_NAME(ChangeHint)
AUTOGENERATE_NAME(CompareItem)
AUTOGENERATE_NAME(CreateMenu)
AUTOGENERATE_NAME(FindComponentIndex)
AUTOGENERATE_NAME(FocusFirst)
AUTOGENERATE_NAME(FocusLast)
AUTOGENERATE_NAME(GetFont)
AUTOGENERATE_NAME(GetMenuFont)
AUTOGENERATE_NAME(GetSortString)
AUTOGENERATE_NAME(GetStyle)
AUTOGENERATE_NAME(HandleParameters)
AUTOGENERATE_NAME(Initialize)
AUTOGENERATE_NAME(LoseFocus)
AUTOGENERATE_NAME(MenuStateChange)
AUTOGENERATE_NAME(MoveFocused)
AUTOGENERATE_NAME(NextControl)
AUTOGENERATE_NAME(NextPage)
AUTOGENERATE_NAME(OnActivate)
AUTOGENERATE_NAME(OnAdjustTop)
AUTOGENERATE_NAME(OnCanClose)
AUTOGENERATE_NAME(OnCapturedMouseMove)
AUTOGENERATE_NAME(OnChange)
AUTOGENERATE_NAME(OnClick)
AUTOGENERATE_NAME(OnClose)
AUTOGENERATE_NAME(OnColumnSized)
AUTOGENERATE_NAME(OnDblClick)
AUTOGENERATE_NAME(OnDeActivate)
AUTOGENERATE_NAME(OnDraw)
AUTOGENERATE_NAME(OnDrawCaption)
AUTOGENERATE_NAME(OnDrawItem)
AUTOGENERATE_NAME(OnDrawText)
AUTOGENERATE_NAME(OnEndOfLine)
AUTOGENERATE_NAME(OnHitTest)
AUTOGENERATE_NAME(OnInvalidate)
AUTOGENERATE_NAME(OnKeyEvent)
AUTOGENERATE_NAME(OnKeyType)
AUTOGENERATE_NAME(OnLoadINI)
AUTOGENERATE_NAME(OnMessage)
AUTOGENERATE_NAME(OnMousePressed)
AUTOGENERATE_NAME(OnMouseRelease)
AUTOGENERATE_NAME(OnNeedRawKeyPress)
AUTOGENERATE_NAME(OnOpen)
AUTOGENERATE_NAME(OnPreDraw)
AUTOGENERATE_NAME(OnRender)
AUTOGENERATE_NAME(OnReOpen)
AUTOGENERATE_NAME(OnRightClick)
AUTOGENERATE_NAME(OnSaveINI)
AUTOGENERATE_NAME(OnScrollZoneClick)
AUTOGENERATE_NAME(OnSortChanged)
AUTOGENERATE_NAME(OnWatch)
AUTOGENERATE_NAME(PrevControl)
AUTOGENERATE_NAME(PrevPage)
AUTOGENERATE_NAME(SetFocus)
AUTOGENERATE_NAME(SetText)
AUTOGENERATE_NAME(Swap)
AUTOGENERATE_NAME(Timer)

#ifndef NAMES_ONLY

enum EScaleMode
{
    SM_None                 =0,
    SM_Up                   =1,
    SM_Down                 =2,
    SM_Left                 =3,
    SM_Right                =4,
    SM_MAX                  =5,
};
struct XINTERFACE_API FDigitSet
{
    class UMaterial* DigitTexture;
    FIntBox TextureCoords[11];
};

struct XINTERFACE_API FSpriteWidget
{
    class UMaterial* WidgetTexture;
    BYTE RenderStyle;
    FIntBox TextureCoords;
    FLOAT TextureScale;
    BYTE DrawPivot;
    FLOAT PosX;
    FLOAT PosY;
    INT OffsetX;
    INT OffsetY;
    BYTE ScaleMode;
    FLOAT Scale;
    FColor Tints[2];
};

struct XINTERFACE_API FNumericWidget
{
    BYTE RenderStyle;
    INT MinDigitCount;
    FLOAT TextureScale;
    BYTE DrawPivot;
    FLOAT PosX;
    FLOAT PosY;
    INT OffsetX;
    INT OffsetY;
    FColor Tints[2];
    INT bPadWithZeroes;
    INT Value;
};

struct XINTERFACE_API FHudLocalizedMessage
{
    class UClass* Message;
    FStringNoInit StringMessage;
    INT Switch;
    class APlayerReplicationInfo* RelatedPRI;
    class APlayerReplicationInfo* RelatedPRI2;
    class UObject* OptionalObject;
    FLOAT EndOfLife;
    FLOAT Lifetime;
    class UFont* StringFont;
    FColor DrawColor;
    BYTE DrawPivot;
    BYTE StackMode;
    FLOAT PosX;
    FLOAT PosY;
    FLOAT dx;
    FLOAT dy;
    BITFIELD Drawn:1 GCC_PACK(4);
};


class XINTERFACE_API AHudBase : public AHUD
{
public:
    INT TeamIndex;
    BYTE PassStyle;
    FHudLocalizedMessage LocalMessages[8];
    class UClass* VoteMenuClass;
    class UMaterial* TargetMaterial;
    BITFIELD bShowTargeting:1 GCC_PACK(4);
    FVector TargetingLocation GCC_PACK(4);
    FLOAT TargetingSize;
    FStringNoInit InstructionText;
    FStringNoInit InstructionKeyText;
    FLOAT InstructTextBorderX;
    FLOAT InstructTextBorderY;
    FLOAT InstrDelta;
    FLOAT InstrRate;
    class UFont* InstructionFont;
    BITFIELD DoCropping:1 GCC_PACK(4);
    FLOAT CroppingAmount GCC_PACK(4);
    class UMaterial* CroppingMaterial;
    DECLARE_FUNCTION(execDrawNumericWidget);
    DECLARE_FUNCTION(execDrawSpriteWidget);
    DECLARE_CLASS(AHudBase,AHUD,0|CLASS_Transient|CLASS_Config,XInterface)
    NO_DEFAULT_CONSTRUCTOR(AHudBase)
};


struct UGUIController_eventMoveFocused_Parms
{
    class UGUIComponent* Ctrl;
    INT bmLeft;
    INT bmTop;
    INT bmWidth;
    INT bmHeight;
    FLOAT ClipX;
    FLOAT ClipY;
};
struct UGUIController_eventChangeFocus_Parms
{
    class UGUIComponent* Who;
};
struct UGUIController_eventCreateMenu_Parms
{
    FString NewMenuName;
    class UGUIPage* ReturnValue;
};
struct UGUIController_eventOnNeedRawKeyPress_Parms
{
    BYTE NewKey;
    BITFIELD ReturnValue;
};
struct UGUIController_eventGetStyle_Parms
{
    FString StyleName;
    class UGUIStyles* ReturnValue;
};
struct UGUIController_eventGetMenuFont_Parms
{
    FString FontName;
    class UGUIFont* ReturnValue;
};
class XINTERFACE_API UGUIController : public UBaseGUIController
{
public:
    TArrayNoInit<class UGUIPage*> MenuStack;
    class UGUIPage* ActivePage;
    TArrayNoInit<class UGUIFont*> FontStack;
    TArrayNoInit<class UGUIStyles*> StyleStack;
    TArrayNoInit<FString> StyleNames;
    TArrayNoInit<class UMaterial*> MouseCursors;
    TArrayNoInit<FVector> MouseCursorOffset;
    TArrayNoInit<class UGUIPage*> PersistentStack;
    INT MouseX;
    INT MouseY;
    INT LastMouseX;
    INT LastMouseY;
    BITFIELD ShiftPressed:1 GCC_PACK(4);
    BITFIELD AltPressed:1;
    BITFIELD CtrlPressed:1;
    FLOAT DblClickWindow GCC_PACK(4);
    FLOAT LastClickTime;
    INT LastClickX;
    INT LastClickY;
    FLOAT ButtonRepeatDelay;
    BYTE RepeatKey;
    FLOAT RepeatDelta;
    FLOAT RepeatTime;
    FLOAT CursorFade;
    INT CursorStep;
    FLOAT FastCursorFade;
    INT FastCursorStep;
    class UGUIComponent* FocusedControl;
    class UGUIComponent* ActiveControl;
    class UGUIComponent* SkipControl;
    class UGUIComponent* MoveControl;
    BITFIELD bIgnoreNextRelease:1 GCC_PACK(4);
    BITFIELD bModAuthor:1;
    BITFIELD bDesignMode:1;
    BITFIELD bHighlightCurrent:1;
    BITFIELD bCurMenuInitialized:1;
    FStringNoInit GameResolution GCC_PACK(4);
    FLOAT MenuMouseSens;
    BITFIELD MainNotWanted:1 GCC_PACK(4);
    class USound* MouseOverSound GCC_PACK(4);
    class USound* ClickSound;
    class USound* EditSound;
    class USound* UpSound;
    class USound* DownSound;
    BITFIELD bForceMouseCheck:1 GCC_PACK(4);
    BITFIELD bIgnoreUntilPress:1;
    class UMaterial* WhiteBorder GCC_PACK(4);
    FScriptDelegate __OnNeedRawKeyPress__Delegate;
    DECLARE_FUNCTION(execResetKeyboard);
    DECLARE_FUNCTION(execLoadDecoText);
    DECLARE_FUNCTION(execGetProfileList);
    DECLARE_FUNCTION(execGetMapList);
    DECLARE_FUNCTION(execGetWeaponList);
    DECLARE_FUNCTION(execGetTeamSymbolList);
    DECLARE_FUNCTION(execGetMainMenuClass);
    DECLARE_FUNCTION(execGetCurrentRes);
    DECLARE_FUNCTION(execGetStyle);
    DECLARE_FUNCTION(execGetMenuFont);
    void eventMoveFocused(class UGUIComponent* Ctrl, INT bmLeft, INT bmTop, INT bmWidth, INT bmHeight, FLOAT ClipX, FLOAT ClipY)
    {
        UGUIController_eventMoveFocused_Parms Parms;
        Parms.Ctrl=Ctrl;
        Parms.bmLeft=bmLeft;
        Parms.bmTop=bmTop;
        Parms.bmWidth=bmWidth;
        Parms.bmHeight=bmHeight;
        Parms.ClipX=ClipX;
        Parms.ClipY=ClipY;
        ProcessEvent(FindFunctionChecked(XINTERFACE_MoveFocused),&Parms);
    }
    void eventChangeFocus(class UGUIComponent* Who)
    {
        UGUIController_eventChangeFocus_Parms Parms;
        Parms.Who=Who;
        ProcessEvent(FindFunctionChecked(XINTERFACE_ChangeFocus),&Parms);
    }
    class UGUIPage* eventCreateMenu(const FString& NewMenuName)
    {
        UGUIController_eventCreateMenu_Parms Parms;
        Parms.ReturnValue=0;
        Parms.NewMenuName=NewMenuName;
        ProcessEvent(FindFunctionChecked(XINTERFACE_CreateMenu),&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD delegateOnNeedRawKeyPress(BYTE NewKey)
    {
        UGUIController_eventOnNeedRawKeyPress_Parms Parms;
        Parms.ReturnValue=0;
        Parms.NewKey=NewKey;
        ProcessDelegate(XINTERFACE_OnNeedRawKeyPress,&__OnNeedRawKeyPress__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    class UGUIStyles* eventGetStyle(const FString& StyleName)
    {
        UGUIController_eventGetStyle_Parms Parms;
        Parms.ReturnValue=0;
        Parms.StyleName=StyleName;
        ProcessEvent(FindFunctionChecked(XINTERFACE_GetStyle),&Parms);
        return Parms.ReturnValue;
    }
    class UGUIFont* eventGetMenuFont(const FString& FontName)
    {
        UGUIController_eventGetMenuFont_Parms Parms;
        Parms.ReturnValue=0;
        Parms.FontName=FontName;
        ProcessEvent(FindFunctionChecked(XINTERFACE_GetMenuFont),&Parms);
        return Parms.ReturnValue;
    }
    DECLARE_CLASS(UGUIController,UBaseGUIController,0|CLASS_Config,XInterface)
		void  NativeMessage(const FString Msg, FLOAT MsgLife);
		UBOOL NativeKeyType(BYTE& iKey, TCHAR Unicode );
		UBOOL NativeKeyEvent(BYTE& iKey, BYTE& State, FLOAT Delta );
		void  NativeTick(FLOAT DeltaTime);
		void  NativePreRender(UCanvas* Canvas);
		void  NativePostRender(UCanvas* Canvas);

		virtual void LookUnderCursor(FLOAT dX, FLOAT dY);
		UGUIComponent* UnderCursor(FLOAT MouseX, FLOAT MouseY);
		
		UBOOL virtual MousePressed(UBOOL IsRepeat);								
		UBOOL virtual MouseReleased();
		
		UBOOL HasMouseMoved();								

		void PlayInterfaceSound(USound* sound);
		void PlayClickSound(BYTE SoundNum);
};

enum ePageAlign
{
    PGA_None                =0,
    PGA_Client              =1,
    PGA_Left                =2,
    PGA_Right               =3,
    PGA_Top                 =4,
    PGA_Bottom              =5,
    PGA_MAX                 =6,
};
enum eIconPosition
{
    ICP_Normal              =0,
    ICP_Center              =1,
    ICP_Scaled              =2,
    ICP_Stretched           =3,
    ICP_Bound               =4,
    ICP_MAX                 =5,
};
enum EMenuRenderStyle
{
    MSTY_None               =0,
    MSTY_Normal             =1,
    MSTY_Masked             =2,
    MSTY_Translucent        =3,
    MSTY_Modulated          =4,
    MSTY_Alpha              =5,
    MSTY_Additive           =6,
    MSTY_Subtractive        =7,
    MSTY_Particle           =8,
    MSTY_AlphaZ             =9,
    MSTY_MAX                =10,
};
enum eEditMask
{
    EDM_None                =0,
    EDM_Alpha               =1,
    EDM_Numeric             =2,
    EDM_MAX                 =3,
};
enum eImgAlign
{
    IMGA_TopLeft            =0,
    IMGA_Center             =1,
    IMGA_BottomRight        =2,
    IMGA_MAX                =3,
};
enum eImgStyle
{
    ISTY_Normal             =0,
    ISTY_Stretched          =1,
    ISTY_Scaled             =2,
    ISTY_Bound              =3,
    ISTY_Justified          =4,
    ISTY_MAX                =5,
};
enum eTextCase
{
    TXTC_None               =0,
    TXTC_Upper              =1,
    TXTC_Lower              =2,
    TXTC_MAX                =3,
};
enum eTextAlign
{
    TXTA_Left               =0,
    TXTA_Center             =1,
    TXTA_Right              =2,
    TXTA_MAX                =3,
};
enum eMenuState
{
    MSAT_Blurry             =0,
    MSAT_Watched            =1,
    MSAT_Focused            =2,
    MSAT_Pressed            =3,
    MSAT_Disabled           =4,
    MSAT_MAX                =5,
};
#define UCONST_QBTN_YesNoCancel 50
#define UCONST_QBTN_YesNo 48
#define UCONST_QBTN_AbortRetry 68
#define UCONST_QBTN_OkCancel 3
#define UCONST_QBTN_Ignore 128
#define UCONST_QBTN_Abort 64
#define UCONST_QBTN_No 32
#define UCONST_QBTN_Yes 16
#define UCONST_QBTN_Continue 8
#define UCONST_QBTN_Retry 4
#define UCONST_QBTN_Cancel 2
#define UCONST_QBTN_Ok 1

class XINTERFACE_API UGUI : public UObject
{
public:
    class UGUIController* Controller;
    DECLARE_CLASS(UGUI,UObject,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUI)
};

enum EClickSound
{
    CS_None                 =0,
    CS_Click                =1,
    CS_Edit                 =2,
    CS_Up                   =3,
    CS_Down                 =4,
    CS_MAX                  =5,
};

struct UGUIComponent_eventPrevPage_Parms
{
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventNextPage_Parms
{
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventPrevControl_Parms
{
    class UGUIComponent* Sender;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventNextControl_Parms
{
    class UGUIComponent* Sender;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventFocusLast_Parms
{
    class UGUIComponent* Sender;
    BITFIELD bIgnoreMultiTabStops;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventFocusFirst_Parms
{
    class UGUIComponent* Sender;
    BITFIELD bIgnoreMultiTabStops;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventLoseFocus_Parms
{
    class UGUIComponent* Sender;
};
struct UGUIComponent_eventSetFocus_Parms
{
    class UGUIComponent* Who;
};
struct UGUIComponent_eventMenuStateChange_Parms
{
    BYTE NewState;
};
struct UGUIComponent_eventTimer_Parms
{
};
struct UGUIComponent_eventOnSaveINI_Parms
{
    class UGUIComponent* Sender;
    FString ReturnValue;
};
struct UGUIComponent_eventOnLoadINI_Parms
{
    class UGUIComponent* Sender;
    FString S;
};
struct UGUIComponent_eventOnCapturedMouseMove_Parms
{
    FLOAT deltaX;
    FLOAT deltaY;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventOnKeyEvent_Parms
{
    BYTE Key;
    BYTE State;
    FLOAT Delta;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventOnKeyType_Parms
{
    BYTE Key;
    FString Unicode;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventOnChange_Parms
{
    class UGUIComponent* Sender;
};
struct UGUIComponent_eventOnMouseRelease_Parms
{
    class UGUIComponent* Sender;
};
struct UGUIComponent_eventOnMousePressed_Parms
{
    class UGUIComponent* Sender;
    BITFIELD bRepeat;
};
struct UGUIComponent_eventOnRightClick_Parms
{
    class UGUIComponent* Sender;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventOnDblClick_Parms
{
    class UGUIComponent* Sender;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventOnClick_Parms
{
    class UGUIComponent* Sender;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventOnInvalidate_Parms
{
};
struct UGUIComponent_eventOnMessage_Parms
{
    FString Msg;
    FLOAT MsgLife;
};
struct UGUIComponent_eventOnRender_Parms
{
    class UCanvas* Canvas;
};
struct UGUIComponent_eventOnHitTest_Parms
{
    FLOAT MouseX;
    FLOAT MouseY;
};
struct UGUIComponent_eventOnWatch_Parms
{
};
struct UGUIComponent_eventOnDeActivate_Parms
{
};
struct UGUIComponent_eventOnActivate_Parms
{
};
struct UGUIComponent_eventOnDraw_Parms
{
    class UCanvas* Canvas;
    BITFIELD ReturnValue;
};
struct UGUIComponent_eventOnPreDraw_Parms
{
    class UCanvas* Canvas;
    BITFIELD ReturnValue;
};
class XINTERFACE_API UGUIComponent : public UGUI
{
public:
    class UGUIComponent* MenuOwner;
    BYTE MenuState;
    FStringNoInit IniOption;
    FStringNoInit IniDefault;
    FStringNoInit StyleName;
    BITFIELD bBoundToParent:1 GCC_PACK(4);
    BITFIELD bScaleToParent:1;
    BITFIELD bHasFocus:1;
    BITFIELD bVisible:1;
    BITFIELD bAcceptsInput:1;
    BITFIELD bCaptureTabs:1;
    BITFIELD bCaptureMouse:1;
    BITFIELD bNeverFocus:1;
    BITFIELD bRepeatClick:1;
    BITFIELD bRequireReleaseClick:1;
    class UGUIComponent* FocusInstead GCC_PACK(4);
    FStringNoInit Hint;
    FLOAT WinTop;
    FLOAT WinLeft;
    FLOAT WinWidth;
    FLOAT WinHeight;
    INT MouseCursorIndex;
    BITFIELD bTabStop:1 GCC_PACK(4);
    BITFIELD bFocusOnWatch:1;
    INT Tag GCC_PACK(4);
    class UGUILabel* FriendlyLabel;
    BITFIELD bMouseOverSound:1 GCC_PACK(4);
    BYTE OnClickSound GCC_PACK(4);
    class UGUIStyles* Style;
    FLOAT Bounds[4];
    FLOAT ClientBounds[4];
    BITFIELD bPendingFocus:1 GCC_PACK(4);
    INT TimerIndex GCC_PACK(4);
    BITFIELD bTimerRepeat:1 GCC_PACK(4);
    FLOAT TimerCountdown GCC_PACK(4);
    FLOAT TimerInterval;
    FLOAT SaveX;
    FLOAT SaveY;
    FColor SaveColor;
    class UFont* SaveFont;
    BYTE SaveStyle;
    FScriptDelegate __OnPreDraw__Delegate;
    FScriptDelegate __OnDraw__Delegate;
    FScriptDelegate __OnActivate__Delegate;
    FScriptDelegate __OnDeActivate__Delegate;
    FScriptDelegate __OnWatch__Delegate;
    FScriptDelegate __OnHitTest__Delegate;
    FScriptDelegate __OnRender__Delegate;
    FScriptDelegate __OnMessage__Delegate;
    FScriptDelegate __OnInvalidate__Delegate;
    FScriptDelegate __OnClick__Delegate;
    FScriptDelegate __OnDblClick__Delegate;
    FScriptDelegate __OnRightClick__Delegate;
    FScriptDelegate __OnMousePressed__Delegate;
    FScriptDelegate __OnMouseRelease__Delegate;
    FScriptDelegate __OnChange__Delegate;
    FScriptDelegate __OnKeyType__Delegate;
    FScriptDelegate __OnKeyEvent__Delegate;
    FScriptDelegate __OnCapturedMouseMove__Delegate;
    FScriptDelegate __OnLoadINI__Delegate;
    FScriptDelegate __OnSaveINI__Delegate;
    DECLARE_FUNCTION(execActualTop);
    DECLARE_FUNCTION(execActualLeft);
    DECLARE_FUNCTION(execActualHeight);
    DECLARE_FUNCTION(execActualWidth);
    DECLARE_FUNCTION(execKillTimer);
    DECLARE_FUNCTION(execSetTimer);
    BITFIELD eventPrevPage()
    {
        UGUIComponent_eventPrevPage_Parms Parms;
        Parms.ReturnValue=0;
        ProcessEvent(FindFunctionChecked(XINTERFACE_PrevPage),&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD eventNextPage()
    {
        UGUIComponent_eventNextPage_Parms Parms;
        Parms.ReturnValue=0;
        ProcessEvent(FindFunctionChecked(XINTERFACE_NextPage),&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD eventPrevControl(class UGUIComponent* Sender)
    {
        UGUIComponent_eventPrevControl_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Sender=Sender;
        ProcessEvent(FindFunctionChecked(XINTERFACE_PrevControl),&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD eventNextControl(class UGUIComponent* Sender)
    {
        UGUIComponent_eventNextControl_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Sender=Sender;
        ProcessEvent(FindFunctionChecked(XINTERFACE_NextControl),&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD eventFocusLast(class UGUIComponent* Sender, BITFIELD bIgnoreMultiTabStops)
    {
        UGUIComponent_eventFocusLast_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Sender=Sender;
        Parms.bIgnoreMultiTabStops=bIgnoreMultiTabStops;
        ProcessEvent(FindFunctionChecked(XINTERFACE_FocusLast),&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD eventFocusFirst(class UGUIComponent* Sender, BITFIELD bIgnoreMultiTabStops)
    {
        UGUIComponent_eventFocusFirst_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Sender=Sender;
        Parms.bIgnoreMultiTabStops=bIgnoreMultiTabStops;
        ProcessEvent(FindFunctionChecked(XINTERFACE_FocusFirst),&Parms);
        return Parms.ReturnValue;
    }
    void eventLoseFocus(class UGUIComponent* Sender)
    {
        UGUIComponent_eventLoseFocus_Parms Parms;
        Parms.Sender=Sender;
        ProcessEvent(FindFunctionChecked(XINTERFACE_LoseFocus),&Parms);
    }
    void eventSetFocus(class UGUIComponent* Who)
    {
        UGUIComponent_eventSetFocus_Parms Parms;
        Parms.Who=Who;
        ProcessEvent(FindFunctionChecked(XINTERFACE_SetFocus),&Parms);
    }
    void eventMenuStateChange(BYTE NewState)
    {
        UGUIComponent_eventMenuStateChange_Parms Parms;
        Parms.NewState=NewState;
        ProcessEvent(FindFunctionChecked(XINTERFACE_MenuStateChange),&Parms);
    }
    void eventTimer()
    {
        if(IsProbing(NAME_Timer)) {
        ProcessEvent(FindFunctionChecked(XINTERFACE_Timer),NULL);
        }
    }
    FString delegateOnSaveINI(class UGUIComponent* Sender)
    {
        UGUIComponent_eventOnSaveINI_Parms Parms;
        Parms.Sender=Sender;
        ProcessDelegate(XINTERFACE_OnSaveINI,&__OnSaveINI__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    void delegateOnLoadINI(class UGUIComponent* Sender, const FString& S)
    {
        UGUIComponent_eventOnLoadINI_Parms Parms;
        Parms.Sender=Sender;
        Parms.S=S;
        ProcessDelegate(XINTERFACE_OnLoadINI,&__OnLoadINI__Delegate,&Parms);
    }
    BITFIELD delegateOnCapturedMouseMove(FLOAT deltaX, FLOAT deltaY)
    {
        UGUIComponent_eventOnCapturedMouseMove_Parms Parms;
        Parms.ReturnValue=0;
        Parms.deltaX=deltaX;
        Parms.deltaY=deltaY;
        ProcessDelegate(XINTERFACE_OnCapturedMouseMove,&__OnCapturedMouseMove__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD delegateOnKeyEvent(BYTE& Key, BYTE& State, FLOAT Delta)
    {
        UGUIComponent_eventOnKeyEvent_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Key=Key;
        Parms.State=State;
        Parms.Delta=Delta;
        ProcessDelegate(XINTERFACE_OnKeyEvent,&__OnKeyEvent__Delegate,&Parms);
        Key=Parms.Key;
        State=Parms.State;
        return Parms.ReturnValue;
    }
    BITFIELD delegateOnKeyType(BYTE& Key, const FString& Unicode)
    {
        UGUIComponent_eventOnKeyType_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Key=Key;
        Parms.Unicode=Unicode;
        ProcessDelegate(XINTERFACE_OnKeyType,&__OnKeyType__Delegate,&Parms);
        Key=Parms.Key;
        return Parms.ReturnValue;
    }
    void delegateOnChange(class UGUIComponent* Sender)
    {
        UGUIComponent_eventOnChange_Parms Parms;
        Parms.Sender=Sender;
        ProcessDelegate(XINTERFACE_OnChange,&__OnChange__Delegate,&Parms);
    }
    void delegateOnMouseRelease(class UGUIComponent* Sender)
    {
        UGUIComponent_eventOnMouseRelease_Parms Parms;
        Parms.Sender=Sender;
        ProcessDelegate(XINTERFACE_OnMouseRelease,&__OnMouseRelease__Delegate,&Parms);
    }
    void delegateOnMousePressed(class UGUIComponent* Sender, BITFIELD bRepeat)
    {
        UGUIComponent_eventOnMousePressed_Parms Parms;
        Parms.Sender=Sender;
        Parms.bRepeat=bRepeat;
        ProcessDelegate(XINTERFACE_OnMousePressed,&__OnMousePressed__Delegate,&Parms);
    }
    BITFIELD delegateOnRightClick(class UGUIComponent* Sender)
    {
        UGUIComponent_eventOnRightClick_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Sender=Sender;
        ProcessDelegate(XINTERFACE_OnRightClick,&__OnRightClick__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD delegateOnDblClick(class UGUIComponent* Sender)
    {
        UGUIComponent_eventOnDblClick_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Sender=Sender;
        ProcessDelegate(XINTERFACE_OnDblClick,&__OnDblClick__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD delegateOnClick(class UGUIComponent* Sender)
    {
        UGUIComponent_eventOnClick_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Sender=Sender;
        ProcessDelegate(XINTERFACE_OnClick,&__OnClick__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    void delegateOnInvalidate()
    {
        ProcessDelegate(XINTERFACE_OnInvalidate,&__OnInvalidate__Delegate,NULL);
    }
    void delegateOnMessage(const FString& Msg, FLOAT MsgLife)
    {
        UGUIComponent_eventOnMessage_Parms Parms;
        Parms.Msg=Msg;
        Parms.MsgLife=MsgLife;
        ProcessDelegate(XINTERFACE_OnMessage,&__OnMessage__Delegate,&Parms);
    }
    void delegateOnRender(class UCanvas* Canvas)
    {
        UGUIComponent_eventOnRender_Parms Parms;
        Parms.Canvas=Canvas;
        ProcessDelegate(XINTERFACE_OnRender,&__OnRender__Delegate,&Parms);
    }
    void delegateOnHitTest(FLOAT MouseX, FLOAT MouseY)
    {
        UGUIComponent_eventOnHitTest_Parms Parms;
        Parms.MouseX=MouseX;
        Parms.MouseY=MouseY;
        ProcessDelegate(XINTERFACE_OnHitTest,&__OnHitTest__Delegate,&Parms);
    }
    void delegateOnWatch()
    {
        ProcessDelegate(XINTERFACE_OnWatch,&__OnWatch__Delegate,NULL);
    }
    void delegateOnDeActivate()
    {
        ProcessDelegate(XINTERFACE_OnDeActivate,&__OnDeActivate__Delegate,NULL);
    }
    void delegateOnActivate()
    {
        ProcessDelegate(XINTERFACE_OnActivate,&__OnActivate__Delegate,NULL);
    }
    BITFIELD delegateOnDraw(class UCanvas* Canvas)
    {
        UGUIComponent_eventOnDraw_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Canvas=Canvas;
        ProcessDelegate(XINTERFACE_OnDraw,&__OnDraw__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD delegateOnPreDraw(class UCanvas* Canvas)
    {
        UGUIComponent_eventOnPreDraw_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Canvas=Canvas;
        ProcessDelegate(XINTERFACE_OnPreDraw,&__OnPreDraw__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    DECLARE_CLASS(UGUIComponent,UGUI,0,XInterface)
		virtual void PreDraw(UCanvas *Canvas);	// Should be overridden in a subclass
		virtual void Draw(UCanvas* Canvas);		// Should be overridden in a subclass

		virtual UBOOL PerformHitTest(INT MouseX, INT MouseY);					// Check to see if a mouse press affects the control
		virtual void  UpdateBounds();											// Updates the Bounds for hit tests and such
		virtual FLOAT ActualWidth();											// Returns the actual width (including scaling) of a component
		virtual FLOAT ActualHeight();											// Returns the actual height (including scaling) of a component
		virtual FLOAT ActualLeft();												// Returns the actual left (including scaling) of a component
		virtual FLOAT ActualTop();												// Returns the actual top (including scaling) of a component
		virtual void  SaveCanvasState(UCanvas* Canvas);							// Save the current state of the canvas
		virtual void  RestoreCanvasState(UCanvas* Canvas);						// Restores the state of the canvas

		virtual UGUIComponent* UnderCursor(FLOAT MouseX, FLOAT MouseY);
		
		virtual UBOOL MouseMove(INT XDelta, INT YDelta);			// The Mouse has moved
		virtual UBOOL MousePressed(UBOOL IsRepeat);					// The Mouse was pressed								
		virtual UBOOL MouseReleased();								// The Mouse was released								
		virtual UBOOL MouseHover();									// The Mouse is over a non-pressed thing

		virtual UBOOL NativeKeyType(BYTE& iKey, TCHAR Unicode );				// Handle key presses
		virtual UBOOL NativeKeyEvent(BYTE& iKey, BYTE& State, FLOAT Delta);	// Handle key events

		virtual void SetDims(FLOAT Width, FLOAT Height, FLOAT Left, FLOAT Top);	// Set the dims quickly
		virtual void  CloneDims(UGUIComponent* From);	// Clones the Width,Height, Top, Left settings

		virtual UBOOL SpecialHit();
		virtual void  NativeInvalidate();
};


class XINTERFACE_API UGUIProgressBar : public UGUIComponent
{
public:
    class UMaterial* BarBack;
    class UMaterial* BarTop;
    FColor BarColor;
    FLOAT Low;
    FLOAT High;
    FLOAT Value;
    FLOAT CaptionWidth;
    BYTE CaptionAlign;
    BYTE ValueRightAlign;
    FStringNoInit Caption;
    FStringNoInit FontName;
    FStringNoInit ValueFontName;
    FLOAT GraphicMargin;
    FLOAT ValueRightWidth;
    BITFIELD bShowLow:1 GCC_PACK(4);
    BITFIELD bShowHigh:1;
    BITFIELD bShowValue:1;
    INT NumDecimals GCC_PACK(4);
    DECLARE_CLASS(UGUIProgressBar,UGUIComponent,0,XInterface)
	void Draw(UCanvas* Canvas);	
};


struct UGUIMultiComponent_eventFindComponentIndex_Parms
{
    class UGUIComponent* Who;
    INT ReturnValue;
};
class XINTERFACE_API UGUIMultiComponent : public UGUIComponent
{
public:
    TArrayNoInit<class UGUIComponent*> Controls;
    class UGUIComponent* FocusedControl;
    INT eventFindComponentIndex(class UGUIComponent* Who)
    {
        UGUIMultiComponent_eventFindComponentIndex_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Who=Who;
        ProcessEvent(FindFunctionChecked(XINTERFACE_FindComponentIndex),&Parms);
        return Parms.ReturnValue;
    }
    DECLARE_CLASS(UGUIMultiComponent,UGUIComponent,0,XInterface)
		void PreDraw(UCanvas* Canvas);		// Do any size/postitioning
		void Draw(UCanvas* Canvas);			// Draw the component

		UGUIComponent* UnderCursor(FLOAT MouseX, FLOAT MouseY);
		
		UBOOL NativeKeyType(BYTE& iKey, TCHAR Unicode );					// A Key or Mouse button has pressed
		UBOOL NativeKeyEvent(BYTE& iKey, BYTE& State, FLOAT Delta );		// A Key/Mouse event occured
		
		void NativeInvalidate();
		UBOOL SpecialHit();
		
		UBOOL PerformHitTest(INT MouseX, INT MouseY);
		
};


class XINTERFACE_API UGUIListBoxBase : public UGUIMultiComponent
{
public:
    class UGUIVertScrollBar* ScrollBar;
    BITFIELD bVisibleWhenEmpty:1 GCC_PACK(4);
    DECLARE_CLASS(UGUIListBoxBase,UGUIMultiComponent,0,XInterface)
	void PreDraw(UCanvas* Canvas);		
	void Draw(UCanvas* Canvas);										// Handle drawing of the component natively
};


class XINTERFACE_API UGUIScrollTextBox : public UGUIListBoxBase
{
public:
    class UGUIScrollText* MyScrollText;
    BITFIELD bRepeat:1 GCC_PACK(4);
    FLOAT InitialDelay GCC_PACK(4);
    FLOAT CharDelay;
    FLOAT EOLDelay;
    FLOAT RepeatDelay;
    BYTE TextAlign;
    DECLARE_CLASS(UGUIScrollTextBox,UGUIListBoxBase,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUIScrollTextBox)
};


class XINTERFACE_API UGUIMultiColumnListBox : public UGUIListBoxBase
{
public:
    class UGUIMultiColumnList* List;
    class UGUIMultiColumnListHeader* Header;
    DECLARE_CLASS(UGUIMultiColumnListBox,UGUIListBoxBase,0,XInterface)
	void PreDraw(UCanvas* Canvas);		
};


class XINTERFACE_API UGUIListBox : public UGUIListBoxBase
{
public:
    class UGUIList* List;
    DECLARE_CLASS(UGUIListBox,UGUIListBoxBase,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUIListBox)
};


class XINTERFACE_API UGUIPanel : public UGUIMultiComponent
{
public:
    class UMaterial* Background;
    DECLARE_CLASS(UGUIPanel,UGUIMultiComponent,0,XInterface)
		void Draw(UCanvas* Canvas);
		UBOOL PerformHitTest(INT MouseX, INT MouseY);

};

enum EGUISplitterType
{
    SPLIT_Vertical          =0,
    SPLIT_Horizontal        =1,
    SPLIT_MAX               =2,
};

class XINTERFACE_API UGUISplitter : public UGUIPanel
{
public:
    BYTE SplitOrientation;
    FLOAT SplitPosition;
    FLOAT SplitAreaSize;
    DECLARE_FUNCTION(execSplitterUpdatePositions);
    DECLARE_CLASS(UGUISplitter,UGUIPanel,0,XInterface)
		void PreDraw(UCanvas* Canvas);
		void Draw(UCanvas* Canvas);
		UBOOL MouseMove(INT XDelta, INT YDelta);
		UBOOL MousePressed(UBOOL IsRepeat);
		void SplitterUpdatePositions();
};


class XINTERFACE_API UGUITabPanel : public UGUIPanel
{
public:
    BITFIELD bFillHeight:1 GCC_PACK(4);
    class UGUITabButton* MyButton GCC_PACK(4);
    DECLARE_CLASS(UGUITabPanel,UGUIPanel,0,XInterface)
		void PreDraw(UCanvas* Canvas);
};


class XINTERFACE_API UGUIMenuOption : public UGUIMultiComponent
{
public:
    FStringNoInit ComponentClassName;
    FStringNoInit Caption;
    FStringNoInit LabelFont;
    FColor LabelColor;
    BITFIELD bHeightFromComponent:1 GCC_PACK(4);
    FLOAT CaptionWidth GCC_PACK(4);
    FLOAT ComponentWidth;
    BITFIELD bFlipped:1 GCC_PACK(4);
    BYTE LabelJustification GCC_PACK(4);
    BYTE ComponentJustification;
    BITFIELD bSquare:1 GCC_PACK(4);
    BITFIELD bVerticalLayout:1;
    class UGUILabel* MyLabel GCC_PACK(4);
    class UGUIComponent* MyComponent;
    DECLARE_CLASS(UGUIMenuOption,UGUIMultiComponent,0,XInterface)
		void PreDraw(UCanvas* Canvas);
};


class XINTERFACE_API UGUIComboBox : public UGUIMultiComponent
{
public:
    INT MaxVisibleItems;
    BITFIELD bListItemsOnly:1 GCC_PACK(4);
    BITFIELD bShowListOnFocus:1;
    BITFIELD bReadOnly:1;
    INT Index GCC_PACK(4);
    FStringNoInit TextStr;
    class UGUIList* List;
    class UGUIEditBox* Edit;
    class UGUIListBox* ListBox;
    class UGUIComboButton* DownButton;
    DECLARE_CLASS(UGUIComboBox,UGUIMultiComponent,0,XInterface)
		void PreDraw(UCanvas* Canvas);
		
};


class XINTERFACE_API UGUITabControl : public UGUIMultiComponent
{
public:
    BITFIELD bDockPanels:1 GCC_PACK(4);
    TArrayNoInit<class UGUITabButton*> TabStack GCC_PACK(4);
    class UGUITabButton* ActiveTab;
    FStringNoInit BackgroundStyleName;
    class UGUIStyles* BackgroundStyle;
    class UMaterial* BackgroundImage;
    FLOAT TabHeight;
    BITFIELD bFillSpace:1 GCC_PACK(4);
    DECLARE_CLASS(UGUITabControl,UGUIMultiComponent,0,XInterface)
		void PreDraw(UCanvas* Canvas);
		void Draw(UCanvas* Canvas);									

		UGUIComponent* UnderCursor(FLOAT MouseX, FLOAT MouseY);
		UBOOL SpecialHit();
		
};


struct UGUIScrollBarBase_eventAlignThumb_Parms
{
};
class XINTERFACE_API UGUIScrollBarBase : public UGUIMultiComponent
{
public:
    class UGUIListBase* MyList;
    void eventAlignThumb()
    {
        ProcessEvent(FindFunctionChecked(XINTERFACE_AlignThumb),NULL);
    }
    DECLARE_CLASS(UGUIScrollBarBase,UGUIMultiComponent,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUIScrollBarBase)
};


class XINTERFACE_API UGUIHorzScrollBar : public UGUIScrollBarBase
{
public:
    FLOAT GripLeft;
    FLOAT GripWidth;
    DECLARE_CLASS(UGUIHorzScrollBar,UGUIScrollBarBase,0,XInterface)
		void PreDraw(UCanvas* Canvas);
};


class XINTERFACE_API UGUIVertScrollBar : public UGUIScrollBarBase
{
public:
    FLOAT GripTop;
    FLOAT GripHeight;
    FLOAT GrabOffset;
    DECLARE_CLASS(UGUIVertScrollBar,UGUIScrollBarBase,0,XInterface)
		void PreDraw(UCanvas* Canvas);
};


class XINTERFACE_API UGUINumericEdit : public UGUIMultiComponent
{
public:
    FStringNoInit Value;
    BITFIELD bLeftJustified:1 GCC_PACK(4);
    INT MinValue GCC_PACK(4);
    INT MaxValue;
    INT Step;
    DECLARE_CLASS(UGUINumericEdit,UGUIMultiComponent,0,XInterface)
		void Draw(UCanvas* Canvas);
};


struct UGUIPage_eventHandleParameters_Parms
{
    FString Param1;
    FString Param2;
};
struct UGUIPage_eventChangeHint_Parms
{
    FString NewHint;
};
struct UGUIPage_eventOnClose_Parms
{
    BITFIELD bCanceled;
};
struct UGUIPage_eventOnCanClose_Parms
{
    BITFIELD bCanceled;
    BITFIELD ReturnValue;
};
struct UGUIPage_eventOnReOpen_Parms
{
};
struct UGUIPage_eventOnOpen_Parms
{
};
class XINTERFACE_API UGUIPage : public UGUIMultiComponent
{
public:
    class UMaterial* Background;
    FColor BackgroundColor;
    FColor InactiveFadeColor;
    BYTE BackgroundRStyle;
    BITFIELD bRenderWorld:1 GCC_PACK(4);
    BITFIELD bPauseIfPossible:1;
    BITFIELD bCheckResolution:1;
    class USound* OpenSound GCC_PACK(4);
    class USound* CloseSound;
    BITFIELD bRequire640x480:1 GCC_PACK(4);
    BITFIELD bPersistent:1;
    class UGUIPage* ParentPage GCC_PACK(4);
    TArrayNoInit<class UGUIComponent*> Timers;
    BITFIELD bAllowedAsLast:1 GCC_PACK(4);
    FScriptDelegate __OnOpen__Delegate GCC_PACK(4);
    FScriptDelegate __OnReOpen__Delegate;
    FScriptDelegate __OnCanClose__Delegate;
    FScriptDelegate __OnClose__Delegate;
    void eventHandleParameters(const FString& Param1, const FString& Param2)
    {
        UGUIPage_eventHandleParameters_Parms Parms;
        Parms.Param1=Param1;
        Parms.Param2=Param2;
        ProcessEvent(FindFunctionChecked(XINTERFACE_HandleParameters),&Parms);
    }
    void eventChangeHint(const FString& NewHint)
    {
        UGUIPage_eventChangeHint_Parms Parms;
        Parms.NewHint=NewHint;
        ProcessEvent(FindFunctionChecked(XINTERFACE_ChangeHint),&Parms);
    }
    void delegateOnClose(BITFIELD bCanceled)
    {
        UGUIPage_eventOnClose_Parms Parms;
        Parms.bCanceled=bCanceled;
        ProcessDelegate(XINTERFACE_OnClose,&__OnClose__Delegate,&Parms);
    }
    BITFIELD delegateOnCanClose(BITFIELD bCanceled)
    {
        UGUIPage_eventOnCanClose_Parms Parms;
        Parms.ReturnValue=0;
        Parms.bCanceled=bCanceled;
        ProcessDelegate(XINTERFACE_OnCanClose,&__OnCanClose__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    void delegateOnReOpen()
    {
        ProcessDelegate(XINTERFACE_OnReOpen,&__OnReOpen__Delegate,NULL);
    }
    void delegateOnOpen()
    {
        ProcessDelegate(XINTERFACE_OnOpen,&__OnOpen__Delegate,NULL);
    }
    DECLARE_CLASS(UGUIPage,UGUIMultiComponent,0,XInterface)
		void Draw(UCanvas* Canvas);										
		UBOOL NativeKeyEvent(BYTE& iKey, BYTE& State, FLOAT Delta );
		void UpdateTimers(float DeltaTime);
		UBOOL PerformHitTest(INT MouseX, INT MouseY);
		
};


struct UGUIListBase_eventOnAdjustTop_Parms
{
    class UGUIComponent* Sender;
};
struct UGUIListBase_eventOnDrawItem_Parms
{
    class UCanvas* Canvas;
    INT item;
    FLOAT X;
    FLOAT Y;
    FLOAT W;
    FLOAT H;
    BITFIELD bSelected;
};
class XINTERFACE_API UGUIListBase : public UGUIComponent
{
public:
    BITFIELD bSorted:1 GCC_PACK(4);
    FColor SelectedBKColor GCC_PACK(4);
    class UMaterial* SelectedImage;
    INT Top;
    INT Index;
    INT ItemsPerPage;
    INT ItemHeight;
    INT ItemWidth;
    INT ItemCount;
    BITFIELD bHotTrack:1 GCC_PACK(4);
    BITFIELD bVisibleWhenEmpty:1;
    class UGUIScrollBarBase* MyScrollBar GCC_PACK(4);
    FScriptDelegate __OnDrawItem__Delegate;
    FScriptDelegate __OnAdjustTop__Delegate;
    void delegateOnAdjustTop(class UGUIComponent* Sender)
    {
        UGUIListBase_eventOnAdjustTop_Parms Parms;
        Parms.Sender=Sender;
        ProcessDelegate(XINTERFACE_OnAdjustTop,&__OnAdjustTop__Delegate,&Parms);
    }
    void delegateOnDrawItem(class UCanvas* Canvas, INT item, FLOAT X, FLOAT Y, FLOAT W, FLOAT H, BITFIELD bSelected)
    {
        UGUIListBase_eventOnDrawItem_Parms Parms;
        Parms.Canvas=Canvas;
        Parms.item=item;
        Parms.X=X;
        Parms.Y=Y;
        Parms.W=W;
        Parms.H=H;
        Parms.bSelected=bSelected;
        ProcessDelegate(XINTERFACE_OnDrawItem,&__OnDrawItem__Delegate,&Parms);
    }
    DECLARE_CLASS(UGUIListBase,UGUIComponent,0,XInterface)
	virtual void DrawItem(UCanvas* Canvas, INT Item, FLOAT X, FLOAT Y, FLOAT W, FLOAT H) {}
};


class XINTERFACE_API UGUIVertList : public UGUIListBase
{
public:
    DECLARE_CLASS(UGUIVertList,UGUIListBase,0,XInterface)
	void PreDraw(UCanvas* Canvas);	
	void Draw(UCanvas* Canvas);	
};


struct UGUIList_eventSwap_Parms
{
    INT IndexA;
    INT IndexB;
};
struct UGUIList_eventCompareItem_Parms
{
    FGUIListElem ElemA;
    FGUIListElem ElemB;
    INT ReturnValue;
};
class XINTERFACE_API UGUIList : public UGUIVertList
{
public:
    BYTE TextAlign;
    TArrayNoInit<FGUIListElem> Elements;
    FScriptDelegate __CompareItem__Delegate;
    DECLARE_FUNCTION(execSortList);
    void eventSwap(INT IndexA, INT IndexB)
    {
        UGUIList_eventSwap_Parms Parms;
        Parms.IndexA=IndexA;
        Parms.IndexB=IndexB;
        ProcessEvent(FindFunctionChecked(XINTERFACE_Swap),&Parms);
    }
    INT delegateCompareItem(FGUIListElem ElemA, FGUIListElem ElemB)
    {
        UGUIList_eventCompareItem_Parms Parms;
        Parms.ReturnValue=0;
        Parms.ElemA=ElemA;
        Parms.ElemB=ElemB;
        ProcessDelegate(XINTERFACE_CompareItem,&__CompareItem__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    DECLARE_CLASS(UGUIList,UGUIVertList,0,XInterface)
	void DrawItem(UCanvas* Canvas, INT Item, FLOAT X, FLOAT Y, FLOAT W, FLOAT H);
};

enum eScrollState
{
    STS_None                =0,
    STS_Initial             =1,
    STS_Char                =2,
    STS_EOL                 =3,
    STS_Repeat              =4,
    STS_MAX                 =5,
};

struct UGUIScrollText_eventOnEndOfLine_Parms
{
};
class XINTERFACE_API UGUIScrollText : public UGUIList
{
public:
    FStringNoInit Content;
    FStringNoInit Separator;
    INT VisibleLines;
    INT VisibleChars;
    INT oldWidth;
    BYTE ScrollState;
    BITFIELD bNewContent:1 GCC_PACK(4);
    BITFIELD bStopped:1;
    BITFIELD bRepeat:1;
    FLOAT InitialDelay GCC_PACK(4);
    FLOAT CharDelay;
    FLOAT EOLDelay;
    FLOAT RepeatDelay;
    FScriptDelegate __OnEndOfLine__Delegate;
    void delegateOnEndOfLine()
    {
        ProcessDelegate(XINTERFACE_OnEndOfLine,&__OnEndOfLine__Delegate,NULL);
    }
    DECLARE_CLASS(UGUIScrollText,UGUIList,0,XInterface)
	void PreDraw(UCanvas *Canvas);
	void Draw(UCanvas* Canvas);	
	void DrawItem(UCanvas* Canvas, INT Item, FLOAT X, FLOAT Y, FLOAT W, FLOAT H);
};

struct XINTERFACE_API FMultiColumnSortData
{
    FStringNoInit SortString;
    INT SortItem;
};


struct UGUIMultiColumnList_eventOnSortChanged_Parms
{
};
struct UGUIMultiColumnList_eventOnColumnSized_Parms
{
    INT column;
};
struct UGUIMultiColumnList_eventGetSortString_Parms
{
    INT i;
    FString ReturnValue;
};
class XINTERFACE_API UGUIMultiColumnList : public UGUIVertList
{
public:
    TArrayNoInit<FMultiColumnSortData> SortData;
    TArrayNoInit<INT> InvSortData;
    FStringNoInit ColumnHeadings[8];
    TArrayNoInit<FLOAT> ColumnWidths;
    TArrayNoInit<FLOAT> InitColumnPerc;
    FLOAT CellSpacing;
    INT SortColumn;
    BITFIELD SortDescending:1 GCC_PACK(4);
    BITFIELD ExpandLastColumn:1;
    BITFIELD bInitialised:1;
    BITFIELD NeedsSorting:1;
    DECLARE_FUNCTION(execUpdatedItem);
    DECLARE_FUNCTION(execAddedItem);
    DECLARE_FUNCTION(execChangeSortOrder);
    DECLARE_FUNCTION(execSortList);
    void eventOnSortChanged()
    {
        ProcessEvent(FindFunctionChecked(XINTERFACE_OnSortChanged),NULL);
    }
    void eventOnColumnSized(INT column)
    {
        UGUIMultiColumnList_eventOnColumnSized_Parms Parms;
        Parms.column=column;
        ProcessEvent(FindFunctionChecked(XINTERFACE_OnColumnSized),&Parms);
    }
    FString eventGetSortString(INT i)
    {
        UGUIMultiColumnList_eventGetSortString_Parms Parms;
        Parms.i=i;
        ProcessEvent(FindFunctionChecked(XINTERFACE_GetSortString),&Parms);
        return Parms.ReturnValue;
    }
    DECLARE_CLASS(UGUIMultiColumnList,UGUIVertList,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUIMultiColumnList)
};


class XINTERFACE_API UGUICircularList : public UGUIListBase
{
public:
    BITFIELD bCenterInBounds:1 GCC_PACK(4);
    BITFIELD bFillBounds:1;
    BITFIELD bIgnoreBackClick:1;
    BITFIELD bAllowSelectEmpty:1;
    INT FixedItemsPerPage GCC_PACK(4);
    DECLARE_CLASS(UGUICircularList,UGUIListBase,0,XInterface)
	void Draw(UCanvas* Canva);	
};


class XINTERFACE_API UGUICharacterList : public UGUICircularList
{
public:
    TArrayNoInit<FPlayerRecord> PlayerList;
    BITFIELD bLocked:1 GCC_PACK(4);
    class UMaterial* DefaultPortrait GCC_PACK(4);
    DECLARE_CLASS(UGUICharacterList,UGUICircularList,0,XInterface)
	void PreDraw(UCanvas* Canvas);	
	void DrawItem(UCanvas* Canvas, INT Item, FLOAT X, FLOAT Y, FLOAT W, FLOAT H);
};


class XINTERFACE_API UGUIHorzList : public UGUIListBase
{
public:
    DECLARE_CLASS(UGUIHorzList,UGUIListBase,0,XInterface)
	void Draw(UCanvas* Canvas);	
};


struct UGUISlider_eventOnDrawCaption_Parms
{
    FString ReturnValue;
};
class XINTERFACE_API UGUISlider : public UGUIComponent
{
public:
    FLOAT MinValue;
    FLOAT MaxValue;
    FStringNoInit CaptionStyleName;
    FLOAT Value;
    class UGUIStyles* CaptionStyle;
    BITFIELD bIntSlider:1 GCC_PACK(4);
    FScriptDelegate __OnDrawCaption__Delegate GCC_PACK(4);
    FString delegateOnDrawCaption()
    {
        UGUISlider_eventOnDrawCaption_Parms Parms;
        ProcessDelegate(XINTERFACE_OnDrawCaption,&__OnDrawCaption__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    DECLARE_CLASS(UGUISlider,UGUIComponent,0,XInterface)
		void Draw(UCanvas* Canvas);
};


class XINTERFACE_API UGUITitleBar : public UGUIComponent
{
public:
    FStringNoInit Caption;
    BYTE Justification;
    class UGUITabControl* DockedTabs;
    BITFIELD bDockTop:1 GCC_PACK(4);
    BITFIELD bUseTextHeight:1;
    class UMaterial* Effect GCC_PACK(4);
    DECLARE_CLASS(UGUITitleBar,UGUIComponent,0,XInterface)
		void PreDraw(UCanvas* Canvas);
		void Draw(UCanvas* Canvas);	
};


struct UGUIButton_eventButtonReleased_Parms
{
};
struct UGUIButton_eventButtonPressed_Parms
{
};
class XINTERFACE_API UGUIButton : public UGUIComponent
{
public:
    FStringNoInit Caption;
    void eventButtonReleased()
    {
        ProcessEvent(FindFunctionChecked(XINTERFACE_ButtonReleased),NULL);
    }
    void eventButtonPressed()
    {
        ProcessEvent(FindFunctionChecked(XINTERFACE_ButtonPressed),NULL);
    }
    DECLARE_CLASS(UGUIButton,UGUIComponent,0,XInterface)
		void Draw(UCanvas* Canvas);
};


class XINTERFACE_API UGUITabButton : public UGUIButton
{
public:
    BITFIELD bActive:1 GCC_PACK(4);
    class UGUITabPanel* MyPanel GCC_PACK(4);
    DECLARE_CLASS(UGUITabButton,UGUIButton,0,XInterface)
		UBOOL MousePressed(UBOOL IsRepeat);					// The Mouse was pressed								
		UBOOL MouseReleased();								// The Mouse was released
};


class XINTERFACE_API UGUIGFXButton : public UGUIButton
{
public:
    class UMaterial* Graphic;
    BYTE Position;
    BITFIELD bCheckBox:1 GCC_PACK(4);
    BITFIELD bClientBound:1;
    BITFIELD bChecked:1;
    DECLARE_CLASS(UGUIGFXButton,UGUIButton,0,XInterface)
		void Draw(UCanvas* Canvas);
};


class XINTERFACE_API UGUIHorzGripButton : public UGUIGFXButton
{
public:
    DECLARE_CLASS(UGUIHorzGripButton,UGUIGFXButton,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUIHorzGripButton)
};


class XINTERFACE_API UGUIHorzScrollButton : public UGUIGFXButton
{
public:
    BITFIELD LeftButton:1 GCC_PACK(4);
    DECLARE_CLASS(UGUIHorzScrollButton,UGUIGFXButton,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUIHorzScrollButton)
};


class XINTERFACE_API UGUIVertGripButton : public UGUIGFXButton
{
public:
    DECLARE_CLASS(UGUIVertGripButton,UGUIGFXButton,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUIVertGripButton)
};


class XINTERFACE_API UGUIVertScrollButton : public UGUIGFXButton
{
public:
    BITFIELD UpButton:1 GCC_PACK(4);
    DECLARE_CLASS(UGUIVertScrollButton,UGUIGFXButton,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUIVertScrollButton)
};


class XINTERFACE_API UGUICheckBoxButton : public UGUIGFXButton
{
public:
    DECLARE_CLASS(UGUICheckBoxButton,UGUIGFXButton,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUICheckBoxButton)
};


class XINTERFACE_API UGUISpinnerButton : public UGUIGFXButton
{
public:
    BITFIELD PlusButton:1 GCC_PACK(4);
    DECLARE_CLASS(UGUISpinnerButton,UGUIGFXButton,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUISpinnerButton)
};


struct UGUIEditBox_eventSetText_Parms
{
    FString NewText;
};
class XINTERFACE_API UGUIEditBox : public UGUIButton
{
public:
    FStringNoInit TextStr;
    FStringNoInit AllowedCharSet;
    BITFIELD bMaskText:1 GCC_PACK(4);
    BITFIELD bIntOnly:1;
    BITFIELD bFloatOnly:1;
    BITFIELD bIncludeSign:1;
    BITFIELD bConvertSpaces:1;
    INT MaxWidth GCC_PACK(4);
    BYTE TextCase;
    INT BorderOffsets[4];
    BITFIELD bReadOnly:1 GCC_PACK(4);
    INT CaretPos GCC_PACK(4);
    INT FirstVis;
    INT LastSizeX;
    INT LastCaret;
    INT LastLength;
    BITFIELD bAllSelected:1 GCC_PACK(4);
    BYTE LastKey GCC_PACK(4);
    FLOAT DelayTime;
    void eventSetText(const FString& NewText)
    {
        UGUIEditBox_eventSetText_Parms Parms;
        Parms.NewText=NewText;
        ProcessEvent(FindFunctionChecked(XINTERFACE_SetText),&Parms);
    }
    DECLARE_CLASS(UGUIEditBox,UGUIButton,0,XInterface)
		void Draw(UCanvas* Canvas);
};


class XINTERFACE_API UGUIMultiColumnListHeader : public UGUIComponent
{
public:
    class UGUIMultiColumnList* MyList;
    INT SizingCol;
    INT ClickingCol;
    DECLARE_CLASS(UGUIMultiColumnListHeader,UGUIComponent,0,XInterface)
	UBOOL MousePressed(UBOOL IsRepeat);
	UBOOL MouseReleased();
	UBOOL MouseMove(INT XDelta, INT YDelta);
	UBOOL MouseHover();
	void Draw(UCanvas* Canvas);
	void PreDraw(UCanvas* Canvas);
};


struct UGUIHorzScrollZone_eventOnScrollZoneClick_Parms
{
    FLOAT Delta;
};
class XINTERFACE_API UGUIHorzScrollZone : public UGUIComponent
{
public:
    FScriptDelegate __OnScrollZoneClick__Delegate;
    void delegateOnScrollZoneClick(FLOAT Delta)
    {
        UGUIHorzScrollZone_eventOnScrollZoneClick_Parms Parms;
        Parms.Delta=Delta;
        ProcessDelegate(XINTERFACE_OnScrollZoneClick,&__OnScrollZoneClick__Delegate,&Parms);
    }
    DECLARE_CLASS(UGUIHorzScrollZone,UGUIComponent,0,XInterface)
		void Draw(UCanvas* Canvas);
};


struct UGUIVertScrollZone_eventOnScrollZoneClick_Parms
{
    FLOAT Delta;
};
class XINTERFACE_API UGUIVertScrollZone : public UGUIComponent
{
public:
    FScriptDelegate __OnScrollZoneClick__Delegate;
    void delegateOnScrollZoneClick(FLOAT Delta)
    {
        UGUIVertScrollZone_eventOnScrollZoneClick_Parms Parms;
        Parms.Delta=Delta;
        ProcessDelegate(XINTERFACE_OnScrollZoneClick,&__OnScrollZoneClick__Delegate,&Parms);
    }
    DECLARE_CLASS(UGUIVertScrollZone,UGUIComponent,0,XInterface)
		void Draw(UCanvas* Canvas);
};


class XINTERFACE_API UGUILabel : public UGUIComponent
{
public:
    FStringNoInit Caption;
    BYTE TextAlign;
    FColor TextColor;
    FColor FocusedTextColor;
    BYTE TextStyle;
    FStringNoInit TextFont;
    BITFIELD bTransparent:1 GCC_PACK(4);
    BITFIELD bMultiLine:1;
    FColor BackColor GCC_PACK(4);
    DECLARE_CLASS(UGUILabel,UGUIComponent,0,XInterface)
		void Draw(UCanvas* Canvas);
};


class XINTERFACE_API UGUIImage : public UGUIComponent
{
public:
    class UMaterial* Image;
    FColor ImageColor;
    BYTE ImageStyle;
    BYTE ImageRenderStyle;
    BYTE ImageAlign;
    INT X1;
    INT Y1;
    INT X2;
    INT Y2;
    DECLARE_CLASS(UGUIImage,UGUIComponent,0,XInterface)
		void Draw(UCanvas* Canvas);
};


struct UGUIStyles_eventInitialize_Parms
{
};
struct UGUIStyles_eventOnDrawText_Parms
{
    class UCanvas* Canvas;
    BYTE MenuState;
    FLOAT Left;
    FLOAT Top;
    FLOAT Width;
    FLOAT Height;
    BYTE Align;
    FString Text;
    BITFIELD ReturnValue;
};
struct UGUIStyles_eventOnDraw_Parms
{
    class UCanvas* Canvas;
    BYTE MenuState;
    FLOAT Left;
    FLOAT Top;
    FLOAT Width;
    FLOAT Height;
    BITFIELD ReturnValue;
};
class XINTERFACE_API UGUIStyles : public UGUI
{
public:
    FStringNoInit KeyName;
    BYTE RStyles[5];
    class UMaterial* Images[5];
    BYTE ImgStyle[5];
    FColor FontColors[5];
    FColor ImgColors[5];
    class UGUIFont* Fonts[5];
    INT BorderOffsets[4];
    FStringNoInit FontNames[5];
    BITFIELD bRegistered:1 GCC_PACK(4);
    FScriptDelegate __OnDraw__Delegate GCC_PACK(4);
    FScriptDelegate __OnDrawText__Delegate;
    DECLARE_FUNCTION(execDrawText);
    DECLARE_FUNCTION(execDraw);
    void eventInitialize()
    {
        ProcessEvent(FindFunctionChecked(XINTERFACE_Initialize),NULL);
    }
    BITFIELD delegateOnDrawText(class UCanvas* Canvas, BYTE MenuState, FLOAT Left, FLOAT Top, FLOAT Width, FLOAT Height, BYTE Align, const FString& Text)
    {
        UGUIStyles_eventOnDrawText_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Canvas=Canvas;
        Parms.MenuState=MenuState;
        Parms.Left=Left;
        Parms.Top=Top;
        Parms.Width=Width;
        Parms.Height=Height;
        Parms.Align=Align;
        Parms.Text=Text;
        ProcessDelegate(XINTERFACE_OnDrawText,&__OnDrawText__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    BITFIELD delegateOnDraw(class UCanvas* Canvas, BYTE MenuState, FLOAT Left, FLOAT Top, FLOAT Width, FLOAT Height)
    {
        UGUIStyles_eventOnDraw_Parms Parms;
        Parms.ReturnValue=0;
        Parms.Canvas=Canvas;
        Parms.MenuState=MenuState;
        Parms.Left=Left;
        Parms.Top=Top;
        Parms.Width=Width;
        Parms.Height=Height;
        ProcessDelegate(XINTERFACE_OnDraw,&__OnDraw__Delegate,&Parms);
        return Parms.ReturnValue;
    }
    DECLARE_CLASS(UGUIStyles,UGUI,0,XInterface)
		void Draw(UCanvas* Canvas, BYTE MenuState, FLOAT Left, FLOAT Top, FLOAT Width, FLOAT Height);
		void DrawText(UCanvas* Canvas, BYTE MenuState, FLOAT Left, FLOAT Top, FLOAT Width, FLOAT Height, BYTE Just, const TCHAR* Text);
		void TextSize(UCanvas* Canvas, BYTE MenuState, const TCHAR* Test, INT& XL, INT& YL);
};


struct UGUIFont_eventGetFont_Parms
{
    INT XRes;
    class UFont* ReturnValue;
};
class XINTERFACE_API UGUIFont : public UGUI
{
public:
    FStringNoInit KeyName;
    BITFIELD bFixedSize:1 GCC_PACK(4);
    TArrayNoInit<class UFont*> FontArray GCC_PACK(4);
    DECLARE_FUNCTION(execGetFont);
    class UFont* eventGetFont(INT XRes)
    {
        UGUIFont_eventGetFont_Parms Parms;
        Parms.ReturnValue=0;
        Parms.XRes=XRes;
        ProcessEvent(FindFunctionChecked(XINTERFACE_GetFont),&Parms);
        return Parms.ReturnValue;
    }
    DECLARE_CLASS(UGUIFont,UGUI,0,XInterface)
    NO_DEFAULT_CONSTRUCTOR(UGUIFont)
};

#endif

AUTOGENERATE_FUNCTION(AHudBase,-1,execDrawNumericWidget);
AUTOGENERATE_FUNCTION(AHudBase,-1,execDrawSpriteWidget);
AUTOGENERATE_FUNCTION(UGUIComponent,-1,execActualTop);
AUTOGENERATE_FUNCTION(UGUIComponent,-1,execActualLeft);
AUTOGENERATE_FUNCTION(UGUIComponent,-1,execActualHeight);
AUTOGENERATE_FUNCTION(UGUIComponent,-1,execActualWidth);
AUTOGENERATE_FUNCTION(UGUIComponent,-1,execKillTimer);
AUTOGENERATE_FUNCTION(UGUIComponent,-1,execSetTimer);
AUTOGENERATE_FUNCTION(UGUIList,-1,execSortList);
AUTOGENERATE_FUNCTION(UGUISplitter,-1,execSplitterUpdatePositions);
AUTOGENERATE_FUNCTION(UGUIStyles,-1,execDrawText);
AUTOGENERATE_FUNCTION(UGUIStyles,-1,execDraw);
AUTOGENERATE_FUNCTION(UGUIMultiColumnList,-1,execUpdatedItem);
AUTOGENERATE_FUNCTION(UGUIMultiColumnList,-1,execAddedItem);
AUTOGENERATE_FUNCTION(UGUIMultiColumnList,-1,execChangeSortOrder);
AUTOGENERATE_FUNCTION(UGUIMultiColumnList,-1,execSortList);
AUTOGENERATE_FUNCTION(UGUIFont,-1,execGetFont);
AUTOGENERATE_FUNCTION(UGUIController,-1,execResetKeyboard);
AUTOGENERATE_FUNCTION(UGUIController,-1,execLoadDecoText);
AUTOGENERATE_FUNCTION(UGUIController,-1,execGetProfileList);
AUTOGENERATE_FUNCTION(UGUIController,-1,execGetMapList);
AUTOGENERATE_FUNCTION(UGUIController,-1,execGetWeaponList);
AUTOGENERATE_FUNCTION(UGUIController,-1,execGetTeamSymbolList);
AUTOGENERATE_FUNCTION(UGUIController,-1,execGetMainMenuClass);
AUTOGENERATE_FUNCTION(UGUIController,-1,execGetCurrentRes);
AUTOGENERATE_FUNCTION(UGUIController,-1,execGetStyle);
AUTOGENERATE_FUNCTION(UGUIController,-1,execGetMenuFont);

#ifndef NAMES_ONLY
#undef AUTOGENERATE_NAME
#undef AUTOGENERATE_FUNCTION
#endif

#if SUPPORTS_PRAGMA_PACK
#pragma pack (pop)
#endif

#if __STATIC_LINK
#ifndef XINTERFACE_NATIVE_DEFS
#define XINTERFACE_NATIVE_DEFS

DECLARE_NATIVE_TYPE(XInterface,AHudBase);
DECLARE_NATIVE_TYPE(XInterface,UGUIProgressBar);
DECLARE_NATIVE_TYPE(XInterface,UGUIComponent);
DECLARE_NATIVE_TYPE(XInterface,UGUI);
DECLARE_NATIVE_TYPE(XInterface,UGUIScrollTextBox);
DECLARE_NATIVE_TYPE(XInterface,UGUIListBoxBase);
DECLARE_NATIVE_TYPE(XInterface,UGUIMultiComponent);
DECLARE_NATIVE_TYPE(XInterface,UGUIScrollText);
DECLARE_NATIVE_TYPE(XInterface,UGUIList);
DECLARE_NATIVE_TYPE(XInterface,UGUIVertList);
DECLARE_NATIVE_TYPE(XInterface,UGUIListBase);
DECLARE_NATIVE_TYPE(XInterface,UGUICharacterList);
DECLARE_NATIVE_TYPE(XInterface,UGUICircularList);
DECLARE_NATIVE_TYPE(XInterface,UGUIHorzList);
DECLARE_NATIVE_TYPE(XInterface,UGUISlider);
DECLARE_NATIVE_TYPE(XInterface,UGUISplitter);
DECLARE_NATIVE_TYPE(XInterface,UGUIPanel);
DECLARE_NATIVE_TYPE(XInterface,UGUITitleBar);
DECLARE_NATIVE_TYPE(XInterface,UGUIMenuOption);
DECLARE_NATIVE_TYPE(XInterface,UGUIComboBox);
DECLARE_NATIVE_TYPE(XInterface,UGUITabPanel);
DECLARE_NATIVE_TYPE(XInterface,UGUITabButton);
DECLARE_NATIVE_TYPE(XInterface,UGUIButton);
DECLARE_NATIVE_TYPE(XInterface,UGUITabControl);
DECLARE_NATIVE_TYPE(XInterface,UGUIStyles);
DECLARE_NATIVE_TYPE(XInterface,UGUIMultiColumnListHeader);
DECLARE_NATIVE_TYPE(XInterface,UGUIMultiColumnList);
DECLARE_NATIVE_TYPE(XInterface,UGUIMultiColumnListBox);
DECLARE_NATIVE_TYPE(XInterface,UGUIListBox);
DECLARE_NATIVE_TYPE(XInterface,UGUIHorzScrollBar);
DECLARE_NATIVE_TYPE(XInterface,UGUIScrollBarBase);
DECLARE_NATIVE_TYPE(XInterface,UGUIHorzGripButton);
DECLARE_NATIVE_TYPE(XInterface,UGUIGFXButton);
DECLARE_NATIVE_TYPE(XInterface,UGUIHorzScrollButton);
DECLARE_NATIVE_TYPE(XInterface,UGUIHorzScrollZone);
DECLARE_NATIVE_TYPE(XInterface,UGUIVertScrollBar);
DECLARE_NATIVE_TYPE(XInterface,UGUIVertGripButton);
DECLARE_NATIVE_TYPE(XInterface,UGUIVertScrollButton);
DECLARE_NATIVE_TYPE(XInterface,UGUIVertScrollZone);
DECLARE_NATIVE_TYPE(XInterface,UGUINumericEdit);
DECLARE_NATIVE_TYPE(XInterface,UGUIEditBox);
DECLARE_NATIVE_TYPE(XInterface,UGUICheckBoxButton);
DECLARE_NATIVE_TYPE(XInterface,UGUISpinnerButton);
DECLARE_NATIVE_TYPE(XInterface,UGUILabel);
DECLARE_NATIVE_TYPE(XInterface,UGUIFont);
DECLARE_NATIVE_TYPE(XInterface,UGUIPage);
DECLARE_NATIVE_TYPE(XInterface,UGUIImage);
DECLARE_NATIVE_TYPE(XInterface,UGUIController);

#define AUTO_INITIALIZE_REGISTRANTS_XINTERFACE \
	AHudBase::StaticClass(); \
	GNativeLookupFuncs[Lookup++] = &FindXInterfaceAHudBaseNative; \
	UGUIProgressBar::StaticClass(); \
	UGUIComponent::StaticClass(); \
	GNativeLookupFuncs[Lookup++] = &FindXInterfaceUGUIComponentNative; \
	UGUI::StaticClass(); \
	UGUIScrollTextBox::StaticClass(); \
	UGUIListBoxBase::StaticClass(); \
	UGUIMultiComponent::StaticClass(); \
	UGUIScrollText::StaticClass(); \
	UGUIList::StaticClass(); \
	GNativeLookupFuncs[Lookup++] = &FindXInterfaceUGUIListNative; \
	UGUIVertList::StaticClass(); \
	UGUIListBase::StaticClass(); \
	UGUICharacterList::StaticClass(); \
	UGUICircularList::StaticClass(); \
	UGUIHorzList::StaticClass(); \
	UGUISlider::StaticClass(); \
	UGUISplitter::StaticClass(); \
	GNativeLookupFuncs[Lookup++] = &FindXInterfaceUGUISplitterNative; \
	UGUIPanel::StaticClass(); \
	UGUITitleBar::StaticClass(); \
	UGUIMenuOption::StaticClass(); \
	UGUIComboBox::StaticClass(); \
	UGUITabPanel::StaticClass(); \
	UGUITabButton::StaticClass(); \
	UGUIButton::StaticClass(); \
	UGUITabControl::StaticClass(); \
	UGUIStyles::StaticClass(); \
	GNativeLookupFuncs[Lookup++] = &FindXInterfaceUGUIStylesNative; \
	UGUIMultiColumnListHeader::StaticClass(); \
	UGUIMultiColumnList::StaticClass(); \
	GNativeLookupFuncs[Lookup++] = &FindXInterfaceUGUIMultiColumnListNative; \
	UGUIMultiColumnListBox::StaticClass(); \
	UGUIListBox::StaticClass(); \
	UGUIHorzScrollBar::StaticClass(); \
	UGUIScrollBarBase::StaticClass(); \
	UGUIHorzGripButton::StaticClass(); \
	UGUIGFXButton::StaticClass(); \
	UGUIHorzScrollButton::StaticClass(); \
	UGUIHorzScrollZone::StaticClass(); \
	UGUIVertScrollBar::StaticClass(); \
	UGUIVertGripButton::StaticClass(); \
	UGUIVertScrollButton::StaticClass(); \
	UGUIVertScrollZone::StaticClass(); \
	UGUINumericEdit::StaticClass(); \
	UGUIEditBox::StaticClass(); \
	UGUICheckBoxButton::StaticClass(); \
	UGUISpinnerButton::StaticClass(); \
	UGUILabel::StaticClass(); \
	UGUIFont::StaticClass(); \
	GNativeLookupFuncs[Lookup++] = &FindXInterfaceUGUIFontNative; \
	UGUIPage::StaticClass(); \
	UGUIImage::StaticClass(); \
	UGUIController::StaticClass(); \
	GNativeLookupFuncs[Lookup++] = &FindXInterfaceUGUIControllerNative; \

#endif // XInterface_NATIVE_DEFS

#ifdef NATIVES_ONLY
NATIVE_INFO(AHudBase) GXInterfaceAHudBaseNatives[] = 
{ 
	MAP_NATIVE(AHudBase,execDrawNumericWidget)
	MAP_NATIVE(AHudBase,execDrawSpriteWidget)
	{NULL,NULL}
};
IMPLEMENT_NATIVE_HANDLER(XInterface,AHudBase);

NATIVE_INFO(UGUIComponent) GXInterfaceUGUIComponentNatives[] = 
{ 
	MAP_NATIVE(UGUIComponent,execActualTop)
	MAP_NATIVE(UGUIComponent,execActualLeft)
	MAP_NATIVE(UGUIComponent,execActualHeight)
	MAP_NATIVE(UGUIComponent,execActualWidth)
	MAP_NATIVE(UGUIComponent,execKillTimer)
	MAP_NATIVE(UGUIComponent,execSetTimer)
	{NULL,NULL}
};
IMPLEMENT_NATIVE_HANDLER(XInterface,UGUIComponent);

NATIVE_INFO(UGUIList) GXInterfaceUGUIListNatives[] = 
{ 
	MAP_NATIVE(UGUIList,execSortList)
	{NULL,NULL}
};
IMPLEMENT_NATIVE_HANDLER(XInterface,UGUIList);

NATIVE_INFO(UGUISplitter) GXInterfaceUGUISplitterNatives[] = 
{ 
	MAP_NATIVE(UGUISplitter,execSplitterUpdatePositions)
	{NULL,NULL}
};
IMPLEMENT_NATIVE_HANDLER(XInterface,UGUISplitter);

NATIVE_INFO(UGUIStyles) GXInterfaceUGUIStylesNatives[] = 
{ 
	MAP_NATIVE(UGUIStyles,execDrawText)
	MAP_NATIVE(UGUIStyles,execDraw)
	{NULL,NULL}
};
IMPLEMENT_NATIVE_HANDLER(XInterface,UGUIStyles);

NATIVE_INFO(UGUIMultiColumnList) GXInterfaceUGUIMultiColumnListNatives[] = 
{ 
	MAP_NATIVE(UGUIMultiColumnList,execUpdatedItem)
	MAP_NATIVE(UGUIMultiColumnList,execAddedItem)
	MAP_NATIVE(UGUIMultiColumnList,execChangeSortOrder)
	MAP_NATIVE(UGUIMultiColumnList,execSortList)
	{NULL,NULL}
};
IMPLEMENT_NATIVE_HANDLER(XInterface,UGUIMultiColumnList);

NATIVE_INFO(UGUIFont) GXInterfaceUGUIFontNatives[] = 
{ 
	MAP_NATIVE(UGUIFont,execGetFont)
	{NULL,NULL}
};
IMPLEMENT_NATIVE_HANDLER(XInterface,UGUIFont);

NATIVE_INFO(UGUIController) GXInterfaceUGUIControllerNatives[] = 
{ 
	MAP_NATIVE(UGUIController,execResetKeyboard)
	MAP_NATIVE(UGUIController,execLoadDecoText)
	MAP_NATIVE(UGUIController,execGetProfileList)
	MAP_NATIVE(UGUIController,execGetMapList)
	MAP_NATIVE(UGUIController,execGetWeaponList)
	MAP_NATIVE(UGUIController,execGetTeamSymbolList)
	MAP_NATIVE(UGUIController,execGetMainMenuClass)
	MAP_NATIVE(UGUIController,execGetCurrentRes)
	MAP_NATIVE(UGUIController,execGetStyle)
	MAP_NATIVE(UGUIController,execGetMenuFont)
	{NULL,NULL}
};
IMPLEMENT_NATIVE_HANDLER(XInterface,UGUIController);

#endif // NATIVES_ONLY
#endif // __STATIC_LINK
