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