CWE-ou-minkata/Sources/Tools/MaxComponent/pfGUISkinComp.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.

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

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

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

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "HeadSpin.h"
#include "max.h"
#include "resource.h"
#include "hsTemplates.h"

#include "pfGUISkinComp.h"
#include "plGUICompClassIDs.h"

#include "../MaxMain/plMaxNodeBase.h"


pfGUISkinEditProc	*pfGUISkinEditProc::fInstance = nil;
int					pfGUISkinEditProc::fZoom = 3;		// So re-opening the dialog will keep the same zoom level

extern HINSTANCE hInstance;

pfGUISkinEditProc::pfGUISkinEditProc( plGUISkinComp *comp ) 
{
	fInstance = this; 
	fComp = comp;

	fDblDC = nil;
	fDblBitmap = nil;

	fXOffset = fYOffset = 0;

	fCurrPBRefSet = plGUISkinComp::kRefUpLeftCorner;

	fDefPen = CreatePen( PS_SOLID, 3, RGB( 200, 0, 0 ) );
	fOtherPen = CreatePen( PS_DOT, 1, RGB( 200, 0, 0 ) );

	fDragging = false;
	fDragTimer = 0;

	// Back up the old settings
	IParamBlock2 *pb = fComp->GetParamBlockByID( plComponent::kBlkComp );
	for( int i = 0; i < pfGUISkin::kNumElements; i++ )
	{
		int id = i * 4 + plGUISkinComp::kRefUpLeftCorner;
		fBackups[ i ].fX = pb->GetInt( id + 0 ); 
		fBackups[ i ].fY = pb->GetInt( id + 1 ); 
		fBackups[ i ].fWidth = pb->GetInt( id + 2 ); 
		fBackups[ i ].fHeight = pb->GetInt( id + 3 ); 
	}
}

pfGUISkinEditProc::~pfGUISkinEditProc() 
{
	fInstance = nil;
	DeleteObject( fDefPen );
	IKillDblBuffer();
}

void	pfGUISkinEditProc::IJustDrawOneRect( int whichElement, IParamBlock2 *pb, HDC hDC, HPEN whichPen, int refToIgnore )
{
	whichElement = ( whichElement * 4 ) + plGUISkinComp::kRefUpLeftCorner;

	if( whichElement == refToIgnore )
		return;

	RECT	r;
	SetRect( &r, pb->GetInt( whichElement + 0 ),
				 pb->GetInt( whichElement + 1 ),
				 pb->GetInt( whichElement + 0 ) + pb->GetInt( whichElement + 2 ),
				 pb->GetInt( whichElement + 1 ) + pb->GetInt( whichElement + 3 ) );
	
	r.left *= fZoom; r.right *= fZoom; r.top *= fZoom; r.bottom *= fZoom;

	SelectObject( hDC, whichPen );
	int rop2 = SetROP2( hDC, R2_NOTXORPEN );

	MoveToEx( hDC, r.left, r.top, nil );
	LineTo( hDC, r.right, r.top );
	LineTo( hDC, r.right, r.bottom );
	LineTo( hDC, r.left, r.bottom );
	LineTo( hDC, r.left, r.top );

	SetROP2( hDC, rop2 );
}

void	pfGUISkinEditProc::IRefreshDblBuffer( void )
{
	// Image buffer is where we keep our resized image. Dbl buffer is where we draw our bounds
	if( fDblDC == nil )
		IInitDblBuffer();
	else
	{
		// Copy the zoomed image as our backdrop
		BitBlt( fDblDC, 0, 0, fDblWidth, fDblHeight, fImageDC, 0, 0, SRCCOPY );

		RECT	r;
		IParamBlock2	*pb = fComp->GetParamBlockByID( plComponent::kBlkComp );
		if( pb != nil )
		{
			// Draw all the other elements other than our current one
			for( int i = 0; i < pfGUISkin::kNumElements; i++ )
				IJustDrawOneRect( i, pb, fDblDC, fOtherPen, fCurrPBRefSet );

			// Now draw the bounds of our current element
			SetRect( &r, pb->GetInt( fCurrPBRefSet + 0 ),
						 pb->GetInt( fCurrPBRefSet + 1 ),
						 pb->GetInt( fCurrPBRefSet + 0 ) + pb->GetInt( fCurrPBRefSet + 2 ),
						 pb->GetInt( fCurrPBRefSet + 1 ) + pb->GetInt( fCurrPBRefSet + 3 ) );
			
			// While we have it here, go ahead and update our status text for this element
			char str[ 256 ];
			sprintf( str, "Left: %d\nTop: %d\nWidth: %d\nHeight: %d\n", r.left, r.top, r.right - r.left, r.bottom - r.top );
			SetDlgItemText( fHWnd, IDC_GUI_INFO, str );
							
			r.left *= fZoom; r.right *= fZoom; r.top *= fZoom; r.bottom *= fZoom;

			SelectObject( fDblDC, fDefPen );
			int rop2 = SetROP2( fDblDC, R2_NOTXORPEN );

			MoveToEx( fDblDC, r.left, r.top, nil );
			LineTo( fDblDC, r.right, r.top );
			LineTo( fDblDC, r.right, r.bottom );
			LineTo( fDblDC, r.left, r.bottom );
			LineTo( fDblDC, r.left, r.top );

			SetROP2( fDblDC, rop2 );

			fCurrElemRect = r;
			MapWindowPoints( GetDlgItem( fHWnd, IDC_GUI_PREVIEW ), fHWnd, (POINT *)&fCurrElemRect, 2 );
			OffsetRect( &fCurrElemRect, -fXOffset, -fYOffset );
		}
	}
}

void	pfGUISkinEditProc::IRefreshImageBuffer( void )
{
	IInitDblBuffer();

	plLayerTex *layer = fComp->GetSkinBitmap();
	PBBitmap *pbBMap = layer->GetPBBitmap();

	if( pbBMap->bm == nil )
		pbBMap->Load();
	if( pbBMap->bm != nil )
	{
		// Copy into a new temp bitmap that is the right format for us to read
		Bitmap *newBM;
		BitmapInfo bi;
		bi.SetName( _T("y879873b") );
		bi.SetType( BMM_TRUE_32 );
		bi.SetFlags( MAP_HAS_ALPHA );
		bi.SetWidth( fDblWidth );
		bi.SetHeight( fDblHeight );
		newBM = TheManager->Create( &bi );

		BMM_Color_64 foo = { 0, 0, 0, 0 };
		newBM->CopyImage( pbBMap->bm, COPY_IMAGE_RESIZE_LO_QUALITY, foo, nil );

		// Now copy from our newly created bitmap into our DC....way slow :(
		BITMAPINFO *bitInfo = newBM->ToDib( 24, nil, false );
		if( bitInfo != nil )
		{
			SetDIBitsToDevice( fImageDC, 0, 0, fDblWidth, fDblHeight,
								0, 0, 0, fDblHeight,
								( (UInt8 *)bitInfo ) + bitInfo->bmiHeader.biSize,
								bitInfo,
								DIB_RGB_COLORS );
		}

		newBM->DeleteThis();
	}

	IRefreshDblBuffer();
}

void	pfGUISkinEditProc::IInitDblBuffer( void )
{
	if( fDblDC == NULL )
	{
		int		width, height;
		HDC		desk = GetDC( NULL );

		plLayerTex *layer = fComp->GetSkinBitmap();
		PBBitmap *pbBMap = layer->GetPBBitmap();
		if( pbBMap == nil )
			return;
		width = pbBMap->bi.Width() * fZoom;
		height = pbBMap->bi.Height() * fZoom;
//				GetClientRect( fHWnd, &r );
//				width = r.right - r.left;
//				height = r.bottom - r.top;

		//	Note: For some strange reason, grabbing the HDC of the window doesn't do
		//	any good, 'cause it's black-and-white (right, THAT makes sense). Grabbing
		//	the desktop DC works, however.

		fDblDC = CreateCompatibleDC( desk );
		fDblBitmap = CreateCompatibleBitmap( desk/*fDblDC*/, width, height );
		SelectObject( fDblDC, fDblBitmap );

		fImageDC = CreateCompatibleDC( desk );
		fImageBitmap = CreateCompatibleBitmap( desk/*fDblDC*/, width, height );
		SelectObject( fImageDC, fImageBitmap );

		ReleaseDC( NULL, desk );

		fDblWidth = width;
		fDblHeight = height;

		ISetScrollRanges();
		IRefreshImageBuffer();
	}
}

void	pfGUISkinEditProc::IKillDblBuffer( void )
{
	if( fDblDC != NULL )
	{
		SelectObject( fDblDC, (HBITMAP)NULL );
		DeleteObject( fDblBitmap );
		DeleteDC( fDblDC );
	}

	if( fImageDC != NULL )
	{
		SelectObject( fImageDC, (HBITMAP)NULL );
		DeleteObject( fImageBitmap );
		DeleteDC( fImageDC );
	}

	fDblDC = fImageDC = nil;
	fDblBitmap = fImageBitmap = nil;
}

void	pfGUISkinEditProc::ISetScrollRanges( void )
{
	SCROLLINFO	info;


	int visW = fPreviewRect.right - fPreviewRect.left;
	int visH = fPreviewRect.bottom - fPreviewRect.top;

	if( visW < fDblWidth )
	{
		if( fXOffset > fDblWidth - visW )
			fXOffset = fDblWidth - visW;
		else if( fXOffset < 0 )
			fXOffset = 0;

		info.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
		info.nMin = 0;
		info.nMax = fDblWidth;// - visW;
		info.nPage = visW;
		info.nPos = fXOffset;
		info.cbSize = sizeof( info );

		SetScrollInfo( GetDlgItem( fHWnd, IDC_GUI_HORZSCROLL ), SB_CTL, &info, true );
		ShowWindow( GetDlgItem( fHWnd, IDC_GUI_HORZSCROLL ), true );
	}
	else
	{
		ShowWindow( GetDlgItem( fHWnd, IDC_GUI_HORZSCROLL ), false );
		fXOffset = 0;
	}

	if( visH < fDblHeight )
	{
		if( fYOffset > fDblHeight - visH )
			fYOffset = fDblHeight - visH;
		else if( fYOffset < 0 )
			fYOffset = 0;

		info.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
		info.nMin = 0;
		info.nMax = fDblHeight;// - visH;
		info.nPage = visH;
		info.nPos = fYOffset;
		info.cbSize = sizeof( info );

		SetScrollInfo( GetDlgItem( fHWnd, IDC_GUI_VERTSCROLL ), SB_CTL, &info, true );
		ShowWindow( GetDlgItem( fHWnd, IDC_GUI_VERTSCROLL ), true );
	}
	else
	{
		ShowWindow( GetDlgItem( fHWnd, IDC_GUI_VERTSCROLL ), false );
		fYOffset = 0;
	}
}

bool	pfGUISkinEditProc::IPointWithinRange( int x, int y, int ptX, int ptY )
{
	if( x > ptX - kRangeSlop && x < ptX + kRangeSlop &&
		y > ptY - kRangeSlop && y < ptY + kRangeSlop )
		return true;
	return false;
}

bool	pfGUISkinEditProc::IPointWithinVertRange( int x, int y, int ptX, int ptY1, int ptY2 )
{
	if( x > ptX - kRangeSlop && x < ptX + kRangeSlop &&
		y > ptY1 - kRangeSlop && y < ptY2 + kRangeSlop )
		return true;
	return false;
}

bool	pfGUISkinEditProc::IPointWithinHorzRange( int x, int y, int ptX1, int ptX2, int ptY )
{
	if( x > ptX1 - kRangeSlop && x < ptX2 + kRangeSlop &&
		y > ptY - kRangeSlop && y < ptY + kRangeSlop )
		return true;
	return false;
}

UInt8	pfGUISkinEditProc::IGetDragTypeFlags( int x, int y )
{
	// Corners
	if( IPointWithinRange( x, y, fCurrElemRect.left, fCurrElemRect.top ) )
		return kLeft | kTop;
	if( IPointWithinRange( x, y, fCurrElemRect.right, fCurrElemRect.top ) )
		return kRight | kTop;
	if( IPointWithinRange( x, y, fCurrElemRect.right, fCurrElemRect.bottom ) )
		return kRight | kBottom;
	if( IPointWithinRange( x, y, fCurrElemRect.left, fCurrElemRect.bottom ) )
		return kLeft | kBottom;

	// Edges
	if( IPointWithinVertRange( x, y, fCurrElemRect.left, fCurrElemRect.top, fCurrElemRect.bottom ) )
		return kLeft;
	if( IPointWithinVertRange( x, y, fCurrElemRect.right, fCurrElemRect.top, fCurrElemRect.bottom ) )
		return kRight;

	if( IPointWithinHorzRange( x, y, fCurrElemRect.left, fCurrElemRect.right, fCurrElemRect.top ) )
		return kTop;
	if( IPointWithinHorzRange( x, y, fCurrElemRect.left, fCurrElemRect.right, fCurrElemRect.bottom ) )
		return kBottom;

	// The middle
	if( x >= fCurrElemRect.left && x <= fCurrElemRect.right && y >= fCurrElemRect.top && y <= fCurrElemRect.bottom )
		return kDragAll;

	return 0;
}

INT_PTR CALLBACK	pfGUISkinEditProc::DlgProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
	return fInstance->DialogProc( hDlg, msg, wParam, lParam );
}

INT_PTR CALLBACK	pfGUISkinEditProc::DialogProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
	PAINTSTRUCT		pInfo;
	RECT			r;
	HDC				hDC;
	int				maxDim, i, j, x, y;
	bool			timerActive = false;


	static struct plElemPair
	{
		pfGUISkin::Elements	el;
		const char			*name;
	} sElemPairs[] = { { pfGUISkin::kUpLeftCorner,			"Upper-left Corner" },
					   { pfGUISkin::kTopSpan,				"Top Span" },
					   { pfGUISkin::kUpRightCorner,			"Upper-right Corner" },
					   { pfGUISkin::kRightSpan,				"Right Span" },
					   { pfGUISkin::kLowerRightCorner,		"Lower-right Corner" },
					   { pfGUISkin::kBottomSpan,			"Bottom Span" },
					   { pfGUISkin::kLowerLeftCorner,		"Lower-left Corner" },
					   { pfGUISkin::kLeftSpan,				"Left Span" },
					   { pfGUISkin::kMiddleFill,			"Middle Fill" },
					   { pfGUISkin::kSelectedFill,			"Selected Middle Fill" },
					   { pfGUISkin::kSubMenuArrow,			"Sub-Menu Arrow" },
					   { pfGUISkin::kSelectedSubMenuArrow,	"Selected Sub-Menu Arrow" },
					   { pfGUISkin::kTreeButtonClosed,		"Tree-view Button, Closed" },
					   { pfGUISkin::kTreeButtonOpen,		"Tree-view Button, Open" },
					   { pfGUISkin::kNumElements, nil } };


	fHWnd = hDlg;

	switch( msg )
	{
		case WM_INITDIALOG:

			// Get preview rect
			GetClientRect( GetDlgItem( hDlg, IDC_GUI_PREVIEW ), &fPreviewRect );
			MapWindowPoints( GetDlgItem( hDlg, IDC_GUI_PREVIEW ), hDlg, (POINT *)&fPreviewRect, 2 );

			SendDlgItemMessage( hDlg, IDC_GUI_ZIN, BM_SETIMAGE, (WPARAM)IMAGE_ICON, 
										(LPARAM)LoadImage( hInstance, MAKEINTRESOURCE( IDI_ZOOMIN ), IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR ) );
			SendDlgItemMessage( hDlg, IDC_GUI_ZOUT, BM_SETIMAGE, (WPARAM)IMAGE_ICON, 
										(LPARAM)LoadImage( hInstance, MAKEINTRESOURCE( IDI_ZOOMOUT ), IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR ) );

			// Fill element list
			SendDlgItemMessage( hDlg, IDC_GUI_ELEMENTS, LB_RESETCONTENT, 0, 0 );
			for( i = 0; sElemPairs[ i ].el != pfGUISkin::kNumElements; i++ )
			{
				int idx = SendDlgItemMessage( hDlg, IDC_GUI_ELEMENTS, LB_ADDSTRING, 0, (LPARAM)sElemPairs[ i ].name );
				SendDlgItemMessage( hDlg, IDC_GUI_ELEMENTS, LB_SETITEMDATA, (WPARAM)idx, (LPARAM)sElemPairs[ i ].el );
				if( sElemPairs[ i ].el == pfGUISkin::kUpLeftCorner )
					j = idx;
			}
			SendDlgItemMessage( hDlg, IDC_GUI_ELEMENTS, LB_SETCURSEL, j, 0 );

			fOrigCursor = LoadCursor( nil, IDC_ARROW );//GetCursor();

			break;

		case WM_COMMAND:
			if( LOWORD( wParam ) == IDCANCEL )
			{
				// Since we've been editing the PB directly, we have to now restore them
				// to their original values
				IParamBlock2 *pb = fComp->GetParamBlockByID( plComponent::kBlkComp );
				for( int i = 0; i < pfGUISkin::kNumElements; i++ )
				{
					int id = i * 4 + plGUISkinComp::kRefUpLeftCorner;
					pb->SetValue( id + 0, 0, (int)fBackups[ i ].fX );
					pb->SetValue( id + 1, 0, (int)fBackups[ i ].fY ); 
					pb->SetValue( id + 2, 0, (int)fBackups[ i ].fWidth );
					pb->SetValue( id + 3, 0, (int)fBackups[ i ].fHeight );
				}
				EndDialog( hDlg, 1 );
			}
			else if( LOWORD( wParam ) == IDOK )
				EndDialog( hDlg, 0 );
			else if( LOWORD( wParam ) == IDC_GUI_ZIN )
			{
				fXOffset /= fZoom;	fYOffset /= fZoom;
				fZoom++;
				fXOffset *= fZoom;	fYOffset *= fZoom;

				IKillDblBuffer();
				IRefreshImageBuffer();
				InvalidateRect( hDlg, &fPreviewRect, false );
			}
			else if( LOWORD( wParam ) == IDC_GUI_ZOUT )
			{
				if( fZoom > 1 )
				{
					fXOffset /= fZoom;	fYOffset /= fZoom;
					fZoom--;
					fXOffset *= fZoom;	fYOffset *= fZoom;

					IKillDblBuffer();
					IRefreshImageBuffer();
					InvalidateRect( hDlg, &fPreviewRect, false );
				}
			}
			else if( LOWORD( wParam ) == IDC_GUI_ELEMENTS )
			{
				int idx = SendDlgItemMessage( hDlg, IDC_GUI_ELEMENTS, LB_GETCURSEL, 0, 0 );
				fCurrPBRefSet = SendDlgItemMessage( hDlg, IDC_GUI_ELEMENTS, LB_GETITEMDATA, (WPARAM)idx, 0 ) * 4 + plGUISkinComp::kRefUpLeftCorner;

				IRefreshDblBuffer();
				InvalidateRect( hDlg, &fPreviewRect, false );
			}
			return true;

		case WM_CLOSE:
			EndDialog( hDlg, 0 );
			return true;

		case WM_HSCROLL:
			OffsetRect( &fCurrElemRect, fXOffset, fYOffset );
			switch( LOWORD( wParam ) )
			{
				case SB_PAGEUP:		fXOffset -= 300; break;
				case SB_PAGEDOWN:	fXOffset += 300; break;
				case SB_LINEUP:		fXOffset -= 16; break;
				case SB_LINEDOWN:	fXOffset += 16; break;
				case SB_THUMBPOSITION:
				case SB_THUMBTRACK:
					fXOffset = HIWORD( wParam );
					break;
			}
			maxDim = fDblWidth - ( fPreviewRect.right - fPreviewRect.left );
			if( fXOffset < 0 )
				fXOffset = 0;
			else if( fXOffset > maxDim )
				fXOffset = maxDim;
			SetScrollPos( GetDlgItem( hDlg, IDC_GUI_HORZSCROLL ), SB_CTL, fXOffset, true );

			OffsetRect( &fCurrElemRect, -fXOffset, -fYOffset );
			InvalidateRect( hDlg, &fPreviewRect, false );
			break;

		case WM_VSCROLL:
			OffsetRect( &fCurrElemRect, fXOffset, fYOffset );
			switch( LOWORD( wParam ) )
			{
				case SB_PAGEUP:		fYOffset -= 300; break;
				case SB_PAGEDOWN:	fYOffset += 300; break;
				case SB_LINEUP:		fYOffset -= 16; break;
				case SB_LINEDOWN:	fYOffset += 16; break;
				case SB_THUMBPOSITION:
				case SB_THUMBTRACK:
					fYOffset = HIWORD( wParam );
					break;
			}
			maxDim = fDblHeight - ( fPreviewRect.bottom - fPreviewRect.top );
			if( fYOffset < 0 )
				fYOffset = 0;
			else if( fYOffset > maxDim )
				fYOffset = maxDim;
			SetScrollPos( GetDlgItem( hDlg, IDC_GUI_VERTSCROLL ), SB_CTL, fYOffset, true );

			OffsetRect( &fCurrElemRect, -fXOffset, -fYOffset );
			InvalidateRect( hDlg, &fPreviewRect, false );
			break;

		case WM_PAINT:
			{
				BeginPaint( hDlg, &pInfo );
				hDC = (HDC)pInfo.hdc;

				if( fDblDC == NULL )
					IInitDblBuffer();

				int width = fDblWidth;
				int height = fDblHeight;
				if( width > fPreviewRect.right - fPreviewRect.left )
					width = fPreviewRect.right - fPreviewRect.left;
				if( height > fPreviewRect.bottom - fPreviewRect.top )
					height = fPreviewRect.bottom - fPreviewRect.top;

				BitBlt( hDC, fPreviewRect.left, fPreviewRect.top, width, height, fDblDC, fXOffset, fYOffset, SRCCOPY );

				r = fPreviewRect;
				r.left += width;
				FillRect( hDC, &r, ColorMan()->GetBrush( kBackground ) );

				r = fPreviewRect;
				r.top += height;
				FillRect( hDC, &r, ColorMan()->GetBrush( kBackground ) );

				EndPaint( hDlg, &pInfo );
			}
			break;

		case WM_LBUTTONDOWN:
			SetCapture( hDlg );
			fDragging = true;
			fDragType = IGetDragTypeFlags( GET_X_LPARAM( lParam ), GET_Y_LPARAM( lParam ) );
			if( fDragType == kDragAll )
			{
				fDragOffsetX = fCurrElemRect.left - GET_X_LPARAM( lParam );
				fDragOffsetY = fCurrElemRect.top - GET_Y_LPARAM( lParam );
			}
			else if( fDragType == 0 )
			{
				fDragOffsetX = GET_X_LPARAM( lParam ) + fXOffset;
				fDragOffsetY = GET_Y_LPARAM( lParam ) + fYOffset;
			}
			else
				fDragOffsetX = fDragOffsetY = 0;

			break;

		case WM_LBUTTONUP:
			ReleaseCapture();
			fDragging = false;
			break;

		case WM_TIMER:
			// We do the same processing as MOUSEMOVE, but we need to make sure we have the right
			// mouse position first
			{
				POINT pt;
				GetCursorPos( &pt );
				MapWindowPoints( nil, hDlg, &pt, 1 );
				lParam = MAKELPARAM( pt.x, pt.y );
			}
			// Fall thru...

		case WM_MOUSEMOVE:
			x = GET_X_LPARAM( lParam );
			y = GET_Y_LPARAM( lParam );

			if( fDragging )
			{
				if( fDragType == 0 )
				{
					fXOffset = fDragOffsetX - x;
					fYOffset = fDragOffsetY - y;
					ISetScrollRanges();	// Will clamp offset \for us
				}
				else
				{
					// Translate x and y into bitmap space
					POINT pt;
					pt.x = x;
					pt.y = y;

					if( PtInRect( &fPreviewRect, pt ) )
					{
						MapWindowPoints( hDlg, GetDlgItem( hDlg, IDC_GUI_PREVIEW ), &pt, 1 );

						pt.x += fDragOffsetX;
						pt.y += fDragOffsetY;

						// Note the + 1/2 zoom so it's the closest pixel by center, not by area
						x = ( pt.x + fXOffset + ( fZoom >> 1 ) ) / fZoom;
						y = ( pt.y + fYOffset + ( fZoom >> 1 ) ) / fZoom;

						// Set depending on our current drag flags
						// Note the logic here: if we drag left, we want width and left changing,
						// if we drag both, just left, if we drag right, just width
						IParamBlock2 *pb = fComp->GetParamBlockByID( plComponent::kBlkComp );
						if( fDragType & kLeft )
						{
							if( fDragType & kRight )
								pb->SetValue( fCurrPBRefSet + 0, 0, (int)x );
							else 
							{
								int old = pb->GetInt( fCurrPBRefSet + 0 ) + pb->GetInt( fCurrPBRefSet + 2 );

								pb->SetValue( fCurrPBRefSet + 0, 0, (int)x );
								pb->SetValue( fCurrPBRefSet + 2, 0, (int)old - x );
							}
						}
						else if( fDragType & kRight )
							pb->SetValue( fCurrPBRefSet + 2, 0, (int)x - pb->GetInt( fCurrPBRefSet + 0 ) );

						if( fDragType & kTop )
						{
							if( fDragType & kBottom )
								pb->SetValue( fCurrPBRefSet + 1, 0, (int)y );
							else 
							{
								int old = pb->GetInt( fCurrPBRefSet + 1 ) + pb->GetInt( fCurrPBRefSet + 3 );

								pb->SetValue( fCurrPBRefSet + 1, 0, (int)y );
								pb->SetValue( fCurrPBRefSet + 3, 0, (int)old - y );
							}
						}
						else if( fDragType & kBottom )
							pb->SetValue( fCurrPBRefSet + 3, 0, (int)y - pb->GetInt( fCurrPBRefSet + 1 ) );

						// Clamp width and height
						if( pb->GetInt( fCurrPBRefSet + 2 ) < 0 )
							pb->SetValue( fCurrPBRefSet + 2, 0, (int)0 );
						if( pb->GetInt( fCurrPBRefSet + 3 ) < 0 )
							pb->SetValue( fCurrPBRefSet + 3, 0, (int)0 );

						// Clamp X and Y
						if( pb->GetInt( fCurrPBRefSet + 0 ) < 0 )
							pb->SetValue( fCurrPBRefSet + 0, 0, (int)0 );
						else if( pb->GetInt( fCurrPBRefSet + 0 ) + pb->GetInt( fCurrPBRefSet + 2 ) > fDblWidth / fZoom )
							pb->SetValue( fCurrPBRefSet + 0, 0, (int)fDblWidth / fZoom - pb->GetInt( fCurrPBRefSet + 2 ) );

						if( pb->GetInt( fCurrPBRefSet + 1 ) < 0 )
							pb->SetValue( fCurrPBRefSet + 1, 0, (int)0 );
						else if( pb->GetInt( fCurrPBRefSet + 1 ) + pb->GetInt( fCurrPBRefSet + 3 ) > fDblHeight / fZoom )
							pb->SetValue( fCurrPBRefSet + 1, 0, (int)fDblHeight / fZoom - pb->GetInt( fCurrPBRefSet + 3 ) );
					}
					else
					{
						// Mouse is outside our preview, so scroll if possible
						int dX = ( x < fPreviewRect.left ) ? x - fPreviewRect.left : ( x > fPreviewRect.right ) ? x - fPreviewRect.right : 0;
						int dY = ( y < fPreviewRect.top ) ? y - fPreviewRect.top : ( y > fPreviewRect.bottom ) ? y - fPreviewRect.bottom : 0;

						fXOffset += dX;
						fYOffset += dY;			
						OffsetRect( &fCurrElemRect, -dX, -dY );

						ISetScrollRanges();	// Will clamp origin for us

						// Don't actually drag our bounds, 'cause we're scrolling

						// Note: since we only get MOUSEMOVE when, gee, the mouse moves, if we've scrolled over, it'll only
						// do it once and then wait for the mouse to nudge again. We'd rather it keep going until the user
						// moves the mouse again, so we create a timer that calls us back in n somethingths so we can check again
						if( fDragTimer == 0 )
							fDragTimer = SetTimer( hDlg, 0, 200, nil );
						timerActive = true;		// So we don't kill it at the end here...
					}
				}

				IRefreshDblBuffer();
				InvalidateRect( hDlg, &fPreviewRect, false );
			}
			else
			{
				UInt8 dragType = IGetDragTypeFlags( x, y );
				HCURSOR cursor;
				switch( dragType )
				{
					case kLeft | kTop:		
					case kRight | kBottom:
						cursor = LoadCursor( nil, IDC_SIZENWSE );
						break;
					case kLeft | kBottom:		
					case kRight | kTop:
						cursor = LoadCursor( nil, IDC_SIZENESW );
						break;
					case kLeft:		
					case kRight:
						cursor = LoadCursor( nil, IDC_SIZEWE );
						break;
					case kTop:		
					case kBottom:
						cursor = LoadCursor( nil, IDC_SIZENS );
						break;
					case kLeft | kTop | kRight | kBottom:		
						cursor = LoadCursor( nil, IDC_SIZEALL );
						break;
					default:
						{
							POINT pt;
							pt.x = x;
							pt.y = y;
							if( PtInRect( &fPreviewRect, pt ) )
								cursor = LoadCursor( nil, IDC_HAND );
							else
								cursor = fOrigCursor;
						}
						break;
				}
				
				SetCursor( cursor );

				if( !timerActive )
				{
					// No longer need our trick timer, so kill it
					KillTimer( hDlg, fDragTimer );
					fDragTimer = 0;
				}
			}
			break;
	}

	return false;
}

plGUISkinComp	*plGUISkinComp::GetGUIComp( INode *node )
{
	if( node == nil )
		return nil;

	plComponentBase *base = ( ( plMaxNodeBase *)node )->ConvertToComponent();
	if( base == nil )
		return nil;

	if( base->ClassID() == GUI_SKIN_CLASSID )
		return (plGUISkinComp *)base;

	return nil;
}