/*********************************************************************\ Function name : CCustomSubDialog::InitValues Description : Created at : 27.03.02, @ 12:07:33 Created by : Thomas Kunert Modified by : \*********************************************************************/ Bool CCustomSubDialog::InitValues(void) { Int32 lID = FIRST_CUSTOM_ELEMENT_ID; Int32 i; CCustomElements* pElement = g_pCustomElements->GetItem(m_pElement->m_lElement); if (!pElement) return true; if (!m_pElement->m_pbcGUI) return true; BaseContainer* pBC = &m_pElement->m_pbcGUI[m_pElement->m_lElement]; SetBool(IDC_CUSTOM_OPEN_CLOSE, pElement->m_bIsOpen); for (i = 0; m_pProp && m_pProp[i].type != CUSTOMTYPE_END; i++, lID++) { CustomProperty* pProp = &pElement->m_pProp[i]; if (pProp->type == CUSTOMTYPE_FLAG) SetBool(lID, pBC, pProp->id); else if (pProp->type == CUSTOMTYPE_LONG) SetInt32(lID, pBC, pProp->id); else if (pProp->type == CUSTOMTYPE_REAL) SetFloat(lID, pBC, pProp->id); else if (pProp->type == CUSTOMTYPE_STRING) SetString(lID, pBC, pProp->id); else if (pProp->type == CUSTOMTYPE_VECTOR) { Vector v = pBC->GetVector(pProp->id); SetFloat(lID++,v.x); SetFloat(lID++,v.y); SetFloat(lID,v.z); } } return true; }
///////////////////////////////////////////////////////// // Resets a value with a string, preserving current type void VariableData::ResetWith(wxString value) { switch (type) { case VARDATA_INT: { long temp = 0; value.ToLong(&temp); SetInt(temp); break; } case VARDATA_FLOAT: { double temp = 0; value.ToDouble(&temp); SetFloat(temp); break; } case VARDATA_BOOL: if (value == _T("1")) SetBool(true); else SetBool(false); break; case VARDATA_COLOUR: { long r=0,g=0,b=0; value.Mid(1,2).ToLong(&r,16); value.Mid(3,2).ToLong(&g,16); value.Mid(5,2).ToLong(&b,16); SetColour(wxColour(r,g,b)); break; } default: SetText(value); break; } }
void QvisLegendAttributesInterface::orientationChanged(int orientation) { SetBool(LEGEND_ORIENTATION0, (orientation==2 || orientation==3) ); SetBool(LEGEND_ORIENTATION1, (orientation==1 || orientation==3) ); SetUpdate(false); Apply(); }
void QvisLegendAttributesInterface::drawLabelsChanged(int val) { SetBool(LEGEND_DRAW_VALUES, (val == 1 || val == 3)); SetBool(LEGEND_DRAW_LABELS, (val == 2 || val == 3)); SetUpdate(false); Apply(); }
int prEvent_IsRest(struct VMGlobals *g, int numArgsPushed) { PyrSlot *dictslots = slotRawObject(g->sp)->slots; PyrSlot *arraySlot = dictslots + ivxIdentDict_array; if (isKindOfSlot(arraySlot, class_array)) { PyrSlot key, typeSlot; static PyrSymbol *s_type = getsym("type"); static PyrSymbol *s_rest = getsym("rest"); PyrSymbol *typeSym; // test 'this[\type] == \rest' first SetSymbol(&key, s_type); identDict_lookup(slotRawObject(g->sp), &key, calcHash(&key), &typeSlot); if(!slotSymbolVal(&typeSlot, &typeSym) && typeSym == s_rest) { SetBool(g->sp, 1); return errNone; } else { PyrObject *array = slotRawObject(arraySlot); PyrSymbol *slotSym; static PyrSymbol *s_empty = getsym(""); static PyrSymbol *s_r = getsym("r"); static PyrClass *class_rest = getsym("Rest")->u.classobj; static PyrClass *class_metarest = getsym("Meta_Rest")->u.classobj; PyrSlot *slot; int32 size = array->size; int32 i; slot = array->slots + 1; // scan only the odd items for (i = 1; i < size; i += 2, slot += 2) { if (isKindOfSlot(slot, class_rest) || isKindOfSlot(slot, class_metarest) ) { SetBool(g->sp, 1); return errNone; } else if(!slotSymbolVal(slot, &slotSym)) { if(slotSym == s_empty || slotSym == s_r || slotSym == s_rest ) { SetBool(g->sp, 1); return errNone; } } // why no 'else'? // slotSymbolVal nonzero return = not a symbol; // non-symbols don't indicate rests, so, ignore them. } } } else { return errWrongType; } SetBool(g->sp, 0); return errNone; }
FormLayout::FormLayout() { SetNumber("Form.Width", 400); SetNumber("Form.Height", 300); SetBool("Form.MaximizeBox", false); SetBool("Form.MinimizeBox", false); SetBool("Form.Sizeable", false); SetBool("Form.ToolWindow", false); Set("Form.Name", t_("Noname")); SetPageRect( Rect(Point(10, 10), Size(400, 300)) ); }
/*********************************************************************\ Function name : CArrowSettings::SetData Description : Created at : 12.08.01, @ 21:55:29 Created by : Thomas Kunert Modified by : \*********************************************************************/ void CArrowSettings::SetData() { _Init(); SetBool(IDS_ARROW_SMALL_CHK, m_pArrow->m_lArrowType > 4); Int32 l = m_pArrow->m_lArrowType; if (l > 4) l -= 4; SetInt32(IDS_ARROW_TYPE_COMBO, l - 1); SetBool(IDC_IS_POPUP_CHK, m_pArrow->m_bIsPopupButton); Enable(IDS_ARROW_SMALL_CHK, !m_pArrow->m_bIsPopupButton); Enable(IDS_ARROW_TYPE_COMBO, !m_pArrow->m_bIsPopupButton); Enable(IDC_ARROW_CHILD_ITEMS, m_pArrow->m_bIsPopupButton); m_pArrow->m_Children.FillEditBox(m_pSettingsDialog, IDC_ARROW_CHILD_ITEMS); }
void FoveatedRenderingApp::DefaultRender(izanagi::graph::CGraphicsDevice* device) { izanagi::sample::CSampleCamera& camera = GetCamera(); device->SetTexture(0, m_Img->GetTexture(m_Idx)); device->SetTexture(1, m_mask); auto shd = m_shdDrawCube.m_shd; device->SetShaderProgram(shd); auto hL2W = shd->GetHandleByName("g_mL2W"); shd->SetMatrix(device, hL2W, m_L2W); auto mtxW2C = camera.GetParam().mtxW2C; auto hW2C = shd->GetHandleByName("g_mW2C"); shd->SetMatrix(device, hW2C, mtxW2C); auto hEye = shd->GetHandleByName("g_vEye"); shd->SetVector(device, hEye, camera.GetParam().pos); auto hInvScr = shd->GetHandleByName("invScreen"); izanagi::math::CVector4 invScr(1.0f / SCREEN_WIDTH, 1.0f / SCREEN_HEIGHT, 0, 0); shd->SetVector(device, hInvScr, invScr); auto hCanFoveated = shd->GetHandleByName("canFoveated"); shd->SetBool(device, hCanFoveated, false); m_Cube->Render(device); }
void CXTPPropertyGridItemBool::OnBeforeInsert() { if (m_pBindBool && *m_pBindBool != m_bValue) { SetBool(*m_pBindBool); } }
/************************************* * operator = *************************************/ SHVDataVariant& SHVDataVariantImpl::operator=(const SHVDataVariant& val) { switch (val.GetDataType()) { case SHVDataVariant::TypeInt: SetInt(val.AsInt()); break; case SHVDataVariant::TypeInt64: SetInt64(val.AsInt64()); break; case SHVDataVariant::TypeBool: SetBool(val.AsBool()); break; case SHVDataVariant::TypeDouble: SetDouble(val.AsDouble()); break; case SHVDataVariant::TypeString: SetString(val.AsString()); break; case SHVDataVariant::TypeTime: SetTime(val.AsTime()); break; } return *this; }
PListValue& PListValue::operator =(const PListValue& rhs) { switch (rhs.type_) { case PLVT_NONE: Reset(); break; case PLVT_INT: SetInt(rhs.int_); break; case PLVT_BOOL: SetBool(rhs.bool_); break; case PLVT_FLOAT: SetFloat(rhs.float_); break; case PLVT_STRING: SetString(*rhs.string_); break; case PLVT_VALUEMAP: SetValueMap(*rhs.valueMap_); break; case PLVT_VALUEVECTOR: SetValueVector(*rhs.valueVector_); break; } return *this; }
void ApplinkDialog::Timer(const BaseContainer &msg) { Bool b; GetBool(IDC_CHK_PROMPT, b); if(b) { Filename fn; fn.SetDirectory(gPreferences.GetString(IDC_EXCH_FOLDER)); fn.SetFile("export.txt"); if(GeFExist(fn)) { GePrint("File exists!"); SetTimer(0); if(GeOutString("To import a new object?", GEMB_OKCANCEL) == GEMB_R_OK) { GePrint("Start import!"); BaseDocument* doc = GetActiveDocument(); ApplinkImporter* importer = NewObjClear(ApplinkImporter); importer->Execute(doc, &gPreferences); SetTimer(1000); } else { SetBool(IDC_CHK_PROMPT, false); } } } }
void QvisLegendAttributesInterface::drawMinmaxToggled(bool val) { SetBool(LEGEND_DRAW_MINMAX, val); SetUpdate(false); Apply(); }
void QvisLegendAttributesInterface::drawTitleToggled(bool val) { SetBool(LEGEND_DRAW_TITLE, val); SetUpdate(false); Apply(); }
avtLegendAttributesColleague::avtLegendAttributesColleague( VisWindowColleagueProxy &m) : avtAnnotationColleague(m), atts() { // Populate atts with some legend defaults. SetBool(atts, LEGEND_MANAGE_POSITION, true); SetBool(atts, LEGEND_DRAW_BOX, false); SetBool(atts, LEGEND_DRAW_LABELS, false); SetBool(atts, LEGEND_ORIENTATION0, false); SetBool(atts, LEGEND_ORIENTATION1, false); SetBool(atts, LEGEND_DRAW_TITLE, true); SetBool(atts, LEGEND_DRAW_MINMAX, true); SetBool(atts, LEGEND_CONTROL_TICKS, true); SetBool(atts, LEGEND_MINMAX_INCLUSIVE, true); SetBool(atts, LEGEND_DRAW_VALUES, true); // Set the format string for the legend into the text. stringVector text; text.push_back("%# -9.4g"); atts.SetText(text); // Set the default position. const double defaultPosition[2] = {0.05, 0.9}; atts.SetPosition(defaultPosition); // Set the default scale. const double defaultScale[2] = {1.,1.}; atts.SetPosition2(defaultScale); // Set the default font height. atts.SetDoubleAttribute1(0.015); // Set the default bounding box color. atts.SetColor1(ColorAttribute(0,0,0,50)); // Set the default font properties. atts.SetFontFamily(AnnotationObject::Arial); atts.SetFontBold(false); atts.SetFontItalic(false); atts.SetFontShadow(false); // Set the default number of ticks atts.SetIntAttribute2(5); // Set the default legend type to variable atts.SetIntAttribute3(0); }
int ScIDE_Connected(struct VMGlobals *g, int numArgsPushed) { PyrSlot * returnSlot = g->sp - numArgsPushed + 1; SetBool(returnSlot, gIpcClient != 0); return errNone; }
Bool CSearchDialog::InitValues() { if (!GeDialog::InitValues()) return false; SetBool(IDC_SEARCH_REG_EXPR_CHK, m_bRegExpr); SetString(IDC_SEARCH_EDIT, m_strText); return true; }
bool CSettingsManager::ToggleBool(const std::string &id) { CSharedLock lock(m_settingsCritical); CSetting *setting = GetSetting(id); if (setting == NULL || setting->GetType() != SettingTypeBool) return false; return SetBool(id, !((CSettingBool*)setting)->GetValue()); }
//////// // Copy void VariableData::operator= (const VariableData ¶m) { switch(param.GetType()) { case VARDATA_INT: SetInt(param.AsInt()); break; case VARDATA_FLOAT: SetFloat(param.AsFloat()); break; case VARDATA_TEXT: SetText(param.AsText()); break; case VARDATA_BOOL: SetBool(param.AsBool()); break; case VARDATA_COLOUR: SetColour(param.AsColour()); break; case VARDATA_BLOCK: SetBlock(param.AsBlock()); break; default: DeleteValue(); } }
Bool InitValues() { // Initialize the force items. FreeChildren(CMB_FORCE); AddForceCycleElement(ID_SPRING); AddForceCycleElement(ID_CONNECTOR); AddForceCycleElement(ID_MOTOR); SetInt32(CMB_FORCE, ID_CONNECTOR); SetInt32(CMB_TYPE, -1); SetInt32(CMB_MODE, CMB_MODE_ALL); SetInt32(EDT_MAXCONN, 0, 0, 20, 1, false, 0, LIMIT<Int32>::MAX); SetFloat(EDT_RADIUS, (Float) 0, 0, 500, 1.0, FORMAT_METER, 0, MAXVALUE_FLOAT, false, false); SetBool(CHK_ADDDYNAMICS, false); SetBool(CHK_COMPOUND, false); SetBool(CHK_CLOSED, false); UpdateGadgets(true); return super::InitValues(); }
void WBEvent::Set( const HashedString& Name, const WBParamEvaluator& PE ) { switch( PE.GetType() ) { case WBParamEvaluator::EPT_Bool: SetBool( Name, PE.GetBool() ); break; case WBParamEvaluator::EPT_Int: SetInt( Name, PE.GetInt() ); break; case WBParamEvaluator::EPT_Float: SetFloat( Name, PE.GetFloat() ); break; case WBParamEvaluator::EPT_String: SetHash( Name, PE.GetString() ); break; // Conversion to hash is the best we can do case WBParamEvaluator::EPT_Entity: SetEntity( Name, PE.GetEntity() ); break; case WBParamEvaluator::EPT_Vector: SetVector( Name, PE.GetVector() ); break; } }
int prFileExists(struct VMGlobals * g, int numArgsPushed) { PyrSlot *a = g->sp - 1, *b = g->sp; char filename[PATH_MAX]; int error = slotStrVal(b, filename, PATH_MAX); if (error != errNone) return error; bool res = boost::filesystem::exists(filename); SetBool(a, res); return errNone; }
//////// // Copy void AssOverrideParameter::CopyFrom (const AssOverrideParameter ¶m) { switch(param.GetType()) { case VARDATA_INT: SetInt(param.AsInt()); break; case VARDATA_FLOAT: SetFloat(param.AsFloat()); break; case VARDATA_TEXT: SetText(param.AsText()); break; case VARDATA_BOOL: SetBool(param.AsBool()); break; case VARDATA_COLOUR: SetColour(param.AsColour()); break; case VARDATA_BLOCK: SetBlock(param.AsBlock()); break; default: DeleteValue(); } classification = param.classification; ommited = param.ommited; }
BoolRenderer::BoolRenderer(GraphEditor *parentEditor, bool forValue, BRect valueRect, BMessage *message) :Renderer(parentEditor, NULL) { TRACE(); changeMessage = message; editor = parentEditor; Init(); SetBool(forValue); SetFrame(valueRect); }
int prFileDelete(struct VMGlobals *g, int numArgsPushed) { PyrSlot *a = g->sp - 1, *b = g->sp; char filename[PATH_MAX]; int error = slotStrVal(b, filename, PATH_MAX); if (error != errNone) return error; int err = unlink(filename); SetBool(a, err == 0); return errNone; }
int prNetAddr_GetBroadcastFlag(VMGlobals *g, int numArgsPushed) { if (gUDPport == 0) return errFailed; int opt; socklen_t optlen = sizeof(opt); #ifdef SC_WIN32 if (getsockopt(gUDPport->Socket(), SOL_SOCKET, SO_BROADCAST, (char *)&opt, &optlen) == -1) #else if (getsockopt(gUDPport->Socket(), SOL_SOCKET, SO_BROADCAST, &opt, &optlen) == -1) #endif return errFailed; SetBool(g->sp, opt); return errNone; }
static int prNetAddr_GetBroadcastFlag(VMGlobals *g, int numArgsPushed) { if (gUDPport == 0) return errFailed; boost::system::error_code ec; boost::asio::socket_base::broadcast option; gUDPport->udpSocket.get_option(option, ec); if (ec) return errFailed; SetBool(g->sp, option.value()); return errNone; }
int prEvent_IsRest(struct VMGlobals *g, int numArgsPushed) { PyrSlot *dictslots = slotRawObject(g->sp)->slots; PyrSlot *arraySlot = dictslots + ivxIdentDict_array; static int isRestCount = 0; if (!isKindOfSlot(arraySlot, class_array)) { return errWrongType; } PyrSlot key, typeSlot; PyrSymbol *typeSym; // easy tests first: 'this[\type] == \rest' SetSymbol(&key, s_type); identDict_lookup(slotRawObject(g->sp), &key, calcHash(&key), &typeSlot); if(!slotSymbolVal(&typeSlot, &typeSym) && typeSym == s_rest) { SetBool(g->sp, 1); return errNone; } // and, 'this[\isRest] == true' SetSymbol(&key, s_isRest); identDict_lookup(slotRawObject(g->sp), &key, calcHash(&key), &typeSlot); if(IsTrue(&typeSlot)) { if (isRestCount == 0) post("\nWARNING: Setting isRest to true in an event is deprecated. See the Rest helpfile for supported ways to specify rests.\n\n"); isRestCount = (isRestCount + 1) % 100; SetBool(g->sp, 1); return errNone; } // failing those, scan slot values for something rest-like PyrObject *array = slotRawObject(arraySlot); SetBool(g->sp, dictHasRestlikeValue(array) ? 1 : 0); return errNone; }
Notification::Notification() : KAccessorObject("Notification"), timeout(-1) { SetMethod("setTitle", &Notification::_SetTitle); SetMethod("setMessage", &Notification::_SetMessage); SetMethod("setIcon", &Notification::_SetIcon); SetMethod("setTimeout", &Notification::_SetTimeout); SetMethod("setDelay", &Notification::_SetTimeout); SetMethod("setCallback", &Notification::_SetCallback); SetMethod("show", &Notification::_Show); SetMethod("hide", &Notification::_Hide); SetBool("nativeNotifications", Notification::InitializeImpl()); this->CreateImpl(); }
bool CSettings::SetEx(String strSetting, String strValue) { if(IsBool(strSetting)) SetBool(strSetting, strValue.ToBoolean()); else if(IsInteger(strSetting)) SetInteger(strSetting, strValue.ToInteger()); else if(IsFloat(strSetting)) SetFloat(strSetting, strValue.ToFloat()); else if(IsString(strSetting)) SetString(strSetting, strValue); else if(IsList(strSetting)) AddToList(strSetting, strValue); else return false; return true; }