window.h

虚幻的再开发程序包源代码

			const ANSICHAR* String = (const ANSICHAR*)Info.dwTypeData;
			if( String && String[0]=='I' && String[1]=='D' && String[2]=='_' )
			{
				const_cast<const ANSICHAR*&>(Info.dwTypeData) = TCHAR_TO_ANSI(Localize( Name, appFromAnsi(String), Package ));
				SetMenuItemInfoA( hMenu, i, 1, &Info );
			}
			if( Info.hSubMenu )
				LocalizeSubMenu( Info.hSubMenu, Name, Package );
		}
		else
#endif
		{
			MENUITEMINFO Info;
			TCHAR Buffer[1024];
			appMemzero( &Info, sizeof(Info) );
			Info.cbSize     = sizeof(Info);
			Info.fMask      = MIIM_TYPE | MIIM_SUBMENU;
			Info.cch        = ARRAY_COUNT(Buffer);
			Info.dwTypeData = Buffer;
			GetMenuItemInfo( hMenu, i, 1, &Info );
			const TCHAR* String = (const TCHAR*)Info.dwTypeData;
			if( String && String[0]=='I' && String[1]=='D' && String[2]=='_' )
			{
				const_cast<const TCHAR*&>(Info.dwTypeData) = Localize( Name, String, Package );
				SetMenuItemInfo( hMenu, i, 1, &Info );
			}
			if( Info.hSubMenu )
				LocalizeSubMenu( Info.hSubMenu, Name, Package );
		}
	}
	unguard;
}
inline WINDOW_API HMENU LoadLocalizedMenu( HINSTANCE hInstance, INT Id, const TCHAR* Name, const TCHAR* Package=GPackage )
{
	guard(LoadLocalizedMenu);
	HMENU hMenu = LoadMenuIdX( hInstance, Id );
	if( !hMenu )
		appErrorf( TEXT("Failed loading menu: %s %s"), Package, Name );
	LocalizeSubMenu( hMenu, Name, Package );
	return hMenu;
	unguard;
}

//
// Toggle a menu item and return 0 if it's now off, 1 if it's now on.
//
inline WINDOW_API UBOOL ToggleMenuItem( HMENU hMenu, UBOOL Item )
{
	guard(ToggleMenuItem);
	if( GetMenuState(hMenu,Item,MF_BYCOMMAND)&MF_CHECKED )
	{
		// Now unchecked.
		CheckMenuItem( hMenu, Item, MF_UNCHECKED );
		return 0;
	}
	else
	{
		// Now checked.
		CheckMenuItem( hMenu, Item, MF_CHECKED );
		return 1;
	}
	unguard;
}

/*-----------------------------------------------------------------------------
	FWindowsBitmap.
-----------------------------------------------------------------------------*/

// A bitmap.
class FWindowsBitmap
{
public:
	INT SizeX, SizeY;
	FWindowsBitmap()
	: hBitmap( NULL )
	, SizeX( 0 )
	, SizeY( 0 )
	{}
	~FWindowsBitmap()
	{
		if( hBitmap )
			DeleteObject( hBitmap );
	}
	UBOOL LoadFile( const TCHAR* Filename )
	{
		if( hBitmap )
			DeleteObject( hBitmap );
		hBitmap = LoadFileToBitmap( Filename, SizeX, SizeY );
		return hBitmap!=NULL;
	}
	HBITMAP GetBitmapHandle()
	{
		return hBitmap;
	}
private:
	HBITMAP hBitmap;
	void operator=( FWindowsBitmap& ) {}
};

/*-----------------------------------------------------------------------------
	WWindow.
-----------------------------------------------------------------------------*/

#if WIN_OBJ
	#define W_DECLARE_ABSTRACT_CLASS(a,b,c) DECLARE_ABSTRACT_CLASS(a,b,c) 
	#define W_DECLARE_CLASS(a,b,c) DECLARE_CLASS(a,b,c) 
	#define W_IMPLEMENT_CLASS(a) IMPLEMENT_CLASS(a)
#else
	#define W_DECLARE_ABSTRACT_CLASS(a,b,c) public:
	#define W_DECLARE_CLASS(a,b,c) public:
	#define W_IMPLEMENT_CLASS(a)
#endif

// An operating system window.
class WINDOW_API WWindow : 
#if WIN_OBJ
public UObject, 
#endif
public FCommandTarget
{
	W_DECLARE_ABSTRACT_CLASS(WWindow,UObject,CLASS_Transient);

	// Variables.
	HWND					hWnd;
	FName					PersistentName;
	WORD					ControlId, TopControlId;
	BITFIELD				Destroyed:1;
	BITFIELD				MdiChild:1;
	WWindow*				OwnerWindow;
	FNotifyHook*			NotifyHook;
	FControlSnoop*			Snoop;
	TArray<class WControl*>	Controls;

	// Static.
	static INT              ModalCount;
	static TArray<WWindow*> _Windows;
	static TArray<WWindow*> _DeleteWindows;
	static LONG APIENTRY StaticWndProc( HWND hWnd, UINT Message, UINT wParam, LONG lParam )
	{
		guard(WWindow::StaticProc);
		for( INT i=0; i<_Windows.Num(); i++ )
			if( _Windows(i)->hWnd==hWnd )
				break;
		if( i==_Windows.Num() && (Message==WM_NCCREATE || Message==WM_INITDIALOG) )
		{
			WWindow* WindowCreate
			=	Message!=WM_NCCREATE
			?	(WWindow*)lParam
			:	(GetWindowLongX(hWnd,GWL_EXSTYLE) & WS_EX_MDICHILD)
			?	(WWindow*)((MDICREATESTRUCT*)((CREATESTRUCT*)lParam)->lpCreateParams)->lParam
			:	(WWindow*)((CREATESTRUCT*)lParam)->lpCreateParams;
			check(WindowCreate);
			check(!WindowCreate->hWnd);
			WindowCreate->hWnd = hWnd;
			for( i=0; i<_Windows.Num(); i++ )
				if( _Windows(i)==WindowCreate )
					break;
			check(i<_Windows.Num());
		}
		if( i==_Windows.Num() || GIsCriticalError )
		{
			// Gets through before WM_NCCREATE: WM_GETMINMAXINFO
			return DefWindowProcX( hWnd, Message, wParam, lParam );
		}
		else
		{
			return _Windows(i)->WndProc( Message, wParam, lParam );			
		}
		unguard;
	}
	static WNDPROC RegisterWindowClass( const TCHAR* Name, DWORD Style )
	{
		guard(WWindow::RegisterWindowClass);
#if UNICODE
		if( GUnicodeOS )
		{
			WNDCLASSEXW Cls;
			appMemzero( &Cls, sizeof(Cls) );
			Cls.cbSize			= sizeof(Cls);
			Cls.style			= Style;
			Cls.lpfnWndProc		= StaticWndProc;
			Cls.hInstance		= hInstanceWindow;
			Cls.hIcon			= LoadIconIdX(hInstanceWindow,IDICON_Mainframe);
			Cls.lpszClassName	= Name;
			Cls.hIconSm			= LoadIconIdX(hInstanceWindow,IDICON_Mainframe);
			verify(RegisterClassExW( &Cls ));
		}
		else
#endif
		{
			WNDCLASSEXA Cls;
			appMemzero( &Cls, sizeof(Cls) );
			Cls.cbSize			= sizeof(Cls);
			Cls.style			= Style;
			Cls.lpfnWndProc		= StaticWndProc;
			Cls.hInstance		= hInstanceWindow;
			Cls.hIcon			= LoadIconIdX(hInstanceWindow,IDICON_Mainframe);
			Cls.lpszClassName	= TCHAR_TO_ANSI(Name);
			Cls.hIconSm			= LoadIconIdX(hInstanceWindow,IDICON_Mainframe);
			verify(RegisterClassExA( &Cls ));
		}
		return NULL;
		unguard;
	}

	// Structors.
	WWindow( FName InPersistentName=NAME_None, WWindow* InOwnerWindow=NULL )
#if WIN_OBJ
	:	UObject				( EC_InPlaceConstructor, WWindow::StaticClass(), UObject::GetTransientPackage(), NAME_None, 0 )
	,	hWnd				( NULL )
#else
	:	hWnd				( NULL )
#endif
	,	PersistentName		( InPersistentName )
	,	ControlId			( 0 )
	,	TopControlId		( FIRST_AUTO_CONTROL )
	,	Destroyed			( 0 )
	,   MdiChild            ( 0 )
	,	OwnerWindow			( InOwnerWindow )
	,	NotifyHook			( 0 )
	,   Snoop               ( NULL )
	{}
#if WIN_OBJ
	void Destroy()
	{
		guard(WWindow::Destroy);
		Super::Destroy();
		MaybeDestroy();
		WWindow::_DeleteWindows.RemoveItem( this );
		unguard;
	}
#else
	virtual ~WWindow()
	{
		guard(WWindow:;~WWindow);
		MaybeDestroy();
		WWindow::_DeleteWindows.RemoveItem( this );
		unguard;
	}
#endif

	// Accessors.
	FRect GetClientRect() const
	{
		RECT R;
		::GetClientRect( hWnd, &R );
		return FRect( R );
	}
	void MoveWindow( FRect R, UBOOL bRepaint )
	{
		::MoveWindow( hWnd, R.Min.X, R.Min.Y, R.Width(), R.Height(), bRepaint );
	}
	FRect GetWindowRect() const
	{
		RECT R;
		::GetWindowRect( hWnd, &R );
		return OwnerWindow ? OwnerWindow->ScreenToClient(R) : FRect(R);
	}
	FPoint ClientToScreen( const FPoint& InP )
	{
		POINT P;
		P.x = InP.X;
		P.y = InP.Y;
		::ClientToScreen( hWnd, &P );
		return FPoint( P.x, P.y );
	}
	FPoint ScreenToClient( const FPoint& InP )
	{
		POINT P;
		P.x = InP.X;
		P.y = InP.Y;
		::ScreenToClient( hWnd, &P );
		return FPoint( P.x, P.y );
	}
	FRect ClientToScreen( const FRect& InR )
	{
		return FRect( ClientToScreen(InR.Min), ClientToScreen(InR.Max) );
	}
	FRect ScreenToClient( const FRect& InR )
	{
		return FRect( ScreenToClient(InR.Min), ScreenToClient(InR.Max) );
	}
	FPoint GetCursorPos()
	{
		FPoint Mouse;
		::GetCursorPos( Mouse );
		return ScreenToClient( Mouse );
	}
	void Show( UBOOL Show )
	{
		guard(WWindow::Show);
		ShowWindow( hWnd, Show ? SW_SHOW : SW_HIDE );
		unguard;
	}

	// WWindow interface.
	virtual void Serialize( FArchive& Ar )
	{
		guard(WWindow::Serialize);
		//!!UObject interface.
		//!!Super::Serialize( Ar );
		Ar << PersistentName;
		unguard;
	}
	virtual const TCHAR* GetPackageName()
	{
		return TEXT("Window");
	}
	virtual void DoDestroy()
	{
		guard(WWindow::DoDestroy);
		if( NotifyHook )
			NotifyHook->NotifyDestroy( this );
		if( hWnd )
			DestroyWindow( *this );
		_Windows.RemoveItem( this );
		unguard;
	}
	virtual void GetWindowClassName( TCHAR* Result )=0;
	virtual LONG WndProc( UINT Message, UINT wParam, LONG lParam )
	{
		guard(WWindow::WndProc);
		try
		{
			// Message snoop.
			if( Snoop )
			{
				if( Message==WM_CHAR )
					Snoop->SnoopChar( this, wParam );
				else if( Message==WM_KEYDOWN )
					Snoop->SnoopKeyDown( this, wParam );
				else if( Message==WM_LBUTTONDOWN )
					Snoop->SnoopLeftMouseDown( this, FPoint(LOWORD(lParam),HIWORD(lParam)) );
				else if( Message==WM_RBUTTONDOWN )
					Snoop->SnoopRightMouseDown( this, FPoint(LOWORD(lParam),HIWORD(lParam)) );
			}

			// Special multi-window activation handling.
			if( !MdiChild && !ModalCount )
			{
				static UBOOL AppActive=0;
				if( Message==WM_ACTIVATEAPP )
				{
					AppActive = wParam;
					SendMessageX( hWnd, WM_NCACTIVATE, wParam, 0 );
				}
				else if( Message==WM_NCACTIVATE && AppActive && !wParam )
				{
					return 1;
				}
			}

			// Message processing.
			if( Message==WM_DESTROY )
			{
				OnDestroy();
			}
			else if( Message==WM_DRAWITEM )
			{
				DRAWITEMSTRUCT* Info = (DRAWITEMSTRUCT*)lParam;
				for( INT i=0; i<Controls.Num(); i++ )
					if( ((WWindow*)Controls(i))->hWnd==Info->hwndItem )
						{((WWindow*)Controls(i))->OnDrawItem(Info); break;}
				return 1;
			}
			else if( Message==WM_MEASUREITEM )
			{
				MEASUREITEMSTRUCT* Info = (MEASUREITEMSTRUCT*)lParam;
				for( INT i=0; i<Controls.Num(); i++ )
					if( ((WWindow*)Controls(i))->ControlId==Info->CtlID )
						{((WWindow*)Controls(i))->OnMeasureItem(Info); break;}
				return 1;
			}
			else if( Message==WM_CLOSE )
			{
				OnClose();
			}
			else if( Message==WM_CHAR )
			{
				OnChar( wParam );
			}
			else if( Message==WM_KEYDOWN )
			{
				OnKeyDown( wParam );
			}
			else if( Message==WM_PAINT )
			{
				OnPaint();
			}
			else if( Message==WM_CREATE )
			{
				OnCreate();
			}
			else if( Message==WM_TIMER )
			{
				OnTimer();
			}
			else if( Message==WM_INITDIALOG )
			{
				OnInitDialog();
			}
			else if( Message==WM_SETFOCUS )
			{
				OnSetFocus( (HWND)wParam );
			}
			else if( Message==WM_ACTIVATE )
			{
				OnActivate( LOWORD(wParam)!=0 );
			}
			else if( Message==WM_KILLFOCUS )
			{
				OnKillFocus( (HWND)wParam );
			}
			else if( Message==WM_SIZE )
			{
				OnSize( wParam, LOWORD(lParam), HIWORD(lParam) );
			}
			else if( Message==WM_PASTE )
			{
				OnPaste();
			}
			else if( Message==WM_SHOWWINDOW )
			{
				OnShowWindow( wParam );
			}
			else if( Message==WM_COPYDATA )
			{
				OnCopyData( (HWND)wParam, (COPYDATASTRUCT*)lParam );
			}
			else if( Message==WM_CAPTURECHANGED )
			{
				OnReleaseCapture();
			}
			else if( Message==WM_MDIACTIVATE )
			{
				OnMdiActivate( (HWND)lParam==hWnd );
			}
			else if( Message==WM_MOUSEMOVE )
			{
				OnMouseMove( wParam, FPoint(LOWORD(lParam), HIWORD(lParam)) );
			}
			else if( Message==WM_LBUTTONDOWN )
			{
				OnLeftButtonDown();
			}
			else if( Message==WM_RBUTTONDOWN )
			{
				OnRightButtonDown();
			}
			else if( Message==WM_LBUTTONUP )
			{
				OnLeftButtonUp();
			}
			else if( Message==WM_RBUTTONUP )
			{
				OnRightButtonUp();
			}
			else if( Message==WM_CUT )
			{
				OnCut();
			}
			else if( Message==WM_COPY )
			{
				OnCopy();
			}
			else if( Message==WM_UNDO )
			{
				OnUndo();
			}
			else if( Message==WM_SETCURSOR )
			{
				if( OnSetCursor() )
					return 1;