mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 06:22:44 +08:00
76ee07f61c
Co-authored-by: Alexander Trofimov <alexander.trofimov@onlyoffice.com> Co-committed-by: Alexander Trofimov <alexander.trofimov@onlyoffice.com>
550 lines
17 KiB
C++
550 lines
17 KiB
C++
/*
|
||
* Copyright (C) Ascensio System SIA, 2009-2026
|
||
*
|
||
* This program is a free software product. You can redistribute it and/or
|
||
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
||
* version 3 as published by the Free Software Foundation, together with the
|
||
* additional terms provided in the LICENSE file.
|
||
*
|
||
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
||
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
||
* details, see the GNU AGPL at: https://www.gnu.org/licenses/agpl-3.0.html
|
||
*
|
||
* You can contact Ascensio System SIA by email at info@onlyoffice.com
|
||
* or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
|
||
* LV-1050, Latvia, European Union.
|
||
*
|
||
* The interactive user interfaces in modified versions of the Program
|
||
* are required to display Appropriate Legal Notices in accordance with
|
||
* Section 5 of the GNU AGPL version 3.
|
||
*
|
||
* No trademark rights are granted under this License.
|
||
*
|
||
* All non-code elements of the Product, including illustrations,
|
||
* icon sets, and technical writing content, are licensed under the
|
||
* Creative Commons Attribution-ShareAlike 4.0 International License:
|
||
* https://creativecommons.org/licenses/by-sa/4.0/legalcode
|
||
*
|
||
* This license applies only to such non-code elements and does not
|
||
* modify or replace the licensing terms applicable to the Program's
|
||
* source code, which remains licensed under the GNU Affero General
|
||
* Public License v3.
|
||
*
|
||
* SPDX-License-Identifier: AGPL-3.0-only
|
||
*/
|
||
|
||
|
||
#include "TableCellPropertiesMapping.h"
|
||
|
||
namespace DocFileFormat
|
||
{
|
||
TableCellPropertiesMapping::TableCellPropertiesMapping (XMLTools::CStringXmlWriter* pWriter,
|
||
const std::vector<short>* grid, int gridIndex, int cellIndex, unsigned int depth) :
|
||
PropertiesMapping(pWriter)
|
||
{
|
||
_depth = depth;
|
||
_width = 0;
|
||
|
||
_gridIndex = gridIndex;
|
||
_grid = grid;
|
||
_cellIndex = cellIndex;
|
||
|
||
_brcTop = NULL;
|
||
_brcLeft = NULL;
|
||
_brcRight = NULL;
|
||
_brcBottom = NULL;
|
||
|
||
_tcPr = new XMLTools::XMLElement(L"w:tcPr");
|
||
_tcMar = new XMLTools::XMLElement(L"w:tcMar");
|
||
_tcBorders = new XMLTools::XMLElement(L"w:tcBorders");
|
||
|
||
_ftsWidth = Global::nil;
|
||
}
|
||
|
||
TableCellPropertiesMapping::~TableCellPropertiesMapping()
|
||
{
|
||
RELEASEOBJECT(_tcPr);
|
||
RELEASEOBJECT(_tcMar);
|
||
RELEASEOBJECT(_tcBorders);
|
||
}
|
||
}
|
||
|
||
namespace DocFileFormat
|
||
{
|
||
void TableCellPropertiesMapping::Apply (IVisitable* visited)
|
||
{
|
||
TablePropertyExceptions* tapx = static_cast<TablePropertyExceptions*>(visited);
|
||
int nComputedCellWidth = 0, nComputedCellWidths = 0;
|
||
|
||
_gridSpan = 0;
|
||
_bCoverCell = false;
|
||
|
||
unsigned int iTap_current = 1;
|
||
|
||
for ( std::vector<SinglePropertyModifier>::iterator iter = tapx->grpprl->begin(); iter != tapx->grpprl->end(); iter++ )
|
||
{
|
||
DWORD code = iter->OpCode;
|
||
|
||
switch(iter->OpCode)
|
||
{
|
||
case sprmPItap:
|
||
{
|
||
iTap_current = FormatUtils::BytesToUInt32( iter->Arguments, 0, iter->argumentsSize );
|
||
}break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
bool bPresentDefTable = false;
|
||
for (std::vector<SinglePropertyModifier>::iterator iter = tapx->grpprl->begin(); iter != tapx->grpprl->end(); ++iter)
|
||
{
|
||
switch (iter->OpCode)
|
||
{
|
||
case sprmOldTDefTable:
|
||
case sprmTDefTable:
|
||
{
|
||
if (!bPresentDefTable) //118854.doc
|
||
{
|
||
bPresentDefTable = true;
|
||
|
||
SprmTDefTable tdef(iter->Arguments, iter->argumentsSize);
|
||
|
||
bool bUseWidth = true;
|
||
|
||
for (size_t j = 0; j < tdef.rgTc80.size(); ++j)
|
||
{ // 1bc0f6c0-b226-4bcb-912c-e7f97b009d8a.doc
|
||
// Технические_Требования_1_287_ДИТ.DOC
|
||
if (tdef.rgTc80[j].horzMerge == 0 && tdef.rgTc80[j].wWidth < 1)
|
||
{
|
||
//bUseWidth = false;
|
||
break;
|
||
}
|
||
}
|
||
int cc = tdef.numberOfColumns;
|
||
|
||
_tGrid = tdef.rgdxaCenter;
|
||
_tcDef = tdef.rgTc80[(std::min)(_cellIndex, (int)tdef.rgTc80.size() - 1)];
|
||
|
||
appendValueElement( _tcPr, L"textDirection", FormatUtils::MapValueToWideString( _tcDef.textFlow, &Global::TextFlowMap[0][0], 6, 6 ), false );
|
||
|
||
if ( _tcDef.vertMerge == Global::fvmMerge )
|
||
{
|
||
appendValueElement( _tcPr, L"vMerge", L"continue", false );
|
||
}
|
||
else if ( _tcDef.vertMerge == Global::fvmRestart )
|
||
{
|
||
appendValueElement( _tcPr, L"vMerge", L"restart", false );
|
||
}
|
||
|
||
appendValueElement( _tcPr, L"vAlign", FormatUtils::MapValueToWideString( _tcDef.vertAlign, &Global::VerticalAlignMap[0][0], 3, 7 ), false );
|
||
|
||
if ( _tcDef.fFitText )
|
||
{
|
||
appendValueElement( _tcPr, L"tcFitText", L"", false );
|
||
}
|
||
|
||
if ( _tcDef.fNoWrap )
|
||
{
|
||
appendValueElement( _tcPr, L"noWrap", L"", true );
|
||
}
|
||
//int ind = (std::min)(_cellIndex, (int)tdef.rgTc80.size() - 1);
|
||
//int ind1 = ind;
|
||
//while (ind1 < tdef.rgdxaCenter.size() - 1)
|
||
//{
|
||
// int sz = tdef.rgdxaCenter[ ind1 + 1] - tdef.rgdxaCenter[ ind1 ] ;
|
||
// if (sz > 1)
|
||
// break;
|
||
// ind1++;
|
||
//}
|
||
_ftsWidth = (Global::CellWidthType)(_tcDef.ftsWidth);
|
||
|
||
if (_cellIndex < tdef.rgTc80.size())
|
||
{
|
||
if (tdef.rgTc80[_cellIndex].horzMerge == 1)
|
||
{
|
||
for (size_t i = _cellIndex; i < tdef.rgTc80.size(); i++)
|
||
{
|
||
if (tdef.rgTc80[i].horzMerge < 1)
|
||
break;
|
||
|
||
nComputedCellWidth += tdef.rgdxaCenter[i + 1] - tdef.rgdxaCenter[i];
|
||
_gridSpan++;
|
||
}
|
||
}
|
||
else if (tdef.rgTc80[_cellIndex].horzMerge == 2)
|
||
{//skip cover cell
|
||
_gridSpan = 1;
|
||
nComputedCellWidth = 0;
|
||
_bCoverCell = true;
|
||
|
||
}
|
||
else
|
||
{
|
||
_gridSpan = 1;
|
||
|
||
nComputedCellWidths += (tdef.rgdxaCenter[_cellIndex + 1] - tdef.rgdxaCenter[0]);
|
||
nComputedCellWidth += bUseWidth ? tdef.rgTc80[_cellIndex].wWidth :
|
||
(tdef.rgdxaCenter[_cellIndex + 1] - tdef.rgdxaCenter[_cellIndex]);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
|
||
}
|
||
|
||
if (!IsTableBordersDefined(tapx->grpprl) || ( _tcDef.brcTop->GetType() != 0) || ( _tcDef.brcLeft->GetType() != 0) ||( _tcDef.brcRight->GetType() != 0) ||( _tcDef.brcBottom->GetType() != 0))
|
||
{
|
||
_brcTop = std::shared_ptr<BorderCode>(new BorderCode(*_tcDef.brcTop));
|
||
_brcLeft = std::shared_ptr<BorderCode>(new BorderCode(*_tcDef.brcLeft));
|
||
_brcRight = std::shared_ptr<BorderCode>(new BorderCode(*_tcDef.brcRight));
|
||
_brcBottom = std::shared_ptr<BorderCode>(new BorderCode(*_tcDef.brcBottom));
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case sprmTDxaCol:
|
||
{
|
||
}break;
|
||
case sprmTCellPadding:
|
||
{
|
||
unsigned char first = iter->Arguments[0];
|
||
unsigned char lim = iter->Arguments[1];
|
||
unsigned char ftsMargin = iter->Arguments[3];
|
||
short wMargin = FormatUtils::BytesToInt16( iter->Arguments, 4, iter->argumentsSize );
|
||
|
||
if ( ( _cellIndex >= first ) && ( _cellIndex < lim ) )
|
||
{
|
||
if ( FormatUtils::GetBitFromInt( iter->Arguments[2], 0 ) == true )
|
||
{
|
||
appendDxaElement( _tcMar, L"top", FormatUtils::IntToWideString( wMargin ), true );
|
||
}
|
||
|
||
if ( FormatUtils::GetBitFromInt( iter->Arguments[2], 1 ) == true )
|
||
{
|
||
appendDxaElement( _tcMar, L"left", FormatUtils::IntToWideString( wMargin ), true );
|
||
}
|
||
|
||
if ( FormatUtils::GetBitFromInt( iter->Arguments[2], 2 ) == true )
|
||
{
|
||
appendDxaElement( _tcMar, L"bottom", FormatUtils::IntToWideString( wMargin ), true );
|
||
}
|
||
|
||
if ( FormatUtils::GetBitFromInt( iter->Arguments[2], 3 ) == true )
|
||
{
|
||
appendDxaElement( _tcMar, L"right", FormatUtils::IntToWideString( wMargin ), true );
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case sprmTDefTableShd80:
|
||
{
|
||
if (!tapx->IsSkipShading97()) // if this operand is the only one, take it into account, otherwise skip it
|
||
{
|
||
apppendCellShading(iter->Arguments, iter->argumentsSize, _cellIndex);
|
||
}
|
||
}break;
|
||
case sprmOldTDefTableShd:
|
||
case sprmTDefTableShd:
|
||
{ // cell shading for cells 0-20
|
||
apppendCellShading(iter->Arguments, iter->argumentsSize, _cellIndex);
|
||
}break;
|
||
|
||
case sprmTDefTableShd2nd:
|
||
{ // cell shading for cells 21-42
|
||
apppendCellShading(iter->Arguments, iter->argumentsSize, (_cellIndex - 21));
|
||
}break;
|
||
case sprmTDefTableShd3rd:
|
||
{ // cell shading for cells 43-62
|
||
apppendCellShading(iter->Arguments, iter->argumentsSize, (_cellIndex - 43));
|
||
}break;
|
||
case sprmTCellWidth:
|
||
{ //width
|
||
unsigned char first = iter->Arguments[0];
|
||
unsigned char lim = iter->Arguments[1];
|
||
|
||
if ((_cellIndex >= first) && (_cellIndex < lim))
|
||
{
|
||
_ftsWidth = (Global::CellWidthType)(iter->Arguments[2]);
|
||
_width = FormatUtils::BytesToInt16(iter->Arguments, 3, iter->argumentsSize);
|
||
}
|
||
}
|
||
break;
|
||
case sprmTVertAlign:
|
||
{ //vertical alignment
|
||
unsigned char first = iter->Arguments[0];
|
||
unsigned char lim = iter->Arguments[1];
|
||
|
||
if ((_cellIndex >= first) && (_cellIndex < lim))
|
||
{
|
||
appendValueElement(_tcPr, L"vAlign", FormatUtils::MapValueToWideString( (VerticalCellAlignment)iter->Arguments[2], &VerticalCellAlignmentMap[0][0], 3, 7 ), true );
|
||
}
|
||
}
|
||
break;
|
||
case sprmTFitText:
|
||
{ //Autofit
|
||
unsigned char first = iter->Arguments[0];
|
||
unsigned char lim = iter->Arguments[1];
|
||
|
||
if ( ( _cellIndex >= first ) && ( _cellIndex < lim ) )
|
||
{
|
||
appendValueElement( _tcPr, L"tcFitText", FormatUtils::IntToWideString( iter->Arguments[2] ), true );
|
||
}
|
||
}
|
||
break;
|
||
case sprmTTableBorders80:
|
||
{
|
||
const int size = 4;
|
||
unsigned char brc80[size];
|
||
|
||
memcpy(brc80, iter->Arguments, size);
|
||
if (!_brcTop)
|
||
_brcTop = std::shared_ptr<BorderCode>(new BorderCode(brc80, size));
|
||
|
||
memcpy(brc80, (iter->Arguments + 4), size);
|
||
if (!_brcLeft)
|
||
_brcLeft = std::shared_ptr<BorderCode>(new BorderCode(brc80, size));
|
||
|
||
memcpy(brc80, (iter->Arguments + 8), size);
|
||
if (!_brcBottom)
|
||
_brcBottom = std::shared_ptr<BorderCode>(new BorderCode(brc80, size));
|
||
|
||
memcpy(brc80, (iter->Arguments + 12), size);
|
||
if (!_brcRight)
|
||
_brcRight = std::shared_ptr<BorderCode>(new BorderCode(brc80, size));
|
||
|
||
//memcpy(brc80, (iter->Arguments + 16), size);
|
||
//_brcHorz = std::shared_ptr<BorderCode>(new BorderCode(brc80, size));
|
||
|
||
//memcpy(brc80, (iter->Arguments + 20), size);
|
||
//_brcVert = std::shared_ptr<BorderCode>(new BorderCode(brc80, size));
|
||
}break;
|
||
case sprmOldTTableBorders:
|
||
case sprmTTableBorders:
|
||
{
|
||
const int size = 8;
|
||
unsigned char brc[size];
|
||
|
||
memcpy(brc, iter->Arguments, size);
|
||
if (!_brcTop)
|
||
_brcTop = std::shared_ptr<BorderCode>(new BorderCode(brc, size));
|
||
|
||
memcpy(brc, (iter->Arguments + 8), size);
|
||
if (!_brcLeft)
|
||
_brcLeft = std::shared_ptr<BorderCode>(new BorderCode(brc, size));
|
||
|
||
memcpy(brc, (iter->Arguments + 16), size);
|
||
if (!_brcBottom)
|
||
_brcBottom = std::shared_ptr<BorderCode>(new BorderCode(brc, size));
|
||
|
||
memcpy(brc, (iter->Arguments + 24), size);
|
||
if (!_brcRight)
|
||
_brcRight = std::shared_ptr<BorderCode>(new BorderCode(brc, size));
|
||
|
||
//memcpy(brc, (iter->Arguments + 32), size);
|
||
//_brcHorz = std::shared_ptr<BorderCode>(new BorderCode(brc, size));
|
||
|
||
//memcpy(brc, (iter->Arguments + 40), size);
|
||
//_brcVert = std::shared_ptr<BorderCode>(new BorderCode(brc, size));
|
||
}break;
|
||
case sprmOldTSetBrc:
|
||
case sprmTSetBrc:
|
||
{ //borders (cell definition)
|
||
unsigned char min = iter->Arguments[0];
|
||
unsigned char max = iter->Arguments[1];
|
||
|
||
int bordersToApply = (int)( iter->Arguments[2] );
|
||
|
||
if ( ( _cellIndex >= min ) && ( _cellIndex < max ) )
|
||
{
|
||
const int brcSize = 8;
|
||
unsigned char brcBytes[brcSize];
|
||
memcpy( brcBytes, ( iter->Arguments + 3 ), brcSize );
|
||
|
||
if( FormatUtils::BitmaskToBool( bordersToApply, 0x01 ) )
|
||
{
|
||
_brcTop = std::shared_ptr<BorderCode>(new BorderCode( brcBytes, brcSize ));
|
||
}
|
||
if( FormatUtils::BitmaskToBool( bordersToApply, 0x02 ) )
|
||
{
|
||
_brcLeft = std::shared_ptr<BorderCode>(new BorderCode( brcBytes, brcSize ));
|
||
}
|
||
if ( FormatUtils::BitmaskToBool( bordersToApply, 0x04 ) )
|
||
{
|
||
_brcBottom = std::shared_ptr<BorderCode>(new BorderCode( brcBytes, brcSize ));
|
||
}
|
||
if ( FormatUtils::BitmaskToBool( bordersToApply, 0x08 ) )
|
||
{
|
||
_brcRight = std::shared_ptr<BorderCode>(new BorderCode( brcBytes, brcSize ));
|
||
}
|
||
}
|
||
}break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
int nComputedCellWidthsGrid = 0;
|
||
|
||
for (size_t ccc = 0; ccc < _grid->size() && ccc <= _gridIndex; ccc++)
|
||
{
|
||
nComputedCellWidthsGrid += _grid->at(ccc);
|
||
}//zadost.doc
|
||
if (_gridSpan <= 1 && nComputedCellWidth > _width/* && _width > 1*/ && nComputedCellWidths > nComputedCellWidthsGrid)
|
||
{
|
||
int width_current = 0;
|
||
for (int i = _gridIndex; i < _grid->size(); i++)
|
||
{
|
||
width_current += _grid->at(i);
|
||
if (width_current >= nComputedCellWidth)
|
||
break;
|
||
_gridSpan++;
|
||
}
|
||
_width = nComputedCellWidth;
|
||
}
|
||
|
||
XMLTools::XMLElement tcW ( L"w:tcW" );
|
||
|
||
if (_width > 1 || nComputedCellWidth > 0)
|
||
{
|
||
if (_ftsWidth == Global::CellWidthType::nil)
|
||
_ftsWidth = Global::CellWidthType::dxa;
|
||
}
|
||
else _ftsWidth = Global::CellWidthType::Auto;
|
||
|
||
XMLTools::XMLAttribute tcWVal ( L"w:w", FormatUtils::IntToWideString( _width > 1 ? _width : nComputedCellWidth) );
|
||
XMLTools::XMLAttribute tcWType ( L"w:type", FormatUtils::MapValueToWideString(_ftsWidth, &Global::CellWidthTypeMap[0][0], 4, 5 ));
|
||
|
||
tcW.AppendAttribute( tcWVal );
|
||
tcW.AppendAttribute( tcWType );
|
||
_tcPr->AppendChild( tcW );
|
||
|
||
if ( _gridSpan == 1 && ( _gridIndex < (int)_grid->size() ) && ( nComputedCellWidths > nComputedCellWidthsGrid ) )
|
||
{
|
||
//check the number of merged cells
|
||
for ( size_t i = _gridIndex + 1; i < _grid->size(); i++ )
|
||
{
|
||
_gridSpan++;
|
||
|
||
nComputedCellWidthsGrid += _grid->at( i );
|
||
|
||
if ( nComputedCellWidthsGrid >= nComputedCellWidths )
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (_gridSpan > 1)
|
||
{
|
||
appendValueElement( _tcPr, L"gridSpan", FormatUtils::IntToWideString( _gridSpan ), true );
|
||
}
|
||
|
||
//append margins
|
||
if (_tcMar->GetChildCount() > 0)
|
||
{
|
||
_tcPr->AppendChild( *(_tcMar) );
|
||
}
|
||
|
||
//append borders
|
||
if ((_brcTop && _brcTop->GetType() != 0) || (_brcTop && _brcTop->GetNil()))
|
||
{
|
||
XMLTools::XMLElement topBorder( L"w:top" );
|
||
appendBorderAttributes(_brcTop.get(), &topBorder);
|
||
addOrSetBorder(_tcBorders, &topBorder );
|
||
}
|
||
|
||
if ((_brcLeft && _brcLeft->GetType() != 0) || (_brcLeft && _brcLeft->GetNil()))
|
||
{
|
||
XMLTools::XMLElement leftBorder( L"w:left" );
|
||
appendBorderAttributes(_brcLeft.get(), &leftBorder);
|
||
addOrSetBorder(_tcBorders, &leftBorder);
|
||
}
|
||
|
||
if ((_brcBottom && _brcBottom->GetType() != 0) || (_brcBottom && _brcBottom->GetNil()))
|
||
{
|
||
XMLTools::XMLElement bottomBorder( L"w:bottom" );
|
||
appendBorderAttributes(_brcBottom.get(), &bottomBorder);
|
||
addOrSetBorder(_tcBorders, &bottomBorder);
|
||
}
|
||
|
||
if ((_brcRight && _brcRight->GetType() != 0) || (_brcRight && _brcRight->GetNil()))
|
||
{
|
||
XMLTools::XMLElement rightBorder( L"w:right" );
|
||
appendBorderAttributes( _brcRight.get(), &rightBorder );
|
||
addOrSetBorder( _tcBorders, &rightBorder );
|
||
}
|
||
|
||
if ( _tcBorders->GetChildCount() > 0 )
|
||
{
|
||
_tcPr->AppendChild( *(_tcBorders) );
|
||
}
|
||
|
||
//write Properties
|
||
if ((_tcPr->GetChildCount() > 0) || (_tcPr->GetAttributeCount() > 0))
|
||
m_pXmlWriter->WriteString(_tcPr->GetXMLString());
|
||
}
|
||
|
||
void TableCellPropertiesMapping::apppendCellShading (unsigned char* sprmArg, int size, int cellIndex)
|
||
{
|
||
if (sprmArg && cellIndex >= 0)
|
||
{
|
||
//shading descriptor can have 10 bytes (Word 2000) or 2 bytes (Word 97)
|
||
int shdLength = 2;
|
||
|
||
if ( ( size % 10 ) == 0 )
|
||
shdLength = 10;
|
||
|
||
unsigned char* shdBytes = new unsigned char[shdLength];
|
||
|
||
if (shdBytes)
|
||
{
|
||
if ( ( cellIndex * shdLength ) < size )
|
||
{
|
||
memcpy (shdBytes, sprmArg + (cellIndex * shdLength), shdLength);
|
||
|
||
ShadingDescriptor shd (shdBytes, shdLength);
|
||
appendShading (_tcPr, shd);
|
||
}
|
||
|
||
RELEASEARRAYOBJECTS(shdBytes);
|
||
}
|
||
}
|
||
}
|
||
|
||
bool TableCellPropertiesMapping::IsTableBordersDefined (const std::vector<SinglePropertyModifier>* grpprl) const
|
||
{
|
||
if (grpprl)
|
||
{
|
||
std::vector<SinglePropertyModifier>::const_iterator end = grpprl->end();
|
||
for (std::vector<SinglePropertyModifier>::const_iterator iter = grpprl->begin(); iter != end; ++iter)
|
||
{
|
||
if ((iter->OpCode == sprmTTableBorders) || (iter->OpCode == sprmTTableBorders80) || (iter->OpCode == sprmTSetBrc))
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool TableCellPropertiesMapping::IsTableCellWidthDefined (const std::vector<SinglePropertyModifier>* grpprl) const
|
||
{
|
||
if (grpprl)
|
||
{
|
||
std::vector<SinglePropertyModifier>::const_iterator end = grpprl->end();
|
||
for (std::vector<SinglePropertyModifier>::const_iterator iter = grpprl->begin(); iter != end; ++iter)
|
||
{
|
||
if ( iter->OpCode == sprmTCellWidth )
|
||
{
|
||
unsigned char first = iter->Arguments[0];
|
||
unsigned char lim = iter->Arguments[1];
|
||
|
||
if ((_cellIndex >= first) && (_cellIndex < lim))
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|