const TCHAR * ClassName() { return GetString(IDS_AP_PYRAMID_CLASS); }
bool wxComboBox::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
{
wxString value;
int sel = -1;
switch ( param )
{
case CBN_SELENDOK:
case CBN_SELCHANGE:
sel = GetSelection();
// we may sometimes get 2 CBN_SELCHANGE events or a CBN_SELENDOK
// before CBN_SELCHANGE with the same index when the user selects
// an item in the combobox -- ignore duplicates
if ( sel > -1 && sel != m_selectionOld )
{
m_selectionOld = sel;
// GetValue() would still return the old value from here but
// according to the docs we should return the new value if the
// user calls it in his event handler, so update internal
// m_value
m_value = GetString(sel);
wxCommandEvent event(wxEVT_COMMAND_COMBOBOX_SELECTED, GetId());
event.SetInt(sel);
event.SetEventObject(this);
event.SetString(m_value);
ProcessCommand(event);
}
else // no valid selection
{
m_selectionOld = sel;
// hence no EVT_TEXT neither
break;
}
// fall through: for compability with wxGTK, also send the text
// update event when the selection changes (this also seems more
// logical as the text does change)
case CBN_EDITCHANGE:
{
wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
// if sel != -1, value was initialized above (and we can't use
// GetValue() here as it would return the old selection and we
// want the new one)
if ( sel == -1 )
{
m_value = wxGetWindowText(GetHwnd());
m_selectionOld = -1;
}
else // we're synthesizing text updated event from sel change
{
// We need to retrieve the current selection because the
// user may have changed it in the previous handler (for
// CBN_SELCHANGE above).
sel = GetSelection();
if ( sel > -1 )
{
m_value = GetString(sel);
}
}
event.SetString(m_value);
event.SetEventObject(this);
ProcessCommand(event);
}
break;
}
// there is no return value for the CBN_ notifications, so always return
// false from here to pass the message to DefWindowProc()
return false;
}
static void setup_font_select_menu(GtkWidget *widget)
{
gchar * selected = GetString("Terminal","Font","Courier");
load_font_menu(widget, selected);
g_free(selected);
}
const TCHAR * ClassName() { return GetString(IDS_RB_MIRRORMOD); }
void GetClassName(TSTR& s) {s = GetString(IDS_RB_MIRRORMOD);}
const TCHAR * ClassName() { return GetString(IDS_CLASS_NAME); }
//+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+
//| From BaseObject |
//+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+
TCHAR* PFTestGoToNextEvent::GetObjectName()
{
return GetString(IDS_TEST_GOTONEXTEVENT_OBJECT_NAME);
}
ParticlesDataMutable* readPTC(const char* filename,const bool headersOnly)
{
std::auto_ptr<std::istream> input(Gzip_In(filename,std::ios::in|std::ios::binary));
if(!*input){
std::cerr<<"Partio: Unable to open file "<<filename<<std::endl;
return 0;
}
int magic;
read<LITEND>(*input,magic);
if(ptc_magic!=magic){
std::cerr<<"Partio: Magic number '"<<magic<<"' of '"<<filename<<"' doesn't match pptc magic '"<<ptc_magic<<"'"<<std::endl;
return 0;
}
int version;
read<LITEND>(*input,version);
double nPoints;
read<LITEND>(*input,nPoints);
// TODO: allow access to this in the headers only mode for times when only bbox is necessary
float xmin,ymin,zmin,xmax,ymax,zmax;
read<LITEND>(*input,xmin,ymin,zmin,xmax,ymax,zmax);
float dummy;
if (version>=1) for (int d=0;d<4;d++) read<LITEND>(*input,dummy);
// world-to-eye
for(int i=0;i<16;i++) read<LITEND>(*input,dummy);
// eye-to-screen
for(int i=0;i<16;i++) read<LITEND>(*input,dummy);
float imgWidth,imgHeight,imgDepth;
read<LITEND>(*input,imgWidth,imgHeight,imgDepth);
int nVars,dataSize;
read<LITEND>(*input,nVars,dataSize);
// Allocate a simple particle with the appropriate number of points
ParticlesDataMutable* simple=0;
if(headersOnly) simple=new ParticleHeaders;
else simple=create();
simple->addParticles((int)nPoints);
// PTC files always have something for these items, so allocate the data
std::vector<ParticleAttribute> attrHandles;
ParticleAttribute positionHandle=simple->addAttribute("position",VECTOR,3);
ParticleAttribute normalHandle=simple->addAttribute("normal",VECTOR,3);
ParticleAttribute radiusHandle=simple->addAttribute("radius",FLOAT,1);
std::string typeName,name;
// data types are "float", "point", "vector", "normal", "color", or "matrix"
int parsedSize=0;
for(int chanNum=0;chanNum<nVars;chanNum++){
ParseSpec(GetString(*input,'\n'),typeName,name);
int dataSize=0;
ParticleAttributeType dataType;
if(typeName=="color" || typeName=="vector" || typeName=="point" || typeName=="color"){
dataType=VECTOR;
dataSize=3;
}else if(typeName=="matrix"){
dataType=FLOAT;
dataSize=16;
}else if(typeName=="float"){
dataType=FLOAT;
dataSize=1;
}else{
std::cerr<<"Partio: "<<filename<<" had unknown attribute spec "<<typeName<<" "<<name<<std::endl;
simple->release();
return 0;
}
attrHandles.push_back(simple->addAttribute(name.c_str(),dataType,dataSize));
parsedSize+=dataSize;
}
if(dataSize!=parsedSize){
std::cerr<<"Partio: error with PTC, computed dataSize ("<<dataSize
<<") different from read one ("<<parsedSize<<")"<<std::endl;
simple->release();
return 0;
}
// If all we care about is headers, then return.
if(headersOnly){
return simple;
}
// more weird input attributes
if(version>=1) for(int i=0;i<2;i++) read<LITEND>(*input,dummy);
for(int pointIndex=0;pointIndex<nPoints;pointIndex++){
float* pos=simple->dataWrite<float>(positionHandle,pointIndex);
read<LITEND>(*input,pos[0],pos[1],pos[2]);
unsigned short phi,z; // normal encoded
read<LITEND>(*input,phi,z);
float* norm=simple->dataWrite<float>(normalHandle,pointIndex);
// Convert unsigned short (phi,nz) to xyz normal
// This packing code is based on Per Christensen's rman forum post
if (phi != 65535 || z != 65535) {
float nz = (float)z / 65535.0f;
norm[2] = 2.0f * nz - 1.0f;
float fphi = (float)phi / 65535.0f;
fphi = 2.0 * M_PI * (fphi - 0.5);
//assert(-M_PI-0.0001 <= fphi && fphi <= M_PI+0.0001);
double rxy = sqrt(1.0 - norm[2]*norm[2]);
norm[0] = rxy * sin(fphi);
norm[1] = rxy * cos(fphi);
} else {
norm[0] = norm[1] = norm[2] = 0.0f;
}
float* radius=simple->dataWrite<float>(radiusHandle,pointIndex);
read<LITEND>(*input,radius[0]);
for(unsigned int i=0;i<attrHandles.size();i++){
float* data=simple->dataWrite<float>(attrHandles[i],pointIndex);
for(int j=0;j<attrHandles[i].count;j++)
read<LITEND>(*input,data[j]);
}
}
return simple;
}
const TCHAR * ClassName() { return GetString(IDS_RB_TWIST_CLASS); }
std::string ConfigFile::GetStringDefault(const char * block, const char* name, const char* def)
{
string ret;
return GetString(block, name, &ret) ? ret : def;
}
_bstr_t ExcelSchemaSoftDiscoverStrategy::GetSheetName(ChUINT4 sheetIndex)
{
if((sheetIndex < 0) || (sheetIndex >= GetSheetCount()))
return _T("");
return GetString(m_pSheetNames->at(sheetIndex));
}
Object*
BuildNURBSPyramid(float width, float depth, float height, int genUVs)
{
int pyramid_faces[5][4] = { {0, 1, 2, 3}, // bottom
{2, 3, 4, 4}, // back
{1, 0, 4, 4}, // front
{3, 1, 4, 4}, // left
{0, 2, 4, 4}};// right
Point3 pyramid_verts[5] = { Point3(-0.5, -0.5, 0.0),
Point3( 0.5, -0.5, 0.0),
Point3(-0.5, 0.5, 0.0),
Point3( 0.5, 0.5, 0.0),
Point3( 0.0, 0.0, 1.0)};
NURBSSet nset;
for (int face = 0; face < 5; face++) {
Point3 bl = pyramid_verts[pyramid_faces[face][0]];
Point3 br = pyramid_verts[pyramid_faces[face][1]];
Point3 tl = pyramid_verts[pyramid_faces[face][2]];
Point3 tr = pyramid_verts[pyramid_faces[face][3]];
Matrix3 size;
size.IdentityMatrix();
Point3 lwh(width, depth, height);
size.Scale(lwh);
bl = bl * size;
br = br * size;
tl = tl * size;
tr = tr * size;
NURBSCVSurface *surf = new NURBSCVSurface();
nset.AppendObject(surf);
surf->SetUOrder(4);
surf->SetVOrder(4);
surf->SetNumCVs(4, 4);
surf->SetNumUKnots(8);
surf->SetNumVKnots(8);
Point3 top, bot;
for (int r = 0; r < 4; r++) {
top = tl + (((float)r/3.0f) * (tr - tl));
bot = bl + (((float)r/3.0f) * (br - bl));
for (int c = 0; c < 4; c++) {
NURBSControlVertex ncv;
ncv.SetPosition(0, bot + (((float)c/3.0f) * (top - bot)));
ncv.SetWeight(0, 1.0f);
surf->SetCV(r, c, ncv);
}
}
for (int k = 0; k < 4; k++) {
surf->SetUKnot(k, 0.0);
surf->SetVKnot(k, 0.0);
surf->SetUKnot(k + 4, 1.0);
surf->SetVKnot(k + 4, 1.0);
}
surf->Renderable(TRUE);
surf->SetGenerateUVs(genUVs);
if (height > 0.0f)
surf->FlipNormals(TRUE);
else
surf->FlipNormals(FALSE);
switch(face) {
case 0: // bottom
surf->SetTextureUVs(0, 0, Point2(1.0f, 0.0f));
surf->SetTextureUVs(0, 1, Point2(0.0f, 0.0f));
surf->SetTextureUVs(0, 2, Point2(1.0f, 1.0f));
surf->SetTextureUVs(0, 3, Point2(0.0f, 1.0f));
break;
default: // sides
surf->SetTextureUVs(0, 0, Point2(0.5f, 1.0f));
surf->SetTextureUVs(0, 1, Point2(0.5f, 1.0f));
surf->SetTextureUVs(0, 2, Point2(0.0f, 0.0f));
surf->SetTextureUVs(0, 3, Point2(1.0f, 0.0f));
break;
}
TCHAR bname[80];
_stprintf(bname, _T("%s%02d"), GetString(IDS_CT_SURF), face);
surf->SetName(bname);
}
#define F(s1, s2, s1r, s1c, s2r, s2c) \
fuse.mSurf1 = (s1); \
fuse.mSurf2 = (s2); \
fuse.mRow1 = (s1r); \
fuse.mCol1 = (s1c); \
fuse.mRow2 = (s2r); \
fuse.mCol2 = (s2c); \
nset.mSurfFuse.Append(1, &fuse);
NURBSFuseSurfaceCV fuse;
// Fuse the degenerate peaks
for (int i = 1; i < 5; i++) {
for (int j = 1; j < 4; j++) {
F(i, i, 0, 3, j, 3);
}
}
// Fuse the peaks together
F(1, 2, 0, 3, 0, 3);
F(1, 3, 0, 3, 0, 3);
F(1, 4, 0, 3, 0, 3);
// Bottom(0) to Back (1)
F(0, 1, 3, 3, 3, 0);
F(0, 1, 2, 3, 2, 0);
F(0, 1, 1, 3, 1, 0);
F(0, 1, 0, 3, 0, 0);
// Bottom(0) to Front (2)
F(0, 2, 0, 0, 3, 0);
F(0, 2, 1, 0, 2, 0);
F(0, 2, 2, 0, 1, 0);
F(0, 2, 3, 0, 0, 0);
// Bottom(0) to Left (3)
F(0, 3, 3, 0, 3, 0);
F(0, 3, 3, 1, 2, 0);
F(0, 3, 3, 2, 1, 0);
F(0, 3, 3, 3, 0, 0);
// Bottom(0) to Right (4)
F(0, 4, 0, 0, 0, 0);
F(0, 4, 0, 1, 1, 0);
F(0, 4, 0, 2, 2, 0);
F(0, 4, 0, 3, 3, 0);
// Front (2) to Right (4)
F(2, 4, 3, 1, 0, 1);
F(2, 4, 3, 2, 0, 2);
// Right (4) to Back (1)
F(4, 1, 3, 1, 0, 1);
F(4, 1, 3, 2, 0, 2);
// Back (1) to Left (3)
F(1, 3, 3, 1, 0, 1);
F(1, 3, 3, 2, 0, 2);
// Left (3) to Front (2)
F(3, 2, 3, 1, 0, 1);
F(3, 2, 3, 2, 0, 2);
Matrix3 mat;
mat.IdentityMatrix();
Object *obj = CreateNURBSObject(NULL, &nset, mat);
return obj;
}
const TCHAR *GetObjectName() { return GetString(IDS_RB_PYRAMID); }
const TCHAR* Category() { return GetString(IDS_AP_PRIMITIVES); }
// Edger Delete modifier method
void EditPatchMod::DoEdgeDelete()
{
ModContextList mcList;
INodeTab nodes;
TimeValue t = ip->GetTime();
int holdNeeded = 0;
if (!ip)
return;
ip->GetModContexts(mcList, nodes);
ClearPatchDataFlag(mcList, EPD_BEENDONE);
theHold.Begin();
RecordTopologyTags();
for (int i = 0; i < mcList.Count(); i++)
{
int altered = 0;
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
if (!patchData)
continue;
if (patchData->GetFlag(EPD_BEENDONE))
continue;
// If the mesh isn't yet cache, this will cause it to get cached.
RPatchMesh *rpatch;
PatchMesh *patch = patchData->TempData(this)->GetPatch(t, rpatch);
if (!patch)
continue;
patchData->RecordTopologyTags(patch);
// If this is the first edit, then the delta arrays will be allocated
patchData->BeginEdit(t);
// If any bits are set in the selection set, let's DO IT!!
if (patch->edgeSel.NumberSet())
{
altered = holdNeeded = 1;
if (theHold.Holding())
theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "DoEdgeDelete"));
int edges = patch->getNumEdges();
int patches = patch->getNumPatches();
int verts = patch->getNumVerts();
// Tag the patches that are attached to selected edges
BitArray delPatches(patches);
delPatches.ClearAll();
for (int i = 0; i < edges; ++i)
{
if (patch->edgeSel[i])
{
#if (MAX_RELEASE < 4000)
if (patch->edges[i].patch1 >= 0)
delPatches.Set(patch->edges[i].patch1);
if (patch->edges[i].patch2 >= 0)
delPatches.Set(patch->edges[i].patch2);
#else // (MAX_RELEASE < 4000)
if (patch->edges[i].patches[0] >= 0)
delPatches.Set(patch->edges[i].patches[0]);
if (patch->edges[i].patches[1] >= 0)
delPatches.Set(patch->edges[i].patches[1]);
#endif // (MAX_RELEASE < 4000)
}
}
BitArray delVerts(verts);
delVerts.ClearAll();
DeletePatchParts(patch, rpatch, delVerts, delPatches);
patch->computeInteriors();
patchData->UpdateChanges(patch, rpatch);
patchData->TempData(this)->Invalidate(PART_TOPO);
}
patchData->SetFlag(EPD_BEENDONE, TRUE);
}
if (holdNeeded)
{
ResolveTopoChanges();
theHold.Accept(GetString(IDS_TH_EDGEDELETE));
}
else
{
ip->DisplayTempPrompt(GetString(IDS_TH_NOEDGESSEL), PROMPT_TIME);
theHold.End();
}
nodes.DisposeTemporary();
ClearPatchDataFlag(mcList, EPD_BEENDONE);
NotifyDependents(FOREVER, PART_TOPO, REFMSG_CHANGE);
ip->RedrawViews(ip->GetTime(), REDRAW_NORMAL);
}
void GetClassName(TSTR& s) { s= GetString(IDS_RB_TWISTMOD); }
void EditPatchMod::DoPatchDelete()
{
ModContextList mcList;
INodeTab nodes;
TimeValue t = ip->GetTime();
int holdNeeded = 0;
if (!ip)
return;
ip->GetModContexts(mcList, nodes);
ClearPatchDataFlag(mcList, EPD_BEENDONE);
theHold.Begin();
RecordTopologyTags();
for (int i = 0; i < mcList.Count(); i++)
{
int altered = 0;
EditPatchData *patchData =(EditPatchData*)mcList[i]->localData;
if (!patchData)
continue;
if (patchData->GetFlag(EPD_BEENDONE))
continue;
// If the mesh isn't yet cache, this will cause it to get cached.
RPatchMesh *rpatch;
PatchMesh *patch = patchData->TempData(this)->GetPatch(t, rpatch);
if (!patch)
continue;
patchData->RecordTopologyTags(patch);
// If this is the first edit, then the delta arrays will be allocated
patchData->BeginEdit(t);
// If any bits are set in the selection set, let's DO IT!!
if (patch->patchSel.NumberSet())
{
altered = holdNeeded = 1;
if (theHold.Holding())
theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "DoPatchDelete"));
// Call the patch delete function
DeleteSelPatches(patch, rpatch);
patchData->UpdateChanges(patch, rpatch);
patchData->TempData(this)->Invalidate(PART_TOPO);
}
patchData->SetFlag(EPD_BEENDONE, TRUE);
}
if (holdNeeded)
{
ResolveTopoChanges();
theHold.Accept(GetString(IDS_TH_PATCHDELETE));
}
else
{
ip->DisplayTempPrompt(GetString(IDS_TH_NOPATCHESSEL), PROMPT_TIME);
theHold.End();
}
nodes.DisposeTemporary();
ClearPatchDataFlag(mcList, EPD_BEENDONE);
NotifyDependents(FOREVER, PART_TOPO, REFMSG_CHANGE);
ip->RedrawViews(ip->GetTime(), REDRAW_NORMAL);
}
const TCHAR *GetObjectName() {return GetString(IDS_RB_TWIST);}
const TCHAR* Category() { return GetString(IDS_CATEGORY); }
__declspec( dllexport ) const TCHAR *
LibDescription() { return GetString(IDS_LIBDESC); }
//+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+
//| From Animatable |
//+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+
void PFTestGoToNextEvent::GetClassName(TSTR& s)
{
s = GetString(IDS_TEST_GOTONEXTEVENT_CLASS_NAME);
}
// program to encrypt user string by keyword entered in command line
int main(int argc, string argv[])
{
// declare variables
int shift;
int KeyValue;
// only accept two command line arguments
if (argc != 2)
{
printf("You screwed up!!!\n");
return 1;
}
// capture the second command line argument as a string
string key = argv[1];
// iterate through the key to make sure it's alphabetical
for (int n = 0, keylength = strlen(argv[1]); n < keylength; n++)
{
if ((key[n] >= '0') && (key[n] <= '9'))
{
printf("Sorry!\n");
return 1;
}
}
// get the plain text
string PlainText = GetString();
// iterating through plaintext
for(int i = 0, j = 0, length = strlen(PlainText); i < length; i++, j++)
{
// start the key again if key shorter than PlainText
if (j >= strlen(key))
{
j = 0;
}
// declared a variable of a different name
KeyValue = key[j];
// skip key[j] if PlainText[i] is not an alpha character
if (!isalpha(PlainText[i]))
{
j = (j - 1);
}
// makes Aa = 0, Zz = 25 for the uppercase letters
if ((KeyValue >= 'A') && (KeyValue <= 'Z'))
{
KeyValue = (KeyValue - 'A');
}
// makes Aa = 0, Zz = 25 for the lowercase letters
if ((KeyValue >= 'a') && (KeyValue <= 'z'))
{
KeyValue = (KeyValue - 'a');
}
// encryption
shift = (PlainText[i] + KeyValue);
// wrapping after Z for uppercase letters
if (isupper(PlainText[i]) && (shift > 'Z'))
{
shift = (shift - 26);
}
// wrapping after z for lowercase letters
if (islower(PlainText[i]) && (shift > 'z'))
{
shift = (shift - 26);
}
// if character is alphabetical, print encrypted result
if (isalpha(PlainText[i]))
{
printf("%c", shift);
}
// if non-alphabetical character, print as is
else
{
printf("%c", PlainText[i]);
}
}
printf("\n");
return 0;
}
const TCHAR* Category() { return GetString(IDS_RB_DEFDEFORMATIONS);}
void PFOperatorMaterialFrequency::GetClassName(TSTR& s)
{
s = GetString(IDS_OPERATOR_MATERIALFREQUENCY_CLASS_NAME);
}
TCHAR *GetObjectName() {return GetString(IDS_RB_MIRRORMOD);}
RefResult PFOperatorMaterialFrequency::NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget,
PartID& partID, RefMessage message)
{
IParamMap2* map;
TSTR dynamicNameSuffix;
if ( hTarget == pblock() ) {
int lastUpdateID;
switch (message)
{
case REFMSG_CHANGE:
lastUpdateID = pblock()->LastNotifyParamID();
if (lastUpdateID == kMaterialFrequency_material) {
if (updateFromMXSMtl()) {
NotifyDependents(FOREVER, PART_MTL, kPFMSG_UpdateMaterial, NOTIFY_ALL, TRUE);
NotifyDependents(FOREVER, 0, kPFMSG_DynamicNameChange, NOTIFY_ALL, TRUE);
}
UpdatePViewUI(lastUpdateID);
return REF_STOP;
}
if (!(theHold.Holding() || theHold.RestoreOrRedoing())) return REF_STOP;
switch ( lastUpdateID )
{
case kMaterialFrequency_assignMaterial:
RefreshUI(kMaterialFrequency_message_assignMaterial);
NotifyDependents(FOREVER, PART_MTL, kPFMSG_UpdateMaterial, NOTIFY_ALL, TRUE);
break;
case kMaterialFrequency_assignID:
RefreshUI(kMaterialFrequency_message_assignID);
break;
}
UpdatePViewUI(lastUpdateID);
break;
case REFMSG_NODE_WSCACHE_UPDATED:
updateFromRealMtl();
break;
// Initialization of Dialog
case kMaterialFrequency_RefMsg_InitDlg:
// Set ICustButton properties for MaterialFrequency DAD button
map = (IParamMap2*)partID;
if (map != NULL) {
HWND hWnd = map->GetHWnd();
if (hWnd) {
ICustButton *iBut = GetICustButton(GetDlgItem(hWnd, IDC_MATERIAL));
iBut->SetDADMgr(_dadMgr());
ReleaseICustButton(iBut);
}
}
// Refresh UI
RefreshUI(kMaterialFrequency_message_assignMaterial);
RefreshUI(kMaterialFrequency_message_numSubMtls);
RefreshUI(kMaterialFrequency_message_assignID);
return REF_STOP;
// New Random Seed
case kMaterialFrequency_RefMsg_NewRand:
theHold.Begin();
NewRand();
theHold.Accept(GetString(IDS_NEWRANDOMSEED));
return REF_STOP;
}
}
if ( hTarget == const_cast <Mtl*> (material()) ) {
switch (message)
{
case REFMSG_CHANGE:
{
if (pblock() != NULL) {
Mtl* curMtl = pblock()->GetMtl(kMaterialFrequency_material);
int curNumSubs = (curMtl != NULL) ? curMtl->NumSubMtls() : 0;
if (curNumSubs != lastNumSubs()) {
_lastNumSubs() = curNumSubs;
RefreshUI(kMaterialFrequency_message_numSubMtls);
}
}
}
return REF_STOP;
// if (ignoreRefMsgNotify()) return REF_STOP;
// if (!(theHold.Holding() || theHold.RestoreOrRedoing())) return REF_STOP;
break;
case REFMSG_NODE_NAMECHANGE:
if (HasDynamicName(dynamicNameSuffix)) {
if (lastDynamicName() != dynamicNameSuffix) {
_lastDynamicName() = dynamicNameSuffix;
NotifyDependents(FOREVER, 0, kPFMSG_DynamicNameChange, NOTIFY_ALL, TRUE);
UpdatePViewUI(kMaterialFrequency_material);
}
}
return REF_STOP;
case REFMSG_TARGET_DELETED:
_material() = NULL;
if (pblock() != NULL)
pblock()->SetValue(kMaterialFrequency_material, 0, NULL);
if (theHold.Holding()) {
if (HasDynamicName(dynamicNameSuffix)) {
if (lastDynamicName() != dynamicNameSuffix) {
_lastDynamicName() = dynamicNameSuffix;
NotifyDependents(FOREVER, 0, kPFMSG_DynamicNameChange, NOTIFY_ALL, TRUE);
UpdatePViewUI(kMaterialFrequency_material);
}
}
}
break;
}
}
return REF_SUCCEED;
}
int CreateTopWindow(void)
{
#ifdef MOUSE_POINTER_CHANGE
#ifdef WIN32
static const gchar *cr[CURSOR_MODE_3270] = { "arrow",
"wait",
"arrow",
"sizenwse", // Top-left
"sizenesw", // Top-right
"sizens", // Top
"sizenesw", // Bottom-left
"sizenwse", // Bottom-right
"sizens", // Bottom
"sizewe", // Left
"sizewe", // Right
"sizeall" // Inside
};
#else
static int cr[CURSOR_MODE_3270] = { GDK_XTERM,
GDK_WATCH,
GDK_X_CURSOR,
GDK_TOP_LEFT_CORNER, // Top-left
GDK_TOP_RIGHT_CORNER, // Top-right
GDK_TOP_SIDE, // Top
GDK_BOTTOM_LEFT_CORNER, // Bottom-left
GDK_BOTTOM_RIGHT_CORNER, // Bottom-right
GDK_BOTTOM_SIDE, // Bottom
GDK_LEFT_SIDE, // Left
GDK_RIGHT_SIDE, // Right
GDK_FLEUR // Inside
};
#endif // WIN32
int f;
#endif // MOUSE_POINTER_CHANGE
static const struct ui_menu_setup_table widget_setup[] =
{
{ "fontselect", setup_font_select_menu },
{ "inputmethod", setup_input_methods_menu },
{ "screensizes", setup_screen_size_menu },
{ NULL, NULL }
};
gchar *ptr;
init_actions();
#ifdef MOUSE_POINTER_CHANGE
// Load mouse pointers
#ifdef WIN32
for(f=0;f<CURSOR_MODE_3270;f++)
wCursor[f] = gdk_cursor_new_from_name(gdk_display_get_default(), cr[f]);
#else
for(f=0;f<CURSOR_MODE_3270;f++)
wCursor[f] = gdk_cursor_new(cr[f]);
#endif
#endif // MOUSE_POINTER_CHANGE
if(!CreateTerminalWindow())
return -1;
// Load UI - Create toplevel window
ptr = g_build_filename(program_data,"ui",NULL);
topwindow = create_window_from_ui_files(ptr,terminal,widget_setup);
g_free(ptr);
// Load program logo
load_icon();
/*
if(program_logo && g_file_test(program_logo,G_FILE_TEST_IS_REGULAR))
{
pix = gdk_pixbuf_new_from_file(program_logo,NULL);
}
else
{
gchar *filename = g_build_filename(program_data,PROGRAM_LOGO,NULL);
if(g_file_test(filename,G_FILE_TEST_IS_REGULAR))
pix = gdk_pixbuf_new_from_file(filename, NULL);
Trace("pixbuf(%s): %p",filename,pix);
g_free(filename);
}
if(pix)
{
gtk_window_set_icon(GTK_WINDOW(topwindow),pix);
g_object_set_data_full(G_OBJECT(topwindow),"logo",pix,g_object_unref);
#if defined( HAVE_IGEMAC )
gtk_osxapplication_set_dock_icon_pixbuf(osxapp,pix);
#endif
}
*/
gtk_action_set_sensitive(action_by_id[ACTION_RESELECT],FALSE);
g_signal_connect(G_OBJECT(topwindow),"destroy",G_CALLBACK(action_quit),0);
// gtk_window_set_icon_list(GTK_WINDOW(topwindow),main_icon);
gtk_window_set_default_size(GTK_WINDOW(topwindow),590,430);
ptr = GetString("TopWindow","Title","");
settitle(ptr);
g_free(ptr);
action_restore(0);
gtk_window_set_position(GTK_WINDOW(topwindow),GTK_WIN_POS_CENTER);
return 0;
}
TCHAR* PFOperatorMaterialFrequency::GetObjectName()
{
return GetString(IDS_OPERATOR_MATERIALFREQUENCY_OBJECT_NAME);
}
/*
* MenuCommand: A menu item has been selected.
*/
void MenuCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
// Set last action time to now, to prevent keypress from being interpreted as a game action.
KeySetLastNorepeatTime();
// See if module wants to handle menu selection
if (ModuleEvent(EVENT_MENUITEM, id) == False)
return;
/* Handle menu selections */
switch (id)
{
case ID_GAME_EXIT:
if (connection != CON_NONE && !AreYouSure(hInst, hMain, NO_BUTTON, IDS_LOGOFF))
break;
MainQuit(hwnd);
break;
case ID_GAME_PRINTMAP:
if (state == STATE_GAME)
PrintMap(FALSE);
break;
case ID_GAME_CONNECT:
OfflineConnect();
break;
case ID_GAME_DISCONNECT:
if (!AreYouSure(hInst, hMain, NO_BUTTON, IDS_LOGOFF))
break;
Logoff();
MainSetState(STATE_OFFLINE);
break;
case ID_GAME_SETTINGS:
if (DialogBox(hInst, MAKEINTRESOURCE(IDD_SETTINGS), hMain, PreferencesDialogProc) == IDOK)
{
ModuleEvent(EVENT_CONFIGCHANGED);
MenuDisplaySettings(hMain);
}
break;
case ID_CONFIGMENU:
ConfigMenuLaunch();
break;
case ID_GAME_PASSWORD:
PerformAction(A_CHANGEPASSWORD, NULL);
break;
case ID_OPTIONS_TIMEOUT:
UserSetTimeout();
break;
case ID_OPTIONS_MUSIC:
config.play_music = !config.play_music;
CheckMenuItem(menu, ID_OPTIONS_MUSIC, config.play_music ? MF_CHECKED : MF_UNCHECKED);
UserToggleMusic(config.play_music);
break;
case ID_OPTIONS_SOUND:
config.play_sound = !config.play_sound;
CheckMenuItem(menu, ID_OPTIONS_SOUND, config.play_sound ? MF_CHECKED : MF_UNCHECKED);
if (!config.play_sound)
SoundStopAll();
break;
case ID_OPTIONS_SAVENOW:
SaveSettings();
break;
case ID_OPTIONS_SAVEEXIT:
config.save_settings = !config.save_settings;
CheckMenuItem(menu, ID_OPTIONS_SAVEEXIT, config.save_settings ? MF_CHECKED : MF_UNCHECKED);
break;
case ID_OPTIONS_AREA:
// due to issues with certain D3D drivers, this no longer immediately updates the config
// it now sets a temporary variable that will update the config on shutdown
// this means a shutdown and restart are necessary for window size changes
MessageBox(hMain, "You must shutdown and restart Meridian 59 for these changes to take effect",
"Direct3D", MB_OK);
// config.large_area = !config.large_area;
gLargeArea = !gLargeArea;
CheckMenuItem(menu, ID_OPTIONS_AREA, gLargeArea ? MF_CHECKED : MF_UNCHECKED);
/* if (state == STATE_GAME)
// Send ourselves a resize message
ResizeAll();
RedrawAll();*/
break;
case ID_OPTIONS_FONT_MAP_TITLE: UserSelectFont(FONT_MAP_TITLE); break;
case ID_OPTIONS_FONT_MAP_LABEL: UserSelectFont(FONT_MAP_LABEL); break;
case ID_OPTIONS_FONT_MAP_TEXT: UserSelectFont(FONT_MAP_TEXT); break;
case ID_FONT_GAMETEXT:
UserSelectFont(FONT_EDIT);
break;
case ID_FONT_LIST:
UserSelectFont(FONT_LIST);
break;
case ID_FONT_MAIL:
UserSelectFont(FONT_MAIL);
break;
case ID_FONT_TITLES:
UserSelectFont(FONT_TITLES);
break;
case ID_FONT_STATISTICS:
UserSelectFont(FONT_STATS);
break;
case ID_FONT_INPUT:
UserSelectFont(FONT_INPUT);
break;
case ID_FONT_LABELS:
UserSelectFont(FONT_LABELS);
break;
case ID_FONT_DEFAULTS:
FontsRestoreDefaults();
break;
case ID_COLOR_MAIN:
UserSelectColors(COLOR_FGD, COLOR_BGD);
break;
case ID_COLOR_LIST:
UserSelectColors(COLOR_LISTFGD, COLOR_LISTBGD);
break;
case ID_COLOR_LISTSEL:
UserSelectColors(COLOR_LISTSELFGD, COLOR_LISTSELBGD);
break;
case ID_COLOR_MAGIC:
UserSelectColor(COLOR_ITEM_MAGIC_FG);
break;
case ID_COLOR_HIGHLIGHT:
UserSelectColor(COLOR_HIGHLITE);
break;
case ID_COLOR_MAIL:
UserSelectColors(COLOR_MAILFGD, COLOR_MAILBGD);
break;
case ID_COLOR_TEXT:
UserSelectColors(COLOR_MAINEDITFGD, COLOR_MAINEDITBGD);
break;
case ID_COLOR_EDIT:
UserSelectColors(COLOR_EDITFGD, COLOR_EDITBGD);
break;
case ID_COLOR_SYSMSG:
UserSelectColor(COLOR_SYSMSGFGD);
case ID_COLOR_QUESTHEADER:
UserSelectColor(COLOR_QUEST_HEADER);
break;
break;
case ID_COLOR_STATS:
UserSelectColors(COLOR_STATSFGD, COLOR_STATSBGD);
break;
case ID_COLOR_BAR1:
UserSelectColor(COLOR_BAR1);
break;
case ID_COLOR_BAR2:
UserSelectColor(COLOR_BAR2);
break;
case ID_COLOR_BAR3:
UserSelectColor(COLOR_BAR3);
break;
case ID_COLOR_BAR4:
UserSelectColor(COLOR_BAR4);
break;
case ID_COLOR_INVNUM:
UserSelectColors(COLOR_INVNUMFGD, COLOR_INVNUMBGD);
break;
case ID_COLOR_DEFAULTS:
ColorsRestoreDefaults();
break;
case ID_HELP_CONTENTS:
StartHelp();
break;
case ID_HOMEPAGE:
WebLaunchBrowser(GetString(hInst, IDS_HOMEPAGEURL));
break;
case ID_FORUM:
WebLaunchBrowser(GetString(hInst, IDS_FORUMURL));
break;
case ID_WIKI:
WebLaunchBrowser(GetString(hInst, IDS_WIKIURL));
break;
case ID_HELP_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUT), hMain, AboutDialogProc);
break;
}
}
void MapSignalsDlg::SetUpUi()
{
std::list<IFrame*> lstFrames;
std::map<ISignal*, ISignal*> mapSignals;
std::string strSignal;
SignalProps ouSigProps;
QVariant qVariant;
UID_ELEMENT uidSignal;
ui.tableSignals->setRowCount(0);
std::map<UID_ELEMENT, UID_ELEMENT> mapTempSignals;
if(nullptr != m_pouEcu)
{
((IEcu*)m_pouEcu)->GetSignalList(eTx, mapSignals);
int nRowCount = 0;
//for(auto itrFrame : lstFrames)
{
//itrFrame->GetSignalList(mapSignals);
ui.tableSignals->setRowCount(mapSignals.size());
QList<QVariant> ouColumns;
for(auto itrSignal : mapSignals)
{
uidSignal = itrSignal.first->GetUniqueId();
if(mapTempSignals.find(uidSignal) == mapTempSignals.end())
{
strSignal = "";
itrSignal.first->GetName(strSignal);
itrSignal.first->GetProperties(ouSigProps);
QIntValidator* pSigStartBitValidator = new QIntValidator();
pSigStartBitValidator->setRange(0, 63);
QLineEdit* pRawEdit = new QLineEdit(nullptr);
pRawEdit->setValidator(pSigStartBitValidator);
pRawEdit->setFrame(false);
ouColumns.push_back(QVariant(strSignal.c_str()));
ouColumns.push_back(QVariant());
ouColumns.push_back(QVariant(GetString(ouSigProps.m_ouLINSignalProps.m_nLength, 10)));
qVariant.setValue(itrSignal.first->GetUniqueId());
ui.tableSignals->InsertRow(nRowCount, ouColumns);
ui.tableSignals->item(nRowCount, defCOL_SIGNAL_NAME)->setData(Qt::UserRole, qVariant);
ui.tableSignals->item(nRowCount, defCOL_SIGNAL_NAME)->setCheckState(Qt::Unchecked);
auto itrMap = m_mapSignalUIDSigInst.find(itrSignal.first->GetUniqueId());
if( itrMap != m_mapSignalUIDSigInst.end())
{
ui.tableSignals->item(nRowCount, defCOL_SIGNAL_NAME)->setCheckState(Qt::Checked);
pRawEdit->setText(GetString(itrMap->second.m_nStartBit, 10));
}
ui.tableSignals->setCellWidget(nRowCount++, defCOL_START_BIT, pRawEdit);
ouColumns.clear();
mapTempSignals[uidSignal] = uidSignal;
}
}
}
}
}
