PageRenderTime 58ms CodeModel.GetById 20ms RepoModel.GetById 1ms app.codeStats 0ms

/indra/newview/llpaneleditwearable.cpp

https://bitbucket.org/lindenlab/viewer-beta/
C++ | 1365 lines | 1082 code | 178 blank | 105 comment | 106 complexity | 77eb68e1dbc88912fff2dd1fdd86e847 MD5 | raw file
Possible License(s): LGPL-2.1 
    

  1. /** 
    2. 

  2.  * @file llpaneleditwearable.cpp
    3. 

  3.  * @brief UI panel for editing of a particular wearable item.
    4. 

  4.  *
    5. 

  5.  * $LicenseInfo:firstyear=2009&license=viewerlgpl$
    6. 

  6.  * Second Life Viewer Source Code
    7. 

  7.  * Copyright (C) 2010, Linden Research, Inc.
    8. 

  8.  * 
    9. 

  9.  * This library is free software; you can redistribute it and/or
    10. 

  10.  * modify it under the terms of the GNU Lesser General Public
    11. 

  11.  * License as published by the Free Software Foundation;
    12. 

  12.  * version 2.1 of the License only.
    13. 

  13.  * 
    14. 

  14.  * This library is distributed in the hope that it will be useful,
    15. 

  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16. 

  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    17. 

  17.  * Lesser General Public License for more details.
    18. 

  18.  * 
    19. 

  19.  * You should have received a copy of the GNU Lesser General Public
    20. 

  20.  * License along with this library; if not, write to the Free Software
    21. 

  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
    22. 

  22.  * 
    23. 

  23.  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
    24. 

  24.  * $/LicenseInfo$
    25. 

  25.  */
    26. 

  26. 

  27. #include "llviewerprecompiledheaders.h"
    28. 

  28. 

  29. #include "llpaneleditwearable.h"
    30. 

  30. #include "llpanel.h"
    31. 

  31. #include "llwearable.h"
    32. 

  32. #include "lluictrl.h"
    33. 

  33. #include "llscrollingpanellist.h"
    34. 

  34. #include "llvisualparam.h"
    35. 

  35. #include "lltoolmorph.h"
    36. 

  36. #include "llviewerjointmesh.h"
    37. 

  37. #include "lltrans.h"
    38. 

  38. #include "llbutton.h"
    39. 

  39. #include "llsliderctrl.h"
    40. 

  40. #include "llagent.h"
    41. 

  41. #include "llvoavatarself.h"
    42. 

  42. #include "lltexteditor.h"
    43. 

  43. #include "lltextbox.h"
    44. 

  44. #include "llaccordionctrl.h"
    45. 

  45. #include "llaccordionctrltab.h"
    46. 

  46. #include "llagentwearables.h"
    47. 

  47. #include "llscrollingpanelparam.h"
    48. 

  48. #include "llradiogroup.h"
    49. 

  49. #include "llnotificationsutil.h"
    50. 

  50. 

  51. #include "llcolorswatch.h"
    52. 

  52. #include "lltexturectrl.h"
    53. 

  53. #include "lltextureentry.h"
    54. 

  54. #include "llviewercontrol.h"    // gSavedSettings
    55. 

  55. #include "llviewertexturelist.h"
    56. 

  56. #include "llagentcamera.h"
    57. 

  57. #include "llmorphview.h"
    58. 

  58. 

  59. #include "llcommandhandler.h"
    60. 

  60. #include "lltextutil.h"
    61. 

  61. #include "llappearancemgr.h"
    62. 

  62. 

  63. // register panel with appropriate XML
    64. 

  64. static LLRegisterPanelClassWrapper<LLPanelEditWearable> t_edit_wearable("panel_edit_wearable");
    65. 

  65. 

  66. // subparts of the UI for focus, camera position, etc.
    67. 

  67. enum ESubpart {
    68. 

  68.         SUBPART_SHAPE_HEAD = 1, // avoid 0
    69. 

  69.         SUBPART_SHAPE_EYES,
    70. 

  70.         SUBPART_SHAPE_EARS,
    71. 

  71.         SUBPART_SHAPE_NOSE,
    72. 

  72.         SUBPART_SHAPE_MOUTH,
    73. 

  73.         SUBPART_SHAPE_CHIN,
    74. 

  74.         SUBPART_SHAPE_TORSO,
    75. 

  75.         SUBPART_SHAPE_LEGS,
    76. 

  76.         SUBPART_SHAPE_WHOLE,
    77. 

  77.         SUBPART_SHAPE_DETAIL,
    78. 

  78.         SUBPART_SKIN_COLOR,
    79. 

  79.         SUBPART_SKIN_FACEDETAIL,
    80. 

  80.         SUBPART_SKIN_MAKEUP,
    81. 

  81.         SUBPART_SKIN_BODYDETAIL,
    82. 

  82.         SUBPART_HAIR_COLOR,
    83. 

  83.         SUBPART_HAIR_STYLE,
    84. 

  84.         SUBPART_HAIR_EYEBROWS,
    85. 

  85.         SUBPART_HAIR_FACIAL,
    86. 

  86.         SUBPART_EYES,
    87. 

  87.         SUBPART_SHIRT,
    88. 

  88.         SUBPART_PANTS,
    89. 

  89.         SUBPART_SHOES,
    90. 

  90.         SUBPART_SOCKS,
    91. 

  91.         SUBPART_JACKET,
    92. 

  92.         SUBPART_GLOVES,
    93. 

  93.         SUBPART_UNDERSHIRT,
    94. 

  94.         SUBPART_UNDERPANTS,
    95. 

  95.         SUBPART_SKIRT,
    96. 

  96.         SUBPART_ALPHA,
    97. 

  97.         SUBPART_TATTOO,
    98. 

  98.         SUBPART_PHYSICS_BREASTS_UPDOWN,
    99. 

  99.         SUBPART_PHYSICS_BREASTS_INOUT,
    100. 

  100.         SUBPART_PHYSICS_BREASTS_LEFTRIGHT,
    101. 

  101.         SUBPART_PHYSICS_BELLY_UPDOWN,
    102. 

  102.         SUBPART_PHYSICS_BUTT_UPDOWN,
    103. 

  103.         SUBPART_PHYSICS_BUTT_LEFTRIGHT,
    104. 

  104.         SUBPART_PHYSICS_ADVANCED,
    105. 

  105.  };
    106. 

  106. 

  107. using namespace LLVOAvatarDefines;
    108. 

  108. 

  109. typedef std::vector<ESubpart> subpart_vec_t;
    110. 

  110. 

  111. // Locally defined classes
    112. 

  112. 

  113. class LLEditWearableDictionary : public LLSingleton<LLEditWearableDictionary>
    114. 

  114. {
    115. 

  115.         //--------------------------------------------------------------------
    116. 

  116.         // Constructors and Destructors
    117. 

  117.         //--------------------------------------------------------------------
    118. 

  118. public:
    119. 

  119.         LLEditWearableDictionary();
    120. 

  120.         virtual ~LLEditWearableDictionary();
    121. 

  121.         
    122. 

  122.         //--------------------------------------------------------------------
    123. 

  123.         // Wearable Types
    124. 

  124.         //--------------------------------------------------------------------
    125. 

  125. public:
    126. 

  126.         struct WearableEntry : public LLDictionaryEntry
    127. 

  127.         {
    128. 

  128.                 WearableEntry(LLWearableType::EType type,
    129. 

  129.                                           const std::string &title,
    130. 

  130.                                           const std::string &desc_title,
    131. 

  131.                                           U8 num_color_swatches,  // number of 'color_swatches'
    132. 

  132.                                           U8 num_texture_pickers, // number of 'texture_pickers'
    133. 

  133.                                           U8 num_subparts, ... ); // number of subparts followed by a list of ETextureIndex and ESubparts
    134. 

  134. 

  135. 

  136.                 const LLWearableType::EType mWearableType;
    137. 

  137.                 const std::string   mTitle;
    138. 

  138.                 const std::string       mDescTitle;
    139. 

  139.                 subpart_vec_t           mSubparts;
    140. 

  140.                 texture_vec_t           mColorSwatchCtrls;
    141. 

  141.                 texture_vec_t           mTextureCtrls;
    142. 

  142.         };
    143. 

  143. 

  144.         struct Wearables : public LLDictionary<LLWearableType::EType, WearableEntry>
    145. 

  145.         {
    146. 

  146.                 Wearables();
    147. 

  147.         } mWearables;
    148. 

  148. 

  149.         const WearableEntry*    getWearable(LLWearableType::EType type) const { return mWearables.lookup(type); }
    150. 

  150. 

  151.         //--------------------------------------------------------------------
    152. 

  152.         // Subparts
    153. 

  153.         //--------------------------------------------------------------------
    154. 

  154. public:
    155. 

  155.         struct SubpartEntry : public LLDictionaryEntry
    156. 

  156.         {
    157. 

  157.                 SubpartEntry(ESubpart part,
    158. 

  158.                                          const std::string &joint,
    159. 

  159.                                          const std::string &edit_group,
    160. 

  160.                                          const std::string &param_list,
    161. 

  161.                                          const std::string &accordion_tab,
    162. 

  162.                                          const LLVector3d  &target_offset,
    163. 

  163.                                          const LLVector3d  &camera_offset,
    164. 

  164.                                          const ESex        &sex);
    165. 

  165. 

  166.                 ESubpart                        mSubpart;
    167. 

  167.                 std::string                     mTargetJoint;
    168. 

  168.                 std::string                     mEditGroup;
    169. 

  169.                 std::string                     mParamList;
    170. 

  170.                 std::string                     mAccordionTab;
    171. 

  171.                 LLVector3d                      mTargetOffset;
    172. 

  172.                 LLVector3d                      mCameraOffset;
    173. 

  173.                 ESex                            mSex;
    174. 

  174.         };
    175. 

  175. 

  176.         struct Subparts : public LLDictionary<ESubpart, SubpartEntry>
    177. 

  177.         {
    178. 

  178.                 Subparts();
    179. 

  179.         } mSubparts;
    180. 

  180. 

  181.         const SubpartEntry*  getSubpart(ESubpart subpart) const { return mSubparts.lookup(subpart); }
    182. 

  182. 

  183.         //--------------------------------------------------------------------
    184. 

  184.         // Picker Control Entries
    185. 

  185.         //--------------------------------------------------------------------
    186. 

  186. public:
    187. 

  187.         struct PickerControlEntry : public LLDictionaryEntry
    188. 

  188.         {
    189. 

  189.                 PickerControlEntry(ETextureIndex tex_index,
    190. 

  190.                                                    const std::string name,
    191. 

  191.                                                    const LLUUID default_image_id = LLUUID::null,
    192. 

  192.                                                    const bool allow_no_texture = false);
    193. 

  193.                 ETextureIndex           mTextureIndex;
    194. 

  194.                 const std::string       mControlName;
    195. 

  195.                 const LLUUID            mDefaultImageId;
    196. 

  196.                 const bool                      mAllowNoTexture;
    197. 

  197.         };
    198. 

  198. 

  199.         struct ColorSwatchCtrls : public LLDictionary<ETextureIndex, PickerControlEntry>
    200. 

  200.         {
    201. 

  201.                 ColorSwatchCtrls();
    202. 

  202.         } mColorSwatchCtrls;
    203. 

  203. 

  204.         struct TextureCtrls : public LLDictionary<ETextureIndex, PickerControlEntry>
    205. 

  205.         {
    206. 

  206.                 TextureCtrls();
    207. 

  207.         } mTextureCtrls;
    208. 

  208. 

  209.         const PickerControlEntry* getTexturePicker(ETextureIndex index) const { return mTextureCtrls.lookup(index); }
    210. 

  210.         const PickerControlEntry* getColorSwatch(ETextureIndex index) const { return mColorSwatchCtrls.lookup(index); }
    211. 

  211. };
    212. 

  212. 

  213. LLEditWearableDictionary::LLEditWearableDictionary()
    214. 

  214. {
    215. 

  215. 

  216. }
    217. 

  217. 

  218. //virtual 
    219. 

  219. LLEditWearableDictionary::~LLEditWearableDictionary()
    220. 

  220. {
    221. 

  221. }
    222. 

  222. 

  223. LLEditWearableDictionary::Wearables::Wearables()
    224. 

  224. {
    225. 

  225.         // note the subpart that is listed first is treated as "default", regardless of what order is in enum.
    226. 

  226.         // Please match the order presented in XUI. -Nyx
    227. 

  227.         // this will affect what camera angle is shown when first editing a wearable
    228. 

  228.         addEntry(LLWearableType::WT_SHAPE,              new WearableEntry(LLWearableType::WT_SHAPE,"edit_shape_title","shape_desc_text",0,0,9,  SUBPART_SHAPE_WHOLE, SUBPART_SHAPE_HEAD,        SUBPART_SHAPE_EYES,     SUBPART_SHAPE_EARS,     SUBPART_SHAPE_NOSE,     SUBPART_SHAPE_MOUTH, SUBPART_SHAPE_CHIN, SUBPART_SHAPE_TORSO, SUBPART_SHAPE_LEGS));
    229. 

  229.         addEntry(LLWearableType::WT_SKIN,               new WearableEntry(LLWearableType::WT_SKIN,"edit_skin_title","skin_desc_text",0,3,4, TEX_HEAD_BODYPAINT, TEX_UPPER_BODYPAINT, TEX_LOWER_BODYPAINT, SUBPART_SKIN_COLOR, SUBPART_SKIN_FACEDETAIL, SUBPART_SKIN_MAKEUP, SUBPART_SKIN_BODYDETAIL));
    230. 

  230.         addEntry(LLWearableType::WT_HAIR,               new WearableEntry(LLWearableType::WT_HAIR,"edit_hair_title","hair_desc_text",0,1,4, TEX_HAIR, SUBPART_HAIR_COLOR,       SUBPART_HAIR_STYLE,     SUBPART_HAIR_EYEBROWS, SUBPART_HAIR_FACIAL));
    231. 

  231.         addEntry(LLWearableType::WT_EYES,               new WearableEntry(LLWearableType::WT_EYES,"edit_eyes_title","eyes_desc_text",0,1,1, TEX_EYES_IRIS, SUBPART_EYES));
    232. 

  232.         addEntry(LLWearableType::WT_SHIRT,              new WearableEntry(LLWearableType::WT_SHIRT,"edit_shirt_title","shirt_desc_text",1,1,1, TEX_UPPER_SHIRT, TEX_UPPER_SHIRT, SUBPART_SHIRT));
    233. 

  233.         addEntry(LLWearableType::WT_PANTS,              new WearableEntry(LLWearableType::WT_PANTS,"edit_pants_title","pants_desc_text",1,1,1, TEX_LOWER_PANTS, TEX_LOWER_PANTS, SUBPART_PANTS));
    234. 

  234.         addEntry(LLWearableType::WT_SHOES,              new WearableEntry(LLWearableType::WT_SHOES,"edit_shoes_title","shoes_desc_text",1,1,1, TEX_LOWER_SHOES, TEX_LOWER_SHOES, SUBPART_SHOES));
    235. 

  235.         addEntry(LLWearableType::WT_SOCKS,              new WearableEntry(LLWearableType::WT_SOCKS,"edit_socks_title","socks_desc_text",1,1,1, TEX_LOWER_SOCKS, TEX_LOWER_SOCKS, SUBPART_SOCKS));
    236. 

  236.         addEntry(LLWearableType::WT_JACKET,     new WearableEntry(LLWearableType::WT_JACKET,"edit_jacket_title","jacket_desc_text",1,2,1, TEX_UPPER_JACKET, TEX_UPPER_JACKET, TEX_LOWER_JACKET, SUBPART_JACKET));
    237. 

  237.         addEntry(LLWearableType::WT_GLOVES,     new WearableEntry(LLWearableType::WT_GLOVES,"edit_gloves_title","gloves_desc_text",1,1,1, TEX_UPPER_GLOVES, TEX_UPPER_GLOVES, SUBPART_GLOVES));
    238. 

  238.         addEntry(LLWearableType::WT_UNDERSHIRT, new WearableEntry(LLWearableType::WT_UNDERSHIRT,"edit_undershirt_title","undershirt_desc_text",1,1,1, TEX_UPPER_UNDERSHIRT, TEX_UPPER_UNDERSHIRT, SUBPART_UNDERSHIRT));
    239. 

  239.         addEntry(LLWearableType::WT_UNDERPANTS, new WearableEntry(LLWearableType::WT_UNDERPANTS,"edit_underpants_title","underpants_desc_text",1,1,1, TEX_LOWER_UNDERPANTS, TEX_LOWER_UNDERPANTS, SUBPART_UNDERPANTS));
    240. 

  240.         addEntry(LLWearableType::WT_SKIRT,              new WearableEntry(LLWearableType::WT_SKIRT,"edit_skirt_title","skirt_desc_text",1,1,1, TEX_SKIRT, TEX_SKIRT, SUBPART_SKIRT));
    241. 

  241.         addEntry(LLWearableType::WT_ALPHA,              new WearableEntry(LLWearableType::WT_ALPHA,"edit_alpha_title","alpha_desc_text",0,5,1, TEX_LOWER_ALPHA, TEX_UPPER_ALPHA, TEX_HEAD_ALPHA, TEX_EYES_ALPHA, TEX_HAIR_ALPHA, SUBPART_ALPHA));
    242. 

  242.         addEntry(LLWearableType::WT_TATTOO,     new WearableEntry(LLWearableType::WT_TATTOO,"edit_tattoo_title","tattoo_desc_text",1,3,1, TEX_HEAD_TATTOO, TEX_LOWER_TATTOO, TEX_UPPER_TATTOO, TEX_HEAD_TATTOO, SUBPART_TATTOO));
    243. 

  243.         addEntry(LLWearableType::WT_PHYSICS,    new WearableEntry(LLWearableType::WT_PHYSICS,"edit_physics_title","physics_desc_text",0,0,7, SUBPART_PHYSICS_BREASTS_UPDOWN, SUBPART_PHYSICS_BREASTS_INOUT, SUBPART_PHYSICS_BREASTS_LEFTRIGHT, SUBPART_PHYSICS_BELLY_UPDOWN, SUBPART_PHYSICS_BUTT_UPDOWN, SUBPART_PHYSICS_BUTT_LEFTRIGHT, SUBPART_PHYSICS_ADVANCED));
    244. 

  244. }
    245. 

  245. 

  246. LLEditWearableDictionary::WearableEntry::WearableEntry(LLWearableType::EType type,
    247. 

  247.                                           const std::string &title,
    248. 

  248.                                           const std::string &desc_title,
    249. 

  249.                                           U8 num_color_swatches,
    250. 

  250.                                           U8 num_texture_pickers,
    251. 

  251.                                           U8 num_subparts, ... ) :
    252. 

  252.         LLDictionaryEntry(title),
    253. 

  253.         mWearableType(type),
    254. 

  254.         mTitle(title),
    255. 

  255.         mDescTitle(desc_title)
    256. 

  256. {
    257. 

  257.         va_list argp;
    258. 

  258.         va_start(argp, num_subparts);
    259. 

  259. 

  260.         for (U8 i = 0; i < num_color_swatches; ++i)
    261. 

  261.         {
    262. 

  262.                 ETextureIndex index = (ETextureIndex)va_arg(argp,int);
    263. 

  263.                 mColorSwatchCtrls.push_back(index);
    264. 

  264.         }
    265. 

  265. 

  266.         for (U8 i = 0; i < num_texture_pickers; ++i)
    267. 

  267.         {
    268. 

  268.                 ETextureIndex index = (ETextureIndex)va_arg(argp,int);
    269. 

  269.                 mTextureCtrls.push_back(index);
    270. 

  270.         }
    271. 

  271. 

  272.         for (U8 i = 0; i < num_subparts; ++i)
    273. 

  273.         {
    274. 

  274.                 ESubpart part = (ESubpart)va_arg(argp,int);
    275. 

  275.                 mSubparts.push_back(part);
    276. 

  276.         }
    277. 

  277. }
    278. 

  278. 

  279. LLEditWearableDictionary::Subparts::Subparts()
    280. 

  280. {
    281. 

  281.         addEntry(SUBPART_SHAPE_WHOLE, new SubpartEntry(SUBPART_SHAPE_WHOLE, "mPelvis", "shape_body","shape_body_param_list", "shape_body_tab", LLVector3d(0.f, 0.f, 0.1f), LLVector3d(-2.5f, 0.5f, 0.8f),SEX_BOTH));
    282. 

  282.         addEntry(SUBPART_SHAPE_HEAD, new SubpartEntry(SUBPART_SHAPE_HEAD, "mHead", "shape_head", "shape_head_param_list", "shape_head_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    283. 

  283.         addEntry(SUBPART_SHAPE_EYES, new SubpartEntry(SUBPART_SHAPE_EYES, "mHead", "shape_eyes", "shape_eyes_param_list", "shape_eyes_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    284. 

  284.         addEntry(SUBPART_SHAPE_EARS, new SubpartEntry(SUBPART_SHAPE_EARS, "mHead", "shape_ears", "shape_ears_param_list", "shape_ears_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    285. 

  285.         addEntry(SUBPART_SHAPE_NOSE, new SubpartEntry(SUBPART_SHAPE_NOSE, "mHead", "shape_nose", "shape_nose_param_list", "shape_nose_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    286. 

  286.         addEntry(SUBPART_SHAPE_MOUTH, new SubpartEntry(SUBPART_SHAPE_MOUTH, "mHead", "shape_mouth", "shape_mouth_param_list", "shape_mouth_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    287. 

  287.         addEntry(SUBPART_SHAPE_CHIN, new SubpartEntry(SUBPART_SHAPE_CHIN, "mHead", "shape_chin", "shape_chin_param_list", "shape_chin_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    288. 

  288.         addEntry(SUBPART_SHAPE_TORSO, new SubpartEntry(SUBPART_SHAPE_TORSO, "mTorso", "shape_torso", "shape_torso_param_list", "shape_torso_tab", LLVector3d(0.f, 0.f, 0.3f), LLVector3d(-1.f, 0.15f, 0.3f),SEX_BOTH));
    289. 

  289.         addEntry(SUBPART_SHAPE_LEGS, new SubpartEntry(SUBPART_SHAPE_LEGS, "mPelvis", "shape_legs", "shape_legs_param_list", "shape_legs_tab", LLVector3d(0.f, 0.f, -0.5f), LLVector3d(-1.6f, 0.15f, -0.5f),SEX_BOTH));
    290. 

  290. 

  291.         addEntry(SUBPART_SKIN_COLOR, new SubpartEntry(SUBPART_SKIN_COLOR, "mHead", "skin_color", "skin_color_param_list", "skin_color_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    292. 

  292.         addEntry(SUBPART_SKIN_FACEDETAIL, new SubpartEntry(SUBPART_SKIN_FACEDETAIL, "mHead", "skin_facedetail", "skin_face_param_list", "skin_face_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    293. 

  293.         addEntry(SUBPART_SKIN_MAKEUP, new SubpartEntry(SUBPART_SKIN_MAKEUP, "mHead", "skin_makeup", "skin_makeup_param_list", "skin_makeup_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    294. 

  294.         addEntry(SUBPART_SKIN_BODYDETAIL, new SubpartEntry(SUBPART_SKIN_BODYDETAIL, "mPelvis", "skin_bodydetail", "skin_body_param_list", "skin_body_tab", LLVector3d(0.f, 0.f, -0.2f), LLVector3d(-2.5f, 0.5f, 0.5f),SEX_BOTH));
    295. 

  295. 

  296.         addEntry(SUBPART_HAIR_COLOR, new SubpartEntry(SUBPART_HAIR_COLOR, "mHead", "hair_color", "hair_color_param_list", "hair_color_tab", LLVector3d(0.f, 0.f, 0.10f), LLVector3d(-0.4f, 0.05f, 0.10f),SEX_BOTH));
    297. 

  297.         addEntry(SUBPART_HAIR_STYLE, new SubpartEntry(SUBPART_HAIR_STYLE, "mHead", "hair_style", "hair_style_param_list", "hair_style_tab", LLVector3d(0.f, 0.f, 0.10f), LLVector3d(-0.4f, 0.05f, 0.10f),SEX_BOTH));
    298. 

  298.         addEntry(SUBPART_HAIR_EYEBROWS, new SubpartEntry(SUBPART_HAIR_EYEBROWS, "mHead", "hair_eyebrows", "hair_eyebrows_param_list", "hair_eyebrows_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    299. 

  299.         addEntry(SUBPART_HAIR_FACIAL, new SubpartEntry(SUBPART_HAIR_FACIAL, "mHead", "hair_facial", "hair_facial_param_list", "hair_facial_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_MALE));
    300. 

  300. 

  301.         addEntry(SUBPART_EYES, new SubpartEntry(SUBPART_EYES, "mHead", "eyes", "eyes_main_param_list", "eyes_main_tab", LLVector3d(0.f, 0.f, 0.05f), LLVector3d(-0.5f, 0.05f, 0.07f),SEX_BOTH));
    302. 

  302. 

  303.         addEntry(SUBPART_SHIRT, new SubpartEntry(SUBPART_SHIRT, "mTorso", "shirt", "shirt_main_param_list", "shirt_main_tab", LLVector3d(0.f, 0.f, 0.3f), LLVector3d(-1.f, 0.15f, 0.3f),SEX_BOTH));
    304. 

  304.         addEntry(SUBPART_PANTS, new SubpartEntry(SUBPART_PANTS, "mPelvis", "pants", "pants_main_param_list", "pants_main_tab", LLVector3d(0.f, 0.f, -0.5f), LLVector3d(-1.6f, 0.15f, -0.5f),SEX_BOTH));
    305. 

  305.         addEntry(SUBPART_SHOES, new SubpartEntry(SUBPART_SHOES, "mPelvis", "shoes", "shoes_main_param_list", "shoes_main_tab", LLVector3d(0.f, 0.f, -0.5f), LLVector3d(-1.6f, 0.15f, -0.5f),SEX_BOTH));
    306. 

  306.         addEntry(SUBPART_SOCKS, new SubpartEntry(SUBPART_SOCKS, "mPelvis", "socks", "socks_main_param_list", "socks_main_tab", LLVector3d(0.f, 0.f, -0.5f), LLVector3d(-1.6f, 0.15f, -0.5f),SEX_BOTH));
    307. 

  307.         addEntry(SUBPART_JACKET, new SubpartEntry(SUBPART_JACKET, "mTorso", "jacket", "jacket_main_param_list", "jacket_main_tab", LLVector3d(0.f, 0.f, 0.f), LLVector3d(-2.f, 0.1f, 0.3f),SEX_BOTH));
    308. 

  308.         addEntry(SUBPART_SKIRT, new SubpartEntry(SUBPART_SKIRT, "mPelvis", "skirt", "skirt_main_param_list", "skirt_main_tab", LLVector3d(0.f, 0.f, -0.5f), LLVector3d(-1.6f, 0.15f, -0.5f),SEX_BOTH));
    309. 

  309.         addEntry(SUBPART_GLOVES, new SubpartEntry(SUBPART_GLOVES, "mTorso", "gloves", "gloves_main_param_list", "gloves_main_tab", LLVector3d(0.f, 0.f, 0.f), LLVector3d(-1.f, 0.15f, 0.f),SEX_BOTH));
    310. 

  310.         addEntry(SUBPART_UNDERSHIRT, new SubpartEntry(SUBPART_UNDERSHIRT, "mTorso", "undershirt", "undershirt_main_param_list", "undershirt_main_tab", LLVector3d(0.f, 0.f, 0.3f), LLVector3d(-1.f, 0.15f, 0.3f),SEX_BOTH));
    311. 

  311.         addEntry(SUBPART_UNDERPANTS, new SubpartEntry(SUBPART_UNDERPANTS, "mPelvis", "underpants", "underpants_main_param_list", "underpants_main_tab", LLVector3d(0.f, 0.f, -0.5f), LLVector3d(-1.6f, 0.15f, -0.5f),SEX_BOTH));
    312. 

  312.         addEntry(SUBPART_ALPHA, new SubpartEntry(SUBPART_ALPHA, "mPelvis", "alpha", "alpha_main_param_list", "alpha_main_tab", LLVector3d(0.f, 0.f, 0.1f), LLVector3d(-2.5f, 0.5f, 0.8f),SEX_BOTH));
    313. 

  313.         addEntry(SUBPART_TATTOO, new SubpartEntry(SUBPART_TATTOO, "mPelvis", "tattoo", "tattoo_main_param_list", "tattoo_main_tab", LLVector3d(0.f, 0.f, 0.1f), LLVector3d(-2.5f, 0.5f, 0.8f),SEX_BOTH));
    314. 

  314.         addEntry(SUBPART_PHYSICS_BREASTS_UPDOWN, new SubpartEntry(SUBPART_PHYSICS_BREASTS_UPDOWN, "mTorso", "physics_breasts_updown", "physics_breasts_updown_param_list", "physics_breasts_updown_tab", LLVector3d(0.f, 0.f, 0.3f), LLVector3d(0.f, 0.f, 0.f),SEX_FEMALE));
    315. 

  315.         addEntry(SUBPART_PHYSICS_BREASTS_INOUT, new SubpartEntry(SUBPART_PHYSICS_BREASTS_INOUT, "mTorso", "physics_breasts_inout", "physics_breasts_inout_param_list", "physics_breasts_inout_tab", LLVector3d(0.f, 0.f, 0.3f), LLVector3d(0.f, 0.f, 0.f),SEX_FEMALE));
    316. 

  316.         addEntry(SUBPART_PHYSICS_BREASTS_LEFTRIGHT, new SubpartEntry(SUBPART_PHYSICS_BREASTS_LEFTRIGHT, "mTorso", "physics_breasts_leftright", "physics_breasts_leftright_param_list", "physics_breasts_leftright_tab", LLVector3d(0.f, 0.f, 0.3f), LLVector3d(0.f, 0.f, 0.f),SEX_FEMALE));
    317. 

  317.         addEntry(SUBPART_PHYSICS_BELLY_UPDOWN, new SubpartEntry(SUBPART_PHYSICS_BELLY_UPDOWN, "mTorso", "physics_belly_updown", "physics_belly_updown_param_list", "physics_belly_updown_tab", LLVector3d(0.f, 0.f, 0.3f), LLVector3d(0.f, 0.f, 0.f),SEX_BOTH));
    318. 

  318.         addEntry(SUBPART_PHYSICS_BUTT_UPDOWN, new SubpartEntry(SUBPART_PHYSICS_BUTT_UPDOWN, "mTorso", "physics_butt_updown", "physics_butt_updown_param_list", "physics_butt_updown_tab", LLVector3d(0.f, 0.f, 0.3f), LLVector3d(0.f, 0.f, 0.f),SEX_BOTH));
    319. 

  319.         addEntry(SUBPART_PHYSICS_BUTT_LEFTRIGHT, new SubpartEntry(SUBPART_PHYSICS_BUTT_LEFTRIGHT, "mTorso", "physics_butt_leftright", "physics_butt_leftright_param_list", "physics_butt_leftright_tab", LLVector3d(0.f, 0.f, 0.f), LLVector3d(0.f, 0.f, 0.f),SEX_BOTH));
    320. 

  320.         addEntry(SUBPART_PHYSICS_ADVANCED, new SubpartEntry(SUBPART_PHYSICS_ADVANCED, "mTorso", "physics_advanced", "physics_advanced_param_list", "physics_advanced_tab", LLVector3d(0.f, 0.f, 0.f), LLVector3d(0.f, 0.f, 0.f),SEX_BOTH));
    321. 

  321. }
    322. 

  322. 

  323. LLEditWearableDictionary::SubpartEntry::SubpartEntry(ESubpart part,
    324. 

  324.                                          const std::string &joint,
    325. 

  325.                                          const std::string &edit_group,
    326. 

  326.                                          const std::string &param_list,
    327. 

  327.                                          const std::string &accordion_tab,
    328. 

  328.                                          const LLVector3d  &target_offset,
    329. 

  329.                                          const LLVector3d  &camera_offset,
    330. 

  330.                                          const ESex        &sex) :
    331. 

  331.         LLDictionaryEntry(edit_group),
    332. 

  332.         mSubpart(part),
    333. 

  333.         mTargetJoint(joint),
    334. 

  334.         mEditGroup(edit_group),
    335. 

  335.         mParamList(param_list),
    336. 

  336.         mAccordionTab(accordion_tab),
    337. 

  337.         mTargetOffset(target_offset),
    338. 

  338.         mCameraOffset(camera_offset),
    339. 

  339.         mSex(sex)
    340. 

  340. {
    341. 

  341. }
    342. 

  342. 

  343. LLEditWearableDictionary::ColorSwatchCtrls::ColorSwatchCtrls()
    344. 

  344. {
    345. 

  345.         addEntry ( TEX_UPPER_SHIRT,  new PickerControlEntry (TEX_UPPER_SHIRT, "Color/Tint" ));
    346. 

  346.         addEntry ( TEX_LOWER_PANTS,  new PickerControlEntry (TEX_LOWER_PANTS, "Color/Tint" ));
    347. 

  347.         addEntry ( TEX_LOWER_SHOES,  new PickerControlEntry (TEX_LOWER_SHOES, "Color/Tint" ));
    348. 

  348.         addEntry ( TEX_LOWER_SOCKS,  new PickerControlEntry (TEX_LOWER_SOCKS, "Color/Tint" ));
    349. 

  349.         addEntry ( TEX_UPPER_JACKET, new PickerControlEntry (TEX_UPPER_JACKET, "Color/Tint" ));
    350. 

  350.         addEntry ( TEX_SKIRT,  new PickerControlEntry (TEX_SKIRT, "Color/Tint" ));
    351. 

  351.         addEntry ( TEX_UPPER_GLOVES, new PickerControlEntry (TEX_UPPER_GLOVES, "Color/Tint" ));
    352. 

  352.         addEntry ( TEX_UPPER_UNDERSHIRT, new PickerControlEntry (TEX_UPPER_UNDERSHIRT, "Color/Tint" ));
    353. 

  353.         addEntry ( TEX_LOWER_UNDERPANTS, new PickerControlEntry (TEX_LOWER_UNDERPANTS, "Color/Tint" ));
    354. 

  354.         addEntry ( TEX_HEAD_TATTOO, new PickerControlEntry(TEX_HEAD_TATTOO, "Color/Tint" ));
    355. 

  355. }
    356. 

  356. 

  357. LLEditWearableDictionary::TextureCtrls::TextureCtrls()
    358. 

  358. {
    359. 

  359.         addEntry ( TEX_HEAD_BODYPAINT,  new PickerControlEntry (TEX_HEAD_BODYPAINT,  "Head", LLUUID::null, TRUE ));
    360. 

  360.         addEntry ( TEX_UPPER_BODYPAINT, new PickerControlEntry (TEX_UPPER_BODYPAINT, "Upper Body", LLUUID::null, TRUE ));
    361. 

  361.         addEntry ( TEX_LOWER_BODYPAINT, new PickerControlEntry (TEX_LOWER_BODYPAINT, "Lower Body", LLUUID::null, TRUE ));
    362. 

  362.         addEntry ( TEX_HAIR, new PickerControlEntry (TEX_HAIR, "Texture", LLUUID( gSavedSettings.getString( "UIImgDefaultHairUUID" ) ), FALSE ));
    363. 

  363.         addEntry ( TEX_EYES_IRIS, new PickerControlEntry (TEX_EYES_IRIS, "Iris", LLUUID( gSavedSettings.getString( "UIImgDefaultEyesUUID" ) ), FALSE ));
    364. 

  364.         addEntry ( TEX_UPPER_SHIRT, new PickerControlEntry (TEX_UPPER_SHIRT, "Fabric", LLUUID( gSavedSettings.getString( "UIImgDefaultShirtUUID" ) ), FALSE ));
    365. 

  365.         addEntry ( TEX_LOWER_PANTS, new PickerControlEntry (TEX_LOWER_PANTS, "Fabric", LLUUID( gSavedSettings.getString( "UIImgDefaultPantsUUID" ) ), FALSE ));
    366. 

  366.         addEntry ( TEX_LOWER_SHOES, new PickerControlEntry (TEX_LOWER_SHOES, "Fabric", LLUUID( gSavedSettings.getString( "UIImgDefaultShoesUUID" ) ), FALSE ));
    367. 

  367.         addEntry ( TEX_LOWER_SOCKS, new PickerControlEntry (TEX_LOWER_SOCKS, "Fabric", LLUUID( gSavedSettings.getString( "UIImgDefaultSocksUUID" ) ), FALSE ));
    368. 

  368.         addEntry ( TEX_UPPER_JACKET, new PickerControlEntry (TEX_UPPER_JACKET, "Upper Fabric", LLUUID( gSavedSettings.getString( "UIImgDefaultJacketUUID" ) ), FALSE ));
    369. 

  369.         addEntry ( TEX_LOWER_JACKET, new PickerControlEntry (TEX_LOWER_JACKET, "Lower Fabric", LLUUID( gSavedSettings.getString( "UIImgDefaultJacketUUID" ) ), FALSE ));
    370. 

  370.         addEntry ( TEX_SKIRT, new PickerControlEntry (TEX_SKIRT, "Fabric", LLUUID( gSavedSettings.getString( "UIImgDefaultSkirtUUID" ) ), FALSE ));
    371. 

  371.         addEntry ( TEX_UPPER_GLOVES, new PickerControlEntry (TEX_UPPER_GLOVES, "Fabric", LLUUID( gSavedSettings.getString( "UIImgDefaultGlovesUUID" ) ), FALSE ));
    372. 

  372.         addEntry ( TEX_UPPER_UNDERSHIRT, new PickerControlEntry (TEX_UPPER_UNDERSHIRT, "Fabric", LLUUID( gSavedSettings.getString( "UIImgDefaultUnderwearUUID" ) ), FALSE ));
    373. 

  373.         addEntry ( TEX_LOWER_UNDERPANTS, new PickerControlEntry (TEX_LOWER_UNDERPANTS, "Fabric", LLUUID( gSavedSettings.getString( "UIImgDefaultUnderwearUUID" ) ), FALSE ));
    374. 

  374.         addEntry ( TEX_LOWER_ALPHA, new PickerControlEntry (TEX_LOWER_ALPHA, "Lower Alpha", LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) ), TRUE ));
    375. 

  375.         addEntry ( TEX_UPPER_ALPHA, new PickerControlEntry (TEX_UPPER_ALPHA, "Upper Alpha", LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) ), TRUE ));
    376. 

  376.         addEntry ( TEX_HEAD_ALPHA, new PickerControlEntry (TEX_HEAD_ALPHA, "Head Alpha", LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) ), TRUE ));
    377. 

  377.         addEntry ( TEX_EYES_ALPHA, new PickerControlEntry (TEX_EYES_ALPHA, "Eye Alpha", LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) ), TRUE ));
    378. 

  378.         addEntry ( TEX_HAIR_ALPHA, new PickerControlEntry (TEX_HAIR_ALPHA, "Hair Alpha", LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) ), TRUE ));
    379. 

  379.         addEntry ( TEX_LOWER_TATTOO, new PickerControlEntry (TEX_LOWER_TATTOO, "Lower Tattoo", LLUUID::null, TRUE ));
    380. 

  380.         addEntry ( TEX_UPPER_TATTOO, new PickerControlEntry (TEX_UPPER_TATTOO, "Upper Tattoo", LLUUID::null, TRUE ));
    381. 

  381.         addEntry ( TEX_HEAD_TATTOO, new PickerControlEntry (TEX_HEAD_TATTOO, "Head Tattoo", LLUUID::null, TRUE ));
    382. 

  382. }
    383. 

  383. 

  384. LLEditWearableDictionary::PickerControlEntry::PickerControlEntry(ETextureIndex tex_index,
    385. 

  385.                                          const std::string name,
    386. 

  386.                                          const LLUUID default_image_id,
    387. 

  387.                                          const bool allow_no_texture) :
    388. 

  388.         LLDictionaryEntry(name),
    389. 

  389.         mTextureIndex(tex_index),
    390. 

  390.         mControlName(name),
    391. 

  391.         mDefaultImageId(default_image_id),
    392. 

  392.         mAllowNoTexture(allow_no_texture)
    393. 

  393. {
    394. 

  394. }
    395. 

  395. 

  396. /**
    397. 

  397.  * Class to prevent hack in LLButton's constructor and use paddings declared in xml.
    398. 

  398.  */
    399. 

  399. class LLLabledBackButton : public LLButton
    400. 

  400. {
    401. 

  401. public:
    402. 

  402.         struct Params : public LLInitParam::Block<Params, LLButton::Params>
    403. 

  403.         {
    404. 

  404.                 Params() {}
    405. 

  405.         };
    406. 

  406. protected:
    407. 

  407.         friend class LLUICtrlFactory;
    408. 

  408.         LLLabledBackButton(const Params&);
    409. 

  409. };
    410. 

  410. 

  411. static LLDefaultChildRegistry::Register<LLLabledBackButton> labeled_back_btn("labeled_back_button");
    412. 

  412. 

  413. LLLabledBackButton::LLLabledBackButton(const Params& params)
    414. 

  414. : LLButton(params)
    415. 

  415. {
    416. 

  416.         // override hack in LLButton's constructor to use paddings have been set in xml
    417. 

  417.         setLeftHPad(params.pad_left);
    418. 

  418.         setRightHPad(params.pad_right);
    419. 

  419. }
    420. 

  420. 

  421. // Helper functions.
    422. 

  422. static const texture_vec_t null_texture_vec;
    423. 

  423. 

  424. // Specializations of this template function return a vector of texture indexes of particular control type
    425. 

  425. // (i.e. LLColorSwatchCtrl or LLTextureCtrl) which are contained in given WearableEntry.
    426. 

  426. template <typename T>
    427. 

  427. const texture_vec_t&
    428. 

  428. get_pickers_indexes(const LLEditWearableDictionary::WearableEntry *wearable_entry) { return null_texture_vec; }
    429. 

  429. 

  430. // Specializations of this template function return picker control entry for particular control type.
    431. 

  431. template <typename T>
    432. 

  432. const LLEditWearableDictionary::PickerControlEntry*
    433. 

  433. get_picker_entry (const ETextureIndex index) { return NULL; }
    434. 

  434. 

  435. typedef boost::function<void(LLPanel* panel, const LLEditWearableDictionary::PickerControlEntry*)> function_t;
    436. 

  436. 

  437. typedef struct PickerControlEntryNamePredicate
    438. 

  438. {
    439. 

  439.         PickerControlEntryNamePredicate(const std::string name) : mName (name) {};
    440. 

  440.         bool operator()(const LLEditWearableDictionary::PickerControlEntry* entry) const
    441. 

  441.         {
    442. 

  442.                 return (entry && entry->mName == mName);
    443. 

  443.         }
    444. 

  444. private:
    445. 

  445.         const std::string mName;
    446. 

  446. } PickerControlEntryNamePredicate;
    447. 

  447. 

  448. // A full specialization of get_pickers_indexes for LLColorSwatchCtrl
    449. 

  449. template <>
    450. 

  450. const texture_vec_t&
    451. 

  451. get_pickers_indexes<LLColorSwatchCtrl> (const LLEditWearableDictionary::WearableEntry *wearable_entry)
    452. 

  452. {
    453. 

  453.         if (!wearable_entry)
    454. 

  454.         {
    455. 

  455.                 llwarns << "could not get LLColorSwatchCtrl indexes for null wearable entry." << llendl;
    456. 

  456.                 return null_texture_vec;
    457. 

  457.         }
    458. 

  458.         return wearable_entry->mColorSwatchCtrls;
    459. 

  459. }
    460. 

  460. 

  461. // A full specialization of get_pickers_indexes for LLTextureCtrl
    462. 

  462. template <>
    463. 

  463. const texture_vec_t&
    464. 

  464. get_pickers_indexes<LLTextureCtrl> (const LLEditWearableDictionary::WearableEntry *wearable_entry)
    465. 

  465. {
    466. 

  466.         if (!wearable_entry)
    467. 

  467.         {
    468. 

  468.                 llwarns << "could not get LLTextureCtrl indexes for null wearable entry." << llendl;
    469. 

  469.                 return null_texture_vec;
    470. 

  470.         }
    471. 

  471.         return wearable_entry->mTextureCtrls;
    472. 

  472. }
    473. 

  473. 

  474. // A full specialization of get_picker_entry for LLColorSwatchCtrl
    475. 

  475. template <>
    476. 

  476. const LLEditWearableDictionary::PickerControlEntry*
    477. 

  477. get_picker_entry<LLColorSwatchCtrl> (const ETextureIndex index)
    478. 

  478. {
    479. 

  479.         return LLEditWearableDictionary::getInstance()->getColorSwatch(index);
    480. 

  480. }
    481. 

  481. 

  482. // A full specialization of get_picker_entry for LLTextureCtrl
    483. 

  483. template <>
    484. 

  484. const LLEditWearableDictionary::PickerControlEntry*
    485. 

  485. get_picker_entry<LLTextureCtrl> (const ETextureIndex index)
    486. 

  486. {
    487. 

  487.         return LLEditWearableDictionary::getInstance()->getTexturePicker(index);
    488. 

  488. }
    489. 

  489. 

  490. template <typename CtrlType, class Predicate>
    491. 

  491. const LLEditWearableDictionary::PickerControlEntry*
    492. 

  492. find_picker_ctrl_entry_if(LLWearableType::EType type, const Predicate pred)
    493. 

  493. {
    494. 

  494.         const LLEditWearableDictionary::WearableEntry *wearable_entry
    495. 

  495.                 = LLEditWearableDictionary::getInstance()->getWearable(type);
    496. 

  496.         if (!wearable_entry)
    497. 

  497.         {
    498. 

  498.                 llwarns << "could not get wearable dictionary entry for wearable of type: " << type << llendl;
    499. 

  499.                 return NULL;
    500. 

  500.         }
    501. 

  501.         const texture_vec_t& indexes = get_pickers_indexes<CtrlType>(wearable_entry);
    502. 

  502.         for (texture_vec_t::const_iterator
    503. 

  503.                          iter = indexes.begin(),
    504. 

  504.                          iter_end = indexes.end();
    505. 

  505.                  iter != iter_end; ++iter)
    506. 

  506.         {
    507. 

  507.                 const ETextureIndex te = *iter;
    508. 

  508.                 const LLEditWearableDictionary::PickerControlEntry*     entry
    509. 

  509.                         = get_picker_entry<CtrlType>(te);
    510. 

  510.                 if (!entry)
    511. 

  511.                 {
    512. 

  512.                         llwarns << "could not get picker dictionary entry (" << te << ") for wearable of type: " << type << llendl;
    513. 

  513.                         continue;
    514. 

  514.                 }
    515. 

  515.                 if (pred(entry))
    516. 

  516.                 {
    517. 

  517.                         return entry;
    518. 

  518.                 }
    519. 

  519.         }
    520. 

  520.         return NULL;
    521. 

  521. }
    522. 

  522. 

  523. template <typename CtrlType>
    524. 

  524. void
    525. 

  525. for_each_picker_ctrl_entry(LLPanel* panel, LLWearableType::EType type, function_t fun)
    526. 

  526. {
    527. 

  527.         if (!panel)
    528. 

  528.         {
    529. 

  529.                 llwarns << "the panel wasn't passed for wearable of type: " << type << llendl;
    530. 

  530.                 return;
    531. 

  531.         }
    532. 

  532.         const LLEditWearableDictionary::WearableEntry *wearable_entry
    533. 

  533.                 = LLEditWearableDictionary::getInstance()->getWearable(type);
    534. 

  534.         if (!wearable_entry)
    535. 

  535.         {
    536. 

  536.                 llwarns << "could not get wearable dictionary entry for wearable of type: " << type << llendl;
    537. 

  537.                 return;
    538. 

  538.         }
    539. 

  539.         const texture_vec_t& indexes = get_pickers_indexes<CtrlType>(wearable_entry);
    540. 

  540.         for (texture_vec_t::const_iterator
    541. 

  541.                          iter = indexes.begin(),
    542. 

  542.                          iter_end = indexes.end();
    543. 

  543.                  iter != iter_end; ++iter)
    544. 

  544.         {
    545. 

  545.                 const ETextureIndex te = *iter;
    546. 

  546.                 const LLEditWearableDictionary::PickerControlEntry*     entry
    547. 

  547.                         = get_picker_entry<CtrlType>(te);
    548. 

  548.                 if (!entry)
    549. 

  549.                 {
    550. 

  550.                         llwarns << "could not get picker dictionary entry (" << te << ") for wearable of type: " << type << llendl;
    551. 

  551.                         continue;
    552. 

  552.                 }
    553. 

  553.                 fun (panel, entry);
    554. 

  554.         }
    555. 

  555. }
    556. 

  556. 

  557. // The helper functions for pickers management
    558. 

  558. static void init_color_swatch_ctrl(LLPanelEditWearable* self, LLPanel* panel, const LLEditWearableDictionary::PickerControlEntry* entry)
    559. 

  559. {
    560. 

  560.         LLColorSwatchCtrl* color_swatch_ctrl = panel->getChild<LLColorSwatchCtrl>(entry->mControlName);
    561. 

  561.         if (color_swatch_ctrl)
    562. 

  562.         {
    563. 

  563.                 // Can't get the color from the wearable here, since the wearable may not be set when this is called.
    564. 

  564.                 color_swatch_ctrl->setOriginal(LLColor4::white);
    565. 

  565.         }
    566. 

  566. }
    567. 

  567. 

  568. static void init_texture_ctrl(LLPanelEditWearable* self, LLPanel* panel, const LLEditWearableDictionary::PickerControlEntry* entry)
    569. 

  569. {
    570. 

  570.         LLTextureCtrl* texture_ctrl = panel->getChild<LLTextureCtrl>(entry->mControlName);
    571. 

  571.         if (texture_ctrl)
    572. 

  572.         {
    573. 

  573.                 texture_ctrl->setDefaultImageAssetID(entry->mDefaultImageId);
    574. 

  574.                 texture_ctrl->setAllowNoTexture(entry->mAllowNoTexture);
    575. 

  575.                 // Don't allow (no copy) or (notransfer) textures to be selected.
    576. 

  576.                 texture_ctrl->setImmediateFilterPermMask(PERM_NONE);
    577. 

  577.                 texture_ctrl->setNonImmediateFilterPermMask(PERM_NONE);
    578. 

  578.         }
    579. 

  579. }
    580. 

  580. 

  581. static void update_color_swatch_ctrl(LLPanelEditWearable* self, LLPanel* panel, const LLEditWearableDictionary::PickerControlEntry* entry)
    582. 

  582. {
    583. 

  583.         LLColorSwatchCtrl* color_swatch_ctrl = panel->getChild<LLColorSwatchCtrl>(entry->mControlName);
    584. 

  584.         if (color_swatch_ctrl)
    585. 

  585.         {
    586. 

  586.                 color_swatch_ctrl->set(self->getWearable()->getClothesColor(entry->mTextureIndex));
    587. 

  587.                 color_swatch_ctrl->closeFloaterColorPicker();
    588. 

  588.         }
    589. 

  589. }
    590. 

  590. 

  591. static void update_texture_ctrl(LLPanelEditWearable* self, LLPanel* panel, const LLEditWearableDictionary::PickerControlEntry* entry)
    592. 

  592. {
    593. 

  593.         LLTextureCtrl* texture_ctrl = panel->getChild<LLTextureCtrl>(entry->mControlName);
    594. 

  594.         if (texture_ctrl)
    595. 

  595.         {
    596. 

  596.                 LLUUID new_id;
    597. 

  597.                 LLLocalTextureObject *lto = self->getWearable()->getLocalTextureObject(entry->mTextureIndex);
    598. 

  598.                 if( lto && (lto->getID() != IMG_DEFAULT_AVATAR) )
    599. 

  599.                 {
    600. 

  600.                         new_id = lto->getID();
    601. 

  601.                 }
    602. 

  602.                 else
    603. 

  603.                 {
    604. 

  604.                         new_id = LLUUID::null;
    605. 

  605.                 }
    606. 

  606.                 LLUUID old_id = texture_ctrl->getImageAssetID();
    607. 

  607.                 if (old_id != new_id)
    608. 

  608.                 {
    609. 

  609.                         // texture has changed, close the floater to avoid DEV-22461
    610. 

  610.                         texture_ctrl->closeDependentFloater();
    611. 

  611.                 }
    612. 

  612.                 texture_ctrl->setImageAssetID(new_id);
    613. 

  613.         }
    614. 

  614. }
    615. 

  615. 

  616. static void set_enabled_color_swatch_ctrl(bool enabled, LLPanel* panel, const LLEditWearableDictionary::PickerControlEntry* entry)
    617. 

  617. {
    618. 

  618.         LLColorSwatchCtrl* color_swatch_ctrl = panel->getChild<LLColorSwatchCtrl>(entry->mControlName);
    619. 

  619.         if (color_swatch_ctrl)
    620. 

  620.         {
    621. 

  621.                 color_swatch_ctrl->setEnabled(enabled);
    622. 

  622.         }
    623. 

  623. }
    624. 

  624. 

  625. static void set_enabled_texture_ctrl(bool enabled, LLPanel* panel, const LLEditWearableDictionary::PickerControlEntry* entry)
    626. 

  626. {
    627. 

  627.         LLTextureCtrl* texture_ctrl = panel->getChild<LLTextureCtrl>(entry->mControlName);
    628. 

  628.         if (texture_ctrl)
    629. 

  629.         {
    630. 

  630.                 texture_ctrl->setEnabled(enabled);
    631. 

  631.         }
    632. 

  632. }
    633. 

  633. 

  634. // LLPanelEditWearable
    635. 

  635. 

  636. LLPanelEditWearable::LLPanelEditWearable()
    637. 

  637.         : LLPanel()
    638. 

  638.         , mWearablePtr(NULL)
    639. 

  639.         , mWearableItem(NULL)
    640. 

  640. {
    641. 

  641.         mCommitCallbackRegistrar.add("ColorSwatch.Commit", boost::bind(&LLPanelEditWearable::onColorSwatchCommit, this, _1));
    642. 

  642.         mCommitCallbackRegistrar.add("TexturePicker.Commit", boost::bind(&LLPanelEditWearable::onTexturePickerCommit, this, _1));
    643. 

  643. }
    644. 

  644. 

  645. //virtual
    646. 

  646. LLPanelEditWearable::~LLPanelEditWearable()
    647. 

  647. {
    648. 

  648. 

  649. }
    650. 

  650. 

  651. bool LLPanelEditWearable::changeHeightUnits(const LLSD& new_value)
    652. 

  652. {
    653. 

  653.         updateMetricLayout( new_value.asBoolean() );
    654. 

  654.         updateTypeSpecificControls(LLWearableType::WT_SHAPE);
    655. 

  655.         return true;
    656. 

  656. }
    657. 

  657. 

  658. void LLPanelEditWearable::updateMetricLayout(BOOL new_value)
    659. 

  659. {
    660. 

  660.         LLUIString current_metric, replacment_metric;
    661. 

  661.         current_metric = new_value ? mMeters : mFeet;
    662. 

  662.         replacment_metric = new_value ? mFeet : mMeters;
    663. 

  663.         mHeigthValue.setArg( "[METRIC1]", current_metric.getString() );
    664. 

  664.         mReplacementMetricUrl.setArg( "[URL_METRIC2]", std::string("[secondlife:///app/metricsystem ") + replacment_metric.getString() + std::string("]"));
    665. 

  665. }
    666. 

  666. 

  667. void LLPanelEditWearable::updateAvatarHeightLabel()
    668. 

  668. {
    669. 

  669.         mTxtAvatarHeight->setText(LLStringUtil::null);
    670. 

  670.         LLStyle::Params param;
    671. 

  671.         param.color = mAvatarHeigthLabelColor;
    672. 

  672.         mTxtAvatarHeight->appendText(mHeigth, false, param);
    673. 

  673.         param.color = mAvatarHeigthValueLabelColor;
    674. 

  674.         mTxtAvatarHeight->appendText(mHeigthValue, false, param);
    675. 

  675.         param.color = mAvatarHeigthLabelColor; // using mAvatarHeigthLabelColor for '/' separator
    676. 

  676.         mTxtAvatarHeight->appendText(" / ", false, param);
    677. 

  677.         mTxtAvatarHeight->appendText(this->mReplacementMetricUrl, false, param);
    678. 

  678. }
    679. 

  679. 

  680. void LLPanelEditWearable::onWearablePanelVisibilityChange(const LLSD &in_visible_chain, LLAccordionCtrl* accordion_ctrl)
    681. 

  681. {
    682. 

  682.         if (in_visible_chain.asBoolean() && accordion_ctrl != NULL)
    683. 

  683.         {
    684. 

  684.                 accordion_ctrl->expandDefaultTab();
    685. 

  685.         }
    686. 

  686. }
    687. 

  687. 

  688. void LLPanelEditWearable::setWearablePanelVisibilityChangeCallback(LLPanel* bodypart_panel)
    689. 

  689. {
    690. 

  690.         if (bodypart_panel != NULL)
    691. 

  691.         {
    692. 

  692.                 LLAccordionCtrl* accordion_ctrl = bodypart_panel->getChild<LLAccordionCtrl>("wearable_accordion");
    693. 

  693. 

  694.                 if (accordion_ctrl != NULL)
    695. 

  695.                 {
    696. 

  696.                         bodypart_panel->setVisibleCallback(
    697. 

  697.                                         boost::bind(&LLPanelEditWearable::onWearablePanelVisibilityChange, this, _2, accordion_ctrl));
    698. 

  698.                 }
    699. 

  699.                 else
    700. 

  700.                 {
    701. 

  701.                         llwarns << "accordion_ctrl is NULL" << llendl;
    702. 

  702.                 }
    703. 

  703.         }
    704. 

  704.         else
    705. 

  705.         {
    706. 

  706.                 llwarns << "bodypart_panel is NULL" << llendl;
    707. 

  707.         }
    708. 

  708. }
    709. 

  709. 

  710. // virtual 
    711. 

  711. BOOL LLPanelEditWearable::postBuild()
    712. 

  712. {
    713. 

  713.         // buttons
    714. 

  714.         mBtnRevert = getChild<LLButton>("revert_button");
    715. 

  715.         mBtnRevert->setClickedCallback(boost::bind(&LLPanelEditWearable::onRevertButtonClicked, this));
    716. 

  716. 

  717.         mBtnBack = getChild<LLButton>("back_btn");
    718. 

  718.         mBackBtnLabel = mBtnBack->getLabelUnselected();
    719. 

  719.         mBtnBack->setLabel(LLStringUtil::null);
    720. 

  720.         // handled at appearance panel level?
    721. 

  721.         //mBtnBack->setClickedCallback(boost::bind(&LLPanelEditWearable::onBackButtonClicked, this));
    722. 

  722. 

  723.         mNameEditor = getChild<LLLineEditor>("description");
    724. 

  724. 

  725.         mPanelTitle = getChild<LLTextBox>("edit_wearable_title");
    726. 

  726.         mDescTitle = getChild<LLTextBox>("description_text");
    727. 

  727. 

  728.         getChild<LLRadioGroup>("sex_radio")->setCommitCallback(boost::bind(&LLPanelEditWearable::onCommitSexChange, this));
    729. 

  729.         getChild<LLButton>("save_as_button")->setCommitCallback(boost::bind(&LLPanelEditWearable::onSaveAsButtonClicked, this));
    730. 

  730. 

  731.         // The following panels will be shown/hidden based on what wearable we're editing
    732. 

  732.         // body parts
    733. 

  733.         mPanelShape = getChild<LLPanel>("edit_shape_panel");
    734. 

  734.         mPanelSkin = getChild<LLPanel>("edit_skin_panel");
    735. 

  735.         mPanelEyes = getChild<LLPanel>("edit_eyes_panel");
    736. 

  736.         mPanelHair = getChild<LLPanel>("edit_hair_panel");
    737. 

  737. 

  738.         // Setting the visibility callback is applied only to the bodyparts panel
    739. 

  739.         // because currently they are the only ones whose 'wearable_accordion' has
    740. 

  740.         // multiple accordion tabs (see EXT-8164 for details).
    741. 

  741.         setWearablePanelVisibilityChangeCallback(mPanelShape);
    742. 

  742.         setWearablePanelVisibilityChangeCallback(mPanelSkin);
    743. 

  743.         setWearablePanelVisibilityChangeCallback(mPanelEyes);
    744. 

  744.         setWearablePanelVisibilityChangeCallback(mPanelHair);
    745. 

  745. 

  746.         //clothes
    747. 

  747.         mPanelShirt = getChild<LLPanel>("edit_shirt_panel");
    748. 

  748.         mPanelPants = getChild<LLPanel>("edit_pants_panel");
    749. 

  749.         mPanelShoes = getChild<LLPanel>("edit_shoes_panel");
    750. 

  750.         mPanelSocks = getChild<LLPanel>("edit_socks_panel");
    751. 

  751.         mPanelJacket = getChild<LLPanel>("edit_jacket_panel");
    752. 

  752.         mPanelGloves = getChild<LLPanel>("edit_gloves_panel");
    753. 

  753.         mPanelUndershirt = getChild<LLPanel>("edit_undershirt_panel");
    754. 

  754.         mPanelUnderpants = getChild<LLPanel>("edit_underpants_panel");
    755. 

  755.         mPanelSkirt = getChild<LLPanel>("edit_skirt_panel");
    756. 

  756.         mPanelAlpha = getChild<LLPanel>("edit_alpha_panel");
    757. 

  757.         mPanelTattoo = getChild<LLPanel>("edit_tattoo_panel");
    758. 

  758.         mPanelPhysics = getChild<LLPanel>("edit_physics_panel");
    759. 

  759. 

  760.         mTxtAvatarHeight = mPanelShape->getChild<LLTextBox>("avatar_height");
    761. 

  761. 

  762.         mWearablePtr = NULL;
    763. 

  763. 

  764.         configureAlphaCheckbox(LLVOAvatarDefines::TEX_LOWER_ALPHA, "lower alpha texture invisible");
    765. 

  765.         configureAlphaCheckbox(LLVOAvatarDefines::TEX_UPPER_ALPHA, "upper alpha texture invisible");
    766. 

  766.         configureAlphaCheckbox(LLVOAvatarDefines::TEX_HEAD_ALPHA, "head alpha texture invisible");
    767. 

  767.         configureAlphaCheckbox(LLVOAvatarDefines::TEX_EYES_ALPHA, "eye alpha texture invisible");
    768. 

  768.         configureAlphaCheckbox(LLVOAvatarDefines::TEX_HAIR_ALPHA, "hair alpha texture invisible");
    769. 

  769. 

  770.         // configure tab expanded callbacks
    771. 

  771.         for (U32 type_index = 0; type_index < (U32)LLWearableType::WT_COUNT; ++type_index)
    772. 

  772.         {
    773. 

  773.                 LLWearableType::EType type = (LLWearableType::EType) type_index;
    774. 

  774.                 const LLEditWearableDictionary::WearableEntry *wearable_entry = LLEditWearableDictionary::getInstance()->getWearable(type);
    775. 

  775.                 if (!wearable_entry)
    776. 

  776.                 {
    777. 

  777.                         llwarns << "could not get wearable dictionary entry for wearable of type: " << type << llendl;
    778. 

  778.                         continue;
    779. 

  779.                 }
    780. 

  780.                 U8 num_subparts = wearable_entry->mSubparts.size();
    781. 

  781.         
    782. 

  782.                 for (U8 index = 0; index < num_subparts; ++index)
    783. 

  783.                 {
    784. 

  784.                         // dive into data structures to get the panel we need
    785. 

  785.                         ESubpart subpart_e = wearable_entry->mSubparts[index];
    786. 

  786.                         const LLEditWearableDictionary::SubpartEntry *subpart_entry = LLEditWearableDictionary::getInstance()->getSubpart(subpart_e);
    787. 

  787.         
    788. 

  788.                         if (!subpart_entry)
    789. 

  789.                         {
    790. 

  790.                                 llwarns << "could not get wearable subpart dictionary entry for subpart: " << subpart_e << llendl;
    791. 

  791.                                 continue;
    792. 

  792.                         }
    793. 

  793.         
    794. 

  794.                         const std::string accordion_tab = subpart_entry->mAccordionTab;
    795. 

  795.         
    796. 

  796.                         LLAccordionCtrlTab *tab = getChild<LLAccordionCtrlTab>(accordion_tab);
    797. 

  797.         
    798. 

  798.                         if (!tab)
    799. 

  799.                         {
    800. 

  800.                                 llwarns << "could not get llaccordionctrltab from UI with name: " << accordion_tab << llendl;
    801. 

  801.                                 continue;
    802. 

  802.                         }
    803. 

  803.         
    804. 

  804.                         // initialize callback to ensure camera view changes appropriately.
    805. 

  805.                         tab->setDropDownStateChangedCallback(boost::bind(&LLPanelEditWearable::onTabExpandedCollapsed,this,_2,index));
    806. 

  806.                 }
    807. 

  807. 

  808.                 // initialize texture and color picker controls
    809. 

  809.                 for_each_picker_ctrl_entry <LLColorSwatchCtrl> (getPanel(type), type, boost::bind(init_color_swatch_ctrl, this, _1, _2));
    810. 

  810.                 for_each_picker_ctrl_entry <LLTextureCtrl>     (getPanel(type), type, boost::bind(init_texture_ctrl, this, _1, _2));
    811. 

  811.         }
    812. 

  812. 

  813.         // init all strings
    814. 

  814.         mMeters         = mPanelShape->getString("meters");
    815. 

  815.         mFeet           = mPanelShape->getString("feet");
    816. 

  816.         mHeigth         = mPanelShape->getString("height") + " ";
    817. 

  817.         mHeigthValue    = "[HEIGHT] [METRIC1]";
    818. 

  818.         mReplacementMetricUrl   = "[URL_METRIC2]";
    819. 

  819. 

  820.         std::string color = mPanelShape->getString("heigth_label_color");
    821. 

  821.         mAvatarHeigthLabelColor = LLUIColorTable::instance().getColor(color, LLColor4::green);
    822. 

  822.         color = mPanelShape->getString("heigth_value_label_color");
    823. 

  823.         mAvatarHeigthValueLabelColor = LLUIColorTable::instance().getColor(color, LLColor4::green);
    824. 

  824.         gSavedSettings.getControl("HeightUnits")->getSignal()->connect(boost::bind(&LLPanelEditWearable::changeHeightUnits, this, _2));
    825. 

  825.         updateMetricLayout(gSavedSettings.getBOOL("HeightUnits"));
    826. 

  826. 

  827.         return TRUE;
    828. 

  828. }
    829. 

  829. 

  830. // virtual 
    831. 

  831. // LLUICtrl
    832. 

  832. BOOL LLPanelEditWearable::isDirty() const
    833. 

  833. {
    834. 

  834.         BOOL isDirty = FALSE;
    835. 

  835.         if (mWearablePtr)
    836. 

  836.         {
    837. 

  837.                 if (mWearablePtr->isDirty() ||
    838. 

  838.                         mWearableItem->getName().compare(mNameEditor->getText()) != 0)
    839. 

  839.                 {
    840. 

  840.                         isDirty = TRUE;
    841. 

  841.                 }
    842. 

  842.         }
    843. 

  843.         return isDirty;
    844. 

  844. }
    845. 

  845. //virtual
    846. 

  846. void LLPanelEditWearable::draw()
    847. 

  847. {
    848. 

  848.         updateVerbs();
    849. 

  849.         if (getWearable() && getWearable()->getType() == LLWearableType::WT_SHAPE)
    850. 

  850.         {
    851. 

  851.                 //updating avatar height
    852. 

  852.                 updateTypeSpecificControls(LLWearableType::WT_SHAPE);
    853. 

  853.         }
    854. 

  854. 

  855.         LLPanel::draw();
    856. 

  856. }
    857. 

  857. 

  858. void LLPanelEditWearable::setVisible(BOOL visible)
    859. 

  859. {
    860. 

  860.         if (!visible)
    861. 

  861.         {
    862. 

  862.                 showWearable(mWearablePtr, FALSE);
    863. 

  863.         }
    864. 

  864.         LLPanel::setVisible(visible);
    865. 

  865. }
    866. 

  866. 

  867. void LLPanelEditWearable::setWearable(LLWearable *wearable, BOOL disable_camera_switch)
    868. 

  868. {
    869. 

  869.         showWearable(mWearablePtr, FALSE, disable_camera_switch);
    870. 

  870.         mWearablePtr = wearable;
    871. 

  871.         showWearable(mWearablePtr, TRUE, disable_camera_switch);
    872. 

  872. }
    873. 

  873. 

  874. 

  875. //static 
    876. 

  876. void LLPanelEditWearable::onRevertButtonClicked(void* userdata)
    877. 

  877. {
    878. 

  878.         LLPanelEditWearable *panel = (LLPanelEditWearable*) userdata;
    879. 

  879.         panel->revertChanges();
    880. 

  880. }
    881. 

  881. 

  882. void LLPanelEditWearable::onSaveAsButtonClicked()
    883. 

  883. {
    884. 

  884.         LLSD args;
    885. 

  885.         args["DESC"] = mNameEditor->getText();
    886. 

  886. 

  887.         LLNotificationsUtil::add("SaveWearableAs", args, LLSD(), boost::bind(&LLPanelEditWearable::saveAsCallback, this, _1, _2));
    888. 

  888. }
    889. 

  889. 

  890. void LLPanelEditWearable::saveAsCallback(const LLSD& notification, const LLSD& response)
    891. 

  891. {
    892. 

  892.         S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
    893. 

  893.         if (0 == option)
    894. 

  894.         {
    895. 

  895.                 std::string wearable_name = response["message"].asString();
    896. 

  896.                 LLStringUtil::trim(wearable_name);
    897. 

  897.                 if( !wearable_name.empty() )
    898. 

  898.                 {
    899. 

  899.                         mNameEditor->setText(wearable_name);
    900. 

  900.                         saveChanges(true);
    901. 

  901.                 }
    902. 

  902.         }
    903. 

  903. }
    904. 

  904. 

  905. void LLPanelEditWearable::onCommitSexChange()
    906. 

  906. {
    907. 

  907.         if (!isAgentAvatarValid()) return;
    908. 

  908. 

  909.         LLWearableType::EType type = mWearablePtr->getType();
    910. 

  910.         U32 index = gAgentWearables.getWearableIndex(mWearablePtr);
    911. 

  911. 

  912.         if( !gAgentWearables.isWearableModifiable(type, index))
    913. 

  913.         {
    914. 

  914.                 return;
    915. 

  915.         }
    916. 

  916. 

  917.         LLViewerVisualParam* param = static_cast<LLViewerVisualParam*>(gAgentAvatarp->getVisualParam( "male" ));
    918. 

  918.         if( !param )
    919. 

  919.         {
    920. 

  920.                 return;
    921. 

  921.         }
    922. 

  922. 

  923.         bool is_new_sex_male = (gSavedSettings.getU32("AvatarSex") ? SEX_MALE : SEX_FEMALE) == SEX_MALE;
    924. 

  924.         LLWearable*     wearable = gAgentWearables.getWearable(type, index);
    925. 

  925.         if (wearable)
    926. 

  926.         {
    927. 

  927.                 wearable->setVisualParamWeight(param->getID(), is_new_sex_male, FALSE);
    928. 

  928.         }
    929. 

  929.         param->setWeight( is_new_sex_male, FALSE );
    930. 

  930. 

  931.         gAgentAvatarp->updateSexDependentLayerSets( FALSE );
    932. 

  932. 

  933.         gAgentAvatarp->updateVisualParams();
    934. 

  934. 

  935.         updateScrollingPanelUI();
    936. 

  936. }
    937. 

  937. 

  938. void LLPanelEditWearable::onTexturePickerCommit(const LLUICtrl* ctrl)
    939. 

  939. {
    940. 

  940.         const LLTextureCtrl* texture_ctrl = dynamic_cast<const LLTextureCtrl*>(ctrl);
    941. 

  941.         if (!texture_ctrl)
    942. 

  942.         {
    943. 

  943.                 llwarns << "got commit signal from not LLTextureCtrl." << llendl;
    944. 

  944.                 return;
    945. 

  945.         }
    946. 

  946. 

  947.         if (getWearable())
    948. 

  948.         {
    949. 

  949.                 LLWearableType::EType type = getWearable()->getType();
    950. 

  950.                 const PickerControlEntryNamePredicate name_pred(texture_ctrl->getName());
    951. 

  951.                 const LLEditWearableDictionary::PickerControlEntry* entry
    952. 

  952.                         = find_picker_ctrl_entry_if<LLTextureCtrl, PickerControlEntryNamePredicate>(type, name_pred);
    953. 

  953.                 if (entry)
    954. 

  954.                 {
    955. 

  955.                         // Set the new version
    956. 

  956.                         LLViewerFetchedTexture* image = LLViewerTextureManager::getFetchedTexture(texture_ctrl->getImageAssetID());
    957. 

  957.                         if( image->getID() == IMG_DEFAULT )
    958. 

  958.                         {
    959. 

  959.                                 image = LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT_AVATAR);
    960. 

  960.                         }
    961. 

  961.                         if (getWearable())
    962. 

  962.                         {
    963. 

  963.                                 U32 index = gAgentWearables.getWearableIndex(getWearable());
    964. 

  964.                                 gAgentAvatarp->setLocalTexture(entry->mTextureIndex, image, FALSE, index);
    965. 

  965.                                 LLVisualParamHint::requestHintUpdates();
    966. 

  966.                                 gAgentAvatarp->wearableUpdated(type, FALSE);
    967. 

  967.                         }
    968. 

  968.                 }
    969. 

  969.                 else
    970. 

  970.                 {
    971. 

  971.                         llwarns << "could not get texture picker dictionary entry for wearable of type: " << type << llendl;
    972. 

  972.                 }
    973. 

  973.         }
    974. 

  974. }
    975. 

  975. 

  976. void LLPanelEditWearable::onColorSwatchCommit(const LLUICtrl* ctrl)
    977. 

  977. {
    978. 

  978.         if (getWearable())
    979. 

  979.         {
    980. 

  980.                 LLWearableType::EType type = getWearable()->getType();
    981. 

  981.                 const PickerControlEntryNamePredicate name_pred(ctrl->getName());
    982. 

  982.                 const LLEditWearableDictionary::PickerControlEntry* entry
    983. 

  983.                         = find_picker_ctrl_entry_if<LLColorSwatchCtrl, PickerControlEntryNamePredicate>(type, name_pred);
    984. 

  984.                 if (entry)
    985. 

  985.                 {
    986. 

  986.                         const LLColor4& old_color = getWearable()->getClothesColor(entry->mTextureIndex);
    987. 

  987.                         const LLColor4& new_color = LLColor4(ctrl->getValue());
    988. 

  988.                         if( old_color != new_color )
    989. 

  989.                         {
    990. 

  990.                                 getWearable()->setClothesColor(entry->mTextureIndex, new_color, TRUE);
    991. 

  991.                                 LLVisualParamHint::requestHintUpdates();
    992. 

  992.                                 gAgentAvatarp->wearableUpdated(getWearable()->getType(), FALSE);
    993. 

  993.                         }
    994. 

  994.                 }
    995. 

  995.                 else
    996. 

  996.                 {
    997. 

  997.                         llwarns << "could not get color swatch dictionary entry for wearable of type: " << type << llendl;
    998. 

  998.                 }
    999. 

  999.         }
    1000. 

  1000. }
    1001. 

  1001. 

  1002. void LLPanelEditWearable::updatePanelPickerControls(LLWearableType::EType type)
    1003. 

  1003. {
    1004. 

  1004.         LLPanel* panel = getPanel(type);
    1005. 

  1005.         if (!panel)
    1006. 

  1006.                 return;
    1007. 

  1007. 

  1008.         bool is_modifiable = false;
    1009. 

  1009.         bool is_copyable   = false;
    1010. 

  1010. 

  1011.         if(mWearableItem)
    1012. 

  1012.         {
    1013. 

  1013.                 const LLPermissions& perm = mWearableItem->getPermissions();
    1014. 

  1014.                 is_modifiable = perm.allowModifyBy(gAgent.getID(), gAgent.getGroupID());
    1015. 

  1015.                 is_copyable = perm.allowCopyBy(gAgent.getID(), gAgent.getGroupID());
    1016. 

  1016.         }
    1017. 

  1017. 

  1018.         if (is_modifiable)
    1019. 

  1019.         {
    1020. 

  1020.                 // Update picker controls
    1021. 

  1021.                 for_each_picker_ctrl_entry <LLColorSwatchCtrl> (panel, type, boost::bind(update_color_swatch_ctrl, this, _1, _2));
    1022. 

  1022.                 for_each_picker_ctrl_entry <LLTextureCtrl>     (panel, type, boost::bind(update_texture_ctrl, this, _1, _2));
    1023. 

  1023.         }
    1024. 

  1024.         else
    1025. 

  1025.         {
    1026. 

  1026.                 // Disable controls
    1027. 

  1027.                 for_each_picker_ctrl_entry <LLColorSwatchCtrl> (panel, type, boost::bind(set_enabled_color_swatch_ctrl, false, _1, _2));
    1028. 

  1028.                 for_each_picker_ctrl_entry <LLTextureCtrl>     (panel, type, boost::bind(set_enabled_texture_ctrl, false, _1, _2));
    1029. 

  1029.         }
    1030. 

  1030. }
    1031. 

  1031. 

  1032. void LLPanelEditWearable::saveChanges(bool force_save_as)
    1033. 

  1033. {
    1034. 

  1034.         if (!mWearablePtr || !isDirty())
    1035. 

  1035.         {
    1036. 

  1036.                 // do nothing if no unsaved changes
    1037. 

  1037.                 return;
    1038. 

  1038.         }
    1039. 

  1039. 

  1040.         U32 index = gAgentWearables.getWearableIndex(mWearablePtr);
    1041. 

  1041. 

  1042.         std::string new_name = mNameEditor->getText();
    1043. 

  1043.         if (force_save_as)
    1044. 

  1044.         {
    1045. 

  1045.                 // the name of the wearable has changed, re-save wearable with new name
    1046. 

  1046.                 LLAppearanceMgr::instance().removeCOFItemLinks(mWearablePtr->getItemID(),false);
    1047. 

  1047.                 gAgentWearables.saveWearableAs(mWearablePtr->getType(), index, new_name, FALSE);
    1048. 

  1048.                 mNameEditor->setText(mWearableItem->getName());
    1049. 

  1049.         }
    1050. 

  1050.         else
    1051. 

  1051.         {
    1052. 

  1052.                 gAgentWearables.saveWearable(mWearablePtr->getType(), index, TRUE, new_name);
    1053. 

  1053.         }
    1054. 

  1054. }
    1055. 

  1055. 

  1056. void LLPanelEditWearable::revertChanges()
    1057. 

  1057. {
    1058. 

  1058.         if (!mWearablePtr || !isDirty())
    1059. 

  1059.         {
    1060. 

  1060.                 // no unsaved changes to revert
    1061. 

  1061.                 return;
    1062. 

  1062.         }
    1063. 

  1063. 

  1064.         mWearablePtr->revertValues();
    1065. 

  1065.         mNameEditor->setText(mWearableItem->getName());
    1066. 

  1066.         updatePanelPickerControls(mWearablePtr->getType());
    1067. 

  1067.         updateTypeSpecificControls(mWearablePtr->getType());
    1068. 

  1068.         gAgentAvatarp->wearableUpdated(mWearablePtr->getType(), FALSE);
    1069. 

  1069. }
    1070. 

  1070. 

  1071. void LLPanelEditWearable::showWearable(LLWearable* wearable, BOOL show, BOOL disable_camera_switch)
    1072. 

  1072. {
    1073. 

  1073.         if (!wearable)
    1074. 

  1074.         {
    1075. 

  1075.                 return;
    1076. 

  1076.         }
    1077. 

  1077. 

  1078.         mWearableItem = gInventory.getItem(mWearablePtr->getItemID());
    1079. 

  1079.         llassert(mWearableItem);
    1080. 

  1080. 

  1081.         LLWearableType::EType type = wearable->getType();
    1082. 

  1082.         LLPanel *targetPanel = NULL;
    1083. 

  1083.         std::string title;
    1084. 

  1084.         std::string description_title;
    1085. 

  1085. 

  1086.         const LLEditWearableDictionary::WearableEntry *wearable_entry = LLEditWearableDictionary::getInstance()->getWearable(type);
    1087. 

  1087.         if (!wearable_entry)
    1088. 

  1088.         {
    1089. 

  1089.                 llwarns << "called LLPanelEditWearable::showWearable with an invalid wearable type! (" << type << ")" << llendl;
    1090. 

  1090.                 return;
    1091. 

  1091.         }
    1092. 

  1092. 

  1093.         targetPanel = getPanel(type);
    1094. 

  1094.         title = getString(wearable_entry->mTitle);
    1095. 

  1095.         description_title = getString(wearable_entry->mDescTitle);
    1096. 

  1096. 

  1097.         // Update picker controls state
    1098. 

  1098.         for_each_picker_ctrl_entry <LLColorSwatchCtrl> (targetPanel, type, boost::bind(set_enabled_color_swatch_ctrl, show, _1, _2));
    1099. 

  1099.         for_each_picker_ctrl_entry <LLTextureCtrl>     (targetPanel, type, boost::bind(set_enabled_texture_ctrl, show, _1, _2));
    1100. 

  1100. 

  1101.         targetPanel->setVisible(show);
    1102. 

  1102.         toggleTypeSpecificControls(type);
    1103. 

  1103. 

  1104.         if (show)
    1105. 

  1105.         {
    1106. 

  1106.                 mPanelTitle->setText(title);
    1107. 

  1107.                 mPanelTitle->setToolTip(title);
    1108. 

  1108.                 mDescTitle->setText(description_title);
    1109. 

  1109.                 
    1110. 

  1110.                 // set name
    1111. 

  1111.                 mNameEditor->setText(mWearableItem->getName());
    1112. 

  1112. 

  1113.                 updatePanelPickerControls(type);
    1114. 

  1114.                 updateTypeSpecificControls(type);
    1115. 

  1115. 

  1116.                 // clear and rebuild visual param list
    1117. 

  1117.                 U8 num_subparts = wearable_entry->mSubparts.size();
    1118. 

  1118.         
    1119. 

  1119.                 for (U8 index = 0; index < num_subparts; ++index)
    1120. 

  1120.                 {
    1121. 

  1121.                         // dive into data structures to get the panel we need
    1122. 

  1122.                         ESubpart subpart_e = wearable_entry->mSubparts[index];
    1123. 

  1123.                         const LLEditWearableDictionary::SubpartEntry *subpart_entry = LLEditWearableDictionary::getInstance()->getSubpart(subpart_e);
    1124. 

  1124.         
    1125. 

  1125.                         if (!subpart_entry)
    1126. 

  1126.                         {
    1127. 

  1127.                                 llwarns << "could not get wearable subpart dictionary entry for subpart: " << subpart_e << llendl;
    1128. 

  1128.                                 continue;
    1129. 

  1129.                         }
    1130. 

  1130.         
    1131. 

  1131.                         const std::string scrolling_panel = subpart_entry->mParamList;
    1132. 

  1132.                         const std::string accordion_tab = subpart_entry->mAccordionTab;
    1133. 

  1133.         
    1134. 

  1134.                         LLScrollingPanelList *panel_list = getChild<LLScrollingPanelList>(scrolling_panel);
    1135. 

  1135.                         LLAccordionCtrlTab *tab = getChild<LLAccordionCtrlTab>(accordion_tab);
    1136. 

  1136. 			
    1137. 

  1137.                         if (!panel_list)
    1138. 

  1138.                         {
    1139. 

  1139.                                 llwarns << "could not get scrolling panel list: " << scrolling_panel << llendl;
    1140. 

  1140.                                 continue;
    1141. 

  1141.                         }
    1142. 

  1142.         
    1143. 

  1143.                         if (!tab)
    1144. 

  1144.                         {
    1145. 

  1145.                                 llwarns << "could not get llaccordionctrltab from UI with name: " << accordion_tab << llendl;
    1146. 

  1146.                                 continue;
    1147. 

  1147.                         }
    1148. 

  1148. 

  1149. 			// Don't show female subparts if you're not female, etc.
    1150. 

  1150. 			if (!(gAgentAvatarp->getSex() & subpart_entry->mSex))
    1151. 

  1151. 			{
    1152. 

  1152. 				tab->setVisible(FALSE);
    1153. 

  1153. 				continue;
    1154. 

  1154. 			}
    1155. 

  1155. 			else
    1156. 

  1156. 			{
    1157. 

  1157. 				tab->setVisible(TRUE);
    1158. 

  1158. 			}
    1159. 

  1159. 			
    1160. 

  1160.                         // what edit group do we want to extract params for?
    1161. 

  1161.                         const std::string edit_group = subpart_entry->mEditGroup;
    1162. 

  1162.         
    1163. 

  1163.                         // storage for ordered list of visual params
    1164. 

  1164.                         value_map_t sorted_params;
    1165. 

  1165.                         getSortedParams(sorted_params, edit_group);
    1166. 

  1166. 

  1167.                         LLJoint* jointp = gAgentAvatarp->getJoint( subpart_entry->mTargetJoint );
    1168. 

  1168.                         if (!jointp)
    1169. 

  1169.                         {
    1170. 

  1170.                                 jointp = gAgentAvatarp->getJoint("mHead");
    1171. 

  1171.                         }
    1172. 

  1172. 

  1173.                         buildParamList(panel_list, sorted_params, tab, jointp);
    1174. 

  1174.         
    1175. 

  1175.                         updateScrollingPanelUI();
    1176. 

  1176.                 }
    1177. 

  1177.                 if (!disable_camera_switch)
    1178. 

  1178.                 {
    1179. 

  1179.                         showDefaultSubpart();
    1180. 

  1180.                 }
    1181. 

  1181. 

  1182.                 updateVerbs();
    1183. 

  1183.         }
    1184. 

  1184. }
    1185. 

  1185. 

  1186. void LLPanelEditWearable::showDefaultSubpart()
    1187. 

  1187. {
    1188. 

  1188.         changeCamera(3);
    1189. 

  1189. }
    1190. 

  1190. 

  1191. void LLPanelEditWearable::onTabExpandedCollapsed(const LLSD& param, U8 index)
    1192. 

  1192. {
    1193. 

  1193.         bool expanded = param.asBoolean();
    1194. 

  1194. 

  1195.         if (!mWearablePtr || !gAgentCamera.cameraCustomizeAvatar())
    1196. 

  1196.         {
    1197. 

  1197.                 // we don't have a valid wearable we're editing, or we've left the wearable editor
    1198. 

  1198.                 return;
    1199. 

  1199.         }
    1200. 

  1200. 

  1201.         if (expanded)
    1202. 

  1202.         {
    1203. 

  1203.                 changeCamera(index);
    1204. 

  1204.         }
    1205. 

  1205. 

  1206. }
    1207. 

  1207. 

  1208. void LLPanelEditWearable::changeCamera(U8 subpart)
    1209. 

  1209. {
    1210. 

  1210. 	// Don't change the camera if this type doesn't have a camera switch.
    1211. 

  1211. 	// Useful for wearables like physics that don't have an associated physical body part.
    1212. 

  1212. 	if (LLWearableType::getDisableCameraSwitch(mWearablePtr->getType()))
    1213. 

  1213. 	{
    1214. 

  1214. 		return;
    1215. 

  1215. 	}
    1216. 

  1216.         const LLEditWearableDictionary::WearableEntry *wearable_entry = LLEditWearableDictionary::getInstance()->getWearable(mWearablePtr->getType());
    1217. 

  1217.         if (!wearable_entry)
    1218. 

  1218.         {
    1219. 

  1219.                 llinfos << "could not get wearable dictionary entry for wearable type: " << mWearablePtr->getType() << llendl;
    1220. 

  1220.                 return;
    1221. 

  1221.         }
    1222. 

  1222. 

  1223.         if (subpart >= wearable_entry->mSubparts.size())
    1224. 

  1224.         {
    1225. 

  1225.                 llinfos << "accordion tab expanded for invalid subpart. Wearable type: " << mWearablePtr->getType() << " subpart num: " << subpart << llendl;
    1226. 

  1226.                 return;
    1227. 

  1227.         }
    1228. 

  1228. 

  1229.         ESubpart subpart_e = wearable_entry->mSubparts[subpart];
    1230. 

  1230.         const LLEditWearableDictionary::SubpartEntry *subpart_entry = LLEditWearableDictionary::getInstance()->getSubpart(subpart_e);
    1231. 

  1231. 

  1232.         if (!subpart_entry)
    1233. 

  1233.         {
    1234. 

  1234.                 llwarns << "could not get wearable subpart dictionary entry for subpart: " << subpart_e << llendl;
    1235. 

  1235.                 return;
    1236. 

  1236.         }
    1237. 

  1237. 

  1238.         // Update the camera
    1239. 

  1239.         gMorphView->setCameraTargetJoint( gAgentAvatarp->getJoint( subpart_entry->mTargetJoint ) );
    1240. 

  1240.         gMorphView->setCameraTargetOffset( subpart_entry->mTargetOffset );
    1241. 

  1241.         gMorphView->setCameraOffset( subpart_entry->mCameraOffset );
    1242. 

  1242.         if (gSavedSettings.getBOOL("AppearanceCameraMovement"))
    1243. 

  1243.         {
    1244. 

  1244.                 gMorphView->updateCamera();
    1245. 

  1245.         }
    1246. 

  1246. }
    1247. 

  1247. 

  1248. void LLPanelEditWearable::updateScrollingPanelList()
    1249. 

  1249. {
    1250. 

  1250.         updateScrollingPanelUI();
    1251. 

  1251. }
    1252. 

  1252. 

  1253. void LLPanelEditWearable::toggleTypeSpecificControls(LLWearableType::EType type)
    1254. 

  1254. {
    1255. 

  1255.         // Toggle controls specific to shape editing panel.
    1256. 

  1256.         {
    1257. 

  1257.                 bool is_shape = (type == LLWearableType::WT_SHAPE);
    1258. 

  1258.                 getChildView("sex_radio")->setVisible( is_shape);
    1259. 

  1259.                 getChildView("female_icon")->setVisible( is_shape);
    1260. 

  1260.                 getChildView("male_icon")->setVisible( is_shape);
    1261. 

  1261.         }
    1262. 

  1262. }
    1263. 

  1263. 

  1264. void LLPanelEditWearable::updateTypeSpecificControls(LLWearableType::EType type)
    1265. 

  1265. {
    1266. 

  1266.         const F32 ONE_METER = 1.0;
    1267. 

  1267.         const F32 ONE_FOOT = 0.3048 * ONE_METER; // in meters
    1268. 

  1268.         // Update controls specific to shape editing panel.
    1269. 

  1269.         if (type == LLWearableType::WT_SHAPE)
    1270. 

  1270.         {
    1271. 

  1271.                 // Update avatar height
    1272. 

  1272.                 F32 new_size = gAgentAvatarp->mBodySize.mV[VZ];
    1273. 

  1273.                 if (gSavedSettings.getBOOL("HeightUnits") == FALSE)
    1274. 

  1274.                 {
    1275. 

  1275.                         // convert meters to feet
    1276. 

  1276.                         new_size = new_size / ONE_FOOT;
    1277. 

  1277.                 }
    1278. 

  1278. 

  1279.                 std::string avatar_height_str = llformat("%.2f", new_size);
    1280. 

  1280.                 mHeigthValue.setArg("[HEIGHT]", avatar_height_str);
    1281. 

  1281.                 updateAvatarHeightLabel();
    1282. 

  1282.         }
    1283. 

  1283. 

  1284.         if (LLWearableType::WT_ALPHA == type)
    1285. 

  1285.         {
    1286. 

  1286.                 updateAlphaCheckboxes();
    1287. 

  1287. 

  1288.                 initPreviousAlphaTextures();
    1289. 

  1289.         }
    1290. 

  1290. }
    1291. 

  1291. 

  1292. void LLPanelEditWearable::updateScrollingPanelUI()
    1293. 

  1293. {
    1294. 

  1294.         // do nothing if we don't have a valid wearable we're editing
    1295. 

  1295.         if (mWearablePtr == NULL)
    1296. 

  1296.         {
    1297. 

  1297.                 return;
    1298. 

  1298.         }
    1299. 

  1299. 

  1300.         LLWearableType::EType type = mWearablePtr->getType();
    1301. 

  1301.         LLPanel *panel = getPanel(type);
    1302. 

  1302. 

  1303.         if(panel && (mWearablePtr->getItemID().notNull()))
    1304. 

  1304.         {
    1305. 

  1305.                 const LLEditWearableDictionary::WearableEntry *wearable_entry = LLEditWearableDictionary::getInstance()->getWearable(type);
    1306. 

  1306.                 llassert(wearable_entry);
    1307. 

  1307.                 if (!wearable_entry) return;
    1308. 

  1308.                 U8 num_subparts = wearable_entry->mSubparts.size();
    1309. 

  1309. 

  1310.                 LLScrollingPanelParam::sUpdateDelayFrames = 0;
    1311. 

  1311.                 for (U8 index = 0; index < num_subparts; ++index)
    1312. 

  1312.                 {
    1313. 

  1313.                         // dive into data structures to get the panel we need
    1314. 

  1314.                         ESubpart subpart_e = wearable_entry->mSubparts[index];
    1315. 

  1315.                         const LLEditWearableDictionary::SubpartEntry *subpart_entry = LLEditWearableDictionary::getInstance()->getSubpart(subpart_e);
    1316. 

  1316. 

  1317.                         const std::string scrolling_panel = subpart_entry->mParamList;
    1318. 

  1318. 

  1319.                         LLScrollingPanelList *panel_list = getChild<LLScrollingPanelList>(scrolling_panel);
    1320. 

  1320.         
    1321. 

  1321.                         if (!panel_list)
    1322. 

  1322.                         {
    1323. 

  1323.                                 llwarns << "could not get scrolling panel list: " << scrolling_panel << llendl;
    1324. 

  1324.                                 continue;
    1325. 

  1325.                         }
    1326. 

  1326.                         
    1327. 

  1327.                         panel_list->updatePanels(TRUE);
    1328. 

  1328.                 }
    1329. 

  1329.         }
    1330. 

  1330. }
    1331. 

  1331. 

  1332. LLPanel* LLPanelEditWearable::getPanel(LLWearableType::EType type)
    1333. 

  1333. {
    1334. 

  1334.         switch (type)
    1335. 

  1335.         {
    1336. 

  1336.                 case LLWearableType::WT_SHAPE:
    1337. 

  1337.                         return mPanelShape;
    1338. 

  1338.                         break;
    1339. 

  1339. 

  1340.                 case LLWearableType::WT_SKIN:
    1341. 

  1341.                         return mPanelSkin;
    1342. 

  1342.                         break;
    1343. 

  1343. 

  1344.                 case LLWearableType::WT_HAIR:
    1345. 

  1345.                         return mPanelHair;
    1346. 

  1346.                         break;
    1347. 

  1347. 

  1348.                 case LLWearableType::WT_EYES:
    1349. 

  1349.                         return mPanelEyes;
    1350. 

  1350.                         break;
    1351. 

  1351. 

  1352.                 case LLWearableType::WT_SHIRT:
    1353. 

  1353.                         return mPanelShirt;
    1354. 

  1354.                         break;
    1355. 

  1355. 

  1356.                 case LLWearableType::WT_PANTS:
    1357. 

  1357.                         return mPanelPants;
    1358. 

  1358.                         break;
    1359. 

  1359. 

  1360.                 case LLWearableType::WT_SHOES:
    1361. 

  1361.                         return mPanelShoes;
    1362. 

  1362.                         break;
    1363. 

  1363. 

  1364.                 case LLWearableType::WT_SOCKS:
    1365. 

  1365.                    
    1366.