bool XAP_Dictionary::save(void)
{
if (!m_bDirty)
return true;
if (!_openFile("w"))
return false;
UT_GenericVector<UT_UCSChar *> * pVec = m_hashWords.enumerate();
UT_ASSERT(pVec);
UT_uint32 size = pVec->size();
for (UT_uint32 i = 0; i < size; i++)
{
UT_UCSChar * pWord = pVec->getNthItem(i);
_outputUTF8(pWord, UT_UCS4_strlen(pWord));
_writeBytes(reinterpret_cast<const UT_Byte *>("\n"));
}
_closeFile();
delete pVec;
m_bDirty = false;
return true;
}
/*!
* This method looks to see if there is a list at the current point. If so
* fill the dialog with that stuff, otherwise fill the dialog with the uncustomized
* values corresponding to m_NewListType.
*/
void AP_Dialog_Lists::PopulateDialogData(void)
{
m_isListAtPoint = getBlock()->isListItem();
if(m_isListAtPoint == true)
{
fillDialogFromBlock();
}
else
{
// m_NewListType = NOT_A_LIST;
fillUncustomizedValues();
}
if(m_isListAtPoint == true)
{
const UT_UCSChar * tmp1 = getBlock()->getListLabel();
if(tmp1 != NULL)
{
UT_sint32 cnt = UT_MIN(UT_UCS4_strlen(tmp1),80);
UT_sint32 i;
for(i =0; i<=cnt; i++)
m_curListLabel[i] = *tmp1++;
}
m_curListLevel = getBlock()->getLevel();
m_curStartValue = getAutoNum()->getStartValue32();
m_iStartValue = getAutoNum()->getStartValue32();
m_DocListType = getAutoNum()->getType();
}
else
{
m_DocListType = NOT_A_LIST;
m_curStartValue = 1;
}
}
//
// _ucsToAscii
// -----------------------
// Helper function to convert UCS-4 strings into Ascii.
// NOTE: you must call delete[] on the returned text!!!
//
inline static char*
_ucsToAscii(const UT_UCSChar* text)
{
UT_return_val_if_fail(text,0);
// calculate length of text so that we can create a character
// buffer of equal size.
const unsigned int length = UT_UCS4_strlen(static_cast<const UT_UCS4Char *>(text));
// allocate ascii characters plus room for a null terminator.
char* ret = new char[length+1];
// do the string conversion. this is simple we just cast to
// char since UCS-4 is the same as Ascii for english.
for(unsigned int i = 0;i < length;++i)
{
ret[i] = static_cast<char>(text[i]);
}
// finally null terminate the string.
ret[length] = '\0';
// and now return it.
return ret;
}
char * AP_Dialog_MarkRevisions::getComment1()
{
_initRevision();
if(!m_pRev || m_bForceNew)
return NULL;
bool bFree = false;
const UT_UCS4Char * pC = m_pRev->getDescription();
if(!pC)
return NULL;
// now we run this string through fribidi
if(XAP_App::getApp()->theOSHasBidiSupport() == XAP_App::BIDI_SUPPORT_NONE)
{
UT_UCS4Char *pStr2 = 0;
UT_uint32 iLen = UT_UCS4_strlen(pC);
pStr2 = (UT_UCS4Char *)UT_calloc( iLen + 1, sizeof(UT_UCS4Char));
UT_return_val_if_fail(pStr2,NULL);
bFree = true;
UT_BidiCharType iDomDir = UT_bidiGetCharType(pC[0]);
UT_bidiReorderString(pC, iLen, iDomDir, pStr2);
pC = pStr2;
}
char * pComment = (char *)UT_calloc(UT_UCS4_strlen(pC) + 1, sizeof(char));
UT_return_val_if_fail(pComment,NULL);
UT_UCS4_strcpy_to_char(pComment,pC);
if(bFree)
{
FREEP(pC);
}
return pComment;
}
void XAP_Dialog_FontChooser::setDrawString(const UT_UCSChar * str)
{
FREEP(m_drawString);
UT_sint32 len = UT_UCS4_strlen(str);
if(len <= 0)
{
UT_UCS4_cloneString_char (&m_drawString, PREVIEW_ENTRY_DEFAULT_STRING);
}
else
{
UT_UCS4_cloneString(&m_drawString, str);
}
}
bool fp_FieldListLabelRun::calculateValue(void)
{
UT_UCSChar sz_ucs_FieldValue[FPFIELD_MAX_LENGTH + 1];
UT_uint32 i = 0;
UT_UCSChar * listlabel = NULL;
if(getBlock()->isContainedByTOC())
{
xxx_UT_DEBUGMSG(("!!!!!!------!!!! ListLabel in TOC!!!! \n"));
//
// First Find the block in the document.
//
pf_Frag_Strux* sdh = getBlock()->getStruxDocHandle();
PD_Document * pDoc = getBlock()->getDocument();
PT_DocPosition pos = pDoc->getStruxPosition(sdh)+1;
FL_DocLayout * pLayout = getBlock()->getDocLayout();
fl_BlockLayout * pBlockInDoc = pLayout->findBlockAtPosition(pos);
if(pBlockInDoc == NULL)
{
sz_ucs_FieldValue[0] = static_cast<UT_UCSChar>(' ');
sz_ucs_FieldValue[1] = 0;
return _setValue(sz_ucs_FieldValue);
}
i = 0;
listlabel = pBlockInDoc->getListLabel();
}
else
{
i = 0;
listlabel = getBlock()->getListLabel();
}
if(listlabel == NULL)
{
sz_ucs_FieldValue[0] = 0;
}
else
{
//
// This code is here because UT_UCS_copy_char is broken
//
i = 0;
UT_uint32 len = UT_MIN( UT_UCS4_strlen(listlabel),FPFIELD_MAX_LENGTH + 1) ;
for(i=0; i<=len;i++)
{
sz_ucs_FieldValue[i] = *listlabel++;
}
// sz_ucs_FieldValue[len] = 0;
// m_sFieldValue[0] = 0; // Force an update!!!
}
return _setValue(sz_ucs_FieldValue);
}
/*!
* Little convienence method to get the List label from the FakeAutoNum used in the
* Preview.
*/
UT_UCSChar * AP_Dialog_Lists::getListLabel(UT_sint32 itemNo)
{
UT_ASSERT_HARMLESS(itemNo < 4);
static UT_UCSChar lab[80];
const UT_UCSChar * tmp = m_pFakeAuto->getLabel(m_pFakeSdh[itemNo]);
if(tmp == NULL)
{
return NULL;
}
UT_sint32 cnt = UT_MIN(UT_UCS4_strlen(tmp),80);
UT_sint32 i;
for(i =0; i<= cnt; i++)
lab[i] = *tmp++;
return lab;
}
/*!
* Event-handler for button "Change All".
*/
void
AP_UnixDialog_Spell::onChangeAllClicked ()
{
UT_DEBUGMSG (("ROB: AP_UnixDialog_Spell::onChangeAllClicked()\n"));
UT_UCSChar * replace = NULL;
replace = _convertFromMB((char*)gtk_entry_get_text(GTK_ENTRY(m_eChange)));
if (!replace || !UT_UCS4_strlen(replace))
{
FREEP(replace);
return;
}
addChangeAll(replace);
changeWordWith(replace);
FREEP(replace);
}
/*!
* This method counts the number of common characters in pszNeedle found in
* pszHaystack. Every time character in pszNeedle is found in pszHaystack the
* score is incremented by 1.
*/
UT_uint32 XAP_Dictionary::countCommonChars( UT_UCSChar *pszHaystack,UT_UCSChar * pszNeedle)
{
UT_uint32 lenNeedle = UT_UCS4_strlen(pszNeedle);
UT_UCSChar oneChar[2];
oneChar[1] = 0;
UT_uint32 i=0;
UT_uint32 score =0;
for(i=0; i< lenNeedle; i++)
{
oneChar[0] = pszNeedle[i];
if(UT_UCS4_strstr(pszHaystack,oneChar) != 0)
{
score++;
}
}
return score;
}
void AP_Preview_PageNumbers::draw (const UT_Rect *clip)
{
UT_UNUSED(clip);
GR_Painter painter(m_gc);
int x = 0, y = 0;
UT_sint32 iWidth = m_gc->tlu (getWindowWidth());
UT_sint32 iHeight = m_gc->tlu (getWindowHeight());
UT_Rect pageRect(m_gc->tlu(7), m_gc->tlu(7), iWidth - m_gc->tlu(14), iHeight - m_gc->tlu(14));
painter.fillRect(GR_Graphics::CLR3D_Background, 0, 0, iWidth, iHeight);
painter.clearArea(pageRect.left, pageRect.top, pageRect.width, pageRect.height);
// actually draw some "text" on the preview for a more realistic appearance
m_gc->setLineWidth(m_gc->tlu(1));
m_gc->setColor3D(GR_Graphics::CLR3D_Foreground);
UT_sint32 iFontHeight = m_gc->getFontHeight ();
UT_sint32 step = m_gc->tlu(4);
for (int txty = pageRect.top + (2 * iFontHeight); txty < pageRect.top + pageRect.height - (2 * iFontHeight); txty += step)
{
painter.drawLine (pageRect.left + m_gc->tlu(5), txty, pageRect.left + pageRect.width - m_gc->tlu(5), txty);
}
// draw in the page number as a header or footer, properly aligned
switch (m_align)
{
case AP_Dialog_PageNumbers::id_RALIGN : x = pageRect.left + pageRect.width - (2 * m_gc->measureUnRemappedChar(*m_str)); break;
case AP_Dialog_PageNumbers::id_CALIGN : x = pageRect.left + (int)(pageRect.width / 2); break;
case AP_Dialog_PageNumbers::id_LALIGN : x = pageRect.left + m_gc->measureUnRemappedChar(*m_str); break;
}
switch (m_control)
{
case AP_Dialog_PageNumbers::id_HDR : y = pageRect.top + (int)(iFontHeight / 2); break;
case AP_Dialog_PageNumbers::id_FTR : y = pageRect.top + pageRect.height - (int)(1.5 * iFontHeight); break;
}
//m_gc->setColor3D(GR_Graphics::CLR3D_Foreground);
painter.drawChars (m_str, 0, UT_UCS4_strlen(m_str), x, y);
}
void AP_Dialog_MarkRevisions::addRevision()
{
UT_return_if_fail(m_pDoc);
if (!m_pComment2)
return;
_initRevision();
UT_uint32 iId = 1;
if(m_pRev)
iId = m_pRev->getId() + 1;
time_t tStart = time(NULL);
m_pDoc->addRevision(iId, m_pComment2->ucs4_str().ucs4_str(), UT_UCS4_strlen(m_pComment2->ucs4_str().ucs4_str()), tStart, 0, true);
m_pRev = NULL;
}
/*!
* Returns true if the word given is found in the users custom dictionary.
\param const UT_UCSChar * pWord the word to look for suggestion for
\param UT_uint32 len the length of the word
\returns UT_Vector * pVecSuggestions this a vector of suggestions.
The returner is responsible for deleting these words.
*/
void XAP_Dictionary::suggestWord(UT_GenericVector<UT_UCSChar *> * pVecSuggestions, const UT_UCSChar * pWord, UT_uint32 len)
{
//
// Get the words in the local dictionary
//
UT_GenericVector<UT_UCSChar *> * pVec = m_hashWords.enumerate();
UT_ASSERT(pVec);
UT_uint32 i=0;
UT_uint32 count = pVec->getItemCount();
//
// Turn our word into a NULL teminated string
//
UT_UCSChar * pszWord = static_cast<UT_UCSChar*>(UT_calloc(len+1, sizeof(UT_UCSChar)));
for(i=0; i< len; i++)
{
pszWord[i] = pWord[i];
}
pszWord[len] = 0;
//
// Loop over all the words in our custom doctionary and add them to the
//the suggestions if they're possibilities.
//
for(i=0; i< count; i++)
{
UT_UCSChar * pszDict = pVec->getNthItem(i);
UT_UCSChar * pszReturn = NULL;
float lenDict = static_cast<float>(UT_UCS4_strlen(pszDict));
UT_uint32 wordInDict = countCommonChars(pszDict,pszWord);
UT_uint32 dictInWord = countCommonChars(pszWord,pszDict);
float flen = static_cast<float>(len);
float frac1 = (static_cast<float>(wordInDict)) / flen;
float frac2 = (static_cast<float>(dictInWord)) / lenDict;
if((frac1 > 0.8) && (frac2 > 0.8))
{
UT_UCS4_cloneString(&pszReturn, pszDict);
pVecSuggestions->addItem(pszReturn);
}
}
FREEP(pszWord);
DELETEP(pVec);
}
/*!
* This method updates the drawing area in the dialog.
*/
void XAP_Dialog_FontChooser::event_previewExposed(const UT_UCSChar * pszChars)
{
UT_UCSChar * pszNew = NULL;
if(!pszChars || UT_UCS4_strlen(pszChars) <= 0)
{
//FREEP(pszChars); // we should not g_free it here
UT_UCS4_cloneString_char (&pszNew, PREVIEW_ENTRY_DEFAULT_STRING);
if (!pszNew)
return;
m_pFontPreview->setDrawString(pszNew);
}
else
{
m_pFontPreview->setDrawString(pszChars);
}
m_pFontPreview->draw();
FREEP(pszNew);
}
//
// _ucs4ToLatin1
// -----------------------
// Helper function to convert UCS-4 strings into Latin1.
// NOTE: you must call delete[] on the returned text!!!
//
inline static char * _ucs4ToLatin1(const UT_UCS4Char * text)
{
// calculate length of text so that we can create a character
// buffer of equal size.
const unsigned int length = UT_UCS4_strlen(text);
// allocate ascii characters plus room for a null terminator.
char * ret = new char[length + 1];
// do the string conversion. this is simple we just cast to
// char since UCS-4 is the same as Latin1 for FT's languages.
for (unsigned int i = 0; i < length; ++i)
{
ret[i] = static_cast<char>(text[i]);
}
// finally null terminate the string.
ret[length] = '\0';
// and now return it.
return ret;
}
//
// _ucsToUTF8
// -----------------------
// Helper function to convert UCS-4 strings into UTF-8
// Doing this gains us CJK and Russian translation!
//
static void _ucsToUTF8(UT_String& dest, const UT_UCSChar* src)
{
// calculate length of text
const unsigned int length = UT_UCS4_strlen(static_cast<const UT_UCS4Char *>(src));
UT_Wctomb wctomb("UTF-8");
const UT_UCSChar * pData;
int mbLen;
char pC[MY_MB_LEN_MAX];
// do the string conversion.
for (pData=src; (pData<src+length); ++pData)
{
if (!wctomb.wctomb(pC,mbLen,*pData))
{
mbLen=1;
pC[0]='?';
wctomb.initialize();
}
else
pC[mbLen]=0;
dest += pC;
}
}
/*
*
* Finally draw the characters in the preview.
*
*/
void XAP_Preview_FontPreview::draw(void)
{
//
// Get text decorations.
//
bool isUnder,isOver,isStrike;
const std::string sDecor = getVal("text-decoration");
if(!sDecor.empty())
{
isUnder = (NULL != strstr(sDecor.c_str(),"underline"));
isOver = (NULL != strstr(sDecor.c_str(),"overline"));
isStrike = (NULL != strstr(sDecor.c_str(),"line-through"));
}
else
{
isUnder = false;
isOver = false;
isStrike = false;
}
//
// Do foreground and background colors.
//
UT_RGBColor FGcolor(0,0,0);
const std::string sFGColor = getVal("color");
if(!sFGColor.empty())
UT_parseColor(sFGColor.c_str(),FGcolor);
UT_RGBColor BGcolor(m_clrBackground);
const std::string sBGColor = getVal("bgcolor");
if(!sBGColor.empty() && strcmp(sBGColor.c_str(),"transparent") != 0)
UT_parseColor(sBGColor.c_str(),BGcolor);
//
// Get the font and bold/italic- ness
//
//GR_Font * pFont;
std::string sFamily = getVal("font-family");
std::string sStyle = getVal("font-style");
std::string sVariant = getVal("font-variant");
std::string sStretch = getVal("font-stretch");
std::string sSize = getVal("font-size");
std::string sWeight = getVal("font-weight");
if(sFamily.empty())
sFamily = "Times New Roman";
if(sStyle.empty())
sStyle = "normal";
if(sVariant.empty())
sVariant = "normal";
if(sStretch.empty())
sStretch = "normal";
if(sSize.empty())
sSize="12pt";
if(sWeight.empty())
sWeight = "normal";
m_pFont = m_gc->findFont(sFamily.c_str(), sStyle.c_str(),
sVariant.c_str(), sWeight.c_str(),
sStretch.c_str(), sSize.c_str(),
NULL);
UT_ASSERT_HARMLESS(m_pFont);
if(!m_pFont)
{
clearScreen();
return;
}
m_gc->setFont(m_pFont);
m_iAscent = m_gc->getFontAscent(m_pFont);
m_iDescent = m_gc->getFontDescent(m_pFont);
m_iHeight = m_gc->getFontHeight(m_pFont);
//
// Clear the screen!
//
clearScreen();
//
// Calculate the draw coordinates position
//
UT_sint32 iWinWidth = m_gc->tlu(getWindowWidth());
UT_sint32 iWinHeight = m_gc->tlu(getWindowHeight());
UT_sint32 iTop = (iWinHeight - m_iHeight)/2;
UT_sint32 len = UT_UCS4_strlen(m_pszChars);
UT_sint32 twidth = m_gc->measureString(m_pszChars,0,len,NULL);
UT_sint32 iLeft = (iWinWidth - twidth)/2;
//
// Fill the background color
//
GR_Painter painter(m_gc);
if(!sBGColor.empty())
painter.fillRect(BGcolor,iLeft,iTop,twidth,m_iHeight);
//
// Do the draw chars at last!
//
m_gc->setColor(FGcolor);
painter.drawChars(m_pszChars, 0, len, iLeft, iTop);
//
// Do the decorations
//
if(isUnder)
{
UT_sint32 iDrop = iTop + m_iAscent + m_iDescent/3;
painter.drawLine(iLeft,iDrop,iLeft+twidth,iDrop);
}
if(isOver)
{
UT_sint32 iDrop = iTop + m_gc->tlu(1) + (UT_MAX(m_gc->tlu(10),m_iAscent) - m_gc->tlu(10))/8;
painter.drawLine(iLeft,iDrop,iLeft+twidth,iDrop);
}
if(isStrike)
{
UT_sint32 iDrop = iTop + m_iAscent * 2 /3;
painter.drawLine(iLeft,iDrop,iLeft+twidth,iDrop);
}
// bad hardcoded color, but this will probably [ <-this assumption is the bad thing :) ] never be different anyway
m_gc->setColor(UT_RGBColor(0,0,0));
painter.drawLine(0, 0, m_gc->tlu(getWindowWidth()), 0);
painter.drawLine(m_gc->tlu(getWindowWidth()) - m_gc->tlu(1), 0, m_gc->tlu(getWindowWidth()) - m_gc->tlu(1),
m_gc->tlu(getWindowHeight()));
painter.drawLine(m_gc->tlu(getWindowWidth()) - m_gc->tlu(1), m_gc->tlu(getWindowHeight()) - m_gc->tlu(1), 0,
m_gc->tlu(getWindowHeight()) - m_gc->tlu(1));
painter.drawLine(0, m_gc->tlu(getWindowHeight()) - m_gc->tlu(1), 0, 0);
}
UT_UCS4String::UT_UCS4String(const UT_UCS4Char* sz, size_t n)
: pimpl(new UT_StringImpl<UT_UCS4Char>(sz, n ? n : (sz) ? UT_UCS4_strlen(sz) : 0))
{
}
UT_UCS4String& UT_UCS4String::operator+=(const UT_UCS4Char* rhs)
{
UT_return_val_if_fail(rhs, *this);
pimpl->append(rhs, UT_UCS4_strlen(rhs));
return *this;
}
void AP_Lists_preview::draw(void)
{
UT_return_if_fail(m_pFont);
GR_Painter painter(m_gc);
m_gc->setFont(m_pFont);
UT_RGBColor clrGrey = UT_RGBColor(128,128,128);
UT_RGBColor clrBlack = UT_RGBColor(0,0,0);
UT_sint32 iWidth = m_gc->tlu(getWindowWidth());
UT_sint32 iHeight = m_gc->tlu(getWindowHeight());
UT_UCSChar ucs_label[50];
UT_sint32 iDescent = m_gc->getFontDescent();
UT_sint32 iAscent = m_gc->getFontAscent();
UT_sint32 iFont = iDescent + iAscent;
m_iLine_height = iFont;
//
// clear our screen
//
if (m_bFirst == true)
{
painter.clearArea(0, 0, iWidth, iHeight);
}
m_gc->setColor(clrBlack);
UT_sint32 yoff = m_gc->tlu(5) ;
UT_sint32 xoff = m_gc->tlu(5) ;
UT_sint32 i,ii,yloc,awidth,aheight,maxw;
UT_sint32 twidth =0;
UT_sint32 j,xy;
float z,fwidth;
// todo 6.5 should be the page width in inches
float pagew = 2.0;
aheight = m_gc->tlu(16);
fwidth = static_cast<float>(m_gc->tdu(iWidth));
z = (float)((fwidth - 2.0*static_cast<float>(m_gc->tdu(xoff))) /pagew);
UT_sint32 indent = m_gc->tlu(static_cast<UT_sint32>( z*(m_fAlign+m_fIndent)));
if(indent < 0)
indent = 0;
maxw = 0;
for(i=0; i<4; i++)
{
UT_UCSChar * lv = getLists()->getListLabel(i);
UT_sint32 len =0;
if(lv != NULL)
{
//
// This code is here because UT_UCS_copy_char is broken
//
len = UT_MIN(UT_UCS4_strlen(lv),51);
for(j=0; j<=len;j++)
{
ucs_label[j] = *lv++;
}
ucs_label[len] = 0;
len = UT_UCS4_strlen(ucs_label);
yloc = yoff + iAscent + (iHeight - 2*yoff -iFont)*i/4;
// painter.drawChars(ucs_label,0,len,xoff+indent,yloc);
twidth = m_gc->measureString(ucs_label,0,len,NULL);
if(twidth > maxw)
maxw = twidth;
}
}
//
// Work out where to put grey areas to represent text
//
UT_sint32 xx,yy;
if(maxw > 0)
maxw++;
// UT_sint32 vspace = (iHeight - 2*yoff -iFont)*i/16;
z = (float)((fwidth - 2.0*static_cast<float>(m_gc->tdu(xoff))) /(float)pagew);
UT_sint32 ialign = m_gc->tlu(static_cast<UT_sint32>( z*m_fAlign));
xx = xoff + ialign;
xy = xoff + ialign;
if(xx < (xoff + maxw + indent))
xy = xoff + maxw + indent + m_gc->tlu(1);
ii = 0;
for(i=0; i<4; i++)
{
yloc = yoff + iAscent + (iHeight - 2*yoff -iFont)*i/4;
for(j=0; j< 2; j++)
{
yy = yloc + m_gc->tlu(5) + j*m_gc->tlu(21);
m_iLine_pos[ii++] = yy;
}
}
//
// Now finally draw the preview
//
UT_BidiCharType iDirection = getLists()->getBlock()->getDominantDirection();
for(i=0; i<8; i++)
{
//
// First clear the line
//
painter.clearArea(0, m_iLine_pos[i], iWidth, iHeight);
if((i & 1) == 0)
{
//
// Draw the text
//
UT_UCSChar * lv = getLists()->getListLabel(i/2);
UT_sint32 len =0;
if(lv != NULL)
{
len = UT_MIN(UT_UCS4_strlen(lv),49);
if(len > 1 && XAP_App::getApp()->theOSHasBidiSupport() == XAP_App::BIDI_SUPPORT_GUI)
{
UT_bidiReorderString(lv, len, iDirection, ucs_label);
}
else
{
for(j=0; j<=len;j++)
ucs_label[j] = *lv++;
}
ucs_label[len] = 0;
len = UT_UCS4_strlen(ucs_label);
yloc = yoff + iAscent + (iHeight - 2*yoff -iFont)*i/8;
if(iDirection == UT_BIDI_RTL)
painter.drawChars(ucs_label,0,len,iWidth - xoff - indent - maxw,yloc);
else
painter.drawChars(ucs_label,0,len,xoff+indent,yloc);
yy = m_iLine_pos[i];
awidth = iWidth - 2*xoff - xy;
if(iDirection == UT_BIDI_RTL)
painter.fillRect(clrGrey,xoff,yy,awidth,aheight);
else
painter.fillRect(clrGrey,xy,yy,awidth,aheight);
}
else
{
yy = m_iLine_pos[i];
awidth = iWidth - 2*xoff - xy;
if(iDirection == UT_BIDI_RTL)
painter.fillRect(clrGrey,xoff,yy,awidth,aheight);
else
painter.fillRect(clrGrey,xy,yy,awidth,aheight);
}
}
else
{
yy = m_iLine_pos[i];
awidth = iWidth - 2*xoff - xx;
if(iDirection == UT_BIDI_RTL)
painter.fillRect(clrGrey,xoff,yy,awidth,aheight);
else
painter.fillRect(clrGrey,xy,yy,awidth,aheight);
}
}
}