bool AccessibilityTable::isDataTable() const
{
if (!m_renderer)
return false;
// Do not consider it a data table is it has an ARIA role.
if (hasARIARole())
return false;
// When a section of the document is contentEditable, all tables should be
// treated as data tables, otherwise users may not be able to work with rich
// text editors that allow creating and editing tables.
if (node() && node()->hasEditableStyle())
return true;
if (!m_renderer->isTable())
return false;
// This employs a heuristic to determine if this table should appear.
// Only "data" tables should be exposed as tables.
// Unfortunately, there is no good way to determine the difference
// between a "layout" table and a "data" table.
RenderTable* table = toRenderTable(m_renderer);
HTMLTableElement* tableElement = this->tableElement();
if (tableElement) {
// If there is a caption element, summary, THEAD, or TFOOT section, it's most certainly a data table.
if (!tableElement->summary().isEmpty() || tableElement->tHead() || tableElement->tFoot() || tableElement->caption())
return true;
// If someone used "rules" attribute than the table should appear.
if (!tableElement->rules().isEmpty())
return true;
// If there's a colgroup or col element, it's probably a data table.
for (const auto& child : childrenOfType<Element>(*tableElement)) {
if (child.hasTagName(colTag) || child.hasTagName(colgroupTag))
return true;
}
}
// go through the cell's and check for tell-tale signs of "data" table status
// cells have borders, or use attributes like headers, abbr, scope or axis
table->recalcSectionsIfNeeded();
RenderTableSection* firstBody = table->firstBody();
if (!firstBody)
return false;
int numCols = firstBody->numColumns();
int numRows = firstBody->numRows();
// If there's only one cell, it's not a good AXTable candidate.
if (numRows == 1 && numCols == 1)
return false;
// If there are at least 20 rows, we'll call it a data table.
if (numRows >= 20)
return true;
// Store the background color of the table to check against cell's background colors.
const RenderStyle& tableStyle = table->style();
Color tableBGColor = tableStyle.visitedDependentColor(CSSPropertyBackgroundColor);
// check enough of the cells to find if the table matches our criteria
// Criteria:
// 1) must have at least one valid cell (and)
// 2) at least half of cells have borders (or)
// 3) at least half of cells have different bg colors than the table, and there is cell spacing
unsigned validCellCount = 0;
unsigned borderedCellCount = 0;
unsigned backgroundDifferenceCellCount = 0;
unsigned cellsWithTopBorder = 0;
unsigned cellsWithBottomBorder = 0;
unsigned cellsWithLeftBorder = 0;
unsigned cellsWithRightBorder = 0;
Color alternatingRowColors[5];
int alternatingRowColorCount = 0;
int headersInFirstColumnCount = 0;
for (int row = 0; row < numRows; ++row) {
int headersInFirstRowCount = 0;
for (int col = 0; col < numCols; ++col) {
RenderTableCell* cell = firstBody->primaryCellAt(row, col);
if (!cell)
continue;
Element* cellElement = cell->element();
if (!cellElement)
continue;
if (cell->width() < 1 || cell->height() < 1)
continue;
validCellCount++;
bool isTHCell = cellElement->hasTagName(thTag);
// If the first row is comprised of all <th> tags, assume it is a data table.
if (!row && isTHCell)
headersInFirstRowCount++;
// If the first column is comprised of all <th> tags, assume it is a data table.
if (!col && isTHCell)
headersInFirstColumnCount++;
// In this case, the developer explicitly assigned a "data" table attribute.
if (is<HTMLTableCellElement>(cellElement)) {
HTMLTableCellElement& tableCellElement = downcast<HTMLTableCellElement>(*cellElement);
if (!tableCellElement.headers().isEmpty() || !tableCellElement.abbr().isEmpty()
|| !tableCellElement.axis().isEmpty() || !tableCellElement.scope().isEmpty())
return true;
}
const RenderStyle& renderStyle = cell->style();
// If the empty-cells style is set, we'll call it a data table.
if (renderStyle.emptyCells() == HIDE)
return true;
// If a cell has matching bordered sides, call it a (fully) bordered cell.
if ((cell->borderTop() > 0 && cell->borderBottom() > 0)
|| (cell->borderLeft() > 0 && cell->borderRight() > 0))
borderedCellCount++;
// Also keep track of each individual border, so we can catch tables where most
// cells have a bottom border, for example.
if (cell->borderTop() > 0)
cellsWithTopBorder++;
if (cell->borderBottom() > 0)
cellsWithBottomBorder++;
if (cell->borderLeft() > 0)
cellsWithLeftBorder++;
if (cell->borderRight() > 0)
cellsWithRightBorder++;
// If the cell has a different color from the table and there is cell spacing,
// then it is probably a data table cell (spacing and colors take the place of borders).
Color cellColor = renderStyle.visitedDependentColor(CSSPropertyBackgroundColor);
if (table->hBorderSpacing() > 0 && table->vBorderSpacing() > 0
&& tableBGColor != cellColor && cellColor.alpha() != 1)
backgroundDifferenceCellCount++;
// If we've found 10 "good" cells, we don't need to keep searching.
if (borderedCellCount >= 10 || backgroundDifferenceCellCount >= 10)
return true;
// For the first 5 rows, cache the background color so we can check if this table has zebra-striped rows.
if (row < 5 && row == alternatingRowColorCount) {
RenderObject* renderRow = cell->parent();
if (!renderRow || !renderRow->isBoxModelObject() || !toRenderBoxModelObject(renderRow)->isTableRow())
continue;
const RenderStyle& rowRenderStyle = renderRow->style();
Color rowColor = rowRenderStyle.visitedDependentColor(CSSPropertyBackgroundColor);
alternatingRowColors[alternatingRowColorCount] = rowColor;
alternatingRowColorCount++;
}
}
if (!row && headersInFirstRowCount == numCols && numCols > 1)
return true;
}
if (headersInFirstColumnCount == numRows && numRows > 1)
return true;
// if there is less than two valid cells, it's not a data table
if (validCellCount <= 1)
return false;
// half of the cells had borders, it's a data table
unsigned neededCellCount = validCellCount / 2;
if (borderedCellCount >= neededCellCount
|| cellsWithTopBorder >= neededCellCount
|| cellsWithBottomBorder >= neededCellCount
|| cellsWithLeftBorder >= neededCellCount
|| cellsWithRightBorder >= neededCellCount)
return true;
// half had different background colors, it's a data table
if (backgroundDifferenceCellCount >= neededCellCount)
return true;
// Check if there is an alternating row background color indicating a zebra striped style pattern.
if (alternatingRowColorCount > 2) {
Color firstColor = alternatingRowColors[0];
for (int k = 1; k < alternatingRowColorCount; k++) {
// If an odd row was the same color as the first row, its not alternating.
if (k % 2 == 1 && alternatingRowColors[k] == firstColor)
return false;
// If an even row is not the same as the first row, its not alternating.
if (!(k % 2) && alternatingRowColors[k] != firstColor)
return false;
}
return true;
}
return false;
}
bool DragController::concludeEditDrag(DragData* dragData)
{
ASSERT(dragData);
ASSERT(!m_isHandlingDrag);
if (!m_document)
return false;
IntPoint point = m_document->view()->windowToContents(dragData->clientPosition());
Element* element = m_document->elementFromPoint(point.x(), point.y());
ASSERT(element);
Frame* innerFrame = element->ownerDocument()->frame();
ASSERT(innerFrame);
if (dragData->containsColor()) {
Color color = dragData->asColor();
if (!color.isValid())
return false;
if (!innerFrame)
return false;
RefPtr<Range> innerRange = innerFrame->selection()->toNormalizedRange();
RefPtr<CSSStyleDeclaration> style = m_document->createCSSStyleDeclaration();
ExceptionCode ec;
style->setProperty("color", color.name(), ec);
if (!innerFrame->editor()->shouldApplyStyle(style.get(), innerRange.get()))
return false;
m_client->willPerformDragDestinationAction(DragDestinationActionEdit, dragData);
innerFrame->editor()->applyStyle(style.get(), EditActionSetColor);
return true;
}
if (!m_page->dragController()->canProcessDrag(dragData)) {
m_page->dragCaretController()->clear();
return false;
}
if (HTMLInputElement* fileInput = asFileInput(element)) {
if (!fileInput->isEnabled())
return false;
if (!dragData->containsFiles())
return false;
Vector<String> filenames;
dragData->asFilenames(filenames);
if (filenames.isEmpty())
return false;
// Ugly. For security none of the API's available to us to set the input value
// on file inputs. Even forcing a change in HTMLInputElement doesn't work as
// RenderFileUploadControl clears the file when doing updateFromElement()
RenderFileUploadControl* renderer = static_cast<RenderFileUploadControl*>(fileInput->renderer());
if (!renderer)
return false;
renderer->receiveDroppedFiles(filenames);
return true;
}
Selection dragCaret(m_page->dragCaretController()->selection());
m_page->dragCaretController()->clear();
RefPtr<Range> range = dragCaret.toNormalizedRange();
// For range to be null a WebKit client must have done something bad while
// manually controlling drag behaviour
if (!range)
return false;
DocLoader* loader = range->ownerDocument()->docLoader();
loader->setAllowStaleResources(true);
if (dragIsMove(innerFrame->selection()) || dragCaret.isContentRichlyEditable()) {
bool chosePlainText = false;
RefPtr<DocumentFragment> fragment = documentFragmentFromDragData(dragData, range, true, chosePlainText);
if (!fragment || !innerFrame->editor()->shouldInsertFragment(fragment, range, EditorInsertActionDropped)) {
loader->setAllowStaleResources(false);
return false;
}
m_client->willPerformDragDestinationAction(DragDestinationActionEdit, dragData);
if (dragIsMove(innerFrame->selection())) {
bool smartMove = innerFrame->selectionGranularity() == WordGranularity
&& innerFrame->editor()->smartInsertDeleteEnabled()
&& dragData->canSmartReplace();
applyCommand(MoveSelectionCommand::create(fragment, dragCaret.base(), smartMove));
} else {
if (setSelectionToDragCaret(innerFrame, dragCaret, range, point))
applyCommand(ReplaceSelectionCommand::create(m_document, fragment, true, dragData->canSmartReplace(), chosePlainText));
}
} else {
String text = dragData->asPlainText();
if (text.isEmpty() || !innerFrame->editor()->shouldInsertText(text, range.get(), EditorInsertActionDropped)) {
loader->setAllowStaleResources(false);
return false;
}
m_client->willPerformDragDestinationAction(DragDestinationActionEdit, dragData);
if (setSelectionToDragCaret(innerFrame, dragCaret, range, point))
applyCommand(ReplaceSelectionCommand::create(m_document, createFragmentFromText(range.get(), text), true, false, true));
}
loader->setAllowStaleResources(false);
return true;
}
Color Color::contrasted() const {
Color c = *this;
c.contrast();
return c;
}
float LightEntity::computeClosestPower(
const Color &target,
const Color &source) {
//minimize sqrt((source.r*power - target.r)^2 + (source.g*power - target.g) + (source.b*power - target.b));
return source.dot(target) / source.lengthSquared();
}
void showInfo(HWND hDlg, PLUGIN_DATA *data, int selected)
{
int size = 128;
// Load the background image
CGdiPlusBitmapResource* image = new CGdiPlusBitmapResource();
image->Load(IDB_BACKGROUND, _T("PNG"), dllInstance);
if (image->m_pBitmap != NULL) {
// Get the background color
Color* background = new Color();
background->SetFromCOLORREF(GetSysColor(COLOR_BTNFACE));
// Create the bitmap
Bitmap bitmap(size+64,size+64);
Graphics bitmapGraphics(&bitmap);
SolidBrush solidBrush(*background);
bitmapGraphics.FillRectangle(&solidBrush, 0, 0, image->m_pBitmap->GetHeight()+64, image->m_pBitmap->GetWidth()+64);
// Apply color transformation and draw the icon
RectF rect(0.0f, 0.0f, (REAL)size+64, (REAL)size+64);
ImageAttributes attributes;
ColorMatrix colorMatrix = {
0.45f, 0.33f, 0.33f, 0.0f, 0.0f,
0.33f, 0.33f, 0.33f, 0.0f, 0.0f,
0.33f, 0.33f, 0.33f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.1f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
attributes.SetColorMatrix(&colorMatrix, ColorMatrixFlagsDefault, ColorAdjustTypeDefault);
bitmapGraphics.DrawImage(image->m_pBitmap, rect, 0, 0, (REAL)image->m_pBitmap->GetHeight(), (REAL)image->m_pBitmap->GetWidth(), UnitPixel, &attributes, NULL, NULL);
// Init Brushes & Font
SolidBrush blackBrush(Color(255, 0, 0, 0));
SolidBrush whiteBrush(Color(128, 160, 160, 160));
FontFamily fontFamily(L"Arial");
Font font(&fontFamily, 13, FontStyleBold, UnitPixel);
// Draw the name, author, version and notes
Docklet::DOCKLET_INFO info = Docklet::GetInformationFromDll((char*)data->docklets[selected].path);
USES_CONVERSION;
wchar_t name[200];
wcscpy_s(name, L"");
wcscat_s(name, CA2W(info.name));
wchar_t notes[500];
wcscpy_s(notes, L"");
wcscat_s(notes, CA2W(info.notes));
wchar_t author[200];
wcscpy_s(author, L"By ");
wcscat_s(author, CA2W(info.author));
int major = info.version/100;
int minor = info.version - 100*major;
wchar_t version[40];
wcscpy_s(version, L"");
if (minor > 9)
swprintf_s(version, L"Version %d.%d", major, minor);
else
swprintf_s(version, L"Version %d.0%d", major, minor);
////////////////////////////////////////////////////////////////////////////
bitmapGraphics.DrawString((WCHAR *)&name, -1, &font, PointF(1.0f, 1.0f), &whiteBrush);
bitmapGraphics.DrawString((WCHAR *)&name, -1, &font, PointF(0.0f, 0.0f), &blackBrush);
bitmapGraphics.DrawString((WCHAR *)&author, -1, &font, PointF(1.0f, 21.0f), &whiteBrush);
bitmapGraphics.DrawString((WCHAR *)&author, -1, &font, PointF(0.0f, 20.0f), &blackBrush);
bitmapGraphics.DrawString((WCHAR *)&version, -1, &font, PointF(1.0f, 41.0f), &whiteBrush);
bitmapGraphics.DrawString((WCHAR *)&version, -1, &font, PointF(0.0f, 40.0f), &blackBrush);
RectF rect1(1.0f, 101.0f, 200.0f, 200.0f);
RectF rect2(0.0f, 100.0f, 200.0f, 200.0f);
bitmapGraphics.DrawString((WCHAR *)¬es, -1, &font, rect1, StringFormat::GenericDefault(), &whiteBrush);
bitmapGraphics.DrawString((WCHAR *)¬es, -1, &font, rect2, StringFormat::GenericDefault(), &blackBrush);
////////////////////////////////////////////////////////////////////////////
HBITMAP hBitmap;
bitmap.GetHBITMAP(*background, &hBitmap);
// Display the image
SendDlgItemMessage(hDlg, IDC_ICON_PIC, STM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM) hBitmap);
delete(background);
}
delete(image);
}
void JSONValue::AddColor(const Color& value)
{
AddString(value.ToString());
}
void SubThreadStage()
{
ResIdentifierPtr psmm_input = ResLoader::Instance().Open(ps_desc_.res_name);
KlayGE::XMLDocument doc;
XMLNodePtr root = doc.Parse(psmm_input);
{
XMLNodePtr particle_node = root->FirstNode("particle");
{
XMLNodePtr alpha_node = particle_node->FirstNode("alpha");
ps_desc_.ps_data->particle_alpha_from_tex = alpha_node->Attrib("from")->ValueString();
ps_desc_.ps_data->particle_alpha_to_tex = alpha_node->Attrib("to")->ValueString();
}
{
XMLNodePtr color_node = particle_node->FirstNode("color");
{
Color from;
XMLAttributePtr attr = color_node->Attrib("from");
if (attr)
{
std::vector<std::string> strs;
boost::algorithm::split(strs, attr->ValueString(), boost::is_any_of(" "));
for (size_t i = 0; i < 3; ++ i)
{
if (i < strs.size())
{
boost::algorithm::trim(strs[i]);
from[i] = static_cast<float>(atof(strs[i].c_str()));
}
else
{
from[i] = 0;
}
}
}
from.a() = 1;
ps_desc_.ps_data->particle_color_from = from;
Color to;
attr = color_node->Attrib("to");
if (attr)
{
std::vector<std::string> strs;
boost::algorithm::split(strs, attr->ValueString(), boost::is_any_of(" "));
for (size_t i = 0; i < 3; ++ i)
{
if (i < strs.size())
{
boost::algorithm::trim(strs[i]);
to[i] = static_cast<float>(atof(strs[i].c_str()));
}
else
{
to[i] = 0;
}
}
}
to.a() = 1;
ps_desc_.ps_data->particle_color_to = to;
}
}
}
{
XMLNodePtr emitter_node = root->FirstNode("emitter");
XMLAttributePtr type_attr = emitter_node->Attrib("type");
if (type_attr)
{
ps_desc_.ps_data->emitter_type = type_attr->ValueString();
}
else
{
ps_desc_.ps_data->emitter_type = "point";
}
XMLNodePtr freq_node = emitter_node->FirstNode("frequency");
if (freq_node)
{
XMLAttributePtr attr = freq_node->Attrib("value");
ps_desc_.ps_data->frequency = attr->ValueFloat();
}
XMLNodePtr angle_node = emitter_node->FirstNode("angle");
if (angle_node)
{
XMLAttributePtr attr = angle_node->Attrib("value");
ps_desc_.ps_data->angle = attr->ValueInt() * DEG2RAD;
}
XMLNodePtr pos_node = emitter_node->FirstNode("pos");
if (pos_node)
{
float3 min_pos(0, 0, 0);
XMLAttributePtr attr = pos_node->Attrib("min");
if (attr)
{
std::vector<std::string> strs;
boost::algorithm::split(strs, attr->ValueString(), boost::is_any_of(" "));
for (size_t i = 0; i < 3; ++ i)
{
if (i < strs.size())
{
boost::algorithm::trim(strs[i]);
min_pos[i] = static_cast<float>(atof(strs[i].c_str()));
}
else
{
min_pos[i] = 0;
}
}
}
ps_desc_.ps_data->min_pos = min_pos;
float3 max_pos(0, 0, 0);
attr = pos_node->Attrib("max");
if (attr)
{
std::vector<std::string> strs;
boost::algorithm::split(strs, attr->ValueString(), boost::is_any_of(" "));
for (size_t i = 0; i < 3; ++ i)
{
if (i < strs.size())
{
boost::algorithm::trim(strs[i]);
max_pos[i] = static_cast<float>(atof(strs[i].c_str()));
}
else
{
max_pos[i] = 0;
}
}
}
ps_desc_.ps_data->max_pos = max_pos;
}
XMLNodePtr vel_node = emitter_node->FirstNode("vel");
if (vel_node)
{
XMLAttributePtr attr = vel_node->Attrib("min");
ps_desc_.ps_data->min_vel = attr->ValueFloat();
attr = vel_node->Attrib("max");
ps_desc_.ps_data->max_vel = attr->ValueFloat();
}
XMLNodePtr life_node = emitter_node->FirstNode("life");
if (life_node)
{
XMLAttributePtr attr = life_node->Attrib("min");
ps_desc_.ps_data->min_life = attr->ValueFloat();
attr = life_node->Attrib("max");
ps_desc_.ps_data->max_life = attr->ValueFloat();
}
}
{
XMLNodePtr updater_node = root->FirstNode("updater");
XMLAttributePtr type_attr = updater_node->Attrib("type");
if (type_attr)
{
ps_desc_.ps_data->updater_type = type_attr->ValueString();
}
else
{
ps_desc_.ps_data->updater_type = "polyline";
}
if ("polyline" == ps_desc_.ps_data->updater_type)
{
for (XMLNodePtr node = updater_node->FirstNode("curve"); node; node = node->NextSibling("curve"))
{
std::vector<float2> xys;
for (XMLNodePtr ctrl_point_node = node->FirstNode("ctrl_point"); ctrl_point_node; ctrl_point_node = ctrl_point_node->NextSibling("ctrl_point"))
{
XMLAttributePtr attr_x = ctrl_point_node->Attrib("x");
XMLAttributePtr attr_y = ctrl_point_node->Attrib("y");
xys.push_back(float2(attr_x->ValueFloat(), attr_y->ValueFloat()));
}
XMLAttributePtr attr = node->Attrib("name");
size_t const name_hash = RT_HASH(attr->ValueString().c_str());
if (CT_HASH("size_over_life") == name_hash)
{
ps_desc_.ps_data->size_over_life_ctrl_pts = xys;
}
else if (CT_HASH("mass_over_life") == name_hash)
{
ps_desc_.ps_data->mass_over_life_ctrl_pts = xys;
}
else if (CT_HASH("opacity_over_life") == name_hash)
{
ps_desc_.ps_data->opacity_over_life_ctrl_pts = xys;
}
}
}
}
RenderFactory& rf = Context::Instance().RenderFactoryInstance();
RenderDeviceCaps const & caps = rf.RenderEngineInstance().DeviceCaps();
if (caps.multithread_res_creating_support)
{
this->MainThreadStage();
}
}
int main()
{
Vector2<int> vec2(12,25);
Vector2<int> vec3(13,24);
Vector2<int> storage;
std::cout << "Vector2: \n\n";
storage = vec3 + vec2;
std::cout << "Add:" << "(" << storage.x << "," << storage.y << ")" << std::endl;
storage = vec3 - vec2;
std::cout << "Subtract:" << "(" << storage.x << "," << storage.y << ")" << std::endl;
storage = vec3 / vec2;
std::cout << "Divide:" << "(" << storage.x << "," << storage.y << ")" << std::endl;
storage = vec3 * vec2;
std::cout << "Multiply:" << "(" << storage.x << "," << storage.y << ")" << std::endl;
storage = vec3 % vec2;
std::cout << "Modulus:" << "(" << storage.x << "," << storage.y << "," << ")" << std::endl;
int sto = storage.Dot(vec2, vec3);
std::cout << "Dot product: " << sto << std::endl;
int mg = storage.Mag(vec2);
std::cout << "Magnitude: " << mg << std::endl;
Vector2<int> norm = storage.Normalise(vec2);
std::cout << "Normalize:" << "(" << norm.x << "," << norm.y << "," << ")\n\n" << std::endl;
Vector3<int> vec1(12, 12, 12);
Vector3<int> vec4(12, 12, 12);
Vector3<int> storage2;
std::cout << "Vector3: \n\n";
storage2 = vec1 + vec4;
std::cout << "Add:" << "(" << storage2.x << "," << storage2.y << "," << storage2.z << ")" << std::endl;
storage2 = vec1 - vec4;
std::cout << "Subtract:" << "(" << storage2.x << "," << storage2.y << "," << storage2.z << ")" << std::endl;
storage2 = vec1 / vec4;
std::cout << "Divide:" << "(" << storage2.x << "," << storage2.y << "," << storage2.z << ")" << std::endl;
storage2 = vec1 * vec4;
std::cout << "Multiply:" << "(" << storage2.x << "," << storage2.y << "," << storage2.z << ")" << std::endl;
storage2 = vec1 % vec4;
std::cout << "Modulus:" << "(" << storage2.x << "," << storage2.y << "," << storage2.z << ")" << std::endl;
int Dot = storage2.Dot(vec1, vec4);
std::cout << "Dot Product is: " << Dot << std::endl;
Vector3<int> cross = storage2.Cross(vec1, vec4);
std::cout << "Cross Product is: " << cross.x << "," << cross.y << cross.z << std::endl;
int Mag = storage2.Mag(vec1);
std::cout << "Magnitude Product is: " << Mag << std::endl;
Vector3<int> Norm = storage2.Normalise(vec1);
std::cout << "Normalised:" << "(" << Norm.x << "," << Norm.y << "," << Norm.z << ")\n" << std::endl;
std::cout << "Color: \n\n";
Color<int> color;
Color<int> boo1(12, 12, 12, 12);
Color<int> boo2(13, 13, 13, 13);
Color<int> test;
test = boo1 + boo2;
std::cout << "Add:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl;
test = boo1 - boo2;
std::cout << "Subtract:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl;
test = boo1 * boo2;
std::cout << "Multiply:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl;
test = boo1 / boo2;
std::cout << "Quotient:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl;
test = boo1 % boo2;
std::cout << "Modulus:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl;
test = test.Normalise(boo1);
std::cout << "Normalize:" << "(" << test.r << "," << test.g << "," << test.b << "," << test.a << ")" << std::endl;
float mag = test.Mag(boo1);
std::cout << "Magnitude: " << mag;
Color<int> rgba = color.HexConv("#FFFFFF");
std::cout << "\nRGBA Values Are : (" << rgba.r << "," << rgba.g << "," << rgba.b << "," << rgba.a << ")\n";
system("PAUSE");
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Event handler
//-----------------------------------------------------------------------------
void CTFDeathMatchScoreBoardDialog::FireGameEvent(IGameEvent *event)
{
const char *type = event->GetName();
if ( 0 == Q_strcmp( type, "server_spawn" ) )
{
// set server name in scoreboard
const char *hostname = event->GetString( "hostname" );
wchar_t wzHostName[256];
wchar_t wzServerLabel[256];
g_pVGuiLocalize->ConvertANSIToUnicode( hostname, wzHostName, sizeof( wzHostName ) );
g_pVGuiLocalize->ConstructString( wzServerLabel, sizeof(wzServerLabel), g_pVGuiLocalize->Find( "#Scoreboard_Server" ), 1, wzHostName );
SetDialogVariable( "server", wzServerLabel );
// Set the level name after the server spawn
char szMapName[MAX_MAP_NAME];
Q_FileBase(engine->GetLevelName(), szMapName, sizeof(szMapName));
Q_strlower(szMapName);
SetDialogVariable("mapname", GetMapDisplayName(szMapName));
m_pWinPanel->SetVisible(false);
bLockInput = false;
ShowPanel(false);
}
else if (Q_strcmp("teamplay_win_panel", type) == 0)
{
if (!TFGameRules() || !TFGameRules()->IsDeathmatch())
return;
m_flTimeUpdateTeamScore = gpGlobals->curtime + 4.5f;
bLockInput = true;
C_TF_PlayerResource *tf_PR = dynamic_cast<C_TF_PlayerResource *>(g_PR);
if (!tf_PR)
return;
// look for the top 3 players sent in the event
for (int i = 1; i <= 3; i++)
{
bool bShow = false;
char szPlayerIndexVal[64] = "", szPlayerScoreVal[64] = "", szPlayerKillsVal[64] = "", szPlayerDeathsVal[64] = "";
// get player index and round points from the event
Q_snprintf(szPlayerIndexVal, ARRAYSIZE(szPlayerIndexVal), "player_%d", i);
Q_snprintf(szPlayerScoreVal, ARRAYSIZE(szPlayerScoreVal), "player_%d_points", i);
Q_snprintf(szPlayerKillsVal, ARRAYSIZE(szPlayerKillsVal), "player_%d_kills", i);
Q_snprintf(szPlayerDeathsVal, ARRAYSIZE(szPlayerDeathsVal), "player_%d_deaths", i);
int iPlayerIndex = event->GetInt(szPlayerIndexVal, 0);
int iRoundScore = event->GetInt(szPlayerScoreVal, 0);
int iPlayerKills = event->GetInt(szPlayerKillsVal, 0);
int iPlayerDeaths = event->GetInt(szPlayerDeathsVal, 0);
// round score of 0 means no player to show for that position (not enough players, or didn't score any points that round)
if (iRoundScore > 0)
bShow = true;
CAvatarImagePanel *pPlayerAvatar = dynamic_cast<CAvatarImagePanel *>(m_pWinPanel->FindChildByName(CFmtStr("Player%dAvatar", i)));
if (pPlayerAvatar)
{
pPlayerAvatar->ClearAvatar();
if (bShow)
{
pPlayerAvatar->SetPlayer(GetSteamIDForPlayerIndex(iPlayerIndex), k_EAvatarSize32x32);
pPlayerAvatar->SetAvatarSize(32, 32);
}
pPlayerAvatar->SetVisible(bShow);
}
vgui::Label *pPlayerName = dynamic_cast<Label *>(m_pWinPanel->FindChildByName(CFmtStr("Player%dName", i)));
vgui::Label *pPlayerKills = dynamic_cast<Label *>(m_pWinPanel->FindChildByName(CFmtStr("Player%dKills", i)));
vgui::Label *pPlayerDeaths = dynamic_cast<Label *>(m_pWinPanel->FindChildByName(CFmtStr("Player%dDeaths", i)));
CModelPanel *pPlayerModel = dynamic_cast<CModelPanel *>(m_pWinPanel->FindChildByName(CFmtStr("Player%dModel", i)));
if (!pPlayerName || !pPlayerKills || !pPlayerDeaths)
return;
if (bShow)
{
// set the player labels to team color
Color clr = tf_PR->GetPlayerColor(iPlayerIndex);
pPlayerName->SetFgColor(clr);
pPlayerKills->SetFgColor(clr);
pPlayerDeaths->SetFgColor(clr);
// set label contents
pPlayerName->SetText(g_PR->GetPlayerName(iPlayerIndex));
pPlayerKills->SetText(CFmtStr("Kills: %d", iPlayerKills));
pPlayerDeaths->SetText(CFmtStr("Deaths: %d", iPlayerDeaths));
// store the colors for model coloring
m_vecWinningPlayerColor.AddToTail(Vector(clr.r() / 255.0f, clr.g() / 255.0f, clr.b() / 255.0f));
}
// show or hide labels for this player position
pPlayerName->SetVisible(bShow);
pPlayerKills->SetVisible(bShow);
pPlayerDeaths->SetVisible(bShow);
pPlayerModel->SetVisible(bShow);
}
ShowPanel(true);
}
else if (Q_strcmp("teamplay_round_start", type) == 0)
{
m_flTimeUpdateTeamScore = 0.0f;
m_pWinPanel->SetVisible(false);
bLockInput = false;
ShowPanel(false);
}
if( IsVisible() )
{
Update();
}
}
void Font::drawGlyphs(GraphicsContext* context, const SimpleFontData* font, const GlyphBuffer& glyphBuffer,
int from, int numGlyphs, const FloatPoint& point) const
{
cairo_t* cr = context->platformContext();
cairo_save(cr);
cairo_set_scaled_font(cr, font->platformData().scaledFont());
GlyphBufferGlyph* glyphs = (GlyphBufferGlyph*)glyphBuffer.glyphs(from);
float offset = 0.0f;
for (int i = 0; i < numGlyphs; i++) {
glyphs[i].x = offset;
glyphs[i].y = 0.0f;
offset += glyphBuffer.advanceAt(from + i);
}
Color fillColor = context->fillColor();
// Synthetic Oblique
if(font->platformData().syntheticOblique()) {
cairo_matrix_t mat = {1, 0, -tanf(SYNTHETIC_OBLIQUE_ANGLE * acosf(0) / 90), 1, point.x(), point.y()};
cairo_transform(cr, &mat);
} else {
cairo_translate(cr, point.x(), point.y());
}
// Text shadow, inspired by FontMac
IntSize shadowSize;
int shadowBlur = 0;
Color shadowColor;
bool hasShadow = context->textDrawingMode() == cTextFill &&
context->getShadow(shadowSize, shadowBlur, shadowColor);
// TODO: Blur support
if (hasShadow) {
// Disable graphics context shadows (not yet implemented) and paint them manually
context->clearShadow();
Color shadowFillColor(shadowColor.red(), shadowColor.green(), shadowColor.blue(), shadowColor.alpha() * fillColor.alpha() / 255);
cairo_save(cr);
float red, green, blue, alpha;
shadowFillColor.getRGBA(red, green, blue, alpha);
cairo_set_source_rgba(cr, red, green, blue, alpha);
#if ENABLE(FILTERS)
cairo_text_extents_t extents;
cairo_scaled_font_glyph_extents(font->platformData().scaledFont(), glyphs, numGlyphs, &extents);
FloatRect rect(FloatPoint(), FloatSize(extents.width, extents.height));
IntSize shadowBufferSize;
FloatRect shadowRect;
float kernelSize = 0.f;
GraphicsContext::calculateShadowBufferDimensions(shadowBufferSize, shadowRect, kernelSize, rect, shadowSize, shadowBlur);
// Draw shadow into a new ImageBuffer
OwnPtr<ImageBuffer> shadowBuffer = ImageBuffer::create(shadowBufferSize);
GraphicsContext* shadowContext = shadowBuffer->context();
cairo_t* shadowCr = shadowContext->platformContext();
cairo_translate(shadowCr, kernelSize, extents.height + kernelSize);
cairo_set_scaled_font(shadowCr, font->platformData().scaledFont());
cairo_show_glyphs(shadowCr, glyphs, numGlyphs);
if (font->syntheticBoldOffset()) {
cairo_save(shadowCr);
cairo_translate(shadowCr, font->syntheticBoldOffset(), 0);
cairo_show_glyphs(shadowCr, glyphs, numGlyphs);
cairo_restore(shadowCr);
}
cairo_translate(cr, 0.0, -extents.height);
context->createPlatformShadow(shadowBuffer.release(), shadowColor, shadowRect, kernelSize);
#else
cairo_translate(cr, shadowSize.width(), shadowSize.height());
cairo_show_glyphs(cr, glyphs, numGlyphs);
if (font->syntheticBoldOffset()) {
cairo_save(cr);
cairo_translate(cr, font->syntheticBoldOffset(), 0);
cairo_show_glyphs(cr, glyphs, numGlyphs);
cairo_restore(cr);
}
#endif
cairo_restore(cr);
}
if (context->textDrawingMode() & cTextFill) {
if (context->fillGradient()) {
cairo_set_source(cr, context->fillGradient()->platformGradient());
if (context->getAlpha() < 1.0f) {
cairo_push_group(cr);
cairo_paint_with_alpha(cr, context->getAlpha());
cairo_pop_group_to_source(cr);
}
} else if (context->fillPattern()) {
TransformationMatrix affine;
cairo_set_source(cr, context->fillPattern()->createPlatformPattern(affine));
if (context->getAlpha() < 1.0f) {
cairo_push_group(cr);
cairo_paint_with_alpha(cr, context->getAlpha());
cairo_pop_group_to_source(cr);
}
} else {
float red, green, blue, alpha;
fillColor.getRGBA(red, green, blue, alpha);
cairo_set_source_rgba(cr, red, green, blue, alpha * context->getAlpha());
}
cairo_show_glyphs(cr, glyphs, numGlyphs);
if (font->syntheticBoldOffset()) {
cairo_save(cr);
cairo_translate(cr, font->syntheticBoldOffset(), 0);
cairo_show_glyphs(cr, glyphs, numGlyphs);
cairo_restore(cr);
}
}
if (context->textDrawingMode() & cTextStroke) {
if (context->strokeGradient()) {
cairo_set_source(cr, context->strokeGradient()->platformGradient());
if (context->getAlpha() < 1.0f) {
cairo_push_group(cr);
cairo_paint_with_alpha(cr, context->getAlpha());
cairo_pop_group_to_source(cr);
}
} else if (context->strokePattern()) {
TransformationMatrix affine;
cairo_set_source(cr, context->strokePattern()->createPlatformPattern(affine));
if (context->getAlpha() < 1.0f) {
cairo_push_group(cr);
cairo_paint_with_alpha(cr, context->getAlpha());
cairo_pop_group_to_source(cr);
}
} else {
Color strokeColor = context->strokeColor();
float red, green, blue, alpha;
strokeColor.getRGBA(red, green, blue, alpha);
cairo_set_source_rgba(cr, red, green, blue, alpha * context->getAlpha());
}
cairo_glyph_path(cr, glyphs, numGlyphs);
cairo_set_line_width(cr, context->strokeThickness());
cairo_stroke(cr);
}
// Re-enable the platform shadow we disabled earlier
if (hasShadow)
context->setShadow(shadowSize, shadowBlur, shadowColor, DeviceColorSpace);
cairo_restore(cr);
}
void SVGInlineTextBox::paintSelectionBackground(PaintInfo& paintInfo)
{
ASSERT(paintInfo.shouldPaintWithinRoot(renderer()));
ASSERT(paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection);
ASSERT(truncation() == cNoTruncation);
if (renderer()->style()->visibility() != VISIBLE)
return;
RenderObject* parentRenderer = parent()->renderer();
ASSERT(parentRenderer);
ASSERT(!parentRenderer->document()->printing());
// Determine whether or not we're selected.
bool paintSelectedTextOnly = paintInfo.phase == PaintPhaseSelection;
bool hasSelection = selectionState() != RenderObject::SelectionNone;
if (!hasSelection || paintSelectedTextOnly)
return;
Color backgroundColor = renderer()->selectionBackgroundColor();
if (!backgroundColor.isValid() || !backgroundColor.alpha())
return;
RenderSVGInlineText* textRenderer = toRenderSVGInlineText(this->textRenderer());
ASSERT(textRenderer);
if (!textShouldBePainted(textRenderer))
return;
RenderStyle* style = parentRenderer->style();
ASSERT(style);
RenderStyle* selectionStyle = style;
if (hasSelection) {
selectionStyle = parentRenderer->getCachedPseudoStyle(SELECTION);
if (!selectionStyle)
selectionStyle = style;
}
int startPosition, endPosition;
selectionStartEnd(startPosition, endPosition);
int fragmentStartPosition = 0;
int fragmentEndPosition = 0;
AffineTransform fragmentTransform;
unsigned textFragmentsSize = m_textFragments.size();
for (unsigned i = 0; i < textFragmentsSize; ++i) {
SVGTextFragment& fragment = m_textFragments.at(i);
ASSERT(!m_paintingResource);
fragmentStartPosition = startPosition;
fragmentEndPosition = endPosition;
if (!mapStartEndPositionsIntoFragmentCoordinates(fragment, fragmentStartPosition, fragmentEndPosition))
continue;
GraphicsContextStateSaver stateSaver(*paintInfo.context);
fragment.buildFragmentTransform(fragmentTransform);
if (!fragmentTransform.isIdentity())
paintInfo.context->concatCTM(fragmentTransform);
paintInfo.context->setFillColor(backgroundColor, style->colorSpace());
paintInfo.context->fillRect(selectionRectForTextFragment(fragment, fragmentStartPosition, fragmentEndPosition, style), backgroundColor, style->colorSpace());
m_paintingResourceMode = ApplyToDefaultMode;
}
ASSERT(!m_paintingResource);
}
void OGLGraphics::setBackgroundColor(const Color &color)
{
m_bcgColor.assign(color);
glClearColor(color.r(), color.g(), color.b(), color.a());
}
Color Color::blend(const Color& B, const Color& A) {
Color C;
C.setRedF(B.redF() + (1.0 - B.alphaF()) * A.redF());
C.setGreenF(B.greenF() + (1.0 - B.alphaF()) * A.greenF());
C.setBlueF(B.blueF() + (1.0 - B.alphaF()) * A.blueF());
C.setAlphaF(B.alphaF() + (1.0 - B.alphaF()) * A.alphaF());
return C;
}
void RenderTreeAsText::writeRenderObject(TextStream& ts, const RenderObject& o, RenderAsTextBehavior behavior)
{
ts << o.renderName();
if (behavior & RenderAsTextShowAddresses)
ts << " " << static_cast<const void*>(&o);
if (o.style() && o.style()->zIndex())
ts << " zI: " << o.style()->zIndex();
if (o.node()) {
String tagName = getTagName(o.node());
if (!tagName.isEmpty()) {
ts << " {" << tagName << "}";
// flag empty or unstyled AppleStyleSpan because we never
// want to leave them in the DOM
if (isEmptyOrUnstyledAppleStyleSpan(o.node()))
ts << " *empty or unstyled AppleStyleSpan*";
}
}
RenderBlock* cb = o.containingBlock();
bool adjustForTableCells = cb ? cb->isTableCell() : false;
LayoutRect r;
if (o.isText()) {
// FIXME: Would be better to dump the bounding box x and y rather than the first run's x and y, but that would involve updating
// many test results.
const RenderText& text = *toRenderText(&o);
IntRect linesBox = text.linesBoundingBox();
r = IntRect(text.firstRunX(), text.firstRunY(), linesBox.width(), linesBox.height());
if (adjustForTableCells && !text.firstTextBox())
adjustForTableCells = false;
} else if (o.isRenderInline()) {
// FIXME: Would be better not to just dump 0, 0 as the x and y here.
const RenderInline& inlineFlow = *toRenderInline(&o);
r = IntRect(0, 0, inlineFlow.linesBoundingBox().width(), inlineFlow.linesBoundingBox().height());
adjustForTableCells = false;
} else if (o.isTableCell()) {
// FIXME: Deliberately dump the "inner" box of table cells, since that is what current results reflect. We'd like
// to clean up the results to dump both the outer box and the intrinsic padding so that both bits of information are
// captured by the results.
const RenderTableCell& cell = *toRenderTableCell(&o);
r = LayoutRect(cell.x(), cell.y() + cell.intrinsicPaddingBefore(), cell.width(), cell.height() - cell.intrinsicPaddingBefore() - cell.intrinsicPaddingAfter());
} else if (o.isBox())
r = toRenderBox(&o)->frameRect();
// FIXME: Temporary in order to ensure compatibility with existing layout test results.
if (adjustForTableCells)
r.move(0, -toRenderTableCell(o.containingBlock())->intrinsicPaddingBefore());
// FIXME: Convert layout test results to report sub-pixel values, in the meantime using enclosingIntRect
// for consistency with old results.
ts << " " << enclosingIntRect(r);
if (!(o.isText() && !o.isBR())) {
if (o.isFileUploadControl())
ts << " " << quoteAndEscapeNonPrintables(toRenderFileUploadControl(&o)->fileTextValue());
if (o.parent()) {
Color color = o.style()->visitedDependentColor(CSSPropertyColor);
if (o.parent()->style()->visitedDependentColor(CSSPropertyColor) != color)
ts << " [color=" << color.nameForRenderTreeAsText() << "]";
// Do not dump invalid or transparent backgrounds, since that is the default.
Color backgroundColor = o.style()->visitedDependentColor(CSSPropertyBackgroundColor);
if (o.parent()->style()->visitedDependentColor(CSSPropertyBackgroundColor) != backgroundColor
&& backgroundColor.isValid() && backgroundColor.rgb())
ts << " [bgcolor=" << backgroundColor.nameForRenderTreeAsText() << "]";
Color textFillColor = o.style()->visitedDependentColor(CSSPropertyWebkitTextFillColor);
if (o.parent()->style()->visitedDependentColor(CSSPropertyWebkitTextFillColor) != textFillColor
&& textFillColor.isValid() && textFillColor != color && textFillColor.rgb())
ts << " [textFillColor=" << textFillColor.nameForRenderTreeAsText() << "]";
Color textStrokeColor = o.style()->visitedDependentColor(CSSPropertyWebkitTextStrokeColor);
if (o.parent()->style()->visitedDependentColor(CSSPropertyWebkitTextStrokeColor) != textStrokeColor
&& textStrokeColor.isValid() && textStrokeColor != color && textStrokeColor.rgb())
ts << " [textStrokeColor=" << textStrokeColor.nameForRenderTreeAsText() << "]";
if (o.parent()->style()->textStrokeWidth() != o.style()->textStrokeWidth() && o.style()->textStrokeWidth() > 0)
ts << " [textStrokeWidth=" << o.style()->textStrokeWidth() << "]";
}
if (!o.isBoxModelObject())
return;
const RenderBoxModelObject& box = *toRenderBoxModelObject(&o);
if (box.borderTop() || box.borderRight() || box.borderBottom() || box.borderLeft()) {
ts << " [border:";
BorderValue prevBorder;
if (o.style()->borderTop() != prevBorder) {
prevBorder = o.style()->borderTop();
if (!box.borderTop())
ts << " none";
else {
ts << " (" << box.borderTop() << "px ";
printBorderStyle(ts, o.style()->borderTopStyle());
Color col = o.style()->borderTopColor();
if (!col.isValid())
col = o.style()->color();
ts << col.nameForRenderTreeAsText() << ")";
}
}
if (o.style()->borderRight() != prevBorder) {
prevBorder = o.style()->borderRight();
if (!box.borderRight())
ts << " none";
else {
ts << " (" << box.borderRight() << "px ";
printBorderStyle(ts, o.style()->borderRightStyle());
Color col = o.style()->borderRightColor();
if (!col.isValid())
col = o.style()->color();
ts << col.nameForRenderTreeAsText() << ")";
}
}
if (o.style()->borderBottom() != prevBorder) {
prevBorder = box.style()->borderBottom();
if (!box.borderBottom())
ts << " none";
else {
ts << " (" << box.borderBottom() << "px ";
printBorderStyle(ts, o.style()->borderBottomStyle());
Color col = o.style()->borderBottomColor();
if (!col.isValid())
col = o.style()->color();
ts << col.nameForRenderTreeAsText() << ")";
}
}
if (o.style()->borderLeft() != prevBorder) {
prevBorder = o.style()->borderLeft();
if (!box.borderLeft())
ts << " none";
else {
ts << " (" << box.borderLeft() << "px ";
printBorderStyle(ts, o.style()->borderLeftStyle());
Color col = o.style()->borderLeftColor();
if (!col.isValid())
col = o.style()->color();
ts << col.nameForRenderTreeAsText() << ")";
}
}
ts << "]";
}
}
if (o.isTableCell()) {
const RenderTableCell& c = *toRenderTableCell(&o);
ts << " [r=" << c.rowIndex() << " c=" << c.col() << " rs=" << c.rowSpan() << " cs=" << c.colSpan() << "]";
}
#if ENABLE(DETAILS)
if (o.isDetailsMarker()) {
ts << ": ";
switch (toRenderDetailsMarker(&o)->orientation()) {
case RenderDetailsMarker::Left:
ts << "left";
break;
case RenderDetailsMarker::Right:
ts << "right";
break;
case RenderDetailsMarker::Up:
ts << "up";
break;
case RenderDetailsMarker::Down:
ts << "down";
break;
}
}
#endif
if (o.isListMarker()) {
String text = toRenderListMarker(&o)->text();
if (!text.isEmpty()) {
if (text.length() != 1)
text = quoteAndEscapeNonPrintables(text);
else {
switch (text[0]) {
case bullet:
text = "bullet";
break;
case blackSquare:
text = "black square";
break;
case whiteBullet:
text = "white bullet";
break;
default:
text = quoteAndEscapeNonPrintables(text);
}
}
ts << ": " << text;
}
}
if (behavior & RenderAsTextShowIDAndClass) {
if (Node* node = o.node()) {
if (node->hasID())
ts << " id=\"" + static_cast<Element*>(node)->getIdAttribute() + "\"";
if (node->hasClass()) {
StyledElement* styledElement = static_cast<StyledElement*>(node);
String classes;
for (size_t i = 0; i < styledElement->classNames().size(); ++i) {
if (i > 0)
classes += " ";
classes += styledElement->classNames()[i];
}
ts << " class=\"" + classes + "\"";
}
}
}
if (behavior & RenderAsTextShowLayoutState) {
bool needsLayout = o.selfNeedsLayout() || o.needsPositionedMovementLayout() || o.posChildNeedsLayout() || o.normalChildNeedsLayout();
if (needsLayout)
ts << " (needs layout:";
bool havePrevious = false;
if (o.selfNeedsLayout()) {
ts << " self";
havePrevious = true;
}
if (o.needsPositionedMovementLayout()) {
if (havePrevious)
ts << ",";
havePrevious = true;
ts << " positioned movement";
}
if (o.normalChildNeedsLayout()) {
if (havePrevious)
ts << ",";
havePrevious = true;
ts << " child";
}
if (o.posChildNeedsLayout()) {
if (havePrevious)
ts << ",";
ts << " positioned child";
}
if (needsLayout)
ts << ")";
}
#if PLATFORM(QT)
// Print attributes of embedded QWidgets. E.g. when the WebCore::Widget
// is invisible the QWidget should be invisible too.
if (o.isRenderPart()) {
const RenderPart* part = toRenderPart(const_cast<RenderObject*>(&o));
if (part->widget() && part->widget()->platformWidget()) {
QObject* wid = part->widget()->platformWidget();
ts << " [QT: ";
ts << "geometry: {" << wid->property("geometry").toRect() << "} ";
ts << "isHidden: " << !wid->property("isVisible").toBool() << " ";
ts << "isSelfVisible: " << part->widget()->isSelfVisible() << " ";
ts << "isParentVisible: " << part->widget()->isParentVisible() << " ] ";
}
}
#endif
}
static inline void setColor(cairo_t* cr, const Color& col)
{
float red, green, blue, alpha;
col.getRGBA(red, green, blue, alpha);
cairo_set_source_rgba(cr, red, green, blue, alpha);
}
inline void ToGDIColor(const Color& source, Gdiplus::Color& target) {
target = Gdiplus::Color(source.GetAlpha(), source.GetRed(), source.GetGreen(), source.GetBlue());
}
void JSONValue::SetColor(const String& name, const Color& value)
{
SetString(name, value.ToString());
}
void Text::setShadowColor (const Color &c)
{
evas_object_text_shadow_color_set (o, c.red (), c.green (), c.blue (), c.alpha ());
}
void SVGColorProperty::calculateAnimatedValue(SVGNativeAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtr<SVGPropertyBase> fromValue, PassRefPtr<SVGPropertyBase> toValue, PassRefPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
{
StyleColor fromStyleColor = toSVGColorProperty(fromValue)->m_styleColor;
StyleColor toStyleColor = toSVGColorProperty(toValue)->m_styleColor;
StyleColor toAtEndOfDurationStyleColor = toSVGColorProperty(toAtEndOfDurationValue)->m_styleColor;
// Apply currentColor rules.
ASSERT(contextElement);
Color fallbackColor = fallbackColorForCurrentColor(contextElement);
Color fromColor = fromStyleColor.resolve(fallbackColor);
Color toColor = toStyleColor.resolve(fallbackColor);
Color toAtEndOfDurationColor = toAtEndOfDurationStyleColor.resolve(fallbackColor);
Color animatedColor = m_styleColor.resolve(fallbackColor);
ASSERT(animationElement);
float animatedRed = animatedColor.red();
animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.red(), toColor.red(), toAtEndOfDurationColor.red(), animatedRed);
float animatedGreen = animatedColor.green();
animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.green(), toColor.green(), toAtEndOfDurationColor.green(), animatedGreen);
float animatedBlue = animatedColor.blue();
animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.blue(), toColor.blue(), toAtEndOfDurationColor.blue(), animatedBlue);
float animatedAlpha = animatedColor.alpha();
animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.alpha(), toColor.alpha(), toAtEndOfDurationColor.alpha(), animatedAlpha);
m_styleColor = StyleColor(makeRGBA(roundf(animatedRed), roundf(animatedGreen), roundf(animatedBlue), roundf(animatedAlpha)));
}
void Text::setGlow2Color (const Color &c)
{
evas_object_text_glow2_color_set (o, c.red (), c.green (), c.blue (), c.alpha ());
}
void Font::internalPrint(float x, float y, const Color& color, const char* output) const
{
program->use();
glUniformMatrix4fv(program->getUniformLocation(u_projectionMatrix), 1, GL_FALSE, camera->getProjectionMatrix().getM());
glUniformMatrix4fv(program->getUniformLocation(u_viewMatrix), 1, GL_FALSE, camera->getViewMatrix().getM());
glUniform1f(program->getUniformLocation(u_fontWidth), cellWidthNormalized);
glUniform1f(program->getUniformLocation(u_fontHeight), cellHeightNormalized);
glUniform4fv(program->getUniformLocation(u_fontColor), 1, color.getRGBA());
glBindTexture(GL_TEXTURE_2D, fontTextureName);
glUniform1i(program->getUniformLocation(u_fontTexture), 0);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
ViewportSP currentViewport = ViewportManager::getInstance()->getDefaultViewport();
Matrix4x4 modelMatrix;
Matrix4x4 toScreenMatrix;
toScreenMatrix.translate(-static_cast<float>(currentViewport->getWidth()) / 2.0f + cellWidth / 2.0f, static_cast<float>(currentViewport->getHeight()) / 2.0f - cellHeight / 2.0f, 0.0f);
fontVAO->bind();
char c;
float currentColumnNormalized;
float currentRowNormalized;
float currentX = x;
float currentY = y;
int32_t stringLength = strlen(output);
for (int32_t i = 0; i < stringLength; i++)
{
c = output[i];
if (c != '\n')
{
currentColumnNormalized = static_cast<float>(c % columns) * cellWidth / width;
currentRowNormalized = 1.0f - static_cast<float>(c / rows) * cellHeight / height - cellHeightNormalized;
glUniform1f(program->getUniformLocation(u_fontLeft), currentColumnNormalized);
glUniform1f(program->getUniformLocation(u_fontTop), currentRowNormalized);
modelMatrix.identity();
modelMatrix.translate(currentX, -currentY, 0.0f);
modelMatrix.multiply(toScreenMatrix);
glUniformMatrix4fv(program->getUniformLocation(u_modelMatrix), 1, GL_FALSE, modelMatrix.getM());
glDrawElements(GL_TRIANGLES, numberIndices, GL_UNSIGNED_INT, 0);
currentX += fontWidth;
}
else
{
currentX = x;
currentY += fontHeight;
}
}
fontVAO->unbind();
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, 0);
}
void Text::setOutlineColor (const Color &c)
{
evas_object_text_outline_color_set (o, c.red (), c.green (), c.blue (), c.alpha ());
}
inline void debug_ast(AST_Node* node, std::string ind, Env* env)
{
if (node == 0) return;
if (ind == "") std::cerr << "####################################################################\n";
if (dynamic_cast<Bubble*>(node)) {
Bubble* bubble = dynamic_cast<Bubble*>(node);
std::cerr << ind << "Bubble " << bubble;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << bubble->tabs();
std::cerr << std::endl;
debug_ast(bubble->node(), ind + " ", env);
} else if (dynamic_cast<Trace*>(node)) {
Trace* trace = dynamic_cast<Trace*>(node);
std::cerr << ind << "Trace " << trace;
std::cerr << " (" << pstate_source_position(node) << ")"
<< " [name:" << trace->name() << "]"
<< std::endl;
debug_ast(trace->block(), ind + " ", env);
} else if (dynamic_cast<At_Root_Block*>(node)) {
At_Root_Block* root_block = dynamic_cast<At_Root_Block*>(node);
std::cerr << ind << "At_Root_Block " << root_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << root_block->tabs();
std::cerr << std::endl;
debug_ast(root_block->expression(), ind + ":", env);
debug_ast(root_block->block(), ind + " ", env);
} else if (dynamic_cast<CommaSequence_Selector*>(node)) {
CommaSequence_Selector* selector = dynamic_cast<CommaSequence_Selector*>(node);
std::cerr << ind << "CommaSequence_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " [@media:" << selector->media_block() << "]";
std::cerr << (selector->is_invisible() ? " [INVISIBLE]": " -");
std::cerr << (selector->has_placeholder() ? " [PLACEHOLDER]": " -");
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
// } else if (dynamic_cast<Expression*>(node)) {
// Expression* expression = dynamic_cast<Expression*>(node);
// std::cerr << ind << "Expression " << expression << " " << expression->concrete_type() << std::endl;
} else if (dynamic_cast<Parent_Selector*>(node)) {
Parent_Selector* selector = dynamic_cast<Parent_Selector*>(node);
std::cerr << ind << "Parent_Selector " << selector;
// if (selector->not_selector()) cerr << " [in_declaration]";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " [" << (selector->is_real_parent_ref() ? "REAL" : "FAKE") << "]";
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
// debug_ast(selector->selector(), ind + "->", env);
} else if (dynamic_cast<Sequence_Selector*>(node)) {
Sequence_Selector* selector = dynamic_cast<Sequence_Selector*>(node);
std::cerr << ind << "Sequence_Selector " << selector
<< " (" << pstate_source_position(node) << ")"
<< " <" << selector->hash() << ">"
<< " [length:" << longToHex(selector->length()) << "]"
<< " [weight:" << longToHex(selector->specificity()) << "]"
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_invisible() ? " [INVISIBLE]": " -")
<< (selector->has_placeholder() ? " [PLACEHOLDER]": " -")
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_parent_ref() ? " [has parent]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< " -- ";
std::string del;
switch (selector->combinator()) {
case Sequence_Selector::PARENT_OF: del = ">"; break;
case Sequence_Selector::PRECEDES: del = "~"; break;
case Sequence_Selector::ADJACENT_TO: del = "+"; break;
case Sequence_Selector::ANCESTOR_OF: del = " "; break;
case Sequence_Selector::REFERENCE: del = "//"; break;
}
// if (del = "/") del += selector->reference()->perform(&to_string) + "/";
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
debug_ast(selector->head(), ind + " " /* + "[" + del + "]" */, env);
if (selector->tail()) {
debug_ast(selector->tail(), ind + "{" + del + "}", env);
} else if(del != " ") {
std::cerr << ind << " |" << del << "| {trailing op}" << std::endl;
}
SourcesSet set = selector->sources();
// debug_sources_set(set, ind + " @--> ");
} else if (dynamic_cast<SimpleSequence_Selector*>(node)) {
SimpleSequence_Selector* selector = dynamic_cast<SimpleSequence_Selector*>(node);
std::cerr << ind << "SimpleSequence_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " [weight:" << longToHex(selector->specificity()) << "]";
std::cerr << " [@media:" << selector->media_block() << "]";
std::cerr << (selector->extended() ? " [extended]": " -");
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Wrapped_Selector*>(node)) {
Wrapped_Selector* selector = dynamic_cast<Wrapped_Selector*>(node);
std::cerr << ind << "Wrapped_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->selector(), ind + " () ", env);
} else if (dynamic_cast<Pseudo_Selector*>(node)) {
Pseudo_Selector* selector = dynamic_cast<Pseudo_Selector*>(node);
std::cerr << ind << "Pseudo_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->expression(), ind + " <= ", env);
} else if (dynamic_cast<Attribute_Selector*>(node)) {
Attribute_Selector* selector = dynamic_cast<Attribute_Selector*>(node);
std::cerr << ind << "Attribute_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->value(), ind + "[" + selector->matcher() + "] ", env);
} else if (dynamic_cast<Class_Selector*>(node)) {
Class_Selector* selector = dynamic_cast<Class_Selector*>(node);
std::cerr << ind << "Class_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
} else if (dynamic_cast<Id_Selector*>(node)) {
Id_Selector* selector = dynamic_cast<Id_Selector*>(node);
std::cerr << ind << "Id_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
} else if (dynamic_cast<Element_Selector*>(node)) {
Element_Selector* selector = dynamic_cast<Element_Selector*>(node);
std::cerr << ind << "Element_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">";
std::cerr << std::endl;
} else if (dynamic_cast<Placeholder_Selector*>(node)) {
Placeholder_Selector* selector = dynamic_cast<Placeholder_Selector*>(node);
std::cerr << ind << "Placeholder_Selector [" << selector->ns_name() << "] " << selector
<< " <" << selector->hash() << ">"
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
} else if (dynamic_cast<Simple_Selector*>(node)) {
Simple_Selector* selector = dynamic_cast<Simple_Selector*>(node);
std::cerr << ind << "Simple_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << std::endl;
} else if (dynamic_cast<Selector_Schema*>(node)) {
Selector_Schema* selector = dynamic_cast<Selector_Schema*>(node);
std::cerr << ind << "Selector_Schema " << selector;
std::cerr << " (" << pstate_source_position(node) << ")"
<< (selector->at_root() && selector->at_root() ? " [@ROOT]" : "")
<< " [@media:" << selector->media_block() << "]"
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
debug_ast(selector->contents(), ind + " ");
// for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Selector*>(node)) {
Selector* selector = dynamic_cast<Selector*>(node);
std::cerr << ind << "Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
} else if (dynamic_cast<Media_Query_Expression*>(node)) {
Media_Query_Expression* block = dynamic_cast<Media_Query_Expression*>(node);
std::cerr << ind << "Media_Query_Expression " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (block->is_interpolated() ? " [is_interpolated]": " -")
<< std::endl;
debug_ast(block->feature(), ind + " feature) ");
debug_ast(block->value(), ind + " value) ");
} else if (dynamic_cast<Media_Query*>(node)) {
Media_Query* block = dynamic_cast<Media_Query*>(node);
std::cerr << ind << "Media_Query " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (block->is_negated() ? " [is_negated]": " -")
<< (block->is_restricted() ? " [is_restricted]": " -")
<< std::endl;
debug_ast(block->media_type(), ind + " ");
for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Media_Block*>(node)) {
Media_Block* block = dynamic_cast<Media_Block*>(node);
std::cerr << ind << "Media_Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->media_queries(), ind + " =@ ");
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Supports_Block*>(node)) {
Supports_Block* block = dynamic_cast<Supports_Block*>(node);
std::cerr << ind << "Supports_Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->condition(), ind + " =@ ");
debug_ast(block->block(), ind + " <>");
} else if (dynamic_cast<Supports_Operator*>(node)) {
Supports_Operator* block = dynamic_cast<Supports_Operator*>(node);
std::cerr << ind << "Supports_Operator " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->left(), ind + " left) ");
debug_ast(block->right(), ind + " right) ");
} else if (dynamic_cast<Supports_Negation*>(node)) {
Supports_Negation* block = dynamic_cast<Supports_Negation*>(node);
std::cerr << ind << "Supports_Negation " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->condition(), ind + " condition) ");
} else if (dynamic_cast<At_Root_Query*>(node)) {
At_Root_Query* block = dynamic_cast<At_Root_Query*>(node);
std::cerr << ind << "At_Root_Query " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->feature(), ind + " feature) ");
debug_ast(block->value(), ind + " value) ");
} else if (dynamic_cast<Supports_Declaration*>(node)) {
Supports_Declaration* block = dynamic_cast<Supports_Declaration*>(node);
std::cerr << ind << "Supports_Declaration " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->feature(), ind + " feature) ");
debug_ast(block->value(), ind + " value) ");
} else if (dynamic_cast<Block*>(node)) {
Block* root_block = dynamic_cast<Block*>(node);
std::cerr << ind << "Block " << root_block;
std::cerr << " (" << pstate_source_position(node) << ")";
if (root_block->is_root()) std::cerr << " [root]";
std::cerr << " " << root_block->tabs() << std::endl;
if (root_block->block()) for(auto i : root_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Warning*>(node)) {
Warning* block = dynamic_cast<Warning*>(node);
std::cerr << ind << "Warning " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->message(), ind + " : ");
} else if (dynamic_cast<Error*>(node)) {
Error* block = dynamic_cast<Error*>(node);
std::cerr << ind << "Error " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Debug*>(node)) {
Debug* block = dynamic_cast<Debug*>(node);
std::cerr << ind << "Debug " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->value(), ind + " ");
} else if (dynamic_cast<Comment*>(node)) {
Comment* block = dynamic_cast<Comment*>(node);
std::cerr << ind << "Comment " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() <<
" <" << prettyprint(block->pstate().token.ws_before()) << ">" << std::endl;
debug_ast(block->text(), ind + "// ", env);
} else if (dynamic_cast<If*>(node)) {
If* block = dynamic_cast<If*>(node);
std::cerr << ind << "If " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->predicate(), ind + " = ");
debug_ast(block->block(), ind + " <>");
debug_ast(block->alternative(), ind + " ><");
} else if (dynamic_cast<Return*>(node)) {
Return* block = dynamic_cast<Return*>(node);
std::cerr << ind << "Return " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Extension*>(node)) {
Extension* block = dynamic_cast<Extension*>(node);
std::cerr << ind << "Extension " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->selector(), ind + "-> ", env);
} else if (dynamic_cast<Content*>(node)) {
Content* block = dynamic_cast<Content*>(node);
std::cerr << ind << "Content " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [@media:" << block->media_block() << "]";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Import_Stub*>(node)) {
Import_Stub* block = dynamic_cast<Import_Stub*>(node);
std::cerr << ind << "Import_Stub " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << block->imp_path() << "] ";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Import*>(node)) {
Import* block = dynamic_cast<Import*>(node);
std::cerr << ind << "Import " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
// std::vector<std::string> files_;
for (auto imp : block->urls()) debug_ast(imp, ind + "@: ", env);
debug_ast(block->media_queries(), ind + "@@ ");
} else if (dynamic_cast<Assignment*>(node)) {
Assignment* block = dynamic_cast<Assignment*>(node);
std::cerr << ind << "Assignment " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <<" << block->variable() << ">> " << block->tabs() << std::endl;
debug_ast(block->value(), ind + "=", env);
} else if (dynamic_cast<Declaration*>(node)) {
Declaration* block = dynamic_cast<Declaration*>(node);
std::cerr << ind << "Declaration " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->property(), ind + " prop: ", env);
debug_ast(block->value(), ind + " value: ", env);
debug_ast(block->block(), ind + " ", env);
} else if (dynamic_cast<Keyframe_Rule*>(node)) {
Keyframe_Rule* has_block = dynamic_cast<Keyframe_Rule*>(node);
std::cerr << ind << "Keyframe_Rule " << has_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << has_block->tabs() << std::endl;
if (has_block->selector()) debug_ast(has_block->selector(), ind + "@");
if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Directive*>(node)) {
Directive* block = dynamic_cast<Directive*>(node);
std::cerr << ind << "Directive " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << block->keyword() << "] " << block->tabs() << std::endl;
debug_ast(block->selector(), ind + "~", env);
debug_ast(block->value(), ind + "+", env);
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Each*>(node)) {
Each* block = dynamic_cast<Each*>(node);
std::cerr << ind << "Each " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<For*>(node)) {
For* block = dynamic_cast<For*>(node);
std::cerr << ind << "For " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<While*>(node)) {
While* block = dynamic_cast<While*>(node);
std::cerr << ind << "While " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Definition*>(node)) {
Definition* block = dynamic_cast<Definition*>(node);
std::cerr << ind << "Definition " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [name: " << block->name() << "] ";
std::cerr << " [type: " << (block->type() == Sass::Definition::Type::MIXIN ? "Mixin " : "Function ") << "] ";
// this seems to lead to segfaults some times?
// std::cerr << " [signature: " << block->signature() << "] ";
std::cerr << " [native: " << block->native_function() << "] ";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->parameters(), ind + " params: ", env);
if (block->block()) debug_ast(block->block(), ind + " ", env);
} else if (dynamic_cast<Mixin_Call*>(node)) {
Mixin_Call* block = dynamic_cast<Mixin_Call*>(node);
std::cerr << ind << "Mixin_Call " << block << " " << block->tabs();
std::cerr << " [" << block->name() << "]";
std::cerr << " [has_content: " << block->has_content() << "] " << std::endl;
debug_ast(block->arguments(), ind + " args: ");
if (block->block()) debug_ast(block->block(), ind + " ", env);
} else if (Ruleset* ruleset = dynamic_cast<Ruleset*>(node)) {
std::cerr << ind << "Ruleset " << ruleset;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [indent: " << ruleset->tabs() << "]";
std::cerr << (ruleset->is_invisible() ? " [INVISIBLE]" : "");
std::cerr << (ruleset->at_root() ? " [@ROOT]" : "");
std::cerr << (ruleset->is_root() ? " [root]" : "");
std::cerr << std::endl;
debug_ast(ruleset->selector(), ind + ">");
debug_ast(ruleset->block(), ind + " ");
} else if (dynamic_cast<Block*>(node)) {
Block* block = dynamic_cast<Block*>(node);
std::cerr << ind << "Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (block->is_invisible() ? " [INVISIBLE]" : "");
std::cerr << " [indent: " << block->tabs() << "]" << std::endl;
for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Textual*>(node)) {
Textual* expression = dynamic_cast<Textual*>(node);
std::cerr << ind << "Textual ";
if (expression->type() == Textual::NUMBER) std::cerr << " [NUMBER]";
else if (expression->type() == Textual::PERCENTAGE) std::cerr << " [PERCENTAGE]";
else if (expression->type() == Textual::DIMENSION) std::cerr << " [DIMENSION]";
else if (expression->type() == Textual::HEX) std::cerr << " [HEX]";
std::cerr << expression << " [" << expression->value() << "]";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
if (expression->is_delayed()) std::cerr << " [delayed]";
std::cerr << std::endl;
} else if (dynamic_cast<Variable*>(node)) {
Variable* expression = dynamic_cast<Variable*>(node);
std::cerr << ind << "Variable " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->name() << "]" << std::endl;
std::string name(expression->name());
if (env && env->has(name)) debug_ast(static_cast<Expression*>((*env)[name]), ind + " -> ", env);
} else if (dynamic_cast<Function_Call_Schema*>(node)) {
Function_Call_Schema* expression = dynamic_cast<Function_Call_Schema*>(node);
std::cerr << ind << "Function_Call_Schema " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << "" << std::endl;
debug_ast(expression->name(), ind + "name: ", env);
debug_ast(expression->arguments(), ind + " args: ", env);
} else if (dynamic_cast<Function_Call*>(node)) {
Function_Call* expression = dynamic_cast<Function_Call*>(node);
std::cerr << ind << "Function_Call " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->name() << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << std::endl;
debug_ast(expression->arguments(), ind + " args: ", env);
} else if (dynamic_cast<Arguments*>(node)) {
Arguments* expression = dynamic_cast<Arguments*>(node);
std::cerr << ind << "Arguments " << expression;
if (expression->is_delayed()) std::cerr << " [delayed]";
std::cerr << " (" << pstate_source_position(node) << ")";
if (expression->has_named_arguments()) std::cerr << " [has_named_arguments]";
if (expression->has_rest_argument()) std::cerr << " [has_rest_argument]";
if (expression->has_keyword_argument()) std::cerr << " [has_keyword_argument]";
std::cerr << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Argument*>(node)) {
Argument* expression = dynamic_cast<Argument*>(node);
std::cerr << ind << "Argument " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->value() << "]";
std::cerr << " [name: " << expression->name() << "] ";
std::cerr << " [rest: " << expression->is_rest_argument() << "] ";
std::cerr << " [keyword: " << expression->is_keyword_argument() << "] " << std::endl;
debug_ast(expression->value(), ind + " value: ", env);
} else if (dynamic_cast<Parameters*>(node)) {
Parameters* expression = dynamic_cast<Parameters*>(node);
std::cerr << ind << "Parameters " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [has_optional: " << expression->has_optional_parameters() << "] ";
std::cerr << " [has_rest: " << expression->has_rest_parameter() << "] ";
std::cerr << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Parameter*>(node)) {
Parameter* expression = dynamic_cast<Parameter*>(node);
std::cerr << ind << "Parameter " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [name: " << expression->name() << "] ";
std::cerr << " [default: " << expression->default_value() << "] ";
std::cerr << " [rest: " << expression->is_rest_parameter() << "] " << std::endl;
} else if (dynamic_cast<Unary_Expression*>(node)) {
Unary_Expression* expression = dynamic_cast<Unary_Expression*>(node);
std::cerr << ind << "Unary_Expression " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [delayed: " << expression->is_delayed() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->type() << "]" << std::endl;
debug_ast(expression->operand(), ind + " operand: ", env);
} else if (dynamic_cast<Binary_Expression*>(node)) {
Binary_Expression* expression = dynamic_cast<Binary_Expression*>(node);
std::cerr << ind << "Binary_Expression " << expression;
if (expression->is_interpolant()) std::cerr << " [is interpolant] ";
if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
if (expression->is_right_interpolant()) std::cerr << " [right interpolant] ";
std::cerr << " [delayed: " << expression->is_delayed() << "] ";
std::cerr << " [ws_before: " << expression->op().ws_before << "] ";
std::cerr << " [ws_after: " << expression->op().ws_after << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->type_name() << "]" << std::endl;
debug_ast(expression->left(), ind + " left: ", env);
debug_ast(expression->right(), ind + " right: ", env);
} else if (dynamic_cast<Map*>(node)) {
Map* expression = dynamic_cast<Map*>(node);
std::cerr << ind << "Map " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [Hashed]" << std::endl;
for (auto i : expression->elements()) {
debug_ast(i.first, ind + " key: ");
debug_ast(i.second, ind + " val: ");
}
} else if (dynamic_cast<List*>(node)) {
List* expression = dynamic_cast<List*>(node);
std::cerr << ind << "List " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " (" << expression->length() << ") " <<
(expression->separator() == SASS_COMMA ? "Comma " : expression->separator() == SASS_HASH ? "Map" : "Space ") <<
" [delayed: " << expression->is_delayed() << "] " <<
" [interpolant: " << expression->is_interpolant() << "] " <<
" [listized: " << expression->from_selector() << "] " <<
" [arglist: " << expression->is_arglist() << "] " <<
" [hash: " << expression->hash() << "] " <<
std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Content*>(node)) {
Content* expression = dynamic_cast<Content*>(node);
std::cerr << ind << "Content " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [@media:" << expression->media_block() << "]";
std::cerr << " [Statement]" << std::endl;
} else if (dynamic_cast<Boolean*>(node)) {
Boolean* expression = dynamic_cast<Boolean*>(node);
std::cerr << ind << "Boolean " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->value() << "]" << std::endl;
} else if (dynamic_cast<Color*>(node)) {
Color* expression = dynamic_cast<Color*>(node);
std::cerr << ind << "Color " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [delayed: " << expression->is_delayed() << "] ";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->r() << ":" << expression->g() << ":" << expression->b() << "@" << expression->a() << "]" << std::endl;
} else if (dynamic_cast<Number*>(node)) {
Number* expression = dynamic_cast<Number*>(node);
std::cerr << ind << "Number " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->value() << expression->unit() << "]" <<
" [hash: " << expression->hash() << "] " <<
std::endl;
} else if (dynamic_cast<String_Quoted*>(node)) {
String_Quoted* expression = dynamic_cast<String_Quoted*>(node);
std::cerr << ind << "String_Quoted " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << prettyprint(expression->value()) << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
if (expression->quote_mark()) std::cerr << " [quote_mark: " << expression->quote_mark() << "]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<String_Constant*>(node)) {
String_Constant* expression = dynamic_cast<String_Constant*>(node);
std::cerr << ind << "String_Constant " << expression;
if (expression->concrete_type()) {
std::cerr << " " << expression->concrete_type();
}
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << prettyprint(expression->value()) << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<String_Schema*>(node)) {
String_Schema* expression = dynamic_cast<String_Schema*>(node);
std::cerr << ind << "String_Schema " << expression;
std::cerr << " " << expression->concrete_type();
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [is interpolant]";
if (expression->has_interpolant()) std::cerr << " [has interpolant]";
if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
if (expression->is_right_interpolant()) std::cerr << " [right interpolant] ";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<String*>(node)) {
String* expression = dynamic_cast<String*>(node);
std::cerr << ind << "String " << expression;
std::cerr << " " << expression->concrete_type();
std::cerr << " (" << pstate_source_position(node) << ")";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<Expression*>(node)) {
Expression* expression = dynamic_cast<Expression*>(node);
std::cerr << ind << "Expression " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
switch (expression->concrete_type()) {
case Expression::Concrete_Type::NONE: std::cerr << " [NONE]"; break;
case Expression::Concrete_Type::BOOLEAN: std::cerr << " [BOOLEAN]"; break;
case Expression::Concrete_Type::NUMBER: std::cerr << " [NUMBER]"; break;
case Expression::Concrete_Type::COLOR: std::cerr << " [COLOR]"; break;
case Expression::Concrete_Type::STRING: std::cerr << " [STRING]"; break;
case Expression::Concrete_Type::LIST: std::cerr << " [LIST]"; break;
case Expression::Concrete_Type::MAP: std::cerr << " [MAP]"; break;
case Expression::Concrete_Type::SELECTOR: std::cerr << " [SELECTOR]"; break;
case Expression::Concrete_Type::NULL_VAL: std::cerr << " [NULL_VAL]"; break;
case Expression::Concrete_Type::C_WARNING: std::cerr << " [C_WARNING]"; break;
case Expression::Concrete_Type::C_ERROR: std::cerr << " [C_ERROR]"; break;
case Expression::Concrete_Type::NUM_TYPES: std::cerr << " [NUM_TYPES]"; break;
}
std::cerr << std::endl;
} else if (dynamic_cast<Has_Block*>(node)) {
Has_Block* has_block = dynamic_cast<Has_Block*>(node);
std::cerr << ind << "Has_Block " << has_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << has_block->tabs() << std::endl;
if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Statement*>(node)) {
Statement* statement = dynamic_cast<Statement*>(node);
std::cerr << ind << "Statement " << statement;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << statement->tabs() << std::endl;
}
if (ind == "") std::cerr << "####################################################################\n";
}
bool AccessibilityTable::isDataTable() const
{
if (!m_renderer)
return false;
// Do not consider it a data table is it has an ARIA role.
if (hasARIARole())
return false;
// This employs a heuristic to determine if this table should appear.
// Only "data" tables should be exposed as tables.
// Unfortunately, there is no good way to determine the difference
// between a "layout" table and a "data" table.
RenderTable* table = toRenderTable(m_renderer);
Node* tableNode = table->node();
if (!tableNode || !tableNode->hasTagName(tableTag))
return false;
// if there is a caption element, summary, THEAD, or TFOOT section, it's most certainly a data table
HTMLTableElement* tableElement = static_cast<HTMLTableElement*>(tableNode);
if (!tableElement->summary().isEmpty() || tableElement->tHead() || tableElement->tFoot() || tableElement->caption())
return true;
// if someone used "rules" attribute than the table should appear
if (!tableElement->rules().isEmpty())
return true;
// go through the cell's and check for tell-tale signs of "data" table status
// cells have borders, or use attributes like headers, abbr, scope or axis
RenderTableSection* firstBody = table->firstBody();
if (!firstBody)
return false;
int numCols = firstBody->numColumns();
int numRows = firstBody->numRows();
// if there's only one cell, it's not a good AXTable candidate
if (numRows == 1 && numCols == 1)
return false;
// store the background color of the table to check against cell's background colors
RenderStyle* tableStyle = table->style();
if (!tableStyle)
return false;
Color tableBGColor = tableStyle->visitedDependentColor(CSSPropertyBackgroundColor);
// check enough of the cells to find if the table matches our criteria
// Criteria:
// 1) must have at least one valid cell (and)
// 2) at least half of cells have borders (or)
// 3) at least half of cells have different bg colors than the table, and there is cell spacing
unsigned validCellCount = 0;
unsigned borderedCellCount = 0;
unsigned backgroundDifferenceCellCount = 0;
Color alternatingRowColors[5];
int alternatingRowColorCount = 0;
int headersInFirstColumnCount = 0;
for (int row = 0; row < numRows; ++row) {
int headersInFirstRowCount = 0;
for (int col = 0; col < numCols; ++col) {
RenderTableCell* cell = firstBody->primaryCellAt(row, col);
if (!cell)
continue;
Node* cellNode = cell->node();
if (!cellNode)
continue;
if (cell->width() < 1 || cell->height() < 1)
continue;
validCellCount++;
HTMLTableCellElement* cellElement = static_cast<HTMLTableCellElement*>(cellNode);
bool isTHCell = cellElement->hasTagName(thTag);
// If the first row is comprised of all <th> tags, assume it is a data table.
if (!row && isTHCell)
headersInFirstRowCount++;
// If the first column is comprised of all <tg> tags, assume it is a data table.
if (!col && isTHCell)
headersInFirstColumnCount++;
// in this case, the developer explicitly assigned a "data" table attribute
if (!cellElement->headers().isEmpty() || !cellElement->abbr().isEmpty()
|| !cellElement->axis().isEmpty() || !cellElement->scope().isEmpty())
return true;
RenderStyle* renderStyle = cell->style();
if (!renderStyle)
continue;
// a cell needs to have matching bordered sides, before it can be considered a bordered cell.
if ((cell->borderTop() > 0 && cell->borderBottom() > 0)
|| (cell->borderLeft() > 0 && cell->borderRight() > 0))
borderedCellCount++;
// if the cell has a different color from the table and there is cell spacing,
// then it is probably a data table cell (spacing and colors take the place of borders)
Color cellColor = renderStyle->visitedDependentColor(CSSPropertyBackgroundColor);
if (table->hBorderSpacing() > 0 && table->vBorderSpacing() > 0
&& tableBGColor != cellColor && cellColor.alpha() != 1)
backgroundDifferenceCellCount++;
// if we've found 10 "good" cells, we don't need to keep searching
if (borderedCellCount >= 10 || backgroundDifferenceCellCount >= 10)
return true;
// For the first 5 rows, cache the background color so we can check if this table has zebra-striped rows.
if (row < 5 && row == alternatingRowColorCount) {
RenderObject* renderRow = cell->parent();
if (!renderRow || !renderRow->isBoxModelObject() || !toRenderBoxModelObject(renderRow)->isTableRow())
continue;
RenderStyle* rowRenderStyle = renderRow->style();
if (!rowRenderStyle)
continue;
Color rowColor = rowRenderStyle->visitedDependentColor(CSSPropertyBackgroundColor);
alternatingRowColors[alternatingRowColorCount] = rowColor;
alternatingRowColorCount++;
}
}
if (!row && headersInFirstRowCount == numCols && numCols > 1)
return true;
}
if (headersInFirstColumnCount == numRows && numRows > 1)
return true;
// if there is less than two valid cells, it's not a data table
if (validCellCount <= 1)
return false;
// half of the cells had borders, it's a data table
unsigned neededCellCount = validCellCount / 2;
if (borderedCellCount >= neededCellCount)
return true;
// half had different background colors, it's a data table
if (backgroundDifferenceCellCount >= neededCellCount)
return true;
// Check if there is an alternating row background color indicating a zebra striped style pattern.
if (alternatingRowColorCount > 2) {
Color firstColor = alternatingRowColors[0];
for (int k = 1; k < alternatingRowColorCount; k++) {
// If an odd row was the same color as the first row, its not alternating.
if (k % 2 == 1 && alternatingRowColors[k] == firstColor)
return false;
// If an even row is not the same as the first row, its not alternating.
if (!(k % 2) && alternatingRowColors[k] != firstColor)
return false;
}
return true;
}
return false;
}
Color Color::blend(const Color& source) const
{
if (!alpha() || !source.hasAlpha())
return source;
if (!source.alpha())
return *this;
int d = 255 * (alpha() + source.alpha()) - alpha() * source.alpha();
int a = d / 255;
int r = (red() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.red()) / d;
int g = (green() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.green()) / d;
int b = (blue() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.blue()) / d;
return Color(r, g, b, a);
}
Color Renderer::rayTraceRecursive(Shape* scene, Ray& ray, Lights& lights, int maxReflect) {
IntersectResult result;
scene->Intersect(ray, &result);
if (result.geometry) {
Material* pMaterial = result.geometry->material;
float reflectiveness = pMaterial->reflectiveness;
Color color(0, 0, 0);
std::mt19937 eng(4029349);
std::uniform_real_distribution<float> fraction_dist;
for (int i = 0; i < lights.size(); i++) {
Light* pLight = lights[i];
Color c;
if (!pLight->shadow) {
//no shadow
Vector3dF incidenceNormal = pLight->incidenceNormal(result.position);
c = pMaterial->Sample(ray, result.position, result.normal, incidenceNormal);
} else if (pLight->softshadow) {
Vector3dF incidenceCenter = pLight->incidence(result.position);
Vector3dF incidenceNormal = incidenceCenter.Normalize();
Vector3dF rayNormal(-incidenceCenter.y, incidenceCenter.x, 0);
rayNormal = rayNormal.Normalize();
float disToLight = 0;
if (pLight->lightType == LightType_Point) {
disToLight = (dynamic_cast<PointLight*>(pLight)->pos - result.position).Length();
}
int hitTimes = 0;
int raysPerFan = pLight->shadowrays / 4;
for (int quadrant = 0; quadrant < 4; quadrant++) {
for (int r = 0; r < raysPerFan; r++) {
float angle = quadrant * 90.0f + fraction_dist(eng) * 90.f;
float dis = fraction_dist(eng) * pLight->radius;
//printf("<%.1f, %.1f> ", angle, dis);
Vector3dF d = rayNormal.rotate(incidenceNormal, PI * angle / 180.f);
Ray shadowrays(result.position, (-incidenceCenter) + d * dis);
shadowrays.d = shadowrays.d.Normalize();
IntersectResult _result;
scene->Intersect(shadowrays, &_result);
if (_result.geometry) {
if (disToLight && _result.distance >= disToLight) {
continue;
}
hitTimes++;
}
}
//printf("\n");
}
//printf("\n");
c = pMaterial->Sample(ray, result.position, result.normal, incidenceNormal);
if (hitTimes > 0) {
//printf("%d\n", hitTimes);
float black_ratio = hitTimes / (float)pLight->shadowrays;
//c = c * ( 1.0f - black_ratio) + Color::Black * black_ratio;
c = c.Modulate(Color::White * (1.0f - black_ratio));
c = c.clamp();
}
}
else {
//normal shadow
Vector3dF incidenceNormal = pLight->incidenceNormal(result.position);
//Is this light visible
Ray shadowrays(result.position, -incidenceNormal);
IntersectResult _result;
scene->Intersect(shadowrays, &_result);
bool canSample = true;
if (_result.geometry) {
if (pLight->lightType == LightType_Point) {
float disToLight = (dynamic_cast<PointLight*>(pLight)->pos - result.position).Length();
if (disToLight >= _result.distance) {
canSample = false;
c = Color::Black;
}
}
else if (pLight->lightType == LightType_Direction) {
canSample = false;
c = Color::Black;
}
}
if(canSample){
c = pMaterial->Sample(ray, result.position, result.normal, incidenceNormal);
}
}
color = color + c;
}
color = Color(color * (1.0f - reflectiveness));
if (reflectiveness > 0 && maxReflect > 0) {
Vector3dF r = Vector3dF(result.normal * (-2 * (result.normal.Dot(ray.d))) + ray.d);
Ray new_ray(result.position, r);
Color reflectedColor = rayTraceRecursive(scene, new_ray, lights, maxReflect - 1);
assert(reflectedColor.r() >= 0 && reflectedColor.g() >= 0 && reflectedColor.b() >= 0);
color = color + reflectedColor * reflectiveness;
}
return color;
}
else
return Color::Black;
}
Color Color::inverted() const {
Color c = *this;
c.invert();
return c;
}
int main() {
outPut[0]="scene1.test";
outPut[1]="scene1-camera1.test";
outPut[2]="scene1-camera2.test";
outPut[3]="scene1-camera3.test";
outPut[4]="scene1-camera4.test";
outPut[5]="scene2-camera1.test";
outPut[6]="scene2-camera2.test";
outPut[7]="scene2-camera3.test";
outPut[8]="scene3.test";
outPut[9]="self.test";
outPut[10]="spheres.test";
outPut[11]="self1.test";
outPut[12]="spheres2.test";
outPut[13]="spheres3.test";
outPut[14]="scene3-2.test";
outPut[15]="self2.test";
outPut[16]="self3.test";
outPut[17]="self4.test";
outPut[18]="self2-1.test";
outPut[19]="self2-2.test";
outPut[20]="self4-2.test";
outPut[21]="self4-3.test";
outPut[22]="spheres4.test";
outPut[23]="self4-4.test";
outPut[24]="self4-5.test";
outPut[25]="self4-6.test";
outPut[26]="self2-3.test";
outPut[27]="self3-1.test";
outPut[28]="scene1-4.test";
outPut[29]="spheres4-1.test";
outPut[30]="spheres4-2.test";
outPut[31]="spheres4-3.test";
outPut[32]="spheres4-4.test";
outPut[33]="spheres4-5.test";
for (int names=0; names<TESTS; names++){
Film myImage;
Camera myCamera;
vector<Primitive> myPrimitives(1, Primitive());
vector<Triangle> myTriangles(1, Triangle());
Parser myParser;
Sample currSample(0,0);
Sampler mySampler;
RayTracer myTracer;
Ray currRay(vec3(0,0,0), vec3(0,0,0), vec3(0,0,0));
Color currColor;
inputfile.open(outPut[names].c_str());
int *x,*y;
x =(int*) malloc(sizeof(int));
y =(int*) malloc(sizeof(int));
myParser.initialparse(inputfile, x, y);
myCamera.SetAspect(x, y);
myImage.SetFilm(*x,*y);
myImage.InitializeFilm();
mySampler.SetSamplerSize(*x, *y);
myParser.parsefile(inputfile, &myCamera, &myTracer, &maxDepth);
myTracer.SetDepth(maxDepth);
cout<<"maxDepth: "<<maxDepth<<endl;
assert(maxDepth>=2);
while(mySampler.GetSample(&currSample)){
currColor.SetColor(0.0,0.0,0.0); // reset currColor to 0 every time
myCamera.GenerateRay(currSample,&currRay);
myTracer.traceRay(&currRay, 0, &currColor);
myImage.Commit(currSample, currColor);
}
myImage.WriteImage(outPut[names]);
inputfile.close();
delete x;
delete y;
cout << "finished " << outPut[names] << endl;
}
cout << "finished everything" << endl;
return 0;
}
bool AccessibilityTable::isTableExposableThroughAccessibility()
{
// the following is a heuristic used to determine if a
// <table> should be exposed as an AXTable. The goal
// is to only show "data" tables
if (!m_renderer || !m_renderer->isTable())
return false;
// if the developer assigned an aria role to this, then we shouldn't
// expose it as a table, unless, of course, the aria role is a table
AccessibilityRole ariaRole = ariaRoleAttribute();
if (ariaRole == TableRole)
return true;
if (ariaRole != UnknownRole)
return false;
RenderTable* table = static_cast<RenderTable*>(m_renderer);
// this employs a heuristic to determine if this table should appear.
// Only "data" tables should be exposed as tables.
// Unfortunately, there is no good way to determine the difference
// between a "layout" table and a "data" table
Node* tableNode = table->element();
if (!tableNode || !tableNode->hasTagName(tableTag))
return false;
// if there is a caption element, summary, THEAD, or TFOOT section, it's most certainly a data table
HTMLTableElement* tableElement = static_cast<HTMLTableElement*>(tableNode);
if (!tableElement->summary().isEmpty() || tableElement->tHead() || tableElement->tFoot() || tableElement->caption())
return true;
// if someone used "rules" attribute than the table should appear
if (!tableElement->rules().isEmpty())
return true;
// go through the cell's and check for tell-tale signs of "data" table status
// cells have borders, or use attributes like headers, abbr, scope or axis
RenderTableSection* firstBody = table->firstBody();
if (!firstBody)
return false;
int numCols = firstBody->numColumns();
int numRows = firstBody->numRows();
// if there's only one cell, it's not a good AXTable candidate
if (numRows == 1 && numCols == 1)
return false;
// store the background color of the table to check against cell's background colors
RenderStyle* tableStyle = table->style();
if (!tableStyle)
return false;
Color tableBGColor = tableStyle->backgroundColor();
// check enough of the cells to find if the table matches our criteria
// Criteria:
// 1) must have at least one valid cell (and)
// 2) at least half of cells have borders (or)
// 3) at least half of cells have different bg colors than the table, and there is cell spacing
unsigned validCellCount = 0;
unsigned borderedCellCount = 0;
unsigned backgroundDifferenceCellCount = 0;
for (int row = 0; row < numRows; ++row) {
for (int col = 0; col < numCols; ++col) {
RenderTableCell* cell = firstBody->cellAt(row, col).cell;
if (!cell)
continue;
Node* cellNode = cell->element();
if (!cellNode)
continue;
if (cell->width() < 1 || cell->height() < 1)
continue;
validCellCount++;
HTMLTableCellElement* cellElement = static_cast<HTMLTableCellElement*>(cellNode);
// in this case, the developer explicitly assigned a "data" table attribute
if (!cellElement->headers().isEmpty() || !cellElement->abbr().isEmpty() ||
!cellElement->axis().isEmpty() || !cellElement->scope().isEmpty())
return true;
RenderStyle* renderStyle = cell->style();
if (!renderStyle)
continue;
// a cell needs to have matching bordered sides, before it can be considered a bordered cell.
if ((cell->borderTop() > 0 && cell->borderBottom() > 0) ||
(cell->borderLeft() > 0 && cell->borderRight() > 0))
borderedCellCount++;
// if the cell has a different color from the table and there is cell spacing,
// then it is probably a data table cell (spacing and colors take the place of borders)
Color cellColor = renderStyle->backgroundColor();
if (table->hBorderSpacing() > 0 && table->vBorderSpacing() > 0 &&
tableBGColor != cellColor && cellColor.alpha() != 1)
backgroundDifferenceCellCount++;
// if we've found 10 "good" cells, we don't need to keep searching
if (borderedCellCount >= 10 || backgroundDifferenceCellCount >= 10)
return true;
}
}
// if there is less than two valid cells, it's not a data table
if (validCellCount <= 1)
return false;
// half of the cells had borders, it's a data table
unsigned neededCellCount = validCellCount / 2;
if (borderedCellCount >= neededCellCount)
return true;
// half had different background colors, it's a data table
if (backgroundDifferenceCellCount >= neededCellCount)
return true;
return false;
}
Color ColorDistance::addColors(const Color& first, const Color& second)
{
return Color(first.red() + second.red(), first.green() + second.green(), first.blue() + second.blue());
}