Backups/GTASource
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c971d568a112e5bec2e45ab389375b07c6914a6e
GTASource/game/frontend/html/HtmlDocument.cpp
T
expvintl 419f2e4752 init
2025-02-23 17:40:52 +08:00

2224 lines
63 KiB
C++
Raw Blame History

//
// filename: HtmlDocument.cpp
// description:
//
// --- Include Files ------------------------------------------------------------
#include "HtmlDocument.h"
// C headers
// Rage headers
#include "file/asset.h"
#include "file/device.h"
#include "file/device_relative.h"
#include "flash/err.h"
#include "parsercore/attribute.h"
#include "parsercore/element.h"
#include "system/param.h"
// Game headerso
#include "Css.h"
#include "HtmlLanguage.h"
#include "HtmlNode.h"
#include "HtmlParser.h"
// Framework Headers
//#include "fwmaths/Maths.h"
#ifndef HTML_RESOURCE
#include "HtmlScriptObject.h"
#include "HtmlTextFormat.h"
#include "HtmlViewport.h"
#include "camera/viewports/Viewport.h"
#include "debug/debug.h"
#include "Text/TextFormat.h"
#include "renderer/RenderThread.h"
#include "scene/stores/txdstore.h"
#endif
// --- Defines ------------------------------------------------------------------
// --- Constants ----------------------------------------------------------------
// --- Structure/Class Definitions ----------------------------------------------
// --- Globals ------------------------------------------------------------------
#if __DEV
PARAM(htmlpath, "Path to find non-resourced HTML files");
#endif
// --- Static Globals -----------------------------------------------------------
// --- Static class members -----------------------------------------------------
CHtmlNode* CHtmlDocument::sm_pCurrent;
atArray<parElement*> CHtmlDocument::sm_elements;
bool CHtmlDocument::sm_parseScriptObjects = true;
bool CHtmlDocument::sm_loadTextures = true;
bool CHtmlDocument::sm_inBody = false;
atArray<CHtmlNode* > CHtmlDocument::sm_inlineObjs;
CHtmlDocument* CHtmlDocument::sm_pCurrentDocument = NULL;
CHtmlDocument::LoadTextureFn CHtmlDocument::sm_loadTextureFn = NULL;
atArray<int> CHtmlDocument::sm_txdIndicesUsed;
#ifndef HTML_RESOURCE
CTextLayout CHtmlDocument::sm_HtmlTextLayout;
#endif
#if __DEV
s32 CHtmlNode::sm_debugPrintTab = 0;
#ifndef HTML_RESOURCE
PARAM(debugscripthtml, "Debug html script objects");
#endif
#endif
// --- Code ---------------------------------------------------------------------
// --- CHtmlDocument ------------------------------------------------------------
CHtmlDocument::CHtmlDocument() : m_pRootNode(NULL),
m_pBodyNode(NULL),
m_pTitle(NULL),
m_pTxd(NULL)
{
}
CHtmlDocument::CHtmlDocument(datResource& rsc) :
m_pTitle(rsc),
m_pTxd(rsc),
//m_swfArray(rsc, true),
m_links(rsc, true),
m_styleSheet(rsc)
{
// do them in the function because we want to control the order they get done in
rsc.PointerFixup(m_pRootNode);
::new ((void*)m_pRootNode) CHtmlElementNode(rsc);
rsc.PointerFixup(m_pBodyNode);
}
CHtmlDocument::~CHtmlDocument()
{
Delete();
}
void CHtmlDocument::Init(unsigned /*initMode*/)
{
static fiDeviceRelative gHttpDevice;
// create html mount
#if __DEV
const char* pHtmlPath;
if(PARAM_htmlpath.Get(pHtmlPath))
gHttpDevice.Init(pHtmlPath, false);
else
#endif
gHttpDevice.Init("platform:/html/", true);
gHttpDevice.MountAs("http:/");
}
void CHtmlDocument::Place(CHtmlDocument* that, datResource& rsc)
{
sm_pCurrentDocument = that;
::new (that) CHtmlDocument(rsc);
sm_pCurrentDocument = NULL;
}
#if __DECLARESTRUCT
void CHtmlDocument::DeclareStruct(datTypeStruct &s)
{
STRUCT_BEGIN(CHtmlDocument);
if(m_pRootNode)
datSwapper(*m_pRootNode);
STRUCT_FIELD_VP(m_pRootNode);
STRUCT_FIELD_VP(m_pBodyNode);
STRUCT_FIELD(m_pTitle);
STRUCT_FIELD(m_pTxd);
STRUCT_FIELD(m_padArray);
STRUCT_FIELD(m_links);
STRUCT_FIELD(m_styleSheet);
STRUCT_END();
}
#endif
void CHtmlDocument::Delete()
{
if(m_pRootNode)
{
delete m_pRootNode;
m_pRootNode = NULL;
}
// remove title string
if(m_pTitle)
{
delete[] m_pTitle;
m_pTitle = NULL;
}
// remove texture dictionary
if(m_pTxd)
{
#ifndef HTML_RESOURCE
// flush render thread so it releases the current visible objects
gRenderThreadInterface.Flush();
#endif //HTML_RESOURCE
delete m_pTxd;
m_pTxd = NULL;
}
m_links.Reset();
// m_swfArray.Reset();
m_styleSheet.Shutdown();
// reset the txds used
sm_txdIndicesUsed.Reset();
}
//
// name: CHtmlDocument::GetLinkRef
// description: Get web page this link references
const char* CHtmlDocument::GetLinkRef(s32 link)
{
CHtmlElementNode* pNode = m_links[link];
return pNode->GetAttributeData();
}
//
// name: CHtmlDocument::GetLinkAtPosition
// description: Return the link at this position. If there is no link then return -1
s32 CHtmlDocument::GetLinkAtPosition(float x, float y)
{
#define TEMP_LINK_WIDTH (48.0f)
#define TEMP_LINK_HEIGHT (16.0f)
// temporary until we get proper bounding boxes for the links
for(s32 i=0; i<m_links.GetCount(); i++)
{
CHtmlElementNode* pNode = m_links[i];
float linkX = pNode->GetRenderState().m_currentX;
float linkY = pNode->GetRenderState().m_currentY;
float linkWidth = pNode->GetRenderState().m_width;
float linkHeight = pNode->GetRenderState().m_height;
if(x >= linkX && x < linkX+linkWidth && y >= linkY && y < linkY+linkHeight)
return i;
}
return -1;
}
//
// name: CHtmlDocument::AddInlineObject
// description: Add to inline object list
void CHtmlDocument::AddInlineObject(CHtmlNode* pNode)
{
sysMemStartTemp();
sm_inlineObjs.PushAndGrow(pNode);
sysMemEndTemp();
}
//
// name: CHtmlDocument::ResetInlineObjectList
// description: Reset inline object list
void CHtmlDocument::ResetInlineObjectList()
{
sysMemStartTemp();
sm_inlineObjs.Reset();
sysMemEndTemp();
}
//
// name: CHtmlDocument::SetupDefaultStyleSheet
// description: Setup default style sheet
void CHtmlDocument::SetupDefaultStyleSheet()
{
m_styleSheet.Init();
CCssStyleClass* pClass = m_styleSheet.GetDefaultStyleClass();
CCssStyleGroup* pGroup = pClass->AddStyleGroup(HTML_HTML);
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_BODY);
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINBOTTOM, 8));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINLEFT, 8));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINRIGHT, 8));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 8));
pGroup->AddStyle(CCssStyle(CCssStyle::COLOR, Color32(0,0,0)));
pGroup->AddStyle(CCssStyle(CCssStyle::BACKGROUNDCOLOR, Color32(255,255,255)));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_HEADING1);
pGroup->AddStyle(CCssStyle(CCssStyle::FONTSIZE, 24));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 16));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINBOTTOM, 16));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_HEADING2);
pGroup->AddStyle(CCssStyle(CCssStyle::FONTSIZE, 18));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 13.5f));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINBOTTOM, 13.5f));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_HEADING3);
pGroup->AddStyle(CCssStyle(CCssStyle::FONTSIZE, 14));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 12));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINBOTTOM, 12));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_HEADING4);
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 12));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINBOTTOM, 15));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_HEADING5);
pGroup->AddStyle(CCssStyle(CCssStyle::FONTSIZE, 10));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 15));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_HEADING6);
pGroup->AddStyle(CCssStyle(CCssStyle::FONTSIZE, 9));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 15));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_DIV);
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
// pGroup = sm_styleSheet.AddStyleGroup(HTML_IMAGE);
// pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_TABLE);
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERWIDTH, 1.0f));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERSTYLE, HTML_SOLID));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERLEFTCOLOR, Color32(0xcc,0xcc,0xcc)));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERTOPCOLOR, Color32(0xcc,0xcc,0xcc)));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERRIGHTCOLOR, Color32(0x66,0x66,0x66)));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERBOTTOMCOLOR, Color32(0x66,0x66,0x66)));
pGroup = pClass->AddStyleGroup(HTML_TABLEROW);
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_TABLESECTION));
pGroup = pClass->AddStyleGroup(HTML_TABLEENTRY);
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_TABLECELL));
pGroup->AddStyle(CCssStyle(CCssStyle::VERTICALALIGN, HTML_ALIGN_MIDDLE));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERWIDTH, 1.0f));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERSTYLE, HTML_SOLID));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERTOPCOLOR, Color32(0x66,0x66,0x66)));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERLEFTCOLOR, Color32(0x66,0x66,0x66)));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERBOTTOMCOLOR, Color32(0xcc,0xcc,0xcc)));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERRIGHTCOLOR, Color32(0xcc,0xcc,0xcc)));
pGroup = pClass->AddStyleGroup(HTML_TABLEHEADER);
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_TABLECELL));
pGroup->AddStyle(CCssStyle(CCssStyle::VERTICALALIGN, HTML_ALIGN_MIDDLE));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERWIDTH, 1.0f));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERSTYLE, HTML_SOLID));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERTOPCOLOR, Color32(0x66,0x66,0x66)));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERLEFTCOLOR, Color32(0x66,0x66,0x66)));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERBOTTOMCOLOR, Color32(0xcc,0xcc,0xcc)));
pGroup->AddStyle(CCssStyle(CCssStyle::BORDERRIGHTCOLOR, Color32(0xcc,0xcc,0xcc)));
pGroup = pClass->AddStyleGroup(HTML_DEFLIST);
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 14));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINBOTTOM, 14));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_DEFTERM);
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_DEFDESC);
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINLEFT, 40));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_UNORDERED_LIST);
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 14));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINBOTTOM, 14));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINLEFT, 40));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_ORDERED_LIST);
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 14));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINBOTTOM, 14));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINLEFT, 40));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_PARAGRAPH);
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINTOP, 14));
pGroup->AddStyle(CCssStyle(CCssStyle::MARGINBOTTOM, 14));
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup = pClass->AddStyleGroup(HTML_A);
pGroup->AddStyle(CCssStyle(CCssStyle::TEXTDECORATION, HTML_UNDERLINE));
pGroup->AddStyle(CCssStyle(CCssStyle::COLOR, Color32(0x80,0x80,0x80)));
pGroup = pClass->AddStyleGroup(HTML_CENTER);
pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
pGroup->AddStyle(CCssStyle(CCssStyle::TEXTALIGN, HTML_ALIGN_CENTER));
// pGroup = pClass->AddStyleGroup(HTML_SPAN);
// pGroup->AddStyle(CCssStyle(CCssStyle::DISPLAY, HTML_BLOCK));
}
void CHtmlDocument::PushHtmlFolder(const char* pFilename)
{
char pathname[RAGE_MAX_PATH];
ASSET.RemoveNameFromPath(pathname, RAGE_MAX_PATH, pFilename);
ASSET.PushFolder(pathname);
}
bool CHtmlDocument::LoadDocument(const char* pFilename)
{
sysMemStartTemp();
// set flash warning level
#if __DEV
// swfSetFlashDebugLevel(eFEL_Fatal, eFWL_Critical);
#endif
Assert(m_pRootNode == NULL);
CHtmlDocument::PushHtmlFolder(pFilename);
fiStream* pStream = ASSET.Open(ASSET.FileName(pFilename), NULL);
if(pStream == NULL)
{
return false;
}
sm_pCurrentDocument = this;
CHtmlLanguage::GetCurrent();
sm_pCurrent = NULL;
sysMemEndTemp();
SetupDefaultStyleSheet();
sysMemStartTemp();
// If loading texture function isn't setup then set it
if(sm_loadTextureFn == 0)
sm_loadTextureFn = MakeFunctorRet(*this, &CHtmlDocument::LoadTextureInternal);
CHtmlParser parser(pStream);
parser.SetBeginElementCallback(parStreamIn::BeginElementCB(this, &CHtmlDocument::ReadBeginElement));
parser.SetEndElementCallback(parStreamIn::EndElementCB(this, &CHtmlDocument::ReadEndElement));
parser.SetDataCallback(parStreamIn::DataCB(this, &CHtmlDocument::ReadData));
parser.ReadWithCallbacks();
pStream->Close();
sysMemEndTemp();
Process();
sysMemStartTemp();
ResetElementArray();
//sm_styleSheet.Shutdown();
sysMemEndTemp();
ASSET.PopFolder();
// reset loading texture function
sm_loadTextureFn = NULL;
sm_pCurrentDocument = NULL;
return true;
}
void CHtmlDocument::ReadBeginElement(parElement& element, bool leaf)
{
CHtmlElementNode* pNode;
parElement* pElement = rage_new parElement;
// ensure element owns it own name
pElement->SetName("temp", true);
sm_elements.PushAndGrow(pElement);
pElement->CopyFrom(element);
sysMemEndTemp();
// If this is a table element create a special class because table formatting is a bitch and needs loads
// of special code
if(!stricmp(element.GetName(), "table"))
pNode = rage_new CHtmlTableNode(pElement);
else if(!stricmp(element.GetName(), "td") || !stricmp(element.GetName(), "th") || !stricmp(element.GetName(), "tr"))
pNode = rage_new CHtmlTableElementNode(pElement);
// else if(!stricmp(element.GetName(), "embed")) // assume all embed tags are flash objects
// pNode = new CHtmlFlashNode(pElement);
else
pNode = rage_new CHtmlElementNode(pElement);
// if there is no current node then this must be the root node
if(sm_pCurrent == NULL)
{
Assert(m_pRootNode == NULL);
m_pRootNode = pNode;
}
else
sm_pCurrent->AddChild(pNode);
if(leaf == false)
{
sm_pCurrent = pNode;
}
sysMemStartTemp();
}
void CHtmlDocument::ReadEndElement(bool leaf)
{
if(!leaf)
sm_pCurrent = sm_pCurrent->GetParent();
}
void CHtmlDocument::ReadData(char* pData, int size, bool incomplete)
{
sysMemEndTemp();
if(incomplete)
Quitf("Need to increase datachunk size. Data is too large");
Assert(sm_pCurrent);
CHtmlElementNode* pElement = dynamic_cast<CHtmlElementNode*>(sm_pCurrent);
// if parent element is a style tag then read style sheet
if(pElement && !stricmp(pElement->GetElement().GetName(), "style"))
{
char filename[RAGE_MAX_PATH];
fiDeviceMemory::MakeMemoryFileName(filename, sizeof(filename), pData, size, false, NULL);
m_styleSheet.ReadFile(filename);
}
else
{
CHtmlDataNode* pNode = rage_new CHtmlDataNode(pData, size);
sm_pCurrent->AddChild(pNode);
}
sysMemStartTemp();
}
//
// name: CHtmlDocument::SetActive
// description:
void CHtmlDocument::SetActive(CHtmlNode* pNode, bool active)
{
pNode->GetRenderState().m_active = active;
for(s32 i=0; i<pNode->GetNumChildren(); i++)
SetActive(pNode->GetChild(i), active);
}
//
// name: CHtmlDocument::Process
// description: Extract data from elements
void CHtmlDocument::Process()
{
sm_inBody = false;
ProcessNode(m_pRootNode);
Assertf(m_pRootNode->GetElementId() == HTML_HTML, "There is no HTML tag in this file");
}
//
// name: CHtmlDocument::Process
// description: Extract data from elements
void CHtmlDocument::PostProcess()
{
PostProcessNode(m_pRootNode);
}
void CHtmlDocument::ProcessNode(CHtmlNode* pNode)
{
CHtmlElementNode* pElement = dynamic_cast<CHtmlElementNode*>(pNode);
CHtmlDataNode* pData = dynamic_cast<CHtmlDataNode*>(pNode);
if(pElement)
{
ProcessElement(pElement);
// process children nodes
for(s32 i=0; i<pNode->GetNumChildren(); i++)
{
pNode->GetChild(i)->GetRenderState().Inherit(pNode->GetRenderState());
ProcessNode(pNode->GetChild(i));
}
// this is called from PostProcessNode now
//PostProcessElement(pElement);
pElement->ResetParserElement();
}
else if(pData)
ProcessData(pData);
}
void CHtmlDocument::ProcessElement(CHtmlElementNode* pElementNode)
{
s32 elementId = CHtmlLanguage::GetCurrent().GetElementId(pElementNode->GetElement().GetName());
pElementNode->m_elementId = elementId;
#if __DEV
if(elementId == HTML_ELEMENT_INVALID)
Warningf("Unrecognised tag: %s", pElementNode->GetElement().GetName());
#endif
// Apply style sheet
ApplyDefaultStyleSheet(pElementNode);
// inherit table values
if(pElementNode->GetRenderState().m_display == HTML_TABLECELL ||
pElementNode->GetRenderState().m_display == HTML_TABLESECTION)
{
pElementNode->GetRenderState().InheritTableState(pElementNode->GetParent()->GetRenderState());
}
ProcessAttributes(pElementNode);
switch(elementId)
{
case HTML_BODY:
ProcessBody(pElementNode);
break;
case HTML_META:
ProcessMetaData(pElementNode);
break;
case HTML_A:
ProcessLink(pElementNode);
break;
case HTML_LINK:
ProcessFileLink(pElementNode);
break;
case HTML_IMAGE:
ProcessImage(pElementNode);
break;
case HTML_EMBED:
ProcessEmbed(pElementNode);
break;
case HTML_OBJECT:
ProcessObject(pElementNode);
break;
case HTML_SCRIPTOBJ:
ProcessScriptObject(pElementNode);
break;
case HTML_TEXT:
ProcessText(pElementNode);
break;
default:
break;
}
}
//
// name: CHtmlDocument::ResetElementArray
// description: Reset all the parser elements and empty array
void CHtmlDocument::ResetElementArray()
{
for(s32 i=0; i<sm_elements.GetCount(); i++)
{
delete sm_elements[i];
}
sm_elements.Reset();
}
//
// name: ApplyDefaultStyleSheet
// description: Apply default style sheet for this node
void CHtmlDocument::ApplyDefaultStyleSheet(CHtmlElementNode* pNode)
{
CCssStyleGroup* pGroup = m_styleSheet.GetDefaultStyleClass()->GetStyleGroup(pNode->GetElementId());
if(pGroup)
pGroup->Apply(pNode->GetRenderState());
// check for pseudo classes
ApplyPseudoClassStyleSheet(pNode, "", ":hover");
}
//
// name: ApplyDefaultStyleSheet
// description: Apply default style sheet for this node
void CHtmlDocument::ApplyStyleSheet(CHtmlElementNode* pNode, const char* pClassName)
{
CCssStyleClass* pClass = m_styleSheet.GetStyleClass(pClassName);
if(pClass)
{
// apply default style group first
CCssStyleGroup* pGroup = pClass->GetDefaultStyleGroup();
if(pGroup)
pGroup->Apply(pNode->GetRenderState());
// apply element style group
pGroup = pClass->GetStyleGroup(pNode->GetElementId());
if(pGroup)
pGroup->Apply(pNode->GetRenderState());
// check for pseudo classes
ApplyPseudoClassStyleSheet(pNode, pClassName, ":hover");
}
}
//
// name: CHtmlDocument::ApplyPseudoClassStyleSheet
// description: Apply style sheet pseudo classes to additional renderstates
void CHtmlDocument::ApplyPseudoClassStyleSheet(CHtmlElementNode* pNode, const char* pClassName, const char* pPseudoClassName)
{
CCssStyleClass* pClass;
CCssStyleGroup* pGroup;
// check for pseudo classes
char pseudoClassName[128];
strcpy(pseudoClassName, pClassName);
strcat(pseudoClassName, pPseudoClassName);
pClass = m_styleSheet.GetStyleClass(pseudoClassName);
if(pClass)
{
// apply element style group
pGroup = pClass->GetStyleGroup(pNode->GetElementId());
if(pGroup)
{
pGroup->ApplyHoverPseudoClass(pNode->GetRenderState());
}
}
}
void CHtmlDocument::ProcessAttributes(CHtmlElementNode* pElementNode)
{
parElement& element = pElementNode->GetElement();
HtmlRenderState& renderState = pElementNode->GetRenderState();
sysMemStartTemp();
for(s32 i=0; i<element.GetAttributes().GetCount(); i++)
{
parAttribute& attr = element.GetAttributes()[i];
HtmlAttributeTag tag = CHtmlLanguage::GetCurrent().GetAttributeId(attr.GetName());
switch(tag)
{
case HTML_ATTR_ALIGN:
renderState.m_textAlign = CHtmlLanguage::GetCurrent().GetValueId(attr.GetStringValue());
break;
case HTML_ATTR_ALINK:
renderState.m_activeColor = CHtmlLanguage::GetCurrent().GetColor(attr.GetStringValue());
break;
case HTML_ATTR_LINK:
{
Color32 col = CHtmlLanguage::GetCurrent().GetColor(attr.GetStringValue());
m_styleSheet.GetDefaultStyleClass()->GetStyleGroup(HTML_A)->AddStyle(CCssStyle(CCssStyle::COLOR, col));
}
break;
case HTML_ATTR_BGCOLOR:
renderState.m_renderBackground = true;
renderState.m_backgroundColor = CHtmlLanguage::GetCurrent().GetColor(attr.GetStringValue());
break;
case HTML_ATTR_BACKGROUND:
{
sysMemEndTemp();
renderState.m_pBackgroundImage = sm_loadTextureFn(attr.GetStringValue());
renderState.m_renderBackground = true;
sysMemStartTemp();
}
break;
case HTML_ATTR_BORDER:
attr.ConvertToInt();
{
float border = (float)attr.GetIntValue();
if(border == 0.0f)
{
renderState.m_borderBottomStyle = HTML_NONE;
renderState.m_borderLeftStyle = HTML_NONE;
renderState.m_borderRightStyle = HTML_NONE;
renderState.m_borderTopStyle = HTML_NONE;
}
else
{
renderState.m_borderBottomStyle = HTML_SOLID;
renderState.m_borderLeftStyle = HTML_SOLID;
renderState.m_borderRightStyle = HTML_SOLID;
renderState.m_borderTopStyle = HTML_SOLID;
}
renderState.m_borderBottomWidth = border;
renderState.m_borderLeftWidth = border;
renderState.m_borderRightWidth = border;
renderState.m_borderTopWidth = border;
}
break;
case HTML_ATTR_BORDERCOLOR:
renderState.m_borderBottomColor = CHtmlLanguage::GetCurrent().GetColor(attr.GetStringValue());
renderState.m_borderLeftColor = renderState.m_borderBottomColor;
renderState.m_borderRightColor = renderState.m_borderBottomColor;
renderState.m_borderTopColor = renderState.m_borderBottomColor;
break;
case HTML_ATTR_CELLSPACING:
attr.ConvertToInt();
renderState.m_cellspacing = (float)attr.GetIntValue();
break;
case HTML_ATTR_CELLPADDING:
attr.ConvertToInt();
renderState.m_cellpadding = (float)attr.GetIntValue();
break;
case HTML_ATTR_CLASS:
// do some style sheet
ApplyStyleSheet(pElementNode, attr.GetStringValue());
break;
case HTML_ATTR_COLOR:
renderState.m_color = CHtmlLanguage::GetCurrent().GetColor(attr.GetStringValue());
break;
case HTML_ATTR_HEIGHT:
attr.ConvertToInt();
renderState.m_forcedHeight = (float)attr.GetIntValue();
break;
case HTML_ATTR_MARGINHEIGHT:
attr.ConvertToInt();
renderState.m_marginBottom = (float)attr.GetIntValue();
renderState.m_marginTop = (float)attr.GetIntValue();
break;
case HTML_ATTR_MARGINWIDTH:
attr.ConvertToInt();
renderState.m_marginLeft = (float)attr.GetIntValue();
renderState.m_marginRight = (float)attr.GetIntValue();
break;
case HTML_ATTR_VALIGN:
renderState.m_verticalAlign = CHtmlLanguage::GetCurrent().GetValueId(attr.GetStringValue());
break;
case HTML_ATTR_WIDTH:
attr.ConvertToInt();
renderState.m_forcedWidth = (float)attr.GetIntValue();
break;
case HTML_ATTR_STYLE:
ParseStyle(attr.GetStringValue(), renderState);
break;
case HTML_ATTR_COLSPAN:
attr.ConvertToInt();
renderState.m_colSpan = attr.GetIntValue();
break;
case HTML_ATTR_ROWSPAN:
attr.ConvertToInt();
renderState.m_rowSpan = attr.GetIntValue();
break;
case HTML_ATTR_SRC:
case HTML_ATTR_ALT:
case HTML_ATTR_NAME:
case HTML_ATTR_CONTENT:
case HTML_ATTR_HREF:
//ignore
break;
default:
Warningf("Unrecognised attribute %s", attr.GetName());
break;
}
}
sysMemEndTemp();
}
void CHtmlDocument::ParseStyle(const char* pStyle, HtmlRenderState& renderState)
{
sysMemStartTemp();
char filename[RAGE_MAX_PATH];
fiDeviceMemory::MakeMemoryFileName(filename, sizeof(filename), pStyle, strlen(pStyle), false, NULL);
CCssStyleGroup styleGroup;
styleGroup.ReadFile(filename);
styleGroup.Apply(renderState);
sysMemEndTemp();
}
void CHtmlDocument::ProcessBody(CHtmlElementNode* pElementNode)
{
// parElement& element = pElementNode->m_element;
sm_inBody = true;
// pElementNode->GetRenderState().m_renderBackground = true;
m_pBodyNode = pElementNode;
}
void CHtmlDocument::ProcessLink(CHtmlElementNode* pElementNode)
{
const parElement& element = pElementNode->GetElement();
// get image texture
const parAttribute* pHRef = element.FindAttribute("href");
// parElement& element = pElementNode->m_element;
// add to link array, if link has valid href value
if(pHRef)
{
pElementNode->m_data = pHRef->GetStringValue();
// This is now done in the PostProcess stage
//m_links.PushAndGrow(pElementNode);
}
}
void CHtmlDocument::ProcessFileLink(CHtmlElementNode* pElementNode)
{
const parElement& element = pElementNode->GetElement();
// get image texture
const parAttribute* pRel = element.FindAttribute("rel");
const parAttribute* pHRef = element.FindAttribute("href");
// parElement& element = pElementNode->m_element;
// add to link array, if link has valid href value
if(pRel && !stricmp(pRel->GetStringValue(), "stylesheet"))
{
// if there is a href attribute it must be the stylesheet filename
if(pHRef)
{
m_styleSheet.ReadFile(pHRef->GetStringValue());
}
}
}
void CHtmlDocument::ProcessImage(CHtmlElementNode* pElementNode)
{
char tempBuffer[512];
HtmlRenderState& rs = pElementNode->GetRenderState();
const parElement& element = pElementNode->GetElement();
grcTexture* pImage = NULL;
// get image texture
const parAttribute* pSrc = element.FindAttribute("src");
Assertf(pSrc, "\"img\" tag doesn't have \"src\" attribute");
const parAttribute* pTxd = element.FindAttribute("txd");
if(pTxd)
{
strcpy(tempBuffer, pTxd->GetStringValue());
strcat(tempBuffer, ":");
strcat(tempBuffer, pSrc->GetStringValue());
pElementNode->m_data = tempBuffer;
#ifndef HTML_RESOURCE
if(pTxd->GetStringValue()[0] == '*')
{
pImage = grcTextureFactory::GetInstance().LookupTextureReference(pElementNode->GetTextureName());
}
else
{
int slot = g_TxdStore.FindSlot(pTxd->GetStringValue());
Assertf(slot != -1, "%s:Txd file does not exist", pTxd->GetStringValue());
g_TxdStore.PushCurrentTxd();
g_TxdStore.SetCurrentTxd(slot);
pImage = sm_loadTextureFn(pElementNode->GetTextureName());
g_TxdStore.PopCurrentTxd();
// add slot to txd array if it isn't already there
s32 i;
for(i=0; i<sm_txdIndicesUsed.GetCount(); i++)
if(sm_txdIndicesUsed[i] == slot)
break;
if(i == sm_txdIndicesUsed.GetCount())
sm_txdIndicesUsed.PushAndGrow(slot);
}
#endif
}
else
{
pgDictionary<grcTexture>::SetCurrent(NULL);
pElementNode->m_data = pSrc->GetStringValue();
pImage = sm_loadTextureFn(pElementNode->m_data);
}
// work out width and height of image
float width=-1;
float height=-1;
if(pImage)
{
width = (float)pImage->GetWidth();
height = (float)pImage->GetHeight();
}
const parAttribute* pWidth = element.FindAttribute("width");
const parAttribute* pHeight = element.FindAttribute("height");
if(pWidth && pHeight)
{
rs.m_forcedWidth = (float)pWidth->GetIntValue();
rs.m_forcedHeight = (float)pHeight->GetIntValue();
}
else if(pWidth)
{
rs.m_forcedWidth = (float)pWidth->GetIntValue();
rs.m_forcedHeight = height * rs.m_width / width;
}
else if(pHeight)
{
rs.m_forcedHeight = (float)pHeight->GetIntValue();
rs.m_forcedWidth = width * rs.m_height / height;
}
else
{
rs.m_forcedHeight = height;
rs.m_forcedWidth = width;
}
rs.m_width = rs.m_forcedWidth;
rs.m_height = rs.m_forcedHeight;
}
void CHtmlDocument::ProcessEmbed(CHtmlElementNode* UNUSED_PARAM(pElementNode))
{
// assume all embed tags are flash movies
/* CHtmlFlashNode* pFlashNode = dynamic_cast<CHtmlFlashNode*>(pElementNode);
HtmlRenderState& rs = pElementNode->GetRenderState();
Assert(pFlashNode);
pFlashNode->Load();
m_swfArray.PushAndGrow(pFlashNode->GetContext());
rs.m_width = rs.m_forcedWidth;
rs.m_height = rs.m_forcedHeight;*/
}
void CHtmlDocument::ProcessObject(CHtmlElementNode* pElementNode)
{
// we are ignoring this object so we need to reset its renderstate so it doesn't affect its children
HtmlRenderState rs;
pElementNode->GetRenderState() = rs;
}
//
// name: CHtmlDocument::ProcessScriptObject
// description: Process related script object
void CHtmlDocument::ProcessScriptObject(CHtmlElementNode* pElementNode)
{
const parElement& element = pElementNode->GetElement();
const parAttribute* pAttr = element.FindAttribute("name");
Assertf(pAttr, "scriptobj tag doesn't have name attribute");
pElementNode->m_data = pAttr->GetStringValue();
#ifndef HTML_RESOURCE
if(sm_parseScriptObjects)
{
ParseScriptObject(pElementNode);
}
#endif
}
#ifndef HTML_RESOURCE
//
// name: CHtmlDocument::ParseScriptObject
// description:
void CHtmlDocument::ParseScriptObject(CHtmlElementNode* pElementNode)
{
sysMemStartTemp();
s32 index = gHtmlScriptObjectMgr.Get(pElementNode->m_data);
Assertf(index != -1, "%s:Script object doesn't exists", (const char*)pElementNode->m_data);
// create memory stream and load html from memory
char filename[64];
#if __DEV
if(PARAM_debugscripthtml.Get())
{
Displayf("\n%s\n", gHtmlScriptObjectMgr.GetHtml(index));
}
#endif
fiDeviceMemory::MakeMemoryFileName(filename, 64, gHtmlScriptObjectMgr.GetHtml(index), gHtmlScriptObjectMgr.GetHtmlSize(index), false, NULL);
// create file handle and load
fiStream* pStream = ASSET.Open(filename, NULL);
Assert(pStream);
sm_pCurrent = pElementNode;
CHtmlParser parser(pStream);
parser.SetBeginElementCallback(parStreamIn::BeginElementCB(this, &CHtmlDocument::ReadBeginElement));
parser.SetEndElementCallback(parStreamIn::EndElementCB(this, &CHtmlDocument::ReadEndElement));
parser.SetDataCallback(parStreamIn::DataCB(this, &CHtmlDocument::ReadData));
parser.ReadWithCallbacks();
pStream->Close();
sm_pCurrent = NULL;
sysMemEndTemp();
}
#endif
//
// name: CHtmlDocument::ProcessText
// description:
void CHtmlDocument::ProcessText(CHtmlElementNode* pElementNode)
{
// get name
const parElement& element = pElementNode->GetElement();
const parAttribute* pSrc = element.FindAttribute("name");
Assertf(pSrc, "\"text\" tag doesn't have \"name\" attribute");
pElementNode->m_data = pSrc->GetStringValue();
}
void CHtmlDocument::ProcessMetaData(CHtmlElementNode* UNUSED_PARAM(pElementNode))
{
}
void CHtmlDocument::PostProcessNode(CHtmlNode* pNode)
{
CHtmlElementNode* pElement = dynamic_cast<CHtmlElementNode*>(pNode);
if(pElement)
{
// process children nodes
for(s32 i=0; i<pNode->GetNumChildren(); i++)
{
//pNode->GetChild(i)->GetRenderState().Inherit(pNode->GetRenderState());
PostProcessNode(pNode->GetChild(i));
}
PostProcessElement(pElement);
}
}
void CHtmlDocument::PostProcessElement(CHtmlElementNode* pElementNode)
{
switch(pElementNode->m_elementId)
{
case HTML_TABLE:
PostProcessTable(pElementNode);
break;
case HTML_A:
PostProcessLink(pElementNode);
break;
default:
break;
}
}
void CHtmlDocument::PostProcessLink(CHtmlElementNode* pElementNode)
{
m_links.PushAndGrow(pElementNode);
}
#define TABLE_NODE_ARRAY_SIZE 1024
//
// name: GetTableNodes
// description: Fillout array with all the table related nodes
void CHtmlDocument::GetTableNodes(CHtmlNode* pNode, CHtmlElementNode** ppNodes, s32& index)
{
CHtmlElementNode* pElement = dynamic_cast<CHtmlElementNode*>(pNode);
CHtmlTableElementNode* pTableElement = dynamic_cast<CHtmlTableElementNode*>(pNode);
if(pElement)
{
if(pTableElement)
{
Assertf(index < TABLE_NODE_ARRAY_SIZE, "Too many table tags");
ppNodes[index] = pElement;
index++;
}
// don't process children for table entry as it may contain another table
if(pElement->GetRenderState().m_display != HTML_TABLECELL)
{
// process children nodes
for(s32 i=0; i<pNode->GetNumChildren(); i++)
{
GetTableNodes(pNode->GetChild(i), ppNodes, index);
}
}
}
}
//
// name: CountTableRowsAndColumns
// description: Count the number of rows and columns a table has
void CHtmlDocument::CountTableRowsAndColumns(CHtmlElementNode** pNodes, s32 num, CHtmlTableNode* pTableNode)
{
s32 numColumns = 0;
s32 numRows = 0;
s32 numColumns2=0;
for(s32 i=0; i<num; i++)
{
if(pNodes[i]->GetElementId() == HTML_TABLEROW)
{
if(numColumns2 > numColumns)
numColumns = numColumns2;
numRows++;
numColumns2 = 0;
}
if(pNodes[i]->GetRenderState().m_display == HTML_TABLECELL)
{
s32 colspan = pNodes[i]->GetRenderState().m_colSpan;
numColumns2 += colspan;
}
}
if(numColumns2 > numColumns)
numColumns = numColumns2;
// if found entry tags but no row tags
if(numColumns > 0 && numRows == 0)
numRows = 1;
pTableNode->SetNumColumns(numColumns);
pTableNode->SetNumRows(numRows);
}
//
// name: CHtmlDocument::CheckTableRowsAndColumns
// description: Check that table rows and columns haven't changed number and if so re-allocate
void CHtmlDocument::CheckTableRowsAndColumns(CHtmlElementNode** pNodes, s32 num, CHtmlTableNode* pTableNode)
{
s32 numRows = pTableNode->GetNumRows();
s32 numColumns = pTableNode->GetNumColumns();
CountTableRowsAndColumns(pNodes, num, pTableNode);
if(numRows != pTableNode->GetNumRows() || numColumns != pTableNode->GetNumColumns())
{
pTableNode->DeleteArrays();
pTableNode->AllocateArrays();
}
}
#ifndef HTML_RESOURCE
//
// name: GetTableCellCoords
// description: Calculate the cell coords for each table node
void CHtmlDocument::GetTableCellCoords(CHtmlElementNode** pNodes, s32 num, CHtmlTableNode* pTableNode)
{
s32* pRowSpan = Alloca(s32, pTableNode->GetNumColumns());
// set array to 1
for(s32 i=0; i<pTableNode->GetNumColumns(); i++)
pRowSpan[i] = 1;
s32 column = 0;
s32 rows = 0;
for(s32 i=0; i<num; i++)
{
if(pNodes[i]->GetElementId() == HTML_TABLEROW)
{
CHtmlTableElementNode* pTableElement = dynamic_cast<CHtmlTableElementNode*>(pNodes[i]);
Assert(pTableElement);
pTableElement->m_row = rows;
rows++;
column = 0;
}
if(pNodes[i]->GetRenderState().m_display == HTML_TABLECELL)
{
//If we have hit an entry and not hit a row increment row counter
if(rows == 0)
rows = 1;
while(pRowSpan[column] > rows && column < pTableNode->GetNumColumns())
column++;
Assert(column != pTableNode->GetNumColumns());
CHtmlTableElementNode* pTableElement = dynamic_cast<CHtmlTableElementNode*>(pNodes[i]);
Assert(pTableElement);
pTableElement->m_row = rows-1;
pTableElement->m_column = column;
s32 colSpan = pTableElement->GetRenderState().m_colSpan;
while(colSpan--)
{
pRowSpan[column] = rows + pTableElement->GetRenderState().m_rowSpan;
column++;
}
// pRowSpan[column] = rows + pTableElement->GetRenderState().m_rowSpan;
// column += pTableElement->GetRenderState().m_colSpan;
}
}
}
//
// name: GetTableWidthsAndHeights
// description: Get the column width and row heights for a table
void CHtmlDocument::GetTableWidthsAndHeights(CHtmlElementNode** pNodes, s32 num, CHtmlTableNode* pTableNode)
{
for(s32 i=0; i<num; i++)
{
CHtmlTableElementNode* pTableElement = dynamic_cast<CHtmlTableElementNode*>(pNodes[i]);
Assert(pTableElement);
if(pTableElement->GetElementId() == HTML_TABLEROW)
{
if(pTableElement->GetRenderState().m_height > 0.0f)
pTableNode->SetRowHeight(pTableElement->m_row, pNodes[i]->GetRenderState().m_height);
}
if(pTableElement->GetRenderState().m_display == HTML_TABLECELL)
{
s32 colspan = pTableElement->GetRenderState().m_colSpan;
float minWidth, maxWidth;
GetNodeMinMaxWidth(pTableElement, minWidth, maxWidth);
//GetForcedNodeDimensions(pNodes[i], childSize);
// can't force width for entries that span more than one column at the moment
if(colspan == 1)
{
pTableNode->SetColumnMinWidth(pTableElement->m_column,
Max<float>(minWidth, pTableNode->GetColumnMinWidth(pTableElement->m_column)));
pTableNode->SetColumnMaxWidth(pTableElement->m_column,
Max<float>(maxWidth, pTableNode->GetColumnMaxWidth(pTableElement->m_column)));
}
}
}
}
#endif
//
// name: CHtmlDocument::PostProcessTable
// description: Calculate table size and sizes that are forced
void CHtmlDocument::PostProcessTable(CHtmlElementNode* pElementNode)
{
CHtmlTableNode* pTable = dynamic_cast<CHtmlTableNode*>(pElementNode);
CHtmlElementNode* pNodes[TABLE_NODE_ARRAY_SIZE];
s32 numNodes=0;
Assert(pTable);
GetTableNodes(pTable, pNodes, numNodes);
CountTableRowsAndColumns(pNodes, numNodes, pTable);
// allocate arrays for row and column sizes
pTable->AllocateArrays();
// GetTableCellCoords(pNodes, numNodes, pTable);
// GetTableWidthsAndHeights(pNodes, numNodes, pTable);
}
void CHtmlDocument::SetTitle(GxtChar* pTitle)
{
s32 length = StringLength(pTitle);
// delete old string if it existed
if(m_pTitle)
delete[] m_pTitle;
// allocate space for new one and copy
m_pTitle = rage_new GxtChar[length + 1];
safecpy(m_pTitle.ptr, pTitle, length+1);
}
//
// name: CHtmlDocument::ProcessData
// description: Process data
void CHtmlDocument::ProcessData(CHtmlDataNode* pDataNode)
{
Assert(pDataNode->GetParent());
CHtmlElementNode* pParentNode = dynamic_cast<CHtmlElementNode*>(pDataNode->GetParent());
Assert(pParentNode);
switch(pParentNode->m_elementId)
{
case HTML_TITLE:
SetTitle(pDataNode->GetData());
break;
default:
break;
}
/* if(sm_inBody)
{
p
}*/
}
#ifndef HTML_RESOURCE
//
// name: CHtmlDocument::GetNodeMinMaxWidth/GetElementMinMaxWidth/GetDataMinMaxWidth
// description: Get minimum and maximum width of node for table dimension calculations
void CHtmlDocument::GetNodeMinMaxWidth(CHtmlNode* pNode, float& minWidth, float& maxWidth)
{
CHtmlElementNode* pElement = dynamic_cast<CHtmlElementNode*>(pNode);
CHtmlDataNode* pData = dynamic_cast<CHtmlDataNode*>(pNode);
minWidth = 0.0f;
maxWidth = 0.0f;
if(pNode->GetRenderState().m_forcedWidth > 0.0f)
{
minWidth = pElement->GetRenderState().m_forcedWidth;
maxWidth = pElement->GetRenderState().m_forcedWidth;
}
if(pElement)
{
float localMin = 0.0f;
float localMax = 0.0f;
if(GetElementMinMaxWidth(pElement, minWidth, maxWidth) == false)
{
// process children nodes
for(s32 i=0; i<pNode->GetNumChildren(); i++)
{
GetNodeMinMaxWidth(pNode->GetChild(i), localMin, localMax);
minWidth = rage::Max(localMin, minWidth);
maxWidth = rage::Max(localMax, maxWidth);
}
}
}
else if(pData)
GetDataMinMaxWidth(pData, minWidth, maxWidth);
}
bool CHtmlDocument::GetElementMinMaxWidth(CHtmlElementNode* pElement, float& minWidth, float& maxWidth)
{
if(pElement->GetElementId() == HTML_IMAGE)
{
minWidth = pElement->GetRenderState().m_width;
maxWidth = pElement->GetRenderState().m_width;
return true;
}
// don't parse into tables
else if(pElement->GetElementId() == HTML_TABLE)
{
CHtmlTableNode* pTable = dynamic_cast<CHtmlTableNode*>(pElement);
Assert(pTable);
minWidth = rage::Max(pTable->GetMinWidth(), minWidth);
maxWidth = rage::Max(pTable->GetMaxWidth(), maxWidth);
return true;
}
else if(pElement->GetElementId() == HTML_TEXT)
{
// get text
GxtChar* pString = TheText.Get(pElement->GetAttributeData());
pElement->GetRenderState().SetFontProperties();
#ifndef HTML_RESOURCE
minWidth = (float)CTextFormat::GetMaxWordLength(&sm_HtmlTextLayout, pString);
maxWidth = (float)(sm_HtmlTextLayout.GetStringWidthOnScreen(pString, true)*GetFormattedWidth()); // 1st screen done
#else
pString;
minWidth = maxWidth = 0.0f;
#endif
}
return false;
}
void CHtmlDocument::GetDataMinMaxWidth(CHtmlDataNode* pData, float& minWidth, float& maxWidth)
{
pData->GetRenderState().SetFontProperties();
#ifndef HTML_RESOURCE
minWidth = (float)CTextFormat::GetMaxWordLength(&sm_HtmlTextLayout, pData->GetData());
maxWidth = (float)(sm_HtmlTextLayout.GetStringWidthOnScreen(pData->GetData(), true)*GetFormattedWidth()); // 1st screen done
#else
minWidth = maxWidth = 0.0f;
#endif
}
//
// name: CHtmlDocument::GetForcedNodeDimensions
// description: Get dimensions of node if it is forced
void CHtmlDocument::GetForcedNodeDimensions(CHtmlNode* pNode, Vector2& size)
{
CHtmlElementNode* pElement = dynamic_cast<CHtmlElementNode*>(pNode);
size.x = -1.0f;
size.y = -1.0f;
// if this is an image node return width of the image
if(pElement)
{
HtmlRenderState& rs = pElement->GetRenderState();
if(pElement->GetElementId() == HTML_IMAGE)
{
size.x = rs.m_width;
size.y = rs.m_height;
return;
}
// don't parse into tables
if(pElement->GetElementId() == HTML_TABLE)
return;
}
// if this isn't an element node then return invalid width
else
{
return;
}
// process children nodes. If one returns an invalid width then return as we cannot force the width
// of this node
for(s32 i=0; i<pElement->GetNumChildren(); i++)
{
GetForcedNodeDimensions(pElement->GetChild(i), size);
if(size.x == -1.0f)
return;
}
}
//
// name: CHtmlDocument::GetMinimumNodeDimensions
// description: Get mnimum dimensions of node if it is forced
/*void CHtmlDocument::GetMinimumNodeDimensions(CHtmlNode* pNode, Vector2& size)
{
CHtmlElementNode* pElement = dynamic_cast<CHtmlElementNode*>(pNode);
// if this is an image node return width of the image
if(pElement)
{
HtmlRenderState& rs = pElement->GetRenderState();
if(rs.m_width > size.x)
size.x = rs.m_width;
if(rs.m_height > size.y)
size.y = rs.m_height;
// process children nodes. If one returns an invalid width then return as we cannot force the width
// of this node
for(s32 i=0; i<pElement->GetNumChildren(); i++)
{
GetMinimumNodeDimensions(pElement->GetChild(i), size);
}
}
}*/
//
// name: CHtmlDocument::GetFormattedDimensions
// description: Get dimensions document has been formatted to
void CHtmlDocument::GetFormattedDimensions(float& x, float& y)
{
x = m_pRootNode->GetRenderState().m_forcedWidth;
y = m_pRootNode->GetRenderState().m_forcedHeight;
}
//
// name: CHtmlDocument::GetFormattedWidth
// description: Get width document has been formatted to
float CHtmlDocument::GetFormattedWidth()
{
return m_pRootNode->GetRenderState().m_forcedWidth;
}
//
// name: CHtmlDocument::FormatDocument
// description: Setups renderstate and positional info for each node based on window size
void CHtmlDocument::FormatDocument(s32 width, s32 height)
{
Vector2 posn(0.0f, 0.0f);
Vector2 size(0.0f, 0.0f);
m_pRootNode->GetRenderState().m_forcedWidth = (float)width;
m_pRootNode->GetRenderState().m_forcedHeight = (float)height;
m_pRootNode->GetRenderState().m_currentX = 0.0f;
m_pRootNode->GetRenderState().m_currentY = 0.0f;
sm_inBody = false;
//GetNodeSize(m_pRootNode, size);
FormatNode(m_pRootNode, posn);
}
//
// name: CHtmlDocument::FormatNode
// description: Format positions of node
void CHtmlDocument::FormatNode(CHtmlNode* pNode, Vector2& posn)
{
Vector2 posn2 = posn;
//CHtmlNode* pParent = pNode->GetParent();
// If not the root node
//if(pParent)
{
CHtmlElementNode* pElement = dynamic_cast<CHtmlElementNode*>(pNode);
if(pNode->GetRenderState().m_display != HTML_INLINE)
FormatInlineObjectList(posn2);
if(pNode->GetNumChildren() > 0 || pNode->GetRenderState().m_display != HTML_INLINE)
{
posn = posn2;
if(pNode->GetRenderState().m_display == HTML_INLINE)
AddInlineObject(pNode);//sm_inlineObjs.PushAndGrow(pNode);
Assert(pElement);
FormatElement(pElement, posn2);
UpdatePosition(pNode, posn, posn2);
}
else
AddInlineObject(pNode);//sm_inlineObjs.PushAndGrow(pNode);
}
}
void CHtmlDocument::UpdatePosition(CHtmlNode* pNode, Vector2& posn, const Vector2& newPosn)
{
CHtmlNode* pParentNode = pNode->GetParent();
if(pParentNode == NULL)
return;
HtmlRenderState& rs = pNode->GetRenderState();
float x, y;
float width, height;
pParentNode->GetDimensions(x, y, width, height);
// If render state width is valid then use that as a delta on the position
// otherwise just use the returned position from FormatNode()
Vector2 delta;
if(rs.m_width != -1)
delta.x = (float)rs.m_width;
else
delta.x = newPosn.x - posn.x;
if(rs.m_height != -1)
delta.y = (float)rs.m_height;
else
delta.y = newPosn.y - posn.y;
/*if(rs.m_currentX + delta.x + rs.m_marginRight <= x + width && rs.m_display == HTML_INLINE)
posn.x = rs.m_currentX + delta.x;
else*/
{
posn.x = x;
posn.y = rs.m_currentY + delta.y;// + rs.m_marginBottom + rs.m_borderBottomWidth;
posn.y += rs.m_borderBottomWidth;
// if not last child add margin bottom
CHtmlNode* pLastChild = NULL;
if(pNode->GetParent())
{
pLastChild = pNode->GetParent()->GetChild(pNode->GetParent()->GetNumChildren()-1);
}
if(pLastChild != pNode)
posn.y += rs.m_marginBottom;
}
}
//
// name: CHtmlDocument::FormatElement
// description:
void CHtmlDocument::FormatElement(CHtmlElementNode* pElementNode, Vector2& posn)
{
HtmlRenderState& rs = pElementNode->GetRenderState();
float x, y, width, height;
rs.m_width = rs.m_forcedWidth;
rs.m_height = rs.m_forcedHeight;
pElementNode->GetDimensions(x,y,width,height);
// force width and height on all block display nodes
if(rs.m_display == HTML_BLOCK)
{
if(pElementNode->GetElementId() != HTML_TABLE)
{
if(rs.m_width < 0.0f)
rs.m_width = width;
}
// the first child of block nodes can't set left and top margins
if(pElementNode->GetParent() &&
pElementNode->GetParent()->GetRenderState().m_display != HTML_INLINE &&
pElementNode->GetParent()->GetChild(0) == pElementNode)
{
rs.m_marginLeft = 0.0f;
rs.m_marginTop = 0.0f;
}
}
// non-block nodes can't set the margins or have borders
else if(rs.m_display == HTML_INLINE)
{
rs.m_marginLeft = 0.0f;
rs.m_marginRight = 0.0f;
rs.m_paddingLeft = 0.0f;
rs.m_paddingRight = 0.0f;
rs.m_borderLeftStyle = HTML_NONE;
rs.m_borderRightStyle = HTML_NONE;
rs.m_borderTopStyle = HTML_NONE;
rs.m_borderBottomStyle = HTML_NONE;
}
// set border widths
if(rs.m_borderLeftStyle == HTML_NONE)
rs.m_borderLeftWidth = 0.0f;
if(rs.m_borderRightStyle == HTML_NONE)
rs.m_borderRightWidth = 0.0f;
if(rs.m_borderTopStyle == HTML_NONE)
rs.m_borderTopWidth = 0.0f;
if(rs.m_borderBottomStyle == HTML_NONE)
rs.m_borderBottomWidth = 0.0f;
// set border style
if(rs.m_borderLeftWidth == 0.0f)
rs.m_borderLeftStyle = HTML_NONE;
if(rs.m_borderRightWidth == 0.0f)
rs.m_borderRightStyle = HTML_NONE;
if(rs.m_borderTopWidth == 0.0f)
rs.m_borderTopStyle = HTML_NONE;
if(rs.m_borderBottomWidth == 0.0f)
rs.m_borderBottomStyle = HTML_NONE;
// Add margin to position. Padding doesn't affect position of this node only nodes that are
// children of this node
posn.x += rs.m_marginLeft + rs.m_borderLeftWidth;
posn.y += rs.m_marginTop + rs.m_borderTopWidth;
// margins affect width and height
if(rs.m_width > 0.0f)
{
rs.m_width -= rs.m_marginLeft + rs.m_marginRight + rs.m_borderLeftWidth + rs.m_borderRightWidth;
if(rs.m_width < 0.0f)
rs.m_width = 0.0f;
}
/* if(rs.m_height > 0.0f)
{
rs.m_height -= rs.m_marginTop + rs.m_marginBottom;
if(rs.m_height < 0.0f)
rs.m_height = 0.0f;
}*/
// set current position
rs.m_currentX = posn.x;
rs.m_currentY = posn.y;
switch(pElementNode->m_elementId)
{
case HTML_BODY:
sm_inBody = true;
break;
case HTML_TABLE:
FormatTable(pElementNode, posn);
AlignNode(pElementNode);
return;
default:
break;
}
posn.x += rs.m_paddingLeft;
posn.y += rs.m_paddingTop;
// process children nodes
for(s32 i=0; i<pElementNode->GetNumChildren(); i++)
{
FormatNode(pElementNode->GetChild(i), posn);
}
if(rs.m_display != HTML_INLINE)
FormatInlineObjectList(posn);
if(sm_inBody)
{
// Set block size
if(rs.m_display == HTML_BLOCK)
{
posn.y += rs.m_paddingBottom;
rs.m_height = posn.y - rs.m_currentY;
/* posn.y += rs.m_borderBottomWidth;
// if not last child
CHtmlNode* pLastChild = NULL;
if(pElementNode->GetParent())
{
pLastChild = pElementNode->GetParent()->GetChild(pElementNode->GetParent()->GetNumChildren()-1);
}
if(pLastChild != pElementNode)
posn.y += rs.m_marginBottom;*/
}
if(pElementNode->m_elementId == HTML_BODY)
{
// rs.m_height = height;
sm_inBody = false;
}
AlignNode(pElementNode);
}
}
//
// name: FilloutTableColumnWidths
// description: Fillout table element widths
void CHtmlDocument::FilloutTableColumnWidths(CHtmlElementNode** pNodes, s32 numNodes, CHtmlTableNode* pTableNode)
{
HtmlRenderState& trs = pTableNode->GetRenderState();
for(s32 i=0; i<numNodes; i++)
{
if(pNodes[i]->GetRenderState().m_display == HTML_TABLECELL)
{
CHtmlTableElementNode* pTableElement = dynamic_cast<CHtmlTableElementNode*>(pNodes[i]);
Assert(pTableElement);
HtmlRenderState& rs = pTableElement->GetRenderState();
// get column span
s32 colspan = pTableElement->GetRenderState().m_colSpan;
// add column widths onto table entry width
rs.m_forcedWidth = 0;
for(s32 j=0; j<colspan; j++)
rs.m_forcedWidth += pTableNode->GetColumnWidth(pTableElement->m_column+j) + trs.m_cellspacing;
// take off last spacing values
rs.m_forcedWidth -= trs.m_cellspacing;
}
}
}
//
// name: FormatTableEntries
// description: Calculate table entry positions and format their children
void CHtmlDocument::FormatTableEntries(CHtmlElementNode** pNodes, s32 numNodes, CHtmlTableNode* pTable)
{
HtmlRenderState& trs = pTable->GetRenderState();
//int rows = 0;
int columns = 0;
Vector2 tableRootPosn = Vector2(trs.m_currentX, trs.m_currentY);
Vector2 currRowPosn = tableRootPosn;
float maxHeight = tableRootPosn.y;
CHtmlTableElementNode* pTableElement = NULL;
currRowPosn.x += trs.m_cellspacing;
currRowPosn.y += trs.m_cellspacing;
for(s32 i=0; i<numNodes; i++)
{
pTableElement = dynamic_cast<CHtmlTableElementNode*>(pNodes[i]);
Assert(pTableElement);
if(pTableElement->GetElementId() == HTML_TABLEROW)
{
// store previous row height
if(pTableElement->m_row > 0)
{
maxHeight += trs.m_cellpadding;
pTable->SetCalculatedRowHeight(pTableElement->m_row-1, maxHeight - currRowPosn.y - trs.m_borderTopWidth - trs.m_borderBottomWidth);
}
// set current row position
currRowPosn.x = tableRootPosn.x + trs.m_cellspacing;
currRowPosn.y = maxHeight + trs.m_cellspacing;
// set new max height
// if row height is set then set max height
HtmlRenderState& rs = pTableElement->GetRenderState();
if(rs.m_height > 0.0f)
maxHeight = currRowPosn.y + rs.m_height;
columns = 0;
}
else if(pTableElement->GetRenderState().m_display == HTML_TABLECELL)
{
HtmlRenderState& rs = pTableElement->GetRenderState();
// get position of cell
for(s32 j=columns; j<pTableElement->m_column; j++)
currRowPosn.x += pTable->GetColumnWidth(j) + trs.m_cellspacing;
Vector2 posn(currRowPosn);
Vector2 posn2(currRowPosn);
rs.m_paddingLeft = trs.m_cellpadding;
rs.m_paddingRight = trs.m_cellpadding;
rs.m_paddingTop = trs.m_cellpadding;
rs.m_paddingBottom = trs.m_cellpadding;
// format table entry and its children
//FormatNode(pTableElement, posn);
FormatElement(pTableElement, posn2);
rs.m_cellHeight = posn2.y - currRowPosn.y;
rs.m_height = rage::Max(rs.m_cellHeight, rs.m_height);
UpdatePosition(pTableElement, posn, posn2);
//if(rs.m_height + currRowPosn.y + trs.m_borderTopWidth + trs.m_borderBottomWidth > posn.y)
// posn.y = rs.m_height + currRowPosn.y + trs.m_borderTopWidth + trs.m_borderBottomWidth;
// has it increased the height of this row?
if(rs.m_rowSpan < 2)
maxHeight = rage::Max(posn.y, maxHeight);
columns = pTableElement->m_column;
}
}
// store previous row height
maxHeight += trs.m_cellpadding;
if(pTableElement)
pTable->SetCalculatedRowHeight(pTableElement->m_row, maxHeight - currRowPosn.y - trs.m_borderTopWidth - trs.m_borderBottomWidth);
// set table height
float height = maxHeight - pTable->GetRenderState().m_currentY + trs.m_cellspacing;
float cellscaling = 1.0f;
// if calculated height is greater than current set height then set table height.
if(height >= pTable->GetRenderState().m_height)
pTable->GetRenderState().m_height = height;
// otherwise scale up all
else if(pTable->GetNumRows() > 0)
{
float forcedHeight = pTable->GetRenderState().m_height;
float currentHeight = 0.0f;
forcedHeight -= trs.m_cellspacing * (pTable->GetNumRows() + 1);
forcedHeight -= (trs.m_borderTopWidth + trs.m_borderBottomWidth) * (pTable->GetNumRows() + 1);
//forcedHeight -= trs.m_cellpadding * pTable->GetNumRows() * 2.0f;
for(s32 i=0; i<pTable->GetNumRows(); i++)
currentHeight += pTable->GetRowHeight(i);
cellscaling = forcedHeight / currentHeight;
Assert(cellscaling >= 1.0f);
}
Vector2 offset(0.0f, 0.0f);
float nextYOffset = 0.0f;
// set table cell positions based on new row heights
for(s32 i=0; i<numNodes; i++)
{
pTableElement = dynamic_cast<CHtmlTableElementNode*>(pNodes[i]);
HtmlRenderState& rs = pTableElement->GetRenderState();
if(pTableElement->GetElementId() == HTML_TABLEROW)
{
offset.y = nextYOffset;
// calculate how much we have to offset the table cells by
nextYOffset += pTable->GetRowHeight(pTableElement->m_row) * (cellscaling - 1.0f);
pTable->SetCalculatedRowHeight(pTableElement->m_row, pTable->GetRowHeight(pTableElement->m_row) * cellscaling);
}
else if(rs.m_display == HTML_TABLECELL)
{
// If cell is to be offset, offset the cell and then all its children
if(offset.y > 0.0f)
{
pTableElement->GetRenderState().m_currentY += offset.y;
for(s32 i=0; i<pTableElement->GetNumChildren(); i++)
OffsetPositions(pTableElement->GetChild(i), offset);
}
}
}
// set table entry heights, and vertically align contents
for(s32 i=0; i<numNodes; i++)
{
pTableElement = dynamic_cast<CHtmlTableElementNode*>(pNodes[i]);
HtmlRenderState& rs = pTableElement->GetRenderState();
if(rs.m_display == HTML_TABLECELL)
{
// vertical align
pTableElement->GetRenderState().m_height = 0.0f;
for(s32 j=0; j<rs.m_rowSpan; j++)
{
if(pTableElement->m_row+j < pTable->GetNumRows())
{
rs.m_height += (pTable->GetRowHeight(pTableElement->m_row+j));
rs.m_height += trs.m_cellspacing + trs.m_borderTopWidth + trs.m_borderBottomWidth;
}
}
rs.m_height -= trs.m_cellspacing + trs.m_borderTopWidth + trs.m_borderBottomWidth;
VerticalAlignNode(pTableElement);
}
}
}
void CHtmlDocument::FormatTable(CHtmlElementNode* pNode, Vector2& posn)
{
CHtmlTableNode* pTable = dynamic_cast<CHtmlTableNode*>(pNode);
CHtmlElementNode* pNodes[TABLE_NODE_ARRAY_SIZE];
s32 numNodes=0;
Assert(pTable);
// get list of table rows and entries
GetTableNodes(pTable, pNodes, numNodes);
// count table rows and columns and if they are different re-allocate arrays
CheckTableRowsAndColumns(pNodes, numNodes, pTable);
GetTableCellCoords(pNodes, numNodes, pTable);
GetTableWidthsAndHeights(pNodes, numNodes, pTable);
// calculate the size of the columns that don't have any size info
pTable->CalculateColumnWidths();
// fillout their width values
FilloutTableColumnWidths(pNodes, numNodes, pTable);
// format contents of the table entries and set table height
FormatTableEntries(pNodes, numNodes, pTable);
posn.y += pTable->GetRenderState().m_height;
}
//
// name: CHtmlDocument::AlignNode
// description: Align node according to alignment render state
void CHtmlDocument::AlignNode(CHtmlElementNode* pNode)
{
CHtmlNode* pBlockNode = pNode->GetNonInlineNode();
HtmlRenderState& rs = pNode->GetRenderState();
HtmlRenderState& brs = pBlockNode->GetRenderState();
Vector2 offset(0.0f, 0.0f);
// cannot align table entries or rows
if(pNode->GetRenderState().m_display == HTML_TABLECELL || pNode->GetRenderState().m_display == HTML_TABLESECTION)
return;
if(rs.m_display == HTML_BLOCK)
{
s32 textAlign = rs.m_textAlign;
if(textAlign == HTML_UNDEFINED)
textAlign = brs.m_textAlign;
// Assert(brs.m_width >= rs.m_width);
float diffWidth = brs.m_width - rs.m_width;
if(brs.m_width < rs.m_width)
diffWidth = 0.0f;
if(textAlign == HTML_ALIGN_RIGHT)
offset.x = diffWidth;
else if(textAlign == HTML_ALIGN_CENTER)
offset.x = diffWidth / 2.0f;
if(offset.x != 0.0f)
OffsetPositions(pNode, offset);
}
}
//
// name: CHtmlDocument::VerticalAlignNode
// description: Vertical align children nodes according to alignment render state and the height passed in
void CHtmlDocument::VerticalAlignNode(CHtmlElementNode* pNode)
{
HtmlRenderState& rs = pNode->GetRenderState();
Vector2 offset(0.0f, 0.0f);
// Assert(rs.m_cellHeight <= rs.m_height);
if(rs.m_cellHeight == 0.0f)
{
return;
}
float diffHeight = rage::Max(rs.m_height - rs.m_cellHeight, 0.0f);
if(rs.m_verticalAlign == HTML_ALIGN_BOTTOM)
offset.y = diffHeight;
else if(rs.m_verticalAlign == HTML_ALIGN_MIDDLE)
offset.y = diffHeight / 2.0f;
// offset children
if(offset.y != 0.0f)
{
for(s32 i=0; i<pNode->GetNumChildren(); i++)
OffsetPositions(pNode->GetChild(i), offset);
}
}
//
// name: CHtmlDocument::FormatData
// description:
void CHtmlDocument::FormatData(CHtmlDataNode* pDataNode, Vector2& posn)
{
HtmlRenderState& rs = pDataNode->GetRenderState();
// set current position
rs.m_currentX = posn.x;
rs.m_currentY = posn.y;
Vector2 vPos;
float width, height;
float formattedWidth, formattedHeight;
pDataNode->GetDimensions(vPos.x,vPos.y,width,height);
GetFormattedDimensions(formattedWidth, formattedHeight);
rs.SetFontProperties();
vPos.x = rs.m_currentX;
vPos.y = rs.m_currentY;
#ifndef HTML_RESOURCE
sm_HtmlTextLayout.SetWrap(Vector2(vPos.x/formattedWidth, (vPos.x+width)/formattedWidth));
#endif
if(rs.m_textAlign == HTML_ALIGN_RIGHT)
vPos.x += width;
else if(rs.m_textAlign == HTML_ALIGN_CENTER)
vPos.x += width / 2.0f;
// temporary stuff to get size of lines
#ifndef HTML_RESOURCE
s32 lines = sm_HtmlTextLayout.GetNumberOfLines(&vPos, pDataNode->GetData());
posn.y += lines * ((CTextFormat::GetLineHeight(sm_HtmlTextLayout)*formattedHeight));
#endif
}
//
// name: CHtmlDocument::FormatInlineObjectList
// description: Format the list of data objec
void CHtmlDocument::FormatInlineObjectList(Vector2& posn)
{
Vector2 posn2 = posn;
if(sm_inBody)
{
float formattedWidth, formattedHeight;
GetFormattedDimensions(formattedWidth, formattedHeight);
if(GetInlineObjectCount() > 0)
{
float x,y;
float width, height;
CHtmlNode* pNonInlineNode = GetInlineObject(0)->GetNonInlineNode();//sm_inlineObjs[0]->GetNonInlineNode();
CHtmlNode* pLastLinkNode = NULL;
// get dimensions from first objects parent
pNonInlineNode->GetDimensions(x,y,width,height);
CHtmlTextFormat fn(x, posn.y, width, pNonInlineNode->GetRenderState().m_textAlign, formattedWidth, formattedHeight);
for(s32 i=0; i<GetInlineObjectCount(); i++)
{
CHtmlNode* pNode = GetInlineObject(i);
CHtmlElementNode* pElement = dynamic_cast<CHtmlElementNode*>(pNode);
CHtmlDataNode* pData = dynamic_cast<CHtmlDataNode*>(pNode);
if(pData)
{
HtmlRenderState& rs = pData->GetRenderState();
rs.SetFontProperties();
fn.SetHtmlNode(pNode);
#ifndef HTML_RESOURCE
sm_HtmlTextLayout.SetWrap(Vector2(x/formattedWidth, (x+width)/formattedWidth)); // 1st screen done maybe
sm_HtmlTextLayout.SetOrientation(FONT_LEFT);
CTextFormat::ProcessCurrentString(&sm_HtmlTextLayout, (posn.x + fn.GetCurrentX())/formattedWidth, posn.y/formattedHeight, pData->GetData(), fn);
#endif
}
else if(pElement)
{
// only know how to format images, flash movies
if(pElement->GetElementId() == HTML_IMAGE ||
pElement->GetElementId() == HTML_EMBED)
{
fn.SetHtmlNode(pNode);
fn.AddNonTextBlock(pElement->GetRenderState().m_width, pElement->GetRenderState().m_height);
}
else if(pElement->GetElementId() == HTML_TEXT)
{
HtmlRenderState& rs = pElement->GetRenderState();
rs.SetFontProperties();
fn.SetHtmlNode(pNode);
#ifndef HTML_RESOURCE
sm_HtmlTextLayout.SetWrap(Vector2(x/formattedWidth, (x+width)/formattedWidth));
sm_HtmlTextLayout.SetOrientation(FONT_LEFT);
CTextFormat::ProcessCurrentString(&sm_HtmlTextLayout, (posn.x + fn.GetCurrentX())/formattedWidth, posn.y/formattedHeight, TheText.Get(pElement->GetAttributeData()), fn);
#endif
}
else if(pElement->GetElementId() == HTML_BREAK)
{
pElement->GetRenderState().SetFontProperties();
fn.SetHtmlNode(pNode);
#ifndef HTML_RESOURCE
fn.AddNonTextBlock(1, (CTextFormat::GetLineHeight(sm_HtmlTextLayout)*formattedHeight));
#endif
fn.NewLine();
}
else
{
pElement->GetRenderState().m_currentX = posn.x + fn.GetCurrentX();
pElement->GetRenderState().m_currentY = posn.y + fn.GetCurrentY();
}
}
// If we are working out the size of a link and the current node's parent was this link then calculate size of link
if(pLastLinkNode && pNode->GetParent() == pLastLinkNode)
{
if(fn.GetCurrentY() != pLastLinkNode->GetRenderState().m_currentY - posn.y)
{
pLastLinkNode->GetRenderState().m_width = fn.GetCurrentX();
pLastLinkNode->GetRenderState().m_height = posn.y + fn.GetCurrentY() + fn.GetCurrentLineHeight() - pLastLinkNode->GetRenderState().m_currentY;
}
else
{
pLastLinkNode->GetRenderState().m_width = posn.x + fn.GetCurrentX() - pLastLinkNode->GetRenderState().m_currentX;
pLastLinkNode->GetRenderState().m_height = fn.GetCurrentLineHeight();
}
}
else
pLastLinkNode = NULL;
// Have to do this after getting size of link from child
if(pElement && pElement->GetElementId() == HTML_A)
pLastLinkNode = pElement;
}
fn.NewLine();
posn.y += fn.GetCurrentY();
// work out link positions
for(s32 i=0; i<GetInlineObjectCount(); i++)
{
CHtmlNode* pNode = GetInlineObject(i);
CHtmlElementNode* pElement = dynamic_cast<CHtmlElementNode*>(pNode);
// Position of link is defined by the position of the first entry
if(pLastLinkNode && pNode->GetParent() == pLastLinkNode)
{
pLastLinkNode->GetRenderState().m_currentX = pNode->GetRenderState().m_currentX;
pLastLinkNode->GetRenderState().m_currentY = pNode->GetRenderState().m_currentY;
}
pLastLinkNode = NULL;
// Have to do this after getting size of link from child
if(pElement && pElement->GetElementId() == HTML_A)
pLastLinkNode = pElement;
}
}
}
ResetInlineObjectList();//sm_inlineObjs.Reset();
}
#endif //HTML_FORMAT
//
// name: OffsetPositions
// description: Offset the position of children nodes
void CHtmlDocument::OffsetPositions(CHtmlNode* pNode, const Vector2& posn)
{
pNode->GetRenderState().m_currentX += posn.x;
pNode->GetRenderState().m_currentY += posn.y;
for(s32 i=0; i<pNode->GetNumChildren(); i++)
{
CHtmlNode* pChild = pNode->GetChild(i);
OffsetPositions(pChild, posn);
}
}
//
// name: CHtmlDocument::GetLinkPosition
// description: Return position of link
void CHtmlDocument::GetLinkPosition(s32 link, float& x, float& y)
{
x = m_links[link]->GetRenderState().m_currentX;
y= m_links[link]->GetRenderState().m_currentY;
}
//
// name: CHtmlDocument::LoadTextureInternal
// description: Load a texture and add it to the texture dictionary
grcTexture* CHtmlDocument::LoadTextureInternal(const char* pName)
{
grcTexture* pImage;
// If we have a current txd then check inside that for the texture
if(pgDictionary<grcTexture>::GetCurrent())
{
pImage = pgDictionary<grcTexture>::GetCurrent()->Lookup(pName);
if(pImage)
return pImage;
}
// If texture dictionary isn't constructed build it and reserve 256 slots
if(m_pTxd == NULL)
m_pTxd = rage_new pgDictionary<grcTexture>(256);
// Is image already in texture dictionary
pImage = m_pTxd->Lookup(pName);
if(pImage)
return pImage;
char filename[RAGE_MAX_PATH];
ASSET.RemoveExtensionFromPath(filename, RAGE_MAX_PATH, pName);
pImage = grcTextureFactory::GetInstance().Create(filename);
if(pImage)
{
// Add entry to texture dictionary
m_pTxd->AddEntry(pName, pImage);
}
else
{
Errorf("Cannot load image %s", pName);
}
return pImage;
}
#if __DEV
void CHtmlDocument::DebugPrint()
{
Printf("Title: %s\n", (const char*)(GxtChar*)m_pTitle);
m_pRootNode->DebugPrint();
}
#endif
Reference in New Issue View Git Blame Copy Permalink