You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1880 lines
46 KiB
1880 lines
46 KiB
/*==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 "plAutoUIParams.h" |
|
|
|
#include "../MaxMain/plMaxAccelerators.h" |
|
#include "hsUtils.h" |
|
#include <algorithm> |
|
#include "../MaxMain/plMaxNode.h" |
|
#include "plComponentBase.h" |
|
|
|
plAutoUIParam::plAutoUIParam(ParamID id, const char *name) : |
|
fID(id), fName(hsStrcpy(name)), fVisID(-1), fHeight(0) |
|
{ |
|
} |
|
|
|
plAutoUIParam::~plAutoUIParam() |
|
{ |
|
delete [] fName; |
|
} |
|
|
|
int plAutoUIParam::Create(HWND hDlg, IParamBlock2 *pb, int yOffset) |
|
{ |
|
int size = fControlVec.size(); |
|
if (size > 0) |
|
fControlVec.clear(); |
|
|
|
int initialOffset = yOffset; |
|
int finalOffset = CreateControls(hDlg, pb, yOffset); |
|
|
|
fHeight = finalOffset - initialOffset; |
|
fhDlg = hDlg; |
|
|
|
return finalOffset; |
|
} |
|
|
|
int plAutoUIParam::ISizeControl(HWND hDlg, HWND hControl, int w, int h, int y, int x) |
|
{ |
|
// Convert the dialog units to screen units |
|
RECT rect; |
|
SetRect(&rect, x, 0, w, h); |
|
MapDialogRect(hDlg, &rect); |
|
// Y is already in screen units |
|
rect.top = y; |
|
|
|
// Resize the window |
|
MoveWindow(hControl, rect.left, rect.top, rect.right, rect.bottom, FALSE); |
|
|
|
return rect.bottom; |
|
} |
|
|
|
HWND plAutoUIParam::ICreateControl(HWND hDlg, const char *className, const char *wndName, DWORD style, DWORD exStyle) |
|
{ |
|
HWND hwnd = CreateWindowEx(exStyle, className, wndName, WS_VISIBLE | WS_CHILD | style, |
|
0, 0, 0, 0, hDlg, 0/*(HMENU)fDlgItemID*/, hInstance, NULL); |
|
|
|
fControlVec.push_back(hwnd); |
|
|
|
return hwnd; |
|
} |
|
|
|
// By default the controls use a font that is too big. This fixes that. |
|
void plAutoUIParam::ISetControlFont(HWND hControl) |
|
{ |
|
SendMessage(hControl, WM_SETFONT, (WPARAM)GetCOREInterface()->GetAppHFont(), TRUE); |
|
} |
|
|
|
int plAutoUIParam::IAddStaticText(HWND hDlg, int y, const char *text) |
|
{ |
|
HWND hStatic = ICreateControl(hDlg, "Static", text, SS_LEFT); |
|
int height = ISizeControl(hDlg, hStatic, 100, 8, y) + 2; |
|
ISetControlFont(hStatic); |
|
|
|
return height; |
|
} |
|
|
|
int plAutoUIParam::GetParamType() |
|
{ |
|
return kTypeNone; |
|
} |
|
|
|
void plAutoUIParam::Show(int yOffset) |
|
{ |
|
HWND tmp; |
|
|
|
int ctrlOffset = 0; |
|
RECT rect; |
|
|
|
for (int i = 0; i < fControlVec.size(); i++) |
|
{ |
|
tmp = fControlVec[i]; |
|
GetWindowRect(tmp, &rect); |
|
|
|
SetRect(&rect, 3, 0, (rect.right - rect.left) + 3, rect.bottom - rect.top); |
|
//MapDialogRect(fhDlg, &rect); |
|
// Y is already in screen units |
|
rect.top = yOffset + ctrlOffset; |
|
rect.bottom = rect.bottom + rect.top; |
|
|
|
// Resize the window |
|
MoveWindow(tmp, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, TRUE); |
|
//MoveWindow(tmp, rect.left, yOffset + ctrlOffset, (rect.right - rect.left), (rect.bottom - rect.top), FALSE); |
|
ctrlOffset += (rect.bottom - rect.top) + 2; |
|
|
|
ShowWindow(tmp, SW_SHOW); |
|
} |
|
} |
|
|
|
void plAutoUIParam::Hide() |
|
{ |
|
HWND tmp; |
|
|
|
for (int i = 0; i < fControlVec.size(); i++) |
|
{ |
|
tmp = fControlVec[i]; |
|
ShowWindow(tmp, SW_HIDE); |
|
} |
|
} |
|
|
|
int plAutoUIParam::GetHeight() |
|
{ |
|
return fHeight; |
|
} |
|
|
|
void plAutoUIParam::SetVisInfo(ParamID id, std::vector<std::string>* states) |
|
{ |
|
fVisID = id; |
|
fVisStates = *states; |
|
} |
|
|
|
bool plAutoUIParam::CheckVisibility(ParamID id, std::string state) |
|
{ |
|
if (fVisStates.size() == 0) |
|
{ |
|
return true; |
|
} |
|
else |
|
{ |
|
if (fVisID == id) |
|
{ |
|
if (std::find(fVisStates.begin(), fVisStates.end(), state) != fVisStates.end()) |
|
{ |
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
} |
|
|
|
hsBool plAutoUIParam::GetBool(IParamBlock2 *pb) |
|
{ |
|
hsAssert(false, "Parameter is not a bool"); |
|
return false; |
|
} |
|
float plAutoUIParam::GetFloat(IParamBlock2 *pb) |
|
{ |
|
hsAssert(false, "Parameter is not a float"); |
|
return -1; |
|
} |
|
int plAutoUIParam::GetInt(IParamBlock2 *pb) |
|
{ |
|
hsAssert(false, "Parameter is not an int"); |
|
return -1; |
|
} |
|
const char* plAutoUIParam::GetString(IParamBlock2 *pb) |
|
{ |
|
hsAssert(false, "Parameter is not a string"); |
|
return nil; |
|
} |
|
int plAutoUIParam::GetCount(IParamBlock2 *pb) |
|
{ |
|
hsAssert(false, "Parameter is not a key list"); |
|
return -1; |
|
} |
|
plKey plAutoUIParam::GetKey(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(false, "Parameter is not a key"); |
|
return nil; |
|
} |
|
plComponentBase *plAutoUIParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(false, "Parameter is not a component"); |
|
return nil; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plCheckBoxParam::plCheckBoxParam(ParamID id, const char *name) : |
|
plAutoUIParam(id, name), fhCheck(nil) |
|
{ |
|
} |
|
|
|
int plCheckBoxParam::CreateControls(HWND hDlg, IParamBlock2 *pb, int yOffset) |
|
{ |
|
// Create the checkbox |
|
fhCheck = ICreateControl(hDlg, "Button", fName, BS_AUTOCHECKBOX); |
|
yOffset += ISizeControl(hDlg, fhCheck, 90, 10, yOffset) + 2; |
|
|
|
// Set the check from the current value |
|
SendMessage(fhCheck, BM_SETCHECK, pb->GetInt(fID), 0); |
|
|
|
return yOffset; |
|
} |
|
|
|
bool plCheckBoxParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhCheck) |
|
{ |
|
// Get the state |
|
hsBool checked = (SendMessage(fhCheck, BM_GETCHECK, 0, 0) == BST_CHECKED); |
|
// Set the state in the paramblock |
|
pb->SetValue(fID, 0, checked); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
int plCheckBoxParam::GetParamType() |
|
{ |
|
return kTypeBool; |
|
} |
|
hsBool plCheckBoxParam::GetBool(IParamBlock2 *pb) |
|
{ |
|
return pb->GetInt(fID); |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plSpinnerParam::plSpinnerParam(ParamID id, const char *name, bool isFloat) : |
|
plAutoUIParam(id, name), fIsFloat(isFloat), fhSpinner(nil) |
|
{ |
|
} |
|
|
|
int plSpinnerParam::CreateControls(HWND hDlg, IParamBlock2 *pb, int yOffset) |
|
{ |
|
yOffset += IAddStaticText(hDlg, yOffset, fName); |
|
|
|
// Create the edit box |
|
HWND hEdit = ICreateControl(hDlg, "CustEdit"); |
|
ISizeControl(hDlg, hEdit, 30, 10, yOffset); |
|
|
|
// Create the spinner (beside the edit box) |
|
fhSpinner = ICreateControl(hDlg, "SpinnerControl"); |
|
yOffset += ISizeControl(hDlg, fhSpinner, 8, 10, yOffset, 33) + 2; |
|
|
|
// Initialize the spinner |
|
ISpinnerControl *spin = GetISpinner(fhSpinner); |
|
ParamDef &def = pb->GetParamDef(fID); |
|
if (fIsFloat) |
|
{ |
|
spin->SetLimits(def.range_low.f, def.range_high.f, FALSE); |
|
spin->SetValue(pb->GetFloat(fID), FALSE); |
|
spin->SetScale(0.1f); |
|
spin->LinkToEdit(hEdit, EDITTYPE_FLOAT); |
|
} |
|
else |
|
{ |
|
spin->SetLimits(def.range_low.i, def.range_high.i, FALSE); |
|
spin->SetValue(pb->GetInt(fID), FALSE); |
|
spin->SetScale(1); |
|
spin->LinkToEdit(hEdit, EDITTYPE_INT); |
|
} |
|
|
|
ReleaseISpinner(spin); |
|
|
|
return yOffset; |
|
} |
|
|
|
void plSpinnerParam::Show(int yOffset) |
|
{ |
|
yOffset += ISizeControl(fhDlg, fControlVec[0], 100, 8, yOffset) + 2; |
|
ISizeControl(fhDlg, fControlVec[1], 30, 10, yOffset); |
|
ISizeControl(fhDlg, fControlVec[2], 8, 10, yOffset, 33); |
|
|
|
ShowWindow(fControlVec[0], SW_SHOW); |
|
ShowWindow(fControlVec[1], SW_SHOW); |
|
ShowWindow(fControlVec[2], SW_SHOW); |
|
} |
|
|
|
bool plSpinnerParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == CC_SPINNER_CHANGE)// && HIWORD(wParam) == FALSE) |
|
{ |
|
ISpinnerControl *spin = (ISpinnerControl*)lParam; |
|
HWND hSpinner = spin->GetHwnd(); |
|
if (hSpinner == fhSpinner) |
|
{ |
|
// Set the state |
|
if (fIsFloat) |
|
pb->SetValue(fID, 0, spin->GetFVal()); |
|
else |
|
pb->SetValue(fID, 0, spin->GetIVal()); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
int plSpinnerParam::GetParamType() |
|
{ |
|
return fIsFloat ? kTypeFloat : kTypeInt; |
|
} |
|
float plSpinnerParam::GetFloat(IParamBlock2 *pb) |
|
{ |
|
return (fIsFloat ? pb->GetFloat(fID) : -1); |
|
} |
|
int plSpinnerParam::GetInt(IParamBlock2 *pb) |
|
{ |
|
return (!fIsFloat ? pb->GetInt(fID) : -1); |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plEditParam::plEditParam(ParamID id, const char *name, int lines) : |
|
plAutoUIParam(id, name), fhEdit(nil), fLines(lines) |
|
{ |
|
} |
|
|
|
int plEditParam::CreateControls(HWND hDlg, IParamBlock2 *pb, int yOffset) |
|
{ |
|
yOffset += IAddStaticText(hDlg, yOffset, fName); |
|
|
|
// |
|
// Create the edit box |
|
// |
|
DWORD flags = ES_AUTOHSCROLL | ES_LEFT | WS_BORDER; |
|
// If this edit box has more than one line, add the multiline flags |
|
if (fLines > 1) |
|
flags |= ES_AUTOVSCROLL | ES_MULTILINE | ES_WANTRETURN; |
|
|
|
fhEdit = ICreateControl(hDlg, "Edit", nil, flags, WS_EX_CLIENTEDGE); |
|
yOffset += ISizeControl(hDlg, fhEdit, 100, 5 + 8*fLines, yOffset) + 2; |
|
ISetControlFont(fhEdit); |
|
|
|
// Initialize the edit box |
|
SetWindowText(fhEdit, pb->GetStr(fID)); |
|
|
|
return yOffset; |
|
} |
|
|
|
void plEditParam::Show(int yOffset) |
|
{ |
|
yOffset += ISizeControl(fhDlg, fControlVec[0], 100, 8, yOffset) + 2; |
|
ISizeControl(fhDlg, fControlVec[1], 100, 5 + 8*fLines, yOffset); |
|
|
|
ShowWindow(fControlVec[0], SW_SHOW); |
|
ShowWindow(fControlVec[1], SW_SHOW); |
|
} |
|
|
|
bool plEditParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND) |
|
{ |
|
// Disable Max accelerators when the edit box gets focus |
|
if (HIWORD(wParam) == EN_SETFOCUS && (HWND)lParam == fhEdit) |
|
{ |
|
plMaxAccelerators::Disable(); |
|
return true; |
|
} |
|
else if (HIWORD(wParam) == EN_KILLFOCUS && (HWND)lParam == fhEdit) |
|
{ |
|
// Get the text from the edit and store it in the paramblock |
|
int len = GetWindowTextLength(fhEdit)+1; |
|
if (len > 1) |
|
{ |
|
char *buf = TRACKED_NEW char[len]; |
|
GetWindowText(fhEdit, buf, len); |
|
pb->SetValue(fID, 0, buf); |
|
delete [] buf; |
|
} |
|
else |
|
pb->SetValue(fID, 0, ""); |
|
|
|
plMaxAccelerators::Enable(); |
|
|
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
int plEditParam::GetParamType() |
|
{ |
|
return kTypeString; |
|
} |
|
const char* plEditParam::GetString(IParamBlock2 *pb) |
|
{ |
|
return pb->GetStr(fID); |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include "plPickNode.h" |
|
|
|
plPickListParam::plPickListParam(ParamID id, const char *name, std::vector<Class_ID>* filter) : |
|
plAutoUIParam(id, name), fhList(nil), fhAdd(nil), fhRemove(nil) |
|
{ |
|
if (filter) |
|
fCIDs = *filter; |
|
} |
|
|
|
int plPickListParam::CreateControls(HWND hDlg, IParamBlock2 *pb, int yOffset) |
|
{ |
|
yOffset += IAddStaticText(hDlg, yOffset, fName) + 2; |
|
|
|
// Create the listbox |
|
fhList = ICreateControl(hDlg, "ListBox", nil, LBS_STANDARD | LBS_NOINTEGRALHEIGHT, WS_EX_CLIENTEDGE); |
|
yOffset += ISizeControl(hDlg, fhList, 100, 5+4*8, yOffset) + 2; |
|
ISetControlFont(fhList); |
|
|
|
// Create the Add button |
|
fhAdd = ICreateControl(hDlg, "Button"); |
|
ISizeControl(hDlg, fhAdd, 48, 14, yOffset, 4); |
|
SetWindowText(fhAdd, "Add..."); |
|
|
|
// Create the Remove button |
|
fhRemove = ICreateControl(hDlg, "Button"); |
|
yOffset += ISizeControl(hDlg, fhRemove, 48, 14, yOffset, 54); |
|
SetWindowText(fhRemove, "Remove"); |
|
|
|
return yOffset; |
|
} |
|
|
|
void plPickListParam::Show(int yOffset) |
|
{ |
|
yOffset += ISizeControl(fhDlg, fControlVec[0], 100, 8, yOffset) + 4; |
|
yOffset += ISizeControl(fhDlg, fControlVec[1], 100, 5+4*8, yOffset) + 2; |
|
ISizeControl(fhDlg, fControlVec[2], 48, 14, yOffset, 4); |
|
ISizeControl(fhDlg, fControlVec[3], 48, 14, yOffset, 54); |
|
|
|
ShowWindow(fControlVec[0], SW_SHOW); |
|
ShowWindow(fControlVec[1], SW_SHOW); |
|
ShowWindow(fControlVec[2], SW_SHOW); |
|
ShowWindow(fControlVec[3], SW_SHOW); |
|
} |
|
|
|
bool plPickListParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_INITDIALOG) |
|
{ |
|
IUpdateList(pb); |
|
return false; |
|
} |
|
|
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhAdd) |
|
{ |
|
plPick::Node(pb, fID, &fCIDs, false, false); |
|
IUpdateList(pb); |
|
return true; |
|
} |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
int sel = SendMessage(fhList, LB_GETCURSEL, 0, 0); |
|
if (sel != -1) |
|
{ |
|
pb->Delete(fID, sel, 1); |
|
IUpdateList(pb); |
|
} |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
void plPickListParam::IUpdateList(IParamBlock2 *pb) |
|
{ |
|
SendMessage(fhList, LB_RESETCONTENT, 0, 0); |
|
|
|
int count = pb->Count(fID); |
|
for (int i = 0; i < count; i++) |
|
{ |
|
INode *node = pb->GetINode(fID, 0, i); |
|
const char *name = node ? node->GetName() : "<deleted>"; |
|
SendMessage(fhList, LB_ADDSTRING, 0, (LPARAM)name); |
|
} |
|
} |
|
|
|
int plPickListParam::GetParamType() |
|
{ |
|
return kTypeSceneObj; |
|
} |
|
int plPickListParam::GetCount(IParamBlock2 *pb) |
|
{ |
|
return pb->Count(fID); |
|
} |
|
plKey plPickListParam::GetKey(IParamBlock2 *pb, int idx) |
|
{ |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID, 0, idx); |
|
if (node) |
|
return node->GetKey(); |
|
|
|
return nil; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
class plPickButtonParam; |
|
|
|
class PickNodeButtonFilter : public PickNodeCallback |
|
{ |
|
public: |
|
virtual BOOL Filter(INode *node) { return TRUE; } |
|
}; |
|
static PickNodeButtonFilter gPickFilter; |
|
|
|
class PickNodeButtonMode : public PickModeCallback |
|
{ |
|
public: |
|
plPickButtonParam *fParam; |
|
IParamBlock2 *fPB; |
|
|
|
BOOL HitTest(IObjParam *ip, HWND hWnd, ViewExp *vpt, IPoint2 m, int flags) |
|
{ |
|
return (ip->PickNode(hWnd,m,&gPickFilter) != NULL); |
|
} |
|
BOOL Pick(IObjParam *ip, ViewExp *vpt); |
|
|
|
PickNodeCallback *GetFilter() { return &gPickFilter; } |
|
BOOL RightClick(IObjParam *ip, ViewExp *vpt); |
|
}; |
|
|
|
static PickNodeButtonMode gPickMode; |
|
|
|
plPickButtonParam::plPickButtonParam(ParamID id, const char *name, std::vector<Class_ID>* filter, bool canConvertToType) : |
|
plAutoUIParam(id, name), fButton(nil), fCanConvertToType(canConvertToType) |
|
{ |
|
if (filter) |
|
fCIDs = *filter; |
|
} |
|
|
|
int plPickButtonParam::CreateControls(HWND hDlg, IParamBlock2 *pb, int yOffset) |
|
{ |
|
yOffset += IAddStaticText(hDlg, yOffset, fName) + 2; |
|
|
|
// Create the picknode button |
|
HWND button = ICreateControl(hDlg, "CustButton"); |
|
ISizeControl(hDlg, button, 84, 12, yOffset); |
|
|
|
fButton = GetICustButton(button); |
|
|
|
// Setup the button properties |
|
fButton->SetType(CBT_CHECK); |
|
fButton->SetButtonDownNotify(TRUE); |
|
fButton->SetCheckHighlight(TRUE); |
|
fButton->SetHighlightColor(GREEN_WASH); |
|
|
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
else |
|
fButton->SetText("(none)"); |
|
|
|
// Create the Remove button |
|
fhRemove = ICreateControl(hDlg, "Button"); |
|
yOffset += ISizeControl(hDlg, fhRemove, 17, 12, yOffset, 89); |
|
SetWindowText(fhRemove, "Clear"); |
|
|
|
return yOffset; |
|
} |
|
|
|
void plPickButtonParam::Show(int yOffset) |
|
{ |
|
yOffset += ISizeControl(fhDlg, fControlVec[0], 100, 8, yOffset) + 4; |
|
ISizeControl(fhDlg, fControlVec[1], 84, 12, yOffset); |
|
ISizeControl(fhDlg, fControlVec[2], 17, 12, yOffset, 89); |
|
|
|
|
|
ShowWindow(fControlVec[0], SW_SHOW); |
|
ShowWindow(fControlVec[1], SW_SHOW); |
|
ShowWindow(fControlVec[2], SW_SHOW); |
|
} |
|
|
|
bool plPickButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fCIDs.size() > 0) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if (plPick::Node(pb, fID, &fCIDs, true, fCanConvertToType)) |
|
{ |
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
} |
|
else |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
gPickMode.fParam = this; |
|
gPickMode.fPB = pb; |
|
GetCOREInterface()->SetPickMode(&gPickMode); |
|
} |
|
else |
|
{ |
|
GetCOREInterface()->ClearPickMode(); |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
void plPickButtonParam::SetPickNode(INode *node, IParamBlock2 *pb) |
|
{ |
|
if (node && pb) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)node); |
|
fButton->SetText(node->GetName()); |
|
} |
|
|
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
|
|
BOOL PickNodeButtonMode::Pick(IObjParam *ip, ViewExp *vpt) |
|
{ |
|
INode *node = vpt->GetClosestHit(); |
|
if (node && fParam && fPB) |
|
fParam->SetPickNode(node, fPB); |
|
fParam = nil; |
|
fPB = nil; |
|
|
|
return TRUE; |
|
} |
|
|
|
BOOL PickNodeButtonMode::RightClick(IObjParam *ip, ViewExp *vpt) |
|
{ |
|
if (fParam && fPB) |
|
fParam->SetPickNode(nil, nil); |
|
fParam = nil; |
|
fPB = nil; |
|
|
|
return TRUE; |
|
} |
|
|
|
int plPickButtonParam::GetParamType() |
|
{ |
|
return kTypeSceneObj; |
|
} |
|
int plPickButtonParam::GetCount(IParamBlock2 *pb) |
|
{ |
|
return (pb->GetReferenceTarget(fID) ? 1 : 0); |
|
} |
|
plKey plPickButtonParam::GetKey(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->GetKey(); |
|
|
|
return nil; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plPickComponentButtonParam::plPickComponentButtonParam(ParamID id, const char *name, std::vector<Class_ID>* filter, bool canConvertToType) : |
|
plPickButtonParam(id, name, filter, canConvertToType) |
|
{ |
|
hsAssert(filter, "Need to have a ClassID filter for pick component buttons"); |
|
} |
|
|
|
int plPickComponentButtonParam::GetParamType() |
|
{ |
|
return kTypeComponent; |
|
} |
|
|
|
plComponentBase* plPickComponentButtonParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plPickComponentListParam::plPickComponentListParam(ParamID id, const char *name, std::vector<Class_ID>* filter) : |
|
plPickListParam(id, name, filter) |
|
{ |
|
} |
|
|
|
bool plPickComponentListParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
return plPickListParam::IsMyMessage(msg, wParam, lParam, pb); |
|
} |
|
|
|
int plPickComponentListParam::GetParamType() |
|
{ |
|
return kTypeComponent; |
|
} |
|
|
|
plComponentBase *plPickComponentListParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID, 0, idx); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plPickActivatorButtonParam::plPickActivatorButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickActivatorButtonParam::GetParamType() |
|
{ |
|
return kTypeActivator; |
|
} |
|
plComponentBase* plPickActivatorButtonParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
bool plPickActivatorButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if (plPick::Activator(pb, fID, true)) |
|
{ |
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
|
|
|
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plPickActivatorListParam::plPickActivatorListParam(ParamID id, const char *name) : |
|
plPickListParam(id, name, nil) |
|
{ |
|
} |
|
|
|
bool plPickActivatorListParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhAdd) |
|
{ |
|
plPick::Activator(pb, fID, false); |
|
IUpdateList(pb); |
|
return true; |
|
} |
|
} |
|
|
|
return plPickListParam::IsMyMessage(msg, wParam, lParam, pb); |
|
} |
|
|
|
int plPickActivatorListParam::GetParamType() |
|
{ |
|
return kTypeActivator; |
|
} |
|
|
|
plComponentBase *plPickActivatorListParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID, 0, idx); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include "plPickMaterialMap.h" |
|
#include "../MaxPlasmaMtls/Layers/plPlasmaMAXLayer.h" |
|
#include "../plSurface/plLayerInterface.h" |
|
#include "../plGImage/plDynamicTextMap.h" |
|
|
|
plPickDynamicTextButtonParam::plPickDynamicTextButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickDynamicTextButtonParam::GetParamType() |
|
{ |
|
return kTypeDynamicText; |
|
} |
|
|
|
// temp hack to get the name of the texture map name |
|
const char* plPickDynamicTextButtonParam::GetString(IParamBlock2 *pb) |
|
{ |
|
// get the plKeys based on the texture map that the DynamicText map is on |
|
Texmap* texmap = (Texmap*)pb->GetReferenceTarget(fID); |
|
return texmap->GetName(); |
|
} |
|
|
|
int plPickDynamicTextButtonParam::GetCount(IParamBlock2 *pb) |
|
{ |
|
|
|
// get the plKeys based on the texture map that the DynamicText map is on |
|
Texmap* texmap = (Texmap*)pb->GetReferenceTarget(fID); |
|
// make sure that there was a texmap set |
|
if ( texmap ) |
|
{ |
|
plPlasmaMAXLayer *maxLayer = plPlasmaMAXLayer::GetPlasmaMAXLayer( texmap ); |
|
if( maxLayer != nil ) |
|
{ |
|
// It's one of our Plasma layer types, which means most likely it got converted. |
|
|
|
// Note: if the following count is zero, it was never converted, which most likely means |
|
// no visible geometry in the scene uses this layer. So why do you even care about it? |
|
return maxLayer->GetNumConversionTargets(); |
|
} |
|
} |
|
return 0; |
|
} |
|
|
|
plKey plPickDynamicTextButtonParam::GetKey(IParamBlock2 *pb, int idx) |
|
{ |
|
|
|
// get the plKeys based on the texture map that the DynamicText map is on |
|
Texmap* texmap = (Texmap*)pb->GetReferenceTarget(fID); |
|
// make sure that there was a texmap set |
|
if ( texmap ) |
|
{ |
|
plPlasmaMAXLayer *maxLayer = plPlasmaMAXLayer::GetPlasmaMAXLayer( texmap ); |
|
if( maxLayer != nil ) |
|
{ |
|
// make sure the index is valid |
|
if ( idx >= 0 && idx < maxLayer->GetNumConversionTargets() ) |
|
{ |
|
plLayerInterface *convertedLayer = maxLayer->GetConversionTarget(idx); |
|
if ( convertedLayer ) |
|
{ |
|
plBitmap* bmap = convertedLayer->GetTexture(); |
|
// make sure there was a bitmap and that it is a DynamicTextMap |
|
if ( bmap ) |
|
return bmap->GetKey(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// otherwise we didn't find one, because of one of many reasons |
|
return nil; |
|
} |
|
|
|
int plPickDynamicTextButtonParam::CreateControls(HWND hDlg, IParamBlock2 *pb, int yOffset) |
|
{ |
|
yOffset += IAddStaticText(hDlg, yOffset, fName) + 2; |
|
|
|
// Create the picknode button |
|
HWND button = ICreateControl(hDlg, "CustButton"); |
|
ISizeControl(hDlg, button, 84, 12, yOffset); |
|
|
|
fButton = GetICustButton(button); |
|
|
|
// Setup the button properties |
|
fButton->SetType(CBT_CHECK); |
|
fButton->SetButtonDownNotify(TRUE); |
|
fButton->SetCheckHighlight(TRUE); |
|
fButton->SetHighlightColor(GREEN_WASH); |
|
|
|
Texmap* texmap = (Texmap*)pb->GetReferenceTarget(fID); |
|
if (texmap) |
|
fButton->SetText(texmap->GetName()); |
|
else |
|
fButton->SetText("(none)"); |
|
|
|
// Create the Remove button |
|
fhRemove = ICreateControl(hDlg, "Button"); |
|
yOffset += ISizeControl(hDlg, fhRemove, 17, 12, yOffset, 89); |
|
SetWindowText(fhRemove, "Clear"); |
|
|
|
return yOffset; |
|
} |
|
|
|
bool plPickDynamicTextButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if ( plPickMaterialMap::PickTexmap(pb, fID) ) |
|
{ |
|
Texmap* texmap = (Texmap*)pb->GetReferenceTarget(fID); |
|
if (texmap) |
|
fButton->SetText(texmap->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
|
|
plPickSingleComponentButtonParam::plPickSingleComponentButtonParam(ParamID id, const char *name, int myType, Class_ID myClassToPick ) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
fClassToPick = myClassToPick; |
|
fMyType = myType; |
|
} |
|
|
|
int plPickSingleComponentButtonParam::GetParamType() |
|
{ |
|
return fMyType; |
|
} |
|
|
|
plComponentBase* plPickSingleComponentButtonParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
|
|
bool plPickSingleComponentButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if (plPick::GenericClass(pb, fID, true,fClassToPick)) |
|
{ |
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
|
|
plPickExcludeRegionButtonParam::plPickExcludeRegionButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickExcludeRegionButtonParam::GetParamType() |
|
{ |
|
return kTypeExcludeRegion; |
|
} |
|
|
|
plComponentBase* plPickExcludeRegionButtonParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
|
|
bool plPickExcludeRegionButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if (plPick::ExcludeRegion(pb, fID, true)) |
|
{ |
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
|
|
plPickWaterComponentButtonParam::plPickWaterComponentButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickWaterComponentButtonParam::GetParamType() |
|
{ |
|
return kTypeWaterComponent; |
|
} |
|
|
|
plComponentBase* plPickWaterComponentButtonParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
|
|
bool plPickWaterComponentButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if (plPick::WaterComponent(pb, fID, true)) |
|
{ |
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plPickSwimCurrentInterfaceButtonParam::plPickSwimCurrentInterfaceButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickSwimCurrentInterfaceButtonParam::GetParamType() |
|
{ |
|
return kTypeSwimCurrentInterface; |
|
} |
|
|
|
plComponentBase* plPickSwimCurrentInterfaceButtonParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
|
|
bool plPickSwimCurrentInterfaceButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if (plPick::Swim2DComponent(pb, fID, true)) |
|
{ |
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plPickClusterComponentButtonParam::plPickClusterComponentButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickClusterComponentButtonParam::GetParamType() |
|
{ |
|
return kTypeClusterComponent; |
|
} |
|
|
|
plComponentBase* plPickClusterComponentButtonParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
bool plPickClusterComponentButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if (plPick::ClusterComponent(pb, fID, true)) |
|
{ |
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
return true; |
|
} |
|
} |
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plPickAnimationButtonParam::plPickAnimationButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickAnimationButtonParam::GetParamType() |
|
{ |
|
return kTypeAnimation; |
|
} |
|
|
|
plComponentBase* plPickAnimationButtonParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
|
|
bool plPickAnimationButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if (plPick::Animation(pb, fID, true)) |
|
{ |
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
|
|
plPickBehaviorButtonParam::plPickBehaviorButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickBehaviorButtonParam::GetParamType() |
|
{ |
|
return kTypeBehavior; |
|
} |
|
|
|
plComponentBase* plPickBehaviorButtonParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
|
|
bool plPickBehaviorButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if (plPick::Behavior(pb, fID, true)) |
|
{ |
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plPickMaterialButtonParam::plPickMaterialButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickMaterialButtonParam::GetParamType() |
|
{ |
|
return kTypeMaterial; |
|
} |
|
|
|
// temp hack to get the name of the texture map name |
|
const char* plPickMaterialButtonParam::GetString(IParamBlock2 *pb) |
|
{ |
|
// get the plKeys based on the texture map that the DynamicText map is on |
|
Texmap* texmap = (Texmap*)pb->GetReferenceTarget(fID); |
|
return texmap->GetName(); |
|
} |
|
|
|
int plPickMaterialButtonParam::GetCount(IParamBlock2 *pb) |
|
{ |
|
|
|
// get the plKeys based on the texture map that the Texture map is on |
|
Texmap* texmap = (Texmap*)pb->GetReferenceTarget(fID); |
|
// make sure that there was a texmap set |
|
if ( texmap ) |
|
{ |
|
plPlasmaMAXLayer *maxLayer = plPlasmaMAXLayer::GetPlasmaMAXLayer( texmap ); |
|
if( maxLayer != nil ) |
|
{ |
|
// It's one of our Plasma layer types, which means most likely it got converted. |
|
|
|
// Note: if the following count is zero, it was never converted, which most likely means |
|
// no visible geometry in the scene uses this layer. So why do you even care about it? |
|
return maxLayer->GetNumConversionTargets(); |
|
} |
|
} |
|
return 0; |
|
} |
|
|
|
plKey plPickMaterialButtonParam::GetKey(IParamBlock2 *pb, int idx) |
|
{ |
|
|
|
// get the plKeys based on the texture map that the Texture map is on |
|
Texmap* texmap = (Texmap*)pb->GetReferenceTarget(fID); |
|
// make sure that there was a texmap set |
|
if ( texmap ) |
|
{ |
|
plPlasmaMAXLayer *maxLayer = plPlasmaMAXLayer::GetPlasmaMAXLayer( texmap ); |
|
if( maxLayer != nil ) |
|
{ |
|
// make sure the index is valid |
|
if ( idx >= 0 && idx < maxLayer->GetNumConversionTargets() ) |
|
{ |
|
plLayerInterface *convertedLayer = maxLayer->GetConversionTarget(idx); |
|
if ( convertedLayer ) |
|
{ |
|
plBitmap* bmap = convertedLayer->GetTexture(); |
|
// make sure there was a bitmap |
|
if ( bmap ) |
|
return bmap->GetKey(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// otherwise we didn't find one, because of one of many reasons |
|
return nil; |
|
} |
|
|
|
int plPickMaterialButtonParam::CreateControls(HWND hDlg, IParamBlock2 *pb, int yOffset) |
|
{ |
|
yOffset += IAddStaticText(hDlg, yOffset, fName) + 2; |
|
|
|
// Create the picknode button |
|
HWND button = ICreateControl(hDlg, "CustButton"); |
|
ISizeControl(hDlg, button, 84, 12, yOffset); |
|
|
|
fButton = GetICustButton(button); |
|
|
|
// Setup the button properties |
|
fButton->SetType(CBT_CHECK); |
|
fButton->SetButtonDownNotify(TRUE); |
|
fButton->SetCheckHighlight(TRUE); |
|
fButton->SetHighlightColor(GREEN_WASH); |
|
|
|
Texmap* texmap = (Texmap*)pb->GetReferenceTarget(fID); |
|
if (texmap) |
|
fButton->SetText(texmap->GetName()); |
|
else |
|
fButton->SetText("(none)"); |
|
|
|
// Create the Remove button |
|
fhRemove = ICreateControl(hDlg, "Button"); |
|
yOffset += ISizeControl(hDlg, fhRemove, 17, 12, yOffset, 89); |
|
SetWindowText(fhRemove, "Clear"); |
|
|
|
return yOffset; |
|
} |
|
|
|
bool plPickMaterialButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if ( plPickMaterialMap::PickTexmap(pb, fID) ) |
|
{ |
|
Texmap* texmap = (Texmap*)pb->GetReferenceTarget(fID); |
|
if (texmap) |
|
fButton->SetText(texmap->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plPickMaterialAnimationButtonParam::plPickMaterialAnimationButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickMaterialAnimationButtonParam::GetParamType() |
|
{ |
|
return kTypeMaterialAnimation; |
|
} |
|
|
|
const char* plPickMaterialAnimationButtonParam::GetString(IParamBlock2 *pb) |
|
{ |
|
Mtl* texmap = (Mtl*)pb->GetReferenceTarget(fID); |
|
return texmap->GetName(); |
|
} |
|
|
|
int plPickMaterialAnimationButtonParam::GetCount(IParamBlock2 *pb) |
|
{ |
|
return fKeys.Count(); |
|
} |
|
|
|
plKey plPickMaterialAnimationButtonParam::GetKey(IParamBlock2 *pb, int idx) |
|
{ |
|
int kcount = fKeys.Count(); |
|
|
|
if ( idx >= 0 && idx < kcount ) |
|
{ |
|
return fKeys[idx]; |
|
} |
|
|
|
return nil; |
|
} |
|
|
|
// this is in plResponderMtl.cpp |
|
extern int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const char* segName, hsTArray<plKey>& keys);; |
|
|
|
void plPickMaterialAnimationButtonParam::CreateKeyArray(IParamBlock2* pb) |
|
{ |
|
fKeys.Reset(); |
|
|
|
Mtl* mtl = (Mtl*)pb->GetReferenceTarget(fID); |
|
|
|
int bob = GetMatAnimModKey(mtl, nil, nil, fKeys); |
|
} |
|
|
|
void plPickMaterialAnimationButtonParam::DestroyKeyArray() |
|
{ |
|
fKeys.Reset(); |
|
} |
|
|
|
int plPickMaterialAnimationButtonParam::CreateControls(HWND hDlg, IParamBlock2 *pb, int yOffset) |
|
{ |
|
yOffset += IAddStaticText(hDlg, yOffset, fName) + 2; |
|
|
|
// Create the picknode button |
|
HWND button = ICreateControl(hDlg, "CustButton"); |
|
ISizeControl(hDlg, button, 84, 12, yOffset); |
|
|
|
fButton = GetICustButton(button); |
|
|
|
// Setup the button properties |
|
fButton->SetType(CBT_CHECK); |
|
fButton->SetButtonDownNotify(TRUE); |
|
fButton->SetCheckHighlight(TRUE); |
|
fButton->SetHighlightColor(GREEN_WASH); |
|
|
|
Mtl* texmap = (Mtl*)pb->GetReferenceTarget(fID); |
|
if (texmap) |
|
fButton->SetText(texmap->GetName()); |
|
else |
|
fButton->SetText("(none)"); |
|
|
|
// Create the Remove button |
|
fhRemove = ICreateControl(hDlg, "Button"); |
|
yOffset += ISizeControl(hDlg, fhRemove, 17, 12, yOffset, 89); |
|
SetWindowText(fhRemove, "Clear"); |
|
|
|
return yOffset; |
|
} |
|
|
|
bool plPickMaterialAnimationButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if ( Mtl* mtl = plPickMaterialMap::PickMaterial(0) ) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)mtl); |
|
fButton->SetText(mtl->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plDropDownListParam::plDropDownListParam(ParamID id, const char *name, std::vector<std::string>* options) : |
|
plAutoUIParam(id, name), fhList(nil) |
|
{ |
|
if (options) |
|
fOptions = *options; |
|
} |
|
|
|
int plDropDownListParam::CreateControls(HWND hDlg, IParamBlock2 *pb, int yOffset) |
|
{ |
|
yOffset += IAddStaticText(hDlg, yOffset, fName) + 2; |
|
|
|
// Create the combobox |
|
fhList = ICreateControl(hDlg, "ComboBox", nil, CBS_DROPDOWNLIST | CBS_NOINTEGRALHEIGHT | WS_VSCROLL, WS_EX_CLIENTEDGE); |
|
ISizeControl(hDlg, fhList, 100, 100, yOffset); |
|
yOffset += 13 + 2; |
|
ISetControlFont(fhList); |
|
|
|
return yOffset + 5; |
|
} |
|
|
|
bool plDropDownListParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_INITDIALOG) |
|
{ |
|
IUpdateList(pb); |
|
return false; |
|
} |
|
|
|
if ((HWND)lParam == fhList) |
|
{ |
|
if (HIWORD(wParam) == CBN_SELENDOK) |
|
{ |
|
int idx = ComboBox_GetCurSel(fhList); |
|
|
|
if (idx >=0 && idx < fOptions.size()) |
|
{ |
|
char* buf = TRACKED_NEW char[fOptions[idx].size() + 1]; |
|
strcpy(buf, fOptions[idx].c_str()); |
|
pb->SetValue(fID, 0, buf); |
|
delete [] buf; |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
void plDropDownListParam::IUpdateList(IParamBlock2 *pb) |
|
{ |
|
std::string val = ""; |
|
int selection = -1; |
|
|
|
if (pb) |
|
{ |
|
char* bob = pb->GetStr(fID); |
|
if (bob) |
|
val = bob; |
|
} |
|
|
|
ComboBox_ResetContent(fhList); |
|
|
|
for (int i = 0; i < fOptions.size(); i++) |
|
{ |
|
const char *name = fOptions[i].c_str(); |
|
|
|
ComboBox_AddString(fhList, name); |
|
|
|
if (fOptions[i] == val) |
|
{ |
|
selection = i; |
|
} |
|
} |
|
|
|
if (selection >= 0) |
|
{ |
|
ComboBox_SetCurSel(fhList, selection); |
|
} |
|
} |
|
|
|
int plDropDownListParam::GetParamType() |
|
{ |
|
return kTypeDropDownList; |
|
} |
|
|
|
int plDropDownListParam::GetCount(IParamBlock2 *pb) |
|
{ |
|
return pb->Count(fID); |
|
} |
|
|
|
const char* plDropDownListParam::GetString(IParamBlock2 *pb) |
|
{ |
|
return pb->GetStr(fID); |
|
} |
|
|
|
void plDropDownListParam::Show(int yOffset) |
|
{ |
|
/* |
|
HWND tmp; |
|
|
|
int ctrlOffset = 0; |
|
RECT rect; |
|
|
|
for (int i = 0; i < fControlVec.size(); i++) |
|
{ |
|
tmp = fControlVec[i]; |
|
GetWindowRect(tmp, &rect); |
|
|
|
SetRect(&rect, 3, 0, (rect.right - rect.left) + 3, rect.bottom - rect.top); |
|
//MapDialogRect(fhDlg, &rect); |
|
// Y is already in screen units |
|
rect.top = yOffset + ctrlOffset; |
|
rect.bottom = rect.bottom + rect.top; |
|
|
|
// Resize the window |
|
MoveWindow(tmp, rect.left, rect.top, rect.right - rect.left, (tmp == fhList) ? 100 : rect.bottom - rect.top, TRUE); |
|
//MoveWindow(tmp, rect.left, yOffset + ctrlOffset, (rect.right - rect.left), (rect.bottom - rect.top), FALSE); |
|
ctrlOffset += (rect.bottom - rect.top) + 2; |
|
ShowWindow(tmp, SW_SHOW); |
|
} |
|
*/ |
|
|
|
yOffset += ISizeControl(fhDlg, fControlVec[0], 100, 8, yOffset) + 4; |
|
ISizeControl(fhDlg, fhList, 100, 100, yOffset); |
|
|
|
ShowWindow(fControlVec[0], SW_SHOW); |
|
ShowWindow(fControlVec[1], SW_SHOW); |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plPickGrassComponentButtonParam::plPickGrassComponentButtonParam(ParamID id, const char *name) : |
|
plPickButtonParam(id, name, nil, false) |
|
{ |
|
} |
|
|
|
int plPickGrassComponentButtonParam::GetParamType() |
|
{ |
|
return kTypeGrassComponent; |
|
} |
|
|
|
plComponentBase* plPickGrassComponentButtonParam::GetComponent(IParamBlock2 *pb, int idx) |
|
{ |
|
hsAssert(idx == 0, "Pick buttons only have one key"); |
|
plMaxNode *node = (plMaxNode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
return node->ConvertToComponent(); |
|
|
|
return nil; |
|
} |
|
|
|
|
|
bool plPickGrassComponentButtonParam::IsMyMessage(UINT msg, WPARAM wParam, LPARAM lParam, IParamBlock2 *pb) |
|
{ |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_BUTTONUP) |
|
{ |
|
if ((HWND)lParam == fButton->GetHwnd()) |
|
{ |
|
if (fButton->IsChecked()) |
|
{ |
|
if (plPick::GrassComponent(pb, fID, true)) |
|
{ |
|
INode *node = (INode*)pb->GetReferenceTarget(fID); |
|
if (node) |
|
fButton->SetText(node->GetName()); |
|
} |
|
fButton->SetCheck(FALSE); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
// check if the reset button is hit |
|
if (msg == WM_COMMAND && HIWORD(wParam) == BN_CLICKED) |
|
{ |
|
if ((HWND)lParam == fhRemove) |
|
{ |
|
pb->SetValue(fID, 0, (ReferenceTarget*)nil); |
|
fButton->SetText("(none)"); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
|