2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/include/graphite/GrCommon.h Thu Jan 22 00:36:40 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/include/graphite/GrCommon.h Sat Aug 22 19:36:32 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -18,6 +18,8 @@
|
|
|
|
#ifndef GRCOMMON_INCLUDED
|
|
|
|
#define GRCOMMON_INCLUDED
|
|
|
|
|
|
|
|
+#define _SECURE_SCL 0 // to allow GlyphSetIterator to work, which points off the end of a vector
|
|
|
|
+#define _HAS_ITERATOR_DEBUGGING 0
|
|
|
|
|
|
|
|
// Standard Headers.
|
|
|
|
|
|
|
|
@@ -33,6 +35,7 @@
|
|
|
|
#include <vector>
|
|
|
|
#include <algorithm>
|
|
|
|
#include <string>
|
|
|
|
+///#include <stdexcept> -- possibly needed for std::string Xran and Xlen functions??
|
|
|
|
|
|
|
|
// Uncomment this to allow multiple versions of gr to coexist
|
|
|
|
// in the same program e.g. pangographite with gtk uses namespace gr
|
|
|
|
@@ -41,7 +44,7 @@
|
|
|
|
// Provided the client includes GrClient.h first this #define is
|
|
|
|
// picked up by all files.
|
|
|
|
|
|
|
|
-//#define gr gr2
|
|
|
|
+#define gr gr3ooo
|
|
|
|
|
|
|
|
// Project headers
|
|
|
|
#include "GrPlatform.h"
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/include/graphite/GrMstypes.h Thu Jan 22 00:36:40 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/include/graphite/GrMstypes.h Sat Aug 22 19:36:32 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -24,11 +24,11 @@
|
|
|
|
|
|
|
|
typedef signed long HRESULT;
|
|
|
|
|
|
|
|
-inline const long InterlockedIncrement(long *const intr_lck) {
|
|
|
|
+inline long InterlockedIncrement(long *const intr_lck) {
|
|
|
|
return ++*intr_lck;
|
|
|
|
}
|
|
|
|
|
|
|
|
-inline const long InterlockedDecrement(long *const intr_lck) {
|
|
|
|
+inline long InterlockedDecrement(long *const intr_lck) {
|
|
|
|
return --*intr_lck;
|
|
|
|
}
|
|
|
|
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/makefile.vc7 Thu Aug 21 16:24:32 2008
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/makefile.vc7 Sat Aug 22 19:36:32 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -48,11 +48,7 @@
|
|
|
|
CPP_DEBUG=/D "TRACING" $(CPP_DEBUG)
|
|
|
|
!ENDIF
|
|
|
|
|
|
|
|
-!IF "$(OS)" == "Windows_NT"
|
|
|
|
NULL=
|
|
|
|
-!ELSE
|
|
|
|
-NULL=nul
|
|
|
|
-!ENDIF
|
|
|
|
|
|
|
|
clean :
|
|
|
|
@- rd /s/q .\release_temp
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/makefile.vc8 Sat Aug 22 21:58:25 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/makefile.vc8 Sat Aug 22 21:57:42 2009
|
|
|
|
@@ -2,11 +2,16 @@
|
|
|
|
TARGET=graphite
|
|
|
|
|
|
|
|
CPP=cl.exe
|
|
|
|
-CPPFLAGS=/Zc:wchar_t- /nologo /W4 /GR /EHsc /I "./src/font" /I "./src/painter" /I "./src/segment" /I "./src/textsource" /I "./src/generic" /I "./include/graphite" /I "../wrappers/win32" /D "GR_NAMESPACE" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /D "TRACING" /Fp"$(INTDIR)\graphite.pch" /Fd"$(INTDIR)\\" /FD /c
|
|
|
|
+### HDU: disabled building with the normal compile flags
|
|
|
|
+###CPPFLAGS= /Zc:wchar_t- /nologo /W4 /GR /EHsc /I "./src/font" /I "./src/painter" /I "./src/segment" /I "./src/textsource" /I "./src/generic" /I "./include/graphite" /I "../wrappers/win32" /D "GR_NAMESPACE" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /D "TRACING" /Fp"$(INTDIR)\graphite.pch" /Fd"$(INTDIR)\\" /FD /c
|
|
|
|
+### HDU: because for full binary compatibility with the rest of OOo all compile flags must match exactly
|
|
|
|
+### which is especially true for template-heavy C++ code with non-default config (e.g. _STLP_DEBUG enabled)
|
|
|
|
+CPPFLAGS= $(CFLAGS4MSC) /nologo /W4 /I "./src/font" /I "./src/painter" /I "./src/segment" /I "./src/textsource" /I "./src/generic" /I "./include/graphite" /I "../wrappers/win32" /D "GR_NAMESPACE" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /D "TRACING" /Fp"$(INTDIR)\graphite.pch" /Fd"$(INTDIR)\\" /FD /c
|
|
|
|
+
|
2009-08-17 09:12:14 -05:00
|
|
|
# /Wp62
|
|
|
|
|
|
|
|
LINK=link.exe
|
|
|
|
-LINK_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /dll /pdb:"$(OUTDIR)\\graphite.pdb" /machine:I386 /out:"$(OUTDIR)\\$(TARGET).dll" /implib:"$(OUTDIR)\\$(TARGET).lib"
|
|
|
|
+LINK_FLAGS=$(ADDLIBS) kernel32.lib user32.lib gdi32.lib winspool.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /dll /pdb:"$(OUTDIR)\\graphite.pdb" /machine:I386 /out:"$(OUTDIR)\\$(TARGET).dll" /implib:"$(OUTDIR)\\$(TARGET).lib"
|
|
|
|
|
|
|
|
BSC32=bscmake.exe
|
|
|
|
BSC32_FLAGS=/nologo /o"$(OUTDIR)\\$(TARGET).bsc"
|
2009-08-24 03:32:29 -05:00
|
|
|
@@ -48,11 +52,7 @@
|
2009-08-17 09:12:14 -05:00
|
|
|
CPP_DEBUG=/D "TRACING" $(CPP_DEBUG)
|
|
|
|
!ENDIF
|
|
|
|
|
|
|
|
-!IF "$(OS)" == "Windows_NT"
|
|
|
|
NULL=
|
|
|
|
-!ELSE
|
|
|
|
-NULL=nul
|
|
|
|
-!ENDIF
|
|
|
|
|
|
|
|
clean :
|
|
|
|
@- rd /s/q .\release_temp
|
2009-08-24 03:32:29 -05:00
|
|
|
@@ -779,7 +779,7 @@
|
|
|
|
@- $(CPP) $(CPPFLAGS) $(CPP_DEBUG) /Fo"$(INTDIR)\FileFont$(OBJEXT)" $?
|
|
|
|
|
|
|
|
"$(INTDIR)\FileFont_dll$(OBJEXT)" : "src/font/FileFont.cpp"
|
|
|
|
- @- $(CPP) $(CPPFLAGS) /D "_DLL" /Fo"$(INTDIR)\FileFont_dll$(OBJEXT)" $?
|
|
|
|
+ $(CPP) $(CPPFLAGS) /D "_DLL" /Fo"$(INTDIR)\FileFont_dll$(OBJEXT)" $?
|
|
|
|
|
|
|
|
!ENDIF
|
|
|
|
|
|
|
|
--- misc/silgraphite-2.3.1/engine/src/font/FileFont.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/font/FileFont.cpp Sat Aug 22 19:36:32 2009
|
|
|
|
@@ -207,11 +207,11 @@
|
|
|
|
cch16 += cch16Used;
|
|
|
|
}
|
|
|
|
// }
|
|
|
|
-#else
|
|
|
|
+#elif 1
|
|
|
|
m_stuFaceName.assign(rgchwFace);
|
|
|
|
- // VS 2005 needs this:
|
|
|
|
- //for (int cch16 = 0; cch16 < cchw; cch16++)
|
|
|
|
- // m_stuFaceName.push_back(rgchwFace[cch16]);
|
|
|
|
+#else // VS 2005 needs this:
|
|
|
|
+ for (int cch16 = 0; cch16 < cchw; cch16++)
|
|
|
|
+ m_stuFaceName.push_back(rgchwFace[cch16]);
|
|
|
|
#endif
|
|
|
|
pTable = readTable(ktiHead, lSize);
|
|
|
|
if (!m_fIsValid || !pTable)
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -233,7 +233,7 @@
|
|
|
|
FileFont::readTable(int /*TableId*/ tid, size_t & size)
|
|
|
|
{
|
|
|
|
const TableId tableId = TableId(tid);
|
|
|
|
- bool isValid = true;
|
|
|
|
+ bool isTableValid = true;
|
|
|
|
size_t lOffset = 0, lSize = 0;
|
|
|
|
if (!m_pTableCache)
|
|
|
|
{
|
|
|
|
@@ -245,9 +245,9 @@
|
|
|
|
size = m_pTableCache->getTableSize(tableId);
|
|
|
|
// check whether it is already in the cache
|
|
|
|
if (pTable) return pTable;
|
|
|
|
- isValid &= TtfUtil::GetTableInfo(tableId, m_pHeader, m_pTableDir,
|
|
|
|
+ isTableValid &= TtfUtil::GetTableInfo(tableId, m_pHeader, m_pTableDir,
|
|
|
|
lOffset, lSize);
|
|
|
|
- if (!isValid)
|
|
|
|
+ if (!isTableValid)
|
|
|
|
return NULL;
|
|
|
|
fseek(m_pfile, lOffset, SEEK_SET);
|
|
|
|
// only allocate if needed
|
|
|
|
@@ -255,16 +255,16 @@
|
|
|
|
|
|
|
|
if (!pTable)
|
|
|
|
{
|
|
|
|
- isValid = false;
|
|
|
|
+ isTableValid = false;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
size_t bytesRead = fread(pTable, 1, lSize, m_pfile);
|
|
|
|
- isValid = bytesRead == lSize;
|
|
|
|
- if (isValid)
|
|
|
|
+ isTableValid = bytesRead == lSize;
|
|
|
|
+ if (isTableValid)
|
|
|
|
{
|
|
|
|
- isValid &= TtfUtil::CheckTable(tableId, pTable, lSize);
|
|
|
|
+ isTableValid &= TtfUtil::CheckTable(tableId, pTable, lSize);
|
|
|
|
}
|
|
|
|
- if (!isValid)
|
|
|
|
+ if (!isTableValid)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/font/Font.cpp Tue May 20 08:04:16 2008
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/font/Font.cpp Sat Aug 22 19:36:33 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -626,7 +626,7 @@
|
|
|
|
Assert(false);
|
|
|
|
m_ifeat = m_cfeat;
|
|
|
|
}
|
|
|
|
- else if (m_ifeat + n < 0)
|
|
|
|
+ else if (static_cast<int>(m_ifeat) + n < 0)
|
|
|
|
{
|
|
|
|
// Can't decrement.
|
|
|
|
Assert(false);
|
|
|
|
@@ -727,7 +727,7 @@
|
|
|
|
Assert(false);
|
|
|
|
m_ifset = m_cfset;
|
|
|
|
}
|
|
|
|
- if (m_ifset + n < 0)
|
|
|
|
+ if (static_cast<int>(m_ifset) + n < 0)
|
|
|
|
{
|
|
|
|
// Can't decrement.
|
|
|
|
Assert(false);
|
|
|
|
@@ -820,7 +820,7 @@
|
|
|
|
Assert(false);
|
|
|
|
m_ilang = m_clang;
|
|
|
|
}
|
|
|
|
- else if (m_ilang + n < 0)
|
|
|
|
+ else if (static_cast<int>(m_ilang) + n < 0)
|
|
|
|
{
|
|
|
|
// Can't decrement.
|
|
|
|
Assert(false);
|
|
|
|
@@ -906,7 +906,7 @@
|
|
|
|
Assert(false);
|
|
|
|
m_ilang = m_clang;
|
|
|
|
}
|
|
|
|
- else if (m_ilang + n < 0)
|
|
|
|
+ else if (static_cast<int>(m_ilang) + n < 0)
|
|
|
|
{
|
|
|
|
// Can't decrement.
|
|
|
|
Assert(false);
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/font/TtfUtil.cpp Thu Jan 29 10:33:19 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/font/TtfUtil.cpp Sat Aug 22 19:36:33 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -492,7 +492,7 @@
|
|
|
|
const Sfnt::FontHeader * pTable =
|
|
|
|
reinterpret_cast<const Sfnt::FontHeader *>(pHead);
|
|
|
|
|
|
|
|
- return read(((pTable->mac_style) & 0x00000002) != 0);
|
|
|
|
+ return ((read(pTable->mac_style) & 0x00000002) != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
@@ -1108,8 +1108,8 @@
|
|
|
|
{ // loca entries are two bytes and have been divided by two
|
|
|
|
if (nGlyphId <= (lLocaSize >> 1) - 1) // allow sentinel value to be accessed
|
|
|
|
{
|
|
|
|
- const uint16 * pTable = reinterpret_cast<const uint16 *>(pLoca);
|
|
|
|
- return (read(pTable[nGlyphId]) << 1);
|
|
|
|
+ const uint16 * pTableLoca = reinterpret_cast<const uint16 *>(pLoca);
|
|
|
|
+ return (read(pTableLoca[nGlyphId]) << 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -1117,8 +1117,8 @@
|
|
|
|
{ // loca entries are four bytes
|
|
|
|
if (nGlyphId <= (lLocaSize >> 2) - 1)
|
|
|
|
{
|
|
|
|
- const uint32 * pTable = reinterpret_cast<const uint32 *>(pLoca);
|
|
|
|
- return read(pTable[nGlyphId]);
|
|
|
|
+ const uint32 * pTableLoca = reinterpret_cast<const uint32 *>(pLoca);
|
|
|
|
+ return read(pTableLoca[nGlyphId]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -1586,7 +1586,7 @@
|
|
|
|
|
|
|
|
for (size_t i = 0; i < cCompId; i++)
|
|
|
|
{
|
|
|
|
- void * pSimpleGlyf = GlyfLookup(static_cast<gr::gid16>(rgnCompId[i]),
|
|
|
|
+ pSimpleGlyf = GlyfLookup(static_cast<gr::gid16>(rgnCompId[i]),
|
|
|
|
pGlyf, pLoca, lLocaSize, pHead);
|
|
|
|
if (pSimpleGlyf == NULL) {return false;}
|
|
|
|
|
|
|
|
@@ -1748,7 +1748,7 @@
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
bool GlyfPoints(gr::gid16 nGlyphId, const void * pGlyf,
|
|
|
|
const void * pLoca, size_t lLocaSize, const void * pHead,
|
|
|
|
- const int * prgnContourEndPoint, size_t cnEndPoints,
|
|
|
|
+ const int * /*prgnContourEndPoint*/, size_t /*cnEndPoints*/,
|
|
|
|
int * prgnX, int * prgnY, bool * prgfOnCurve, size_t cnPoints)
|
|
|
|
{
|
|
|
|
std::fill_n(prgnX, cnPoints, INT_MAX);
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/painter/SegmentPainter.cpp Wed Jan 28 04:01:29 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/painter/SegmentPainter.cpp Sat Aug 22 19:36:33 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -353,7 +353,7 @@
|
|
|
|
@param bOn - true if we are turning on (ignored in this implementation)
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
bool SegmentPainter::drawSelectionRange(int ichwAnchor, int ichwEnd,
|
|
|
|
- float ydLineTop, float ydLineBottom, bool bOn)
|
|
|
|
+ float ydLineTop, float ydLineBottom, bool /*bOn*/)
|
|
|
|
{
|
|
|
|
if (g_fDrawing)
|
|
|
|
return true;
|
|
|
|
@@ -993,7 +993,7 @@
|
|
|
|
an I-beam (std selection)
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void SegmentPainter::CalcOrDrawInsertionPoint(
|
|
|
|
- int ichwIP, bool fAssocPrev, bool bOn, bool fForceSplit,
|
|
|
|
+ int ichwIP, bool fAssocPrev, bool /*bOn*/, bool fForceSplit,
|
|
|
|
Rect * prdPrimary, Rect * prdSecondary)
|
|
|
|
{
|
|
|
|
GrResult res = kresOk;
|
|
|
|
@@ -1277,7 +1277,7 @@
|
|
|
|
if NULL, do the drawing
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void SegmentPainter::InvertIBeam(float xs, float ysTop, float ysBottom,
|
|
|
|
- bool fAssocPrev, Rect * prdRet)
|
|
|
|
+ bool /*fAssocPrev*/, Rect * prdRet)
|
|
|
|
{
|
|
|
|
float xd = ScaleXToDest(xs);
|
|
|
|
float ydTop = ScaleYToDest(ysTop);
|
|
|
|
@@ -1675,7 +1675,7 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SegmentPainter::AtEdgeOfCluster(GrSlotOutput * psloutBase, int isloutBase,
|
|
|
|
- GrSlotOutput * pslout, int islout, bool fBefore)
|
|
|
|
+ GrSlotOutput * /*pslout*/, int islout, bool fBefore)
|
|
|
|
{
|
|
|
|
// Compare pslout to all the members of the cluster. If it is the minimum or maximum, it
|
|
|
|
// is at an edge.
|
|
|
|
@@ -1778,12 +1778,12 @@
|
|
|
|
}
|
|
|
|
for (icomp = 0; icomp < pslout->NumberOfComponents(); icomp++)
|
|
|
|
{
|
|
|
|
- for (int ichw = pslout->FirstUnderlyingComponent(icomp) ;
|
|
|
|
- ichw <= pslout->LastUnderlyingComponent(icomp) ;
|
|
|
|
- ichw++)
|
|
|
|
+ for (int ichwTemp = pslout->FirstUnderlyingComponent(icomp) ;
|
|
|
|
+ ichwTemp <= pslout->LastUnderlyingComponent(icomp) ;
|
|
|
|
+ ichwTemp++)
|
|
|
|
{
|
|
|
|
- if (m_pseg->m_prgiComponent[ichw - m_pseg->m_ichwAssocsMin] == icomp)
|
|
|
|
- prgfAllSelected[ichw] = fAll;
|
|
|
|
+ if (m_pseg->m_prgiComponent[ichwTemp - m_pseg->m_ichwAssocsMin] == icomp)
|
|
|
|
+ prgfAllSelected[ichwTemp] = fAll;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@@ -2304,7 +2304,11 @@
|
|
|
|
Assert that there are no overlaps among all the rectangles in the array, which should
|
|
|
|
be the case if AdjustRectsToNotOverlap is working properly.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
+#ifdef _DEBUG
|
|
|
|
void SegmentPainter::AssertNoOverlaps(std::vector<Rect> & vrect)
|
|
|
|
+#else
|
|
|
|
+void SegmentPainter::AssertNoOverlaps(std::vector<Rect> & /*vrect*/)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
#ifdef _DEBUG
|
|
|
|
for (int irect1 = 0; irect1 < signed(vrect.size() - 1); irect1++)
|
|
|
|
@@ -2452,7 +2456,11 @@
|
|
|
|
Assert that there are no overlaps among all the rectangles in the array, which should
|
|
|
|
be the case if AdjustRectsToNotOverlap is working properly.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
+#ifdef _DEBUG
|
|
|
|
void SegmentPainter::AssertNoOverlaps(std::vector<LineSeg> & vls)
|
|
|
|
+#else
|
|
|
|
+void SegmentPainter::AssertNoOverlaps(std::vector<LineSeg> & /*vls*/)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
#ifdef _DEBUG
|
|
|
|
for (int ils1 = 0; ils1 < (int)vls.size() - 1; ils1++)
|
|
|
|
@@ -2884,7 +2892,7 @@
|
|
|
|
{
|
|
|
|
if (icompNext != icompCurr)
|
|
|
|
{
|
|
|
|
- float xsHorizNext = (fIPOnRight) ? vxsRights[icompNext] : vxsLefts[icompNext];
|
|
|
|
+ xsHorizNext = (fIPOnRight) ? vxsRights[icompNext] : vxsLefts[icompNext];
|
|
|
|
if (fMovingRight && xsHorizNext > xsHorizCurr)
|
|
|
|
break;
|
|
|
|
else if (!fMovingRight && xsHorizNext < xsHorizCurr)
|
|
|
|
@@ -2996,7 +3004,7 @@
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
Make sure the font is set to use the character properties required by this segment.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void SegmentPainter::SetFontProps(unsigned long clrFore, unsigned long clrBack)
|
|
|
|
+void SegmentPainter::SetFontProps(unsigned long /*clrFore*/, unsigned long /*clrBack*/)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/FileInput.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/FileInput.cpp Sat Aug 22 19:36:33 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -80,7 +80,7 @@
|
|
|
|
#ifdef GR_FW
|
|
|
|
bool GrBufferIStream::Open(std::wstring stuFileName, int kMode)
|
|
|
|
#else
|
|
|
|
-bool GrBufferIStream::Open(const char * pcFileName, std::ios::openmode kMode)
|
|
|
|
+bool GrBufferIStream::Open(const char * /*pcFileName*/, std::ios::openmode /*kMode*/)
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
Assert(false); // use OpenBuffer
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrCharStream.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrCharStream.cpp Sat Aug 22 19:36:33 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -417,8 +417,11 @@
|
|
|
|
return true;
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
-
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+bool GrCharStream::AtUnicodeCharBoundary(utf8 * prgchs, int cchs, int ichs, UtfType /*utf*/)
|
|
|
|
+#else
|
|
|
|
bool GrCharStream::AtUnicodeCharBoundary(utf8 * prgchs, int cchs, int ichs, UtfType utf)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
Assert(ichs >= 0);
|
|
|
|
Assert(ichs <= cchs);
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrClassTable.h Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrClassTable.h Sat Aug 22 19:36:33 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -54,7 +54,11 @@
|
|
|
|
/*------------------------------------------------------------------------------------------
|
|
|
|
Copy the raw memory into the instance.
|
|
|
|
------------------------------------------------------------------------------------------*/
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+ void CopyFrom(data16 * pchwStart, int /*cchw*/)
|
|
|
|
+#else
|
|
|
|
void CopyFrom(data16 * pchwStart, int cchw)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
m_cgixBIG = pchwStart[0];
|
|
|
|
m_digixBIGInit = pchwStart[1];
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrEngine.cpp Wed Jan 28 04:01:29 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrEngine.cpp Sat Aug 22 19:36:33 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -159,12 +159,12 @@
|
|
|
|
GrEngine::~GrEngine()
|
|
|
|
{
|
|
|
|
DestroyEverything();
|
|
|
|
- #ifdef _MSC_VER
|
|
|
|
- if (!_CrtCheckMemory())
|
|
|
|
- {
|
|
|
|
- OutputDebugString(L"bad memory");
|
|
|
|
- }
|
|
|
|
- #endif
|
|
|
|
+// #ifdef _MSC_VER
|
|
|
|
+// if (!_CrtCheckMemory())
|
|
|
|
+// {
|
|
|
|
+// OutputDebugString(L"bad memory");
|
|
|
|
+// }
|
|
|
|
+// #endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
@@ -173,12 +173,12 @@
|
|
|
|
void GrEngine::DestroyEverything()
|
|
|
|
{
|
|
|
|
DestroyContents();
|
|
|
|
- #ifdef _MSC_VER
|
|
|
|
- if (!_CrtCheckMemory())
|
|
|
|
- {
|
|
|
|
- OutputDebugString(L"bad memory");
|
|
|
|
- }
|
|
|
|
- #endif
|
|
|
|
+// #ifdef _MSC_VER
|
|
|
|
+// if (!_CrtCheckMemory())
|
|
|
|
+// {
|
|
|
|
+// OutputDebugString(L"bad memory");
|
|
|
|
+// }
|
|
|
|
+// #endif
|
|
|
|
|
|
|
|
m_strCtrlFileReg.erase();
|
|
|
|
m_strCtrlFileBold.erase();
|
|
|
|
@@ -417,7 +417,11 @@
|
|
|
|
@return The supported script direction(s). If more than one, the application is
|
|
|
|
responsible for choosing the most appropriate.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+GrResult GrEngine::get_ScriptDirection(unsigned int * pgrfsdc, OLECHAR * /*prgchwErrMsg*/, int /*cchMaxErrMsg*/)
|
|
|
|
+#else
|
|
|
|
GrResult GrEngine::get_ScriptDirection(unsigned int * pgrfsdc, OLECHAR * prgchwErrMsg, int cchMaxErrMsg)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
ChkGrOutPtr(pgrfsdc);
|
|
|
|
ChkGrArrayArg(prgchwErrMsg, cchMaxErrMsg);
|
|
|
|
@@ -789,7 +793,7 @@
|
|
|
|
Record a system error indicating a bad error in rendering using a supposedly valid font.
|
|
|
|
OBSOLETE
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrEngine::RecordFontRunError(OLECHAR * prgchwErrMsg, int cchMax, GrResult res)
|
|
|
|
+void GrEngine::RecordFontRunError(OLECHAR * prgchwErrMsg, int cchMax, GrResult /*res*/)
|
|
|
|
{
|
|
|
|
if (prgchwErrMsg == NULL || cchMax == 0)
|
|
|
|
return;
|
|
|
|
@@ -970,7 +974,7 @@
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
Return whether the text is asking for bold and/or italic text.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrEngine::GetStyles(Font * pfont, int ichwMin, bool * pfBold, bool * pfItalic)
|
|
|
|
+void GrEngine::GetStyles(Font * pfont, int /*ichwMin*/, bool * pfBold, bool * pfItalic)
|
|
|
|
{
|
|
|
|
*pfBold = pfont->bold();
|
|
|
|
*pfItalic = pfont->italic();
|
|
|
|
@@ -981,7 +985,11 @@
|
|
|
|
Should only be called when we know we are using a base font, or when we are reading
|
|
|
|
the base font to see if it is valid.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+void GrEngine::SwitchGraphicsFont(bool /*fBase*/)
|
|
|
|
+#else
|
|
|
|
void GrEngine::SwitchGraphicsFont(bool fBase)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
Assert(!fBase || m_stuBaseFaceName.size() > 0);
|
|
|
|
|
|
|
|
@@ -1135,7 +1143,7 @@
|
|
|
|
m_chwJShrink0 = 0xffff;
|
|
|
|
m_chwJStep0 = 0xffff;
|
|
|
|
m_chwJWeight0 = 0xffff;
|
|
|
|
- for (int i = 0; i < m_cJLevels; i++)
|
|
|
|
+ for (i = 0; i < m_cJLevels; i++)
|
|
|
|
{
|
|
|
|
// justification glyph attribute IDs
|
|
|
|
bTmp = grstrm.ReadByteFromFont();
|
|
|
|
@@ -1210,10 +1218,12 @@
|
|
|
|
|
|
|
|
// rendering behaviors--ignore for now
|
|
|
|
byte cBehaviors = grstrm.ReadByteFromFont();
|
|
|
|
- unsigned int nBehaviors[kMaxRenderingBehavior];
|
|
|
|
+ int nTmp;
|
|
|
|
+ //unsigned int nBehaviors[kMaxRenderingBehavior]; -- this big buffer causes a stack overflow in Multiscribe; rework eventually
|
|
|
|
for (i = 0; i < cBehaviors; i++)
|
|
|
|
{
|
|
|
|
- nBehaviors[i] = unsigned(grstrm.ReadIntFromFont());
|
|
|
|
+ //nBehaviors[i] = unsigned(grstrm.ReadIntFromFont());
|
|
|
|
+ nTmp = unsigned(grstrm.ReadIntFromFont());
|
|
|
|
}
|
|
|
|
|
|
|
|
// linebreak glyph ID
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrFSM.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrFSM.cpp Sat Aug 22 19:36:33 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -46,7 +46,7 @@
|
|
|
|
Fill in the FSM by reading from the font stream.
|
|
|
|
Assumes the stream is in the correct position.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-bool GrFSM::ReadFromFont(GrIStream & grstrm, int fxdVersion)
|
|
|
|
+bool GrFSM::ReadFromFont(GrIStream & grstrm, int /*fxdVersion*/)
|
|
|
|
{
|
|
|
|
short snTmp;
|
|
|
|
|
|
|
|
@@ -138,7 +138,7 @@
|
|
|
|
Fill in the FSM's state table by reading from the font stream.
|
|
|
|
Assumes the stream is in the correct position.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-bool GrFSM::ReadStateTableFromFont(GrIStream & grstrm, int fxdVersion)
|
|
|
|
+bool GrFSM::ReadStateTableFromFont(GrIStream & grstrm, int /*fxdVersion*/)
|
|
|
|
{
|
|
|
|
int cCells = ((m_crow - m_crowFinal) * m_ccol);
|
|
|
|
m_prgrowTransitions = new short[cCells];
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrFeature.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrFeature.cpp Sat Aug 22 19:36:33 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -186,7 +186,7 @@
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
Read the languages from the font.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-bool GrLangTable::ReadFromFont(GrIStream * pgrstrm, int fxdVersion)
|
|
|
|
+bool GrLangTable::ReadFromFont(GrIStream * pgrstrm, int /*fxdVersion*/)
|
|
|
|
{
|
|
|
|
GrIStream & grstrm = *pgrstrm;
|
|
|
|
|
|
|
|
@@ -206,13 +206,22 @@
|
|
|
|
|
|
|
|
m_cbOffset0 = (lsbf)(m_prglang[0].cbOffsetBIG);
|
|
|
|
|
|
|
|
- Assert((lsbf)(m_prglang[m_clang].cFeaturesBIG) == 0); // bogus entry has no settings
|
|
|
|
+ if ((lsbf)(m_prglang[m_clang].cFeaturesBIG) == 0) // bogus entry has no settings
|
|
|
|
+ {
|
|
|
|
cb = (lsbf)(m_prglang[m_clang].cbOffsetBIG) - m_cbOffset0;
|
|
|
|
- Assert(cb % sizeof(FeatSet) == 0); // # of bytes fits nicely into FeatSet class
|
|
|
|
+ if (cb % sizeof(FeatSet) == 0) // # of bytes fits nicely into FeatSet class
|
|
|
|
+ {
|
|
|
|
int cfset = cb / sizeof(FeatSet);
|
|
|
|
m_prgfset = new FeatSet[cfset];
|
|
|
|
m_cfset = cfset;
|
|
|
|
grstrm.ReadBlockFromFont(m_prgfset, cb);
|
|
|
|
+ }
|
|
|
|
+ else return false;
|
|
|
|
+ }
|
|
|
|
+ else
|
|
|
|
+ {
|
|
|
|
+ return false;
|
|
|
|
+ }
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrPass.cpp Wed Jan 28 04:01:29 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrPass.cpp Sat Aug 22 19:36:34 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -279,9 +279,10 @@
|
|
|
|
@param twsh - how we are handling trailing white-space
|
|
|
|
@param pnRet - return value
|
|
|
|
@param pcslotGot - return the number of slots gotten
|
|
|
|
- @param pislotFinalBreak - return the index of the final slot, when we are removing
|
|
|
|
- the trailing white-space and so the end of the segment
|
|
|
|
- will be before the any actual line-break slot
|
|
|
|
+ @param pislotFinalBreak - index of the final slot (LB or actual glyph), or -1;
|
|
|
|
+ adjusted when we are removing the trailing white-space and
|
|
|
|
+ so the end of the segment will be before the any actual
|
|
|
|
+ line-break slot
|
|
|
|
|
|
|
|
@return kNextPass if we were able to generated the number requested, or processing is
|
|
|
|
complete; otherwise return the number of slots needed from the previous pass.
|
|
|
|
@@ -465,7 +466,7 @@
|
|
|
|
void GrBidiPass::ExtendOutput(GrTableManager * ptman,
|
|
|
|
GrSlotStream* psstrmIn, GrSlotStream* psstrmOut,
|
|
|
|
int cslotNeededByNext, TrWsHandling twsh,
|
|
|
|
- int * pnRet, int * pcslotGot, int * pislotFinalBreak)
|
|
|
|
+ int * pnRet, int * pcslotGot, int * /*pislotFinalBreak*/)
|
|
|
|
{
|
|
|
|
Assert(psstrmIn->SlotsToReprocess() == 0);
|
|
|
|
|
|
|
|
@@ -776,7 +777,7 @@
|
|
|
|
int GrPass::ExtendFinalOutput(GrTableManager * ptman,
|
|
|
|
GrSlotStream * psstrmInput, GrSlotStream * psstrmOutput,
|
|
|
|
float xsSpaceAllotted, bool fWidthIsCharCount, bool fInfiniteWidth,
|
|
|
|
- bool fHaveLineBreak, bool fMustBacktrack, LineBrk lbMax, TrWsHandling twsh,
|
|
|
|
+ bool fHaveLineBreak, bool fMustBacktrack, LineBrk /*lbMax*/, TrWsHandling twsh,
|
|
|
|
int * pislotLB, float * pxsWidth)
|
|
|
|
{
|
|
|
|
EngineState * pengst = ptman->State();
|
|
|
|
@@ -897,7 +898,11 @@
|
|
|
|
Remove undesirable trailing white-space.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
int GrPass::RemoveTrailingWhiteSpace(GrTableManager * ptman, GrSlotStream * psstrmOut,
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+ TrWsHandling /*twsh*/, int * pislotFinalBreak)
|
|
|
|
+#else
|
|
|
|
TrWsHandling twsh, int * pislotFinalBreak)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
EngineState * pengst = ptman->State();
|
|
|
|
|
|
|
|
@@ -944,7 +949,7 @@
|
|
|
|
should never be necessary if they've set up their tables right.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void GrPass::CheckInputProgress(GrSlotStream * psstrmInput, GrSlotStream * psstrmOutput,
|
|
|
|
- int islotOrigInput)
|
|
|
|
+ int /*islotOrigInput*/)
|
|
|
|
{
|
|
|
|
int islotInput = psstrmInput->ReadPosForNextGet();
|
|
|
|
// Assert(islotInput >= islotOrigInput); -- no longer true now that we can back up
|
|
|
|
@@ -1752,7 +1757,7 @@
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
int GrPass::Unwind(GrTableManager * ptman,
|
|
|
|
int islotChanged, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut,
|
|
|
|
- bool fFirst)
|
|
|
|
+ bool /*fFirst*/)
|
|
|
|
{
|
|
|
|
// Back up the number of slots required for the longest rule context,
|
|
|
|
// but if we land in the middle of a chunk, go forward to its boundary.
|
|
|
|
@@ -1824,7 +1829,7 @@
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
int GrBidiPass::Unwind(GrTableManager * ptman,
|
|
|
|
int islotChanged, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut,
|
|
|
|
- bool fFirst)
|
|
|
|
+ bool /*fFirst*/)
|
|
|
|
{
|
|
|
|
int islotIn;
|
|
|
|
int islotOut;
|
|
|
|
@@ -1901,8 +1906,8 @@
|
|
|
|
OBSOLETE
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
//:Ignore
|
|
|
|
-void GrPosPass::Unattach(GrSlotStream * psstrmIn, int islotIn,
|
|
|
|
- GrSlotStream * psstrmOut, int islotOut, int islotLB)
|
|
|
|
+void GrPosPass::Unattach(GrSlotStream * /*psstrmIn*/, int /*islotIn*/,
|
|
|
|
+ GrSlotStream * /*psstrmOut*/, int /*islotOut*/, int /*islotLB*/)
|
|
|
|
{
|
|
|
|
// Because this is a positioning pass, there is a one-to-one correspondence between
|
|
|
|
// the slots in the input and the slots in the output. Thus we can make simplifying
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrPass.h Thu Aug 21 16:24:32 2008
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrPass.h Sat Aug 22 19:36:34 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -197,7 +197,7 @@
|
|
|
|
bool ReadFromFont(GrIStream & grstrm, int fxdSilfVersion, int fxdRuleVersion, int nOffset);
|
|
|
|
void InitializeWithNoRules();
|
|
|
|
|
|
|
|
- virtual void SetTopDirLevel(int n)
|
|
|
|
+ virtual void SetTopDirLevel(int /*n*/)
|
|
|
|
{ // only GrBidiPass does anything interesting
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -253,13 +253,13 @@
|
|
|
|
m_pzpst->SetResyncSkip(n);
|
|
|
|
}
|
|
|
|
|
|
|
|
- virtual void DoCleanUpSegMin(GrTableManager * ptman,
|
|
|
|
- GrSlotStream * psstrmIn, int islotInitReadPos, GrSlotStream * psstrmOut)
|
|
|
|
+ virtual void DoCleanUpSegMin(GrTableManager * /*ptman*/,
|
|
|
|
+ GrSlotStream * /*psstrmIn*/, int /*islotInitReadPos*/, GrSlotStream * /*psstrmOut*/)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
- virtual void DoCleanUpSegLim(GrTableManager * ptman, GrSlotStream * psstrmOut,
|
|
|
|
- TrWsHandling twsh)
|
|
|
|
+ virtual void DoCleanUpSegLim(GrTableManager * /*ptman*/, GrSlotStream * /*psstrmOut*/,
|
|
|
|
+ TrWsHandling /*twsh*/)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -383,8 +383,8 @@
|
|
|
|
void MapChunks(GrSlotStream * psstrmIn, GrSlotStream * psstrmOut,
|
|
|
|
int islotChunkI, int islotChunkO, int cslotReprocessed);
|
|
|
|
|
|
|
|
- virtual void Unattach(GrSlotStream * psstrmIn, int islotIn, // GrPosPass overrides
|
|
|
|
- GrSlotStream * psstrmOut, int islotOut, int islotLB)
|
|
|
|
+ virtual void Unattach(GrSlotStream * /*psstrmIn*/, int /*islotIn*/, // GrPosPass overrides
|
|
|
|
+ GrSlotStream * /*psstrmOut*/, int /*islotOut*/, int /*islotLB*/)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -500,8 +500,8 @@
|
|
|
|
|
|
|
|
protected:
|
|
|
|
// Irrelevant when generating glyphs.
|
|
|
|
- virtual void RunRule(GrTableManager *, int ruln,
|
|
|
|
- GrSlotStream * psstrmInput, GrSlotStream * psstrmOutput)
|
|
|
|
+ virtual void RunRule(GrTableManager *, int /*ruln*/,
|
|
|
|
+ GrSlotStream * /*psstrmInput*/, GrSlotStream * /*psstrmOutput*/)
|
|
|
|
{
|
|
|
|
Assert(false);
|
|
|
|
}
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrPassActionCode.cpp Wed Jan 28 04:01:29 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrPassActionCode.cpp Sat Aug 22 19:36:34 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -632,8 +632,13 @@
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
We are finished processing a slot; go on to the next slot, or possibly go backwards.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrPass::DoNext(GrTableManager * ptman,
|
|
|
|
- int cslot, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+void GrPass::DoNext(GrTableManager * /*ptman*/,
|
|
|
|
+ int /*cslot*/, GrSlotStream * /*psstrmIn*/, GrSlotStream * /*psstrmOut*/)
|
|
|
|
+#else
|
|
|
|
+void GrPass::DoNext(GrTableManager * /*ptman*/,
|
|
|
|
+ int cslot, GrSlotStream * /*psstrmIn*/, GrSlotStream * /*psstrmOut*/)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
gAssert(cslot == 1); // for now anyway
|
|
|
|
}
|
|
|
|
@@ -690,6 +695,7 @@
|
|
|
|
psstrmOut->SetSegMinToWritePos(false);
|
|
|
|
if (fSetSegLim)
|
|
|
|
psstrmOut->SetSegLimToWritePos(false);
|
|
|
|
+ //gid16 chw; chw = pslotNew->GlyphID();
|
|
|
|
psstrmOut->NextPut(pslotNew);
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -729,6 +735,7 @@
|
|
|
|
psstrmOut->SetSegMinToWritePos(false);
|
|
|
|
if (fSetSegLim)
|
|
|
|
psstrmOut->SetSegLimToWritePos(false);
|
|
|
|
+ //gid16 chw; chw = pslotNew->GlyphID();
|
|
|
|
psstrmOut->NextPut(pslotNew);
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -825,7 +832,7 @@
|
|
|
|
@param psstrmIn / Out - input/output streams
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void GrPass::DoPutSubs3(GrTableManager * ptman, bool fInserting,
|
|
|
|
- int cslotSel1, int nSelClass1, int cslotSel2, int nSelClass2, int cslotSel3, int nSelClass3,
|
|
|
|
+ int cslotSel1, int nSelClass1, int cslotSel2, int nSelClass2, int /*cslotSel3*/, int nSelClass3,
|
|
|
|
int nReplacementClass,
|
|
|
|
GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
|
|
|
|
{
|
|
|
|
@@ -888,7 +895,7 @@
|
|
|
|
Common part of all the DoPutSubs... methods.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void GrPass::DoPutSubsAux(GrTableManager * ptman, bool fInserting, gid16 nGlyphReplacement,
|
|
|
|
- GrSlotStream * psstrmIn, GrSlotStream * psstrmOut, GrSlotState * pslotNextInput,
|
|
|
|
+ GrSlotStream * /*psstrmIn*/, GrSlotStream * psstrmOut, GrSlotState * pslotNextInput,
|
|
|
|
bool fAtSegMin, bool fAtSegLim)
|
|
|
|
{
|
|
|
|
EngineState * pengst = ptman->State();
|
|
|
|
@@ -915,6 +922,7 @@
|
|
|
|
psstrmOut->SetSegMinToWritePos(false);
|
|
|
|
if (fSetSegLim)
|
|
|
|
psstrmOut->SetSegLimToWritePos(false);
|
|
|
|
+ //gid16 chw; chw = pslotNew->GlyphID();
|
|
|
|
psstrmOut->NextPut(pslotNew);
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -924,7 +932,7 @@
|
|
|
|
and its after-assoc to the slot before it. This makes it basically unselectable.
|
|
|
|
OBSOLETE - handled by slot initialization code
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrPass::SetNeutralAssocs(GrSlotState * pslotNew, GrSlotStream * psstrmIn)
|
|
|
|
+void GrPass::SetNeutralAssocs(GrSlotState * pslotNew, GrSlotStream * /*psstrmIn*/)
|
|
|
|
{
|
|
|
|
pslotNew->ClearAssocs();
|
|
|
|
}
|
|
|
|
@@ -943,6 +951,7 @@
|
|
|
|
psstrmOut->SetSegLimToWritePos();
|
|
|
|
|
|
|
|
GrSlotState * pslot = psstrmIn->NextGet();
|
|
|
|
+ //gid16 chw; chw = pslotNew->GlyphID();
|
|
|
|
pslot->MarkDeleted();
|
|
|
|
|
|
|
|
if (ptman->LoggingTransduction())
|
|
|
|
@@ -957,7 +966,7 @@
|
|
|
|
@param fInserting - whether current slot was inserted
|
|
|
|
@param psstrmIn / Out - input/output streams
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrPass::DoAssoc(int cnAssocs, std::vector<int> & vnAssocs, bool fInserting,
|
|
|
|
+void GrPass::DoAssoc(int cnAssocs, std::vector<int> & vnAssocs, bool /*fInserting*/,
|
|
|
|
GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
|
|
|
|
{
|
|
|
|
gAssert((unsigned)cnAssocs == vnAssocs.size());
|
|
|
|
@@ -997,7 +1006,11 @@
|
|
|
|
@param vnStack - stack to read value from
|
|
|
|
@param psstrmIn / Out - input/output streams
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+void GrPass::DoSetAttr(GrTableManager * ptman, ActionCommand op, bool /*fInserting*/,
|
|
|
|
+#else
|
|
|
|
void GrPass::DoSetAttr(GrTableManager * ptman, ActionCommand op, bool fInserting,
|
|
|
|
+#endif
|
|
|
|
SlotAttrName slat, int slati, std::vector<int> & vnStack,
|
|
|
|
GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
|
|
|
|
{
|
|
|
|
@@ -1192,7 +1205,7 @@
|
|
|
|
@param psstrmIn - input stream
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void GrPass::DoPushSlotAttr(GrTableManager * ptman,
|
|
|
|
- int nSlotRef, bool fInserting,
|
|
|
|
+ int nSlotRef, bool /*fInserting*/,
|
|
|
|
SlotAttrName slat, int slati, std::vector<int> & vnStack,
|
|
|
|
GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
|
|
|
|
{
|
|
|
|
@@ -1236,16 +1249,16 @@
|
|
|
|
|
|
|
|
case kslatAttTo: nVal = pslot->AttachTo(); break;
|
|
|
|
case kslatAttLevel: nVal = pslot->AttachLevel(); break;
|
|
|
|
- case kslatAttAtX: nVal = pslot->AttachAtX(ptman, psstrmIn); break;
|
|
|
|
case kslatAttAtY: nVal = pslot->AttachAtY(); break;
|
|
|
|
case kslatAttAtGpt: nVal = pslot->AttachAtGpoint(); break;
|
|
|
|
case kslatAttAtXoff: nVal = pslot->AttachAtXOffset(); break;
|
|
|
|
case kslatAttAtYoff: nVal = pslot->AttachAtYOffset(); break;
|
|
|
|
- case kslatAttWithX: nVal = pslot->AttachWithX(ptman, psstrmIn); break;
|
|
|
|
case kslatAttWithY: nVal = pslot->AttachWithY(); break;
|
|
|
|
case kslatAttWithGpt: nVal = pslot->AttachWithGpoint(); break;
|
|
|
|
case kslatAttWithXoff: nVal = pslot->AttachWithXOffset(); break;
|
|
|
|
case kslatAttWithYoff: nVal = pslot->AttachWithYOffset(); break;
|
|
|
|
+ case kslatAttAtX: nVal = pslot->AttachAtX(ptman, psstrmIn); break;
|
|
|
|
+ case kslatAttWithX: nVal = pslot->AttachWithX(ptman, psstrmIn); break;
|
|
|
|
|
|
|
|
case kslatMeasureSol: nVal = pslot->MeasureSol(); break;
|
|
|
|
case kslatMeasureEol: nVal = pslot->MeasureEol(); break;
|
|
|
|
@@ -1282,7 +1295,7 @@
|
|
|
|
@param vnStack - stack to push onto
|
|
|
|
@param psstrmIn - input stream
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrPass::DoPushGlyphAttr(GrTableManager * ptman, int nSlotRef, bool fInserting,
|
|
|
|
+void GrPass::DoPushGlyphAttr(GrTableManager * ptman, int nSlotRef, bool /*fInserting*/,
|
|
|
|
int nGlyphAttr,
|
|
|
|
std::vector<int> & vnStack, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
|
|
|
|
{
|
|
|
|
@@ -1307,7 +1320,7 @@
|
|
|
|
@param vnStack - stack to push onto
|
|
|
|
@param psstrmIn - input stream
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrPass::DoPushAttToGlyphAttr(GrTableManager * ptman, int nSlotRef, bool fInserting,
|
|
|
|
+void GrPass::DoPushAttToGlyphAttr(GrTableManager * ptman, int nSlotRef, bool /*fInserting*/,
|
|
|
|
int nGlyphAttr, std::vector<int> & vnStack,
|
|
|
|
GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
|
|
|
|
{
|
|
|
|
@@ -1337,7 +1350,7 @@
|
|
|
|
@param vnStack - stack to push onto
|
|
|
|
@param psstrmIn - input stream
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrPass::DoPushGlyphMetric(GrTableManager * ptman, int nSlotRef, bool fInserting,
|
|
|
|
+void GrPass::DoPushGlyphMetric(GrTableManager * ptman, int nSlotRef, bool /*fInserting*/,
|
|
|
|
int nGlyphAttr, int nAttLevel,
|
|
|
|
std::vector<int> & vnStack, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
|
|
|
|
{
|
|
|
|
@@ -1364,7 +1377,7 @@
|
|
|
|
@param psstrmIn - input stream
|
|
|
|
@param psstrmOut - output stream
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrPass::DoPushAttToGlyphMetric(GrTableManager * ptman, int nSlotRef, bool fInserting,
|
|
|
|
+void GrPass::DoPushAttToGlyphMetric(GrTableManager * ptman, int nSlotRef, bool /*fInserting*/,
|
|
|
|
int nGlyphAttr, int nAttLevel,
|
|
|
|
std::vector<int> & vnStack,
|
|
|
|
GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
|
|
|
|
@@ -1399,7 +1412,7 @@
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
- pslot->CalcCompositeMetrics(ptman, psstrmIn, nAttLevel, true);
|
|
|
|
+ pslot->CalcCompositeMetrics(ptman, psstrmIn, NULL, nAttLevel, true);
|
|
|
|
|
|
|
|
float xy;
|
|
|
|
switch (gmet)
|
|
|
|
@@ -1435,7 +1448,11 @@
|
|
|
|
@param psstrmIn - input stream
|
|
|
|
@param psstrmOut - output stream
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrPass::DoPushFeatValue(GrTableManager * ptman, int nSlotRef, bool fInserting,
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+void GrPass::DoPushFeatValue(GrTableManager * /*ptman*/, int nSlotRef, bool /*fInserting*/,
|
|
|
|
+#else
|
|
|
|
+void GrPass::DoPushFeatValue(GrTableManager * /*ptman*/, int nSlotRef, bool fInserting,
|
|
|
|
+#endif
|
|
|
|
int nFeat, std::vector<int> & vnStack, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
|
|
|
|
{
|
|
|
|
gAssert(!fInserting);
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrSlotState.cpp Wed Jan 28 04:01:29 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrSlotState.cpp Sat Aug 22 19:36:34 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -261,7 +261,7 @@
|
|
|
|
root or attached leaf slots.
|
|
|
|
OBSOLETE
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrSlotState::FixAttachmentTree(GrSlotState * pslotOld)
|
|
|
|
+void GrSlotState::FixAttachmentTree(GrSlotState * /*pslotOld*/)
|
|
|
|
{
|
|
|
|
#if 0
|
|
|
|
pslotOld->m_vpslotAttLeaves.CopyTo(m_vpslotAttLeaves);
|
|
|
|
@@ -524,13 +524,13 @@
|
|
|
|
GrSlotState * pslot;
|
|
|
|
if (HasComponents())
|
|
|
|
{
|
|
|
|
- for (int iComponent = 0; iComponent < m_cnCompPerLig; iComponent++)
|
|
|
|
+ for (int iLigComponent = 0; iLigComponent < m_cnCompPerLig; iLigComponent++)
|
|
|
|
{
|
|
|
|
- pslot = CompRefSlot(iComponent);
|
|
|
|
+ pslot = CompRefSlot(iLigComponent);
|
|
|
|
if (pslot)
|
|
|
|
{
|
|
|
|
Assert(PassModified() >= pslot->PassModified());
|
|
|
|
- pslot->AllComponentRefs(vichw, vicomp, iComponent);
|
|
|
|
+ pslot->AllComponentRefs(vichw, vicomp, iLigComponent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@@ -1024,7 +1024,7 @@
|
|
|
|
NOTE: the caller is responsible to zap the cached positions of following glyphs
|
|
|
|
in the stream.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrSlotState::AttachToRoot(GrTableManager * ptman, GrSlotStream * psstrm,
|
|
|
|
+void GrSlotState::AttachToRoot(GrTableManager * /*ptman*/, GrSlotStream * psstrm,
|
|
|
|
GrSlotState * pslotNewRoot)
|
|
|
|
{
|
|
|
|
GrSlotState * pslotOldRoot = (m_dislotRootFixed == 0) ?
|
|
|
|
@@ -1063,7 +1063,7 @@
|
|
|
|
|
|
|
|
float xsWidth, xsVisWidth;
|
|
|
|
if (m_xsPositionX == kNegInfFloat || m_ysPositionY == kNegInfFloat)
|
|
|
|
- ptman->CalcPositionsUpTo(psstrmOut->m_ipass, this, &xsWidth, &xsVisWidth);
|
|
|
|
+ ptman->CalcPositionsUpTo(psstrmOut->m_ipass, this, true, &xsWidth, &xsVisWidth);
|
|
|
|
|
|
|
|
*pmXPos = ptman->LogToEmUnits(m_xsPositionX);
|
|
|
|
*pmYPos = ptman->LogToEmUnits(m_ysPositionY);
|
|
|
|
@@ -1077,7 +1077,7 @@
|
|
|
|
{
|
|
|
|
Assert(m_dislotRootFixed == m_srAttachTo);
|
|
|
|
GrSlotState * pslotRoot = AttachRoot(psstrm);
|
|
|
|
- CalcRootMetrics(ptman, psstrm, kPosInfinity);
|
|
|
|
+ CalcRootMetrics(ptman, psstrm, NULL, kPosInfinity);
|
|
|
|
if (pslotRoot)
|
|
|
|
pslotRoot->AdjustRootMetrics(ptman, psstrm);
|
|
|
|
}
|
|
|
|
@@ -1086,13 +1086,15 @@
|
|
|
|
Calculate the composite metrics for this slot.
|
|
|
|
|
|
|
|
@param psstrm - stream for which we are calculating it
|
|
|
|
+ @param psstrmNext - because when processing in the middle of a pass, we may need to
|
|
|
|
+ get the slot from the following (output) stream
|
|
|
|
@param nLevel - attachment level we are asking for; kPosInifinity means all levels
|
|
|
|
@param fThorough - true: do a thorough recalculation; false: don't recalculate
|
|
|
|
metrics for leaves (are they assumed to be accurate???)
|
|
|
|
--currently not used
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void GrSlotState::CalcCompositeMetrics(GrTableManager * ptman, GrSlotStream * psstrm,
|
|
|
|
- int nLevel, bool fThorough)
|
|
|
|
+ GrSlotStream * psstrmNext, int nLevel, bool fThorough)
|
|
|
|
{
|
|
|
|
if (m_nCompositeLevel == nLevel)
|
|
|
|
return;
|
|
|
|
@@ -1101,19 +1103,38 @@
|
|
|
|
{
|
|
|
|
Assert(m_dislotRootFixed == m_srAttachTo);
|
|
|
|
GrSlotState * pslotRoot = AttachRoot(psstrm);
|
|
|
|
+ // Kludge to handle the fact that we might have gotten the root from the wrong stream.
|
|
|
|
+ // Calling MidPassSlotAt finds the right one.
|
|
|
|
+ if (psstrmNext && pslotRoot)
|
|
|
|
+ {
|
|
|
|
+ int islotRoot = pslotRoot->PosPassIndex();
|
|
|
|
+ pslotRoot = psstrm->MidPassSlotAt(islotRoot, psstrmNext);
|
|
|
|
+ }
|
|
|
|
|
|
|
|
InitMetrics(ptman, pslotRoot);
|
|
|
|
|
|
|
|
for (size_t islot = 0; islot < m_vdislotAttLeaves.size(); islot++)
|
|
|
|
{
|
|
|
|
- GrSlotState * pslotLeaf = SlotAtOffset(psstrm, m_vdislotAttLeaves[islot]);
|
|
|
|
+ GrSlotState * pslotLeaf;
|
|
|
|
+ if (psstrmNext)
|
|
|
|
+ {
|
|
|
|
+ // Calculating a position in the middle of processing a pass.
|
|
|
|
+ pslotLeaf = psstrm->MidPassSlotAt(PosPassIndex() + m_vdislotAttLeaves[islot],
|
|
|
|
+ psstrmNext);
|
|
|
|
+ }
|
|
|
|
+ else
|
|
|
|
+ {
|
|
|
|
+ // Calculating the final position.
|
|
|
|
+ pslotLeaf = SlotAtOffset(psstrm, m_vdislotAttLeaves[islot]);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
if (pslotLeaf->AttachLevel() <= nLevel)
|
|
|
|
- pslotLeaf->CalcCompositeMetrics(ptman, psstrm, nLevel, fThorough);
|
|
|
|
+ pslotLeaf->CalcCompositeMetrics(ptman, psstrm, psstrmNext, nLevel, fThorough);
|
|
|
|
else
|
|
|
|
// this slot will be ignored in the composite metrics
|
|
|
|
pslotLeaf->ZapRootMetrics();
|
|
|
|
}
|
|
|
|
- CalcRootMetrics(ptman, psstrm, nLevel);
|
|
|
|
+ CalcRootMetrics(ptman, psstrm, psstrmNext, nLevel);
|
|
|
|
|
|
|
|
m_nCompositeLevel = nLevel;
|
|
|
|
}
|
|
|
|
@@ -1129,25 +1150,33 @@
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
Calculate the metrics for this node and all its leaf nodes.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrSlotState::CalcRootMetrics(GrTableManager * ptman, GrSlotStream * psstrm, int nLevel)
|
|
|
|
+void GrSlotState::CalcRootMetrics(GrTableManager * /*ptman*/, GrSlotStream * psstrm,
|
|
|
|
+ GrSlotStream * psstrmNext, int nLevel)
|
|
|
|
{
|
|
|
|
for (size_t idislot = 0; idislot < m_vdislotAttLeaves.size(); idislot++)
|
|
|
|
{
|
|
|
|
- GrSlotState * pslot = SlotAtOffset(psstrm, m_vdislotAttLeaves[idislot]);
|
|
|
|
- if (pslot->AttachLevel() > nLevel)
|
|
|
|
+ GrSlotState * pslotLeaf = SlotAtOffset(psstrm, m_vdislotAttLeaves[idislot]);
|
|
|
|
+ // Kludge to handle the fact that we might have gotten the leaf from the wrong stream.
|
|
|
|
+ // Calling MidPassSlotAt finds the right one.
|
|
|
|
+ if (psstrmNext)
|
|
|
|
+ {
|
|
|
|
+ int islot = pslotLeaf->PosPassIndex();
|
|
|
|
+ pslotLeaf = psstrm->MidPassSlotAt(islot, psstrmNext);
|
|
|
|
+ }
|
|
|
|
+ if (pslotLeaf->AttachLevel() > nLevel)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
- m_xsClusterXOffset = min(m_xsClusterXOffset, pslot->m_xsClusterXOffset);
|
|
|
|
- if (!pslot->m_fIgnoreAdvance)
|
|
|
|
+ m_xsClusterXOffset = min(m_xsClusterXOffset, pslotLeaf->m_xsClusterXOffset);
|
|
|
|
+ if (!pslotLeaf->m_fIgnoreAdvance)
|
|
|
|
{
|
|
|
|
m_xsClusterAdv = max(
|
|
|
|
m_xsClusterAdv,
|
|
|
|
- pslot->m_xsClusterAdv + m_xsRootShiftX);
|
|
|
|
+ pslotLeaf->m_xsClusterAdv + m_xsRootShiftX);
|
|
|
|
}
|
|
|
|
- m_xsClusterBbLeft = min(m_xsClusterBbLeft, pslot->m_xsClusterBbLeft);
|
|
|
|
- m_xsClusterBbRight = max(m_xsClusterBbRight, pslot->m_xsClusterBbRight);
|
|
|
|
- m_ysClusterBbTop = max(m_ysClusterBbTop, pslot->m_ysClusterBbTop);
|
|
|
|
- m_ysClusterBbBottom = min(m_ysClusterBbBottom, pslot->m_ysClusterBbBottom);
|
|
|
|
+ m_xsClusterBbLeft = min(m_xsClusterBbLeft, pslotLeaf->m_xsClusterBbLeft);
|
|
|
|
+ m_xsClusterBbRight = max(m_xsClusterBbRight, pslotLeaf->m_xsClusterBbRight);
|
|
|
|
+ m_ysClusterBbTop = max(m_ysClusterBbTop, pslotLeaf->m_ysClusterBbTop);
|
|
|
|
+ m_ysClusterBbBottom = min(m_ysClusterBbBottom, pslotLeaf->m_ysClusterBbBottom);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -1263,7 +1292,7 @@
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
Y-offsets of a single glyph relative to the previous advance position.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-float GrSlotState::GlyphYOffset(GrSlotStream * psstrm)
|
|
|
|
+float GrSlotState::GlyphYOffset(GrSlotStream * /*psstrm*/)
|
|
|
|
{
|
|
|
|
return m_ysOffsetY;
|
|
|
|
}
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrSlotState.h Wed Jan 28 04:01:29 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrSlotState.h Sat Aug 22 19:36:34 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -308,7 +308,11 @@
|
|
|
|
{
|
|
|
|
return m_islotPosPass;
|
|
|
|
}
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+ void SetPosPassIndex(int islot, bool /*fInputToPosPass1*/)
|
|
|
|
+#else
|
|
|
|
void SetPosPassIndex(int islot, bool fInputToPosPass1)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
// If we're resetting it, it should be to the same value as before:
|
|
|
|
Assert(fInputToPosPass1 || m_islotPosPass == kNotYetSet || m_islotPosPass == islot);
|
|
|
|
@@ -386,12 +390,12 @@
|
|
|
|
return (IsInitialLineBreak(chwLB) || IsFinalLineBreak(chwLB));
|
|
|
|
//return (m_chwGlyphID == chwLB); // TODO: remove
|
|
|
|
}
|
|
|
|
- bool IsInitialLineBreak(gid16 chwLB)
|
|
|
|
+ bool IsInitialLineBreak(gid16 /*chwLB*/)
|
|
|
|
{
|
|
|
|
return (m_spsl == kspslLbInitial);
|
|
|
|
//return (IsLineBreak(chwLB) && m_fInitialLB == true); // TODO: remove
|
|
|
|
}
|
|
|
|
- bool IsFinalLineBreak(gid16 chwLB)
|
|
|
|
+ bool IsFinalLineBreak(gid16 /*chwLB*/)
|
|
|
|
{
|
|
|
|
return (m_spsl == kspslLbFinal);
|
|
|
|
//return (IsLineBreak(chwLB) && m_fInitialLB == false); // TODO: remove
|
|
|
|
@@ -475,7 +479,7 @@
|
|
|
|
return m_mAttachAtX;
|
|
|
|
}
|
|
|
|
|
|
|
|
- int AttachWithX(GrTableManager * ptman, GrSlotStream * psstrm)
|
|
|
|
+ int AttachWithX(GrTableManager * /*ptman*/, GrSlotStream * /*psstrm*/)
|
|
|
|
{
|
|
|
|
if (m_mAttachAtX == kNotYetSet)
|
|
|
|
{
|
|
|
|
@@ -615,7 +619,7 @@
|
|
|
|
GrSlotStream * psstrmIn, GrSlotStream * psstrmOut, int islotThis);
|
|
|
|
|
|
|
|
void CalcCompositeMetrics(GrTableManager * ptman, GrSlotStream * psstrm,
|
|
|
|
- int nLevel, bool fThorough = false);
|
|
|
|
+ GrSlotStream * psstrmNext, int nLevel, bool fThorough = false);
|
|
|
|
|
|
|
|
void Position(GrTableManager * ptman,
|
|
|
|
GrSlotStream * psstrmOut, int * pmXPos, int * pmYPos);
|
|
|
|
@@ -646,7 +650,7 @@
|
|
|
|
{
|
|
|
|
return ClusterBbLeft(psstrm) + xs;
|
|
|
|
}
|
|
|
|
- float ClusterRsb(GrSlotStream * psstrm, float xs)
|
|
|
|
+ float ClusterRsb(GrSlotStream * /*psstrm*/, float xs)
|
|
|
|
{
|
|
|
|
return ClusterAdvWidthFrom(xs) - ClusterBbRightFrom(xs);
|
|
|
|
}
|
|
|
|
@@ -668,19 +672,19 @@
|
|
|
|
{
|
|
|
|
return ClusterBbRightFrom(Base(psstrm)->ClusterRootOffset());
|
|
|
|
}
|
|
|
|
- float ClusterBbTop(GrSlotStream * psstrm)
|
|
|
|
+ float ClusterBbTop(GrSlotStream * /*psstrm*/)
|
|
|
|
{
|
|
|
|
return m_ysClusterBbTop;
|
|
|
|
}
|
|
|
|
- float ClusterBbBottom(GrSlotStream * psstrm)
|
|
|
|
+ float ClusterBbBottom(GrSlotStream * /*psstrm*/)
|
|
|
|
{
|
|
|
|
return m_ysClusterBbBottom;
|
|
|
|
}
|
|
|
|
- float ClusterBbWidth(GrSlotStream * psstrm)
|
|
|
|
+ float ClusterBbWidth(GrSlotStream * /*psstrm*/)
|
|
|
|
{
|
|
|
|
return m_xsClusterBbRight - m_xsClusterBbLeft + 1;
|
|
|
|
}
|
|
|
|
- float ClusterBbHeight(GrSlotStream * psstrm)
|
|
|
|
+ float ClusterBbHeight(GrSlotStream * /*psstrm*/)
|
|
|
|
{
|
|
|
|
return m_ysClusterBbTop - m_ysClusterBbBottom + 1;
|
|
|
|
}
|
|
|
|
@@ -990,7 +994,8 @@
|
|
|
|
void InitMetrics(GrTableManager * ptman, GrSlotState * pslotRoot);
|
|
|
|
void InitLeafMetrics(GrTableManager * ptman, GrSlotState * pslotRoot);
|
|
|
|
void InitRootMetrics(GrTableManager * ptman);
|
|
|
|
- void CalcRootMetrics(GrTableManager * ptman, GrSlotStream *, int nLevel);
|
|
|
|
+ void CalcRootMetrics(GrTableManager * ptman, GrSlotStream * psstrm,
|
|
|
|
+ GrSlotStream * psstrmNext, int nLevel);
|
|
|
|
void AttachToRoot(GrTableManager * ptman, GrSlotStream *, GrSlotState * pslotNewRoot);
|
|
|
|
void AttachLogUnits(GrTableManager * ptman,
|
|
|
|
GrSlotState * pslotRoot,
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrSlotStream.cpp Wed Feb 04 07:53:26 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrSlotStream.cpp Sat Aug 22 19:36:34 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -189,12 +189,16 @@
|
|
|
|
stream position when the rule is being run.
|
|
|
|
|
|
|
|
@param dislot - how far back to peek before the write position
|
|
|
|
- when the rule started; a negative number
|
|
|
|
+ WHEN THE RULE STARTED; a negative number
|
|
|
|
(NOTE: the current write position is irrelevant)
|
|
|
|
@param fNullOkay - true if it's okay to return NULL in the situation where we're asking
|
|
|
|
for something before the beginning of the stream
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+GrSlotState * GrSlotStream::PeekBack(int dislot, bool /*fNullOkay*/)
|
|
|
|
+#else
|
|
|
|
GrSlotState * GrSlotStream::PeekBack(int dislot, bool fNullOkay)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
Assert(dislot < 0);
|
|
|
|
if (dislot < m_islotRuleStartWrite * -1)
|
|
|
|
@@ -1104,6 +1108,7 @@
|
|
|
|
case kdircRLO:
|
|
|
|
case kdircRLE:
|
|
|
|
case kdircPdfR:
|
|
|
|
+ case kdircRlb:
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case kdircNeutral:
|
|
|
|
@@ -1212,7 +1217,7 @@
|
|
|
|
return true;
|
|
|
|
|
|
|
|
float xsWidth, xsVisWidth;
|
|
|
|
- ptman->CalcPositionsUpTo(m_ipass, NULL, &xsWidth, &xsVisWidth);
|
|
|
|
+ ptman->CalcPositionsUpTo(m_ipass, NULL, false, &xsWidth, &xsVisWidth);
|
|
|
|
|
|
|
|
*pxsWidth = (fIgnoreTrailingWS || twsh == ktwshOnlyWs) ? xsVisWidth : xsWidth;
|
|
|
|
return (*pxsWidth < xsSpaceAllotted);
|
|
|
|
@@ -1322,7 +1327,7 @@
|
|
|
|
@param islotMin - first slot that is officially part of the segment (after initial LB)
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
int GrSlotStream::MakeSegmentBreak(GrTableManager * ptman,
|
|
|
|
- int islotPrevBreak, bool fInsertedLB, int islotStartTry,
|
|
|
|
+ int /*islotPrevBreak*/, bool /*fInsertedLB*/, int islotStartTry,
|
|
|
|
LineBrk lb, TrWsHandling twsh, int islotMin,
|
|
|
|
LineBrk * plbNextToTry)
|
|
|
|
{
|
|
|
|
@@ -1576,7 +1581,11 @@
|
|
|
|
Return the break weight of the given slot, which should be a line-break.
|
|
|
|
OBSOLETE??
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+LineBrk GrSlotStream::BreakWeightAt(gid16 /*chwLB*/, int islot)
|
|
|
|
+#else
|
|
|
|
LineBrk GrSlotStream::BreakWeightAt(gid16 chwLB, int islot)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
GrSlotState * pslot = GetSlotAt(islot);
|
|
|
|
Assert(pslot->IsLineBreak(chwLB));
|
|
|
|
@@ -1769,7 +1778,7 @@
|
|
|
|
@param fBackingUp - this chunk results in the stream position moving backwards,
|
|
|
|
so clear anything we're backing over
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrSlotStream::MapInputChunk(int islotInputMin, int islotOutputMin, int islotInputLim,
|
|
|
|
+void GrSlotStream::MapInputChunk(int islotInputMin, int islotOutputMin, int /*islotInputLim*/,
|
|
|
|
bool fSkipChunkStart, bool fBackingUp)
|
|
|
|
{
|
|
|
|
Assert(AssertValid());
|
|
|
|
@@ -1828,7 +1837,7 @@
|
|
|
|
@param fBackingUp - this chunk results in the stream position moving backwards,
|
|
|
|
so clear anything we're backing over
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrSlotStream::MapOutputChunk(int islotOutputMin, int islotInputMin, int islotOutputLim,
|
|
|
|
+void GrSlotStream::MapOutputChunk(int islotOutputMin, int islotInputMin, int /*islotOutputLim*/,
|
|
|
|
bool fSkipChunkStart, int cslotReprocess, bool fBackingUp)
|
|
|
|
{
|
|
|
|
Assert(AssertValid());
|
|
|
|
@@ -1863,7 +1872,7 @@
|
|
|
|
Ensure that the chunk maps for a pair of streams match properly. The recipient is
|
|
|
|
the input stream.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrSlotStream::AssertChunkMapsValid(GrSlotStream * psstrmOut)
|
|
|
|
+void GrSlotStream::AssertChunkMapsValid(GrSlotStream * /*psstrmOut*/)
|
|
|
|
{
|
|
|
|
#ifdef _DEBUG
|
|
|
|
GrSlotStream * psstrmIn = this;
|
|
|
|
@@ -1915,7 +1924,7 @@
|
|
|
|
Ensure that corresponding items in the streams of a positioning pass have matching
|
|
|
|
stream indices. The recipient is the output stream.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrSlotStream::AssertStreamIndicesValid(GrSlotStream * psstrmIn)
|
|
|
|
+void GrSlotStream::AssertStreamIndicesValid(GrSlotStream * /*psstrmIn*/)
|
|
|
|
{
|
|
|
|
#ifdef _DEBUG
|
|
|
|
if (!GotIndexOffset())
|
|
|
|
@@ -1939,7 +1948,7 @@
|
|
|
|
in the output stream. (Currently the compiler ensures this by making it an error
|
|
|
|
to write rules that don't do this.)
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrSlotStream::AssertAttachmentsInOutput(int islotMin, int islotLim)
|
|
|
|
+void GrSlotStream::AssertAttachmentsInOutput(int /*islotMin*/, int /*islotLim*/)
|
|
|
|
{
|
|
|
|
#ifdef _DEBUG
|
|
|
|
for (int islot = islotMin; islot < islotLim; islot++)
|
|
|
|
@@ -2007,7 +2016,7 @@
|
|
|
|
Record the number of slots in the stream that are previous to the official start of the
|
|
|
|
segment.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrSlotStream::CalcIndexOffset(GrTableManager * ptman)
|
|
|
|
+void GrSlotStream::CalcIndexOffset(GrTableManager * /*ptman*/)
|
|
|
|
{
|
|
|
|
if (GotIndexOffset())
|
|
|
|
return; // already figured it
|
|
|
|
@@ -2203,6 +2212,21 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
+ In the middle of running a pass, return the given slot to use in processing.
|
|
|
|
+ Read it from the reprocess buffer if appropriate, or for slots previous to the current
|
|
|
|
+ position, read from the output stream (psstrmNext).
|
|
|
|
+
|
|
|
|
+ psstrmNext may be NULL when processing is complete, therefore we only have one stream to
|
|
|
|
+ deal with.
|
|
|
|
+----------------------------------------------------------------------------------------------*/
|
|
|
|
+GrSlotState * GrSlotStream::MidPassSlotAt(int islot, GrSlotStream * psstrmNext)
|
|
|
|
+{
|
|
|
|
+ int islotInput = islot - ReadPosForNextGet() + 1; // +1 because RuleInputSlot takes 0 to mean the previously read slot
|
|
|
|
+ GrSlotState * pslot = RuleInputSlot(islotInput, psstrmNext);
|
|
|
|
+ return pslot;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+/*----------------------------------------------------------------------------------------------
|
|
|
|
Return the "current" input item from the rule's perspective, ie, the last slot read.
|
|
|
|
So dislotOffset = 0 means not the slot at the read position but one slot earlier.
|
|
|
|
|
|
|
|
@@ -2214,7 +2238,6 @@
|
|
|
|
@param fNullOkay - true if it's okay to return NULL in the situation where we're asking
|
|
|
|
for something before the beginning of the stream
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-
|
|
|
|
GrSlotState * GrSlotStream::RuleInputSlot(int dislotOffset, GrSlotStream * psstrmOutput,
|
|
|
|
bool fNullOkay)
|
|
|
|
{
|
|
|
|
@@ -2244,8 +2267,10 @@
|
|
|
|
|
|
|
|
if (cslotOffsetBack >= cslotPostReproc + cslotValidReproc)
|
|
|
|
{
|
|
|
|
- // Read from the output stream.
|
|
|
|
- int dislotTmp = dislotOffset - 1 + cslotPostReproc + cslotValidReproc;
|
|
|
|
+ // Read from the output stream. (Remember that PeekBack works relative to
|
|
|
|
+ // the rule-start write position, not the current write position.)
|
|
|
|
+ int dislotTmp = dislotOffset - 1 + cslotPostReproc
|
|
|
|
+ + cslotValidReproc - SlotsToReprocess();
|
|
|
|
Assert(dislotTmp < 0);
|
|
|
|
return psstrmOutput->PeekBack(dislotTmp);
|
|
|
|
}
|
|
|
|
@@ -2253,7 +2278,7 @@
|
|
|
|
{
|
|
|
|
if (m_islotReprocPos > -1)
|
|
|
|
{
|
|
|
|
- // Current read pos is inside reprocess buffer.
|
|
|
|
+ // Current read pos could be inside reprocess buffer.
|
|
|
|
Assert(cslotPostReproc == 0);
|
|
|
|
int islotStartReadReprocBuf = m_vpslotReproc.size() - cslotValidReproc;
|
|
|
|
Assert(islotStartReadReprocBuf >= 0);
|
|
|
|
@@ -2342,9 +2367,10 @@
|
|
|
|
else if (pslotAfter)
|
|
|
|
pslot->Associate(pslotAfter);
|
|
|
|
else
|
|
|
|
+ {
|
|
|
|
// Weird, but can happen with an empty segment.
|
|
|
|
Warn("No assocations");
|
|
|
|
-
|
|
|
|
+ }
|
|
|
|
// Assert(pslot->m_vpslotAssoc.Size() > 0);
|
|
|
|
pslot->m_fNeutralAssocs = true;
|
|
|
|
}
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrSlotStream.h Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrSlotStream.h Sat Aug 22 19:36:34 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -107,7 +107,7 @@
|
|
|
|
ReleaseSlots(0, m_vpslot.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
- void ReleaseSlots(int islotMin, int islotLim)
|
|
|
|
+ void ReleaseSlots(int /*islotMin*/, int /*islotLim*/)
|
|
|
|
{
|
|
|
|
// A slot stream is responsible for deleting the slot states that it created,
|
|
|
|
// that is, the ones whose modified tag equals this stream's pass index.
|
|
|
|
@@ -182,6 +182,7 @@
|
|
|
|
return Peek(islot - ReadPosForNextGet());
|
|
|
|
}
|
|
|
|
|
|
|
|
+ // Return the functional read position, taking into account the reprocess buffer.
|
|
|
|
int ReadPosForNextGet()
|
|
|
|
{
|
|
|
|
return ReadPos() - SlotsToReprocess();
|
|
|
|
@@ -260,12 +261,16 @@
|
|
|
|
|
|
|
|
void MarkFullyWritten();
|
|
|
|
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+ void SetSegMin(int islot, bool /*fAdjusting*/ = false)
|
|
|
|
+#else
|
|
|
|
void SetSegMin(int islot, bool fAdjusting = false)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
Assert(fAdjusting || m_islotSegMin == -1 || m_islotSegMin == islot);
|
|
|
|
m_islotSegMin = islot;
|
|
|
|
}
|
|
|
|
- void SetSegMinToWritePos(bool fMod = true)
|
|
|
|
+ void SetSegMinToWritePos(bool /*fMod*/ = true)
|
|
|
|
{
|
|
|
|
if (m_islotSegMin == -1)
|
|
|
|
m_islotSegMin = m_islotWritePos;
|
|
|
|
@@ -456,6 +461,7 @@
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
+ GrSlotState * MidPassSlotAt(int islot, GrSlotStream * psstrmNext = NULL);
|
|
|
|
GrSlotState * RuleInputSlot(int dislot = 0, GrSlotStream * psstrmOut = NULL,
|
|
|
|
bool fNullOkay = false);
|
|
|
|
GrSlotState * RuleOutputSlot(int dislot = 0);
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrTableManager.cpp Wed Jan 28 04:01:29 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrTableManager.cpp Sat Aug 22 19:36:34 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -25,8 +25,8 @@
|
|
|
|
DEFINE_THIS_FILE
|
|
|
|
#ifndef _WIN32
|
|
|
|
#include <stdlib.h>
|
|
|
|
-#include <math.h>
|
|
|
|
#endif
|
|
|
|
+#include <math.h>
|
|
|
|
|
|
|
|
//:>********************************************************************************************
|
|
|
|
//:> Forward declarations
|
|
|
|
@@ -572,7 +572,7 @@
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Assert(!m_engst.m_fInsertedLB);
|
|
|
|
- Assert(islotUnderBreak == -1 || m_engst.m_fFinalLB);
|
|
|
|
+ //Assert(islotUnderBreak == -1 || m_engst.m_fFinalLB); -- no, ExtendGlyphIDOutput clearly sets islotUnderBreak regardless
|
|
|
|
}
|
|
|
|
int islotTmp = OutputStream(m_cpass - 1)->WritePos();
|
|
|
|
GrSlotState * pslotTmp;
|
|
|
|
@@ -931,7 +931,7 @@
|
|
|
|
@param plbFound - kind of line-break created
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
bool GrTableManager::Backtrack(int * pislotPrevBreak,
|
|
|
|
- LineBrk * plbMin, LineBrk lbMax, TrWsHandling twsh, bool fMoreText,
|
|
|
|
+ LineBrk * plbMin, LineBrk lbMax, TrWsHandling twsh, bool /*fMoreText*/,
|
|
|
|
int ichwCallerBtLim, bool fEndLine,
|
|
|
|
LineBrk * plbFound)
|
|
|
|
{
|
|
|
|
@@ -1343,7 +1343,7 @@
|
|
|
|
Calculate the associations, and record the output slots in the segment.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void GrTableManager::RecordAssocsAndOutput(Font * pfont,
|
|
|
|
- Segment * pseg, bool fWidthIsCharCount,
|
|
|
|
+ Segment * pseg, bool /*fWidthIsCharCount*/,
|
|
|
|
TrWsHandling twsh, bool fParaRtl, int nDirDepth)
|
|
|
|
{
|
|
|
|
int cchwUnderlying = pseg->stopCharacter() - pseg->startCharacter();
|
|
|
|
@@ -1362,7 +1362,7 @@
|
|
|
|
#endif // OLD_TEST_STUFF
|
|
|
|
|
|
|
|
// Make sure the final positions are set for every glyph.
|
|
|
|
- CalcPositionsUpTo(m_cpass-1, reinterpret_cast<GrSlotState *>(NULL),
|
|
|
|
+ CalcPositionsUpTo(m_cpass-1, reinterpret_cast<GrSlotState *>(NULL), false,
|
|
|
|
&xsTotalWidth, &xsVisWidth);
|
|
|
|
pseg->SetWidths(xsVisWidth, xsTotalWidth);
|
|
|
|
|
|
|
|
@@ -1377,7 +1377,7 @@
|
|
|
|
Calculate the underlying-to-surface associations and ligature mappings.
|
|
|
|
Assumes the arrays have been properly initialized.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrTableManager::CalculateAssociations(Segment * pseg, int csloutSurface)
|
|
|
|
+void GrTableManager::CalculateAssociations(Segment * pseg, int /*csloutSurface*/)
|
|
|
|
{
|
|
|
|
GrSlotStream * psstrmFinal = OutputStream(m_cpass-1);
|
|
|
|
|
|
|
|
@@ -2350,18 +2350,20 @@
|
|
|
|
final pass, but it could be another if positions are
|
|
|
|
requested by the rules themselves
|
|
|
|
@param pslotLast - last slot that needs to be positioned, or NULL
|
|
|
|
+ @param fMidPass - calculating the position of some slot in the middle of the pass
|
|
|
|
@param pxsWidth - return the total width used so far
|
|
|
|
@param psxVisibleWidth - return the visible width so far
|
|
|
|
|
|
|
|
MOVE to EngineState
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrTableManager::CalcPositionsUpTo(int ipass, GrSlotState * pslotLast,
|
|
|
|
+void GrTableManager::CalcPositionsUpTo(int ipass, GrSlotState * pslotLast, bool fMidPass,
|
|
|
|
float * pxsWidth, float * pxsVisibleWidth)
|
|
|
|
{
|
|
|
|
Assert(ipass >= m_ipassPos1 - 1);
|
|
|
|
|
|
|
|
int isstrm = ipass;
|
|
|
|
GrSlotStream * psstrm = OutputStream(isstrm);
|
|
|
|
+ GrSlotStream * psstrmNext = (isstrm >= m_cpass - 1) ? NULL : OutputStream(isstrm + 1);
|
|
|
|
Assert(psstrm->GotIndexOffset());
|
|
|
|
if (psstrm->WritePos() <= psstrm->IndexOffset())
|
|
|
|
{
|
|
|
|
@@ -2399,7 +2401,9 @@
|
|
|
|
// to be later in the stream than the last actual slot passed in.
|
|
|
|
if (!psstrm->HasSlotAtPosPassIndex(pslotLast->AttachRootPosPassIndex()))
|
|
|
|
return;
|
|
|
|
- GrSlotState * pslotLastBase = pslotLast->Base(psstrm);
|
|
|
|
+ GrSlotState * pslotLastBase = (fMidPass && pslotLast->PosPassIndex() < psstrm->WritePos())
|
|
|
|
+ ? pslotLast->Base(psstrmNext)
|
|
|
|
+ : pslotLast->Base(psstrm);
|
|
|
|
|
|
|
|
if (ipass == m_cpass - 1 && m_engst.m_islotPosNext > -1)
|
|
|
|
{
|
|
|
|
@@ -2428,6 +2432,7 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<GrSlotState *> vpslotAttached;
|
|
|
|
+ std::vector<GrSlotStream *> vpsstrmAttached;
|
|
|
|
|
|
|
|
bool fRtl = RightToLeft();
|
|
|
|
|
|
|
|
@@ -2435,13 +2440,24 @@
|
|
|
|
{
|
|
|
|
Assert(islot < psstrm->SlotsPresent());
|
|
|
|
|
|
|
|
- pslot = (isstrm == ipass) ? psstrm->SlotAt(islot) : psstrm->OutputSlotAt(islot);
|
|
|
|
+ GrSlotStream * psstrmThis = psstrm;
|
|
|
|
+ if (fMidPass && islot < psstrm->WritePos())
|
|
|
|
+ {
|
|
|
|
+ pslot = psstrm->MidPassSlotAt(islot, psstrmNext);
|
|
|
|
+ psstrmThis = psstrmNext;
|
|
|
|
+ }
|
|
|
|
+ else
|
|
|
|
+ {
|
|
|
|
+ //pslot = (isstrm == ipass) ? psstrm->SlotAt(islot) : psstrm->OutputSlotAt(islot);
|
|
|
|
+ pslot = psstrm->SlotAt(islot);
|
|
|
|
+ }
|
|
|
|
|
|
|
|
if (!pslot->IsBase())
|
|
|
|
{
|
|
|
|
// This slot is attached to another; it will be positioned strictly
|
|
|
|
// relative to that one. This happens in the loop below.
|
|
|
|
vpslotAttached.push_back(pslot);
|
|
|
|
+ vpsstrmAttached.push_back(psstrmThis);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
@@ -2455,7 +2471,7 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure the metrics are the complete ones.
|
|
|
|
- pslot->CalcCompositeMetrics(this, psstrm, kPosInfinity, true);
|
|
|
|
+ pslot->CalcCompositeMetrics(this, psstrm, psstrmNext, kPosInfinity, true);
|
|
|
|
|
|
|
|
float xsInc = pslot->GlyphXOffset(psstrm, fakeItalicRatio);
|
|
|
|
float ysInc = pslot->GlyphYOffset(psstrm);
|
|
|
|
@@ -2514,8 +2530,9 @@
|
|
|
|
|
|
|
|
for (size_t ipslot = 0; ipslot < vpslotAttached.size(); ipslot++)
|
|
|
|
{
|
|
|
|
- GrSlotState * pslot = vpslotAttached[ipslot];
|
|
|
|
- GrSlotState * pslotBase = pslot->Base(psstrm);
|
|
|
|
+ GrSlotState * pslotAtt = vpslotAttached[ipslot];
|
|
|
|
+ GrSlotStream * psstrmAtt = vpsstrmAttached[ipslot];
|
|
|
|
+ GrSlotState * pslotBase = pslotAtt->Base(psstrmAtt);
|
|
|
|
if (pslotBase->XPosition() == kNegInfinity || pslotBase->YPosition() == kNegInfinity)
|
|
|
|
{
|
|
|
|
Assert(false);
|
|
|
|
@@ -2523,10 +2540,10 @@
|
|
|
|
}
|
|
|
|
float xsCluster = pslotBase->XPosition() - pslotBase->GlyphXOffset(psstrm, fakeItalicRatio);
|
|
|
|
float ysCluster = pslotBase->YPosition() - pslotBase->GlyphYOffset(psstrm);
|
|
|
|
- float xsInc = pslot->GlyphXOffset(psstrm, fakeItalicRatio);
|
|
|
|
- float ysInc = pslot->GlyphYOffset(psstrm);
|
|
|
|
- pslot->SetXPos(xsCluster + xsInc);
|
|
|
|
- pslot->SetYPos(ysCluster + ysInc);
|
|
|
|
+ float xsInc = pslotAtt->GlyphXOffset(psstrm, fakeItalicRatio);
|
|
|
|
+ float ysInc = pslotAtt->GlyphYOffset(psstrm);
|
|
|
|
+ pslotAtt->SetXPos(xsCluster + xsInc);
|
|
|
|
+ pslotAtt->SetYPos(ysCluster + ysInc);
|
|
|
|
|
|
|
|
// My theory is that we don't need to adjust *pxsWidth here, because the width of
|
|
|
|
// any non-base slots should be factored into the advance width of their cluster
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/GrTableManager.h Wed Jan 28 04:01:29 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/GrTableManager.h Sat Aug 22 19:36:35 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -442,7 +442,7 @@
|
|
|
|
int LogToEmUnits(float xys);
|
|
|
|
bool GPointToXY(gid16 chwGlyphID, int nGPoint, float * xs, float * ys);
|
|
|
|
|
|
|
|
- void CalcPositionsUpTo(int ipass, GrSlotState * pslotLast,
|
|
|
|
+ void CalcPositionsUpTo(int ipass, GrSlotState * pslotLast, bool fMidPass,
|
|
|
|
float * pxsWidth, float * pxsVisibleWidth);
|
|
|
|
|
|
|
|
void InitPosCache()
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/Platform.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/Platform.cpp Sat Aug 22 19:36:35 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -103,7 +103,7 @@
|
|
|
|
{
|
|
|
|
// assumes NULL terminated strings
|
|
|
|
const utf16 *start = s;
|
|
|
|
- for (; *s; ++s);
|
|
|
|
+ for (; *s; ++s) {};
|
|
|
|
|
|
|
|
return s - start;
|
|
|
|
}
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/Segment.cpp Thu Aug 21 16:24:32 2008
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/Segment.cpp Sat Aug 22 19:36:35 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -1178,7 +1178,7 @@
|
|
|
|
part of the segment.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
float Segment::getRangeWidth(int ichMin, int ichLim,
|
|
|
|
- bool fStartLine, bool fEndLine, bool fSkipSpace)
|
|
|
|
+ bool /*fStartLine*/, bool /*fEndLine*/, bool fSkipSpace)
|
|
|
|
{
|
|
|
|
if (m_dxsWidth < 0)
|
|
|
|
{
|
|
|
|
@@ -1549,7 +1549,11 @@
|
|
|
|
void Segment::SetUpOutputArrays(Font * pfont, GrTableManager * ptman,
|
|
|
|
GrSlotStream * psstrmFinal,
|
|
|
|
int cchwInThisSeg, int csloutSurface, gid16 chwLB,
|
|
|
|
+#ifdef NDEBUG
|
|
|
|
+ TrWsHandling twsh, bool fParaRtl, int nDirDepth, bool /*fEmpty*/)
|
|
|
|
+#else
|
|
|
|
TrWsHandling twsh, bool fParaRtl, int nDirDepth, bool fEmpty)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
m_mFontEmUnits = EngineImpl()->GetFontEmUnits();
|
|
|
|
|
|
|
|
@@ -1725,7 +1729,7 @@
|
|
|
|
Set up the data structures that represent the actual rendered glyphs for the new segment.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void Segment::SetUpGlyphInfo(GrTableManager * ptman, GrSlotStream * psstrmFinal,
|
|
|
|
- gid16 chwLB, int nDirDepth, int islotMin, int cslot)
|
|
|
|
+ gid16 chwLB, int /*nDirDepth*/, int islotMin, int cslot)
|
|
|
|
{
|
|
|
|
//int paraDirLevel = (ptman->State()->ParaRightToLeft()) ? 1 : 0;
|
|
|
|
|
|
|
|
@@ -1751,7 +1755,7 @@
|
|
|
|
|
|
|
|
m_isloutGinf0 = -1;
|
|
|
|
int iginf = 0;
|
|
|
|
- for (int islot = islotMin; islot < cslot; islot++)
|
|
|
|
+ for (islot = islotMin; islot < cslot; islot++)
|
|
|
|
{
|
|
|
|
GrSlotState * pslot = psstrmFinal->SlotAt(islot);
|
|
|
|
|
|
|
|
@@ -2160,7 +2164,7 @@
|
|
|
|
@param ichwUnder - character index relative to the official beginning of the segment
|
|
|
|
@param islot - processed glyph it maps to
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void Segment::MarkSlotInPrevSeg(int ichwUnder, int islot)
|
|
|
|
+void Segment::MarkSlotInPrevSeg(int ichwUnder, int /*islot*/)
|
|
|
|
{
|
|
|
|
if (ichwUnder >= m_ichwAssocsMin)
|
|
|
|
m_prgisloutBefore[ichwUnder - m_ichwAssocsMin] = kNegInfinity;
|
|
|
|
@@ -2174,7 +2178,7 @@
|
|
|
|
@param ichwUnder - character index relative to the official beginning of the segment
|
|
|
|
@param islot - processed glyph it maps to
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void Segment::MarkSlotInNextSeg(int ichwUnder, int islot)
|
|
|
|
+void Segment::MarkSlotInNextSeg(int ichwUnder, int /*islot*/)
|
|
|
|
{
|
|
|
|
if (ichwUnder < m_ichwAssocsLim)
|
|
|
|
m_prgisloutAfter[ichwUnder - m_ichwAssocsMin] = kPosInfinity;
|
|
|
|
@@ -2351,7 +2355,7 @@
|
|
|
|
@param pfAfter - return true if they clicked on trailing side; possibly NULL
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
int Segment::LogicalSurfaceToUnderlying(int islout, float xsOffset, float ysClick,
|
|
|
|
- float dxsGlyphWidth, float dysGlyphHeight, bool * pfAfter)
|
|
|
|
+ float dxsGlyphWidth, float /*dysGlyphHeight*/, bool * pfAfter)
|
|
|
|
{
|
|
|
|
Assert(islout >= 0);
|
|
|
|
Assert(islout < m_cslout);
|
|
|
|
@@ -2529,31 +2533,31 @@
|
|
|
|
else if (fBefore)
|
|
|
|
{
|
|
|
|
int isloutRet;
|
|
|
|
- int ichw = ichwSegOffset;
|
|
|
|
+ int ichwTemp = ichwSegOffset;
|
|
|
|
// If no association has been made, loop forward to the next slot
|
|
|
|
// we are before. As a last resort, answer kPosInfinity, meaning we
|
|
|
|
// aren't before anything.
|
|
|
|
do
|
|
|
|
{
|
|
|
|
- isloutRet = m_prgisloutBefore[ichw - m_ichwAssocsMin];
|
|
|
|
- do { ++ichw; }
|
|
|
|
- while (!GrCharStream::AtUnicodeCharBoundary(m_pgts, ichw));
|
|
|
|
- } while (isloutRet == kPosInfinity && ichw < m_ichwAssocsLim);
|
|
|
|
+ isloutRet = m_prgisloutBefore[ichwTemp - m_ichwAssocsMin];
|
|
|
|
+ do { ++ichwTemp; }
|
|
|
|
+ while (!GrCharStream::AtUnicodeCharBoundary(m_pgts, ichwTemp));
|
|
|
|
+ } while (isloutRet == kPosInfinity && ichwTemp < m_ichwAssocsLim);
|
|
|
|
return isloutRet;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int isloutRet;
|
|
|
|
- int ichw = ichwSegOffset;
|
|
|
|
+ int ichwTemp = ichwSegOffset;
|
|
|
|
// If no association has been made, loop backward to the previous slot
|
|
|
|
// we are after. As a last resort, answer kNegInfinity, meaning we
|
|
|
|
// aren't after anything.
|
|
|
|
do
|
|
|
|
{
|
|
|
|
- isloutRet = m_prgisloutAfter[ichw - m_ichwAssocsMin];
|
|
|
|
- do { --ichw; }
|
|
|
|
- while (!GrCharStream::AtUnicodeCharBoundary(m_pgts, ichw));
|
|
|
|
- } while (isloutRet == kNegInfinity && ichw >= 0);
|
|
|
|
+ isloutRet = m_prgisloutAfter[ichwTemp - m_ichwAssocsMin];
|
|
|
|
+ do { --ichwTemp; }
|
|
|
|
+ while (!GrCharStream::AtUnicodeCharBoundary(m_pgts, ichwTemp));
|
|
|
|
+ } while (isloutRet == kNegInfinity && ichwTemp >= 0);
|
|
|
|
return isloutRet;
|
|
|
|
}
|
|
|
|
Assert(false); // should never reach here
|
|
|
|
@@ -2748,7 +2752,11 @@
|
|
|
|
that root glyph as one of its roots.
|
|
|
|
OBSOLETE
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
+#ifdef _DEBUG
|
|
|
|
void Segment::AssertValidClusters(GrSlotStream * psstrm)
|
|
|
|
+#else
|
|
|
|
+void Segment::AssertValidClusters(GrSlotStream * /*psstrm*/)
|
|
|
|
+#endif
|
|
|
|
{
|
|
|
|
#ifdef _DEBUG
|
|
|
|
for (int islot = 0; islot < psstrm->WritePos(); islot++)
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/src/segment/TransductionLog.cpp Wed Jan 28 04:01:29 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/src/segment/TransductionLog.cpp Sat Aug 22 19:36:35 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -175,7 +175,7 @@
|
|
|
|
Output a file showing a log of the transduction process and the resulting segment.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void GrTableManager::WriteXductnLog(std::ostream & strmOut,
|
|
|
|
- GrCharStream * pchstrm, Segment * psegRet,
|
|
|
|
+ GrCharStream * pchstrm, Segment * /*psegRet*/,
|
|
|
|
int cbPrevSegDat, byte * pbPrevSegDat)
|
|
|
|
{
|
|
|
|
if (cbPrevSegDat == 0)
|
|
|
|
@@ -416,8 +416,8 @@
|
|
|
|
the raw (UTF-16 or UTF-8) chars for display. To do this we get the raw characters
|
|
|
|
directly from the text source.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-void GrCharStream::GetLogDataRaw(GrTableManager * ptman, int cchl, int cchrBackup,
|
|
|
|
- int cchrMaxRaw, int * prgchl,
|
|
|
|
+void GrCharStream::GetLogDataRaw(GrTableManager * /*ptman*/, int cchl, int cchrBackup,
|
|
|
|
+ int /*cchrMaxRaw*/, int * prgchl,
|
|
|
|
utf16 * prgchw2, utf16 * prgchw3, utf16 * prgchw4, utf16 * prgchw5, utf16 * prgchw6,
|
|
|
|
int * prgcchr)
|
|
|
|
{
|
|
|
|
@@ -441,7 +441,7 @@
|
|
|
|
case kutf8:
|
|
|
|
prgchsRunText8 = new utf8[cchrRange];
|
|
|
|
m_pgts->fetch(ichrMin, cchrRange, prgchsRunText8);
|
|
|
|
- for (int ichr = 0; ichr < cchrRange; ichr++)
|
|
|
|
+ for (ichr = 0; ichr < cchrRange; ichr++)
|
|
|
|
prgchwRunText[ichr] = (utf16)prgchsRunText8[ichr]; // zero-extend into UTF-16 buffer
|
|
|
|
break;
|
|
|
|
case kutf16:
|
|
|
|
@@ -634,7 +634,7 @@
|
|
|
|
m_pzpst->LogRulesFiredAndFailed(strmOut, psstrmIn);
|
|
|
|
}
|
|
|
|
|
|
|
|
-void PassState::LogRulesFiredAndFailed(std::ostream & strmOut, GrSlotStream * psstrmIn)
|
|
|
|
+void PassState::LogRulesFiredAndFailed(std::ostream & strmOut, GrSlotStream * /*psstrmIn*/)
|
|
|
|
{
|
|
|
|
|
|
|
|
strmOut << "PASS " << m_ipass << "\n\n" << "Rules matched: ";
|
|
|
|
@@ -1193,7 +1193,7 @@
|
|
|
|
if (fAnyPseudos)
|
|
|
|
{
|
|
|
|
strmOut << "Actual glyphs: ";
|
|
|
|
- for (int islout = 0; islout < m_cslout; islout++)
|
|
|
|
+ for (islout = 0; islout < m_cslout; islout++)
|
|
|
|
{
|
|
|
|
GrSlotOutput * psloutTmp = m_prgslout + islout;
|
|
|
|
if (psloutTmp->GlyphID() != psloutTmp->ActualGlyphForOutput(ptman))
|
|
|
|
@@ -1319,7 +1319,7 @@
|
|
|
|
Write out the header lines for the slot contents.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void GrTableManager::LogSlotHeader(std::ostream & strmOut, int islotLim,
|
|
|
|
- int cspPerSlot, int cspLeading, int islotMin)
|
|
|
|
+ int /*cspPerSlot*/, int cspLeading, int islotMin)
|
|
|
|
{
|
|
|
|
islotLim = min(islotLim, MAX_SLOTS);
|
|
|
|
|
|
|
|
@@ -1721,7 +1721,7 @@
|
|
|
|
|
|
|
|
case kslatAttAtX: // always do these in pairs
|
|
|
|
case kslatAttAtY:
|
|
|
|
- if (m_mAttachAtX != (pslotPrev ? pslotPrev->m_mAttachAtX : kNotYetSet) ||
|
|
|
|
+ if (m_mAttachAtX != (pslotPrev ? pslotPrev->m_mAttachAtX : static_cast<short>(kNotYetSet)) ||
|
|
|
|
m_mAttachAtY != (pslotPrev ? pslotPrev->m_mAttachAtY : 0))
|
|
|
|
{
|
|
|
|
ptman->LogInTable(strmOut,
|
|
|
|
@@ -1730,7 +1730,7 @@
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case kslatAttAtGpt:
|
|
|
|
- if (m_nAttachAtGpoint != (pslotPrev ? pslotPrev->m_nAttachAtGpoint : kNotYetSet))
|
|
|
|
+ if (m_nAttachAtGpoint != (pslotPrev ? pslotPrev->m_nAttachAtGpoint : static_cast<short>(kNotYetSet)))
|
|
|
|
{
|
|
|
|
ptman->LogInTable(strmOut,
|
|
|
|
((m_nAttachAtGpoint == kGpointZero) ? 0 : m_nAttachAtGpoint));
|
|
|
|
@@ -1750,7 +1750,7 @@
|
|
|
|
|
|
|
|
case kslatAttWithX: // always do these in pairs
|
|
|
|
case kslatAttWithY:
|
|
|
|
- if (m_mAttachWithX != (pslotPrev ? pslotPrev->m_mAttachWithX : kNotYetSet) ||
|
|
|
|
+ if (m_mAttachWithX != (pslotPrev ? pslotPrev->m_mAttachWithX : static_cast<short>(kNotYetSet)) ||
|
|
|
|
m_mAttachWithY != (pslotPrev ? pslotPrev->m_mAttachWithY : 0))
|
|
|
|
{
|
|
|
|
ptman->LogInTable(strmOut,
|
|
|
|
@@ -1759,7 +1759,7 @@
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case kslatAttWithGpt:
|
|
|
|
- if (m_nAttachWithGpoint != (pslotPrev ? pslotPrev->m_nAttachWithGpoint : kNotYetSet))
|
|
|
|
+ if (m_nAttachWithGpoint != (pslotPrev ? pslotPrev->m_nAttachWithGpoint : static_cast<short>(kNotYetSet)))
|
|
|
|
{
|
|
|
|
ptman->LogInTable(strmOut,
|
|
|
|
((m_nAttachWithGpoint == kGpointZero) ? 0 : m_nAttachWithGpoint));
|
|
|
|
@@ -1786,14 +1786,14 @@
|
|
|
|
break;
|
|
|
|
|
|
|
|
case kslatBreak:
|
|
|
|
- if (m_lb != (pslotPrev ? pslotPrev->m_lb : kNotYetSet8))
|
|
|
|
+ if (m_lb != (pslotPrev ? pslotPrev->m_lb : static_cast<sdata8>(kNotYetSet8)))
|
|
|
|
{
|
|
|
|
ptman->LogBreakWeightInTable(strmOut, m_lb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case kslatDir:
|
|
|
|
- if (m_dirc != (pslotPrev ? pslotPrev->m_dirc : kNotYetSet8))
|
|
|
|
+ if (m_dirc != (pslotPrev ? pslotPrev->m_dirc : static_cast<sdata8>(kNotYetSet8)))
|
|
|
|
{
|
|
|
|
ptman->LogDirCodeInTable(strmOut, m_dirc);
|
|
|
|
return;
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/test/ProfileHarness/GrUtfTextSrc.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/test/ProfileHarness/GrUtfTextSrc.cpp Sat Aug 22 19:36:35 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -210,12 +210,12 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
-bool GrUtfTextSrc::getRightToLeft(gr::toffset ich)
|
|
|
|
+bool GrUtfTextSrc::getRightToLeft(gr::toffset /*ich*/)
|
|
|
|
{
|
|
|
|
return mRtl; // assumes src only contains one direction
|
|
|
|
}
|
|
|
|
|
|
|
|
-unsigned int GrUtfTextSrc::getDirectionDepth(gr::toffset ich)
|
|
|
|
+unsigned int GrUtfTextSrc::getDirectionDepth(gr::toffset /*ich*/)
|
|
|
|
{
|
|
|
|
return (mRtl) ? 1 : 0; // TBD
|
|
|
|
}
|
|
|
|
@@ -254,7 +254,7 @@
|
|
|
|
return range;
|
|
|
|
}
|
|
|
|
|
|
|
|
-size_t GrUtfTextSrc::getFontFeatures(gr::toffset ich, gr::FeatureSetting * prgfset)
|
|
|
|
+size_t GrUtfTextSrc::getFontFeatures(gr::toffset /*ich*/, gr::FeatureSetting * /*prgfset*/)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
@@ -277,14 +277,14 @@
|
|
|
|
|
|
|
|
// these should be called I hope
|
|
|
|
float
|
|
|
|
-GrUtfTextSrc::getFontSize(gr::toffset ich)
|
|
|
|
+GrUtfTextSrc::getFontSize(gr::toffset /*ich*/)
|
|
|
|
{
|
|
|
|
assert(mFont);
|
|
|
|
return mPointSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
-GrUtfTextSrc::getBold(gr::toffset ich)
|
|
|
|
+GrUtfTextSrc::getBold(gr::toffset /*ich*/)
|
|
|
|
{
|
|
|
|
assert(mFont);
|
|
|
|
// NS_ASSERTION(false, "unexpected call to getBold");
|
|
|
|
@@ -293,7 +293,7 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
-GrUtfTextSrc::getItalic(gr::toffset ich)
|
|
|
|
+GrUtfTextSrc::getItalic(gr::toffset /*ich*/)
|
|
|
|
{
|
|
|
|
assert(mFont);
|
|
|
|
//NS_ASSERTION(false, "unexpected call to getItalic");
|
|
|
|
@@ -301,7 +301,7 @@
|
|
|
|
return mFont->italic();
|
|
|
|
}
|
|
|
|
|
|
|
|
-gr::isocode GrUtfTextSrc::getLanguage(gr::toffset ich)
|
|
|
|
+gr::isocode GrUtfTextSrc::getLanguage(gr::toffset /*ich*/)
|
|
|
|
{
|
|
|
|
gr::isocode unknown;
|
|
|
|
std::fill_n(unknown.rgch, 4, '\0');
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/test/ProfileHarness/GrUtfTextSrc.h Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/test/ProfileHarness/GrUtfTextSrc.h Sat Aug 22 19:36:35 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -79,7 +79,7 @@
|
|
|
|
virtual size_t fetch(gr::toffset ichMin, size_t cch, gr::utf32 * prgchBuffer);
|
|
|
|
virtual size_t fetch(gr::toffset ichMin, size_t cch, gr::utf16 * prgchwBuffer);
|
|
|
|
virtual size_t fetch(gr::toffset ichMin, size_t cch, gr::utf8 * prgchsBuffer);
|
|
|
|
- virtual gr::GrResult getFaceName(int ich, unsigned int cchMax,
|
|
|
|
+ virtual gr::GrResult getFaceName(int /*ich*/, unsigned int /*cchMax*/,
|
|
|
|
gr::utf16 * prgchFaceName, unsigned int * pcchLen)
|
|
|
|
{
|
|
|
|
prgchFaceName[0] = 0;
|
|
|
|
@@ -92,12 +92,12 @@
|
|
|
|
virtual bool getItalic(gr::toffset ich);
|
|
|
|
virtual bool getRightToLeft(gr::toffset ich);
|
|
|
|
virtual unsigned int getDirectionDepth(gr::toffset ich);
|
|
|
|
- virtual float getVerticalOffset(gr::toffset ich) { return 0;};
|
|
|
|
+ virtual float getVerticalOffset(gr::toffset /*ich*/) { return 0;};
|
|
|
|
virtual gr::isocode getLanguage(gr::toffset ich);
|
|
|
|
|
|
|
|
virtual std::pair<gr::toffset, gr::toffset> propertyRange(gr::toffset ich);
|
|
|
|
virtual size_t getFontFeatures(gr::toffset ich, gr::FeatureSetting * prgfset);
|
|
|
|
- virtual bool sameSegment(gr::toffset ich1, gr::toffset ich2) { return true; };
|
|
|
|
+ virtual bool sameSegment(gr::toffset /*ich1*/, gr::toffset /*ich2*/) { return true; };
|
|
|
|
|
|
|
|
protected:
|
|
|
|
bool checkBuffer8();
|
|
|
|
@@ -129,11 +129,11 @@
|
|
|
|
virtual void getColors(gr::toffset ich, int * pclrFore, int * pclrBack);
|
|
|
|
|
|
|
|
// Shouldn't be here!
|
|
|
|
- virtual gr::GrResult Fetch(int ichMin, int ichLim, gr::utf16 * prgchBuf) { return gr::kresNotImpl; };
|
|
|
|
- virtual gr::GrResult get_Length(int * pcch) { return gr::kresNotImpl; };
|
|
|
|
- virtual gr::GrResult GetFontVariations(int ich,
|
|
|
|
- wchar_t * prgchFontVar, int ichMax, int * pich,
|
|
|
|
- int * pichMin, int * pichLim) { return gr::kresNotImpl; };
|
|
|
|
+ virtual gr::GrResult Fetch(int /*ichMin*/, int /*ichLim*/, gr::utf16 * /*prgchBuf*/) { return gr::kresNotImpl; };
|
|
|
|
+ virtual gr::GrResult get_Length(int * /*pcch*/) { return gr::kresNotImpl; };
|
|
|
|
+ virtual gr::GrResult GetFontVariations(int /*ich*/,
|
|
|
|
+ wchar_t * /*prgchFontVar*/, int /*ichMax*/, int * /*pich*/,
|
|
|
|
+ int * /*pichMin*/, int * /*pichLim*/) { return gr::kresNotImpl; };
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/test/ProfileHarness/ProfileHarness.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/test/ProfileHarness/ProfileHarness.cpp Sat Aug 22 19:36:35 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -39,14 +39,14 @@
|
|
|
|
typedef std::pair< gr::GlyphIterator, gr::GlyphIterator > GlyphRange;
|
|
|
|
|
|
|
|
#ifndef HAVE_STRTOF
|
|
|
|
-float strtof(char * text, char ** ignore)
|
|
|
|
+float strtof(char * text, char ** /*ignore*/)
|
|
|
|
{
|
|
|
|
return static_cast<float>(atof(text));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef HAVE_STRTOL
|
|
|
|
-long strtol(char * text, char ** ignore)
|
|
|
|
+long strtol(char * text, char ** /*ignore*/)
|
|
|
|
{
|
|
|
|
return atol(text);
|
|
|
|
}
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/test/RegressionTest/GrJustifier.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/test/RegressionTest/GrJustifier.cpp Sat Aug 22 19:36:35 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -327,7 +327,7 @@
|
|
|
|
&dxStretchAchieved);
|
|
|
|
for (int iiiGlyph = 0; iiiGlyph < cStretchable; iiiGlyph++)
|
|
|
|
{
|
|
|
|
- int iiGlyph = viiGlyphsRem[iiiGlyph];
|
|
|
|
+ iiGlyph = viiGlyphsRem[iiiGlyph];
|
|
|
|
vdxStretchLeft[iiGlyph] = vdxStretchRem[iiiGlyph];
|
|
|
|
vdxWidth[iiGlyph] = vdxWidthRem[iiiGlyph];
|
|
|
|
}
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/test/RegressionTest/RegressionTest.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/test/RegressionTest/RegressionTest.cpp Sat Aug 22 19:36:35 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -675,7 +675,7 @@
|
|
|
|
OutputErrorAux(ptcase, strErr, i, true, valueFound, valueExpected);
|
|
|
|
}
|
|
|
|
|
|
|
|
-void OutputErrorAux(TestCase * ptcase, std::string strErr, int i,
|
|
|
|
+void OutputErrorAux(TestCase * /*ptcase*/, std::string strErr, int i,
|
|
|
|
bool showValues, int valueFound, int valueExpected)
|
|
|
|
{
|
|
|
|
// if (g_debugMode)
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/test/RegressionTest/SimpleTextSrc.cpp Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/test/RegressionTest/SimpleTextSrc.cpp Sat Aug 22 19:36:36 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -70,7 +70,7 @@
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
Return true if the text uses a right-to-left writing system.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-bool SimpleTextSrc::getRightToLeft(toffset ich)
|
|
|
|
+bool SimpleTextSrc::getRightToLeft(toffset /*ich*/)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
@@ -78,7 +78,7 @@
|
|
|
|
/*----------------------------------------------------------------------------------------------
|
|
|
|
Return the depth of embedding of the writing system.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-unsigned int SimpleTextSrc::getDirectionDepth(toffset ich)
|
|
|
|
+unsigned int SimpleTextSrc::getDirectionDepth(toffset /*ich*/)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
@@ -87,7 +87,7 @@
|
|
|
|
Return the vertical offset of the text. This simple implementation provides no
|
|
|
|
vertical offset.
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
-float SimpleTextSrc::getVerticalOffset(toffset ich)
|
|
|
|
+float SimpleTextSrc::getVerticalOffset(toffset /*ich*/)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/engine/test/RegressionTest/SimpleTextSrc.h Thu Jan 22 00:36:42 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/engine/test/RegressionTest/SimpleTextSrc.h Sat Aug 22 19:36:36 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -59,12 +59,12 @@
|
|
|
|
{
|
|
|
|
return m_cchLength;
|
|
|
|
}
|
|
|
|
- virtual size_t fetch(toffset ichMin, size_t cch, utf32 * prgchBuffer)
|
|
|
|
+ virtual size_t fetch(toffset /*ichMin*/, size_t /*cch*/, utf32 * /*prgchBuffer*/)
|
|
|
|
{
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
virtual size_t fetch(toffset ichMin, size_t cch, gr::utf16 * prgchwBuffer);
|
|
|
|
- virtual size_t fetch(toffset ichMin, size_t cch, utf8 * prgchsBuffer)
|
|
|
|
+ virtual size_t fetch(toffset /*ichMin*/, size_t /*cch*/, utf8 * /*prgchsBuffer*/)
|
|
|
|
{
|
|
|
|
throw;
|
|
|
|
};
|
|
|
|
@@ -73,14 +73,14 @@
|
|
|
|
virtual unsigned int getDirectionDepth(toffset ich);
|
|
|
|
virtual float getVerticalOffset(toffset ich);
|
|
|
|
|
|
|
|
- virtual isocode getLanguage(toffset ich)
|
|
|
|
+ virtual isocode getLanguage(toffset /*ich*/)
|
|
|
|
{
|
|
|
|
isocode ret;
|
|
|
|
ret.rgch[0] = 'e'; ret.rgch[1] = 'n'; ret.rgch[2] = 0; ret.rgch[3] = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
- virtual std::pair<toffset, toffset> propertyRange(toffset ich)
|
|
|
|
+ virtual std::pair<toffset, toffset> propertyRange(toffset /*ich*/)
|
|
|
|
{
|
|
|
|
std::pair<toffset, toffset> pairRet;
|
|
|
|
pairRet.first = 0;
|
|
|
|
@@ -88,16 +88,16 @@
|
|
|
|
return pairRet;
|
|
|
|
}
|
|
|
|
|
|
|
|
- virtual size_t getFontFeatures(toffset ich, FeatureSetting * prgfset)
|
|
|
|
+ virtual size_t getFontFeatures(toffset /*ich*/, FeatureSetting * /*prgfset*/)
|
|
|
|
{
|
|
|
|
return 0; // no features in this simple implementation
|
|
|
|
}
|
|
|
|
- virtual bool sameSegment(toffset ich1, toffset ich2)
|
|
|
|
+ virtual bool sameSegment(toffset /*ich1*/, toffset /*ich2*/)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
- virtual void getColors(toffset ich, int * pclrFore, int * pclrBack)
|
|
|
|
+ virtual void getColors(toffset /*ich*/, int * pclrFore, int * pclrBack)
|
|
|
|
{
|
|
|
|
*pclrFore = kclrBlack;
|
|
|
|
*pclrBack = kclrTransparent;
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/wrappers/win32/WinFont.cpp Thu Jan 29 10:33:19 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/wrappers/win32/WinFont.cpp Sat Aug 22 19:36:36 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -767,7 +767,7 @@
|
|
|
|
----------------------------------------------------------------------------------------------*/
|
|
|
|
void WinFont::FontHandleCache::DeleteFont(HFONT hfont)
|
|
|
|
{
|
|
|
|
- if (!hfont || !m_bValid)
|
|
|
|
+ if (!hfont || !m_bValid || m_hmlffcv.size() == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// find the font in the hash map
|
2009-08-24 03:32:29 -05:00
|
|
|
--- misc/silgraphite-2.3.1/wrappers/win32/WinFont.h Thu Jan 29 10:33:19 2009
|
|
|
|
+++ misc/build/silgraphite-2.3.1/wrappers/win32/WinFont.h Sat Aug 22 19:36:36 2009
|
2009-08-17 09:12:14 -05:00
|
|
|
@@ -27,6 +27,10 @@
|
|
|
|
#include "GrClient.h"
|
|
|
|
#include "Font.h"
|
|
|
|
|
|
|
|
+#ifdef _STLPORT_VERSION
|
|
|
|
+namespace stdext = _STLP_STD;
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
namespace gr
|
|
|
|
{
|
|
|
|
|