livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Automated merge with http://bitbucket.org/lindenlab/viewer-interesting

master
Richard Linden 2013-11-06 09:42:46 -08:00
parent 2cb781705e a10eb7b240
commit d9d46d908c
54 changed files with 1314 additions and 1579 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

461
indra/llrender/llrender2dutils.cpp
View File

@ -369,7 +369,7 @@ void gl_draw_scaled_image(S32 x, S32 y, S32 width, S32 height, LLTexture* image,
gl_draw_scaled_rotated_image( x, y, width, height, 0.f, image, color, uv_rect );
}
void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLTexture* image, const LLColor4& color, BOOL solid_color, const LLRectf& uv_rect)
void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLTexture* image, const LLColor4& color, BOOL solid_color, const LLRectf& uv_rect, bool scale_inner)
{
if (NULL == image)
{
@ -382,10 +382,10 @@ void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border
F32 border_height_fraction = (F32)border_height / (F32)image->getHeight(0);
LLRectf scale_rect(border_width_fraction, 1.f - border_height_fraction, 1.f - border_width_fraction, border_height_fraction);
gl_draw_scaled_image_with_border(x, y, width, height, image, color, solid_color, uv_rect, scale_rect);
gl_draw_scaled_image_with_border(x, y, width, height, image, color, solid_color, uv_rect, scale_rect, scale_inner);
}
void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4& color, BOOL solid_color, const LLRectf& uv_outer_rect, const LLRectf& center_rect)
void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4& color, BOOL solid_color, const LLRectf& uv_outer_rect, const LLRectf& center_rect, bool scale_inner)
{
stop_glerror();
@ -395,56 +395,6 @@ void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTex
return;
}
// add in offset of current image to current UI translation
const LLVector3 ui_scale = gGL.getUIScale();
const LLVector3 ui_translation = (gGL.getUITranslation() + LLVector3(x, y, 0.f)).scaledVec(ui_scale);
F32 uv_width = uv_outer_rect.getWidth();
F32 uv_height = uv_outer_rect.getHeight();
// shrink scaling region to be proportional to clipped image region
LLRectf uv_center_rect(
uv_outer_rect.mLeft + (center_rect.mLeft * uv_width),
uv_outer_rect.mBottom + (center_rect.mTop * uv_height),
uv_outer_rect.mLeft + (center_rect.mRight * uv_width),
uv_outer_rect.mBottom + (center_rect.mBottom * uv_height));
F32 image_width = image->getWidth(0);
F32 image_height = image->getHeight(0);
S32 image_natural_width = llround(image_width * uv_width);
S32 image_natural_height = llround(image_height * uv_height);
LLRectf draw_center_rect( uv_center_rect.mLeft * image_width,
uv_center_rect.mTop * image_height,
uv_center_rect.mRight * image_width,
uv_center_rect.mBottom * image_height);
{ // scale fixed region of image to drawn region
draw_center_rect.mRight += width - image_natural_width;
draw_center_rect.mTop += height - image_natural_height;
F32 border_shrink_width = llmax(0.f, draw_center_rect.mLeft - draw_center_rect.mRight);
F32 border_shrink_height = llmax(0.f, draw_center_rect.mBottom - draw_center_rect.mTop);
F32 shrink_width_ratio = center_rect.getWidth() == 1.f ? 0.f : border_shrink_width / ((F32)image_natural_width * (1.f - center_rect.getWidth()));
F32 shrink_height_ratio = center_rect.getHeight() == 1.f ? 0.f : border_shrink_height / ((F32)image_natural_height * (1.f - center_rect.getHeight()));
F32 shrink_scale = 1.f - llmax(shrink_width_ratio, shrink_height_ratio);
draw_center_rect.mLeft = llround(ui_translation.mV[VX] + (F32)draw_center_rect.mLeft * shrink_scale * ui_scale.mV[VX]);
draw_center_rect.mTop = llround(ui_translation.mV[VY] + lerp((F32)height, (F32)draw_center_rect.mTop, shrink_scale) * ui_scale.mV[VY]);
draw_center_rect.mRight = llround(ui_translation.mV[VX] + lerp((F32)width, (F32)draw_center_rect.mRight, shrink_scale) * ui_scale.mV[VX]);
draw_center_rect.mBottom = llround(ui_translation.mV[VY] + (F32)draw_center_rect.mBottom * shrink_scale * ui_scale.mV[VY]);
}
LLRectf draw_outer_rect(ui_translation.mV[VX],
ui_translation.mV[VY] + height * ui_scale.mV[VY],
ui_translation.mV[VX] + width * ui_scale.mV[VX],
ui_translation.mV[VY]);
LLGLSUIDefault gls_ui;
if (solid_color)
{
if (LLGLSLShader::sNoFixedFunction)
@ -458,174 +408,247 @@ void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTex
}
}
gGL.getTexUnit(0)->bind(image, true);
gGL.color4fv(color.mV);
const S32 NUM_VERTICES = 9 * 4; // 9 quads
LLVector2 uv[NUM_VERTICES];
LLVector3 pos[NUM_VERTICES];
S32 index = 0;
gGL.begin(LLRender::QUADS);
if (center_rect.mLeft == 0.f
&& center_rect.mRight == 1.f
&& center_rect.mBottom == 0.f
&& center_rect.mTop == 1.f)
{
// draw bottom left
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
// draw bottom middle
uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
// draw bottom right
uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
// draw left
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
// draw middle
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
// draw right
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
// draw top left
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_outer_rect.mTop, 0.f);
index++;
// draw top middle
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mTop, 0.f);
index++;
// draw top right
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_outer_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mTop, 0.f);
index++;
gGL.vertexBatchPreTransformed(pos, uv, NUM_VERTICES);
gl_draw_scaled_image(x, y, width, height, image, color, uv_outer_rect);
}
else
{
// add in offset of current image to current UI translation
const LLVector3 ui_scale = gGL.getUIScale();
const LLVector3 ui_translation = (gGL.getUITranslation() + LLVector3(x, y, 0.f)).scaledVec(ui_scale);
F32 uv_width = uv_outer_rect.getWidth();
F32 uv_height = uv_outer_rect.getHeight();
// shrink scaling region to be proportional to clipped image region
LLRectf uv_center_rect( uv_outer_rect.mLeft + (center_rect.mLeft * uv_width),
uv_outer_rect.mBottom + (center_rect.mTop * uv_height),
uv_outer_rect.mLeft + (center_rect.mRight * uv_width),
uv_outer_rect.mBottom + (center_rect.mBottom * uv_height));
F32 image_width = image->getWidth(0);
F32 image_height = image->getHeight(0);
S32 image_natural_width = llround(image_width * uv_width);
S32 image_natural_height = llround(image_height * uv_height);
LLRectf draw_center_rect( uv_center_rect.mLeft * image_width,
uv_center_rect.mTop * image_height,
uv_center_rect.mRight * image_width,
uv_center_rect.mBottom * image_height);
if (scale_inner)
{
// scale center region of image to drawn region
draw_center_rect.mRight += width - image_natural_width;
draw_center_rect.mTop += height - image_natural_height;
const F32 border_shrink_width = llmax(0.f, draw_center_rect.mLeft - draw_center_rect.mRight);
const F32 border_shrink_height = llmax(0.f, draw_center_rect.mBottom - draw_center_rect.mTop);
const F32 shrink_width_ratio = center_rect.getWidth() == 1.f ? 0.f : border_shrink_width / ((F32)image_natural_width * (1.f - center_rect.getWidth()));
const F32 shrink_height_ratio = center_rect.getHeight() == 1.f ? 0.f : border_shrink_height / ((F32)image_natural_height * (1.f - center_rect.getHeight()));
const F32 border_shrink_scale = 1.f - llmax(shrink_width_ratio, shrink_height_ratio);
draw_center_rect.mLeft *= border_shrink_scale;
draw_center_rect.mTop = lerp((F32)height, (F32)draw_center_rect.mTop, border_shrink_scale);
draw_center_rect.mRight = lerp((F32)width, (F32)draw_center_rect.mRight, border_shrink_scale);
draw_center_rect.mBottom *= border_shrink_scale;
}
else
{
// keep center region of image at fixed scale, but in same relative position
F32 scale_factor = llmin((F32)width / draw_center_rect.getWidth(), (F32)height / draw_center_rect.getHeight(), 1.f);
F32 scaled_width = draw_center_rect.getWidth() * scale_factor;
F32 scaled_height = draw_center_rect.getHeight() * scale_factor;
draw_center_rect.setCenterAndSize(uv_center_rect.getCenterX() * width, uv_center_rect.getCenterY() * height, scaled_width, scaled_height);
}
draw_center_rect.mLeft = llround(ui_translation.mV[VX] + (F32)draw_center_rect.mLeft * ui_scale.mV[VX]);
draw_center_rect.mTop = llround(ui_translation.mV[VY] + (F32)draw_center_rect.mTop * ui_scale.mV[VY]);
draw_center_rect.mRight = llround(ui_translation.mV[VX] + (F32)draw_center_rect.mRight * ui_scale.mV[VX]);
draw_center_rect.mBottom = llround(ui_translation.mV[VY] + (F32)draw_center_rect.mBottom * ui_scale.mV[VY]);
LLRectf draw_outer_rect(ui_translation.mV[VX],
ui_translation.mV[VY] + height * ui_scale.mV[VY],
ui_translation.mV[VX] + width * ui_scale.mV[VX],
ui_translation.mV[VY]);
LLGLSUIDefault gls_ui;
gGL.getTexUnit(0)->bind(image, true);
gGL.color4fv(color.mV);
const S32 NUM_VERTICES = 9 * 4; // 9 quads
LLVector2 uv[NUM_VERTICES];
LLVector3 pos[NUM_VERTICES];
S32 index = 0;
gGL.begin(LLRender::QUADS);
{
// draw bottom left
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
// draw bottom middle
uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
// draw bottom right
uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_outer_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_outer_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
// draw left
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
// draw middle
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
// draw right
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mBottom);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mBottom, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
// draw top left
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mLeft, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mLeft, draw_outer_rect.mTop, 0.f);
index++;
// draw top middle
uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mTop, 0.f);
index++;
// draw top right
uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_outer_rect.mRight, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_outer_rect.mRight, draw_outer_rect.mTop, 0.f);
index++;
uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mTop);
pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mTop, 0.f);
index++;
gGL.vertexBatchPreTransformed(pos, uv, NUM_VERTICES);
}
gGL.end();
}
gGL.end();
if (solid_color)
{

4
indra/llrender/llrender2dutils.h
View File

@ -75,8 +75,8 @@ void gl_draw_scaled_target(S32 x, S32 y, S32 width, S32 height, LLRenderTarget*
void gl_draw_scaled_image(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
void gl_draw_rotated_image(S32 x, S32 y, F32 degrees, LLTexture* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degrees, LLTexture* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), LLRenderTarget* target = NULL);
void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLTexture* image, const LLColor4 &color, BOOL solid_color = FALSE, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4 &color, BOOL solid_color = FALSE, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), const LLRectf& scale_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLTexture* image, const LLColor4 &color, BOOL solid_color = FALSE, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), bool scale_inner = true);
void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4 &color, BOOL solid_color = FALSE, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), const LLRectf& scale_rect = LLRectf(0.f, 1.f, 1.f, 0.f), bool scale_inner = true);
void gl_stippled_line_3d( const LLVector3& start, const LLVector3& end, const LLColor4& color, F32 phase = 0.f );

50
indra/llrender/lluiimage.cpp
View File

@ -38,11 +38,9 @@ LLUIImage::LLUIImage(const std::string& name, LLPointer<LLTexture> image)
mImage(image),
mScaleRegion(0.f, 1.f, 1.f, 0.f),
mClipRegion(0.f, 1.f, 1.f, 0.f),
mUniformScaling(TRUE),
mNoClip(TRUE),
mImageLoaded(NULL)
{
}
mImageLoaded(NULL),
mScaleStyle(SCALE_INNER)
{}
LLUIImage::~LLUIImage()
{
@ -52,44 +50,35 @@ LLUIImage::~LLUIImage()
void LLUIImage::setClipRegion(const LLRectf& region)
{
mClipRegion = region;
mNoClip = mClipRegion.mLeft == 0.f
&& mClipRegion.mRight == 1.f
&& mClipRegion.mBottom == 0.f
&& mClipRegion.mTop == 1.f;
}
void LLUIImage::setScaleRegion(const LLRectf& region)
{
mScaleRegion = region;
mUniformScaling = mScaleRegion.mLeft == 0.f
&& mScaleRegion.mRight == 1.f
&& mScaleRegion.mBottom == 0.f
&& mScaleRegion.mTop == 1.f;
}
void LLUIImage::setScaleStyle(LLUIImage::EScaleStyle style)
{
mScaleStyle = style;
}
//TODO: move drawing implementation inside class
void LLUIImage::draw(S32 x, S32 y, const LLColor4& color) const
{
gl_draw_scaled_image(x, y, getWidth(), getHeight(), mImage, color, mClipRegion);
draw(x, y, getWidth(), getHeight(), color);
}
void LLUIImage::draw(S32 x, S32 y, S32 width, S32 height, const LLColor4& color) const
{
if (mUniformScaling)
{
gl_draw_scaled_image(x, y, width, height, mImage, color, mClipRegion);
}
else
{
gl_draw_scaled_image_with_border(
x, y,
width, height,
mImage,
color,
FALSE,
mClipRegion,
mScaleRegion);
}
gl_draw_scaled_image_with_border(
x, y,
width, height,
mImage,
color,
FALSE,
mClipRegion,
mScaleRegion,
mScaleStyle == SCALE_INNER);
}
void LLUIImage::drawSolid(S32 x, S32 y, S32 width, S32 height, const LLColor4& color) const
@ -101,7 +90,8 @@ void LLUIImage::drawSolid(S32 x, S32 y, S32 width, S32 height, const LLColor4& c
color,
TRUE,
mClipRegion,
mScaleRegion);
mScaleRegion,
mScaleStyle == SCALE_INNER);
}
void LLUIImage::drawBorder(S32 x, S32 y, S32 width, S32 height, const LLColor4& color, S32 border_width) const

18
indra/llrender/lluiimage.h
View File

@ -42,6 +42,12 @@ extern const LLColor4 UI_VERTEX_COLOR;
class LLUIImage : public LLRefCount
{
public:
enum EScaleStyle
{
SCALE_INNER,
SCALE_OUTER
};
typedef boost::signals2::signal<void (void)> image_loaded_signal_t;
LLUIImage(const std::string& name, LLPointer<LLTexture> image);
@ -49,6 +55,7 @@ public:
void setClipRegion(const LLRectf& region);
void setScaleRegion(const LLRectf& region);
void setScaleStyle(EScaleStyle style);
LLPointer<LLTexture> getImage() { return mImage; }
const LLPointer<LLTexture>& getImage() const { return mImage; }
@ -83,12 +90,11 @@ public:
protected:
image_loaded_signal_t* mImageLoaded;
std::string mName;
LLRectf mScaleRegion;
LLRectf mClipRegion;
LLPointer<LLTexture> mImage;
BOOL mUniformScaling;
BOOL mNoClip;
std::string mName;
LLRectf mScaleRegion;
LLRectf mClipRegion;
LLPointer<LLTexture> mImage;
EScaleStyle mScaleStyle;
};
namespace LLInitParam

7
indra/llui/llfloater.cpp
View File

@ -2905,13 +2905,6 @@ void LLFloaterView::syncFloaterTabOrder()
}
}
}
// sync draw order to tab order
for ( child_list_const_reverse_iter_t child_it = getChildList()->rbegin(); child_it != getChildList()->rend(); ++child_it)
{
LLFloater* floaterp = (LLFloater*)*child_it;
moveChildToFrontOfTabGroup(floaterp);
}
}
LLFloater* LLFloaterView::getParentFloater(LLView* viewp) const

26
indra/llui/lliconctrl.cpp
View File

@ -42,7 +42,9 @@ LLIconCtrl::Params::Params()
: image("image_name"),
color("color"),
use_draw_context_alpha("use_draw_context_alpha", true),
scale_image("scale_image")
scale_image("scale_image"),
min_width("min_width", 0),
min_height("min_height", 0)
{}
LLIconCtrl::LLIconCtrl(const LLIconCtrl::Params& p)
@ -51,8 +53,8 @@ LLIconCtrl::LLIconCtrl(const LLIconCtrl::Params& p)
mImagep(p.image),
mUseDrawContextAlpha(p.use_draw_context_alpha),
mPriority(0),
mDrawWidth(0),
mDrawHeight(0)
mMinWidth(p.min_width),
mMinHeight(p.min_height)
{
if (mImagep.notNull())
{
@ -97,7 +99,13 @@ void LLIconCtrl::setValue(const LLSD& value )
mImagep = LLUI::getUIImage(tvalue.asString(), mPriority);
}
setIconImageDrawSize();
if(mImagep.notNull()
&& mImagep->getImage().notNull()
&& mMinWidth
&& mMinHeight)
{
mImagep->getImage()->setKnownDrawSize(llmax(mMinWidth, mImagep->getWidth()), llmax(mMinHeight, mImagep->getHeight()));
}
}
std::string LLIconCtrl::getImageName() const
@ -108,14 +116,4 @@ std::string LLIconCtrl::getImageName() const
return std::string();
}
void LLIconCtrl::setIconImageDrawSize()
{
if(mImagep.notNull() && mDrawWidth && mDrawHeight)
{
if(mImagep->getImage().notNull())
{
mImagep->getImage()->setKnownDrawSize(mDrawWidth, mDrawHeight) ;
}
}
}

10
indra/llui/lliconctrl.h
View File

@ -49,7 +49,10 @@ public:
Optional<LLUIImage*> image;
Optional<LLUIColor> color;
Optional<bool> use_draw_context_alpha;
Optional<S32> min_width,
min_height;
Ignored scale_image;
Params();
};
protected:
@ -71,15 +74,12 @@ public:
void setImage(LLPointer<LLUIImage> image) { mImagep = image; }
const LLPointer<LLUIImage> getImage() { return mImagep; }
private:
void setIconImageDrawSize() ;
protected:
S32 mPriority;
//the output size of the icon image if set.
S32 mDrawWidth ;
S32 mDrawHeight ;
S32 mMinWidth,
mMinHeight;
// If set to true (default), use the draw context transparency.
// If false, will use transparency returned by getCurrentTransparency(). See STORM-698.

118
indra/llui/lllayoutstack.cpp
View File

@ -33,6 +33,7 @@
#include "lllocalcliprect.h"
#include "llpanel.h"
#include "llcriticaldamp.h"
#include "lliconctrl.h"
#include "boost/foreach.hpp"
static const F32 MIN_FRACTIONAL_SIZE = 0.00001f;
@ -268,25 +269,9 @@ void LLLayoutStack::draw()
// only force drawing invisible children if visible amount is non-zero
drawChild(panelp, 0, 0, !clip_rect.isEmpty());
}
}
const LLView::child_list_t * child_listp = getChildList();
BOOST_FOREACH(LLView * childp, * child_listp)
{
LLResizeBar * resize_barp = dynamic_cast<LLResizeBar*>(childp);
if (resize_barp && resize_barp->isShowDragHandle() && resize_barp->getVisible() && resize_barp->getRect().isValid())
if (panelp->getResizeBar()->getVisible())
{
LLRect screen_rect = resize_barp->calcScreenRect();
if (LLUI::getRootView()->getLocalRect().overlaps(screen_rect) && LLUI::sDirtyRect.overlaps(screen_rect))
{
LLUI::pushMatrix();
{
const LLRect& rb_rect(resize_barp->getRect());
LLUI::translate(rb_rect.mLeft, rb_rect.mBottom);
resize_barp->draw();
}
LLUI::popMatrix();
}
drawChild(panelp->getResizeBar());
}
}
}
@ -351,6 +336,31 @@ void LLLayoutStack::collapsePanel(LLPanel* panel, BOOL collapsed)
static LLTrace::BlockTimerStatHandle FTM_UPDATE_LAYOUT("Update LayoutStacks");
class LLImagePanel : public LLPanel
{
public:
struct Params : public LLInitParam::Block<Params, LLPanel::Params>
{
Optional<bool> horizontal;
Params() : horizontal("horizontal", false) {}
};
LLImagePanel(const Params& p) : LLPanel(p), mHorizontal(p.horizontal) {}
virtual ~LLImagePanel() {}
void draw()
{
const LLRect& parent_rect = getParent()->getRect();
const LLRect& rect = getRect();
LLRect clip_rect( -rect.mLeft, parent_rect.getHeight() - rect.mBottom - 2
, parent_rect.getWidth() - rect.mLeft - (mHorizontal ? 2 : 0), -rect.mBottom);
LLLocalClipRect clip(clip_rect);
LLPanel::draw();
}
private:
bool mHorizontal;
};
void LLLayoutStack::updateLayout()
{
LL_RECORD_BLOCK_TIME(FTM_UPDATE_LAYOUT);
@ -435,8 +445,6 @@ void LLLayoutStack::updateLayout()
}
LLRect resize_bar_rect(panel_rect);
LLResizeBar * resize_barp = panelp->getResizeBar();
bool show_drag_handle = resize_barp->isShowDragHandle();
F32 panel_spacing = (F32)mPanelSpacing * panelp->getVisibleAmount();
F32 panel_visible_dim = panelp->getVisibleDim();
S32 panel_spacing_round = (S32)(llround(panel_spacing));
@ -445,7 +453,7 @@ void LLLayoutStack::updateLayout()
{
cur_pos += panel_visible_dim + panel_spacing;
if (show_drag_handle && panel_spacing_round > mDragHandleThickness)
if (mShowDragHandle && panel_spacing_round > mDragHandleThickness)
{
resize_bar_rect.mLeft = panel_rect.mRight + mDragHandleShift;
resize_bar_rect.mRight = resize_bar_rect.mLeft + mDragHandleThickness;
@ -456,7 +464,7 @@ void LLLayoutStack::updateLayout()
resize_bar_rect.mRight = panel_rect.mRight + panel_spacing_round + mResizeBarOverlap;
}
if (show_drag_handle)
if (mShowDragHandle)
{
resize_bar_rect.mBottom += mDragHandleSecondIndent;
resize_bar_rect.mTop -= mDragHandleFirstIndent;
@ -467,7 +475,7 @@ void LLLayoutStack::updateLayout()
{
cur_pos -= panel_visible_dim + panel_spacing;
if (show_drag_handle && panel_spacing_round > mDragHandleThickness)
if (mShowDragHandle && panel_spacing_round > mDragHandleThickness)
{
resize_bar_rect.mTop = panel_rect.mBottom - mDragHandleShift;
resize_bar_rect.mBottom = resize_bar_rect.mTop - mDragHandleThickness;
@ -478,7 +486,7 @@ void LLLayoutStack::updateLayout()
resize_bar_rect.mBottom = panel_rect.mBottom - panel_spacing_round - mResizeBarOverlap;
}
if (show_drag_handle)
if (mShowDragHandle)
{
resize_bar_rect.mLeft += mDragHandleFirstIndent;
resize_bar_rect.mRight -= mDragHandleSecondIndent;
@ -541,9 +549,69 @@ void LLLayoutStack::createResizeBar(LLLayoutPanel* panelp)
resize_params.min_size(lp->getRelevantMinDim());
resize_params.side((mOrientation == HORIZONTAL) ? LLResizeBar::RIGHT : LLResizeBar::BOTTOM);
resize_params.snapping_enabled(false);
resize_params.show_drag_handle(mShowDragHandle);
LLResizeBar* resize_bar = LLUICtrlFactory::create<LLResizeBar>(resize_params);
lp->mResizeBar = resize_bar;
if (mShowDragHandle)
{
LLPanel::Params resize_bar_bg_panel_p;
resize_bar_bg_panel_p.name = "resize_handle_bg_panel";
resize_bar_bg_panel_p.rect = lp->mResizeBar->getLocalRect();
resize_bar_bg_panel_p.follows.flags = FOLLOWS_ALL;
resize_bar_bg_panel_p.tab_stop = false;
resize_bar_bg_panel_p.background_visible = true;
resize_bar_bg_panel_p.bg_alpha_color = LLUIColorTable::instance().getColor("ResizebarBody");
resize_bar_bg_panel_p.has_border = true;
resize_bar_bg_panel_p.border.border_thickness = 1;
resize_bar_bg_panel_p.border.highlight_light_color = LLUIColorTable::instance().getColor("ResizebarBorderLight");
resize_bar_bg_panel_p.border.shadow_dark_color = LLUIColorTable::instance().getColor("ResizebarBorderDark");
LLPanel* resize_bar_bg_panel = LLUICtrlFactory::create<LLPanel>(resize_bar_bg_panel_p);
LLIconCtrl::Params icon_p;
icon_p.name = "resize_handle_image";
icon_p.rect = lp->mResizeBar->getLocalRect();
icon_p.follows.flags = FOLLOWS_ALL;
icon_p.image = LLUI::getUIImage(mOrientation == HORIZONTAL ? "Vertical Drag Handle" : "Horizontal Drag Handle");
resize_bar_bg_panel->addChild(LLUICtrlFactory::create<LLIconCtrl>(icon_p));
lp->mResizeBar->addChild(resize_bar_bg_panel);
}
/*if (mShowDragHandle)
{
LLViewBorder::Params border_params;
border_params.border_thickness = 1;
border_params.highlight_light_color = LLUIColorTable::instance().getColor("ResizebarBorderLight");
border_params.shadow_dark_color = LLUIColorTable::instance().getColor("ResizebarBorderDark");
addBorder(border_params);
setBorderVisible(TRUE);
LLImagePanel::Params image_panel;
mDragHandleImage = LLUI::getUIImage(LLResizeBar::RIGHT == mSide ? "Vertical Drag Handle" : "Horizontal Drag Handle");
image_panel.bg_alpha_image = mDragHandleImage;
image_panel.background_visible = true;
image_panel.horizontal = (LLResizeBar::BOTTOM == mSide);
mImagePanel = LLUICtrlFactory::create<LLImagePanel>(image_panel);
setImagePanel(mImagePanel);
}*/
//if (mShowDragHandle)
//{
// setBackgroundVisible(TRUE);
// setTransparentColor(LLUIColorTable::instance().getColor("ResizebarBody"));
//}
/*if (mShowDragHandle)
{
S32 image_width = mDragHandleImage->getTextureWidth();
S32 image_height = mDragHandleImage->getTextureHeight();
const LLRect& panel_rect = getRect();
S32 image_left = (panel_rect.getWidth() - image_width) / 2 - 1;
S32 image_bottom = (panel_rect.getHeight() - image_height) / 2;
mImagePanel->setRect(LLRect(image_left, image_bottom + image_height, image_left + image_width, image_bottom));
}*/
LLView::addChild(resize_bar, 0);
}
}

201
indra/llui/llpanel.cpp
View File

@ -38,10 +38,8 @@
#include "lldir.h"
#include "lltimer.h"
#include "llaccordionctrltab.h"
#include "llbutton.h"
#include "llmenugl.h"
//#include "llstatusbar.h"
#include "llui.h"
#include "llkeyboard.h"
#include "lllineeditor.h"
@ -50,7 +48,6 @@
#include "lluictrl.h"
#include "lluictrlfactory.h"
#include "llviewborder.h"
#include "lltabcontainer.h"
static LLDefaultChildRegistry::Register<LLPanel> r1("panel", &LLPanel::fromXML);
LLPanel::factory_stack_t LLPanel::sFactoryStack;
@ -166,8 +163,8 @@ void LLPanel::removeBorder()
// virtual
void LLPanel::clearCtrls()
{
LLView::ctrl_list_t ctrls = getCtrlList();
for (LLView::ctrl_list_t::iterator ctrl_it = ctrls.begin(); ctrl_it != ctrls.end(); ++ctrl_it)
LLPanel::ctrl_list_t ctrls = getCtrlList();
for (LLPanel::ctrl_list_t::iterator ctrl_it = ctrls.begin(); ctrl_it != ctrls.end(); ++ctrl_it)
{
LLUICtrl* ctrl = *ctrl_it;
ctrl->setFocus( FALSE );
@ -178,14 +175,29 @@ void LLPanel::clearCtrls()
void LLPanel::setCtrlsEnabled( BOOL b )
{
LLView::ctrl_list_t ctrls = getCtrlList();
for (LLView::ctrl_list_t::iterator ctrl_it = ctrls.begin(); ctrl_it != ctrls.end(); ++ctrl_it)
LLPanel::ctrl_list_t ctrls = getCtrlList();
for (LLPanel::ctrl_list_t::iterator ctrl_it = ctrls.begin(); ctrl_it != ctrls.end(); ++ctrl_it)
{
LLUICtrl* ctrl = *ctrl_it;
ctrl->setEnabled( b );
}
}
LLPanel::ctrl_list_t LLPanel::getCtrlList() const
{
ctrl_list_t controls;
for(child_list_t::const_iterator it = getChildList()->begin(), end_it = getChildList()->end(); it != end_it; ++it)
{
LLView* viewp = *it;
if(viewp->isCtrl())
{
controls.push_back(static_cast<LLUICtrl*>(viewp));
}
}
return controls;
}
void LLPanel::draw()
{
F32 alpha = getDrawContext().mAlpha;
@ -637,16 +649,6 @@ void LLPanel::childSetVisible(const std::string& id, bool visible)
}
}
bool LLPanel::childIsVisible(const std::string& id) const
{
LLView* child = findChild<LLView>(id);
if (child)
{
return (bool)child->getVisible();
}
return false;
}
void LLPanel::childSetEnabled(const std::string& id, bool enabled)
{
LLView* child = findChild<LLView>(id);
@ -656,55 +658,6 @@ void LLPanel::childSetEnabled(const std::string& id, bool enabled)
}
}
void LLPanel::childSetTentative(const std::string& id, bool tentative)
{
LLUICtrl* child = findChild<LLUICtrl>(id);
if (child)
{
child->setTentative(tentative);
}
}
bool LLPanel::childIsEnabled(const std::string& id) const
{
LLView* child = findChild<LLView>(id);
if (child)
{
return (bool)child->getEnabled();
}
return false;
}
void LLPanel::childSetToolTip(const std::string& id, const std::string& msg)
{
LLView* child = findChild<LLView>(id);
if (child)
{
child->setToolTip(msg);
}
}
void LLPanel::childSetRect(const std::string& id, const LLRect& rect)
{
LLView* child = findChild<LLView>(id);
if (child)
{
child->setRect(rect);
}
}
bool LLPanel::childGetRect(const std::string& id, LLRect& rect) const
{
LLView* child = findChild<LLView>(id);
if (child)
{
rect = child->getRect();
return true;
}
return false;
}
void LLPanel::childSetFocus(const std::string& id, BOOL focus)
{
LLUICtrl* child = findChild<LLUICtrl>(id);
@ -740,15 +693,6 @@ void LLPanel::childSetCommitCallback(const std::string& id, boost::function<void
}
}
void LLPanel::childSetValidate(const std::string& id, boost::function<bool (const LLSD& data)> cb)
{
LLUICtrl* child = findChild<LLUICtrl>(id);
if (child)
{
child->setValidateBeforeCommit(cb);
}
}
void LLPanel::childSetColor(const std::string& id, const LLColor4& color)
{
LLUICtrl* child = findChild<LLUICtrl>(id);
@ -828,95 +772,6 @@ BOOL LLPanel::childSetLabelArg(const std::string& id, const std::string& key, co
return FALSE;
}
BOOL LLPanel::childSetToolTipArg(const std::string& id, const std::string& key, const LLStringExplicit& text)
{
LLView* child = findChild<LLView>(id);
if (child)
{
return child->setToolTipArg(key, text);
}
return FALSE;
}
void LLPanel::childShowTab(const std::string& id, const std::string& tabname, bool visible)
{
LLTabContainer* child = findChild<LLTabContainer>(id);
if (child)
{
child->selectTabByName(tabname);
}
}
LLPanel *LLPanel::childGetVisibleTab(const std::string& id) const
{
LLTabContainer* child = findChild<LLTabContainer>(id);
if (child)
{
return child->getCurrentPanel();
}
return NULL;
}
LLPanel* LLPanel::childGetVisibleTabWithHelp()
{
LLView *child;
bfs_tree_iterator_t it = beginTreeBFS();
// skip ourselves
++it;
for (; it != endTreeBFS(); ++it)
{
child = *it;
LLPanel *curTabPanel = NULL;
// do we have a tab container?
LLTabContainer *tab = dynamic_cast<LLTabContainer *>(child);
if (tab && tab->getVisible())
{
curTabPanel = tab->getCurrentPanel();
}
// do we have an accordion tab?
LLAccordionCtrlTab* accordion = dynamic_cast<LLAccordionCtrlTab *>(child);
if (accordion && accordion->getDisplayChildren())
{
curTabPanel = dynamic_cast<LLPanel *>(accordion->getAccordionView());
}
// if we found a valid tab, does it have a help topic?
if (curTabPanel && !curTabPanel->getHelpTopic().empty())
{
return curTabPanel;
}
}
// couldn't find any active tabs with a help topic string
return NULL;
}
LLPanel *LLPanel::childGetVisiblePanelWithHelp()
{
LLView *child;
bfs_tree_iterator_t it = beginTreeBFS();
// skip ourselves
++it;
for (; it != endTreeBFS(); ++it)
{
child = *it;
// do we have a panel with a help topic?
LLPanel *panel = dynamic_cast<LLPanel *>(child);
if (panel && panel->isInVisibleChain() && !panel->getHelpTopic().empty())
{
return panel;
}
}
// couldn't find any active panels with a help topic string
return NULL;
}
void LLPanel::childSetAction(const std::string& id, const commit_signal_t::slot_type& function)
{
LLButton* button = findChild<LLButton>(id);
@ -935,24 +790,6 @@ void LLPanel::childSetAction(const std::string& id, boost::function<void(void*)>
}
}
void LLPanel::childSetActionTextbox(const std::string& id, boost::function<void(void*)> function, void* value)
{
LLTextBox* textbox = findChild<LLTextBox>(id);
if (textbox)
{
textbox->setClickedCallback(boost::bind(function, value));
}
}
void LLPanel::childSetControlName(const std::string& id, const std::string& control_name)
{
LLUICtrl* view = findChild<LLUICtrl>(id);
if (view)
{
view->setControlName(control_name, NULL);
}
}
boost::signals2::connection LLPanel::setVisibleCallback( const commit_signal_t::slot_type& cb )
{
if (!mVisibleSignal)

38
indra/llui/llpanel.h
View File

@ -105,6 +105,8 @@ protected:
LLPanel(const LLPanel::Params& params = getDefaultParams());
public:
typedef std::vector<class LLUICtrl *> ctrl_list_t;
BOOL buildFromFile(const std::string &filename, const LLPanel::Params& default_params = getDefaultParams());
static LLPanel* createFactoryPanel(const std::string& name);
@ -154,6 +156,7 @@ public:
std::string getHelpTopic() const { return mHelpTopic; }
void setCtrlsEnabled(BOOL b);
ctrl_list_t getCtrlList() const;
LLHandle<LLPanel> getHandle() const { return getDerivedHandle<LLPanel>(); }
@ -174,19 +177,10 @@ public:
// LLView
void childSetVisible(const std::string& name, bool visible);
void childShow(const std::string& name) { childSetVisible(name, true); }
void childHide(const std::string& name) { childSetVisible(name, false); }
bool childIsVisible(const std::string& id) const;
void childSetTentative(const std::string& name, bool tentative);
void childSetEnabled(const std::string& name, bool enabled);
void childEnable(const std::string& name) { childSetEnabled(name, true); }
void childDisable(const std::string& name) { childSetEnabled(name, false); };
bool childIsEnabled(const std::string& id) const;
void childSetToolTip(const std::string& id, const std::string& msg);
void childSetRect(const std::string& id, const LLRect &rect);
bool childGetRect(const std::string& id, LLRect& rect) const;
// LLUICtrl
void childSetFocus(const std::string& id, BOOL focus = TRUE);
@ -197,9 +191,6 @@ public:
// which takes a generic slot. Or use mCommitCallbackRegistrar.add() with
// a named callback and reference it in XML.
void childSetCommitCallback(const std::string& id, boost::function<void (LLUICtrl*,void*)> cb, void* data);
void childSetValidate(const std::string& id, boost::function<bool (const LLSD& data)> cb );
void childSetColor(const std::string& id, const LLColor4& color);
LLCtrlSelectionInterface* childGetSelectionInterface(const std::string& id) const;
@ -214,34 +205,11 @@ public:
// Not implemented for all types, defaults to noop, returns FALSE if not applicaple
BOOL childSetTextArg(const std::string& id, const std::string& key, const LLStringExplicit& text);
BOOL childSetLabelArg(const std::string& id, const std::string& key, const LLStringExplicit& text);
BOOL childSetToolTipArg(const std::string& id, const std::string& key, const LLStringExplicit& text);
// LLTabContainer
void childShowTab(const std::string& id, const std::string& tabname, bool visible = true);
LLPanel *childGetVisibleTab(const std::string& id) const;
// Find a child with a nonempty Help topic
LLPanel *childGetVisibleTabWithHelp();
LLPanel *childGetVisiblePanelWithHelp();
// LLTextBox/LLTextEditor/LLLineEditor
void childSetText(const std::string& id, const LLStringExplicit& text) { childSetValue(id, LLSD(text)); }
// *NOTE: Does not return text from <string> tags, use getString()
std::string childGetText(const std::string& id) const { return childGetValue(id).asString(); }
// LLLineEditor
void childSetPrevalidate(const std::string& id, bool (*func)(const LLWString &) );
// LLButton
void childSetAction(const std::string& id, boost::function<void(void*)> function, void* value);
void childSetAction(const std::string& id, const commit_signal_t::slot_type& function);
// LLTextBox
void childSetActionTextbox(const std::string& id, boost::function<void(void*)> function, void* value = NULL);
void childSetControlName(const std::string& id, const std::string& control_name);
static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node = NULL);
//call onOpen to let panel know when it's about to be shown or activated

78
indra/llui/llresizebar.cpp
View File

@ -35,46 +35,18 @@
#include "llfocusmgr.h"
#include "llwindow.h"
class LLImagePanel : public LLPanel
{
public:
struct Params : public LLInitParam::Block<Params, LLPanel::Params>
{
Optional<bool> horizontal;
Params() : horizontal("horizontal", false) {}
};
LLImagePanel(const Params& p) : LLPanel(p), mHorizontal(p.horizontal) {}
virtual ~LLImagePanel() {}
void draw()
{
const LLRect& parent_rect = getParent()->getRect();
const LLRect& rect = getRect();
LLRect clip_rect( -rect.mLeft, parent_rect.getHeight() - rect.mBottom - 2
, parent_rect.getWidth() - rect.mLeft - (mHorizontal ? 2 : 0), -rect.mBottom);
LLLocalClipRect clip(clip_rect);
LLPanel::draw();
}
private:
bool mHorizontal;
};
static LLDefaultChildRegistry::Register<LLImagePanel> t1("resize_bar_image_panel");
LLResizeBar::Params::Params()
: max_size("max_size", S32_MAX),
snapping_enabled("snapping_enabled", true),
resizing_view("resizing_view"),
side("side"),
allow_double_click_snapping("allow_double_click_snapping", true),
show_drag_handle("show_drag_handle", false)
allow_double_click_snapping("allow_double_click_snapping", true)
{
name = "resize_bar";
}
LLResizeBar::LLResizeBar(const LLResizeBar::Params& p)
: LLPanel(p),
: LLView(p),
mDragLastScreenX( 0 ),
mDragLastScreenY( 0 ),
mLastMouseScreenX( 0 ),
@ -86,7 +58,6 @@ LLResizeBar::LLResizeBar(const LLResizeBar::Params& p)
mAllowDoubleClickSnapping(p.allow_double_click_snapping),
mResizingView(p.resizing_view),
mResizeListener(NULL),
mShowDragHandle(p.show_drag_handle),
mImagePanel(NULL)
{
setFollowsNone();
@ -116,36 +87,6 @@ LLResizeBar::LLResizeBar(const LLResizeBar::Params& p)
default:
break;
}
if (mShowDragHandle)
{
LLViewBorder::Params border_params;
border_params.border_thickness = 1;
border_params.highlight_light_color = LLUIColorTable::instance().getColor("ResizebarBorderLight");
border_params.shadow_dark_color = LLUIColorTable::instance().getColor("ResizebarBorderDark");
addBorder(border_params);
setBorderVisible(TRUE);
LLImagePanel::Params image_panel;
mDragHandleImage = LLUI::getUIImage(LLResizeBar::RIGHT == mSide ? "Vertical Drag Handle" : "Horizontal Drag Handle");
image_panel.bg_alpha_image = mDragHandleImage;
image_panel.background_visible = true;
image_panel.horizontal = (LLResizeBar::BOTTOM == mSide);
mImagePanel = LLUICtrlFactory::create<LLImagePanel>(image_panel);
setImagePanel(mImagePanel);
}
}
BOOL LLResizeBar::postBuild()
{
if (mShowDragHandle)
{
setBackgroundVisible(TRUE);
setTransparentColor(LLUIColorTable::instance().getColor("ResizebarBody"));
}
return LLPanel::postBuild();
}
BOOL LLResizeBar::handleMouseDown(S32 x, S32 y, MASK mask)
@ -433,18 +374,3 @@ LLPanel * LLResizeBar::getImagePanel() const
{
return getChildCount() > 0 ? (LLPanel *)getChildList()->back() : NULL;
}
void LLResizeBar::draw()
{
if (mShowDragHandle)
{
S32 image_width = mDragHandleImage->getTextureWidth();
S32 image_height = mDragHandleImage->getTextureHeight();
const LLRect& panel_rect = getRect();
S32 image_left = (panel_rect.getWidth() - image_width) / 2 - 1;
S32 image_bottom = (panel_rect.getHeight() - image_height) / 2;
mImagePanel->setRect(LLRect(image_left, image_bottom + image_height, image_left + image_width, image_bottom));
}
LLPanel::draw();
}

15
indra/llui/llresizebar.h
View File

@ -27,14 +27,14 @@
#ifndef LL_RESIZEBAR_H
#define LL_RESIZEBAR_H
#include "llpanel.h"
#include "llview.h"
class LLResizeBar : public LLPanel
class LLResizeBar : public LLView
{
public:
enum Side { LEFT, TOP, RIGHT, BOTTOM };
struct Params : public LLInitParam::Block<Params, LLPanel::Params>
struct Params : public LLInitParam::Block<Params, LLView::Params>
{
Mandatory<LLView*> resizing_view;
Mandatory<Side> side;
@ -43,7 +43,6 @@ public:
Optional<S32> max_size;
Optional<bool> snapping_enabled;
Optional<bool> allow_double_click_snapping;
Optional<bool> show_drag_handle;
Params();
};
@ -52,10 +51,8 @@ protected:
LLResizeBar(const LLResizeBar::Params& p);
friend class LLUICtrlFactory;
/*virtual*/ BOOL postBuild();
public:
virtual void draw();
virtual BOOL handleHover(S32 x, S32 y, MASK mask);
virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
@ -66,7 +63,6 @@ public:
void setAllowDoubleClickSnapping(BOOL allow) { mAllowDoubleClickSnapping = allow; }
bool canResize() { return getEnabled() && mMaxSize > mMinSize; }
void setResizeListener(boost::function<void(void*)> listener) {mResizeListener = listener;}
BOOL isShowDragHandle() const { return mShowDragHandle; }
void setImagePanel(LLPanel * panelp);
LLPanel * getImagePanel() const;
@ -79,9 +75,8 @@ private:
S32 mMinSize;
S32 mMaxSize;
const Side mSide;
BOOL mSnappingEnabled;
BOOL mAllowDoubleClickSnapping;
BOOL mShowDragHandle;
bool mSnappingEnabled,
mAllowDoubleClickSnapping;
LLView* mResizingView;
boost::function<void(void*)> mResizeListener;
LLPointer<LLUIImage> mDragHandleImage;

153
indra/llui/lluictrl.cpp
View File

@ -33,6 +33,8 @@
#include "llfocusmgr.h"
#include "llpanel.h"
#include "lluictrlfactory.h"
#include "lltabcontainer.h"
#include "llaccordionctrltab.h"
static LLDefaultChildRegistry::Register<LLUICtrl> r("ui_ctrl");
@ -702,54 +704,19 @@ BOOL LLUICtrl::getIsChrome() const
}
}
// this comparator uses the crazy disambiguating logic of LLCompareByTabOrder,
// but to switch up the order so that children that have the default tab group come first
// and those that are prior to the default tab group come last
class CompareByDefaultTabGroup: public LLCompareByTabOrder
{
public:
CompareByDefaultTabGroup(const LLView::child_tab_order_t& order, S32 default_tab_group):
LLCompareByTabOrder(order),
mDefaultTabGroup(default_tab_group) {}
private:
/*virtual*/ bool compareTabOrders(const LLView::tab_order_t & a, const LLView::tab_order_t & b) const
{
S32 ag = a.first; // tab group for a
S32 bg = b.first; // tab group for b
// these two ifs have the effect of moving elements prior to the default tab group to the end of the list
// (still sorted relative to each other, though)
if(ag < mDefaultTabGroup && bg >= mDefaultTabGroup) return false;
if(bg < mDefaultTabGroup && ag >= mDefaultTabGroup) return true;
return a < b; // sort correctly if they're both on the same side of the default tab group
}
S32 mDefaultTabGroup;
};
// Sorter for plugging into the query.
// I'd have defined it local to the one method that uses it but that broke the VS 05 compiler. -MG
class LLUICtrl::DefaultTabGroupFirstSorter : public LLQuerySorter, public LLSingleton<DefaultTabGroupFirstSorter>
{
public:
/*virtual*/ void operator() (LLView * parent, viewList_t &children) const
{
children.sort(CompareByDefaultTabGroup(parent->getCtrlOrder(), parent->getDefaultTabGroup()));
}
};
LLTrace::BlockTimerStatHandle FTM_FOCUS_FIRST_ITEM("Focus First Item");
BOOL LLUICtrl::focusFirstItem(BOOL prefer_text_fields, BOOL focus_flash)
{
LL_RECORD_BLOCK_TIME(FTM_FOCUS_FIRST_ITEM);
// try to select default tab group child
LLCtrlQuery query = getTabOrderQuery();
// sort things such that the default tab group is at the front
query.setSorter(DefaultTabGroupFirstSorter::getInstance());
LLViewQuery query = getTabOrderQuery();
child_list_t result = query(this);
if(result.size() > 0)
{
LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.front());
LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.back());
if(!ctrl->hasFocus())
{
ctrl->setFocus(TRUE);
@ -764,43 +731,7 @@ BOOL LLUICtrl::focusFirstItem(BOOL prefer_text_fields, BOOL focus_flash)
// search for text field first
if(prefer_text_fields)
{
LLCtrlQuery query = getTabOrderQuery();
query.addPreFilter(LLUICtrl::LLTextInputFilter::getInstance());
child_list_t result = query(this);
if(result.size() > 0)
{
LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.front());
if(!ctrl->hasFocus())
{
ctrl->setFocus(TRUE);
ctrl->onTabInto();
gFocusMgr.triggerFocusFlash();
}
return TRUE;
}
}
// no text field found, or we don't care about text fields
result = getTabOrderQuery().run(this);
if(result.size() > 0)
{
LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.front());
if(!ctrl->hasFocus())
{
ctrl->setFocus(TRUE);
ctrl->onTabInto();
gFocusMgr.triggerFocusFlash();
}
return TRUE;
}
return FALSE;
}
BOOL LLUICtrl::focusLastItem(BOOL prefer_text_fields)
{
// search for text field first
if(prefer_text_fields)
{
LLCtrlQuery query = getTabOrderQuery();
LLViewQuery query = getTabOrderQuery();
query.addPreFilter(LLUICtrl::LLTextInputFilter::getInstance());
child_list_t result = query(this);
if(result.size() > 0)
@ -810,13 +741,16 @@ BOOL LLUICtrl::focusLastItem(BOOL prefer_text_fields)
{
ctrl->setFocus(TRUE);
ctrl->onTabInto();
gFocusMgr.triggerFocusFlash();
if(focus_flash)
{
gFocusMgr.triggerFocusFlash();
}
}
return TRUE;
}
}
// no text field found, or we don't care about text fields
child_list_t result = getTabOrderQuery().run(this);
result = getTabOrderQuery().run(this);
if(result.size() > 0)
{
LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.back());
@ -824,17 +758,21 @@ BOOL LLUICtrl::focusLastItem(BOOL prefer_text_fields)
{
ctrl->setFocus(TRUE);
ctrl->onTabInto();
gFocusMgr.triggerFocusFlash();
if(focus_flash)
{
gFocusMgr.triggerFocusFlash();
}
}
return TRUE;
}
return FALSE;
}
BOOL LLUICtrl::focusNextItem(BOOL text_fields_only)
{
// this assumes that this method is called on the focus root.
LLCtrlQuery query = getTabOrderQuery();
LLViewQuery query = getTabOrderQuery();
static LLUICachedControl<bool> tab_to_text_fields_only ("TabToTextFieldsOnly", false);
if(text_fields_only || tab_to_text_fields_only)
{
@ -847,7 +785,7 @@ BOOL LLUICtrl::focusNextItem(BOOL text_fields_only)
BOOL LLUICtrl::focusPrevItem(BOOL text_fields_only)
{
// this assumes that this method is called on the focus root.
LLCtrlQuery query = getTabOrderQuery();
LLViewQuery query = getTabOrderQuery();
static LLUICachedControl<bool> tab_to_text_fields_only ("TabToTextFieldsOnly", false);
if(text_fields_only || tab_to_text_fields_only)
{
@ -904,8 +842,26 @@ bool LLUICtrl::findHelpTopic(std::string& help_topic_out)
if (panel)
{
LLView *child;
LLPanel *subpanel = NULL;
// does the panel have a sub-panel with a help topic?
LLPanel *subpanel = panel->childGetVisiblePanelWithHelp();
bfs_tree_iterator_t it = beginTreeBFS();
// skip ourselves
++it;
for (; it != endTreeBFS(); ++it)
{
child = *it;
// do we have a panel with a help topic?
LLPanel *panel = dynamic_cast<LLPanel *>(child);
if (panel && panel->isInVisibleChain() && !panel->getHelpTopic().empty())
{
subpanel = panel;
break;
}
}
if (subpanel)
{
help_topic_out = subpanel->getHelpTopic();
@ -913,10 +869,41 @@ bool LLUICtrl::findHelpTopic(std::string& help_topic_out)
}
// does the panel have an active tab with a help topic?
LLPanel *tab = panel->childGetVisibleTabWithHelp();
if (tab)
LLPanel *tab_panel = NULL;
it = beginTreeBFS();
// skip ourselves
++it;
for (; it != endTreeBFS(); ++it)
{
help_topic_out = tab->getHelpTopic();
child = *it;
LLPanel *curTabPanel = NULL;
// do we have a tab container?
LLTabContainer *tab = dynamic_cast<LLTabContainer *>(child);
if (tab && tab->getVisible())
{
curTabPanel = tab->getCurrentPanel();
}
// do we have an accordion tab?
LLAccordionCtrlTab* accordion = dynamic_cast<LLAccordionCtrlTab *>(child);
if (accordion && accordion->getDisplayChildren())
{
curTabPanel = dynamic_cast<LLPanel *>(accordion->getAccordionView());
}
// if we found a valid tab, does it have a help topic?
if (curTabPanel && !curTabPanel->getHelpTopic().empty())
{
tab_panel = curTabPanel;
break;
}
}
if (tab_panel)
{
help_topic_out = tab_panel->getHelpTopic();
return true; // success (tab)
}

3
indra/llui/lluictrl.h
View File

@ -220,7 +220,6 @@ public:
BOOL focusNextItem(BOOL text_entry_only);
BOOL focusPrevItem(BOOL text_entry_only);
BOOL focusFirstItem(BOOL prefer_text_fields = FALSE, BOOL focus_flash = TRUE );
BOOL focusLastItem(BOOL prefer_text_fields = FALSE);
// Non Virtuals
LLHandle<LLUICtrl> getHandle() const { return getDerivedHandle<LLUICtrl>(); }
@ -315,8 +314,6 @@ private:
BOOL mTentative;
ETypeTransparency mTransparencyType;
class DefaultTabGroupFirstSorter;
};
// Build time optimization, generate once in .cpp file

218
indra/llui/llview.cpp
View File

@ -140,7 +140,6 @@ LLView::LLView(const LLView::Params& p)
mFromXUI(p.from_xui),
mIsFocusRoot(p.focus_root),
mLastVisible(FALSE),
mNextInsertionOrdinal(0),
mHoverCursor(getCursorFromString(p.hover_cursor)),
mEnabled(p.enabled),
mMouseOpaque(p.mouse_opaque),
@ -275,22 +274,6 @@ void LLView::sendChildToBack(LLView* child)
}
}
void LLView::moveChildToFrontOfTabGroup(LLUICtrl* child)
{
if(mCtrlOrder.find(child) != mCtrlOrder.end())
{
mCtrlOrder[child].second = -1 * mNextInsertionOrdinal++;
}
}
void LLView::moveChildToBackOfTabGroup(LLUICtrl* child)
{
if(mCtrlOrder.find(child) != mCtrlOrder.end())
{
mCtrlOrder[child].second = mNextInsertionOrdinal++;
}
}
// virtual
bool LLView::addChild(LLView* child, S32 tab_group)
{
@ -298,7 +281,8 @@ bool LLView::addChild(LLView* child, S32 tab_group)
{
return false;
}
if (mParentView == child)
if (this == child)
{
LL_ERRS() << "Adding view " << child->getName() << " as child of itself" << LL_ENDL;
}
@ -312,14 +296,10 @@ bool LLView::addChild(LLView* child, S32 tab_group)
// add to front of child list, as normal
mChildList.push_front(child);
// add to ctrl list if is LLUICtrl
if (child->isCtrl())
// add to tab order list
if (tab_group != 0)
{
LLUICtrl* ctrl = static_cast<LLUICtrl*>(child);
mCtrlOrder.insert(tab_order_pair_t(ctrl,
tab_order_t(tab_group, mNextInsertionOrdinal)));
mNextInsertionOrdinal++;
mTabOrder.insert(tab_order_pair_t(child, tab_group));
}
child->mParentView = this;
@ -350,13 +330,10 @@ void LLView::removeChild(LLView* child)
llassert(child->mInDraw == false);
mChildList.remove( child );
child->mParentView = NULL;
if (child->isCtrl())
child_tab_order_t::iterator found = mTabOrder.find(child);
if(found != mTabOrder.end())
{
child_tab_order_t::iterator found = mCtrlOrder.find(static_cast<LLUICtrl*>(child));
if(found != mCtrlOrder.end())
{
mCtrlOrder.erase(found);
}
mTabOrder.erase(found);
}
}
else
@ -366,53 +343,6 @@ void LLView::removeChild(LLView* child)
updateBoundingRect();
}
LLView::ctrl_list_t LLView::getCtrlList() const
{
ctrl_list_t controls;
BOOST_FOREACH(LLView* viewp, mChildList)
{
if(viewp->isCtrl())
{
controls.push_back(static_cast<LLUICtrl*>(viewp));
}
}
return controls;
}
LLView::ctrl_list_t LLView::getCtrlListSorted() const
{
ctrl_list_t controls = getCtrlList();
std::sort(controls.begin(), controls.end(), LLCompareByTabOrder(mCtrlOrder));
return controls;
}
// This method compares two LLViews by the tab order specified in the comparator object. The
// code for this is a little convoluted because each argument can have four states:
// 1) not a control, 2) a control but not in the tab order, 3) a control in the tab order, 4) null
bool LLCompareByTabOrder::operator() (const LLView* const a, const LLView* const b) const
{
S32 a_score = 0, b_score = 0;
if(a) a_score--;
if(b) b_score--;
if(a && a->isCtrl()) a_score--;
if(b && b->isCtrl()) b_score--;
if(a_score == -2 && b_score == -2)
{
const LLUICtrl * const a_ctrl = static_cast<const LLUICtrl*>(a);
const LLUICtrl * const b_ctrl = static_cast<const LLUICtrl*>(b);
LLView::child_tab_order_const_iter_t a_found = mTabOrder.find(a_ctrl), b_found = mTabOrder.find(b_ctrl);
if(a_found != mTabOrder.end()) a_score--;
if(b_found != mTabOrder.end()) b_score--;
if(a_score == -3 && b_score == -3)
{
// whew! Once we're in here, they're both in the tab order, and we can compare based on that
return compareTabOrders(a_found->second, b_found->second);
}
}
return (a_score == b_score) ? a < b : a_score < b_score;
}
BOOL LLView::isInVisibleChain() const
{
BOOL visible = TRUE;
@ -535,42 +465,6 @@ BOOL LLView::focusPrevRoot()
// static
BOOL LLView::focusNext(LLView::child_list_t & result)
{
LLView::child_list_iter_t focused = result.end();
for(LLView::child_list_iter_t iter = result.begin();
iter != result.end();
++iter)
{
if(gFocusMgr.childHasKeyboardFocus(*iter))
{
focused = iter;
break;
}
}
LLView::child_list_iter_t next = focused;
next = (next == result.end()) ? result.begin() : ++next;
while(next != focused)
{
// wrap around to beginning if necessary
if(next == result.end())
{
next = result.begin();
}
if((*next)->isCtrl())
{
LLUICtrl * ctrl = static_cast<LLUICtrl*>(*next);
ctrl->setFocus(TRUE);
ctrl->onTabInto();
gFocusMgr.triggerFocusFlash();
return TRUE;
}
++next;
}
return FALSE;
}
// static
BOOL LLView::focusPrev(LLView::child_list_t & result)
{
LLView::child_list_reverse_iter_t focused = result.rend();
for(LLView::child_list_reverse_iter_t iter = result.rbegin();
@ -593,6 +487,42 @@ BOOL LLView::focusPrev(LLView::child_list_t & result)
next = result.rbegin();
}
if((*next)->isCtrl())
{
LLUICtrl * ctrl = static_cast<LLUICtrl*>(*next);
ctrl->setFocus(TRUE);
ctrl->onTabInto();
gFocusMgr.triggerFocusFlash();
return TRUE;
}
++next;
}
return FALSE;
}
// static
BOOL LLView::focusPrev(LLView::child_list_t & result)
{
LLView::child_list_iter_t focused = result.end();
for(LLView::child_list_iter_t iter = result.begin();
iter != result.end();
++iter)
{
if(gFocusMgr.childHasKeyboardFocus(*iter))
{
focused = iter;
break;
}
}
LLView::child_list_iter_t next = focused;
next = (next == result.end()) ? result.begin() : ++next;
while(next != focused)
{
// wrap around to beginning if necessary
if(next == result.end())
{
next = result.begin();
}
if((*next)->isCtrl())
{
LLUICtrl * ctrl = static_cast<LLUICtrl*>(*next);
if (!ctrl->hasFocus())
@ -614,7 +544,7 @@ BOOL LLView::focusPrev(LLView::child_list_t & result)
void LLView::deleteAllChildren()
{
// clear out the control ordering
mCtrlOrder.clear();
mTabOrder.clear();
while (!mChildList.empty())
{
@ -1823,15 +1753,63 @@ BOOL LLView::localRectToOtherView( const LLRect& local, LLRect* other, const LLV
return FALSE;
}
// static
const LLCtrlQuery & LLView::getTabOrderQuery()
class CompareByTabOrder
{
static LLCtrlQuery query;
public:
CompareByTabOrder(const LLView::child_tab_order_t& order, S32 default_tab_group = 0)
: mTabOrder(order),
mDefaultTabGroup(default_tab_group)
{}
virtual ~CompareByTabOrder() {}
// This method compares two LLViews by the tab order specified in the comparator object. The
// code for this is a little convoluted because each argument can have four states:
// 1) not a control, 2) a control but not in the tab order, 3) a control in the tab order, 4) null
bool operator() (const LLView* const a, const LLView* const b) const
{
S32 a_group = 0, b_group = 0;
if(!a) return false;
if(!b) return true;
LLView::child_tab_order_const_iter_t a_found = mTabOrder.find(a), b_found = mTabOrder.find(b);
if(a_found != mTabOrder.end())
{
a_group = a_found->second;
}
if(b_found != mTabOrder.end())
{
b_group = b_found->second;
}
if(a_group < mDefaultTabGroup && b_group >= mDefaultTabGroup) return true;
if(b_group < mDefaultTabGroup && a_group >= mDefaultTabGroup) return false;
return a_group > b_group; // sort correctly if they're both on the same side of the default tab groupreturn a > b;
}
private:
// ok to store a reference, as this should only be allocated on stack during view query operations
const LLView::child_tab_order_t& mTabOrder;
const S32 mDefaultTabGroup;
};
class SortByTabOrder : public LLQuerySorter, public LLSingleton<SortByTabOrder>
{
/*virtual*/ void sort(LLView * parent, LLView::child_list_t &children) const
{
children.sort(CompareByTabOrder(parent->getTabOrder(), parent->getDefaultTabGroup()));
}
};
// static
const LLViewQuery & LLView::getTabOrderQuery()
{
static LLViewQuery query;
if(query.getPreFilters().size() == 0) {
query.addPreFilter(LLVisibleFilter::getInstance());
query.addPreFilter(LLEnabledFilter::getInstance());
query.addPreFilter(LLTabStopFilter::getInstance());
query.addPostFilter(LLLeavesFilter::getInstance());
query.setSorter(SortByTabOrder::getInstance());
}
return query;
}
@ -1846,9 +1824,9 @@ class LLFocusRootsFilter : public LLQueryFilter, public LLSingleton<LLFocusRoots
};
// static
const LLCtrlQuery & LLView::getFocusRootsQuery()
const LLViewQuery & LLView::getFocusRootsQuery()
{
static LLCtrlQuery query;
static LLViewQuery query;
if(query.getPreFilters().size() == 0) {
query.addPreFilter(LLVisibleFilter::getInstance());
query.addPreFilter(LLEnabledFilter::getInstance());

34
indra/llui/llview.h
View File

@ -200,12 +200,9 @@ public:
typedef child_list_t::reverse_iterator child_list_reverse_iter_t;
typedef child_list_t::const_reverse_iterator child_list_const_reverse_iter_t;
typedef std::vector<class LLUICtrl *> ctrl_list_t;
typedef std::pair<S32, S32> tab_order_t;
typedef std::pair<LLUICtrl *, tab_order_t> tab_order_pair_t;
typedef std::pair<LLView *, S32> tab_order_pair_t;
// this structure primarily sorts by the tab group, secondarily by the insertion ordinal (lastly by the value of the pointer)
typedef std::map<const LLUICtrl*, tab_order_t> child_tab_order_t;
typedef std::map<const LLView*, S32> child_tab_order_t;
typedef child_tab_order_t::iterator child_tab_order_iter_t;
typedef child_tab_order_t::const_iterator child_tab_order_const_iter_t;
typedef child_tab_order_t::reverse_iterator child_tab_order_reverse_iter_t;
@ -251,8 +248,6 @@ public:
void sendChildToFront(LLView* child);
void sendChildToBack(LLView* child);
void moveChildToFrontOfTabGroup(LLUICtrl* child);
void moveChildToBackOfTabGroup(LLUICtrl* child);
virtual bool addChild(LLView* view, S32 tab_group = 0);
@ -264,9 +259,7 @@ public:
virtual BOOL postBuild() { return TRUE; }
const child_tab_order_t& getCtrlOrder() const { return mCtrlOrder; }
ctrl_list_t getCtrlList() const;
ctrl_list_t getCtrlListSorted() const;
const child_tab_order_t& getTabOrder() const { return mTabOrder; }
void setDefaultTabGroup(S32 d) { mDefaultTabGroup = d; }
S32 getDefaultTabGroup() const { return mDefaultTabGroup; }
@ -500,9 +493,9 @@ public:
static BOOL focusPrev(LLView::child_list_t & result);
// returns query for iterating over controls in tab order
static const LLCtrlQuery & getTabOrderQuery();
static const LLViewQuery & getTabOrderQuery();
// return query for iterating over focus roots in tab order
static const LLCtrlQuery & getFocusRootsQuery();
static const LLViewQuery & getFocusRootsQuery();
static LLWindow* getWindow(void) { return LLUI::sWindow; }
@ -596,7 +589,7 @@ private:
U32 mReshapeFlags;
child_tab_order_t mCtrlOrder;
child_tab_order_t mTabOrder;
S32 mDefaultTabGroup;
S32 mLastTabGroup;
@ -613,8 +606,6 @@ private:
BOOL mLastVisible;
S32 mNextInsertionOrdinal;
bool mInDraw;
static LLWindow* sWindow; // All root views must know about their window.
@ -686,19 +677,6 @@ struct TypeValues<LLView::EOrientation> : public LLInitParam::TypeValuesHelper<L
};
}
class LLCompareByTabOrder
{
public:
LLCompareByTabOrder(const LLView::child_tab_order_t& order) : mTabOrder(order) {}
virtual ~LLCompareByTabOrder() {}
bool operator() (const LLView* const a, const LLView* const b) const;
private:
virtual bool compareTabOrders(const LLView::tab_order_t & a, const LLView::tab_order_t & b) const { return a < b; }
// ok to store a reference, as this should only be allocated on stack during view query operations
const LLView::child_tab_order_t& mTabOrder;
};
template <class T> T* LLView::getChild(const std::string& name, BOOL recurse) const
{
LLView* child = findChildView(name, recurse);

25
indra/llui/llviewquery.cpp
View File

@ -30,7 +30,7 @@
#include "lluictrl.h"
#include "llviewquery.h"
void LLQuerySorter::operator() (LLView * parent, viewList_t &children) const {}
void LLQuerySorter::sort(LLView * parent, viewList_t &children) const {}
filterResult_t LLLeavesFilter::operator() (const LLView* const view, const viewList_t & children) const
{
@ -89,8 +89,8 @@ viewList_t LLViewQuery::run(LLView* view) const
if (pre.first)
{
post = runFilters(view, filtered_children, mPostFilters);
}
}
}
if(pre.first && post.first)
{
@ -105,12 +105,12 @@ viewList_t LLViewQuery::run(LLView* view) const
return result;
}
void LLViewQuery::filterChildren(LLView * view, viewList_t & filtered_children) const
void LLViewQuery::filterChildren(LLView* parent_view, viewList_t & filtered_children) const
{
LLView::child_list_t views(*(view->getChildList()));
LLView::child_list_t views(*(parent_view->getChildList()));
if (mSorterp)
{
(*mSorterp)(view, views); // sort the children per the sorter
mSorterp->sort(parent_view, views); // sort the children per the sorter
}
for(LLView::child_list_iter_t iter = views.begin();
iter != views.end();
@ -134,18 +134,3 @@ filterResult_t LLViewQuery::runFilters(LLView * view, const viewList_t children,
}
return result;
}
class SortByTabOrder : public LLQuerySorter, public LLSingleton<SortByTabOrder>
{
/*virtual*/ void operator() (LLView * parent, LLView::child_list_t &children) const
{
children.sort(LLCompareByTabOrder(parent->getCtrlOrder()));
}
};
LLCtrlQuery::LLCtrlQuery() :
LLViewQuery()
{
setSorter(SortByTabOrder::getInstance());
}

7
indra/llui/llviewquery.h
View File

@ -49,7 +49,7 @@ class LLQuerySorter
{
public:
virtual ~LLQuerySorter() {};
virtual void operator() (LLView * parent, viewList_t &children) const;
virtual void sort(LLView * parent, viewList_t &children) const;
};
class LLLeavesFilter : public LLQueryFilter, public LLSingleton<LLLeavesFilter>
@ -127,10 +127,5 @@ private:
const LLQuerySorter* mSorterp;
};
class LLCtrlQuery : public LLViewQuery
{
public:
LLCtrlQuery();
};
#endif // LL_LLVIEWQUERY_H

5
indra/media_plugins/winmmshim/winmm_shim.cpp
View File

@ -39,7 +39,10 @@ BOOL APIENTRY DllMain( HMODULE hModule,
LPVOID lpReserved
)
{
InitializeCriticalSection(&sCriticalSection);
if (ul_reason_for_call == DLL_PROCESS_ATTACH)
{
InitializeCriticalSection(&sCriticalSection);
}
return TRUE;
}

44
indra/newview/app_settings/settings.xml
View File

@ -11981,50 +11981,6 @@
<key>Value</key>
<integer>1</integer>
</map>
<key>UIAvatariconctrlSymbolHPad</key>
<map>
<key>Comment</key>
<string>UI Avatar Icon Control Symbol Horizontal Pad</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>S32</string>
<key>Value</key>
<real>2</real>
</map>
<key>UIAvatariconctrlSymbolVPad</key>
<map>
<key>Comment</key>
<string>UI Avatar Icon Control Symbol Vertical Pad</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>S32</string>
<key>Value</key>
<real>2</real>
</map>
<key>UIAvatariconctrlSymbolSize</key>
<map>
<key>Comment</key>
<string>UI Avatar Icon Control Symbol Size</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>S32</string>
<key>Value</key>
<real>5</real>
</map>
<key>UIAvatariconctrlSymbolPosition</key>
<map>
<key>Comment</key>
<string>UI Avatar Icon Control Symbol Position (TopLeft|TopRight|BottomLeft|BottomRight)</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>String</string>
<key>Value</key>
<string>BottomRight</string>
</map>
<key>UIButtonOrigHPad</key>
<map>
<key>Comment</key>

73
indra/newview/llavatariconctrl.cpp
View File

@ -49,6 +49,18 @@
static LLDefaultChildRegistry::Register<LLAvatarIconCtrl> r("avatar_icon");
namespace LLInitParam
{
void TypeValues<LLAvatarIconCtrlEnums::ESymbolPos>::declareValues()
{
declare("BottomLeft", LLAvatarIconCtrlEnums::BOTTOM_LEFT);
declare("BottomRight", LLAvatarIconCtrlEnums::BOTTOM_RIGHT);
declare("TopLeft", LLAvatarIconCtrlEnums::TOP_LEFT);
declare("TopRight", LLAvatarIconCtrlEnums::TOP_RIGHT);
}
}
bool LLAvatarIconIDCache::LLAvatarIconIDCacheItem::expired()
{
const F64 SEC_PER_DAY_PLUS_HOUR = (24.0 + 1.0) * 60.0 * 60.0;
@ -145,52 +157,63 @@ void LLAvatarIconIDCache::remove (const LLUUID& avatar_id)
LLAvatarIconCtrl::Params::Params()
: avatar_id("avatar_id"),
draw_tooltip("draw_tooltip", true),
default_icon_name("default_icon_name")
default_icon_name("default_icon_name"),
symbol_hpad("symbol_hpad"),
symbol_vpad("symbol_vpad"),
symbol_size("symbol_size", 1),
symbol_pos("symbol_pos", LLAvatarIconCtrlEnums::BOTTOM_RIGHT)
{
changeDefault(min_width, 32);
changeDefault(min_height, 32);
}
LLAvatarIconCtrl::LLAvatarIconCtrl(const LLAvatarIconCtrl::Params& p)
: LLIconCtrl(p),
: LLIconCtrl(p),
LLAvatarPropertiesObserver(),
mAvatarId(),
mFullName(),
mDrawTooltip(p.draw_tooltip),
mDefaultIconName(p.default_icon_name),
mAvatarNameCacheConnection()
mAvatarNameCacheConnection(),
mSymbolHpad(p.symbol_hpad),
mSymbolVpad(p.symbol_vpad),
mSymbolSize(p.symbol_size),
mSymbolPos(p.symbol_pos)
{
mPriority = LLViewerFetchedTexture::BOOST_ICON;
LLRect rect = p.rect;
mDrawWidth = llmax(32, rect.getWidth()) ;
mDrawHeight = llmax(32, rect.getHeight()) ;
static LLUICachedControl<S32> llavatariconctrl_symbol_hpad("UIAvatariconctrlSymbolHPad", 2);
static LLUICachedControl<S32> llavatariconctrl_symbol_vpad("UIAvatariconctrlSymbolVPad", 2);
static LLUICachedControl<S32> llavatariconctrl_symbol_size("UIAvatariconctrlSymbolSize", 5);
static LLUICachedControl<std::string> llavatariconctrl_symbol_pos("UIAvatariconctrlSymbolPosition", "BottomRight");
// BottomRight is the default position
S32 left = rect.getWidth() - llavatariconctrl_symbol_size - llavatariconctrl_symbol_hpad;
S32 bottom = llavatariconctrl_symbol_vpad;
S32 left = rect.getWidth() - mSymbolSize - mSymbolHpad;
S32 bottom = mSymbolVpad;
if ("BottomLeft" == (std::string)llavatariconctrl_symbol_pos)
switch(mSymbolPos)
{
left = llavatariconctrl_symbol_hpad;
bottom = llavatariconctrl_symbol_vpad;
}
else if ("TopLeft" == (std::string)llavatariconctrl_symbol_pos)
case LLAvatarIconCtrlEnums::BOTTOM_LEFT:
{
left = llavatariconctrl_symbol_hpad;
bottom = rect.getHeight() - llavatariconctrl_symbol_size - llavatariconctrl_symbol_vpad;
}
else if ("TopRight" == (std::string)llavatariconctrl_symbol_pos)
{
left = rect.getWidth() - llavatariconctrl_symbol_size - llavatariconctrl_symbol_hpad;
bottom = rect.getHeight() - llavatariconctrl_symbol_size - llavatariconctrl_symbol_vpad;
left = mSymbolHpad;
bottom = mSymbolVpad;
}
rect.setOriginAndSize(left, bottom, llavatariconctrl_symbol_size, llavatariconctrl_symbol_size);
case LLAvatarIconCtrlEnums::TOP_LEFT:
{
left = mSymbolHpad;
bottom = rect.getHeight() - mSymbolSize - mSymbolVpad;
}
case LLAvatarIconCtrlEnums::TOP_RIGHT:
{
left = rect.getWidth() - mSymbolSize - mSymbolHpad;
bottom = rect.getHeight() - mSymbolSize - mSymbolVpad;
}
case LLAvatarIconCtrlEnums::BOTTOM_RIGHT:
// fallthrough, is default
default:
rect.setOriginAndSize(left, bottom, mSymbolSize, mSymbolSize);
}
if (p.avatar_id.isProvided())
{

46
indra/newview/llavatariconctrl.h
View File

@ -29,7 +29,7 @@
#include <boost/signals2.hpp>
#include "../llui/lliconctrl.h"
#include "lliconctrl.h"
#include "llavatarpropertiesprocessor.h"
#include "llviewermenu.h"
@ -41,14 +41,14 @@ public:
struct LLAvatarIconIDCacheItem
{
LLUUID icon_id;
LLDate cached_time;
LLDate cached_time;
bool expired();
};
LLAvatarIconIDCache():mFilename("avatar_icons_cache.txt")
{
}
LLAvatarIconIDCache()
: mFilename("avatar_icons_cache.txt")
{}
void load ();
void save ();
@ -64,15 +64,41 @@ protected:
std::map<LLUUID,LLAvatarIconIDCacheItem> mCache;//we cache only LLUID and time
};
namespace LLAvatarIconCtrlEnums
{
enum ESymbolPos
{
BOTTOM_LEFT,
BOTTOM_RIGHT,
TOP_LEFT,
TOP_RIGHT
};
}
namespace LLInitParam
{
template<>
struct TypeValues<LLAvatarIconCtrlEnums::ESymbolPos> : public TypeValuesHelper<LLAvatarIconCtrlEnums::ESymbolPos>
{
static void declareValues();
};
}
class LLAvatarIconCtrl
: public LLIconCtrl, public LLAvatarPropertiesObserver
{
public:
struct Params : public LLInitParam::Block<Params, LLIconCtrl::Params>
{
Optional <LLUUID> avatar_id;
Optional <bool> draw_tooltip;
Optional <std::string> default_icon_name;
Optional<LLUUID> avatar_id;
Optional<bool> draw_tooltip;
Optional<std::string> default_icon_name;
Optional<S32> symbol_hpad,
symbol_vpad,
symbol_size;
Optional<LLAvatarIconCtrlEnums::ESymbolPos> symbol_pos;
Params();
};
@ -98,6 +124,10 @@ protected:
std::string mFullName;
bool mDrawTooltip;
std::string mDefaultIconName;
S32 mSymbolHpad,
mSymbolVpad,
mSymbolSize;
LLAvatarIconCtrlEnums::ESymbolPos mSymbolPos;
bool updateFromCache();

2
indra/newview/llfloateravatarpicker.cpp
View File

@ -736,7 +736,7 @@ void LLFloaterAvatarPicker::processResponse(const LLUUID& query_id, const LLSD&
if (search_results->isEmpty())
{
LLStringUtil::format_map_t map;
map["[TEXT]"] = childGetText("Edit");
map["[TEXT]"] = getChild<LLUICtrl>("Edit")->getValue().asString();
LLSD item;
item["id"] = LLUUID::null;
item["columns"][0]["column"] = "name";

32
indra/newview/llfloatermodelpreview.cpp
View File

@ -591,7 +591,7 @@ bool LLFloaterModelPreview::isViewOptionChecked(const LLSD& userdata)
bool LLFloaterModelPreview::isViewOptionEnabled(const LLSD& userdata)
{
return childIsEnabled(userdata.asString());
return getChildView(userdata.asString())->getEnabled();
}
void LLFloaterModelPreview::setViewOptionEnabled(const std::string& option, bool enabled)
@ -3587,11 +3587,11 @@ void LLModelPreview::loadModel(std::string filename, S32 lod, bool force_disable
if (lod == mPreviewLOD)
{
mFMP->childSetText("lod_file_" + lod_name[lod], mLODFile[lod]);
mFMP->childSetValue("lod_file_" + lod_name[lod], mLODFile[lod]);
}
else if (lod == LLModel::LOD_PHYSICS)
{
mFMP->childSetText("physics_file", mLODFile[lod]);
mFMP->childSetValue("physics_file", mLODFile[lod]);
}
mFMP->openFloater();
@ -3606,7 +3606,7 @@ void LLModelPreview::setPhysicsFromLOD(S32 lod)
mModel[LLModel::LOD_PHYSICS] = mModel[lod];
mScene[LLModel::LOD_PHYSICS] = mScene[lod];
mLODFile[LLModel::LOD_PHYSICS].clear();
mFMP->childSetText("physics_file", mLODFile[LLModel::LOD_PHYSICS]);
mFMP->childSetValue("physics_file", mLODFile[LLModel::LOD_PHYSICS]);
mVertexBuffer[LLModel::LOD_PHYSICS].clear();
rebuildUploadData();
refresh();
@ -4322,8 +4322,8 @@ void LLModelPreview::updateStatusMessages()
if (total_tris[lod] > 0)
{
mFMP->childSetText(lod_triangles_name[lod], llformat("%d", total_tris[lod]));
mFMP->childSetText(lod_vertices_name[lod], llformat("%d", total_verts[lod]));
mFMP->childSetValue(lod_triangles_name[lod], llformat("%d", total_tris[lod]));
mFMP->childSetValue(lod_vertices_name[lod], llformat("%d", total_verts[lod]));
}
else
{
@ -4344,8 +4344,8 @@ void LLModelPreview::updateStatusMessages()
}
}
mFMP->childSetText(lod_triangles_name[lod], mesh_status_na);
mFMP->childSetText(lod_vertices_name[lod], mesh_status_na);
mFMP->childSetValue(lod_triangles_name[lod], mesh_status_na);
mFMP->childSetValue(lod_vertices_name[lod], mesh_status_na);
}
const U32 lod_high = LLModel::LOD_HIGH;
@ -4394,7 +4394,7 @@ void LLModelPreview::updateStatusMessages()
if (lod == mPreviewLOD)
{
mFMP->childSetText("lod_status_message_text", mFMP->getString(message));
mFMP->childSetValue("lod_status_message_text", mFMP->getString(message));
icon = mFMP->getChild<LLIconCtrl>("lod_status_message_icon");
icon->setImage(img);
}
@ -4645,12 +4645,12 @@ void LLModelPreview::updateLodControls(S32 lod)
fmp->mLODMode[lod] = 0;
for (U32 i = 0; i < num_file_controls; ++i)
{
mFMP->childShow(file_controls[i] + lod_name[lod]);
mFMP->childSetVisible(file_controls[i] + lod_name[lod], true);
}
for (U32 i = 0; i < num_lod_controls; ++i)
{
mFMP->childHide(lod_controls[i] + lod_name[lod]);
mFMP->childSetVisible(lod_controls[i] + lod_name[lod], true);
}
}
else if (lod_mode == USE_LOD_ABOVE) // use LoD above
@ -4658,12 +4658,12 @@ void LLModelPreview::updateLodControls(S32 lod)
fmp->mLODMode[lod] = 2;
for (U32 i = 0; i < num_file_controls; ++i)
{
mFMP->childHide(file_controls[i] + lod_name[lod]);
mFMP->childSetVisible(file_controls[i] + lod_name[lod], false);
}
for (U32 i = 0; i < num_lod_controls; ++i)
{
mFMP->childHide(lod_controls[i] + lod_name[lod]);
mFMP->childSetVisible(lod_controls[i] + lod_name[lod], false);
}
if (lod < LLModel::LOD_HIGH)
@ -4688,12 +4688,12 @@ void LLModelPreview::updateLodControls(S32 lod)
for (U32 i = 0; i < num_file_controls; ++i)
{
mFMP->childHide(file_controls[i] + lod_name[lod]);
mFMP->getChildView(file_controls[i] + lod_name[lod])->setVisible(false);
}
for (U32 i = 0; i < num_lod_controls; ++i)
{
mFMP->childShow(lod_controls[i] + lod_name[lod]);
mFMP->getChildView(lod_controls[i] + lod_name[lod])->setVisible(true);
}
@ -5644,7 +5644,7 @@ void LLModelPreview::setPreviewLOD(S32 lod)
LLComboBox* combo_box = mFMP->getChild<LLComboBox>("preview_lod_combo");
combo_box->setCurrentByIndex((NUM_LOD-1)-mPreviewLOD); // combo box list of lods is in reverse order
mFMP->childSetText("lod_file_" + lod_name[mPreviewLOD], mLODFile[mPreviewLOD]);
mFMP->childSetValue("lod_file_" + lod_name[mPreviewLOD], mLODFile[mPreviewLOD]);
LLComboBox* combo_box2 = mFMP->getChild<LLComboBox>("preview_lod_combo2");
combo_box2->setCurrentByIndex((NUM_LOD-1)-mPreviewLOD); // combo box list of lods is in reverse order

10
indra/newview/llpanelgroup.cpp
View File

@ -329,8 +329,9 @@ void LLPanelGroup::update(LLGroupChange gc)
if(gdatap)
{
std::string group_name = gdatap->mName.empty() ? LLTrans::getString("LoadingData") : gdatap->mName;
childSetValue("group_name", group_name);
childSetToolTip("group_name",group_name);
LLUICtrl* group_name_ctrl = getChild<LLUICtrl>("group_name");
group_name_ctrl->setValue(group_name);
group_name_ctrl->setToolTip(group_name);
LLGroupData agent_gdatap;
bool is_member = gAgent.getGroupData(mID,agent_gdatap) || gAgent.isGodlike();
@ -376,8 +377,9 @@ void LLPanelGroup::setGroupID(const LLUUID& group_id)
if(gdatap)
{
std::string group_name = gdatap->mName.empty() ? LLTrans::getString("LoadingData") : gdatap->mName;
childSetValue("group_name", group_name);
childSetToolTip("group_name",group_name);
LLUICtrl* group_name_ctrl = getChild<LLUICtrl>("group_name");
group_name_ctrl->setValue(group_name);
group_name_ctrl->setToolTip(group_name);
}
LLButton* button_apply = findChild<LLButton>("btn_apply");

14
indra/newview/llpaneloutfitsinventory.cpp
View File

@ -242,18 +242,12 @@ void LLPanelOutfitsInventory::updateListCommands()
bool wear_visible = !isCOFPanelActive();
bool make_outfit_enabled = isActionEnabled("save_outfit");
LLButton* wear_btn = mListCommands->getChild<LLButton>("wear_btn");
mMyOutfitsPanel->childSetEnabled("trash_btn", trash_enabled);
mListCommands->childSetEnabled("wear_btn", wear_enabled);
mListCommands->childSetVisible("wear_btn", wear_visible);
wear_btn->setEnabled(wear_enabled);
wear_btn->setVisible(wear_visible);
mSaveComboBtn->setMenuItemEnabled("save_outfit", make_outfit_enabled);
if (mMyOutfitsPanel->hasItemSelected())
{
mListCommands->childSetToolTip("wear_btn", getString("wear_items_tooltip"));
}
else
{
mListCommands->childSetToolTip("wear_btn", getString("wear_outfit_tooltip"));
}
wear_btn->setToolTip(getString(mMyOutfitsPanel->hasItemSelected() ? "wear_items_tooltip" : "wear_outfit_tooltip"));
}
void LLPanelOutfitsInventory::onTrashButtonClick()

2
indra/newview/llsidepanelinventory.cpp
View File

@ -161,7 +161,7 @@ BOOL LLSidepanelInventory::postBuild()
{
// UI elements from inventory panel
{
mInventoryPanel = getChild<LLPanel>("sidepanel__inventory_panel");
mInventoryPanel = getChild<LLPanel>("sidepanel_inventory_panel");
mInfoBtn = mInventoryPanel->getChild<LLButton>("info_btn");
mInfoBtn->setClickedCallback(boost::bind(&LLSidepanelInventory::onInfoButtonClicked, this));

8
indra/newview/llviewermenu.cpp
View File

@ -2537,11 +2537,11 @@ bool enable_object_touch(LLUICtrl* ctrl)
LLSelectNode* node = LLSelectMgr::getInstance()->getSelection()->getFirstRootNode();
if (node && node->mValid && !node->mTouchName.empty())
{
gMenuHolder->childSetText(item_name, node->mTouchName);
gMenuHolder->childSetValue(item_name, node->mTouchName);
}
else
{
gMenuHolder->childSetText(item_name, get_default_item_label(item_name));
gMenuHolder->childSetValue(item_name, get_default_item_label(item_name));
}
return new_value;
@ -5951,11 +5951,11 @@ bool enable_object_sit(LLUICtrl* ctrl)
LLSelectNode* node = LLSelectMgr::getInstance()->getSelection()->getFirstRootNode();
if (node && node->mValid && !node->mSitName.empty())
{
gMenuHolder->childSetText(item_name, node->mSitName);
gMenuHolder->childSetValue(item_name, node->mSitName);
}
else
{
gMenuHolder->childSetText(item_name, get_default_item_label(item_name));
gMenuHolder->childSetValue(item_name, get_default_item_label(item_name));
}
}
return !sitting_on_sel && is_object_sittable();

51
indra/newview/llviewertexturelist.cpp
View File

@ -70,6 +70,7 @@ S32 LLViewerTextureList::sNumImages = 0;
LLViewerTextureList gTextureList;
static LLTrace::BlockTimerStatHandle FTM_PROCESS_IMAGES("Process Images");
///////////////////////////////////////////////////////////////////////////////
LLViewerTextureList::LLViewerTextureList()
@ -1587,28 +1588,31 @@ LLUIImagePtr LLUIImageList::getUIImage(const std::string& image_name, S32 priori
}
LLUIImagePtr LLUIImageList::loadUIImageByName(const std::string& name, const std::string& filename,
BOOL use_mips, const LLRect& scale_rect, const LLRect& clip_rect, LLViewerTexture::EBoostLevel boost_priority )
BOOL use_mips, const LLRect& scale_rect, const LLRect& clip_rect, LLViewerTexture::EBoostLevel boost_priority,
LLUIImage::EScaleStyle scale_style)
{
if (boost_priority == LLGLTexture::BOOST_NONE)
{
boost_priority = LLGLTexture::BOOST_UI;
}
LLViewerFetchedTexture* imagep = LLViewerTextureManager::getFetchedTextureFromFile(filename, FTT_LOCAL_FILE, MIPMAP_NO, boost_priority);
return loadUIImage(imagep, name, use_mips, scale_rect, clip_rect);
return loadUIImage(imagep, name, use_mips, scale_rect, clip_rect, scale_style);
}
LLUIImagePtr LLUIImageList::loadUIImageByID(const LLUUID& id,
BOOL use_mips, const LLRect& scale_rect, const LLRect& clip_rect, LLViewerTexture::EBoostLevel boost_priority)
BOOL use_mips, const LLRect& scale_rect, const LLRect& clip_rect, LLViewerTexture::EBoostLevel boost_priority,
LLUIImage::EScaleStyle scale_style)
{
if (boost_priority == LLGLTexture::BOOST_NONE)
{
boost_priority = LLGLTexture::BOOST_UI;
}
LLViewerFetchedTexture* imagep = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, MIPMAP_NO, boost_priority);
return loadUIImage(imagep, id.asString(), use_mips, scale_rect, clip_rect);
return loadUIImage(imagep, id.asString(), use_mips, scale_rect, clip_rect, scale_style);
}
LLUIImagePtr LLUIImageList::loadUIImage(LLViewerFetchedTexture* imagep, const std::string& name, BOOL use_mips, const LLRect& scale_rect, const LLRect& clip_rect)
LLUIImagePtr LLUIImageList::loadUIImage(LLViewerFetchedTexture* imagep, const std::string& name, BOOL use_mips, const LLRect& scale_rect, const LLRect& clip_rect,
LLUIImage::EScaleStyle scale_style)
{
if (!imagep) return NULL;
@ -1621,6 +1625,8 @@ LLUIImagePtr LLUIImageList::loadUIImage(LLViewerFetchedTexture* imagep, const st
imagep->setNoDelete();
LLUIImagePtr new_imagep = new LLUIImage(name, imagep);
new_imagep->setScaleStyle(scale_style);
mUIImages.insert(std::make_pair(name, new_imagep));
mUITextureList.push_back(imagep);
@ -1639,7 +1645,7 @@ LLUIImagePtr LLUIImageList::loadUIImage(LLViewerFetchedTexture* imagep, const st
return new_imagep;
}
LLUIImagePtr LLUIImageList::preloadUIImage(const std::string& name, const std::string& filename, BOOL use_mips, const LLRect& scale_rect, const LLRect& clip_rect)
LLUIImagePtr LLUIImageList::preloadUIImage(const std::string& name, const std::string& filename, BOOL use_mips, const LLRect& scale_rect, const LLRect& clip_rect, LLUIImage::EScaleStyle scale_style)
{
// look for existing image
uuid_ui_image_map_t::iterator found_it = mUIImages.find(name);
@ -1649,7 +1655,7 @@ LLUIImagePtr LLUIImageList::preloadUIImage(const std::string& name, const std::s
LL_ERRS() << "UI Image " << name << " already loaded." << LL_ENDL;
}
return loadUIImageByName(name, filename, use_mips, scale_rect, clip_rect);
return loadUIImageByName(name, filename, use_mips, scale_rect, clip_rect, LLGLTexture::BOOST_UI, scale_style);
}
//static
@ -1709,14 +1715,28 @@ void LLUIImageList::onUIImageLoaded( BOOL success, LLViewerFetchedTexture *src_v
}
}
namespace LLInitParam
{
template<>
struct TypeValues<LLUIImage::EScaleStyle> : public TypeValuesHelper<LLUIImage::EScaleStyle>
{
static void declareValues()
{
declare("scale_inner", LLUIImage::SCALE_INNER);
declare("scale_outer", LLUIImage::SCALE_OUTER);
}
};
}
struct UIImageDeclaration : public LLInitParam::Block<UIImageDeclaration>
{
Mandatory<std::string> name;
Optional<std::string> file_name;
Optional<bool> preload;
Optional<LLRect> scale;
Optional<LLRect> clip;
Optional<bool> use_mips;
Mandatory<std::string> name;
Optional<std::string> file_name;
Optional<bool> preload;
Optional<LLRect> scale;
Optional<LLRect> clip;
Optional<bool> use_mips;
Optional<LLUIImage::EScaleStyle> scale_type;
UIImageDeclaration()
: name("name"),
@ -1724,7 +1744,8 @@ struct UIImageDeclaration : public LLInitParam::Block<UIImageDeclaration>
preload("preload", false),
scale("scale"),
clip("clip"),
use_mips("use_mips", false)
use_mips("use_mips", false),
scale_type("scale_type", LLUIImage::SCALE_INNER)
{}
};
@ -1812,7 +1833,7 @@ bool LLUIImageList::initFromFile()
{
continue;
}
preloadUIImage(image.name, file_name, image.use_mips, image.scale, image.clip);
preloadUIImage(image.name, file_name, image.use_mips, image.scale, image.clip, image.scale_type);
}
if (cur_pass == PASS_DECODE_NOW && !gSavedSettings.getBOOL("NoPreload"))

10
indra/newview/llviewertexturelist.h
View File

@ -218,20 +218,22 @@ public:
bool initFromFile();
LLPointer<LLUIImage> preloadUIImage(const std::string& name, const std::string& filename, BOOL use_mips, const LLRect& scale_rect, const LLRect& clip_rect);
LLPointer<LLUIImage> preloadUIImage(const std::string& name, const std::string& filename, BOOL use_mips, const LLRect& scale_rect, const LLRect& clip_rect, LLUIImage::EScaleStyle stype);
static void onUIImageLoaded( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* src_aux, S32 discard_level, BOOL final, void* userdata );
private:
LLPointer<LLUIImage> loadUIImageByName(const std::string& name, const std::string& filename,
BOOL use_mips = FALSE, const LLRect& scale_rect = LLRect::null,
const LLRect& clip_rect = LLRect::null,
LLViewerTexture::EBoostLevel boost_priority = LLGLTexture::BOOST_UI);
LLViewerTexture::EBoostLevel boost_priority = LLGLTexture::BOOST_UI,
LLUIImage::EScaleStyle = LLUIImage::SCALE_INNER);
LLPointer<LLUIImage> loadUIImageByID(const LLUUID& id,
BOOL use_mips = FALSE, const LLRect& scale_rect = LLRect::null,
const LLRect& clip_rect = LLRect::null,
LLViewerTexture::EBoostLevel boost_priority = LLGLTexture::BOOST_UI);
LLViewerTexture::EBoostLevel boost_priority = LLGLTexture::BOOST_UI,
LLUIImage::EScaleStyle = LLUIImage::SCALE_INNER);
LLPointer<LLUIImage> loadUIImage(LLViewerFetchedTexture* imagep, const std::string& name, BOOL use_mips = FALSE, const LLRect& scale_rect = LLRect::null, const LLRect& clip_rect = LLRect::null);
LLPointer<LLUIImage> loadUIImage(LLViewerFetchedTexture* imagep, const std::string& name, BOOL use_mips = FALSE, const LLRect& scale_rect = LLRect::null, const LLRect& clip_rect = LLRect::null, LLUIImage::EScaleStyle = LLUIImage::SCALE_INNER);
struct LLUIImageLoadData

10
indra/newview/skins/default/textures/textures.xml
View File

@ -29,7 +29,7 @@ with the same filename but different name
-->
<textures version="101">
<!-- Please add new files alphabetically to prevent merge conflicts. JC -->
<!-- Please add new files alphabetically to prevent merge conflicts. JC -->
<texture name="Accordion_ArrowClosed_Off" file_name="containers/Accordion_ArrowClosed_Off.png" preload="false" />
<texture name="Accordion_ArrowClosed_Press" file_name="containers/Accordion_ArrowClosed_Press.png" preload="false" />
<texture name="Accordion_ArrowOpened_Off" file_name="containers/Accordion_ArrowOpened_Off.png" preload="false" />
@ -231,8 +231,9 @@ with the same filename but different name
<texture name="Home_Off" file_name="navbar/Home_Off.png" preload="false" />
<texture name="Horizontal Drag Handle" file_name="widgets/horizontal_drag_handle.png" scale.left="8" scale.right="120" scale.bottom="1" scale.top="6" scale_type="scale_outer"/>
<texture name="Icon_Close_Foreground" file_name="windows/Icon_Close_Foreground.png" preload="true" />
<texture name="Icon_Close_Foreground" file_name="windows/Icon_Close_Foreground.png" preload="true" />
<texture name="Icon_Close_Press" file_name="windows/Icon_Close_Press.png" preload="true" />
<texture name="Icon_Close_Toast" file_name="windows/Icon_Close_Toast.png" preload="true" />
@ -646,8 +647,9 @@ with the same filename but different name
<texture name="Unread_Chiclet" file_name="bottomtray/Unread_Chiclet.png" preload="false" />
<texture name="UpArrow_Off" file_name="icons/UpArrow_Off.png" preload="false" />
<texture name="Vertical Drag Handle" file_name="widgets/vertical_drag_handle.png" scale.left="2" scale.right="7" scale.bottom="8" scale.top="120" scale_type="scale_outer"/>
<texture name="Volume_Background" file_name="windows/Volume_Background.png" preload="false"
<texture name="Volume_Background" file_name="windows/Volume_Background.png" preload="false"
scale.left="6" scale.top="33" scale.right="63" scale.bottom="10" />
<texture name="VoicePTT_Lvl1" file_name="bottomtray/VoicePTT_Lvl1.png" preload="false" />
@ -775,6 +777,4 @@ with the same filename but different name
<texture name="Camera_Drag_Dot" file_name="world/CameraDragDot.png"/>
<texture name="NavBar Separator" file_name="navbar/separator.png"/>
<texture name="Horizontal Drag Handle" file_name="widgets/horizontal_drag_handle.png"/>
<texture name="Vertical Drag Handle" file_name="widgets/vertical_drag_handle.png"/>
</textures>

BIN
indra/newview/skins/default/textures/widgets/horizontal_drag_handle.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 197 B

After

Width:  |  Height:  |  Size: 217 B

BIN
indra/newview/skins/default/textures/widgets/vertical_drag_handle.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 196 B

After

Width:  |  Height:  |  Size: 238 B

2
indra/newview/skins/default/xui/da/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="Ting" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<panel name="button_panel">
<layout_stack name="button_panel_ls">
<layout_panel name="info_btn_lp">

2
indra/newview/skins/default/xui/de/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="Sonstiges" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<layout_stack name="inventory_layout_stack">
<layout_panel name="inbox_layout_panel">
<panel label="" name="marketplace_inbox">

1
indra/newview/skins/default/xui/en/floater_conversation_preview.xml
View File

@ -2,7 +2,6 @@
<floater
legacy_header_height="18"
can_resize="true"
default_tab_group="1"
help_topic="conversation_preview"
height="391"
layout="topleft"

2
indra/newview/skins/default/xui/en/floater_im_session.xml
View File

@ -1,7 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<floater
background_visible="true"
default_tab_group="1"
height="355"
help_topic="floater_im_box"
layout="topleft"
@ -213,7 +212,6 @@
min_width="172">
<layout_stack
animate="true"
default_tab_group="2"
follows="all"
orientation="vertical"
name="translate_and_chat_stack"

1
indra/newview/skins/default/xui/en/floater_toybox.xml
View File

@ -4,7 +4,6 @@
can_dock="false"
can_minimize="false"
can_resize="false"
default_tab_group="1"
height="375"
help_topic="toybox"
layout="topleft"

1
indra/newview/skins/default/xui/en/panel_bottomtray_lite.xml
View File

@ -1,6 +1,5 @@
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<panel
default_tab_group="2"
mouse_opaque="true"
background_visible="true"
bg_alpha_color="DkGray"

2
indra/newview/skins/default/xui/en/panel_main_inventory.xml
View File

@ -1,6 +1,5 @@
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<panel
default_tab_group="1"
follows="all"
height="423"
label="Things"
@ -57,7 +56,6 @@
left="7"
name="inventory filter tabs"
tab_height="30"
tab_group="1"
tab_position="top"
tab_min_width="100"
top_pad="10"

1
indra/newview/skins/default/xui/en/panel_nearby_chat_bar.xml
View File

@ -1,6 +1,5 @@
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<panel
default_tab_group="1"
follows="left|bottom|right"
height="25"
layout="topleft"

971
indra/newview/skins/default/xui/en/panel_outfit_edit.xml
View File

File diff suppressed because it is too large Load Diff

2
indra/newview/skins/default/xui/en/panel_people.xml
View File

@ -1,7 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<!-- Side tray panel -->
<panel
default_tab_group="1"
follows="all"
height="449"
label="People"
@ -60,7 +59,6 @@ Looking for people to hang out with? Try the [secondlife:///app/worldmap World M
layout="topleft"
left="3"
name="tabs"
tab_group="1"
tab_min_width="70"
tab_height="30"
tab_position="top"

105
indra/newview/skins/default/xui/en/sidepanel_inventory.xml
View File

@ -12,17 +12,19 @@
follows="all"
layout="topleft"
left="0"
name="sidepanel__inventory_panel"
name="sidepanel_inventory_panel"
top="0"
label=""
height="570"
visible="true"
default_tab_group="1"
width="330">
<layout_stack
<layout_stack
follows="left|right|top|bottom"
layout="topleft"
left="0"
top="0"
tab_group="1"
orientation="vertical"
name="inventory_layout_stack"
height="535"
@ -75,7 +77,7 @@
<button
control_name="InventoryInboxToggleState"
label="Received items"
font="SansSerifMedium"
font="SansSerifMedium"
name="inbox_btn"
height="35"
width="308"
@ -116,61 +118,56 @@
background_opaque="true"
tool_tip="Drag and drop items to your inventory to use them"
>
<text
name="inbox_inventory_placeholder"
type="string"
follows="all"
layout="topleft"
top="0"
left="0"
width="308"
height="200"
wrap="true"
halign="center">
Purchases from the marketplace will be delivered here.
</text>
<text name="inbox_inventory_placeholder"
type="string"
follows="all"
layout="topleft"
top="0"
left="0"
width="308"
height="200"
wrap="true"
halign="center">
Purchases from the marketplace will be delivered here.
</text>
</panel>
</panel>
</layout_panel>
</layout_stack>
<panel
follows="bottom|left|right"
height="30"
layout="topleft"
name="button_panel"
left="9"
top_pad="7"
width="308">
<layout_stack
follows="bottom|left|right"
height="23"
layout="topleft"
mouse_opaque="false"
name="button_panel_ls"
left="0"
orientation="horizontal"
top="0"
width="308">
<layout_panel
follows="bottom|left|right"
height="23"
layout="bottomleft"
left="0"
mouse_opaque="false"
name="info_btn_lp"
auto_resize="true"
width="101">
<button
enabled="true"
follows="bottom|left|right"
height="23"
label="Profile"
layout="topleft"
left="1"
name="info_btn"
tool_tip="Show object profile"
top="0"
width="100" />
<panel follows="bottom|left|right"
height="30"
layout="topleft"
name="button_panel"
left="9"
top_pad="7"
width="308">
<layout_stack follows="bottom|left|right"
height="23"
layout="topleft"
mouse_opaque="false"
name="button_panel_ls"
left="0"
orientation="horizontal"
top="0"
width="308">
<layout_panel follows="bottom|left|right"
height="23"
layout="bottomleft"
left="0"
mouse_opaque="false"
name="info_btn_lp"
auto_resize="true"
width="101">
<button enabled="true"
follows="bottom|left|right"
height="23"
label="Profile"
layout="topleft"
left="1"
name="info_btn"
tool_tip="Show object profile"
top="0"
width="100" />
</layout_panel>
<layout_panel
follows="bottom|left|right"

12
indra/newview/skins/default/xui/en/widgets/avatar_icon.xml
View File

@ -1,7 +1,9 @@
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<avatar_icon
name="avatar_icon"
default_icon_name="Generic_Person_Large"
use_draw_context_alpha="false">
</avatar_icon>
<avatar_icon name="avatar_icon"
default_icon_name="Generic_Person_Large"
use_draw_context_alpha="false"
symbol_hpad = "2"
symbol_vpad = "1"
symbol_size = "5"/>

2
indra/newview/skins/default/xui/es/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="Cosas" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<layout_stack name="inventory_layout_stack">
<layout_panel name="inbox_layout_panel">
<panel label="" name="marketplace_inbox">

2
indra/newview/skins/default/xui/fr/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="Choses" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<layout_stack name="inventory_layout_stack">
<layout_panel name="inbox_layout_panel">
<panel label="" name="marketplace_inbox">

2
indra/newview/skins/default/xui/it/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="Cose" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<layout_stack name="inventory_layout_stack">
<layout_panel name="inbox_layout_panel">
<panel label="" name="marketplace_inbox">

2
indra/newview/skins/default/xui/ja/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="もの" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<layout_stack name="inventory_layout_stack">
<layout_panel name="inbox_layout_panel">
<panel label="" name="marketplace_inbox">

2
indra/newview/skins/default/xui/pl/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="Rzeczy" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<panel name="button_panel">
<layout_stack name="button_panel_ls">
<layout_panel name="info_btn_lp">

2
indra/newview/skins/default/xui/pt/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="Coisas" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<layout_stack name="inventory_layout_stack">
<layout_panel name="inbox_layout_panel">
<panel label="" name="marketplace_inbox">

2
indra/newview/skins/default/xui/ru/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="Вещи" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<layout_stack name="inventory_layout_stack">
<layout_panel name="inbox_layout_panel">
<panel label="" name="marketplace_inbox">

2
indra/newview/skins/default/xui/tr/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="Eşyalar" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<layout_stack name="inventory_layout_stack">
<layout_panel name="inbox_layout_panel">
<panel label="" name="marketplace_inbox">

2
indra/newview/skins/default/xui/zh/sidepanel_inventory.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<panel label="事物" name="objects panel">
<panel label="" name="sidepanel__inventory_panel">
<panel label="" name="sidepanel_inventory_panel">
<layout_stack name="inventory_layout_stack">
<layout_panel name="inbox_layout_panel">
<panel label="" name="marketplace_inbox">