filter/source/flash/swfwriter2.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: swfwriter2.cxx,v $
  10  * $Revision: 1.10 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_filter.hxx"
  33 #include "swfwriter.hxx"
  34 #include <vcl/virdev.hxx>
  35
  36 #include <math.h>
  37
  38 using namespace ::swf;
  39 using namespace ::std;
  40 using namespace ::com::sun::star::uno;
  41 using namespace ::com::sun::star::io;
  42 using ::rtl::OUString;
  43 using ::rtl::OString;
  44
  45 // -----------------------------------------------------------------------------
  46
  47 sal_uInt16 getMaxBitsUnsigned( sal_uInt32 nValue )
  48 {
  49     sal_uInt16 nBits = 0;
  50
  51     while( nValue )
  52     {
  53         nBits++;
  54         nValue >>= 1;
  55     }
  56
  57     return nBits;
  58 }
  59
  60 // -----------------------------------------------------------------------------
  61
  62 sal_uInt16 getMaxBitsSigned( sal_Int32 nValue )
  63 {
  64     if( nValue < 0 )
  65         nValue *= -1;
  66
  67     return getMaxBitsUnsigned( static_cast< sal_uInt32 >(nValue) ) + 1;
  68 }
  69
  70 // -----------------------------------------------------------------------------
  71
  72 BitStream::BitStream()
  73 {
  74     mnBitPos = 8;
  75     mnCurrentByte = 0;
  76 }
  77
  78 // -----------------------------------------------------------------------------
  79
  80 void BitStream::writeUB( sal_uInt32 nValue, sal_uInt16 nBits )
  81 {
  82     while( nBits != 0 )
  83     {
  84         mnCurrentByte |= nValue << (32 - nBits) >> (32 - mnBitPos);
  85
  86         if ( nBits > mnBitPos )
  87         {
  88             nBits = nBits - mnBitPos;
  89             mnBitPos = 0;
  90         }
  91         else
  92         {
  93             mnBitPos = sal::static_int_cast<sal_uInt8>( mnBitPos - nBits );
  94             nBits = 0;
  95         }
  96
  97         if( 0 == mnBitPos )
  98             pad();
  99     }
 100 }
 101
 102 // -----------------------------------------------------------------------------
 103
 104 void BitStream::writeSB( sal_Int32 nValue, sal_uInt16 nBits )
 105 {
 106     writeUB( static_cast< sal_uInt32 >(nValue), nBits );
 107 }
 108
 109 // -----------------------------------------------------------------------------
 110
 111 void BitStream::writeFB( sal_uInt32 nValue, sal_uInt16 nBits )
 112 {
 113     writeUB( nValue, nBits );
 114 }
 115
 116 // -----------------------------------------------------------------------------
 117
 118 void BitStream::pad()
 119 {
 120     if( 8 != mnBitPos )
 121     {
 122         maData.push_back( mnCurrentByte );
 123         mnCurrentByte = 0;
 124         mnBitPos = 8;
 125     }
 126 }
 127
 128 // -----------------------------------------------------------------------------
 129
 130 void BitStream::writeTo( SvStream& out )
 131 {
 132     pad();
 133
 134     vector< sal_uInt8 >::iterator aIter( maData.begin() );
 135     const vector< sal_uInt8>::iterator aEnd( maData.end() );
 136     while(aIter != aEnd)
 137     {
 138         out << (*aIter++);
 139     }
 140 }
 141
 142 // -----------------------------------------------------------------------------
 143
 144 sal_uInt32 BitStream::getOffset() const
 145 {
 146     return maData.size();
 147 }
 148
 149 ////////////////////////////////////////////////////////////////////////////////
 150
 151 Tag::Tag( sal_uInt8 nTagId )
 152 {
 153     mnTagId = nTagId;
 154 }
 155
 156 // -----------------------------------------------------------------------------
 157
 158 void Tag::write( SvStream &out )
 159 {
 160     Seek( STREAM_SEEK_TO_END );
 161     sal_uInt32 nSz = Tell();
 162     Seek( STREAM_SEEK_TO_BEGIN );
 163
 164     if( mnTagId != 0xff )
 165     {
 166         bool bLarge = nSz > 62;
 167
 168         sal_uInt16 nCode = ( mnTagId << 6 ) | ( bLarge ? 0x3f : _uInt16(nSz) );
 169
 170         out << (sal_uInt8)nCode;
 171         out << (sal_uInt8)(nCode >> 8);
 172
 173         if( bLarge )
 174         {
 175             sal_uInt32 nTmp = nSz;
 176
 177             out << (sal_uInt8)nTmp;
 178             nTmp >>= 8;
 179             out << (sal_uInt8)nTmp;
 180             nTmp >>= 8;
 181             out << (sal_uInt8)nTmp;
 182             nTmp >>= 8;
 183             out << (sal_uInt8)nTmp;
 184         }
 185     }
 186
 187     out.Write( GetData(), nSz );
 188 }
 189 #if 0
 190 // -----------------------------------------------------------------------------
 191
 192 void Tag::addI32( sal_Int32 nValue )
 193 {
 194     addUI32( static_cast<sal_uInt32>( nValue ) );
 195 }
 196 #endif
 197 // -----------------------------------------------------------------------------
 198
 199 void Tag::addUI32( sal_uInt32 nValue )
 200 {
 201     *this << nValue;
 202 }
 203 #if 0
 204 // -----------------------------------------------------------------------------
 205
 206 void Tag::addI16( sal_Int16 nValue )
 207 {
 208     addUI16( static_cast<sal_uInt16>( nValue ) );
 209 }
 210 #endif
 211 // -----------------------------------------------------------------------------
 212
 213 void Tag::addUI16( sal_uInt16 nValue )
 214 {
 215     *this << (sal_uInt8)nValue;
 216     *this << (sal_uInt8)(nValue >> 8);
 217 }
 218
 219 // -----------------------------------------------------------------------------
 220
 221 void Tag::addUI8( sal_uInt8 nValue )
 222 {
 223     *this << (sal_uInt8)nValue;
 224 }
 225
 226 // -----------------------------------------------------------------------------
 227
 228 void Tag::addBits( BitStream& rIn )
 229 {
 230     rIn.writeTo( *this );
 231 }
 232
 233 // -----------------------------------------------------------------------------
 234
 235 void Tag::addRGBA( const Color& rColor )
 236 {
 237     addUI8( rColor.GetRed() );
 238     addUI8( rColor.GetGreen() );
 239     addUI8( rColor.GetBlue() );
 240     addUI8( 0xff - rColor.GetTransparency() );
 241 }
 242
 243 // -----------------------------------------------------------------------------
 244
 245 void Tag::addRGB( const Color& rColor )
 246 {
 247     addUI8( rColor.GetRed() );
 248     addUI8( rColor.GetGreen() );
 249     addUI8( rColor.GetBlue() );
 250 }
 251
 252 // -----------------------------------------------------------------------------
 253
 254 void Tag::addRect( const Rectangle& rRect )
 255 {
 256     writeRect( *this, rRect );
 257 }
 258
 259 // -----------------------------------------------------------------------------
 260
 261 void Tag::writeRect( SvStream& rOut, const Rectangle& rRect )
 262 {
 263     BitStream aBits;
 264
 265     sal_Int32 minX, minY, maxX, maxY;
 266
 267     if( rRect.nLeft < rRect.nRight )
 268     {
 269         minX = rRect.nLeft; maxX = rRect.nRight;
 270     }
 271     else
 272     {
 273         maxX = rRect.nLeft; minX = rRect.nRight;
 274     }
 275
 276
 277     if( rRect.nTop < rRect.nBottom )
 278     {
 279         minY = rRect.nTop; maxY = rRect.nBottom;
 280     }
 281     else
 282     {
 283         maxY = rRect.nTop; minY = rRect.nBottom;
 284     }
 285
 286     // AS: Figure out the maximum nubmer of bits required to represent any of the
 287     //  rectangle coordinates.  Since minX or minY could be negative, they could
 288     //  actually require more bits than maxX or maxY.
 289     // AS: Christian, can they be negative, or is that a wasted check?
 290     // CL: I think so, f.e. for shapes that have the top and/or left edge outside
 291     //         the page origin
 292     sal_uInt8 nBits1 = sal::static_int_cast<sal_uInt8>( max( getMaxBitsSigned( minX ), getMaxBitsSigned( minY ) ) );
 293     sal_uInt8 nBits2 = sal::static_int_cast<sal_uInt8>( max( getMaxBitsSigned( maxX ), getMaxBitsSigned( maxY ) ) );
 294     sal_uInt8 nBitsMax = max( nBits1, nBits2 );
 295
 296     aBits.writeUB( nBitsMax, 5 );
 297     aBits.writeSB( minX, nBitsMax );
 298     aBits.writeSB( maxX, nBitsMax );
 299     aBits.writeSB( minY, nBitsMax );
 300     aBits.writeSB( maxY, nBitsMax );
 301
 302     aBits.writeTo( rOut );
 303 }
 304
 305 // -----------------------------------------------------------------------------
 306
 307 void Tag::addMatrix( const ::basegfx::B2DHomMatrix& rMatrix ) // #i73264#
 308 {
 309     writeMatrix( *this, rMatrix );
 310 }
 311
 312 // -----------------------------------------------------------------------------
 313
 314 void Tag::writeMatrix( SvStream& rOut, const ::basegfx::B2DHomMatrix& rMatrix ) // #i73264#
 315 {
 316
 317     BitStream aBits;
 318
 319     const sal_uInt8 bHasScale = rMatrix.get(0, 0) != 1.0 || rMatrix.get(1, 1) != 1.0;
 320
 321     aBits.writeUB( bHasScale, 1 );
 322
 323     if( bHasScale )
 324     {
 325         sal_uInt8 nScaleBits = 31;
 326
 327         aBits.writeUB( nScaleBits, 5 );
 328         aBits.writeFB( getFixed( rMatrix.get(0, 0) ), nScaleBits );     // Scale X
 329         aBits.writeFB( getFixed( rMatrix.get(1, 1) ), nScaleBits ); // Scale Y
 330     }
 331
 332     const sal_uInt8 bHasRotate = rMatrix.get(0, 1) != 0.0 || rMatrix.get(1, 0) != 0.0;
 333
 334     aBits.writeUB( bHasRotate, 1 );
 335
 336     if( bHasRotate )
 337     {
 338         sal_uInt8 nRotateBits = 31;
 339
 340         aBits.writeUB( nRotateBits, 5 );
 341         aBits.writeFB( getFixed( rMatrix.get(0, 1) ), nRotateBits );    // RotateSkew0
 342         aBits.writeFB( getFixed( rMatrix.get(1, 0) ), nRotateBits );    // RotateSkew1
 343     }
 344
 345     sal_uInt8 nTranslateBits = 16;
 346
 347     aBits.writeUB( nTranslateBits, 5 );
 348     aBits.writeSB( (sal_Int16)rMatrix.get(0, 2), nTranslateBits );              // Translate X
 349     aBits.writeSB( (sal_Int16)rMatrix.get(1, 2), nTranslateBits );              // Translate Y
 350
 351     aBits.writeTo( rOut );
 352 }
 353
 354 // -----------------------------------------------------------------------------
 355
 356 void Tag::addString( const char* pString )
 357 {
 358     if( pString )
 359     {
 360         while( *pString )
 361             addUI8( *pString++ );
 362     }
 363
 364     addUI8( 0 );
 365 }
 366
 367 // -----------------------------------------------------------------------------
 368
 369 void Tag::addStream( SvStream& rIn )
 370 {
 371     *this << rIn;
 372 }
 373
 374 ////////////////////////////////////////////////////////////////////////////////
 375
 376 Sprite::Sprite( sal_uInt16 nId )
 377 : mnId( nId ), mnFrames(0)
 378 {
 379 }
 380
 381 // -----------------------------------------------------------------------------
 382
 383 Sprite::~Sprite()
 384 {
 385     for(vector< Tag* >::iterator i = maTags.begin(); i != maTags.end(); i++)
 386         delete *i;
 387 }
 388
 389 // -----------------------------------------------------------------------------
 390
 391 void Sprite::write( SvStream& out )
 392 {
 393     SvMemoryStream aTmp;
 394     for(vector< Tag* >::iterator i = maTags.begin(); i != maTags.end(); i++)
 395         (*i)->write( aTmp );
 396
 397     if( !mnFrames )
 398         mnFrames = 1;
 399
 400     aTmp.Seek(0);
 401
 402     Tag aTag( TAG_DEFINESPRITE );
 403     aTag.addUI16( mnId );
 404     aTag.addUI16( _uInt16( mnFrames ) );
 405     aTag.addStream( aTmp );
 406     aTag.write( out );
 407 }
 408
 409 // -----------------------------------------------------------------------------
 410
 411 void Sprite::addTag( Tag* pNewTag )
 412 {
 413     if( pNewTag )
 414     {
 415         if( pNewTag->getTagId() == TAG_SHOWFRAME )
 416             mnFrames++;
 417
 418         maTags.push_back( pNewTag );
 419     }
 420 }
 421
 422 /////////////////////////////////////////////////////////////////////////////////
 423
 424 sal_uInt32 swf::getFixed( double fValue )
 425 {
 426     sal_Int16 nUpper = (sal_Int16)floor(fValue);
 427     sal_uInt16 nLower = (sal_uInt16)((fValue - floor(fValue))*0x10000);
 428
 429     sal_uInt32 temp = ((sal_Int32)nUpper)<<16;
 430     temp |= nLower;
 431
 432     return temp;
 433 }
 434
 435 /////////////////////////////////////////////////////////////////////////////////
 436
 437 /** constructs a new flash font for the given VCL Font */
 438 FlashFont::FlashFont( const Font& rFont, sal_uInt16 nId )
 439 : maFont( rFont ), mnNextIndex(0), mnId( nId )
 440 {
 441 }
 442
 443 // -----------------------------------------------------------------------------
 444
 445 FlashFont::~FlashFont()
 446 {
 447 }
 448
 449 // -----------------------------------------------------------------------------
 450
 451 /** gets the glyph id for the given character. The glyphs are created on demand */
 452 sal_uInt16 FlashFont::getGlyph( sal_uInt16 nChar, VirtualDevice* pVDev )
 453 {
 454     // see if we already created a glyph for this character
 455     std::map<sal_uInt16, sal_uInt16, ltuint16>::iterator aIter( maGlyphIndex.find(nChar) );
 456     if( aIter != maGlyphIndex.end() )
 457     {
 458         return aIter->second;
 459     }
 460
 461     // if not, we create one now
 462
 463     maGlyphIndex[nChar] = mnNextIndex;
 464
 465     Font aOldFont( pVDev->GetFont() );
 466     Font aNewFont( aOldFont );
 467     aNewFont.SetAlign( ALIGN_BASELINE );
 468     pVDev->SetFont( aNewFont );
 469     aOldFont.SetOrientation(0);
 470
 471     // let the virtual device convert the character to polygons
 472     PolyPolygon aPolyPoly;
 473     pVDev->GetTextOutline( aPolyPoly, nChar );
 474
 475     maGlyphOffsets.push_back( _uInt16( maGlyphData.getOffset() ) );
 476
 477     // Number of fill and line index bits set to 1
 478     maGlyphData.writeUB( 0x11, 8 );
 479
 480     const sal_uInt16 nCount = aPolyPoly.Count();
 481     sal_uInt16 i,n;
 482     for( i = 0; i < nCount; i++ )
 483     {
 484         Polygon& rPoly = aPolyPoly[ i ];
 485
 486         const USHORT nSize = rPoly.GetSize();
 487         if( nSize )
 488         {
 489             // convert polygon to flash EM_SQUARE (1024x1024)
 490             for( n = 0; n < nSize; n++ )
 491             {
 492                 Point aPoint( rPoly[n] );
 493                 aPoint.X() = static_cast<long>((double(aPoint.X()) * 1024.0 ) / double(aOldFont.GetHeight()));
 494                 aPoint.Y() = static_cast<long>((double(aPoint.Y()) * 1024.0 ) / double(aOldFont.GetHeight()));
 495                 rPoly[n] = aPoint;
 496             }
 497             Writer::Impl_addPolygon( maGlyphData, rPoly, true );
 498         }
 499     }
 500     Writer::Impl_addEndShapeRecord( maGlyphData );
 501
 502     maGlyphData.pad();
 503
 504     pVDev->SetFont( aOldFont );
 505
 506     return mnNextIndex++;
 507 }
 508
 509 // -----------------------------------------------------------------------------
 510
 511 void FlashFont::write( SvStream& out )
 512 {
 513     Tag aTag( TAG_DEFINEFONT );
 514
 515     aTag.addUI16( mnId );
 516
 517     sal_uInt16 nGlyphs = _uInt16( maGlyphOffsets.size() );
 518     sal_uInt16 nOffset = nGlyphs * sizeof( sal_uInt16 );
 519
 520     for(vector< sal_uInt16 >::iterator i = maGlyphOffsets.begin(); i != maGlyphOffsets.end(); i++)
 521         aTag.addUI16( nOffset + (*i) );
 522
 523     aTag.addBits( maGlyphData );
 524
 525     aTag.write( out );
 526 }
 527
 528 ////////////////////////////////////////////////////////////////////////////////
 529
 530 /** this c'tor creates a solid fill style */
 531 FillStyle::FillStyle( const Color& rSolidColor )
 532 :       meType( solid ),
 533     maColor( rSolidColor )
 534 {
 535 }
 536
 537 // -----------------------------------------------------------------------------
 538
 539 /** this c'tor creates a tiled or clipped bitmap fill style */
 540 FillStyle::FillStyle( sal_uInt16 nBitmapId, bool bClipped, const ::basegfx::B2DHomMatrix& rMatrix ) // #i73264#
 541 :       meType( bClipped ? clipped_bitmap : tiled_bitmap ),
 542     maMatrix( rMatrix ),
 543     mnBitmapId( nBitmapId )
 544 {
 545 }
 546
 547 // -----------------------------------------------------------------------------
 548
 549 FillStyle::FillStyleType Impl_getFillStyleType( const Gradient& rGradient )
 550 {
 551     switch( rGradient.GetStyle() )
 552     {
 553     case GradientStyle_ELLIPTICAL:
 554     case GradientStyle_RADIAL:
 555         return FillStyle::radial_gradient;
 556 //      case GradientStyle_AXIAL:
 557 //      case GradientStyle_SQUARE:
 558 //      case GradientStyle_RECT:
 559 //      case GradientStyle_LINEAR:
 560     default:
 561         return FillStyle::linear_gradient;
 562     }
 563 }
 564
 565 // -----------------------------------------------------------------------------
 566
 567 /** this c'tor creates a linear or radial gradient fill style */
 568 FillStyle::FillStyle( const Rectangle& rBoundRect, const Gradient& rGradient )
 569 :       meType( Impl_getFillStyleType( rGradient ) ),
 570     maGradient( rGradient ),
 571     maBoundRect( rBoundRect )
 572 {
 573 }
 574
 575 // -----------------------------------------------------------------------------
 576
 577 void FillStyle::addTo( Tag* pTag ) const
 578 {
 579     pTag->addUI8( sal::static_int_cast<sal_uInt8>( meType ) );
 580     switch( meType )
 581     {
 582     case solid:
 583         pTag->addRGBA( maColor );
 584         break;
 585     case linear_gradient:
 586     case radial_gradient:
 587         Impl_addGradient( pTag );
 588         break;
 589     case tiled_bitmap:
 590     case clipped_bitmap:
 591         pTag->addUI16( mnBitmapId );
 592         pTag->addMatrix( maMatrix );
 593         break;
 594     }
 595 }
 596
 597 // -----------------------------------------------------------------------------
 598
 599 struct GradRecord
 600 {
 601     sal_uInt8   mnRatio;
 602     Color               maColor;
 603
 604     GradRecord( sal_uInt8 nRatio, const Color& rColor ) : mnRatio( nRatio ), maColor( rColor ) {}
 605 };
 606
 607 // TODO: better emulation of our gradients
 608 void FillStyle::Impl_addGradient( Tag* pTag ) const
 609 {
 610     vector< struct GradRecord > aGradientRecords;
 611
 612     ::basegfx::B2DHomMatrix m; // #i73264#
 613
 614     m.rotate( (maGradient.GetAngle() - 900) * F_PI1800 );
 615
 616     switch( maGradient.GetStyle() )
 617     {
 618     case GradientStyle_ELLIPTICAL:
 619     case GradientStyle_RADIAL:
 620         {
 621             aGradientRecords.push_back( GradRecord( 0x00, maGradient.GetEndColor() ) );
 622             aGradientRecords.push_back( GradRecord( 0xff, maGradient.GetStartColor() ) );
 623
 624             double tx = ( maGradient.GetOfsX() * 32768.0 ) / 100.0;
 625             double ty = ( maGradient.GetOfsY() * 32768.0 ) / 100.0;
 626             double scalex = (double)maBoundRect.GetWidth() / 32768.0;
 627             double scaley = (double)maBoundRect.GetHeight() / 32768.0;
 628
 629             m.scale( 1.2, 1.2 );
 630
 631             if( scalex > scaley )
 632             {
 633                 double scale_move = scaley / scalex;
 634
 635                 m.translate( tx, scale_move * ty );
 636
 637
 638                 m.scale( scalex, scalex );
 639             }
 640             else
 641             {
 642                 double scale_move = scalex / scaley;
 643
 644                 m.translate( scale_move * tx, ty );
 645
 646
 647                 m.scale( scaley, scaley );
 648             }
 649
 650         }
 651         break;
 652     case GradientStyle_AXIAL:
 653         {
 654             aGradientRecords.push_back( GradRecord( 0x00, maGradient.GetEndColor() ) );
 655             aGradientRecords.push_back( GradRecord( 0x80, maGradient.GetStartColor() ) );
 656             aGradientRecords.push_back( GradRecord( 0xff, maGradient.GetEndColor() ) );
 657             double tx = ( 32768.0 / 2.0 );
 658             double ty = ( 32768.0 / 2.0 );
 659             double scalex = (double)maBoundRect.GetWidth() / 32768.0;
 660             double scaley = (double)maBoundRect.GetHeight() / 32768.0;
 661
 662             m.translate( tx, ty );
 663             m.scale( scalex, scaley );
 664         }
 665         break;
 666     case GradientStyle_SQUARE:
 667     case GradientStyle_RECT:
 668     case GradientStyle_LINEAR:
 669         {
 670             aGradientRecords.push_back( GradRecord( 0x00, maGradient.GetStartColor() ) );
 671             aGradientRecords.push_back( GradRecord( 0xff, maGradient.GetEndColor() ) );
 672             double scalex = (double)maBoundRect.GetWidth() / 32768.0;
 673             double scaley = (double)maBoundRect.GetHeight() / 32768.0;
 674
 675             m.scale( scalex, scaley );
 676
 677             m.translate( maBoundRect.GetWidth() / 2.0, maBoundRect.GetHeight() / 2.0 );
 678         }
 679         break;
 680     case  GradientStyle_FORCE_EQUAL_SIZE: break;
 681     }
 682
 683     m.translate( maBoundRect.nLeft, maBoundRect.nTop );
 684
 685     pTag->addMatrix( m );
 686
 687     DBG_ASSERT( aGradientRecords.size() < 8, "Illegal FlashGradient!" );
 688
 689     pTag->addUI8( static_cast<sal_uInt8>( aGradientRecords.size() ) );
 690
 691     for(std::vector< GradRecord >::iterator i = aGradientRecords.begin(); i != aGradientRecords.end(); i++)
 692     {
 693         pTag->addUI8( (*i).mnRatio );
 694         pTag->addRGBA( (*i).maColor );
 695     }
 696 }
 697