You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
609 lines
19 KiB
609 lines
19 KiB
//// DspLogcl - Display logical text
|
|
//
|
|
// Shows logical characters and selection range in backing store order and fixed width.
|
|
|
|
|
|
#include "precomp.hxx"
|
|
#include "global.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//// DottedLine
|
|
//
|
|
// Draws a horizontal or a vertical dotted line
|
|
//
|
|
// Not the best algorithm.
|
|
|
|
|
|
void DottedLine(HDC hdc, int x, int y, int dx, int dy) {
|
|
|
|
SetPixel(hdc, x, y, 0);
|
|
|
|
if (dx) {
|
|
|
|
// Horizontal line
|
|
|
|
while (dx > 2) {
|
|
x += 3;
|
|
SetPixel(hdc, x, y, 0);
|
|
dx -= 3;
|
|
}
|
|
x += dx;
|
|
SetPixel(hdc, x, y, 0);
|
|
|
|
} else {
|
|
|
|
// Vertical line
|
|
|
|
while (dy > 2) {
|
|
y += 3;
|
|
SetPixel(hdc, x, y, 0);
|
|
dy -= 3;
|
|
}
|
|
y += dy;
|
|
SetPixel(hdc, x, y, 0);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//// PaintLogical - show characters in logical sequence
|
|
//
|
|
// Display each glyph separately - override the default advance width
|
|
// processing to defeat any overlapping or combining action that the
|
|
// font performs with it's default ABC width.
|
|
//
|
|
// To achieve this, we call ScriptGetGlyphABCWidth to obtain the
|
|
// leading side bearing (A), the black box width (B) and the trailing
|
|
// side bearing (C).
|
|
//
|
|
// Since we can control only the advance width per glyph, we have to
|
|
// calulate suitable advance widths to override the affect of the
|
|
// ABC values in the font.
|
|
//
|
|
// You should never normally need to call ScriptGetGlyphABCWidth.
|
|
//
|
|
// PaintLogical has to implement a form of font fallback - Indian and
|
|
// Tamil scripts are not present in Tahoma, so we go
|
|
// directly to Mangal and Latha for characters in those Unicode ranges.
|
|
|
|
|
|
void PaintLogical(
|
|
HDC hdc,
|
|
int *piY,
|
|
RECT *prc,
|
|
int iLineHeight) {
|
|
|
|
const int MAXBUF = 100;
|
|
const int CELLGAP = 4; // Pixels between adjacent glyphs
|
|
|
|
int icpLineStart; // First character of line
|
|
int icpLineEnd; // End of line (end of buffer or index of CR character)
|
|
int icp;
|
|
int iLen;
|
|
int iPartLen; // Part of string in a single font
|
|
int iPartX;
|
|
int iPartWidth;
|
|
WORD wGlyphBuf[MAXBUF];
|
|
int idx[MAXBUF]; // Force widths so all characters show
|
|
BYTE bFont[MAXBUF]; // Font used for each character
|
|
ABC abc[MAXBUF];
|
|
int iTotX;
|
|
int ildx; // Overall line dx, adjusts for 'A' width of leading glyph
|
|
int iSliderX;
|
|
int iFont; // 0 = Tahoma, 1 = Mangal, 2 = Latha
|
|
RECT rcClear; // Clear each line before displaying it
|
|
|
|
// Selection highlighting
|
|
|
|
bool bHighlight; // Current state of highlighting in the hdc
|
|
int iFrom; // Selection range
|
|
int iTo;
|
|
DWORD dwOldBkColor=0;
|
|
DWORD dwOldTextColor=0;
|
|
|
|
// Item analysis
|
|
|
|
SCRIPT_ITEM items[MAXBUF];
|
|
SCRIPT_CONTROL scriptControl;
|
|
SCRIPT_STATE scriptState;
|
|
INT iItem;
|
|
|
|
|
|
#define NUMLOGICALFONTS 4
|
|
|
|
SCRIPT_CACHE sc[NUMLOGICALFONTS];
|
|
HFONT hf[NUMLOGICALFONTS];
|
|
HFONT hfold;
|
|
HRESULT hr;
|
|
|
|
SCRIPT_FONTPROPERTIES sfp;
|
|
BOOL bMissing;
|
|
|
|
icpLineStart = 0;
|
|
|
|
hf[0] = CreateFontA(iLineHeight*7/10, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "Tahoma");
|
|
hf[1] = CreateFontA(iLineHeight*7/10, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "Mangal");
|
|
hf[2] = CreateFontA(iLineHeight*7/10, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "Latha");
|
|
hf[3] = CreateFontA(iLineHeight*7/20, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "Tahoma"); // for bidi level digits
|
|
|
|
iFont = 0;
|
|
hfold = (HFONT) SelectObject(hdc, hf[iFont]);
|
|
ildx = 0;
|
|
|
|
memset(sc, 0, sizeof(sc));
|
|
bHighlight = FALSE;
|
|
|
|
INT iSliderHeight = g_fOverrideDx ? iLineHeight * 5 / 10 : 0;
|
|
INT iLevelsHeight = g_fShowLevels ? iLineHeight * 8 / 20 : 0;
|
|
|
|
|
|
|
|
// Display line by line
|
|
|
|
while (icpLineStart < g_iTextLen) {
|
|
|
|
|
|
// Clear line before displaying it
|
|
|
|
rcClear = *prc;
|
|
rcClear.top = *piY;
|
|
rcClear.bottom = *piY + iLineHeight + iSliderHeight + iLevelsHeight;
|
|
FillRect(hdc, &rcClear, (HBRUSH) GetStockObject(WHITE_BRUSH));
|
|
|
|
|
|
// Find end of line or end of buffer
|
|
|
|
icpLineEnd = icpLineStart;
|
|
while (icpLineEnd < g_iTextLen && g_wcBuf[icpLineEnd] != 0x0D) {
|
|
icpLineEnd++;
|
|
}
|
|
|
|
if (icpLineEnd - icpLineStart > MAXBUF) {
|
|
iLen = MAXBUF;
|
|
} else {
|
|
iLen = icpLineEnd - icpLineStart;
|
|
}
|
|
|
|
|
|
// Obtain item analysis
|
|
|
|
scriptControl = g_ScriptControl;
|
|
scriptState = g_ScriptState;
|
|
ScriptItemize(g_wcBuf+icpLineStart, iLen, MAXBUF, &scriptControl, &scriptState, items, NULL);
|
|
|
|
|
|
// Determine font and glyph index for each codepoint
|
|
|
|
if (iFont != 0) { // Start with Tahoma
|
|
iFont = 0;
|
|
SelectObject(hdc, hf[0]);
|
|
}
|
|
|
|
hr = ScriptGetCMap(hdc, &sc[iFont], g_wcBuf+icpLineStart, iLen, 0, wGlyphBuf);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
|
|
memset(bFont, 0, iLen);
|
|
|
|
if (hr != S_OK) {
|
|
|
|
// Some characters were not in Tahoma
|
|
|
|
sfp.cBytes = sizeof(sfp);
|
|
ScriptGetFontProperties(hdc, &sc[iFont], &sfp);
|
|
|
|
bMissing = FALSE;
|
|
for (icp=0; icp<iLen; icp++) {
|
|
if (wGlyphBuf[icp] == sfp.wgDefault) {
|
|
bFont[icp] = 1;
|
|
bMissing = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
// Try other fonts
|
|
|
|
while (bMissing && iFont < 2) {
|
|
iFont++;
|
|
SelectObject(hdc, hf[iFont]);
|
|
ScriptGetFontProperties(hdc, &sc[iFont], &sfp);
|
|
bMissing = FALSE;
|
|
for (icp=0; icp<iLen; icp++) {
|
|
if (bFont[icp] == iFont) {
|
|
ScriptGetCMap(hdc, &sc[iFont], g_wcBuf+icpLineStart+icp, 1, 0, wGlyphBuf+icp);
|
|
if (wGlyphBuf[icp] == sfp.wgDefault) {
|
|
bFont[icp] = (BYTE)(iFont+1);
|
|
bMissing = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bMissing) {
|
|
|
|
// Remaining missing characters come from font 0
|
|
for (icp=0; icp<iLen; icp++) {
|
|
if (bFont[icp] >= NUMLOGICALFONTS) {
|
|
bFont[icp] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Display each glyphs black box next to the previous. Override the
|
|
// default ABC behaviour.
|
|
|
|
idx[0] = 0;
|
|
|
|
for (icp=0; icp<iLen; icp++) {
|
|
|
|
if (iFont != bFont[icp]) {
|
|
iFont = bFont[icp];
|
|
SelectObject(hdc, hf[iFont]);
|
|
}
|
|
|
|
ScriptGetGlyphABCWidth(hdc, &sc[iFont], wGlyphBuf[icp], &abc[icp]);
|
|
|
|
if (g_wcBuf[icpLineStart+icp] == ' ') {
|
|
|
|
// Treat entire space as black
|
|
|
|
abc[icp].abcB += abc[icp].abcA; abc[icp].abcA = 0;
|
|
abc[icp].abcB += abc[icp].abcC; abc[icp].abcC = 0;
|
|
|
|
}
|
|
|
|
// Glyph black box width is abc.abcB
|
|
// We'd like the glyph to appear 2 pixels to the right of the
|
|
// previous glyph.
|
|
//
|
|
// The default placement of left edge is abc.abcA.
|
|
//
|
|
// Therefore we need to shift this character to the right by
|
|
// 2 - abc.abcA to get it positioned correctly. We do this by
|
|
// updating the advance width for the previous character.
|
|
|
|
if (!icp) {
|
|
ildx = CELLGAP/2 - abc[icp].abcA;
|
|
} else {
|
|
idx[icp-1] += CELLGAP - abc[icp].abcA;
|
|
}
|
|
|
|
// Now adjust the advance width for this character to take us to
|
|
// the right edge of it's black box.
|
|
|
|
idx[icp] = abc[icp].abcB + abc[icp].abcA;
|
|
}
|
|
|
|
|
|
// Support selection range specified in either direction
|
|
|
|
if (g_iFrom <= g_iTo) {
|
|
iFrom = g_iFrom - icpLineStart;
|
|
iTo = g_iTo - icpLineStart;
|
|
} else {
|
|
iFrom = g_iTo - icpLineStart;
|
|
iTo = g_iFrom - icpLineStart;
|
|
}
|
|
|
|
// Display glyphs in their appropriate fonts
|
|
|
|
icp = 0;
|
|
iPartX = prc->left+ildx;
|
|
|
|
while (icp < iLen) {
|
|
|
|
if (iFont != bFont[icp]) {
|
|
iFont = bFont[icp];
|
|
SelectObject(hdc, hf[iFont]);
|
|
}
|
|
|
|
|
|
// Set selection highlighting at start
|
|
|
|
if ( icp >= iFrom
|
|
&& icp < iTo
|
|
&& !bHighlight) {
|
|
|
|
// Turn on highlighting
|
|
|
|
dwOldBkColor = SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
|
|
dwOldTextColor = SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
|
|
bHighlight = TRUE;
|
|
|
|
} else if ( ( icp < iFrom
|
|
|| icp >= iTo)
|
|
&& bHighlight) {
|
|
|
|
// Turn off highlighting
|
|
|
|
SetBkColor(hdc, dwOldBkColor);
|
|
SetTextColor(hdc, dwOldTextColor);
|
|
bHighlight = FALSE;
|
|
}
|
|
|
|
|
|
// Find longest run from a single font, and
|
|
// without change of highlighting
|
|
|
|
iPartLen = 0;
|
|
iPartWidth = 0;
|
|
|
|
while ( icp+iPartLen < iLen
|
|
&& iFont == bFont[icp+iPartLen]
|
|
&& bHighlight == (icp+iPartLen >= iFrom && icp+iPartLen < iTo)) {
|
|
|
|
iPartWidth += idx[icp+iPartLen];
|
|
iPartLen++;
|
|
}
|
|
|
|
|
|
// Display single font, single highlighting
|
|
|
|
ExtTextOutW(hdc,
|
|
iPartX,
|
|
*piY+2,
|
|
ETO_CLIPPED | ETO_GLYPH_INDEX,
|
|
prc,
|
|
wGlyphBuf+icp,
|
|
iPartLen,
|
|
idx+icp);
|
|
|
|
icp += iPartLen;
|
|
iPartX += iPartWidth;
|
|
}
|
|
|
|
|
|
|
|
// Mark the cells to make the characters stand out clearly
|
|
|
|
MoveToEx(hdc, prc->left, *piY, NULL);
|
|
LineTo(hdc, prc->left, *piY + iLineHeight*3/4);
|
|
|
|
iTotX = 0;
|
|
|
|
for (icp=0; icp<iLen; icp++){
|
|
|
|
iTotX += abc[icp].abcB + CELLGAP;
|
|
idx[icp] = iTotX; // Record cell position for mouse hit testing
|
|
|
|
DottedLine(hdc, prc->left + iTotX, *piY, 0, iLineHeight*3/4);
|
|
|
|
|
|
// Add slider for OverridedDx control
|
|
|
|
if (g_fOverrideDx) {
|
|
|
|
iSliderX = prc->left + (icp==0 ? idx[0]/2 : (idx[icp-1] + idx[icp])/2);
|
|
|
|
// Draw the axis of the slider
|
|
|
|
DottedLine(hdc, iSliderX, *piY + iLineHeight*35/40, 0, iSliderHeight*35/40);
|
|
|
|
// Draw the knob
|
|
|
|
if (g_iWidthBuf[icpLineStart + icp] < iSliderHeight) {
|
|
|
|
MoveToEx(hdc, iSliderX-2, *piY + iLineHeight*35/40 + iSliderHeight*35/40 - g_iWidthBuf[icpLineStart + icp], NULL);
|
|
LineTo (hdc, iSliderX+3, *piY + iLineHeight*35/40 + iSliderHeight*35/40 - g_iWidthBuf[icpLineStart + icp]);
|
|
|
|
} else {
|
|
|
|
MoveToEx(hdc, iSliderX-2, *piY + iLineHeight*35/40, NULL);
|
|
LineTo (hdc, iSliderX+3, *piY + iLineHeight*35/40);
|
|
}
|
|
}
|
|
}
|
|
|
|
MoveToEx(hdc, prc->left + iTotX, *piY, NULL);
|
|
LineTo(hdc, prc->left + iTotX, *piY + iLineHeight*30/40);
|
|
|
|
MoveToEx(hdc, prc->left, *piY, NULL);
|
|
LineTo(hdc, prc->left + iTotX, *piY);
|
|
MoveToEx(hdc, prc->left, *piY + iLineHeight*30/40, NULL);
|
|
LineTo(hdc, prc->left + iTotX, *piY + iLineHeight*30/40);
|
|
|
|
|
|
if (g_fShowLevels)
|
|
{
|
|
// Display bidi levels for each codepoint
|
|
|
|
iItem = 0;
|
|
iFont = 3;
|
|
SelectObject(hdc, hf[3]);
|
|
|
|
for (icp=0; icp<iLen; icp++)
|
|
{
|
|
if (icp == items[iItem+1].iCharPos)
|
|
{
|
|
iItem++;
|
|
|
|
// Draw a vertical line to mark the item boundary
|
|
MoveToEx(hdc, prc->left + idx[icp-1], *piY + iLineHeight*35/40 + iSliderHeight, NULL);
|
|
LineTo( hdc, prc->left + idx[icp-1], *piY + iLineHeight*35/40 + iSliderHeight + iLevelsHeight*35/40);
|
|
}
|
|
|
|
// Establish where horizontally to display the digit
|
|
|
|
char chDigit = char('0' + items[iItem].a.s.uBidiLevel);
|
|
int digitWidth;
|
|
GetCharWidth32A(hdc, chDigit, chDigit, &digitWidth);
|
|
|
|
ExtTextOutA(
|
|
hdc,
|
|
prc->left + (icp==0 ? idx[0]/2 : (idx[icp-1] + idx[icp])/2) - digitWidth / 2,
|
|
*piY + iLineHeight*35/40 + iSliderHeight,
|
|
0,
|
|
NULL,
|
|
&chDigit,
|
|
1,
|
|
NULL);
|
|
}
|
|
}
|
|
|
|
|
|
// Check whether mouse clicks in this line are waiting to be processed
|
|
|
|
if ( g_fOverrideDx
|
|
&& g_fMouseUp && g_iMouseUpY > *piY + iLineHeight*33/40 && g_iMouseUpY < *piY + iLineHeight*63/40) {
|
|
|
|
// Procss change to DX override slider
|
|
|
|
icp = 0;
|
|
while (icp<iLen && prc->left + idx[icp] < g_iMouseUpX) {
|
|
icp++;
|
|
}
|
|
|
|
g_iWidthBuf[icpLineStart+icp] = *piY + 60 - g_iMouseUpY; // Adjust this slider
|
|
InvalidateText(); // Force slider to redraw at new position
|
|
g_fMouseDown = FALSE;
|
|
g_fMouseUp = FALSE;
|
|
g_iFrom = icpLineStart+icp;
|
|
g_iTo = icpLineStart+icp;
|
|
|
|
|
|
} else if (g_fMouseDown && g_iMouseDownY > *piY && g_iMouseDownY < *piY+iLineHeight) {
|
|
|
|
// Handle text selection
|
|
|
|
// Record char pos at left button down
|
|
// Snap mouse hit to closest character boundary
|
|
|
|
if (g_iMouseDownX < prc->left + idx[0]/2) {
|
|
icp = 0;
|
|
} else {
|
|
icp = 1;
|
|
while ( icp < iLen
|
|
&& g_iMouseDownX > prc->left + (idx[icp-1] + idx[icp]) / 2) {
|
|
icp++;
|
|
}
|
|
}
|
|
g_iFrom = icp + icpLineStart;
|
|
|
|
if (g_iFrom < icpLineStart) {
|
|
g_iFrom = icpLineStart;
|
|
}
|
|
if (g_iFrom > icpLineEnd) {
|
|
g_iFrom = icpLineEnd;
|
|
}
|
|
g_fMouseDown = FALSE;
|
|
}
|
|
|
|
|
|
if (g_fMouseUp && g_iMouseUpY > *piY && g_iMouseUpY < *piY+iLineHeight) {
|
|
|
|
// Complete selection processing
|
|
|
|
if (g_iMouseUpX < prc->left + idx[0]/2) {
|
|
icp = 0;
|
|
} else {
|
|
icp = 1;
|
|
while ( icp < iLen
|
|
&& g_iMouseUpX > prc->left + (idx[icp-1] + idx[icp]) / 2) {
|
|
icp++;
|
|
}
|
|
}
|
|
g_iTo = icp + icpLineStart;
|
|
|
|
if (g_iTo < icpLineStart) {
|
|
g_iTo = icpLineStart;
|
|
}
|
|
if (g_iTo > icpLineEnd) {
|
|
g_iTo = icpLineEnd;
|
|
}
|
|
|
|
// Caret is where mouse was raised
|
|
|
|
g_iCurChar = g_iTo;
|
|
g_iCaretSection = CARET_SECTION_LOGICAL; // Show caret in logical text
|
|
g_fUpdateCaret = TRUE;
|
|
|
|
g_fMouseUp = FALSE; // Signal that the mouse up is processed
|
|
|
|
}
|
|
|
|
if ( g_fUpdateCaret
|
|
&& g_iCurChar >= icpLineStart
|
|
&& g_iCurChar <= icpLineEnd
|
|
&& g_iCaretSection == CARET_SECTION_LOGICAL) {
|
|
|
|
g_fUpdateCaret = FALSE;
|
|
if (g_iCurChar <= icpLineStart) {
|
|
ResetCaret(prc->left, *piY, iLineHeight);
|
|
} else {
|
|
ResetCaret(prc->left + idx[g_iCurChar - icpLineStart - 1], *piY, iLineHeight);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
else {
|
|
// ScriptGetCMap failed - therefore this is not a glyphable font.
|
|
// This could indicate
|
|
// A printer device font
|
|
// We're running on FE Win95 which cannot handle glyph indices
|
|
//
|
|
// For the sample app, we know we are using a glyphable Truetype font
|
|
// on a screen DC, so it must mean the sample is running on a Far
|
|
// East version of Windows 95.
|
|
// Theoretically we could go to the trouble of calling
|
|
// WideCharToMultiByte and using the 'A' char interfaces to
|
|
// implement DspLogcl.
|
|
// However this is only a sample program - DspPlain and DspFormt
|
|
// work correctly, but there's no advantage in implementing
|
|
// DspLogcl so well.
|
|
// Display an apology.
|
|
|
|
ExtTextOutA(hdc, prc->left+2, *piY+2, ETO_CLIPPED, prc, "Sorry, no logical text display on Far East Windows 95.", 54, NULL);
|
|
icpLineEnd = g_iTextLen; // Hack to stop display of subsequent lines
|
|
}
|
|
|
|
*piY += iLineHeight + iSliderHeight + iLevelsHeight;
|
|
|
|
|
|
// Advance to next line
|
|
|
|
if (g_fPresentation) {
|
|
icpLineStart = g_iTextLen; // Only show one line in presentation mode
|
|
|
|
} else {
|
|
|
|
if (icpLineEnd < g_iTextLen) {
|
|
icpLineEnd++;
|
|
}
|
|
if (icpLineEnd < g_iTextLen && g_wcBuf[icpLineEnd] == 0x0A) {
|
|
icpLineEnd++;
|
|
}
|
|
icpLineStart = icpLineEnd;
|
|
}
|
|
}
|
|
|
|
SelectObject(hdc, hfold);
|
|
|
|
|
|
if (bHighlight) {
|
|
|
|
// Turn off highlighting
|
|
|
|
SetBkColor(hdc, dwOldBkColor);
|
|
SetTextColor(hdc, dwOldTextColor);
|
|
bHighlight = FALSE;
|
|
}
|
|
|
|
|
|
for (iFont=0; iFont<NUMLOGICALFONTS; iFont++) {
|
|
DeleteObject(hf[iFont]);
|
|
if (sc[iFont]) {
|
|
ScriptFreeCache(&sc[iFont]);
|
|
}
|
|
}
|
|
}
|