CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/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/>.

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;
}