//-----------------------------------------------------------------------------
//
// Look for vgui screens, returns true if it found one ...
//
//-----------------------------------------------------------------------------
C_BaseEntity *FindNearbyVguiScreen( const Vector &viewPosition, const QAngle &viewAngle, int nTeam )
{
if ( IsX360() )
{
// X360TBD: Turn this on if feature actually used
return NULL;
}
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
Assert( pLocalPlayer );
if ( !pLocalPlayer )
return NULL;
// Get the view direction...
Vector lookDir;
AngleVectors( viewAngle, &lookDir );
// Create a ray used for raytracing
Vector lookEnd;
VectorMA( viewPosition, 2.0f * VGUI_SCREEN_MODE_RADIUS, lookDir, lookEnd );
Ray_t lookRay;
lookRay.Init( viewPosition, lookEnd );
#ifndef C17
// Look for vgui screens that are close to the player
CVGuiScreenEnumerator localScreens;
partition->EnumerateElementsInSphere( PARTITION_CLIENT_NON_STATIC_EDICTS, viewPosition, VGUI_SCREEN_MODE_RADIUS, false, &localScreens );
#endif
Vector vecOut, vecViewDelta;
float flBestDist = 2.0f;
C_VGuiScreen *pBestScreen = NULL;
#ifdef C17
for (int i = 0; i < g_pVGUIScreens.Count(); i++)
{
if (g_pVGUIScreens.IsValidIndex(i))
{
C_VGuiScreen *pScreen = g_pVGUIScreens[i];
#else
for (int i = localScreens.GetScreenCount(); --i >= 0; )
{
C_VGuiScreen *pScreen = localScreens.GetVGuiScreen(i);
#endif
if (pScreen->IsAttachedToViewModel())
continue;
// Don't bother with screens I'm behind...
// Hax - don't cancel backfacing with viewmodel attached screens.
// we can get prediction bugs that make us backfacing for one frame and
// it resets the mouse position if we lose focus.
if (pScreen->IsBackfacing(viewPosition))
continue;
// Don't bother with screens that are turned off
if (!pScreen->IsActive())
continue;
// FIXME: Should this maybe go into a derived class of some sort?
// Don't bother with screens on the wrong team
if (!pScreen->IsVisibleToTeam(nTeam))
continue;
if (!pScreen->AcceptsInput())
continue;
if (pScreen->IsInputOnlyToOwner() && pScreen->GetPlayerOwner() != pLocalPlayer)
continue;
// Test perpendicular distance from the screen...
pScreen->GetVectors(NULL, NULL, &vecOut);
VectorSubtract(viewPosition, pScreen->GetAbsOrigin(), vecViewDelta);
float flPerpDist = DotProduct(vecViewDelta, vecOut);
if ((flPerpDist < 0) || (flPerpDist > VGUI_SCREEN_MODE_RADIUS))
continue;
// Perform a raycast to see where in barycentric coordinates the ray hits
// the viewscreen; if it doesn't hit it, you're not in the mode
float u, v, t;
if (!pScreen->IntersectWithRay(lookRay, &u, &v, &t))
continue;
// Barycentric test
if ((u < 0) || (v < 0) || (u > 1) || (v > 1))
continue;
if (t < flBestDist)
{
flBestDist = t;
pBestScreen = pScreen;
}
}
#ifdef C17
}
#endif
return pBestScreen;
}
void ActivateVguiScreen( C_BaseEntity *pVguiScreenEnt )
{
if (pVguiScreenEnt)
{
Assert( dynamic_cast<C_VGuiScreen*>(pVguiScreenEnt) );
C_VGuiScreen *pVguiScreen = static_cast<C_VGuiScreen*>(pVguiScreenEnt);
pVguiScreen->GainFocus( );
}
}
void SetVGuiScreenButtonState( C_BaseEntity *pVguiScreenEnt, int nButtonState )
{
if (pVguiScreenEnt)
{
Assert( dynamic_cast<C_VGuiScreen*>(pVguiScreenEnt) );
C_VGuiScreen *pVguiScreen = static_cast<C_VGuiScreen*>(pVguiScreenEnt);
pVguiScreen->SetButtonState( nButtonState );
}
}
void DeactivateVguiScreen( C_BaseEntity *pVguiScreenEnt )
{
if (pVguiScreenEnt)
{
Assert( dynamic_cast<C_VGuiScreen*>(pVguiScreenEnt) );
C_VGuiScreen *pVguiScreen = static_cast<C_VGuiScreen*>(pVguiScreenEnt);
pVguiScreen->LoseFocus( );
}
}
CVGuiScreenPanel::CVGuiScreenPanel( vgui::Panel *parent, const char *panelName )
: BaseClass( parent, panelName )
{
m_hEntity = NULL;
}
CVGuiScreenPanel::CVGuiScreenPanel( vgui::Panel *parent, const char *panelName, vgui::HScheme hScheme )
: BaseClass( parent, panelName, hScheme )
{
m_hEntity = NULL;
}
bool CVGuiScreenPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
{
const char *pResFile = pKeyValues->GetString( "resfile" );
if (pResFile[0] != 0)
{
KeyValues *pCachedKeyValues = CacheKeyValuesForFile( pResFile );
LoadControlSettings( pResFile, NULL, pCachedKeyValues );
}
// Dimensions in pixels
int nWidth, nHeight;
nWidth = pKeyValues->GetInt( "pixelswide", 240 );
nHeight = pKeyValues->GetInt( "pixelshigh", 160 );
if ((nWidth <= 0) || (nHeight <= 0))
return false;
// If init data isn't specified, then we're just precaching.
if ( pInitData )
{
m_hEntity.Set( pInitData->m_pEntity );
C_VGuiScreen *screen = dynamic_cast< C_VGuiScreen * >( pInitData->m_pEntity );
if ( screen )
{
bool acceptsInput = pKeyValues->GetInt( "acceptsinput", 1 ) ? true : false;
screen->SetAcceptsInput( acceptsInput );
}
}
SetBounds( 0, 0, nWidth, nHeight );
return true;
}
vgui::Panel *CVGuiScreenPanel::CreateControlByName(const char *controlName)
{
// Check the panel metaclass manager to make these controls...
if (!Q_strncmp(controlName, "MaterialImage", 20))
{
return new CBitmapPanel(NULL, "BitmapPanel");
}
if (!Q_strncmp(controlName, "MaterialButton", 20))
{
return new CBitmapButton(NULL, "BitmapButton", "");
}
// Didn't find it? Just use the default stuff
return BaseClass::CreateControlByName( controlName );
}
//-----------------------------------------------------------------------------
// Purpose: Called when the user presses a button
//-----------------------------------------------------------------------------
void CVGuiScreenPanel::OnCommand( const char *command)
{
if ( Q_stricmp( command, "vguicancel" ) )
{
engine->ClientCmd( const_cast<char *>( command ) );
}
BaseClass::OnCommand(command);
}
DECLARE_VGUI_SCREEN_FACTORY( CVGuiScreenPanel, "vgui_screen_panel" );
View& View::SetBounds(Attach bottom, Attach top, Attach left, Attach right, double aspect)
{
this->aspect = aspect;
SetBounds(top,bottom,left,right);
return *this;
}
void CCircleCollider::CalculateBounds()
{
SetBounds(sf::FloatRect(GetPosition().x, GetPosition().y, (m_Radius * 2.f), (m_Radius * 2.f)));
}
void AccessibilityTreeNode::Merge(AccessibilityTreeNode* node)
{
int i = 0, j = 0;
AccessibilityTreeNode* my_child = m_children.Get(i);
AccessibilityTreeNode* your_child = node->m_children.Get(j);
while (my_child || your_child)
{
if (my_child && !your_child)
{
OP_DELETE(my_child);
my_child = m_children.Get(i);
}
else if (your_child && !my_child)
{
your_child->Reparent(this);
your_child = node->m_children.Get(j);
}
else
{
if (my_child->Compare(your_child))
{
my_child->Merge(your_child);
i++;
j++;
}
else
{
int j2 = j+1;
your_child = node->m_children.Get(j2);
while (your_child)
{
if (my_child->Compare(your_child))
{
int diff = j2 - j;
my_child->Merge(your_child);
for (int k = 0; k < diff; k++)
node->m_children.Remove(j)->Reparent(this, i + k);
j++;
i+= 1+diff;
break;
}
j2++;
your_child = node->m_children.Get(j2);
}
if (!your_child)
{
OP_DELETE(my_child);
}
}
my_child = m_children.Get(i);
your_child = node->m_children.Get(j);
}
}
OpRect bounds;
node->GetBounds(bounds);
if (!m_bounds.Equals(bounds))
{
BOOL moved = (bounds.x != m_bounds.x) || (bounds.y != m_bounds.y);
BOOL resized = (bounds.width != m_bounds.width) || (bounds.height != m_bounds.height);
SetBounds(bounds);
BoundsChanged(moved, resized);
}
}
View& View::SetBounds(Attach bottom, Attach top, Attach left, Attach right, bool keep_aspect)
{
aspect = keep_aspect ? v.aspect() : 0;
SetBounds(top,bottom,left,right);
return *this;
}
Camera::Camera() {
SetBounds(-1, -1, -1, -1);
SetPosition(0, 0);
followingSprite = NULL;
}
HRESULT ui::UIListBox::Initialize(graphics::D3DInteropHelper *pD3DInteropHelper) {
#ifdef DEBUG_UILISTBOX
LOG_ENTER(SEVERITY_LEVEL_DEBUG);
#endif
assert(GetWidth() > 0.0f);
assert(GetHeight() > 0.0f);
ui::UIListBoxItem::LAYOUT_DIRECTION layoutDirection = ui::UIListBoxItem::LAYOUT_DIRECTION_VERTICAL;
switch (m_scrollDirection) {
case ui::UIListBox::SCROLL_DIRECTION_HORIZONTAL:
layoutDirection = ui::UIListBoxItem::LAYOUT_DIRECTION_VERTICAL;
m_itemHeight = GetHeight();
if (m_preferredTextAreaSize.height == 0.0f) {
m_preferredTextAreaSize.height = GetHeight() - m_preferredBitmapSize.height - m_marginBetweenBitmapAndText;
}
if (m_preferredTextAreaSize.width == 0.0f) {
m_preferredTextAreaSize.width = m_preferredBitmapSize.width * 3.0f;
}
m_itemWidth = m_preferredTextAreaSize.width;
break;
case ui::UIListBox::SCROLL_DIRECTION_VERTICAL:
layoutDirection = ui::UIListBoxItem::LAYOUT_DIRECTION_HORIZONTAL;
m_itemWidth = GetWidth();
if (m_preferredTextAreaSize.width == 0.0f) {
m_preferredTextAreaSize.width = GetWidth() - m_preferredBitmapSize.width - m_marginBetweenBitmapAndText;
}
if (m_preferredTextAreaSize.height == 0.0f) {
m_preferredTextAreaSize.height = m_preferredBitmapSize.height;
}
m_itemHeight = m_preferredTextAreaSize.height;
break;
}
for (size_t i = 0; i < GetNumberOfElements(); ++i) {
auto element = GetElement(i);
auto listBoxItem = std::dynamic_pointer_cast<UIListBoxItem>(element);
if (listBoxItem.get() != nullptr) {
listBoxItem->SetLayoutDirection(layoutDirection);
listBoxItem->SetPreferredBitmapSize(m_preferredBitmapSize);
listBoxItem->SetPreferredTextAreaSize(m_preferredTextAreaSize);
listBoxItem->SetBounds(0.0f, 0.0f, m_itemWidth, m_itemHeight);
}
}
CHK_WARN_HRESULT(UIContainer::Initialize(pD3DInteropHelper));
auto frameDecorator = std::make_shared<graphics::decorator::FrameDecorator>();
frameDecorator->SetColorSet(m_colorSet);
for (size_t i = 0; i < m_colorSet->GetNumberOfColors(); ++i) {
frameDecorator->AddFrame(graphics::decorator::Frame(i));
}
m_rectFigure->AddDecorator(frameDecorator);
m_rectFigure->SetX(0.0f);
m_rectFigure->SetY(0.0f);
m_rectFigure->SetWidth(GetWidth());
m_rectFigure->SetHeight(GetHeight());
m_rectFigure->SetColor(graphics::color::ColorValue(graphics::color::ColorValue::COLOR_TYPE_RGBA, 0x222222, 1.0f),
graphics::color::COLOR_PATTERN_FLAT);
CHK_WARN_HRESULT(m_rectFigure->Initialize(pD3DInteropHelper));
m_scrollBar->SetParentContainer(shared_from_this());
m_scrollBar->SetMinValue(0.0f);
m_scrollBar->SetMaxValue(GetNumberOfElements() - 1.0f);
m_scrollBar->SetPageSize(1.0f);
if (m_scrollBar->GetCurrentValue() < m_scrollBar->GetMinValue()
|| m_scrollBar->GetCurrentValue() > m_scrollBar->GetMaxValue() - m_scrollBar->GetPageSize()) {
m_scrollBar->SetCurrentValue(0.0f);
}
FLOAT frameThick = static_cast<FLOAT>(m_colorSet->GetNumberOfColors());
if (m_scrollDirection == ui::UIListBox::SCROLL_DIRECTION_HORIZONTAL) {
m_scrollBar->SetDirection(ui::UIScrollBar::SCROLLBAR_DIRECTION_HORIZONTAL);
m_scrollBar->SetBounds(frameThick + m_scrollBarMarginFromSide,
GetHeight() - m_scrollBarThick - frameThick - m_scrollBarMarginFromSide,
GetWidth() - (frameThick + m_scrollBarMarginFromSide) * 2, m_scrollBarThick);
} else {
m_scrollBar->SetDirection(ui::UIScrollBar::SCROLLBAR_DIRECTION_VERTICAL);
m_scrollBar->SetBounds(GetWidth() - m_scrollBarThick - frameThick - m_scrollBarMarginFromSide,
frameThick + m_scrollBarMarginFromSide, m_scrollBarThick,
GetHeight() - (frameThick + m_scrollBarMarginFromSide) * 2);
}
m_scrollBar->AddPositionChangedCallback([&](FLOAT position) { NotifyScrollPositionChanged(position); });
CHK_FATAL_HRESULT(m_scrollBar->Initialize(pD3DInteropHelper));
#ifdef DEBUG_UILISTBOX
LOG_LEAVE(SEVERITY_LEVEL_DEBUG);
#endif
return S_OK;
}
void gxViewElement::SetSize( const gxPix aNewSize, bool aOnMajorAxis )
{
gxRect iBounds = GetBounds();
iBounds.SetSize( aNewSize, aOnMajorAxis );
SetBounds( iBounds );
}
int GraphPaper(vector<T_Point> &points,
int nRows, int nCols,
FlatMatrix2D<int> &bins,
FlatMatrix2D<int> &scoreMat,
FlatMatrix2D<Arrow> &pathMat,
vector<bool> &onOptPath) {
bins.Resize(nRows, nCols);
bins.Fill(0);
scoreMat.Resize(nRows+1, nCols+1);
pathMat.Resize(nRows+1, nCols+1);
scoreMat.Fill(0);
pathMat.Fill(NoArrow);
onOptPath.resize(points.size());
fill(onOptPath.begin(), onOptPath.end(), false);
DNALength xMin, xMax, yMin, yMax;
SetBounds(points, xMin, xMax, 0);
xMax++; // make half-open interval.
SetBounds(points, yMin, yMax, 1);
yMax++; // ditto.
//
// First set up the grid to optimize over.
//
int i;
for (i = 0; i < points.size(); i++) {
int rowIndex = GetIndex(points[i].GetX(), xMin, xMax, nRows);
int colIndex = GetIndex(points[i].GetY(), yMin, yMax, nCols);
bins[rowIndex][colIndex]+= points[i].length;
}
//
// Now optimize using DP.
//
// First handle boundary strips
int r, c;
for (r = 1; r < nRows+1; r++) {
scoreMat[r][0] = 0;
pathMat[r][0] = Up;
}
for (c = 1; c < nCols+1; c++) {
scoreMat[0][c] = 0;
pathMat[0][c] = Left;
}
scoreMat[0][0] = 0;
for (r = 1; r < nRows + 1; r++) {
for (c = 1; c < nCols + 1; c++) {
int diagScore, leftScore, upScore;
diagScore = scoreMat[r-1][c-1];
leftScore = scoreMat[r][c-1];
upScore = scoreMat[r-1][c];
int optScore;
Arrow optDir;
if (diagScore >= leftScore and
diagScore >= upScore) {
optScore = diagScore;
optDir = Diagonal;
}
else if (leftScore >= diagScore and
leftScore >= upScore) {
optScore = leftScore;
optDir = Left;
}
else {
optScore = upScore;
optDir = Up;
}
scoreMat[r][c] = optScore + bins[r-1][c-1];
pathMat[r][c] = optDir;
}
}
r = nRows; c = nCols;
while (r > 0 or c > 0) {
Arrow dir = pathMat[r][c];
pathMat[r][c] = Star;
if (dir == Diagonal) { r--; c--; }
else if (dir == Left) { c--; }
else if (dir == Up) { r--; }
if (r == 0 and c == 0) { break; }
}
//
// Now mark inclusion/exclusion from matrix.
//
int nOpt = 0;
for (i = 0; i < points.size(); i++) {
int rowIndex = GetIndex(points[i].GetX(), xMin, xMax, nRows);
int colIndex = GetIndex(points[i].GetY(), yMin, yMax, nCols);
if (pathMat[rowIndex+1][colIndex+1] == Star) {
onOptPath[i] = true;
}
else if (pathMat[rowIndex][colIndex+1] == Star) {
onOptPath[i] = true;
}
else if (rowIndex + 2 < nRows and pathMat[rowIndex+2][colIndex+1] == Star) {
onOptPath[i] = true;
}
else if (pathMat[rowIndex+1][colIndex] == Star) {
onOptPath[i] = true;
}
else if (colIndex < nCols + 2 and pathMat[rowIndex+1][colIndex+2] == Star) {
onOptPath[i] = true;
}
if (onOptPath[i]) {
++nOpt;
}
}
return nOpt;
}
void gxViewElement::SetPosition( const gxPix aNewPosition, bool aOnMajorAxis )
{
gxRect iBounds = GetBounds();
iBounds.SetPosition( aNewPosition, aOnMajorAxis );
SetBounds( iBounds );
}
void gxViewElement::SetSize( const gxSize& aNewSize )
{
gxRect iBounds = GetBounds();
iBounds.SetSize( aNewSize );
SetBounds( iBounds );
}
void gxViewElement::SetPosition( const gxPoint& aNewPosition )
{
gxRect iBounds = GetBounds();
iBounds.SetPosition( aNewPosition );
SetBounds( iBounds );
}
PLAYER::PLAYER()
{
SetBounds(sf::FloatRect(2,0,28,32));
}
STATICOBJECT::STATICOBJECT()
{
SetBounds(sf::FloatRect(0,0,32,32));
}
////////////////////////////////////////////////////////////////////////
// Procedure DrawScene is called whenever the scene needs to be drawn.
void DrawScene(Scene& scene, int width, int height)
{
// Choose OpenGL or student rendering here. The decision can be
// based on useOpenGLRendering, useFastRendering, or both:
// if (useOpenGLRendering || useFastRendering)
if (scene.UseOpenGLRendering)
{
DrawSceneWithOpenGL(scene, width, height);
return;
}
// ---------------------------------------------------------------------------
// Student rendering code goes here
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBegin(GL_POINTS);
w = width;
h = height;
unsigned nLength = (unsigned) (width * height);
zBuf = new float[nLength];
for (unsigned i = 0; i < nLength; ++i)
zBuf[i] = 1.f;
// for each object
size_t nObjects = scene.objects.size();
for (size_t i = 0; i < nObjects; ++i)
{
Object &obj = scene.objects[i];
// for each polygon
size_t nPolys = obj.polygons.size();
for (size_t j = 0; j < nPolys; ++j)
{
EdgeTable.clear();
APolygon &poly = obj.polygons[j];
std::vector<Vector3D> vVertices;
// Set polygon color
float rgba[4];
Vector3D v3Light = bybyte_cast<Vector3D>(scene.lights[0].position);
v3Light.normalize();
SetColor(v3Light, poly[0].N, obj.Kd, rgba);
// make the A object blue both sides
if (i == 2)
{
for (int c = 0; c < 3; ++c)
rgba[c] = abs(rgba[c]);
}
// Get pixel coords for polygon & push edges
size_t nVerts = poly.size();
for (size_t k = 0; k < nVerts; ++k)
{
// current vertex
Vector4D v4T = scene.viewing.Transform(poly[k].V);
Vector3D v3S = bybyte_cast<Vector3D>(scene.projection.Transform(v4T).Hdiv());
v3S[0] = (float) FloatToInt((v3S[0] + 1.f) * width / 2.f);
v3S[1] = (float) FloatToInt((v3S[1] + 1.f) * height / 2.f);
vVertices.push_back(v3S);
}
// put vertices in correct order
for (size_t k = 0; k < nVerts; ++k)
{
unsigned nNext = poly[k].prevIndex;
// skip horizontal edges
if ((int) vVertices[k][1] == (int) vVertices[nNext][1])
continue;
if (vVertices[k][1] < vVertices[nNext][1])
{
Edge e(vVertices[k], vVertices[nNext]);
EdgeTable.push_back(e);
}
else
{
Edge e(vVertices[nNext], vVertices[k]);
EdgeTable.push_back(e);
}
}
ActiveEdgeList.clear();
EdgeListIt ETIt, AELIt;
size_t nEdges = EdgeTable.size();
// Cull / clip edges
ETIt = EdgeTable.begin();
while (ETIt != EdgeTable.end())
{
// y culling
if (ETIt->v1[1] < 0.f || ETIt->v0[1] >= height)
EdgeTable.erase(ETIt++);
else
{
// y clipping
if (ETIt->v0[1] < 0)
{
ETIt->x += (-ETIt->v0[1] * ETIt->dx);
ETIt->z += (-ETIt->v0[1] * ETIt->dz);
}
else if (ETIt->v1[1] > height)
{
float fYMax = (float) (height - 1);
float fYDif = ETIt->v1[1] - fYMax;
ETIt->v1[1] = fYMax;
ETIt->v1[0] -= (fYDif * ETIt->dx);
ETIt->v1[2] -= (fYDif * ETIt->dz);
}
++ETIt;
}
}
// Set values for scanline 0
ETIt = EdgeTable.begin();
while (ETIt != EdgeTable.end())
{
if ((ETIt->v0[1] <= 0) && (ETIt->v0[1] != ETIt->v1[1]) && (ETIt->v1[1] != 0.f))
{
ActiveEdgeList.push_back(*ETIt);
EdgeTable.erase(ETIt++);
}
else
++ETIt;
}
ActiveEdgeList.sort();
// for each scanline
for (int y = 0; y < height; ++y)
{
// draw by pair
for (AELIt = ActiveEdgeList.begin(); AELIt != ActiveEdgeList.end(); ++AELIt)
{
EdgeListIt AELItPrev = AELIt++;
float z = AELItPrev->z;
float dzdx = (AELIt->z - AELItPrev->z) / (AELIt->x - AELItPrev->x);
int x0 = FloatToInt(AELItPrev->x), x1 = FloatToInt(AELIt->x);
SetBounds(x0, x1);
for (int x = x0; x < x1; ++x)
{
if (z < ZBuf(x, y))
{
ZBuf(x, y) = z;
glColor4fv(rgba);
glVertex2i(x, y);
}
z += dzdx;
}
}
// insert edges into AEL
bool bSort = false;
ETIt = EdgeTable.begin();
while (ETIt != EdgeTable.end())
{
if (IsInRange((float) y, ETIt->v0[1], ETIt->v1[1]))
{
ActiveEdgeList.push_back(*ETIt);
EdgeTable.erase(ETIt++);
bSort = true;
}
else
++ETIt;
}
// increment edges on AEL & remove passed edges
AELIt = ActiveEdgeList.begin();
while (AELIt != ActiveEdgeList.end())
{
AELIt->Inc();
if (!IsInRange((float) y, AELIt->v0[1], AELIt->v1[1]))
ActiveEdgeList.erase(AELIt++);
else
++AELIt;
}
// sort the AEL
if (bSort) ActiveEdgeList.sort();
} // [END] for each scanline
} // [END] for each polygon
} // [END] for each object
delete [] zBuf;
glEnd();
}
NS_IMETHODIMP
nsLeafBoxFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// This is mostly a copy of nsBoxFrame::Reflow().
// We aren't able to share an implementation because of the frame
// class hierarchy. If you make changes here, please keep
// nsBoxFrame::Reflow in sync.
DO_GLOBAL_REFLOW_COUNT("nsLeafBoxFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
NS_ASSERTION(aReflowState.ComputedWidth() >=0 &&
aReflowState.ComputedHeight() >= 0, "Computed Size < 0");
#ifdef DO_NOISY_REFLOW
printf("\n-------------Starting LeafBoxFrame Reflow ----------------------------\n");
printf("%p ** nsLBF::Reflow %d R: ", this, myCounter++);
switch (aReflowState.reason) {
case eReflowReason_Initial:
printf("Ini");break;
case eReflowReason_Incremental:
printf("Inc");break;
case eReflowReason_Resize:
printf("Rsz");break;
case eReflowReason_StyleChange:
printf("Sty");break;
case eReflowReason_Dirty:
printf("Drt ");
break;
default:printf("<unknown>%d", aReflowState.reason);break;
}
printSize("AW", aReflowState.availableWidth);
printSize("AH", aReflowState.availableHeight);
printSize("CW", aReflowState.ComputedWidth());
printSize("CH", aReflowState.ComputedHeight());
printf(" *\n");
#endif
aStatus = NS_FRAME_COMPLETE;
// create the layout state
nsBoxLayoutState state(aPresContext, aReflowState.rendContext);
nsSize computedSize(aReflowState.ComputedWidth(),aReflowState.ComputedHeight());
nsMargin m;
m = aReflowState.mComputedBorderPadding;
//GetBorderAndPadding(m);
// this happens sometimes. So lets handle it gracefully.
if (aReflowState.ComputedHeight() == 0) {
nsSize minSize = GetMinSize(state);
computedSize.height = minSize.height - m.top - m.bottom;
}
nsSize prefSize(0,0);
// if we are told to layout intrinic then get our preferred size.
if (computedSize.width == NS_INTRINSICSIZE || computedSize.height == NS_INTRINSICSIZE) {
prefSize = GetPrefSize(state);
nsSize minSize = GetMinSize(state);
nsSize maxSize = GetMaxSize(state);
prefSize = BoundsCheck(minSize, prefSize, maxSize);
}
// get our desiredSize
if (aReflowState.ComputedWidth() == NS_INTRINSICSIZE) {
computedSize.width = prefSize.width;
} else {
computedSize.width += m.left + m.right;
}
if (aReflowState.ComputedHeight() == NS_INTRINSICSIZE) {
computedSize.height = prefSize.height;
} else {
computedSize.height += m.top + m.bottom;
}
// handle reflow state min and max sizes
// XXXbz the width handling here seems to be wrong, since
// mComputedMin/MaxWidth is a content-box size, whole
// computedSize.width is a border-box size...
if (computedSize.width > aReflowState.mComputedMaxWidth)
computedSize.width = aReflowState.mComputedMaxWidth;
if (computedSize.width < aReflowState.mComputedMinWidth)
computedSize.width = aReflowState.mComputedMinWidth;
// Now adjust computedSize.height for our min and max computed
// height. The only problem is that those are content-box sizes,
// while computedSize.height is a border-box size. So subtract off
// m.TopBottom() before adjusting, then readd it.
computedSize.height = std::max(0, computedSize.height - m.TopBottom());
computedSize.height = NS_CSS_MINMAX(computedSize.height,
aReflowState.mComputedMinHeight,
aReflowState.mComputedMaxHeight);
computedSize.height += m.TopBottom();
nsRect r(mRect.x, mRect.y, computedSize.width, computedSize.height);
SetBounds(state, r);
// layout our children
Layout(state);
// ok our child could have gotten bigger. So lets get its bounds
aDesiredSize.width = mRect.width;
aDesiredSize.height = mRect.height;
aDesiredSize.ascent = GetBoxAscent(state);
// the overflow rect is set in SetBounds() above
aDesiredSize.mOverflowAreas = GetOverflowAreas();
#ifdef DO_NOISY_REFLOW
{
printf("%p ** nsLBF(done) W:%d H:%d ", this, aDesiredSize.width, aDesiredSize.height);
if (maxElementWidth) {
printf("MW:%d\n", *maxElementWidth);
} else {
printf("MW:?\n");
}
}
#endif
return NS_OK;
}
NS_IMETHODIMP
nsLeafBoxFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// This is mostly a copy of nsBoxFrame::Reflow().
// We aren't able to share an implementation because of the frame
// class hierarchy. If you make changes here, please keep
// nsBoxFrame::Reflow in sync.
DO_GLOBAL_REFLOW_COUNT("nsLeafBoxFrame", aReflowState.reason);
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
NS_ASSERTION(aReflowState.mComputedWidth >=0 && aReflowState.mComputedHeight >= 0, "Computed Size < 0");
#ifdef DO_NOISY_REFLOW
printf("\n-------------Starting LeafBoxFrame Reflow ----------------------------\n");
printf("%p ** nsLBF::Reflow %d R: ", this, myCounter++);
switch (aReflowState.reason) {
case eReflowReason_Initial:
printf("Ini");break;
case eReflowReason_Incremental:
printf("Inc");break;
case eReflowReason_Resize:
printf("Rsz");break;
case eReflowReason_StyleChange:
printf("Sty");break;
case eReflowReason_Dirty:
printf("Drt ");
break;
default:printf("<unknown>%d", aReflowState.reason);break;
}
printSize("AW", aReflowState.availableWidth);
printSize("AH", aReflowState.availableHeight);
printSize("CW", aReflowState.mComputedWidth);
printSize("CH", aReflowState.mComputedHeight);
printf(" *\n");
#endif
aStatus = NS_FRAME_COMPLETE;
// create the layout state
nsBoxLayoutState state(aPresContext, aReflowState, aDesiredSize);
// coelesce reflows if we are root.
state.HandleReflow(this);
nsSize computedSize(aReflowState.mComputedWidth,aReflowState.mComputedHeight);
nsMargin m;
m = aReflowState.mComputedBorderPadding;
//GetBorderAndPadding(m);
// this happens sometimes. So lets handle it gracefully.
if (aReflowState.mComputedHeight == 0) {
nsSize minSize(0,0);
GetMinSize(state, minSize);
computedSize.height = minSize.height - m.top - m.bottom;
}
nsSize prefSize(0,0);
// if we are told to layout intrinic then get our preferred size.
if (computedSize.width == NS_INTRINSICSIZE || computedSize.height == NS_INTRINSICSIZE) {
nsSize minSize(0,0);
nsSize maxSize(0,0);
GetPrefSize(state, prefSize);
GetMinSize(state, minSize);
GetMaxSize(state, maxSize);
BoundsCheck(minSize, prefSize, maxSize);
}
// get our desiredSize
if (aReflowState.mComputedWidth == NS_INTRINSICSIZE) {
computedSize.width = prefSize.width;
} else {
computedSize.width += m.left + m.right;
}
if (aReflowState.mComputedHeight == NS_INTRINSICSIZE) {
computedSize.height = prefSize.height;
} else {
computedSize.height += m.top + m.bottom;
}
// handle reflow state min and max sizes
if (computedSize.width > aReflowState.mComputedMaxWidth)
computedSize.width = aReflowState.mComputedMaxWidth;
if (computedSize.height > aReflowState.mComputedMaxHeight)
computedSize.height = aReflowState.mComputedMaxHeight;
if (computedSize.width < aReflowState.mComputedMinWidth)
computedSize.width = aReflowState.mComputedMinWidth;
if (computedSize.height < aReflowState.mComputedMinHeight)
computedSize.height = aReflowState.mComputedMinHeight;
nsRect r(mRect.x, mRect.y, computedSize.width, computedSize.height);
SetBounds(state, r);
// layout our children
Layout(state);
// ok our child could have gotten bigger. So lets get its bounds
// get the ascent
nscoord ascent = mRect.height;
// Only call GetAscent when not doing Initial reflow while in PP
// or when it is Initial reflow while in PP and a chrome doc
// If called again with initial reflow it crashes because the
// frames are fully constructed (I think).
PRBool isChrome;
PRBool isInitialPP = nsBoxFrame::IsInitialReflowForPrintPreview(state, isChrome);
if (!isInitialPP || (isInitialPP && isChrome)) {
GetAscent(state, ascent);
}
aDesiredSize.width = mRect.width;
aDesiredSize.height = mRect.height;
aDesiredSize.ascent = ascent;
aDesiredSize.descent = 0;
// NS_FRAME_OUTSIDE_CHILDREN is set in SetBounds() above
if (mState & NS_FRAME_OUTSIDE_CHILDREN) {
nsRect* overflowArea = GetOverflowAreaProperty();
NS_ASSERTION(overflowArea, "Failed to set overflow area property");
aDesiredSize.mOverflowArea = *overflowArea;
}
// max sure the max element size reflects
// our min width
nscoord* maxElementWidth = state.GetMaxElementWidth();
if (maxElementWidth)
{
nsSize minSize(0,0);
GetMinSize(state, minSize);
if (mRect.width > minSize.width) {
if (aReflowState.mComputedWidth == NS_INTRINSICSIZE) {
*maxElementWidth = minSize.width;
} else {
*maxElementWidth = mRect.width;
}
} else {
*maxElementWidth = mRect.width;
}
}
#ifdef DO_NOISY_REFLOW
{
printf("%p ** nsLBF(done) W:%d H:%d ", this, aDesiredSize.width, aDesiredSize.height);
if (maxElementWidth) {
printf("MW:%d\n", *maxElementWidth);
} else {
printf("MW:?\n");
}
}
#endif
return NS_OK;
}
void BrowserBubble::MoveTo(int x, int y)
{
SetBounds(x, y, bounds_.width(), bounds_.height());
}
void MainMenu::OnThink()
{
BaseClass::OnThink();
SetBounds(0, 0, GameUI2().GetViewport().x, GameUI2().GetViewport().y);
}
void CMissile::OnUpdate (Metric rSecondsPerTick)
// OnUpdate
//
// Update the beam
{
// If we're already destroyed, then just update the timer until the
// vapor trail fades out
if (m_fDestroyed)
{
// Update the painter
if (m_pPainter)
{
m_pPainter->OnUpdate();
RECT rcRect;
m_pPainter->GetRect(&rcRect);
SetBounds(rcRect);
}
// Done?
if (--m_iLifeLeft <= 0)
{
Destroy(removedFromSystem, NULL);
return;
}
}
// Otherwise, update
else
{
int i;
CSystem *pSystem = GetSystem();
int iTick = m_iTick + GetDestiny();
bool bDestroy = false;
// Accelerate, if necessary
if (m_pDesc->m_iAccelerationFactor > 0
&& (iTick % 10 ) == 0)
{
if (m_pDesc->m_iAccelerationFactor < 100
|| GetVel().Length() < m_pDesc->m_rMaxMissileSpeed)
SetVel(GetVel() * (Metric)(m_pDesc->m_iAccelerationFactor / 100.0));
}
// If we can choose new targets, see if we need one now
if (m_pDesc->CanAutoTarget() && m_pTarget == NULL)
m_pTarget = GetNearestEnemy(MAX_TARGET_RANGE, false);
// If this is a tracking missile, change direction to face the target
if ((m_pDesc->m_iManeuverability > 0)
&& m_pTarget
&& ((iTick % m_pDesc->m_iManeuverability) == 0))
{
// Get the position and velocity of the target
CVector vTarget = m_pTarget->GetPos() - GetPos();
CVector vTargetVel = m_pTarget->GetVel() - GetVel();
// Figure out which direction to move in
Metric rCurrentSpeed = GetVel().Length();
Metric rTimeToIntercept = CalcInterceptTime(vTarget, vTargetVel, rCurrentSpeed);
if (rTimeToIntercept > 0.0)
{
CVector vInterceptPoint = vTarget + vTargetVel * rTimeToIntercept;
int iFireAngle = VectorToPolar(vInterceptPoint, NULL);
// If we are directional, then we are constrained to specific angles
if (m_pDesc->m_bDirectional)
{
if (!AreAnglesAligned(iFireAngle, m_iRotation, g_RotationAngle / 2))
{
int iTurn = (iFireAngle + 360 - m_iRotation) % 360;
if (iTurn >= 180)
m_iRotation = (m_iRotation + 360 - g_RotationAngle) % 360;
else
m_iRotation = (m_iRotation + g_RotationAngle) % 360;
}
}
else
{
if (!AreAnglesAligned(iFireAngle, m_iRotation, 1))
{
int iTurn = (iFireAngle + 360 - m_iRotation) % 360;
if (iTurn >= 180)
{
int iTurnAngle = Min((360 - iTurn), g_RotationAngle);
m_iRotation = (m_iRotation + 360 - iTurnAngle) % 360;
}
else
{
int iTurnAngle = Min(iTurn, g_RotationAngle);
m_iRotation = (m_iRotation + iTurnAngle) % 360;
}
SetVel(PolarToVector(m_iRotation, rCurrentSpeed));
}
}
SetVel(PolarToVector(m_iRotation, rCurrentSpeed));
}
}
// Update exhaust
if (m_pExhaust)
{
if (iTick % m_pDesc->m_iExhaustRate)
{
if (m_pExhaust->GetCount() == m_pExhaust->GetMaxCount())
m_pExhaust->Dequeue();
SExhaustParticle &New = m_pExhaust->GetAt(m_pExhaust->Queue());
New.vPos = GetPos();
New.vVel = GetVel();
}
for (int i = 0; i < m_pExhaust->GetCount(); i++)
{
SExhaustParticle &Particle = m_pExhaust->GetAt(i);
Particle.vVel = m_pDesc->m_rExhaustDrag * Particle.vVel;
Particle.vPos = Particle.vPos + Particle.vVel * g_SecondsPerUpdate;
}
}
// Update the painter
if (m_pPainter)
{
m_pPainter->OnUpdate();
RECT rcRect;
m_pPainter->GetRect(&rcRect);
SetBounds(rcRect);
}
// If we have a vapor trail and need to save rotation, do it
if (m_pDesc->m_iVaporTrailLength
&& m_pDesc->m_iManeuverability)
{
// Compute the current rotation
int iDirection;
if (m_pDesc->m_bDirectional)
iDirection = (AlignToRotationAngle(m_iRotation) + 180) % 360;
else
iDirection = (m_iRotation + 180) % 360;
// Add the current rotation to the list of saved rotations
if (m_pSavedRotations == NULL)
{
m_pSavedRotations = new int [m_pDesc->m_iVaporTrailLength];
m_iSavedRotationsCount = 0;
}
int iStart = Min(m_iSavedRotationsCount, m_pDesc->m_iVaporTrailLength - 1);
for (i = iStart; i > 0; i--)
m_pSavedRotations[i] = m_pSavedRotations[i - 1];
m_pSavedRotations[0] = iDirection;
if (m_iSavedRotationsCount < m_pDesc->m_iVaporTrailLength)
m_iSavedRotationsCount++;
}
// See if the missile hit anything
if (m_fDetonate && m_pDesc->HasFragments())
{
CreateFragments(GetPos());
CreateHitEffect(GetPos());
bDestroy = true;
}
else if (m_pHit)
{
// If we have fragments, then explode now
if (m_iHitDir == -1
&& m_pDesc->HasFragments()
&& m_iTick >= m_pDesc->m_iProximityFailsafe)
{
CreateFragments(m_vHitPos);
CreateHitEffect(m_vHitPos);
bDestroy = true;
}
// Otherwise, if this was a direct hit, then we do damage
else if (m_iHitDir != -1)
{
DamageResults result;
DamageDesc Damage = m_pDesc->m_Damage;
Damage.AddBonus(m_iBonus);
Damage.SetCause(m_iCause);
if (IsAutomatedWeapon())
Damage.SetAutomatedWeapon();
result = m_pHit->Damage(this,
m_vHitPos,
(m_iHitDir + 360 + mathRandom(0, 30) - 15) % 360,
Damage);
// If we hit another missile (or some small object) there is a chance
// that we continue
if (result == damagePassthrough)
{
m_iHitPoints = m_iHitPoints / 2;
bDestroy = (m_iHitPoints == 0);
}
// Set the missile to destroy itself after a hit
else if (m_pDesc->m_iPassthrough == 0
|| result == damageNoDamage
|| result == damageAbsorbedByShields
|| mathRandom(1, 100) > m_pDesc->m_iPassthrough)
bDestroy = true;
CreateHitEffect(m_vHitPos);
}
}
// See if the missile has faded out
if (bDestroy || --m_iLifeLeft <= 0)
{
// If this is a fragmentation weapon, then we explode at the end of life
if (!bDestroy && m_pDesc->HasFragments())
{
CreateFragments(GetPos());
CreateHitEffect(GetPos());
}
// If we've got a vapor trail effect, then keep the missile object alive
// but mark it destroyed
int iFadeLife;
if (m_pDesc->m_iVaporTrailLength)
{
m_fDestroyed = true;
m_iLifeLeft = m_pDesc->m_iVaporTrailLength;
}
// If we've got an effect that needs time to fade out, then keep
// the missile object alive
else if (m_pPainter && (iFadeLife = m_pPainter->GetFadeLifetime()))
{
m_pPainter->OnBeginFade();
m_fDestroyed = true;
m_iLifeLeft = iFadeLife;
}
// Otherwise, destroy the missile
else
{
Destroy(removedFromSystem, NULL);
return;
}
}
}
m_iTick++;
}
