void GlyphPageTreeNode::initializePage(const FontData* fontData, unsigned pageNumber)
{
ASSERT(!m_page);
// This function must not be called for the root of the tree, because that
// level does not contain any glyphs.
ASSERT(m_level > 0 && m_parent);
// The parent's page will be 0 if we are level one or the parent's font data
// did not contain any glyphs for that page.
GlyphPage* parentPage = m_parent->page();
// NULL FontData means we're being asked for the system fallback font.
if (fontData) {
if (m_level == 1) {
// Children of the root hold pure pages. These will cover only one
// font data's glyphs, and will have glyph index 0 if the font data does not
// contain the glyph.
unsigned start = pageNumber * GlyphPage::size;
UChar buffer[GlyphPage::size * 2 + 2];
unsigned bufferLength;
unsigned i;
// Fill in a buffer with the entire "page" of characters that we want to look up glyphs for.
if (start < 0x10000) {
bufferLength = GlyphPage::size;
for (i = 0; i < GlyphPage::size; i++)
buffer[i] = start + i;
if (start == 0) {
// Control characters must not render at all.
for (i = 0; i < 0x20; ++i)
buffer[i] = zeroWidthSpace;
for (i = 0x7F; i < 0xA0; i++)
buffer[i] = zeroWidthSpace;
buffer[softHyphen] = zeroWidthSpace;
// \n, \t, and nonbreaking space must render as a space.
buffer[(int)'\n'] = ' ';
buffer[(int)'\t'] = ' ';
buffer[noBreakSpace] = ' ';
} else if (start == (leftToRightMark & ~(GlyphPage::size - 1))) {
// LRM, RLM, LRE, RLE, ZWNJ, ZWJ, and PDF must not render at all.
buffer[leftToRightMark - start] = zeroWidthSpace;
buffer[rightToLeftMark - start] = zeroWidthSpace;
buffer[leftToRightEmbed - start] = zeroWidthSpace;
buffer[rightToLeftEmbed - start] = zeroWidthSpace;
buffer[leftToRightOverride - start] = zeroWidthSpace;
buffer[rightToLeftOverride - start] = zeroWidthSpace;
buffer[zeroWidthNonJoiner - start] = zeroWidthSpace;
buffer[zeroWidthJoiner - start] = zeroWidthSpace;
buffer[popDirectionalFormatting - start] = zeroWidthSpace;
} else if (start == (objectReplacementCharacter & ~(GlyphPage::size - 1))) {
// Object replacement character must not render at all.
buffer[objectReplacementCharacter - start] = zeroWidthSpace;
} else if (start == (zeroWidthNoBreakSpace & ~(GlyphPage::size - 1))) {
// ZWNBS/BOM must not render at all.
buffer[zeroWidthNoBreakSpace - start] = zeroWidthSpace;
}
} else {
bufferLength = GlyphPage::size * 2;
for (i = 0; i < GlyphPage::size; i++) {
int c = i + start;
buffer[i * 2] = U16_LEAD(c);
buffer[i * 2 + 1] = U16_TRAIL(c);
}
}
// Now that we have a buffer full of characters, we want to get back an array
// of glyph indices. This part involves calling into the platform-specific
// routine of our glyph map for actually filling in the page with the glyphs.
// Success is not guaranteed. For example, Times fails to fill page 260, giving glyph data
// for only 128 out of 256 characters.
bool haveGlyphs;
if (!fontData->isSegmented()) {
if (GlyphPage::mayUseMixedFontDataWhenFilling(buffer, bufferLength, static_cast<const SimpleFontData*>(fontData)))
m_page = GlyphPage::createForMixedFontData(this);
else
m_page = GlyphPage::createForSingleFontData(this, static_cast<const SimpleFontData*>(fontData));
#if PLATFORM(IOS)
// FIXME: Times New Roman contains Arabic glyphs, but Core Text doesn't know how to shape them. See <rdar://problem/9823975>.
// Once we have the fix for <rdar://problem/9823975> then remove this code together with SimpleFontData::shouldNotBeUsedForArabic()
// in <rdar://problem/12096835>.
if (pageNumber == 6 && static_cast<const SimpleFontData*>(fontData)->shouldNotBeUsedForArabic())
haveGlyphs = false;
else
#endif
haveGlyphs = fill(m_page.get(), 0, GlyphPage::size, buffer, bufferLength, static_cast<const SimpleFontData*>(fontData));
} else {
m_page = GlyphPage::createForMixedFontData(this);
haveGlyphs = false;
const SegmentedFontData* segmentedFontData = static_cast<const SegmentedFontData*>(fontData);
unsigned numRanges = segmentedFontData->numRanges();
bool zeroFilled = false;
RefPtr<GlyphPage> scratchPage;
GlyphPage* pageToFill = m_page.get();
for (unsigned i = 0; i < numRanges; i++) {
const FontDataRange& range = segmentedFontData->rangeAt(i);
// all this casting is to ensure all the parameters to min and max have the same type,
// to avoid ambiguous template parameter errors on Windows
int from = std::max(0, static_cast<int>(range.from()) - static_cast<int>(start));
int to = 1 + std::min(static_cast<int>(range.to()) - static_cast<int>(start), static_cast<int>(GlyphPage::size) - 1);
if (from < static_cast<int>(GlyphPage::size) && to > 0) {
if (haveGlyphs && !scratchPage) {
scratchPage = GlyphPage::createForMixedFontData(this);
pageToFill = scratchPage.get();
}
if (!zeroFilled) {
if (from > 0 || to < static_cast<int>(GlyphPage::size)) {
for (unsigned i = 0; i < GlyphPage::size; i++)
pageToFill->setGlyphDataForIndex(i, 0, 0);
}
zeroFilled = true;
}
haveGlyphs |= fill(pageToFill, from, to - from, buffer + from * (start < 0x10000 ? 1 : 2), (to - from) * (start < 0x10000 ? 1 : 2), range.fontData().get());
if (scratchPage) {
ASSERT_WITH_SECURITY_IMPLICATION(to <= static_cast<int>(GlyphPage::size));
for (int j = from; j < to; j++) {
if (!m_page->glyphAt(j) && pageToFill->glyphAt(j))
m_page->setGlyphDataForIndex(j, pageToFill->glyphDataForIndex(j));
}
}
}
}
}
if (!haveGlyphs)
m_page = 0;
} else if (parentPage && parentPage->owner() != m_parent) {
// The page we're overriding may not be owned by our parent node.
// This happens when our parent node provides no useful overrides
// and just copies the pointer to an already-existing page (see
// below).
//
// We want our override to be shared by all nodes that reference
// that page to avoid duplication, and so standardize on having the
// page's owner collect all the overrides. Call getChild on the
// page owner with the desired font data (this will populate
// the page) and then reference it.
m_page = parentPage->owner()->getChild(fontData, pageNumber)->page();
} else {
// Get the pure page for the fallback font (at level 1 with no
// overrides). getRootChild will always create a page if one
// doesn't exist, but the page doesn't necessarily have glyphs
// (this pointer may be 0).
GlyphPage* fallbackPage = getRootChild(fontData, pageNumber)->page();
if (!parentPage) {
// When the parent has no glyphs for this page, we can easily
// override it just by supplying the glyphs from our font.
m_page = fallbackPage;
} else if (!fallbackPage) {
// When our font has no glyphs for this page, we can just reference the
// parent page.
m_page = parentPage;
} else {
// Combine the parent's glyphs and ours to form a new more complete page.
m_page = GlyphPage::createForMixedFontData(this);
// Overlay the parent page on the fallback page. Check if the fallback font
// has added anything.
bool newGlyphs = false;
for (unsigned i = 0; i < GlyphPage::size; i++) {
if (parentPage->glyphAt(i))
m_page->setGlyphDataForIndex(i, parentPage->glyphDataForIndex(i));
else if (fallbackPage->glyphAt(i)) {
m_page->setGlyphDataForIndex(i, fallbackPage->glyphDataForIndex(i));
newGlyphs = true;
} else
m_page->setGlyphDataForIndex(i, 0, 0);
}
if (!newGlyphs)
// We didn't override anything, so our override is just the parent page.
m_page = parentPage;
}
}
} else {
// System fallback. Initialized with the parent's page here, as individual
// entries may use different fonts depending on character. If the Font
// ever finds it needs a glyph out of the system fallback page, it will
// ask the system for the best font to use and fill that glyph in for us.
if (parentPage)
m_page = parentPage->createCopiedSystemFallbackPage(this);
else
m_page = GlyphPage::createForMixedFontData(this);
}
}
static void* data_thread(void *vptr) {
struct tree_t* tree = vptr;
struct data_pack dpack;
FILE* fp = fopen (media_file, "rb");
struct alpha_queue *socks;
socks = alpha_queue_new();
if (NULL == fp) {
print_error ("error opening media file");
return NULL;
}
dpack.seqnum = 1;
for (;;) {
size_t amount = fread (dpack.data, 1, EU_PACKETLEN - sizeof (uint64_t), fp);
if (0 == amount) {
print_error ("end of file..?");
return NULL;
}
while (0 == countRootChildren(tree)) {
sleep(1); // Temporary to allow setup for tests
// do nothing.
}
uint64_t i;
for (i = 0; i < countRootChildren(tree); i++) {
struct peer_info *pi = getRootChild (tree, i);
if (NULL == pi)
break;
struct eu_socket *sock = alpha_queue_pop (socks);
if (NULL == sock) {
sock = eu_socket (EU_PUSH);
if (NULL == sock) {
print_error ("no more easy socks?");
return NULL;
}
}
if (eu_connect (sock, pi->addr, pi->port)) {
print_error ("couldn't connect??");
return NULL;
}
int rc = eu_send (sock, &dpack, amount + sizeof (uint64_t), 0);
if (rc != (amount + sizeof (uint64_t))) {
if (rc == -2)
{
int prremove = removePeer (tree, pi->pid);
if (prremove != 0) {
switch (prremove) {
case -1:
print_error ("Memory Error in removing peer\n");
break;
}
}
printTree (tree);
}
print_error ("couldn't send full packet :/");
return NULL;
}
alpha_queue_push (socks, sock);
usleep(200);
}
dpack.seqnum++;
}
}
