// private methods of FFileDialog
//----------------------------------------------------------------------
void FFileDialog::init()
{
static constexpr std::size_t w = 42;
static constexpr std::size_t h = 15;
int x, y;
setGeometry(FPoint(1, 1), FSize(w, h), false);
auto parent_widget = getParentWidget();
if ( parent_widget )
{
x = 1 + int((parent_widget->getWidth() - w) / 2);
y = 1 + int((parent_widget->getHeight() - h) / 3);
}
else
x = y = 1;
if ( dlg_type == FFileDialog::Save )
FDialog::setText("Save file");
else
FDialog::setText("Open file");
widgetSettings (FPoint(x, y)); // Create widgets
initCallbacks();
setModal();
readDir();
}
// virtual
BOOL LLFloaterEnvSettings::postBuild()
{
// load it up
initCallbacks();
syncMenu();
return TRUE;
}
MainForm::MainForm(QWidget* parent, Qt::WFlags flags) : QMainWindow(parent, flags)
{
vrLut = 0;
mprExaminer0 = 0;
mprExaminer1 = 0;
mprExaminer2 = 0;
vrExaminer = 0;
mprWindowLevelManip = 0;
vrTexture = 0;
vrSlicer = 0;
isUpdatingGui_ = false;
isDraggingWindow_ = false;
setupUi(this);
ViewerCore::get()->createPresetMixerForm(this);
ViewerCore::get()->createDicomForm(this, ViewerCore::get()->getDicomElementList());
setWindowFlags(Qt::CustomizeWindowHint);
initFields();
initControlValues();
initConnections();
initCallbacks();
initPresets();
}
LLFloaterEnvSettings::LLFloaterEnvSettings() : LLFloater(std::string("Environment Settings Floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_env_settings.xml");
// load it up
initCallbacks();
}
LLFloaterWater::LLFloaterWater() : LLFloater(std::string("water floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_water.xml");
// add the combo boxes
mWaterPresetCombo = getChild<LLComboBox>("WaterPresetsCombo");
if (mWaterPresetCombo != NULL)
{
populateWaterPresetsList();
mWaterPresetCombo->setCommitCallback(boost::bind(&LLFloaterWater::onChangePresetName, this, _1));
}
// no editing or deleting of the blank string
sDefaultPresets.insert("");
boost_tokenizer tokens(getString("WLDefaultWaterNames"), boost::char_separator<char>(":"));
for (boost_tokenizer::iterator token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
{
std::string tok(*token_iter);
sDefaultPresets.insert(tok);
}
// load it up
initCallbacks();
}
LLFloaterWater::LLFloaterWater() : LLFloater(std::string("water floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_water.xml");
// add the combo boxes
LLComboBox* comboBox = getChild<LLComboBox>("WaterPresetsCombo");
if(comboBox != NULL) {
std::map<std::string, LLWaterParamSet>::iterator mIt =
LLWaterParamManager::instance()->mParamList.begin();
for(; mIt != LLWaterParamManager::instance()->mParamList.end(); mIt++)
{
comboBox->add(mIt->first);
}
// set defaults on combo boxes
comboBox->selectByValue(LLSD("Default"));
}
std::string def_water = getString("WLDefaultWaterNames");
// no editing or deleting of the blank string
sDefaultPresets.insert("");
boost_tokenizer tokens(def_water, boost::char_separator<char>(":"));
for (boost_tokenizer::iterator token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
{
std::string tok(*token_iter);
sDefaultPresets.insert(tok);
}
// load it up
initCallbacks();
}
LLFloaterWindLight::LLFloaterWindLight() : LLFloater(std::string("windlight floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_windlight_options.xml");
// add the combo boxes
mSkyPresetCombo = getChild<LLComboBox>("WLPresetsCombo");
if(mSkyPresetCombo != NULL) {
populateSkyPresetsList();
mSkyPresetCombo->setCommitCallback(onChangePresetName);
}
// add the list of presets
std::string def_days = getString("WLDefaultSkyNames");
// no editing or deleting of the blank string
sDefaultPresets.insert("");
boost_tokenizer tokens(def_days, boost::char_separator<char>(":"));
for (boost_tokenizer::iterator token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
{
std::string tok(*token_iter);
sDefaultPresets.insert(tok);
}
// load it up
initCallbacks();
}
LLFloaterHardwareSettings::LLFloaterHardwareSettings() : LLFloater(std::string("Hardware Settings Floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_hardware_settings.xml");
// load it up
initCallbacks();
}
LLFloaterDayCycle::LLFloaterDayCycle() : LLFloater(std::string("Day Cycle Floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_day_cycle_options.xml");
// add the combo boxes
LLComboBox* keyCombo = getChild<LLComboBox>("WLKeyPresets");
if(keyCombo != NULL)
{
LLWLParamManager::preset_name_list_t local_presets;
LLWLParamManager::instance()->getLocalPresetNames(local_presets);
for (LLWLParamManager::preset_name_list_t::const_iterator it = local_presets.begin(); it != local_presets.end(); ++it)
{
keyCombo->add(*it);
}
// set defaults on combo boxes
keyCombo->selectFirstItem();
}
// add the time slider
LLMultiSliderCtrl* sldr = getChild<LLMultiSliderCtrl>("WLTimeSlider");
sldr->addSlider();
// load it up
initCallbacks();
}
WLFloaterWindLightSend::WLFloaterWindLightSend() : LLFloater(std::string("windlight send floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_windlight_remote_save.xml");
// load it up
initCallbacks();
}
LLFloaterDayCycle::LLFloaterDayCycle() : LLFloater(std::string("Day Cycle Floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_day_cycle_options.xml");
// add the combo boxes
LLComboBox* keyCombo = getChild<LLComboBox>("WLKeyPresets");
if(keyCombo != NULL)
{
std::map<std::string, LLWLParamSet>::iterator mIt =
LLWLParamManager::instance()->mParamList.begin();
for(; mIt != LLWLParamManager::instance()->mParamList.end(); mIt++)
{
if(mIt->second.mInventoryID.isNull())
keyCombo->add(std::string(mIt->first));
}
// set defaults on combo boxes
keyCombo->selectFirstItem();
}
// add the time slider
LLMultiSliderCtrl* sldr = getChild<LLMultiSliderCtrl>("WLTimeSlider");
sldr->addSlider();
// load it up
initCallbacks();
}
Qt7zPackagePrivate::Qt7zPackagePrivate(Qt7zPackage *q) :
m_q(q) ,
m_isOpen(false) ,
m_blockIndex(0xFFFFFFFF) ,
m_outBuffer(0) ,
m_outBufferSize(0)
{
initCallbacks();
}
int main(int argc, char** argv)
{
srand((unsigned int)time(0)); //Seed the random number generator
initGlut(argc, argv);
initCallbacks();
glewInit();
init();
glutMainLoop();
return 0;
}
MainWindow::MainWindow()
{
m_sizeX = 762;
m_sizeY = 576;
m_cam = NULL;
m_mesh = NULL;
m_oldX = m_oldY = 0;
initGlut();
initCallbacks();
}
BOOL LLFloaterHardwareSettings::postBuild()
{
childSetAction("OK", onBtnOK, this);
refresh();
center();
// load it up
initCallbacks();
return TRUE;
}
Qt7zPackagePrivate::Qt7zPackagePrivate(Qt7zPackage *q,
const QString &packagePath) :
m_q(q) ,
m_packagePath(packagePath) ,
m_isOpen(false) ,
m_blockIndex(0xFFFFFFFF) ,
m_outBuffer(0) ,
m_outBufferSize(0)
{
initCallbacks();
}
int main(int argc, char** argv)
{
glutInit(&argc,argv);
//ディスプレイモードの設定
glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
//ウィンドウの生成
glutCreateWindow("glsltest");
//glewの初期化
GLenum err;
err = glewInit();
if(err != GLEW_OK)
{
std::cout << "error at glewInit()." << std::endl;
return 1;
}
//コールバック関数の設定
initCallbacks();
//cudaを使用するデバイスを指定する
cudaSetDevice(0);
//デプスバッファを有効にする
glEnable(GL_DEPTH_TEST);
tsp = new BasicShaderProgram();
vao = new BasicShaderProgram::vaoType(*tsp);
vaod = new VAOPositionColorDynamic<BasicShaderProgram>(*tsp);
vaod2 = new VAOPositionColorDynamic<BasicShaderProgram>(*tsp);
tex = new Texture2D(GL_TEXTURE0);
tex2 = new Texture2D(GL_TEXTURE0);
texsp = new TextureShaderProgram();
vaot = new TextureShaderProgram::vaoType(*texsp, *tex);
vaot2 = new TextureShaderProgram::vaoType(*texsp, *tex2);
//シーンの初期化
initScene();
//メインループ
glutMainLoop();
delete vaod2;
delete vaod;
delete vao;
delete tsp;
delete vaot;
delete vaot2;
delete texsp;
return 0;
}
bool AboutState::onEnter() {
StateParser stateParser;
stateParser.parseState("resources/data.json", s_aboutID, &m_gameObjects,
&m_textureIDList, &m_fontIDList);
if (!MenuState::onEnter()) {
return false;
}
initCallbacks();
std::cout << "entering AboutState\n";
return true;
}
// virtual
BOOL LLFloaterEditSky::postBuild()
{
mSkyPresetNameEditor = getChild<LLLineEditor>("sky_preset_name");
mSkyPresetCombo = getChild<LLComboBox>("sky_preset_combo");
mMakeDefaultCheckBox = getChild<LLCheckBoxCtrl>("make_default_cb");
mSaveButton = getChild<LLButton>("save");
initCallbacks();
// Create the sun position scrubber on the slider.
getChild<LLMultiSliderCtrl>("WLSunPos")->addSlider(12.f);
return TRUE;
}
LLFloaterDayCycle::LLFloaterDayCycle() : LLFloater(std::string("Day Cycle Floater"))
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_day_cycle_options.xml");
// add the combo boxes
LLComboBox* keyCombo = getChild<LLComboBox>("WLKeyPresets");
if(keyCombo != NULL)
{
LLWLParamManager::preset_name_list_t local_presets;
LLWLParamManager::getInstance()->getLocalPresetNames(local_presets);
for (LLWLParamManager::preset_name_list_t::const_iterator it = local_presets.begin(); it != local_presets.end(); ++it)
{
keyCombo->add(*it);
}
// set defaults on combo boxes
keyCombo->selectFirstItem();
}
// add the time slider
LLMultiSliderCtrl* sldr = getChild<LLMultiSliderCtrl>("WLTimeSlider");
sldr->addSlider();
// add the combo boxes
LLComboBox* comboBox = getChild<LLComboBox>("DayCyclePresetsCombo");
if(comboBox != NULL) {
LLDayCycleManager::preset_name_list_t day_presets;
LLDayCycleManager::getInstance()->getPresetNames(day_presets);
LLDayCycleManager::preset_name_list_t::const_iterator it;
for(it = day_presets.begin(); it != day_presets.end(); ++it)
{
comboBox->add(*it);
}
// entry for when we're in estate time
comboBox->add(LLStringUtil::null);
// set defaults on combo boxes
//comboBox->selectByValue(LLSD("Default"));
}
// load it up
initCallbacks();
}
void BrpcCtrlInterface::run()
{
if (! sipDispatcher) {
ERROR("SIP dispatcher hook not set.\n");
return;
}
if (! initCallbacks()) {
ERROR("failed to init BINRPC call back system\n");
return;
}
if(rpcCheck())
serResync();
_run();
}
int main( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGBA );
glutInitWindowSize( 512, 512 );
// If you are using freeglut, the next two lines will check if
// the code is truly 3.2. Otherwise, comment them out
// glutInitContextVersion( 3, 2 );
glutInitContextProfile( GLUT_CORE_PROFILE );
glutCreateWindow( "Sierpinski Gasket" );
glewInit();
init();
initCallbacks();
glutDisplayFunc( display );
glutMainLoop();
return 0;
}
GLFWwindow* initGlfwWindow() {
if (!glfwInit()) {
return NULL;
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
// glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
// glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
GLFWwindow* window = glfwCreateWindow(Width, Height, "Rotating box", NULL, NULL);
if (window == NULL) {
return NULL;
}
glfwMakeContextCurrent(window);
initCallbacks(window);
return window;
}
void IRC::initSessions()
{
IRC::_sessionServerMap.clear();
irc_callbacks_t callbacks = initCallbacks();
std::vector<ConfigHandler::IRCOptions_Server>::iterator it;
for(it = _options->serverVector.begin(); it != _options->serverVector.end(); it++)
{
irc_session_t* s = irc_create_session(&callbacks);
if(!s)
{
std::cerr << "IRC::initSessions() can't creat session for " << it->address << std::endl;
continue;
}
else
std::cout << "IRC::initSessions() created session for " << it->address << std::endl;
irc_option_set(s, LIBIRC_OPTION_STRIPNICKS);
IRC::_sessionServerMap[s] = *it;
}
}
BOOL LLFloaterWindLight::postBuild()
{
// add the list of presets
std::string def_days = getString("WLDefaultSkyNames");
// no editing or deleting of the blank string
sDefaultPresets.insert("");
boost_tokenizer tokens(def_days, boost::char_separator<char>(":"));
for (boost_tokenizer::iterator token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
{
std::string tok(*token_iter);
sDefaultPresets.insert(tok);
}
// add the combo boxes
LLComboBox* comboBox = getChild<LLComboBox>("WLPresetsCombo");
if(comboBox != NULL) {
std::map<std::string, LLWLParamSet>::iterator mIt =
LLWLParamManager::instance()->mParamList.begin();
for(; mIt != LLWLParamManager::instance()->mParamList.end(); mIt++)
{
comboBox->add(mIt->first);
}
// entry for when we're in estate time
comboBox->add(LLStringUtil::null);
// set defaults on combo boxes
comboBox->selectByValue(LLSD("Default"));
}
// load it up
initCallbacks();
syncMenu();
return TRUE;
}
BOOL LLFloaterHardwareSettings::postBuild()
{
childSetAction("OK", onBtnOK, this);
childSetAction("Cancel", onBtnCancel, this);
// Don't do this on Mac as their braindead GL versioning
// sets this when 8x and 16x are indeed available
//
#if !LL_DARWIN
if (gGLManager.mIsIntel || gGLManager.mGLVersion < 3.f)
{ //remove FSAA settings above "4x"
LLComboBox* combo = getChild<LLComboBox>("fsaa");
combo->remove("8x");
combo->remove("16x");
}
#endif
refresh();
center();
// load it up
initCallbacks();
return TRUE;
}
namespace slint
{
std::unordered_map<std::string, XMLConfig::CBType> XMLConfig::callbacks = initCallbacks();
void XMLConfig::getOptions(types::String & str, SLintOptions & options)
{
const std::wstring customer(str.get(0));
if (customer == L"cnes")
{
const CNES::ToolConfiguration tc = CNES::ToolConfiguration::createFromXml(str.get(1));
const CNES::AnalysisConfiguration ac = CNES::AnalysisConfiguration::createFromXml(str.get(2));
const CNES::AnalysisConfigurationType & act = ac.getAnalysisConfiguration();
CNES::CNESConfig::getOptions(tc.getToolConfiguration(), act, options);
for (const CNES::ExcludedProjectFileType & epft : act.getExcludedProjectFile())
{
options.addExcludedFile(epft.getFilename());
}
options.setId(act.getId());
}
}
void XMLConfig::getOptions(const std::wstring & path, SLintOptions & options)
{
xmlDoc * doc = slint::XMLtools::readXML(path);
xmlNode * root = xmlDocGetRootElement(doc);
for (xmlNode * child = root->children; child; child = child->next)
{
const std::string nodeName((const char *)child->name);
auto i = callbacks.find(nodeName);
if (i != callbacks.end())
{
if (SLintChecker * checker = i->second(child))
{
options.addDefault(checker);
}
}
}
xmlFreeDoc(doc);
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<FunctionNameChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
std::wstring pattern;
int min = -1;
int max = -1;
XMLtools::getWString(node, "id", id);
XMLtools::getWString(node, "namePattern", pattern);
XMLtools::getInt(node, "minLength", min);
XMLtools::getInt(node, "maxLength", max);
return new FunctionNameChecker(id, pattern, min, max);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<VariableNameChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
std::wstring pattern;
int min = -1;
int max = -1;
XMLtools::getWString(node, "id", id);
XMLtools::getWString(node, "namePattern", pattern);
XMLtools::getInt(node, "minLength", min);
XMLtools::getInt(node, "maxLength", max);
return new VariableNameChecker(id, pattern, min, max);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<McCabeChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
int max = -1;
XMLtools::getWString(node, "id", id);
XMLtools::getInt(node, "max", max);
return new McCabeChecker(id, max);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<DecimalChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
std::wstring character;
bool checkDot = false;
XMLtools::getWString(node, "id", id);
XMLtools::getWString(node, "character", character);
XMLtools::getBool(node, "checkDot", checkDot);
return new DecimalChecker(id, character, checkDot);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<LineLengthChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
int max = -1;
XMLtools::getWString(node, "id", id);
XMLtools::getInt(node, "max", max);
return new LineLengthChecker(id, max);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<LinesCountChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
int max = -1;
XMLtools::getWString(node, "id", id);
XMLtools::getInt(node, "max", max);
return new LinesCountChecker(id, max);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<StructChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
std::wstring pattern;
int min = -1;
int max = -1;
XMLtools::getWString(node, "id", id);
XMLtools::getWString(node, "fieldPattern", pattern);
XMLtools::getInt(node, "minLength", min);
XMLtools::getInt(node, "maxLength", max);
return new StructChecker(id, pattern, min, max);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<BreaksInLoopChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
int maxBreaks = -1;
int maxContinues = -1;
XMLtools::getWString(node, "id", id);
XMLtools::getInt(node, "maxBreaks", maxBreaks);
XMLtools::getInt(node, "maxContinues", maxContinues);
return new BreaksInLoopChecker(id, maxBreaks, maxContinues);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<NestedBlocksChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
int max = -1;
XMLtools::getWString(node, "id", id);
XMLtools::getInt(node, "max", max);
return new NestedBlocksChecker(id, max);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<ReturnsCountChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
int max = -1;
XMLtools::getWString(node, "id", id);
XMLtools::getInt(node, "max", max);
return new ReturnsCountChecker(id, max);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<ExpInCondChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
int max = -1;
XMLtools::getWString(node, "id", id);
XMLtools::getInt(node, "max", max);
return new ExpInCondChecker(id, max);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<IllegalCallsChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
std::vector<std::wstring> names;
for (xmlNode * child = node->children; child; child = child->next)
{
const std::string nodeName((const char *)child->name);
if (nodeName == "keyword")
{
std::wstring name;
XMLtools::getWString(child, "name", name);
if (!name.empty())
{
names.emplace_back(name);
}
}
}
XMLtools::getWString(node, "id", id);
return new IllegalCallsChecker(id, names);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<FunctionTestReturnChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
std::unordered_map<std::wstring, std::vector<unsigned int>> namesArgs;
for (xmlNode * child = node->children; child; child = child->next)
{
const std::string nodeName((const char *)child->name);
if (nodeName == "keyword")
{
std::wstring name;
XMLtools::getWString(child, "name", name);
if (!name.empty())
{
std::vector<unsigned int> arg;
if (XMLtools::getUIntVector(child, "arg", arg))
{
namesArgs.emplace(name, arg);
}
}
}
}
XMLtools::getWString(node, "id", id);
return new FunctionTestReturnChecker(id, namesArgs);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<SelectChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
bool checkDefault = false;
bool checkHomogeneity = false;
bool checkEmpty = false;
bool checkOneCase = false;
XMLtools::getWString(node, "id", id);
XMLtools::getBool(node, "default", checkDefault);
XMLtools::getBool(node, "homogeneity", checkHomogeneity);
XMLtools::getBool(node, "empty", checkEmpty);
XMLtools::getBool(node, "oneCase", checkOneCase);
return new SelectChecker(id, checkDefault, checkHomogeneity, checkEmpty, checkOneCase);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<CommentRatioChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
double ratio = 0;
XMLtools::getWString(node, "id", id);
XMLtools::getDouble(node, "ratioMin", ratio);
if (ratio < 0)
{
ratio = 0;
}
else if (ratio > 1)
{
ratio = 1;
}
return new CommentRatioChecker(id, ratio);
}
return nullptr;
}
template<>
SLintChecker * XMLConfig::createFromXmlNode<NotEqualChecker>(xmlNode * node)
{
bool enable = true;
XMLtools::getBool(node, "enable", enable);
if (enable)
{
std::wstring id;
std::wstring op;
XMLtools::getWString(node, "id", id);
XMLtools::getWString(node, "operator", op);
if (!op.empty() && (op == L"<>" || op == L"~=" || op == L"@="))
{
return new NotEqualChecker(id, op);
}
}
return nullptr;
}
std::unordered_map<std::string, XMLConfig::CBType> XMLConfig::initCallbacks()
{
std::unordered_map<std::string, CBType> callbacks;
SLINT_INSERT_IN_MAP(GlobalKeyword);
SLINT_INSERT_IN_MAP(Redefinition);
SLINT_INSERT_IN_MAP(Variables);
SLINT_INSERT_IN_MAP(FunctionName);
SLINT_INSERT_IN_MAP(FunctionArgs);
SLINT_INSERT_IN_MAP(UselessArg);
SLINT_INSERT_IN_MAP(UselessRet);
SLINT_INSERT_IN_MAP(VariableName);
SLINT_INSERT_IN_MAP(SingleInstr);
SLINT_INSERT_IN_MAP(EmptyBlock);
SLINT_INSERT_IN_MAP(SemicolonAtEOL);
SLINT_INSERT_IN_MAP(MopenMclose);
SLINT_INSERT_IN_MAP(McCabe);
SLINT_INSERT_IN_MAP(Decimal);
SLINT_INSERT_IN_MAP(Printf);
SLINT_INSERT_IN_MAP(LineLength);
SLINT_INSERT_IN_MAP(LinesCount);
SLINT_INSERT_IN_MAP(Todo);
SLINT_INSERT_IN_MAP(NaN);
SLINT_INSERT_IN_MAP(EqEq);
SLINT_INSERT_IN_MAP(UselessOp);
SLINT_INSERT_IN_MAP(UnreachableCode);
SLINT_INSERT_IN_MAP(Deprecated);
SLINT_INSERT_IN_MAP(Select);
SLINT_INSERT_IN_MAP(ImplicitList);
SLINT_INSERT_IN_MAP(Struct);
SLINT_INSERT_IN_MAP(LoadSave);
SLINT_INSERT_IN_MAP(OldNot);
SLINT_INSERT_IN_MAP(SpacesAroundOp);
SLINT_INSERT_IN_MAP(SpacesInArgs);
SLINT_INSERT_IN_MAP(BreaksInLoop);
SLINT_INSERT_IN_MAP(NestedBlocks);
SLINT_INSERT_IN_MAP(BracketedExp);
SLINT_INSERT_IN_MAP(NotNot);
SLINT_INSERT_IN_MAP(IllegalCalls);
SLINT_INSERT_IN_MAP(ExpInCond);
SLINT_INSERT_IN_MAP(CommentRatio);
SLINT_INSERT_IN_MAP(FunctionArgsOrder);
SLINT_INSERT_IN_MAP(FunctionTestReturn);
SLINT_INSERT_IN_MAP(ReturnsCount);
SLINT_INSERT_IN_MAP(NotEqual);
return callbacks;
}
} // namespace slint
QSpiceChannel::QSpiceChannel(void *channel) : QSpiceObject(channel)
{
initCallbacks();
}
BOOL FloaterQuickPrefs::postBuild()
{
mWaterPresetsCombo = getChild<LLComboBox>("WaterPresetsCombo");
mWLPresetsCombo = getChild<LLComboBox>("WLPresetsCombo");
mWLSunPos = getChild<LLMultiSliderCtrl>("WLSunPos");
LLEnvManagerNew& env_mgr = LLEnvManagerNew::instance();
if (mWaterPresetsCombo != NULL)
{
std::list<std::string> user_presets, system_presets;
LLWaterParamManager::instance().getPresetNames(user_presets, system_presets);
// Add user presets first.
for (std::list<std::string>::const_iterator mIt = user_presets.begin(); mIt != user_presets.end(); ++mIt)
{
if((*mIt).length()>0) mWaterPresetsCombo->add(*mIt);
}
if (user_presets.size() > 0)
{
mWaterPresetsCombo->addSeparator();
}
// Add system presets.
for (std::list<std::string>::const_iterator mIt = system_presets.begin(); mIt != system_presets.end(); ++mIt)
{
if((*mIt).length()>0) mWaterPresetsCombo->add(*mIt);
}
mWaterPresetsCombo->selectByValue(env_mgr.getWaterPresetName());
}
if (mWLPresetsCombo != NULL)
{
LLWLParamManager::preset_name_list_t user_presets, sys_presets, region_presets;
LLWLParamManager::instance().getPresetNames(region_presets, user_presets, sys_presets);
// Add user presets.
for (LLWLParamManager::preset_name_list_t::const_iterator it = user_presets.begin(); it != user_presets.end(); ++it)
{
if((*it).length()>0) mWLPresetsCombo->add(*it);
}
if (!user_presets.empty())
{
mWLPresetsCombo->addSeparator();
}
// Add system presets.
for (LLWLParamManager::preset_name_list_t::const_iterator it = sys_presets.begin(); it != sys_presets.end(); ++it)
{
if((*it).length()>0) mWLPresetsCombo->add(*it);
}
mWLPresetsCombo->selectByValue(env_mgr.getSkyPresetName());
}
mWLSunPos->addSlider(12.f);
initCallbacks();
return LLDockableFloater::postBuild();
}
