SecondLife: newview/llfloatersettingsdebug.cpp Source File

00001 
00032 #include "llviewerprecompiledheaders.h"
00033 #include "llfloatersettingsdebug.h"
00034 #include "llfloater.h"
00035 #include "lluictrlfactory.h"
00036 #include "llfirstuse.h"
00037 #include "llcombobox.h"
00038 #include "llspinctrl.h"
00039 #include "llcolorswatch.h"
00040 #include "llviewercontrol.h"
00041 
00042 LLFloaterSettingsDebug* LLFloaterSettingsDebug::sInstance = NULL;
00043 
00044 LLFloaterSettingsDebug::LLFloaterSettingsDebug() : LLFloater("Configuration Editor")
00045 {
00046 }
00047 
00048 LLFloaterSettingsDebug::~LLFloaterSettingsDebug()
00049 {
00050         sInstance = NULL;
00051 }
00052 
00053 BOOL LLFloaterSettingsDebug::postBuild()
00054 {
00055         LLComboBox* settings_combo = getChild<LLComboBox>("settings_combo");
00056 
00057         struct f : public LLControlGroup::ApplyFunctor
00058         {
00059                 LLComboBox* combo;
00060                 f(LLComboBox* c) : combo(c) {}
00061                 virtual void apply(const LLString& name, LLControlVariable* control)
00062                 {
00063                         combo->add(name, (void*)control);
00064                 }
00065         } func(settings_combo);
00066 
00067         gSavedSettings.applyToAll(&func);
00068         gSavedPerAccountSettings.applyToAll(&func);
00069         gColors.applyToAll(&func);
00070 
00071         settings_combo->sortByName();
00072         settings_combo->setCommitCallback(onSettingSelect);
00073         settings_combo->setCallbackUserData(this);
00074         settings_combo->updateSelection();
00075 
00076         childSetCommitCallback("val_spinner_1", onCommitSettings);
00077         childSetUserData("val_spinner_1", this);
00078         childSetCommitCallback("val_spinner_2", onCommitSettings);
00079         childSetUserData("val_spinner_2", this);
00080         childSetCommitCallback("val_spinner_3", onCommitSettings);
00081         childSetUserData("val_spinner_3", this);
00082         childSetCommitCallback("val_spinner_4", onCommitSettings);
00083         childSetUserData("val_spinner_4", this);
00084         childSetCommitCallback("val_text", onCommitSettings);
00085         childSetUserData("val_text", this);
00086         childSetCommitCallback("boolean_combo", onCommitSettings);
00087         childSetUserData("boolean_combo", this);
00088         childSetCommitCallback("color_swatch", onCommitSettings);
00089         childSetUserData("color_swatch", this);
00090         childSetAction("default_btn", onClickDefault, this);
00091         mComment = getChild<LLTextEditor>("comment_text");
00092         return TRUE;
00093 }
00094 
00095 void LLFloaterSettingsDebug::draw()
00096 {
00097         LLComboBox* settings_combo = getChild<LLComboBox>("settings_combo");
00098         LLControlVariable* controlp = (LLControlVariable*)settings_combo->getCurrentUserdata();
00099         updateControl(controlp);
00100 
00101         LLFloater::draw();
00102 }
00103 
00104 //static
00105 void LLFloaterSettingsDebug::show(void*)
00106 {
00107         if (sInstance == NULL)
00108         {
00109                 sInstance = new LLFloaterSettingsDebug();
00110 
00111                 LLUICtrlFactory::getInstance()->buildFloater(sInstance, "floater_settings_debug.xml");
00112         }
00113 
00114         sInstance->open();              /* Flawfinder: ignore */
00115 }
00116 
00117 //static 
00118 void LLFloaterSettingsDebug::onSettingSelect(LLUICtrl* ctrl, void* user_data)
00119 {
00120         LLFloaterSettingsDebug* floaterp = (LLFloaterSettingsDebug*)user_data;
00121         LLComboBox* combo_box = (LLComboBox*)ctrl;
00122         LLControlVariable* controlp = (LLControlVariable*)combo_box->getCurrentUserdata();
00123 
00124         floaterp->updateControl(controlp);
00125 }
00126 
00127 //static
00128 void LLFloaterSettingsDebug::onCommitSettings(LLUICtrl* ctrl, void* user_data)
00129 {
00130         LLFloaterSettingsDebug* floaterp = (LLFloaterSettingsDebug*)user_data;
00131 
00132         LLComboBox* settings_combo = floaterp->getChild<LLComboBox>("settings_combo");
00133         LLControlVariable* controlp = (LLControlVariable*)settings_combo->getCurrentUserdata();
00134 
00135         LLVector3 vector;
00136         LLVector3d vectord;
00137         LLRect rect;
00138         LLColor4 col4;
00139         LLColor3 col3;
00140         LLColor4U col4U;
00141         LLColor4 color_with_alpha;
00142 
00143         switch(controlp->type())
00144         {               
00145           case TYPE_U32:
00146                 controlp->set(floaterp->childGetValue("val_spinner_1"));
00147                 break;
00148           case TYPE_S32:
00149                 controlp->set(floaterp->childGetValue("val_spinner_1"));
00150                 break;
00151           case TYPE_F32:
00152                 controlp->set(LLSD(floaterp->childGetValue("val_spinner_1").asReal()));
00153                 break;
00154           case TYPE_BOOLEAN:
00155                 controlp->set(floaterp->childGetValue("boolean_combo"));
00156                 break;
00157           case TYPE_STRING:
00158                 controlp->set(LLSD(floaterp->childGetValue("val_text").asString()));
00159                 break;
00160           case TYPE_VEC3:
00161                 vector.mV[VX] = (F32)floaterp->childGetValue("val_spinner_1").asReal();
00162                 vector.mV[VY] = (F32)floaterp->childGetValue("val_spinner_2").asReal();
00163                 vector.mV[VZ] = (F32)floaterp->childGetValue("val_spinner_3").asReal();
00164                 controlp->set(vector.getValue());
00165                 break;
00166           case TYPE_VEC3D:
00167                 vectord.mdV[VX] = floaterp->childGetValue("val_spinner_1").asReal();
00168                 vectord.mdV[VY] = floaterp->childGetValue("val_spinner_2").asReal();
00169                 vectord.mdV[VZ] = floaterp->childGetValue("val_spinner_3").asReal();
00170                 controlp->set(vectord.getValue());
00171                 break;
00172           case TYPE_RECT:
00173                 rect.mLeft = floaterp->childGetValue("val_spinner_1").asInteger();
00174                 rect.mRight = floaterp->childGetValue("val_spinner_2").asInteger();
00175                 rect.mBottom = floaterp->childGetValue("val_spinner_3").asInteger();
00176                 rect.mTop = floaterp->childGetValue("val_spinner_4").asInteger();
00177                 controlp->set(rect.getValue());
00178                 break;
00179           case TYPE_COL4:
00180                 col3.setValue(floaterp->childGetValue("color_swatch"));
00181                 col4 = LLColor4(col3, (F32)floaterp->childGetValue("val_spinner_4").asReal());
00182                 controlp->set(col4.getValue());
00183                 break;
00184           case TYPE_COL3:
00185                 controlp->set(floaterp->childGetValue("color_swatch"));
00186                 //col3.mV[VRED] = (F32)floaterp->childGetValue("val_spinner_1").asC();
00187                 //col3.mV[VGREEN] = (F32)floaterp->childGetValue("val_spinner_2").asReal();
00188                 //col3.mV[VBLUE] = (F32)floaterp->childGetValue("val_spinner_3").asReal();
00189                 //controlp->set(col3.getValue());
00190                 break;
00191           case TYPE_COL4U:
00192                 col3.setValue(floaterp->childGetValue("color_swatch"));
00193                 col4U.setVecScaleClamp(col3);
00194                 col4U.mV[VALPHA] = floaterp->childGetValue("val_spinner_4").asInteger();
00195                 controlp->set(col4U.getValue());
00196                 break;
00197           default:
00198                 break;
00199         }
00200 }
00201 
00202 // static
00203 void LLFloaterSettingsDebug::onClickDefault(void* user_data)
00204 {
00205         LLFloaterSettingsDebug* floaterp = (LLFloaterSettingsDebug*)user_data;
00206         LLComboBox* settings_combo = floaterp->getChild<LLComboBox>("settings_combo");
00207         LLControlVariable* controlp = (LLControlVariable*)settings_combo->getCurrentUserdata();
00208 
00209         if (controlp)
00210         {
00211                 controlp->resetToDefault();
00212                 floaterp->updateControl(controlp);
00213         }
00214 }
00215 
00216 // we've switched controls, or doing per-frame update, so update spinners, etc.
00217 void LLFloaterSettingsDebug::updateControl(LLControlVariable* controlp)
00218 {
00219         LLSpinCtrl* spinner1 = getChild<LLSpinCtrl>("val_spinner_1");
00220         LLSpinCtrl* spinner2 = getChild<LLSpinCtrl>("val_spinner_2");
00221         LLSpinCtrl* spinner3 = getChild<LLSpinCtrl>("val_spinner_3");
00222         LLSpinCtrl* spinner4 = getChild<LLSpinCtrl>("val_spinner_4");
00223         LLColorSwatchCtrl* color_swatch = getChild<LLColorSwatchCtrl>("color_swatch");
00224 
00225         if (!spinner1 || !spinner2 || !spinner3 || !spinner4 || !color_swatch)
00226         {
00227                 llwarns << "Could not find all desired controls by name"
00228                         << llendl;
00229                 return;
00230         }
00231 
00232         spinner1->setVisible(FALSE);
00233         spinner2->setVisible(FALSE);
00234         spinner3->setVisible(FALSE);
00235         spinner4->setVisible(FALSE);
00236         color_swatch->setVisible(FALSE);
00237         childSetVisible("val_text", FALSE);
00238         mComment->setText(LLString::null);
00239 
00240         if (controlp)
00241         {
00242                 eControlType type = controlp->type();
00243 
00244                 //hide combo box only for non booleans, otherwise this will result in the combo box closing every frame
00245                 childSetVisible("boolean_combo", type == TYPE_BOOLEAN);
00246                 
00247 
00248                 mComment->setText(controlp->getComment());
00249                 spinner1->setMaxValue(F32_MAX);
00250                 spinner2->setMaxValue(F32_MAX);
00251                 spinner3->setMaxValue(F32_MAX);
00252                 spinner4->setMaxValue(F32_MAX);
00253                 spinner1->setMinValue(-F32_MAX);
00254                 spinner2->setMinValue(-F32_MAX);
00255                 spinner3->setMinValue(-F32_MAX);
00256                 spinner4->setMinValue(-F32_MAX);
00257                 if (!spinner1->hasFocus())
00258                 {
00259                         spinner1->setIncrement(0.1f);
00260                 }
00261                 if (!spinner2->hasFocus())
00262                 {
00263                         spinner2->setIncrement(0.1f);
00264                 }
00265                 if (!spinner3->hasFocus())
00266                 {
00267                         spinner3->setIncrement(0.1f);
00268                 }
00269                 if (!spinner4->hasFocus())
00270                 {
00271                         spinner4->setIncrement(0.1f);
00272                 }
00273 
00274                 LLSD sd = controlp->get();
00275                 switch(type)
00276                 {
00277                   case TYPE_U32:
00278                         spinner1->setVisible(TRUE);
00279                         spinner1->setLabel(LLString("value")); // Debug, don't translate
00280                         if (!spinner1->hasFocus())
00281                         {
00282                                 spinner1->setValue(sd);
00283                                 spinner1->setMinValue((F32)U32_MIN);
00284                                 spinner1->setMaxValue((F32)U32_MAX);
00285                                 spinner1->setIncrement(1.f);
00286                                 spinner1->setPrecision(0);
00287                         }
00288                         break;
00289                   case TYPE_S32:
00290                         spinner1->setVisible(TRUE);
00291                         spinner1->setLabel(LLString("value")); // Debug, don't translate
00292                         if (!spinner1->hasFocus())
00293                         {
00294                                 spinner1->setValue(sd);
00295                                 spinner1->setMinValue((F32)S32_MIN);
00296                                 spinner1->setMaxValue((F32)S32_MAX);
00297                                 spinner1->setIncrement(1.f);
00298                                 spinner1->setPrecision(0);
00299                         }
00300                         break;
00301                   case TYPE_F32:
00302                         spinner1->setVisible(TRUE);
00303                         spinner1->setLabel(LLString("value")); // Debug, don't translate
00304                         if (!spinner1->hasFocus())
00305                         {
00306                                 spinner1->setPrecision(3);
00307                                 spinner1->setValue(sd);
00308                         }
00309                         break;
00310                   case TYPE_BOOLEAN:
00311                         if (!childHasFocus("boolean_combo"))
00312                         {
00313                                 if (sd.asBoolean())
00314                                 {
00315                                         childSetValue("boolean_combo", LLSD("true"));
00316                                 }
00317                                 else
00318                                 {
00319                                         childSetValue("boolean_combo", LLSD(""));
00320                                 }
00321                         }
00322                         break;
00323                   case TYPE_STRING:
00324                         childSetVisible("val_text", TRUE);
00325                         if (!childHasFocus("val_text"))
00326                         {
00327                                 childSetValue("val_text", sd);
00328                         }
00329                         break;
00330                   case TYPE_VEC3:
00331                   {
00332                         LLVector3 v;
00333                         v.setValue(sd);
00334                         spinner1->setVisible(TRUE);
00335                         spinner1->setLabel(LLString("X"));
00336                         spinner2->setVisible(TRUE);
00337                         spinner2->setLabel(LLString("Y"));
00338                         spinner3->setVisible(TRUE);
00339                         spinner3->setLabel(LLString("Z"));
00340                         if (!spinner1->hasFocus())
00341                         {
00342                                 spinner1->setPrecision(3);
00343                                 spinner1->setValue(v[VX]);
00344                         }
00345                         if (!spinner2->hasFocus())
00346                         {
00347                                 spinner2->setPrecision(3);
00348                                 spinner2->setValue(v[VY]);
00349                         }
00350                         if (!spinner3->hasFocus())
00351                         {
00352                                 spinner3->setPrecision(3);
00353                                 spinner3->setValue(v[VZ]);
00354                         }
00355                         break;
00356                   }
00357                   case TYPE_VEC3D:
00358                   {
00359                         LLVector3d v;
00360                         v.setValue(sd);
00361                         spinner1->setVisible(TRUE);
00362                         spinner1->setLabel(LLString("X"));
00363                         spinner2->setVisible(TRUE);
00364                         spinner2->setLabel(LLString("Y"));
00365                         spinner3->setVisible(TRUE);
00366                         spinner3->setLabel(LLString("Z"));
00367                         if (!spinner1->hasFocus())
00368                         {
00369                                 spinner1->setPrecision(3);
00370                                 spinner1->setValue(v[VX]);
00371                         }
00372                         if (!spinner2->hasFocus())
00373                         {
00374                                 spinner2->setPrecision(3);
00375                                 spinner2->setValue(v[VY]);
00376                         }
00377                         if (!spinner3->hasFocus())
00378                         {
00379                                 spinner3->setPrecision(3);
00380                                 spinner3->setValue(v[VZ]);
00381                         }
00382                         break;
00383                   }
00384                   case TYPE_RECT:
00385                   {
00386                         LLRect r;
00387                         r.setValue(sd);
00388                         spinner1->setVisible(TRUE);
00389                         spinner1->setLabel(LLString("Left"));
00390                         spinner2->setVisible(TRUE);
00391                         spinner2->setLabel(LLString("Right"));
00392                         spinner3->setVisible(TRUE);
00393                         spinner3->setLabel(LLString("Bottom"));
00394                         spinner4->setVisible(TRUE);
00395                         spinner4->setLabel(LLString("Top"));
00396                         if (!spinner1->hasFocus())
00397                         {
00398                                 spinner1->setPrecision(0);
00399                                 spinner1->setValue(r.mLeft);
00400                         }
00401                         if (!spinner2->hasFocus())
00402                         {
00403                                 spinner2->setPrecision(0);
00404                                 spinner2->setValue(r.mRight);
00405                         }
00406                         if (!spinner3->hasFocus())
00407                         {
00408                                 spinner3->setPrecision(0);
00409                                 spinner3->setValue(r.mBottom);
00410                         }
00411                         if (!spinner4->hasFocus())
00412                         {
00413                                 spinner4->setPrecision(0);
00414                                 spinner4->setValue(r.mTop);
00415                         }
00416 
00417                         spinner1->setMinValue((F32)S32_MIN);
00418                         spinner1->setMaxValue((F32)S32_MAX);
00419                         spinner1->setIncrement(1.f);
00420 
00421                         spinner2->setMinValue((F32)S32_MIN);
00422                         spinner2->setMaxValue((F32)S32_MAX);
00423                         spinner2->setIncrement(1.f);
00424 
00425                         spinner3->setMinValue((F32)S32_MIN);
00426                         spinner3->setMaxValue((F32)S32_MAX);
00427                         spinner3->setIncrement(1.f);
00428 
00429                         spinner4->setMinValue((F32)S32_MIN);
00430                         spinner4->setMaxValue((F32)S32_MAX);
00431                         spinner4->setIncrement(1.f);
00432                         break;
00433                   }
00434                   case TYPE_COL4:
00435                   {
00436                         LLColor4 clr;
00437                         clr.setValue(sd);
00438                         color_swatch->setVisible(TRUE);
00439                         // only set if changed so color picker doesn't update
00440                         if(clr != LLColor4(color_swatch->getValue()))
00441                         {
00442                                 color_swatch->set(LLColor4(sd), TRUE, FALSE);
00443                         }
00444                         spinner4->setVisible(TRUE);
00445                         spinner4->setLabel(LLString("Alpha"));
00446                         if (!spinner4->hasFocus())
00447                         {
00448                                 spinner4->setPrecision(3);
00449                                 spinner4->setMinValue(0.0);
00450                                 spinner4->setMaxValue(1.f);
00451                                 spinner4->setValue(clr.mV[VALPHA]);
00452                         }
00453                         break;
00454                   }
00455                   case TYPE_COL3:
00456                   {
00457                         LLColor3 clr;
00458                         clr.setValue(sd);
00459                         color_swatch->setVisible(TRUE);
00460                         color_swatch->setValue(sd);
00461                         break;
00462                   }
00463                   case TYPE_COL4U:
00464                   {
00465                         LLColor4U clr;
00466                         clr.setValue(sd);
00467                         color_swatch->setVisible(TRUE);
00468                         if(LLColor4(clr) != LLColor4(color_swatch->getValue()))
00469                         {
00470                                 color_swatch->set(LLColor4(clr), TRUE, FALSE);
00471                         }
00472                         spinner4->setVisible(TRUE);
00473                         spinner4->setLabel(LLString("Alpha"));
00474                         if(!spinner4->hasFocus())
00475                         {
00476                                 spinner4->setPrecision(0);
00477                                 spinner4->setValue(clr.mV[VALPHA]);
00478                         }
00479 
00480                         spinner4->setMinValue(0);
00481                         spinner4->setMaxValue(255);
00482                         spinner4->setIncrement(1.f);
00483 
00484                         break;
00485                   }
00486                   default:
00487                         mComment->setText(LLString("unknown"));
00488                         break;
00489                 }
00490         }
00491 
00492 }