开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
sitetran.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：181k
源码类别：

Symbian

开发平台：

Visual C++

sitetran.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: sitetran.cpp,v 1.2.40.1 2004/07/09 01:59:28 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #define _TRANSITIONS_ON_
  51. //#define _TESTING_TRANITIONS_   
  53. #ifdef _TESTING_TRANITIONS_
  54. #define INITGUID    // this must be befor pntypes
  55. #endif
  57. #include "hxtypes.h" // this must be before windows.h
  59. #ifdef _WIN32
  60. #include "windows.h"
  61. #endif
  63. #define PI 3.14159265358979323846
  64. #define Root2 1.414213562
  66. #include <math.h>
  67. #include <stdio.h>
  68. #include <stdlib.h>
  70. //#define NO_GRAPHICS
  72. #include "hxcom.h"
  73. #include "hxbuffer.h"
  74. #include "hxassert.h"
  75. #include "sitetran.h"
  76. #include "region.h"
  77. #include "poly.h"
  78. #include "tranmat.h"
  79. #include "hxstrutl.h"
  84. //=======================================================================
  85. //=======================================================================
  86. //               All Transistion effects
  87. //=======================================================================
  88. //=======================================================================
  90. void CopyRegion(HXREGION* dstrgn, HXREGION* rgn)
  91. {
  92.    if (dstrgn != rgn) /*  don't want to copy to itself */
  93.    {  
  94.       if (dstrgn->size < rgn->numRects)
  95.       {
  96.          if (dstrgn->rects)
  97.          {
  98.             HXBOX *prevRects = dstrgn->rects;
  99.                 
  100.             if (! (dstrgn->rects = (HXBOX *)
  101.                    realloc((char *) dstrgn->rects,
  102.                            (unsigned) rgn->numRects * (sizeof(HXBOX))))) {
  103.                free(prevRects);
  104.                return;
  105.             }
  106.          }
  107.          dstrgn->size = rgn->numRects;
  108.       }
  109.       dstrgn->numRects = rgn->numRects;
  110.       dstrgn->extents.x1 = rgn->extents.x1;
  111.       dstrgn->extents.y1 = rgn->extents.y1;
  112.       dstrgn->extents.x2 = rgn->extents.x2;
  113.       dstrgn->extents.y2 = rgn->extents.y2;
  115.       memcpy((char *) dstrgn->rects, (char *) rgn->rects, /* Flawfinder: ignore */
  116.              (int) (rgn->numRects * sizeof(HXBOX)));
  117.    }
  118. }
  121. HXREGION* InvertRGN(HXREGION* in, int x, int y, int x1, int y1)
  122. {
  123.    HXREGION* retRGN = HXCreateRectRegion(x,y,x1 - x,y1 - y);
  124.    HXCombineRgn(retRGN, retRGN, in, HX_RGN_DIFF);
  125.    HXDestroyRegion(in);
  126.    return retRGN;
  127. }
  129. int CompareRects(const void *arg1, const void *arg2)
  130. {
  131.    HXBOX* b1 = (HXBOX*)arg1;
  132.    HXBOX* b2 = (HXBOX*)arg2;
  134.    if (b1->y1 < b2->y1) 
  135.       return -1;
  137.    if (b1->y1 != b2->y1)
  138.       return 1;
  140.    if (b1->x1 < b2->x1)
  141.       return -1;
  143.    if (b1->x1 != b2->x1)
  144.       return 1;
  146.    return 0;
  147. }
  149. HXREGION* MirrorHorizontal(HXREGION* in, int y)
  150. {
  151.    int tmpY;
  153.    for (int i = 0; i < in->numRects; ++i)
  154.    {
  155.       in->rects[i].y1 = 2 * y - in->rects[i].y1;
  156.       in->rects[i].y2 = 2 * y - in->rects[i].y2;
  157.         
  158.       if (in->rects[i].y2 < in->rects[i].y1)
  159.       {
  160.          tmpY = in->rects[i].y1;
  161.          in->rects[i].y1 = in->rects[i].y2;
  162.          in->rects[i].y2 = tmpY;
  163.       }
  164.    }
  166.    qsort((void*)in->rects, in->numRects, sizeof(HXBOX), CompareRects);
  168.    return in;
  169. }
  171. HXREGION* MirrorVertical(HXREGION* in, int x)
  172. {
  173.    int tmpX;
  175.    for (int i = 0; i < in->numRects; ++i)
  176.    {
  177.       in->rects[i].x1 = 2 * x - in->rects[i].x1;
  178.       in->rects[i].x2 = 2 * x - in->rects[i].x2;
  179.         
  180.       if (in->rects[i].x2 < in->rects[i].x1)
  181.       {
  182.          tmpX = in->rects[i].x1;
  183.          in->rects[i].x1 = in->rects[i].x2;
  184.          in->rects[i].x2 = tmpX;
  185.       }
  186.       if( in->rects[i].x1 != 0 )
  187.           in->rects[i].x1 = in->rects[i].x1 -1;
  188.    }
  190.    qsort((void*)in->rects, in->numRects, sizeof(HXBOX), CompareRects);
  192.    return in;
  193. }
  195. void MirrorHorizontal(tranLines* lines, int y)
  196. {
  197.    for (int i = 0; i < lines->m_nLines; ++i)
  198.    {
  199.       lines->m_pLines[i].start.x = lines->m_pLines[i].start.x;
  200.       lines->m_pLines[i].start.y = 2 * y - lines->m_pLines[i].start.y;
  201.       lines->m_pLines[i].finish.x = lines->m_pLines[i].finish.x;
  202.       lines->m_pLines[i].finish.y = 2 * y - lines->m_pLines[i].finish.y;
  203.    }
  204. }
  206. void MirrorVertical(tranLines* lines, int x)
  207. {
  208.    for (int i = 0; i < lines->m_nLines; ++i)
  209.    {
  210.       lines->m_pLines[i].start.x = 2 * x - lines->m_pLines[i].start.x;
  211.       lines->m_pLines[i].start.y = lines->m_pLines[i].start.y;
  212.       lines->m_pLines[i].finish.x = 2 * x - lines->m_pLines[i].finish.x;
  213.       lines->m_pLines[i].finish.y = lines->m_pLines[i].finish.y;
  214.    }
  215. }
  217. tranLines::tranLines()
  218. {
  219.    m_nLines = 0;
  220.    m_pLines = NULL;
  221. }
  223. tranLines::~tranLines()
  224. {
  225.    Destroy();
  226. }
  229. LineSegment::LineSegment(const LineSegment& ls)
  230. {
  231.    *this = ls;
  232. }
  234. void LineSegment::operator=(const LineSegment& right)
  235. {
  236.    start.x = right.start.x;
  237.    start.y = right.start.y;
  238.    finish.x = right.finish.x;
  239.    finish.y = right.finish.y;
  240. }
  242. // returns TRUE if the line is within the boundary, FALSE if it lies completely outside
  243. BOOL LineSegment::Clip(int left, int top, int right, int bottom)
  244. {
  245.    BOOL retVal = TRUE;
  246.    double slope;
  248.    // make sure our start is left of finish
  249.    if (start.x > finish.x)
  250.    {
  251.       int tmp = start.x;
  252.       start.x = finish.x;
  253.       finish.x = tmp;
  255.       tmp = start.y;
  256.       start.y = finish.y;
  257.       finish.y = tmp;
  258.    }
  260.    if (start.x > right || finish.x < left ||
  261.        (start.y < top && finish.y < top) ||
  262.        (start.y > bottom && finish.y > bottom))
  263.    {
  264.       retVal = FALSE;
  265.       goto LineSegment_Clip_End;
  266.    }
  268.    slope = ((double)(finish.y - start.y + 1) / (double)(finish.x - start.x + 1));
  270.    if (start.x < left)
  271.    {
  272.       start.y += int((left - start.x) * slope);
  273.       start.x = left;
  274.    }
  275.    if (start.y > bottom)
  276.    {
  277.       start.x -= int((start.y - bottom) / slope);
  278.       start.y = bottom;
  279.    }
  280.    if(start.y < top)
  281.    {
  282.       start.x += int((top - start.y) / slope);
  283.       start.y = top;
  284.    }
  286.    if (finish.x > right)
  287.    {
  288.       finish.y -= int((finish.x - right) * slope);
  289.       finish.x = right;
  290.    }
  291.    if (finish.y > bottom)
  292.    {
  293.       finish.x -= int((finish.y - bottom) / slope);
  294.       finish.y = bottom;
  295.    }
  296.    if(finish.y < top)
  297.    {
  298.       finish.x += int((top - finish.y) / slope);
  299.       finish.y = top;
  300.    }
  302.    if (start.x < left || start.x > right ||
  303.        start.y < top || start.y > bottom ||
  304.        finish.x < left || finish.x > right || 
  305.        finish.y < top || finish.y > bottom)
  306.    {
  307.       //XXXSMJ currently there's a case were the line can exist with only
  308.       // an endpoint on border.  This means only one pixel of the line is
  309.       // inside the clipping region.  For now, we'll say this sucker is
  310.       // clipped.
  311.       retVal = FALSE;
  312.    }
  314.   LineSegment_Clip_End:
  315.    return retVal;
  316. }
  318. tranLines* operator+(const tranLines& left, const tranLines& right)
  319. {
  320.    tranLines* newLines = const_cast<tranLines*>(&left);
  321.     
  322.    if (right.m_nLines)
  323.    {
  324.       newLines = new tranLines;
  325.     
  326.       newLines->m_nLines = left.m_nLines + right.m_nLines;
  327.       newLines->m_pLines = new LineSegment[newLines->m_nLines];
  328.     
  329.       if (!newLines->m_pLines)
  330.       {
  331.          newLines->m_nLines = 0;
  332.       }
  333.       else
  334.       {
  335.          int i,c;
  336.          for (i = 0, c = 0; i < left.m_nLines; ++i, ++c)
  337.          {
  338.             newLines->m_pLines[c] = left.m_pLines[i];
  339.          }
  340.          for (i = 0; i < right.m_nLines; ++i, ++c)
  341.          {
  342.             newLines->m_pLines[c] = right.m_pLines[i];
  343.          }
  344.       }
  345.    }
  346.    return newLines;
  347. }
  349. void tranLines::operator=(const tranLines& right)
  350. {
  351.    Copy(right);
  352. }
  354. void tranLines::operator+=(const tranLines& right)
  355. {
  356.    if (right.m_nLines)
  357.    {
  358.       tranLines* newLines = *this + right;
  359.       Copy(*newLines);
  360.     
  361.       delete newLines;
  362.    }
  363. }
  365. void tranLines::operator+=(const LineSegment& right)
  366. {
  367.    tranLines newLines;
  368.     
  369.    newLines.m_nLines = 1;
  370.    newLines.m_pLines = new LineSegment[1];
  371.     
  372.    if (!newLines.m_pLines)
  373.    {
  374.       newLines.m_nLines = 0;
  375.    }
  376.    else
  377.    {
  378.       *newLines.m_pLines = right;
  379.    }
  381.    *this += newLines;
  382. }
  384. tranLines::tranLines(const tranLines& tl)
  385. {
  386.    m_nLines = 0;
  387.    m_pLines = NULL;
  389.    Copy(tl);
  390. }
  392. void tranLines::Copy(const tranLines& tl)
  393. {
  394.    Destroy();
  396.    m_nLines = tl.m_nLines;
  398.    if (m_nLines)
  399.    {
  400.       m_pLines = new LineSegment[m_nLines];
  402.       for (int i = 0; i < m_nLines; ++i)
  403.       {
  404.          m_pLines[i] = tl.m_pLines[i];
  405.       }
  406.    }
  407. }
  409. void tranLines::Offset(int x, int y)
  410. {
  411.    for (int i = 0; i < m_nLines; ++i)
  412.    {
  413.       m_pLines[i].start.x += x;
  414.       m_pLines[i].start.y += y;
  415.       m_pLines[i].finish.x += x;
  416.       m_pLines[i].finish.y += y;
  417.    }
  418. }
  420. void tranLines::Destroy()
  421. {
  422.    if (m_pLines)
  423.    {
  424.       delete [] m_pLines;
  425.       m_pLines = NULL;
  426.    }
  428.    m_nLines = 0;
  429. }
  431. void tranLines::Clip(int left, int top, int right, int bottom)
  432. {
  433.    int newlines = m_nLines;
  434.    for (int i = 0; i < m_nLines; ++i)
  435.    {
  436.       if (!m_pLines[i].Clip(left, top, right, bottom))
  437.       {
  438.          // the line is not within our area so mark it for clipping
  439.          m_pLines[i].start.x = m_pLines[i].start.y = m_pLines[i].finish.x = m_pLines[i].finish.y = -42;
  440.          --newlines;
  441.       }
  442.    }
  444.    if (newlines != m_nLines)  // do we need to remove any lines?
  445.    {
  446.       tranLines tmpLines;
  447.       tmpLines.m_nLines = newlines;
  448.       tmpLines.m_pLines = new LineSegment[newlines];
  450.       for (int i = 0, c = 0; c < newlines; ++i)
  451.       {
  452.          if (m_pLines[i].start.x != -42 && m_pLines[i].start.y != -42 &&
  453.              m_pLines[i].finish.x != -42 && m_pLines[i].finish.y != -42)
  454.          {
  455.             tmpLines.m_pLines[c++] = m_pLines[i];
  456.          }
  457.       }
  458.    }
  459. }
  461. void GetDiagonalStripCoords(HXxPoint topLeft, HXxPoint topRight, HXxPoint bottomRight, HXxPoint bottomLeft, HXxPoint* topPoint, HXxPoint* bottomPoint, int completeness)
  462. {
  463.    int topWidth = topRight.x - topLeft.x;
  464.    int bottomWidth = bottomRight.x - bottomLeft.x;
  465.    int height = max(bottomLeft.y - topLeft.y, bottomRight.y - topRight.y);
  466.    double angle;
  467.     
  468.    int length;
  469.    int mark;
  470.     
  471.    if (topWidth > bottomWidth)
  472.    {
  473.       int rightHeight = topLeft.y - topRight.y;
  474.       length = int(sqrt((double)(topWidth * topWidth + rightHeight * rightHeight)));
  475.       mark = int(double(length * completeness) / 1000.0);
  476.       angle = atan(double(topLeft.y - topRight.y) / double(topWidth));
  477.         
  478.       topPoint->x = int(topLeft.x + cos(angle) * mark);
  479.       topPoint->y = int(topLeft.y - sin(angle) * mark);
  480.         
  481.       int length2 = int(sin(angle) * height);
  482.         
  483.       bottomPoint->x = topPoint->x + int(cos(angle) * length2 + 1);
  484.       bottomPoint->y = topPoint->y + height - int(sin(angle) * length2);
  485.    }
  486.    else
  487.    {
  488.       int leftHeight = bottomLeft.y - bottomRight.y;
  489.       length = int(sqrt((double)(bottomWidth * bottomWidth + leftHeight * leftHeight)));
  490.       mark = int(double(length * completeness) / 1000.0);
  491.       angle = atan(double(bottomLeft.y - bottomRight.y) / double(bottomWidth));
  492.         
  493.       bottomPoint->x = int(bottomLeft.x + cos(angle) * mark + 1);
  494.       bottomPoint->y = int(bottomLeft.y - sin(angle) * mark);
  495.         
  496.       int length2 = int(sin(angle) * height);
  497.         
  498.       topPoint->x = bottomPoint->x - int(cos(angle) * length2 + 1);
  499.       topPoint->y = bottomPoint->y - height + int(sin(angle) * length2);
  500.    }
  501. }
  503. void PrintRgnData(HXREGION* retRGN)
  504. {
  505. #ifdef _WINDOWS
  506.    FILE* f1 = ::fopen("d:\expose.txt", "a+"); /* Flawfinder: ignore */
  507.    LPRGNDATA    lpRgnData;
  508.    DWORD sizeNeeed = GetRegionData((HRGN)retRGN, 0, NULL); 
  509.    lpRgnData = (LPRGNDATA) new char[sizeNeeed];
  510.    GetRegionData((HRGN)retRGN, sizeNeeed, lpRgnData); 
  511.    for(int j = 0; j < (int) lpRgnData->rdh.nCount;j++)
  512.    {
  513.       HXRECTANGLE* pRect = (HXRECTANGLE*) lpRgnData->Buffer;
  514.       ::fprintf(f1, "Rect (%d, %d) -(%d, %d)n", pRect[j].x, pRect[j].y, pRect[j].width, pRect[j].height);
  515.    }
  516.    delete lpRgnData;
  517.    fclose(f1);
  518. #else
  519.    HX_ASSERT(!"cant print rgn data");
  520. #endif
  521. }
  524. //#define _TESTING_TRANITIONS_
  525. /* 
  526.  * Table of all transition effects
  527.  */
  528. //          {DefaultTransition, ""},
  530. #ifdef _TRANSITIONS_ON_
  532. tranStruct z_barWipeTable[] =
  533. {
  534.    {EdgeWipe, 1,"leftToRight"},
  535.    {SlideVerticalEdgeWipe, 2, "topToBottom"}
  536. };
  538. tranStruct z_boxWipeTable[] =
  539. {
  540.    {TopLeftEdgeWipe, 3, "topLeft"},
  541.    {TopRightEdgeWipe, 4, "topRight"},
  542.    {BottomRightEdgeWipe, 5, "bottomRight"},
  543.    {BottomLeftEdgeWipe, 6, "bottomLeft"},
  544.    {TopCenterEdgeWipe, 23, "topCenter"},
  545.    {CenterRightEdgeWipe, 24, "rightCenter"},
  546.    {BottomCenterEdgeWipe, 25, "bottomCenter"},
  547.    {LeftCenterEdgeWipe, 26, "leftCenter"}
  548. };
  550. tranStruct z_fourBoxTable[] =
  551. {
  552.    {FourCornerEdgeWipe, 7, "cornersIn"},
  553.    {FourBoxEdgeWipe , 8, "cornersOut"}
  554. };
  556. tranStruct z_barnDoorTable[] =
  557. {
  558.    {BarnVerticalEdgeWipe , 21, "vertical"},
  559.    {BarnHorizontalEdgeWipe, 22, "horizontal"},
  560.    {DiagonaLeftOutEdgeWipe, 45, "diagonalBottomLeft"},
  561.    {DiagonaRightOutEdgeWipe, 46, "diagonalTopLeft"}
  562. };    
  564. tranStruct z_diagonalTable[] =
  565. {
  566.    {DiagonalLeftDownEdgeWipe, 41, "topLeft"},
  567.    {DiagonalRightDownEdgeWipe, 42, "topRight"}
  568. };
  570. tranStruct z_bowTieTable[] =
  571. {
  572.    {VerticalBowTieEdgeWipe, 43, "vertical"},
  573.    {HorizontalBowTieEdgeWipe, 44, "horizontal"}
  574. };
  576. tranStruct z_miscDiagonalTable[] =
  577. {
  578.    {DiagonaCrossEdgeWipe, 47, "doubleBarnDoor"},
  579.    {DiagonalBoxEdgeWipe, 48, "doubleDiamond"}
  580. };
  582. tranStruct z_veeTable[] =
  583. {
  584.    {FilledVEdgeWipe, 61, "down"},
  585.    {FilledVRightEdgeWipe, 62, "left"},
  586.    {FilledVBottomEdgeWipe, 63, "up"},
  587.    {FilledVLeftEdgeWipe, 64, "right"}
  588. };
  590. tranStruct z_barnVeeTable[] =
  591. {
  592.    {HollowVEdgeWipe, 65, "down"},
  593.    {HollowVRightEdgeWipe, 66, "left"},
  594.    {HollowVBottomEdgeWipe , 67, "up"},
  595.    {HollowVLeftEdgeWipe, 68, "right"}
  596. };
  598. tranStruct z_zigZagTable[] =
  599. {
  600.    {VerticalZigZagEdgeWipe, 71, "leftToRight"},
  601.    {HorizontalZigZagEdgeWipe, 72, "topToBottom"}
  602. };
  604. tranStruct z_barnZigZagTable[] =
  605. {
  606.    {VerticalBarnZigZagEdgeWipe, 73, "vertical"},
  607.    {HorizontalBarnZigZagEdgeWipe, 74, "horizontal"}
  608. };
  610. //-----------------------------------------------------------------------
  611. tranStruct z_irisTable[] =
  612. {
  613.    {RectangleIris, 101, "rectangle"},
  614.    {DiamondIris, 102, "diamond"}
  615. };
  617. tranStruct z_triangleTable[] =
  618. {
  619.    {TriangleIris, 103, "up"},
  620.    {TriangleRightIris, 104, "right"},
  621.    {TriangleUpsideDownIris, 105, "down"},
  622.    {TriangleLeftIris, 106, "left"}
  623. };
  625. tranStruct z_arrowHeadTable[] =
  626. {
  627.    {ArrowHeadIris, 107, "up"},
  628.    {ArrowHeadRightIris, 108, "right"},
  629.    {ArrowHeadUpsideDownIris, 109, "down"},
  630.    {ArrowHeadLeftIris, 110, "left"}
  631. };
  633. tranStruct z_pentagonTable[] =
  634. {
  635.    {PentagonIris, 111, "up"},
  636.    {PentagonUpsideDownLeftIris, 112, "down"}
  637. };
  639. tranStruct z_hexagonTable[] =
  640. {
  641.    {HexagonSideIris, 113, "horizontal"},
  642.    {HexagonIris, 114, "vertical"}
  643. };
  645. tranStruct z_ellipseTable[] =
  646. {
  647.    {CircleIris, 119, "circle"},
  648.    {OvalIris, 120, "horizontal"},
  649.    {OvalSideIris, 121, "vertical"}
  650. };
  652. tranStruct z_eyeTable[] =
  653. {
  654.    {CatEyeIris, 122, "horizontal"},
  655.    {CatEyeSideIris, 123, "vertical"}
  656. };
  658. tranStruct z_roundRectTable[] =
  659. {
  660.    {RoundRectHorizontal, 124, "horizontal"},
  661.    {RoundRectVeritical, 125, "vertical"}
  662. };
  664. tranStruct z_starTable[] =
  665. {
  666.    {FourPointStarIris, 127, "fourPoint"},
  667.    {FivePointStarIris, 128, "fivePoint"},
  668.    {SixPointStarIris, 129, "sixPoint"}
  669. };
  671. tranStruct z_miscShapeTable[] =
  672. {
  673.    {HeartIris, 130, "heart"},
  674.    {KeyHoleIris, 131, "keyhole"}
  675. };
  677. //-----------------------------------------------------------------------
  678. tranStruct z_clockTable[] =
  679. {
  680.    {RotatingTopRadial, 201, "clockwiseTwelve"},
  681.    {RotatingRightRadial, 202, "clockwiseThree"},
  682.    {RotatingBottomRadial , 203, "clockwiseSix"},
  683.    {RotatingLeftRadial, 204, "clockwiseNine"}
  684. };
  686. tranStruct z_pinWheelTable[] =
  687. {
  688.    {RotatingTopBottomRadial, 205, "twoBladeVertical"},
  689.    {RotatingLeftRightRadial, 206, "twoBladeHorizontal"},
  690.    {RotatingQuadrantRadial, 207, "fourBlade"}
  691. };
  693. tranStruct z_singleSweepTable[] =
  694. {
  695.    {Top180Radial, 221, "clockwiseTop"},
  696.    {Right180Radial, 222, "clockwiseRight"},
  697.    {Bottom180Radial, 223, "clockwiseBottom"},
  698.    {Left180Radial, 224, "clockwiseLeft"},
  699.    {RotatingTopLeftRadial, 241, "clockwiseTopLeft"},
  700.    {RotatingBottomLeftRadial, 242, "counterClockwiseBottomLeft"},
  701.    {RotatingBottomRightRadial, 243, "clockwiseBottomRight"},
  702.    {RotatingTopRightRadial, 244, "counterClockwiseTopRight"}
  703. };
  705. tranStruct z_fanTable[] =
  706. {
  707.     
  708.    {TopBottom180Radial, 211, "centerTop"},
  709.    {RightToLeft180Radial, 212, "centerRight"},
  710.    {OpenVTopRadial, 231, "top"},
  711.    {OpenVRightRadial, 232, "right"},
  712.    {OpenVBottomRadial, 233, "bottom"},
  713.    {OpenVLeftRadial, 234, "left"},
  714. };
  716. tranStruct z_doubleFanTable[] =
  717. {
  718.    {topBottom90Radial, 213, "fanOutVertical"},
  719.    {RightToLeft90Radial, 214, "fanOutHorizontal"},
  720.    {OpenVTopBottomRadial, 235, "fanInVertical"},
  721.    {OpenVLeftRightRadial, 236, "fanInHorizontal"}
  722. };
  724. tranStruct z_doubleSweepTable[] =
  725. {
  726.    {CounterRotatingTopBottomRadial, 225, "parallelVertical"},
  727.    {CounterRotatingLeftRightRadial, 226, "parallelDiagonal"},
  728.    {DoubleRotatingTopBottomRadial, 227, "oppositeVertical"},
  729.    {DoubleRotatingLeftRightRadial, 228, "oppositeHorizontal"},
  730.    {RotatingTopLeftBottomRightRadial, 245, "parallelDiagonalTopLeft"},
  731.    {RotatingBottomLeftTopRightRadial, 246, "parallelDiagonalBottomLeft"}
  732. };
  734. tranStruct z_saloonDoorTable[] =
  735. {
  736.    {RotatingTopLeftRightRadial, 251, "top"},
  737.    {RotatingLeftTopBottomRadial, 252, "left"},
  738.    {RotatingBottomLeftRightRadial, 253, "bottom"},
  739.    {RotatingRightTopBottomRadial, 254, "right"}
  740. };
  742. tranStruct z_windshieldTable[] =
  743. {
  744.    {RotatingDoubleCenterRightRadial, 261, "right"},
  745.    {RotatingDoubleCenterTopRadial, 262, "up"},
  746.    {RotatingDoubleCenterTopBottomRadial, 263, "vertical"},
  747.    {RotatingDoubleCenterLeftRightRadial, 264, "horizontal"}
  748. };
  750. //-----------------------------------------------------------------------
  751. tranStruct z_snakeTable[] =
  752. {
  753.    {HorizontalMatrix, 301, "topLeftHorizontal"},
  754.    {VerticalMatrix, 302, "topLeftVertical"},
  755.    {TopLeftDiagonalMatrix, 303, "topLeftDiagonal"},
  756.    {TopRightDiagonalMatrix, 304, "topRightDiagonal"},
  757.    {BottomRightDiagonalMatrix, 305, "bottomRightDiagonal"},
  758.    {BottomLeftDiagonalMatrix, 306, "bottomLeftDiagonal"}
  759. };
  761. tranStruct z_spiralTable[] =
  762. {
  763.    {ClockwiseTopLeftMatrix, 310, "topLeftClockwise"},
  764.    {ClockwiseTopRightMatrix, 311, "topRightClockwise"},
  765.    {ClockwiseBottomRightMatrix, 312, "bottomRightClockwise"},
  766.    {ClockwiseBottomLeftMatrix, 313, "bottomLeftClockwise"},
  767.    {CounterClockwiseTopLeftMatrix, 314, "topLeftCounterClockwise"},
  768.    {CounterClockwiseTopRightMatrix, 315, "topRightCounterClockwise"},
  769.    {CounterClockwiseBottomRightMatrix, 316, "bottomRightCounterClockwise"},
  770.    {CounterClockwiseBottomLeftMatrix, 317, "bottomLeftCounterClockwise"}
  771. };
  773. tranStruct z_parallelSnakesTable[] =
  774. {
  775.    {VerticalStartTopMatrix, 320, "verticalTopSame"},
  776.    {VerticalStartBottomMatrix, 321, "verticalBottomSame"},
  777.    {VerticalStartTopOppositeMatrix, 322, "verticalTopLeftOpposite"},
  778.    {VerticalStartBottomOppositeMatrix, 323, "verticalBottomLeftOpposite"},
  779.    {HorizontalStartLeftMatrix, 324, "horizontalLeftSame"},
  780.    {HorizontalStartRightMatrix, 325, "horizontalRightSame"},
  781.    {HorizontalStartLeftOppositeMatrix, 326, "horizontalTopLeftOpposite"},
  782.    {HorizontalStartRightOppositeMatrix, 327, "horizontalTopRightOpposite"},
  783.    {DoubleDiagonalBottom, 328, "diagonalBottomLeftOpposite"},
  784.    {DoubleDiagonalTop, 329, "diagonalTopLeftOpposite"}
  785. };
  787. tranStruct z_boxSnakesTable[] =
  788. {
  789.    {DoubleSpiralTopMatrix, 340, "twoBoxTop"},
  790.    {DoubleSpiralBottomMatrix, 341, "twoBoxBottom"},
  791.    {DoubleSpiralLeftMatrix, 342, "twoBoxLeft"},
  792.    {DoubleSpiralRightMatrix, 343, "twoBoxRight"},
  793.    {QuadSpiralVerticalMatrix, 344, "fourBoxVertical"},
  794.    {QuadSpiralHorizontalMatrix, 345, "fourBoxHorizontal"}
  795. };
  797. tranStruct z_waterfallTable[] =
  798. {
  799.    {VerticalWaterfallLeftMatrix, 350, "verticalLeft"},
  800.    {VerticalWaterfallRightMatrix, 351, "verticalRight"},
  801.    {HorizontalWaterfallLeftMatrix, 352, "horizontalLeft"},
  802.    {HorizontalWaterfallRightMatrix, 353, "horizontalRight"}
  803. };
  805. //-----------------------------------------------------------------------
  806. tranStruct z_slideTable[] =
  807. {
  808.    {SlideFromLeft, -1, "fromLeft"},
  809.    {SlideFromTop, -1, "fromTop"},
  810.    {SlideFromRight, -1, "fromRight"},
  811.    {SlideFromBottom, -1, "fromBottom"}
  812. };
  814. tranStruct z_fadeTable[] =
  815. {
  816.    {Crossfade,     -1, "crossfade"},
  817.    {FadeToColor,   -1, "fadeToColor"},
  818.    {FadeFromColor, -1, "fadeFromColor"}
  819. };
  821. tranStruct z_defaultTable[] =
  822. {
  823.    {DefaultTransition, -1, "DefaultTransition"}
  824. };
  827. //////////////////////////////////////
  828. #endif  //_TRANSITIONS_ON_
  832. tranType z_TransitionTable[] = 
  833. {
  834.    {z_defaultTable, "noTransition", sizeof(z_defaultTable) / sizeof(z_defaultTable[0])},
  835.         
  836. #ifdef _TRANSITIONS_ON_
  837.         
  838.    {z_barWipeTable, "barWipe", sizeof(z_barWipeTable) / sizeof(z_barWipeTable[0])},
  839.    {z_boxWipeTable, "boxWipe", sizeof(z_boxWipeTable) / sizeof(z_boxWipeTable[0])},
  840.    {z_fourBoxTable, "fourBoxWipe", sizeof(z_fourBoxTable) / sizeof(z_fourBoxTable[0])},
  841.    {z_barnDoorTable, "barnDoorWipe", sizeof(z_barnDoorTable) / sizeof(z_barnDoorTable[0])},
  842.    {z_diagonalTable, "diagonalWipe", sizeof(z_diagonalTable) / sizeof(z_diagonalTable[0])},
  843.    {z_bowTieTable, "bowTieWipe", sizeof(z_bowTieTable) / sizeof(z_bowTieTable[0])},
  844.    {z_miscDiagonalTable, "miscDiagonalWipe", sizeof(z_miscDiagonalTable) / sizeof(z_miscDiagonalTable[0])},
  845.    {z_veeTable, "veeWipe", sizeof(z_veeTable) / sizeof(z_veeTable[0])},
  846.    {z_barnVeeTable, "barnVeeWipe", sizeof(z_barnVeeTable) / sizeof(z_barnVeeTable[0])},
  847.    {z_zigZagTable, "zigZagWipe", sizeof(z_zigZagTable) / sizeof(z_zigZagTable[0])},
  848.    {z_barnZigZagTable, "barnZigZagWipe", sizeof(z_barnZigZagTable) / sizeof(z_barnZigZagTable[0])},
  849.    {z_irisTable, "irisWipe", sizeof(z_irisTable) / sizeof(z_irisTable[0])},
  850.    {z_triangleTable, "triangleWipe", sizeof(z_triangleTable) / sizeof(z_triangleTable[0])},
  851.    {z_arrowHeadTable, "arrowHeadWipe", sizeof(z_arrowHeadTable) / sizeof(z_arrowHeadTable[0])},
  852.    {z_pentagonTable, "pentagonWipe", sizeof(z_pentagonTable) / sizeof(z_pentagonTable[0])},
  853.    {z_hexagonTable, "hexagonWipe", sizeof(z_hexagonTable) / sizeof(z_hexagonTable[0])},
  854.    {z_ellipseTable, "ellipseWipe", sizeof(z_ellipseTable) / sizeof(z_ellipseTable[0])},
  855.    {z_eyeTable, "eyeWipe", sizeof(z_eyeTable) / sizeof(z_eyeTable[0])},
  856.    {z_roundRectTable, "roundRectWipe", sizeof(z_roundRectTable) / sizeof(z_roundRectTable[0])},
  857.    {z_starTable, "starWipe", sizeof(z_starTable) / sizeof(z_starTable[0])},
  858.    {z_miscShapeTable, "miscShapeWipe", sizeof(z_miscShapeTable) / sizeof(z_miscShapeTable[0])},
  859.    {z_clockTable, "clockWipe", sizeof(z_clockTable) / sizeof(z_clockTable[0])},
  860.    {z_pinWheelTable, "pinWheelWipe", sizeof(z_pinWheelTable) / sizeof(z_pinWheelTable[0])},
  861.    {z_singleSweepTable, "singleSweepWipe", sizeof(z_singleSweepTable) / sizeof(z_singleSweepTable[0])},
  862.    {z_fanTable, "fanWipe", sizeof(z_fanTable) / sizeof(z_fanTable[0])},
  863.    {z_doubleFanTable, "doubleFanWipe", sizeof(z_doubleFanTable) / sizeof(z_doubleFanTable[0])},
  864.    {z_doubleSweepTable, "doubleSweepWipe", sizeof(z_doubleSweepTable) / sizeof(z_doubleSweepTable[0])},
  865.    {z_saloonDoorTable, "saloonDoorWipe", sizeof(z_saloonDoorTable) / sizeof(z_saloonDoorTable[0])},
  866.    {z_windshieldTable, "windshieldWipe", sizeof(z_windshieldTable) / sizeof(z_windshieldTable[0])},
  867.    {z_snakeTable, "snakeWipe", sizeof(z_snakeTable) / sizeof(z_snakeTable[0])},
  868.    {z_spiralTable, "spiralWipe", sizeof(z_spiralTable) / sizeof(z_spiralTable[0])},
  869.    {z_parallelSnakesTable, "parallelSnakesWipe", sizeof(z_parallelSnakesTable) / sizeof(z_parallelSnakesTable[0])},
  870.    {z_boxSnakesTable, "boxSnakesWipe", sizeof(z_boxSnakesTable) / sizeof(z_boxSnakesTable[0])},
  871.    {z_waterfallTable, "waterfallWipe", sizeof(z_waterfallTable) / sizeof(z_waterfallTable[0])},
  872.    {z_slideTable, "slideWipe", sizeof(z_slideTable) / sizeof(z_slideTable[0])},
  873.    {z_fadeTable, "fade", sizeof(z_fadeTable) / sizeof(z_fadeTable[0])}
  874. #endif //_TRANSITIONS_ON_
  875. };
  877. INT32 z_nNumberTransitionTypes = sizeof(z_TransitionTable) / sizeof(z_TransitionTable[0]);
  879. #ifdef _TRANSITIONS_ON_
  882. void CalcMatrixLines(tranLines* lines, LineSegment* src, LineSegment* mod, BOOL* blocked)
  883. {
  884.    LineSegment ls;
  886.    *blocked = TRUE;
  888.    lines->Destroy();
  890.    if (src->start.y == src->finish.y) // horizontal lines
  891.    {
  892.       if (mod->start.x <= src->start.x && mod->finish.x >= src->start.x && mod->finish.x < src->finish.x)
  893.       {
  894.          ls.start.x = mod->finish.x;
  895.          ls.finish.x = src->finish.x;
  896.          ls.start.y = ls.finish.y = src->start.y;
  898.          *lines += ls;
  899.       }
  900.       else if (mod->start.x <= src->finish.x && mod->start.x > src->start.x && mod->finish.x >= src->finish.x)
  901.       {
  902.          ls.start.x = src->start.x;
  903.          ls.finish.x = mod->start.x;
  904.          ls.start.y = ls.finish.y = src->start.y;
  906.          *lines += ls;
  907.       }
  908.       else if (mod->start.x > src->start.x && mod->finish.x < src->finish.x)
  909.       {
  910.          ls.start.x = mod->finish.x;
  911.          ls.finish.x = src->finish.x;
  912.          ls.start.y = ls.finish.y = src->start.y;
  914.          *lines += ls;
  916.          ls.start.x = src->start.x;
  917.          ls.finish.x = mod->start.x;
  918.          ls.start.y = ls.finish.y = src->start.y;
  920.          *lines += ls;
  921.       }
  922.       else if (mod->start.x >= src->finish.x || mod->finish.x <= src->start.x)
  923.       {
  924.          *blocked = FALSE;
  925.       }
  926.    }
  927.    else                            // vertical lines
  928.    {
  929.       if (mod->start.y < src->start.y && mod->finish.y >= src->start.y && mod->finish.y < src->finish.y)
  930.       {
  931.          ls.start.y = mod->finish.y;
  932.          ls.finish.y = src->finish.y;
  933.          ls.start.x = ls.finish.x = src->start.x;
  935.          *lines += ls;
  936.       }
  937.       else if (mod->start.y < src->finish.y && mod->start.y > src->start.y && mod->finish.y >= src->finish.y)
  938.       {
  939.          ls.start.y = src->start.y;
  940.          ls.finish.y = mod->start.y;
  941.          ls.start.x = ls.finish.x = src->start.x;
  943.          *lines += ls;
  944.       }
  945.       else if (mod->start.y > src->start.y && mod->finish.y < src->finish.y)
  946.       {
  947.          ls.start.y = mod->finish.y;
  948.          ls.finish.y = src->finish.y;
  949.          ls.start.x = ls.finish.x = src->start.x;
  951.          *lines += ls;
  953.          ls.start.y = src->start.y;
  954.          ls.finish.y = mod->start.y;
  955.          ls.start.x = ls.finish.x = src->start.x;
  957.          *lines += ls;
  958.       }
  959.       else if (mod->start.y >= src->finish.y || mod->finish.y <= src->start.y)
  960.       {
  961.          *blocked = FALSE;
  962.       }
  963.    }
  964. }
  966. void CalcMatrixLines(tranLines* newLines, tranLines* src, LineSegment* mod, BOOL* blocked)
  967. {
  968.    tranLines tmpLines;
  970.    newLines->Destroy();
  972.    //XXXSMJ this is not foolproof but will be good enough for our current needs
  973.    for (int i = 0; i < src->m_nLines; ++i)
  974.    {
  975.       CalcMatrixLines(&tmpLines,&src->m_pLines[i],mod,blocked);
  977.       if (!tmpLines.m_nLines) // this happens when lines don't obstruct each other
  978.          *newLines += src->m_pLines[i];
  979.       else
  980.          *newLines += tmpLines;
  981.    }
  982. }
  984. void CalcMatrixBlockCoords(int left, int top, int right, int bottom, MatrixTransitionData *pData, int block, int* blockLeft, int* blockTop, int* blockRight, int* blockBottom)
  985. {
  986.    double blockX = double(right - left + 1) / double(pData->GetWidth());
  987.    double blockY = double(bottom - top + 1) / double(pData->GetHeight());
  988.     
  989.    *blockLeft = int(left + blockX * (block % pData->GetWidth()));
  990.    *blockTop = int(top + blockY * (block / pData->GetWidth()));
  991.    *blockRight = int(left + blockX * (block % pData->GetWidth() + 1));
  992.    *blockBottom = int(top + blockY * (block / pData->GetWidth() + 1));
  993.  
  994.    if (*blockLeft < left) *blockRight = left;
  995.    if (*blockTop < top) *blockBottom = top;
  996.    if (*blockRight > right) *blockRight = right;
  997.    if (*blockBottom > bottom) *blockBottom = bottom;
  998. }
  1000. HXREGION* MatrixTransition(int left, int top, int right, int bottom, int completeness, MatrixTransitionData *pData, tranLines* lines)
  1001. {
  1002.    HXREGION* retRGN = HXCreateRegion();
  1003.    HXREGION* rgn1;
  1004.     
  1005.    int bLeft,bTop,bRight,bBottom;
  1006.    double frameLength = 1000.0 / pData->GetTransitionLength();
  1007.    int frame = (int)((float)completeness/(frameLength+0.1));
  1008.    MatrixBlockTransitionList* blockTransList = pData->GetTransactionListPtr();
  1009.    for (int i = 0; i < frame; ++i)
  1010.    {
  1011.       MatrixBlockTransition* transList = blockTransList[i].GetListPtr();
  1012.       for (int j = 0; j < blockTransList[i].GetSize(); ++j)
  1013.       {
  1014.          // these will all be completed blocks
  1015.          CalcMatrixBlockCoords(left,top,right,bottom,pData,transList[j].block,&bLeft,&bTop,&bRight,&bBottom);
  1016.          rgn1 = HXCreateRectRegion(bLeft,bTop,bRight-bLeft,bBottom-bTop);
  1017.          HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_OR);
  1018.          HXDestroyRegion(rgn1);
  1019.       }
  1020.    }
  1021.     
  1022.    int tmpCompleteness = int((completeness - frameLength * frame) / frameLength * 1000);
  1023.    MatrixBlockTransition* transList = blockTransList[frame].GetListPtr();
  1024.    for (int j = 0; j < blockTransList[frame].GetSize(); ++j)
  1025.    {
  1026.       CalcMatrixBlockCoords(left,top,right,bottom,pData,transList[j].block,&bLeft,&bTop,&bRight,&bBottom);
  1027.         
  1028.       if (transList[j].invert)
  1029.       {
  1030.          rgn1 = transList[j].transition(bLeft,bTop,bRight,bBottom,1000 - tmpCompleteness,lines);
  1031.          rgn1 = InvertRGN(rgn1,bLeft,bTop,bRight,bBottom);
  1032.       }
  1033.       else
  1034.       {
  1035.          rgn1 = transList[j].transition(bLeft,bTop,bRight,bBottom,tmpCompleteness,lines);
  1036.       }
  1037.             
  1038.       HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_OR);
  1039.       HXDestroyRegion(rgn1);
  1040.    }
  1042.    if (lines)
  1043.    {
  1044.       BOOL blocked,tmpBlock;
  1045.       LineSegment lineSeg1, lineSeg2;
  1046.       tranLines tmpLines;
  1048.       for (int x = 0; x < retRGN->numRects; ++x)
  1049.       {
  1050.          // top
  1051.          if (retRGN->rects[x].y1 > top)
  1052.          {
  1053.             tranLines   tl;
  1054.             blocked = tmpBlock = FALSE;
  1056.             lineSeg1.start.x = retRGN->rects[x].x1;
  1057.             lineSeg1.start.y = retRGN->rects[x].y1;
  1058.             lineSeg1.finish.x = retRGN->rects[x].x2;
  1059.             lineSeg1.finish.y = retRGN->rects[x].y1;
  1061.             for (int y = 0; y < x; ++y)
  1062.             {
  1063.                if (retRGN->rects[y].y2 == retRGN->rects[x].y1)
  1064.                {
  1065.                   lineSeg2.start.x = retRGN->rects[y].x1;
  1066.                   lineSeg2.start.y = retRGN->rects[y].y2;
  1067.                   lineSeg2.finish.x = retRGN->rects[y].x2;
  1068.                   lineSeg2.finish.y = retRGN->rects[y].y2;
  1070.                   if (tl.m_nLines)
  1071.                   {
  1072.                      CalcMatrixLines(&tmpLines, &tl, &lineSeg2, &tmpBlock);
  1073.                      tl = tmpLines;
  1074.                   }
  1075.                   else
  1076.                   {
  1077.                      CalcMatrixLines(&tmpLines, &lineSeg1, &lineSeg2, &tmpBlock);
  1078.                      tl += tmpLines;
  1079.                   }
  1081.                   // once we're blocked we don't want to be changed
  1082.                   if (tmpBlock)
  1083.                      blocked = TRUE;
  1084.                }
  1085.             }
  1086.             if (!blocked && !tl.m_nLines)
  1087.             {
  1088.                tl += lineSeg1;
  1089.             }
  1090.             *lines += tl;
  1091.          }
  1092.          // right
  1093.          if (retRGN->rects[x].x2 < right)
  1094.          {
  1095.             tranLines   tl;
  1096.             blocked = tmpBlock = FALSE;
  1098.             lineSeg1.start.x = retRGN->rects[x].x2;
  1099.             lineSeg1.start.y = retRGN->rects[x].y1;
  1100.             lineSeg1.finish.x = retRGN->rects[x].x2;
  1101.             lineSeg1.finish.y = retRGN->rects[x].y2;
  1103.             for (int y = 0; y < retRGN->numRects; ++y)
  1104.             {
  1105.                if (retRGN->rects[y].x1 == retRGN->rects[x].x2)
  1106.                {
  1107.                   lineSeg2.start.x = retRGN->rects[y].x1;
  1108.                   lineSeg2.start.y = retRGN->rects[y].y1;
  1109.                   lineSeg2.finish.x = retRGN->rects[y].x1;
  1110.                   lineSeg2.finish.y = retRGN->rects[y].y2;
  1112.                   if (tl.m_nLines)
  1113.                   {
  1114.                      CalcMatrixLines(&tmpLines, &tl, &lineSeg2, &tmpBlock);
  1115.                      tl = tmpLines;
  1116.                   }
  1117.                   else
  1118.                   {
  1119.                      CalcMatrixLines(&tmpLines, &lineSeg1, &lineSeg2, &tmpBlock);
  1120.                      tl += tmpLines;
  1121.                   }
  1123.                   // once we're blocked we don't want to be changed
  1124.                   if (tmpBlock)
  1125.                      blocked = TRUE;
  1126.                }
  1127.             }
  1128.             if (!blocked && !tl.m_nLines)
  1129.             {
  1130.                tl += lineSeg1;
  1131.             }
  1132.             *lines += tl;
  1133.          }
  1134.          // bottom
  1135.          if (retRGN->rects[x].y2 < bottom)
  1136.          {
  1137.             tranLines   tl;
  1138.             blocked = tmpBlock = FALSE;
  1140.             lineSeg1.start.x = retRGN->rects[x].x1;
  1141.             lineSeg1.start.y = retRGN->rects[x].y2;
  1142.             lineSeg1.finish.x = retRGN->rects[x].x2;
  1143.             lineSeg1.finish.y = retRGN->rects[x].y2;
  1145.             for (int y = 0; y < retRGN->numRects; ++y)
  1146.             {
  1147.                if (retRGN->rects[y].y1 == retRGN->rects[x].y2)
  1148.                {
  1149.                   lineSeg2.start.x = retRGN->rects[y].x1;
  1150.                   lineSeg2.start.y = retRGN->rects[y].y1;
  1151.                   lineSeg2.finish.x = retRGN->rects[y].x2;
  1152.                   lineSeg2.finish.y = retRGN->rects[y].y1;
  1154.                   if (tl.m_nLines)
  1155.                   {
  1156.                      CalcMatrixLines(&tmpLines, &tl, &lineSeg2, &tmpBlock);
  1157.                      tl = tmpLines;
  1158.                   }
  1159.                   else
  1160.                   {
  1161.                      CalcMatrixLines(&tmpLines, &lineSeg1, &lineSeg2, &tmpBlock);
  1162.                      tl += tmpLines;
  1163.                   }
  1165.                   // once we're blocked we don't want to be changed
  1166.                   if (tmpBlock)
  1167.                      blocked = TRUE;
  1168.                }
  1169.             }
  1170.             if (!blocked && !tl.m_nLines)
  1171.             {
  1172.                tl += lineSeg1;
  1173.             }
  1174.             *lines += tl;
  1175.          }
  1176.          // left
  1177.          if (retRGN->rects[x].x1 > left)
  1178.          {
  1179.             tranLines   tl;
  1180.             blocked = tmpBlock = FALSE;
  1182.             lineSeg1.start.x = retRGN->rects[x].x1;
  1183.             lineSeg1.start.y = retRGN->rects[x].y1;
  1184.             lineSeg1.finish.x = retRGN->rects[x].x1;
  1185.             lineSeg1.finish.y = retRGN->rects[x].y2;
  1187.             for (int y = 0; y < retRGN->numRects; ++y)
  1188.             {
  1189.                if (retRGN->rects[y].x2 == retRGN->rects[x].x1)
  1190.                {
  1191.                   lineSeg2.start.x = retRGN->rects[y].x2;
  1192.                   lineSeg2.start.y = retRGN->rects[y].y1;
  1193.                   lineSeg2.finish.x = retRGN->rects[y].x2;
  1194.                   lineSeg2.finish.y = retRGN->rects[y].y2;
  1196.                   if (tl.m_nLines)
  1197.                   {
  1198.                      CalcMatrixLines(&tmpLines, &tl, &lineSeg2, &tmpBlock);
  1199.                      tl = tmpLines;
  1200.                   }
  1201.                   else
  1202.                   {
  1203.                      CalcMatrixLines(&tmpLines, &lineSeg1, &lineSeg2, &tmpBlock);
  1204.                      tl += tmpLines;
  1205.                   }
  1207.                   // once we're blocked we don't want to be changed
  1208.                   if (tmpBlock)
  1209.                      blocked = TRUE;
  1210.                }
  1211.             }
  1212.             if (!blocked && !tl.m_nLines)
  1213.             {
  1214.                tl += lineSeg1;
  1215.             }
  1216.             *lines += tl;
  1217.          }
  1218.       }
  1219.    }
  1220.     
  1221.    return retRGN;
  1222. }
  1224. HXREGION* HorizontalMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1225. {
  1226.    static CHXBuffer* z_HorizontalMatrixDataBuffer = NULL;
  1227.         
  1228.    if (!z_HorizontalMatrixDataBuffer || completeness == MATRIX_TRANSITION_INIT)
  1229.    {
  1230.       MatrixTransitionData* HorizontalMatrixTransition = new MatrixTransitionData(8,8,64);
  1231.       MatrixBlockTransitionList* blockTransList = HorizontalMatrixTransition->GetTransactionListPtr();
  1232.                 
  1233.       for (int i = 0; i < 64; ++i)
  1234.       {
  1235.          blockTransList[i].CreateList(1);
  1236.          MatrixBlockTransition* list = blockTransList[i].GetListPtr();
  1238.          list->invert = ((i / 8) & 1);
  1239.          if (list->invert)      // determine if row we're in is odd; the top row is row 0
  1240.             list->block = ((i / 8) + 1) * 8 - (i % 8) - 1;  // if we're odd we're moving right to left
  1241.          else
  1242.             list->block = i;  // otherwise left to right
  1244.          list->transition = EdgeWipe;
  1245.       }
  1246.                 
  1247.       z_HorizontalMatrixDataBuffer = new CHXBuffer();
  1248.       z_HorizontalMatrixDataBuffer->AddRef();
  1249.       z_HorizontalMatrixDataBuffer->Set((UCHAR*)&HorizontalMatrixTransition, sizeof(UCHAR*));
  1250.    }
  1251.    else if (completeness == MATRIX_TRANSITION_DELETE)
  1252.    {
  1253.       delete *((MatrixTransitionData**)z_HorizontalMatrixDataBuffer->GetBuffer());
  1254.       if (!z_HorizontalMatrixDataBuffer->Release())
  1255.       {
  1256.          z_HorizontalMatrixDataBuffer = NULL;
  1257.          return HXCreateRegion();
  1258.       }
  1259.    }
  1260.         
  1261.    return MatrixTransition(left,top,right,bottom,completeness,
  1262.                            *((MatrixTransitionData**)z_HorizontalMatrixDataBuffer->GetBuffer()),lines);
  1263. }
  1265. HXREGION* VerticalMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1266. {
  1267.    static CHXBuffer* z_VerticalMatrixDataBuffer = NULL;
  1268.         
  1269.    if (!z_VerticalMatrixDataBuffer || completeness == MATRIX_TRANSITION_INIT)
  1270.    {
  1271.       MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(8,8,64);
  1272.       MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
  1273.                 
  1274.       for (int i = 0; i < 64; ++i)
  1275.       {
  1276.          blockTransList[i].CreateList(1);
  1277.          MatrixBlockTransition* list = blockTransList[i].GetListPtr();
  1278.                         
  1279.          list->invert = (i / 8) & 1;
  1280.                         
  1281.          if (list->invert)      // determine if column we're in is odd; the left col is col 0
  1282.             list->block = ((7 - i % 8) % 8) * 8 + i / 8;
  1283.          else
  1284.             list->block = (i % 8) * 8 + i / 8;
  1285.                         
  1286.          list->transition = SlideVerticalEdgeWipe;
  1287.       }
  1288.                 
  1289.       z_VerticalMatrixDataBuffer = new CHXBuffer();
  1290.       z_VerticalMatrixDataBuffer->AddRef();
  1291.       z_VerticalMatrixDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
  1292.    }
  1293.    else if (completeness == MATRIX_TRANSITION_DELETE)
  1294.    {
  1295.       delete *((MatrixTransitionData**)z_VerticalMatrixDataBuffer->GetBuffer());
  1296.       if (!z_VerticalMatrixDataBuffer->Release())
  1297.       {
  1298.          z_VerticalMatrixDataBuffer = NULL;
  1299.          return HXCreateRegion();
  1300.       }
  1301.    }
  1302.         
  1303.    return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_VerticalMatrixDataBuffer->GetBuffer()),lines);
  1304. }
  1306. void GetTopLeftDiagonalCoords(int left, int top, int right, int bottom, int completeness, HXxPoint p[7], tranLines* lines)
  1307. {
  1308.    int width = right - left;
  1309.    int height = bottom - top;
  1310.    double x = double(width) / 8.0;
  1311.    double y = double(height) / 8.0;
  1312.         
  1313.    int area = 0, lastArea = 0;
  1314.    int i;
  1315.         
  1316.    memset(p,0,sizeof(HXxPoint) * 7);
  1317.         
  1318.    int areaComplete = int(double(width * height * completeness) / 1000.0);
  1319.         
  1320.    for (i = 0; i < 16; ++i)
  1321.    {
  1322.       if (i < 8)
  1323.       {
  1324.          area = int((x * i + x) * (y * i + y) / 2);
  1325.       }
  1326.       else
  1327.       {
  1328.          area = width * height - int((x * (14 - i) + x) * (y * (14 - i) + y) / 2);
  1329.       }
  1330.                 
  1331.       if (areaComplete < area)
  1332.          break;
  1333.                 
  1334.       lastArea = area;
  1335.    }
  1336.    if (i == 16) --i;
  1337.         
  1338.    int tmpCompleteness = 1000 - int(double(area - areaComplete) / double(area - lastArea) * 1000);
  1339.         
  1340.    HXxPoint topPt, bottomPt;
  1341.         
  1342.    if (i < 8)
  1343.    {
  1344.       p[0].x = left;
  1345.       p[0].y = int(top + i * y);
  1346.       p[1].x = int(left + i * x);
  1347.       p[1].y = top;
  1348.       p[2].x = int(left + (i + 1) * x);
  1349.       p[2].y = top;
  1350.       p[3].x = left;
  1351.       p[3].y = int(top + (i + 1) * y);
  1352.    }
  1353.    else
  1354.    {
  1355.       int tmp = i - 8;
  1356.                 
  1357.       p[0].x = int(left + tmp * x);
  1358.       p[0].y = bottom;
  1359.       p[1].x = right;
  1360.       p[1].y = int(top + tmp * y);
  1361.       p[2].x = right;
  1362.       p[2].y = int(top + (tmp + 1) * y);
  1363.       p[3].x = int(left + (tmp + 1) * x);
  1364.       p[3].y = bottom;
  1365.    }
  1366.         
  1367.    if (i & 1)
  1368.       tmpCompleteness = 1000 - tmpCompleteness;
  1369.         
  1370.    GetDiagonalStripCoords(p[0],p[1],p[2],p[3],&topPt,&bottomPt,tmpCompleteness);
  1371.         
  1372.    p[0].x = left;
  1373.    p[0].y = top;
  1374.    p[1].y = top;
  1375.         
  1376.    if (i < 8)
  1377.    {
  1378.       if (i & 1)
  1379.       {
  1380.          p[1].x = int(left + x * i + x);
  1381.          p[2].x = bottomPt.x;
  1382.          p[2].y = bottomPt.y;
  1383.          p[3].x = topPt.x;
  1384.          p[3].y = topPt.y;
  1385.          p[4].y = int(top + y * i);
  1386.       }
  1387.       else
  1388.       {
  1389.          p[1].x = int(left + x * i);
  1390.          p[2].x = topPt.x;
  1391.          p[2].y = topPt.y;
  1392.          p[3].x = bottomPt.x;
  1393.          p[3].y = bottomPt.y;
  1394.          p[4].y = int(top + y * i + y);
  1395.       }
  1396.       p[4].x = left;
  1397.    }
  1398.    else
  1399.    {
  1400.       p[1].x = right;
  1401.       p[2].x = right;
  1402.       p[5].y = bottom;
  1403.       p[6].x = left;
  1404.       p[6].y = bottom;
  1405.                 
  1406.       if (i & 1)
  1407.       {
  1408.          p[2].y = int(top + y * (i - 8) + y);
  1409.          p[3].x = bottomPt.x;
  1410.          p[3].y = bottomPt.y;
  1411.          p[4].x = topPt.x;
  1412.          p[4].y = topPt.y;
  1413.          p[5].x = int(left + x * (i - 8));
  1414.       }
  1415.       else
  1416.       {
  1417.          p[2].y = int(top + y * (i - 8));
  1418.          p[3].x = topPt.x;
  1419.          p[3].y = topPt.y;
  1420.          p[4].x = bottomPt.x;
  1421.          p[4].y = bottomPt.y;
  1422.          p[5].x = int(left + x * (i - 8) + x);
  1423.       }
  1424.    }
  1425.    if (lines)
  1426.    {
  1427.       lines->m_nLines = 3;
  1428.       lines->m_pLines = new LineSegment[3];
  1430.       if(!lines->m_pLines)
  1431.       {
  1432.          lines->m_nLines = 0;
  1433.       }
  1434.       else
  1435.       {
  1436.          int pt = (i < 8) ? 1 : 2;
  1437.          lines->m_pLines[0].start.x = p[pt].x;
  1438.          lines->m_pLines[0].start.y= p[pt].y;
  1439.          lines->m_pLines[0].finish.x = p[pt+1].x;
  1440.          lines->m_pLines[0].finish.y= p[pt+1].y;
  1441.          lines->m_pLines[1].start.x = p[pt+1].x;
  1442.          lines->m_pLines[1].start.y= p[pt+1].y;
  1443.          lines->m_pLines[1].finish.x = p[pt+2].x;
  1444.          lines->m_pLines[1].finish.y= p[pt+2].y;
  1445.          lines->m_pLines[2].start.x = p[pt+2].x;
  1446.          lines->m_pLines[2].start.y= p[pt+2].y;
  1447.          lines->m_pLines[2].finish.x = p[pt+3].x;
  1448.          lines->m_pLines[2].finish.y= p[pt+3].y;
  1449.       }
  1450.    }
  1451. }
  1453. HXREGION* TopLeftDiagonalMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1454. {
  1455.    HXxPoint p[7];
  1456.         
  1457.    GetTopLeftDiagonalCoords(left,top,right,bottom,completeness,p,lines);
  1458.    return HXPolygonRegion(p, 7, WindingRule);
  1459. }
  1461. HXREGION* TopRightDiagonalMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1462. {
  1463.    HXREGION* retRGN = MirrorVertical(TopLeftDiagonalMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2);
  1464.    if (lines)
  1465.       MirrorVertical(lines,(right - left) / 2);
  1467.    return retRGN;
  1468. }
  1470. HXREGION* BottomRightDiagonalMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1471. {
  1472.    HXREGION* retRGN = MirrorHorizontal(MirrorVertical(TopLeftDiagonalMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2),top + (bottom - top + 1) / 2);
  1473.    if (lines)
  1474.    {
  1475.       MirrorVertical(lines,(right - left) / 2);
  1476.       MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
  1477.    }
  1479.    return retRGN;
  1480. }
  1482. HXREGION* BottomLeftDiagonalMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1483. {
  1484.    HXREGION* retRGN = MirrorHorizontal(TopLeftDiagonalMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
  1485.    if (lines)
  1486.       MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
  1488.    return retRGN;
  1489. }
  1491. HXREGION* ClockwiseTopLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1492. {
  1493.    static CHXBuffer* z_cwTopLeftDataBuffer = NULL;
  1494.         
  1495.    if (!z_cwTopLeftDataBuffer || completeness == MATRIX_TRANSITION_INIT)
  1496.    {
  1497.       MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(8,8,64);
  1498.       MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
  1499.                 
  1500.       int blockIdx = 0;
  1501.                 
  1502.       for (int i = 8; i > 0; i -= 2)
  1503.       {
  1504.          int j;
  1505.          int horzOffset = ((8 - i) / 2) * 9;
  1506.          int vertOffset = (9 - i) / 2;
  1507.          int vertOffsetRt = i / 2 + 2;
  1508.                         
  1509.          for (j = 0; j < i; ++j, ++blockIdx)
  1510.          {
  1511.             blockTransList[blockIdx].CreateList(1);
  1512.             MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
  1513.                                 
  1514.             list->block = j + horzOffset;
  1515.             list->invert = 0;
  1516.             list->transition = EdgeWipe;
  1517.          }
  1518.          for (j = 0; j < i - 2; ++j, ++blockIdx)
  1519.          {
  1520.             blockTransList[blockIdx].CreateList(1);
  1521.             MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
  1522.                                 
  1523.             list->block = (j + 2 + vertOffset) * 8 - (vertOffset + 1);
  1524.             list->invert = 0;
  1525.             list->transition = SlideVerticalEdgeWipe;
  1526.          }
  1527.          for (j = 0; j < i; ++j, ++blockIdx)
  1528.          {
  1529.             blockTransList[blockIdx].CreateList(1);
  1530.             MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
  1531.                                 
  1532.             list->block = 63 - j - horzOffset;
  1533.             list->invert = 1;
  1534.             list->transition = EdgeWipe;
  1535.          }
  1536.          for (j = 0; j < i - 2; ++j, ++blockIdx)
  1537.          {
  1538.             blockTransList[blockIdx].CreateList(1);
  1539.             MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
  1540.                                 
  1541.             list->block = (vertOffsetRt - j) * 8 + (vertOffset);
  1542.             list->invert = 1;
  1543.             list->transition = SlideVerticalEdgeWipe;
  1544.          }
  1545.       }
  1546.                 
  1547.       z_cwTopLeftDataBuffer = new CHXBuffer();
  1548.       z_cwTopLeftDataBuffer->AddRef();
  1549.       z_cwTopLeftDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
  1550.    }
  1551.    else if (completeness == MATRIX_TRANSITION_DELETE)
  1552.    {
  1553.       delete *((MatrixTransitionData**)z_cwTopLeftDataBuffer->GetBuffer());
  1554.       if (!z_cwTopLeftDataBuffer->Release())
  1555.       {
  1556.          z_cwTopLeftDataBuffer = NULL;
  1557.          return HXCreateRegion();
  1558.       }
  1559.    }
  1560.         
  1561.    return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_cwTopLeftDataBuffer->GetBuffer()),lines);
  1562. }
  1564. HXREGION* ClockwiseTopRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1565. {
  1566.    HXREGION* retRGN = MirrorVertical(
  1567.       CounterClockwiseTopLeftMatrix(left,top,right,bottom,completeness,lines),
  1568.       left + (right - left+1) / 2
  1569.       );
  1570.    if (lines)
  1571.       MirrorVertical(lines,(left + right) / 2);
  1573.    return retRGN;
  1574. }
  1576. HXREGION* ClockwiseBottomRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1577. {
  1578.    HXREGION* retRGN = MirrorHorizontal(MirrorVertical(ClockwiseTopLeftMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2),(top + bottom) / 2);
  1579.    if (lines)
  1580.    {
  1581.       MirrorVertical(lines,left + (right - left + 1) / 2);
  1582.       MirrorHorizontal(lines,(top + bottom) / 2);
  1583.    }
  1584.    return retRGN;
  1585. }
  1587. HXREGION* ClockwiseBottomLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1588. {
  1589.    HXREGION* retRGN = MirrorHorizontal(CounterClockwiseTopLeftMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
  1590.    if (lines)
  1591.       MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
  1592.    return retRGN;
  1593. }
  1595. HXREGION* CounterClockwiseTopLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1596. {
  1597.    static CHXBuffer* z_ccwTopLeftDataBuffer = NULL;
  1598.         
  1599.    if (!z_ccwTopLeftDataBuffer || completeness == MATRIX_TRANSITION_INIT)
  1600.    {
  1601.       MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(8,8,64);
  1602.       MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
  1603.                 
  1604.       int blockIdx = 0;
  1605.                 
  1606.       for (int i = 8; i > 0; i -= 2)
  1607.       {
  1608.          int j;
  1609.          int horzOffset = (int)(5.0 - i / 2);
  1610.          int vertOffset = (int)((9.0 - i) / 2);
  1611.          int vertOffsetRt = (int)(i / 2+ 4);
  1612.                         
  1613.          for (j = 0; j < i; ++j, ++blockIdx)
  1614.          {
  1615.             blockTransList[blockIdx].CreateList(1);
  1616.             MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
  1617.                                 
  1618.             list->block = (j + vertOffset) * 8 + vertOffset;
  1619.             list->invert = 0;
  1620.             list->transition = SlideVerticalEdgeWipe;
  1621.          }
  1622.          for (j = 0; j < i - 2; ++j, ++blockIdx)
  1623.          {
  1624.             blockTransList[blockIdx].CreateList(1);
  1625.             MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
  1626.                                 
  1627.             list->block = j + (i / 2 + 3) * 8 + (10 - i) / 2;
  1628.             list->invert = 0;
  1629.             list->transition = EdgeWipe;
  1630.          }
  1631.          for (j = 0; j < i; ++j, ++blockIdx)
  1632.          {
  1633.             blockTransList[blockIdx].CreateList(1);
  1634.             MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
  1635.                                 
  1636.             list->block = (vertOffsetRt - j) * 8 - vertOffset - 1;
  1637.             list->invert = 1;
  1638.             list->transition = SlideVerticalEdgeWipe;
  1639.          }
  1640.          for (j = 0; j < i - 2; ++j, ++blockIdx)
  1641.          {
  1642.             blockTransList[blockIdx].CreateList(1);
  1643.             MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
  1644.                                 
  1645.             list->block = 7 * horzOffset - 1 - j;
  1646.             list->invert = 1;
  1647.             list->transition = EdgeWipe;
  1648.          }
  1649.       }
  1650.                 
  1651.       z_ccwTopLeftDataBuffer = new CHXBuffer();
  1652.       z_ccwTopLeftDataBuffer->AddRef();
  1653.       z_ccwTopLeftDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
  1654.    }
  1655.    else if (completeness == MATRIX_TRANSITION_DELETE)
  1656.    {
  1657.       delete *((MatrixTransitionData**)z_ccwTopLeftDataBuffer->GetBuffer());
  1658.       if (!z_ccwTopLeftDataBuffer->Release())
  1659.       {
  1660.          z_ccwTopLeftDataBuffer = NULL;
  1661.          return HXCreateRegion();
  1662.       }
  1663.    }
  1664.         
  1665.    return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_ccwTopLeftDataBuffer->GetBuffer()),lines);
  1666. }
  1668. HXREGION* CounterClockwiseTopRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1669. {
  1670.    HXREGION* retRGN = MirrorVertical(ClockwiseTopLeftMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2);
  1671.    if (lines)
  1672.       MirrorVertical(lines,left + (right - left + 1) / 2);
  1673.    return retRGN;
  1674. }
  1676. HXREGION* CounterClockwiseBottomRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1677. {
  1678.    HXREGION* retRGN = MirrorHorizontal(MirrorVertical(CounterClockwiseTopLeftMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2),top + (bottom - top + 1) / 2);
  1679.    if (lines)
  1680.    {
  1681.       MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
  1682.       MirrorVertical(lines,left + (right - left + 1) / 2);
  1683.    }
  1684.    return retRGN;
  1685. }
  1687. HXREGION* CounterClockwiseBottomLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1688. {
  1689.    HXREGION* retRGN = MirrorHorizontal(ClockwiseTopLeftMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
  1690.    if (lines)
  1691.       MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
  1692.    return retRGN;
  1693. }
  1695. HXREGION* VerticalStartTopMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1696. {
  1697.    static CHXBuffer* z_verticalTopDataBuffer = NULL;
  1698.         
  1699.    if (!z_verticalTopDataBuffer || completeness == MATRIX_TRANSITION_INIT)
  1700.    {
  1701.       MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(8,1,4);
  1702.       MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
  1703.                 
  1704.       for (int i = 0; i < 4; ++i)
  1705.       {
  1706.          blockTransList[i].CreateList(2);
  1707.          MatrixBlockTransition* list = blockTransList[i].GetListPtr();
  1708.                         
  1709.          list[0].invert = list[1].invert = i & 1;
  1710.          list[0].transition = list[1].transition = SlideVerticalEdgeWipe;
  1711.          list[0].block = i;
  1712.          list[1].block = 7 - i;
  1713.       }
  1714.                 
  1715.       z_verticalTopDataBuffer = new CHXBuffer();
  1716.       z_verticalTopDataBuffer->AddRef();
  1717.       z_verticalTopDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
  1718.    }
  1719.    else if (completeness == MATRIX_TRANSITION_DELETE)
  1720.    {
  1721.       delete *((MatrixTransitionData**)z_verticalTopDataBuffer->GetBuffer());
  1722.       if (!z_verticalTopDataBuffer->Release())
  1723.       {
  1724.          z_verticalTopDataBuffer = NULL;
  1725.          return HXCreateRegion();
  1726.       }
  1727.    }
  1728.         
  1729.    return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_verticalTopDataBuffer->GetBuffer()),lines);
  1730. }
  1732. HXREGION* VerticalStartBottomMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1733. {
  1734.    HXREGION* retRGN = MirrorHorizontal(VerticalStartTopMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
  1735.    if (lines)
  1736.       MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
  1737.    return retRGN;
  1738. }
  1740. HXREGION* VerticalStartTopOppositeMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1741. {
  1742.    static CHXBuffer* z_verticalTopOppDataBuffer = NULL;
  1743.         
  1744.    if (!z_verticalTopOppDataBuffer || completeness == MATRIX_TRANSITION_INIT)
  1745.    {
  1746.       MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(8,1,4);
  1747.       MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
  1748.                 
  1749.       for (int i = 0; i < 4; ++i)
  1750.       {
  1751.          blockTransList[i].CreateList(2);
  1752.          MatrixBlockTransition* list = blockTransList[i].GetListPtr();
  1753.                         
  1754.          list[0].invert = i & 1;
  1755.          list[1].invert = !list[0].invert;
  1756.          list[0].transition = list[1].transition = SlideVerticalEdgeWipe;
  1757.          list[0].block = i;
  1758.          list[1].block = 7 - i;
  1759.       }
  1760.                 
  1761.       z_verticalTopOppDataBuffer = new CHXBuffer();
  1762.       z_verticalTopOppDataBuffer->AddRef();
  1763.       z_verticalTopOppDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
  1764.    }
  1765.    else if (completeness == MATRIX_TRANSITION_DELETE)
  1766.    {
  1767.       delete *((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer());
  1768.       if (!z_verticalTopOppDataBuffer->Release())
  1769.       {
  1770.          z_verticalTopOppDataBuffer = NULL;
  1771.          return HXCreateRegion();
  1772.       }
  1773.    }
  1774.         
  1775.    return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer()),lines);
  1776. }
  1778. HXREGION* VerticalStartBottomOppositeMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1779. {
  1780.    HXREGION* retRGN = MirrorHorizontal(VerticalStartTopOppositeMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
  1781.    if (lines)
  1782.       MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
  1783.    return retRGN;
  1784. }
  1786. HXREGION* HorizontalStartLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1787. {
  1788.    static CHXBuffer* z_verticalTopOppDataBuffer = NULL;
  1789.         
  1790.    if (!z_verticalTopOppDataBuffer || completeness == MATRIX_TRANSITION_INIT)
  1791.    {
  1792.       MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(1,8,4);
  1793.       MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
  1794.                 
  1795.       for (int i = 0; i < 4; ++i)
  1796.       {
  1797.          blockTransList[i].CreateList(2);
  1798.          MatrixBlockTransition* list = blockTransList[i].GetListPtr();
  1799.                         
  1800.          list[0].invert = list[1].invert = i & 1;
  1801.          list[0].transition = list[1].transition = EdgeWipe;
  1802.          list[0].block = i;
  1803.          list[1].block = 7 - i;
  1804.       }
  1805.                 
  1806.       z_verticalTopOppDataBuffer = new CHXBuffer();
  1807.       z_verticalTopOppDataBuffer->AddRef();
  1808.       z_verticalTopOppDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
  1809.    }
  1810.    else if (completeness == MATRIX_TRANSITION_DELETE)
  1811.    {
  1812.       delete *((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer());
  1813.       if (!z_verticalTopOppDataBuffer->Release())
  1814.       {
  1815.          z_verticalTopOppDataBuffer = NULL;
  1816.          return HXCreateRegion();
  1817.       }
  1818.    }
  1819.         
  1820.    return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer()),lines);
  1821. }
  1823. HXREGION* HorizontalStartRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1824. {
  1825.    HXREGION* retRGN = MirrorVertical(HorizontalStartLeftMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2);
  1826.    if (lines)
  1827.       MirrorVertical(lines,left + (right - left + 1) / 2);
  1828.    return retRGN;
  1829. }
  1831. HXREGION* HorizontalStartLeftOppositeMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1832. {
  1833.    static CHXBuffer* z_verticalTopOppDataBuffer = NULL;
  1834.         
  1835.    if (!z_verticalTopOppDataBuffer || completeness == MATRIX_TRANSITION_INIT)
  1836.    {
  1837.       MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(1,8,4);
  1838.       MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
  1839.                 
  1840.       for (int i = 0; i < 4; ++i)
  1841.       {
  1842.          blockTransList[i].CreateList(2);
  1843.          MatrixBlockTransition* list = blockTransList[i].GetListPtr();
  1844.                         
  1845.          list[0].invert = i & 1;
  1846.          list[1].invert = !list[0].invert;
  1847.          list[0].transition = list[1].transition = EdgeWipe;
  1848.          list[0].block = i;
  1849.          list[1].block = 7 - i;
  1850.       }
  1851.                 
  1852.       z_verticalTopOppDataBuffer = new CHXBuffer();
  1853.       z_verticalTopOppDataBuffer->AddRef();
  1854.       z_verticalTopOppDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
  1855.    }
  1856.    else if (completeness == MATRIX_TRANSITION_DELETE)
  1857.    {
  1858.       delete *((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer());
  1859.       if (!z_verticalTopOppDataBuffer->Release())
  1860.       {
  1861.          z_verticalTopOppDataBuffer = NULL;
  1862.          return HXCreateRegion();
  1863.       }
  1864.    }
  1865.         
  1866.    return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer()),lines);
  1867. }
  1869. HXREGION* HorizontalStartRightOppositeMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1870. {
  1871.    HXREGION* retRGN = MirrorVertical(HorizontalStartLeftOppositeMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2);
  1872.    if (lines)
  1873.       MirrorVertical(lines,left + (right - left + 1) / 2);
  1874.    return retRGN;
  1875. }
  1877. HXREGION* DoubleSpiralTopMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1878. {
  1879.    tranLines* tmpLines = NULL;
  1881.    if (lines)
  1882.       tmpLines = new tranLines;
  1883.    int ii = (int)(((float)(left + right)) / 2.0 + .5)-1;
  1884.    int jj = ii + 1;
  1885.    
  1886.    
  1887.    HXREGION* retRGN = CounterClockwiseTopLeftMatrix(left, top, ii, bottom, completeness,lines);
  1888.    HXREGION* rgn1 = ClockwiseTopRightMatrix(jj, top, right, bottom, completeness,tmpLines);
  1889.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_XOR);
  1890.    HXDestroyRegion(rgn1);
  1892.    if (lines)
  1893.       *lines += *tmpLines;
  1894.         
  1895.    return retRGN;
  1896. }
  1898. HXREGION* DoubleSpiralBottomMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1899. {
  1900.    HXREGION* retRGN = MirrorHorizontal(DoubleSpiralTopMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
  1901.    if (lines)
  1902.       MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
  1904.    return retRGN;
  1905. }
  1907. HXREGION* DoubleSpiralLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1908. {
  1909.    tranLines* tmpLines = NULL;
  1911.    if (lines)
  1912.       tmpLines = new tranLines;
  1914.    HXREGION* retRGN = ClockwiseTopLeftMatrix(left, top, right, (top + bottom) / 2 + 1, completeness,lines);
  1915.    HXREGION* rgn1 = CounterClockwiseBottomLeftMatrix(left, (top + bottom) / 2, right, bottom, completeness,tmpLines);
  1916.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1917.    HXDestroyRegion(rgn1);
  1918.         
  1919.    if (lines)
  1920.       *lines += *tmpLines;
  1921.         
  1922.    return retRGN;
  1923. }
  1925. HXREGION* DoubleSpiralRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1926. {
  1927.    HXREGION* retRGN = MirrorVertical(DoubleSpiralLeftMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2);
  1928.    if (lines)
  1929.       MirrorVertical(lines,left + (right - left + 1) / 2);
  1931.    return retRGN;
  1932. }
  1934. HXREGION* QuadSpiralVerticalMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1935. {
  1936.    tranLines* tmpLines = NULL;
  1938.    if (lines)
  1939.       tmpLines = new tranLines;
  1941.    HXREGION* retRGN = DoubleSpiralTopMatrix(left, top, right, (top + bottom) / 2 + 1, completeness,lines);
  1942.    HXREGION* rgn1 = DoubleSpiralBottomMatrix(left, (top + bottom) / 2 , right, bottom, completeness,tmpLines);
  1943.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1944.    HXDestroyRegion(rgn1);
  1946.    if (lines)
  1947.       *lines += *tmpLines;
  1948.         
  1949.    return retRGN;
  1950. }
  1952. HXREGION* QuadSpiralHorizontalMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1953. {
  1954.    tranLines* tmpLines = NULL;
  1956.    if (lines)
  1957.       tmpLines = new tranLines;
  1959.    HXREGION* retRGN = DoubleSpiralLeftMatrix(left, top, (left + right) / 2, bottom, completeness,lines);
  1960.    HXREGION* rgn1 = DoubleSpiralRightMatrix((left + right) / 2 + 1, top, right, bottom, completeness,tmpLines);
  1961.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_XOR);
  1962.    HXDestroyRegion(rgn1);
  1964.    if (lines)
  1965.       *lines += *tmpLines;
  1966.         
  1967.    return retRGN;
  1968. }
  1970. HXREGION* VerticalWaterfallLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1971. {
  1972.    static CHXBuffer* z_waterfallLeftDataBuffer = NULL;
  1973.         
  1974.    if (!z_waterfallLeftDataBuffer || completeness == MATRIX_TRANSITION_INIT)
  1975.    {
  1976.       MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(8,4,11);
  1977.       MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
  1978.                 
  1979.       int blockCount;
  1980.       int start = 0;
  1981.                 
  1982.       for (int i = 0; i < 11; ++i)
  1983.       {
  1984.          blockCount = 6 - abs(i - 5);
  1985.          if (blockCount > 4) blockCount = 4;
  1986.                         
  1987.          blockTransList[i].CreateList(blockCount);
  1988.          MatrixBlockTransition* list = blockTransList[i].GetListPtr();
  1989.                         
  1990.          for (int j = 0; j < blockCount; ++j)
  1991.          {
  1992.             list[j].block = start - j * 7;
  1993.             list[j].invert = 0;
  1994.             list[j].transition = SlideVerticalEdgeWipe;
  1995.          }
  1996.          start = (i >= 3) ? start + 1 : start + 8;
  1997.       }
  1998.                 
  1999.       z_waterfallLeftDataBuffer = new CHXBuffer();
  2000.       z_waterfallLeftDataBuffer->AddRef();
  2001.       z_waterfallLeftDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
  2002.    }
  2003.    else if (completeness == MATRIX_TRANSITION_DELETE)
  2004.    {
  2005.       delete *((MatrixTransitionData**)z_waterfallLeftDataBuffer->GetBuffer());
  2006.       if (!z_waterfallLeftDataBuffer->Release())
  2007.       {
  2008.          z_waterfallLeftDataBuffer = NULL;
  2009.          return HXCreateRegion();
  2010.       }
  2011.    }
  2012.         
  2013.    return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_waterfallLeftDataBuffer->GetBuffer()),lines);
  2014. }
  2016. HXREGION* VerticalWaterfallRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2017. {
  2018.    HXREGION* retRGN = MirrorVertical(VerticalWaterfallLeftMatrix(left, top, right, bottom, completeness,lines),left + (right - left + 1) / 2);
  2019.    if (lines)
  2020.       MirrorVertical(lines,left + (right - left + 1) / 2);
  2022.    return retRGN;
  2023. }
  2025. HXREGION* HorizontalWaterfallLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2026. {
  2027.    static CHXBuffer* z_waterfallHorzLeftDataBuffer = NULL;
  2028.         
  2029.    if (!z_waterfallHorzLeftDataBuffer || completeness == MATRIX_TRANSITION_INIT)
  2030.    {
  2031.       MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(4,8,11);
  2032.       MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
  2033.                 
  2034.       int blockCount;
  2035.       int start = 0;
  2036.                 
  2037.       for (int i = 0; i < 11; ++i)
  2038.       {
  2039.          blockCount = 6 - abs(i - 5);
  2040.          if (blockCount > 4) blockCount = 4;
  2041.                         
  2042.          blockTransList[i].CreateList(blockCount);
  2043.          MatrixBlockTransition* list = blockTransList[i].GetListPtr();
  2044.                         
  2045.          for (int j = 0; j < blockCount; ++j)
  2046.          {
  2047.             list[j].block = start + j * 3;
  2048.             list[j].invert = 0;
  2049.             list[j].transition = EdgeWipe;
  2050.          }
  2051.          start = (start >= 3) ? start + 4 : start + 1;
  2052.       }
  2053.                 
  2054.       z_waterfallHorzLeftDataBuffer = new CHXBuffer();
  2055.       z_waterfallHorzLeftDataBuffer->AddRef();
  2056.       z_waterfallHorzLeftDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
  2057.    }
  2058.    else if (completeness == MATRIX_TRANSITION_DELETE)
  2059.    {
  2060.       delete *((MatrixTransitionData**)z_waterfallHorzLeftDataBuffer->GetBuffer());
  2061.       if (!z_waterfallHorzLeftDataBuffer->Release())
  2062.       {
  2063.          z_waterfallHorzLeftDataBuffer = NULL;
  2064.          return HXCreateRegion();
  2065.       }
  2066.    }
  2067.         
  2068.    return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_waterfallHorzLeftDataBuffer->GetBuffer()),lines);
  2069. }
  2071. HXREGION* HorizontalWaterfallRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2072. {
  2073.    HXREGION* retRGN = MirrorVertical(HorizontalWaterfallLeftMatrix(left, top, right, bottom, completeness,lines),left + (right - left + 1) / 2);
  2074.    if (lines)
  2075.       MirrorVertical(lines,left + (right - left + 1) / 2);
  2077.    return retRGN;
  2078. }
  2080. #endif //_TRANSITIONS_ON_
  2082. HXREGION* DefaultTransition(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2083. {
  2084.    if (lines)
  2085.    {
  2086.       lines->m_nLines = 0;
  2087.       HX_VECTOR_DELETE( lines->m_pLines );
  2088.    }
  2089.    return HXCreateRectRegion(left, top, right - left, bottom - top);
  2090. }
  2092. #ifdef _TRANSITIONS_ON_
  2094. HXREGION* CreateConvexPoly(int nSides, int startingAngle, int left, int top, int right, int bottom, int completeness, int multiplier = 100, int arclength = 360, int oneExtra = 0, tranLines* lines = NULL)
  2095. {
  2096.    HXxPoint* points = (HXxPoint*) malloc(sizeof(HXxPoint)* (nSides+oneExtra));
  2098.    HX_ASSERT( points );
  2099.    
  2100.    int count = 0;
  2101.    int middlex = (left+right)/2;
  2102.    int middley = (top+bottom)/2;
  2103.    double sizex = (double)(right - left) * (double) completeness / 1000.0 * (double)multiplier / 100.0;
  2104.    double sizey = (double)(bottom - top) * (double) completeness / 1000.0 * (double)multiplier / 100.0;
  2106.    for(;count<(nSides+oneExtra); count++)
  2107.    {
  2108.       double angle      = ((double)startingAngle + ((double)(((double)arclength/(double)nSides)*(double)count)))*PI/180.0;
  2109.       points[count].x = (int) (middlex + sin(angle) * sizex);
  2110.       points[count].y = (int) (middley - cos(angle) * sizey);
  2111.    }
  2113.    if (lines)
  2114.    {
  2115.       lines->m_nLines = nSides;
  2116.       lines->m_pLines = new LineSegment[nSides];
  2118.       lines->m_pLines[0].start.x = points[0].x;
  2119.       lines->m_pLines[0].start.y = points[0].y;
  2121.       for (count = 1; count < nSides; count++)
  2122.       {
  2123.          lines->m_pLines[count].start.x = points[count].x;
  2124.          lines->m_pLines[count].start.y = points[count].y;
  2125.          lines->m_pLines[count - 1].finish.x = points[count].x;
  2126.          lines->m_pLines[count - 1].finish.y = points[count].y;
  2127.       }
  2128.       lines->m_pLines[count - 1].finish.x = points[0].x;
  2129.       lines->m_pLines[count - 1].finish.y = points[0].y;
  2130.    }
  2132.    HXREGION* tempRGN = HXPolygonRegion( points, (nSides+oneExtra), WindingRule);
  2133.    free(points);
  2134.    return tempRGN;
  2135. }
  2137. HXREGION* CreateConcavePoly(int nSides, int startingAngle, int left, int top, int right, int bottom, int completeness, int multiplier = 100, tranLines* lines = NULL)
  2138. {
  2139.    HXxPoint* points = (HXxPoint*) malloc(sizeof(HXxPoint)* nSides*2);
  2140.         
  2141.    int count = 0;
  2142.    int middlex = (left+right)/2;
  2143.    int middley = (top+bottom)/2;
  2144.    double sizex = (double)(right - left) * (double) completeness / 1000.0 * (double)multiplier / 100.0;
  2145.    double sizey = (double)(bottom - top) * (double) completeness / 1000.0 * (double)multiplier / 100.0;
  2146.         
  2147.    for(;count<nSides*2; count++)
  2148.    {
  2149.       double angle      = (startingAngle + ((double)((360.0/((double)nSides*2))*(double)count)))*PI/180.0;
  2150.       points[count].x = (int) (middlex + sin(angle) * sizex * (double)(count %2 + 1));
  2151.       points[count].y = (int) (middley - cos(angle) * sizey * (double)(count %2 + 1));
  2152.    }
  2153.         
  2154.    if (lines)
  2155.    {
  2156.       lines->m_nLines = nSides * 2;
  2157.       lines->m_pLines = new LineSegment[lines->m_nLines];
  2159.       lines->m_pLines[0].start.x = points[0].x;
  2160.       lines->m_pLines[0].start.y = points[0].y;
  2162.       for (count = 1; count < lines->m_nLines; count++)
  2163.       {
  2164.          lines->m_pLines[count].start.x = points[count].x;
  2165.          lines->m_pLines[count].start.y = points[count].y;
  2166.          lines->m_pLines[count - 1].finish.x = points[count].x;
  2167.          lines->m_pLines[count - 1].finish.y = points[count].y;
  2168.       }
  2169.       lines->m_pLines[count - 1].finish.x = points[0].x;
  2170.       lines->m_pLines[count - 1].finish.y = points[0].y;
  2171.    }
  2172.    HXREGION* tempRGN = HXPolygonRegion( points, nSides*2, WindingRule);
  2173.    free(points);
  2174.    return tempRGN;
  2175. }
  2177. HXREGION* CreateArrowHeadPoly(int startingAngle, int left, int top, int right, int bottom, int completeness, int multiplier = 100, tranLines* lines = NULL)
  2178. {
  2179.    int angles[] = {0, 140, 180, 220};
  2180.    double multiple[] = { 1.0, 1.0, 0.3333, 1.0};
  2181.    int nSides = 4;
  2182.    HXxPoint* points = (HXxPoint*) malloc(sizeof(HXxPoint)* nSides);
  2183.         
  2184.    int count = 0;
  2185.    int middlex = (left+right)/2;
  2186.    int middley = (top+bottom)/2;
  2187.    double sizex = (double)(right - left) * (double) completeness / 1000.0 * (double)multiplier / 100.0;
  2188.    double sizey = (double)(bottom - top) * (double) completeness / 1000.0 * (double)multiplier / 100.0;
  2189.         
  2190.    for(;count<nSides; count++)
  2191.    {
  2192.       double angle      = ((double)(startingAngle + angles[count]))*PI/180.0;
  2193.       points[count].x = (int) (middlex + sin(angle) * sizex * multiple[count]);
  2194.       points[count].y = (int) (middley - cos(angle) * sizey * multiple[count]);
  2195.    }
  2196.         
  2197.    if (lines)
  2198.    {
  2199.       lines->m_nLines = nSides;
  2200.       lines->m_pLines = new LineSegment[nSides];
  2202.       lines->m_pLines[0].start.x = points[0].x;
  2203.       lines->m_pLines[0].start.y = points[0].y;
  2205.       for (count = 1; count < nSides; count++)
  2206.       {
  2207.          lines->m_pLines[count].start.x = points[count].x;
  2208.          lines->m_pLines[count].start.y = points[count].y;
  2209.          lines->m_pLines[count - 1].finish.x = points[count].x;
  2210.          lines->m_pLines[count - 1].finish.y = points[count].y;
  2211.       }
  2212.       lines->m_pLines[count - 1].finish.x = points[0].x;
  2213.       lines->m_pLines[count - 1].finish.y = points[0].y;
  2214.    }
  2215.    HXREGION* tempRGN = HXPolygonRegion( points, nSides, WindingRule);
  2216.    free(points);
  2217.    return tempRGN;
  2218. }
  2220. HXREGION* CreateSharpTrianglePoly(int startingAngle, int left, int top, int right, int bottom, int completeness, int multiplier = 100, tranLines* lines = NULL)
  2221. {
  2222.    int angles[] = {0, 150, 210};
  2223.    int nSides = 3;
  2224.    HXxPoint* points = (HXxPoint*) malloc(sizeof(HXxPoint)* nSides);
  2225.         
  2226.    int count = 0;
  2227.    int middlex = (left+right)/2;
  2228.    int middley = (top+bottom)/2;
  2229.    double sizex = (double)(right - left) * (double) completeness / 1000.0 * (double)multiplier / 100.0;
  2230.    double sizey = (double)(bottom - top) * (double) completeness / 1000.0 * (double)multiplier / 100.0;
  2231.         
  2232.    for(;count<nSides; count++)
  2233.    {
  2234.       double angle      = ((double)(startingAngle + angles[count]))*PI/180.0;
  2235.       points[count].x = (int) (middlex + sin(angle) * sizex); 
  2236.       points[count].y = (int) (middley - cos(angle) * sizey);
  2237.    }
  2238.         
  2239.    if (lines)
  2240.    {
  2241.       lines->m_nLines = nSides;
  2242.       lines->m_pLines = new LineSegment[nSides];
  2244.       lines->m_pLines[0].start.x = points[0].x;
  2245.       lines->m_pLines[0].start.y = points[0].y;
  2247.       for (count = 1; count < nSides; count++)
  2248.       {
  2249.          lines->m_pLines[count].start.x = points[count].x;
  2250.          lines->m_pLines[count].start.y = points[count].y;
  2251.          lines->m_pLines[count - 1].finish.x = points[count].x;
  2252.          lines->m_pLines[count - 1].finish.y = points[count].y;
  2253.       }
  2254.       lines->m_pLines[count - 1].finish.x = points[0].x;
  2255.       lines->m_pLines[count - 1].finish.y = points[0].y;
  2256.    }
  2257.    HXREGION* tempRGN = HXPolygonRegion( points, nSides, WindingRule);
  2258.    free(points);
  2259.    return tempRGN;
  2260. }
  2262. HXREGION* KeyHoleIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2263. {
  2264.    if (completeness >= 1000)
  2265.       return HXCreateRectRegion(left,top,right-left,bottom-top);
  2267.    int midX = left + right / 2;
  2268.    int midY = top + bottom / 2;
  2269.    int radius = int(double(midY - top) / 450.0 * completeness);
  2270.    int hTop = midY - radius;
  2271.    int startY = int(hTop + double(midY - hTop) * 2.0 / 5.0);
  2273.    int i;
  2274.    HXxPoint p[61];
  2276.    double angle = 1.570796; // 90 degrees
  2277.    for (i = 0; i <= 30; ++i, angle += 0.087266) // 5 degress
  2278.    {
  2279.       p[i].x = midX + int(cos(angle) * radius);
  2280.       p[i].y = startY - int(sin(angle) * radius);
  2281.    }
  2283.    p[30].x = midX - radius;
  2284.    p[30].y = startY + radius * 3;
  2285.    p[31].x = midX + radius;
  2286.    p[31].y = p[30].y;
  2288.    for (i = 32; i < 61; ++i)
  2289.    {
  2290.       p[i].x = 2 * midX - p[61 - i].x;
  2291.       p[i].y = p[61 - i].y;
  2292.    }
  2294.    if (lines)
  2295.    {
  2296.       lines->m_pLines = new LineSegment[61];
  2298.       if(!lines->m_pLines)
  2299.       {
  2300.          lines->m_nLines = 0;
  2301.       }
  2302.       else
  2303.       {
  2304.          int j;
  2305.          lines->m_nLines = 61;
  2306.          for (i = 0, j = 1; i < 60; ++i, ++j)
  2307.          {
  2308.             lines->m_pLines[i].start.x = p[i].x;
  2309.             lines->m_pLines[i].start.y = p[i].y;
  2310.             lines->m_pLines[i].finish.x = p[j].x;
  2311.             lines->m_pLines[i].finish.y = p[j].y;
  2312.          }
  2313.          lines->m_pLines[60].start.x = p[60].x;
  2314.          lines->m_pLines[60].start.y = p[60].y;
  2315.          lines->m_pLines[60].finish.x = p[0].x;
  2316.          lines->m_pLines[60].finish.y = p[0].y;
  2317.       }
  2318.    }
  2320.    return HXPolygonRegion(p, 61, WindingRule);
  2321. }
  2323. HXREGION* CatEyeIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2324. {
  2325.    int width = right - left;
  2326.    int height = bottom - top;
  2327.    int halfWidth = width / 2;
  2328.    int halfHeight = height / 2;
  2329.    int radius = int(sqrt((double)(height * height + halfWidth * halfWidth)));
  2330.         
  2331.    double step = double(radius) / 1000.0;
  2332.    int x = int(double(halfHeight) / step);
  2333.    double newStep = double(1000 - x) / 1000.0;
  2334.    completeness = int(double(completeness) * newStep + x);
  2335.         
  2336.    tranLines* tmpLines = NULL;
  2338.    if (lines)
  2339.       tmpLines = new tranLines;
  2341.    HXREGION* retRGN = CreateConvexPoly(51,0,halfWidth - radius,top - radius,halfWidth + radius,top + radius,completeness,50,360,0,tmpLines);
  2342.    HXREGION* reg1 = CreateConvexPoly(51,0,halfWidth - radius,bottom - radius,halfWidth + radius,bottom + radius,completeness,50,360,0,lines);
  2343.     
  2344.    if (lines)
  2345.    {
  2346.       *lines += *tmpLines;
  2347.       delete tmpLines;
  2348.    }
  2349.         
  2350.    HXCombineRgn(retRGN, retRGN, reg1, HX_RGN_AND);
  2351.    HXDestroyRegion(reg1);
  2352.         
  2353.    return retRGN;
  2354. }
  2356. HXREGION* CatEyeSideIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2357. {
  2358.    int width = right - left;
  2359.    int height = bottom - top;
  2360.    int halfWidth = width / 2;
  2361.    int halfHeight = height / 2;
  2362.    int radius = int(sqrt((double)(width * width + halfHeight * halfHeight)));
  2363.         
  2364.    double step = double(radius) / 1000.0;
  2365.    int x = int(double(halfWidth) / step);
  2366.    double newStep = double(1000 - x) / 1000.0;
  2367.    completeness = int(double(completeness) * newStep + x);
  2368.         
  2369.    tranLines* tmpLines = NULL;
  2371.    if (lines)
  2372.       tmpLines = new tranLines;
  2374.    HXREGION* retRGN = CreateConvexPoly(51,0,left - radius,halfHeight - radius,left + radius,halfHeight + radius,completeness,50,360,0,lines);
  2375.    HXREGION* reg1 = CreateConvexPoly(51,0,right - radius,halfHeight - radius,right + radius,halfHeight + radius,completeness,50,360,0,tmpLines);
  2376.         
  2377.    if (lines)
  2378.    {
  2379.       *lines += *tmpLines;
  2380.       delete tmpLines;
  2381.    }
  2382.         
  2383.    HXCombineRgn(retRGN, retRGN, reg1, HX_RGN_AND);
  2384.    HXDestroyRegion(reg1);
  2385.         
  2386.    return retRGN;
  2387. }
  2389. HXREGION* RoundRectCalc(int midX, int midY, int dx, int dy, int radius, tranLines* lines)
  2390. {
  2391.    int i;
  2393.    HXxPoint p[60];
  2395.    double angle = 1.570796; // 90 degrees
  2396.    for (i = 0; i < 15; ++i, angle += 0.10472) // 6 degrees
  2397.    {
  2398.       int nx = int(cos(angle) * radius);
  2399.       int ny = int(sin(angle) * radius);
  2401.       p[i].x = p[29 - i].x = midX - dx / 2 + nx;
  2402.       p[59 - i].x = p[30 + i].x = midX + dx / 2 - nx;
  2403.       p[i].y = p[59 - i].y = midY - dy / 2 - ny;
  2404.       p[29 - i].y = p[30 + i].y = midY + dy / 2 + ny;
  2405.    }
  2407.    if (lines)
  2408.    {
  2409.       lines->m_pLines = new LineSegment[60];
  2411.       if(!lines->m_pLines)
  2412.       {
  2413.          lines->m_nLines = 0;
  2414.       }
  2415.       else
  2416.       {
  2417.          int j;
  2418.          lines->m_nLines = 60;
  2419.          for (i = 0, j = 1; i < 59; ++i, ++j)
  2420.          {
  2421.             lines->m_pLines[i].start.x = p[i].x;
  2422.             lines->m_pLines[i].start.y = p[i].y;
  2423.             lines->m_pLines[i].finish.x = p[j].x;
  2424.             lines->m_pLines[i].finish.y = p[j].y;
  2425.          }
  2426.          lines->m_pLines[59].start.x = p[59].x;
  2427.          lines->m_pLines[59].start.y = p[59].y;
  2428.          lines->m_pLines[59].finish.x = p[0].x;
  2429.          lines->m_pLines[59].finish.y = p[0].y;
  2430.       }
  2431.    }
  2432.         
  2433.    return HXPolygonRegion(p, 60, WindingRule);
  2434. }
  2436. HXREGION* RoundRectHorizontal(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2437. {
  2438.    if (completeness >= 1000)
  2439.       return HXCreateRectRegion(left,top,right-left,bottom-top);
  2441.    int width = right - left;
  2442.    int height = bottom - top;
  2443.    int midX = left + width / 2;
  2444.    int midY = top + height / 2;
  2445.    int steps = height / 2 + height / 16;
  2446.         
  2447.    if (width > height * 2)
  2448.       steps += (width - height) / 2;
  2449.         
  2450.    int dy = int(steps * (double(completeness) / 1000.0));
  2451.    int dx = dy * 2;
  2452.    int radius = dy / 2;
  2454.    return RoundRectCalc(midX, midY, dx, dy, radius, lines);
  2455. }
  2457. HXREGION* RoundRectVeritical(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2458. {
  2459.    if (completeness >= 1000)
  2460.       return HXCreateRectRegion(left,top,right-left,bottom-top);
  2462.    int width = right - left;
  2463.    int height = bottom - top;
  2464.    int midX = left + right / 2;
  2465.    int midY = top + bottom / 2;
  2466.    int steps = width / 2;
  2467.         
  2468.    if (height > width * 2)
  2469.       steps += (height - width) / 2;
  2470.         
  2471.    int dx = int(steps * (double(completeness) / 1000.0));
  2472.    int dy = dx * 2;
  2473.    int radius = dx / 2;
  2475.    return RoundRectCalc(midX, midY, dx, dy, radius, lines);
  2476. }
  2478. HXREGION* ConvexPolyIris(int sides, int angle, int left, int top, int right, int bottom, int completeness, int multiplier = 100, tranLines* lines = NULL)
  2479. {
  2480.    if (completeness >= 1000)
  2481.       return HXCreateRectRegion(left,top,right-left,bottom-top);
  2482.         
  2483.    int width = right - left;
  2484.    int height = bottom - top;
  2485.    int midX = left + width / 2;
  2486.    int midY = top + height / 2;
  2487.         
  2488.    double step = double(max(width, height)) / 2000.0;
  2489.    int square = int(step * completeness);
  2490.         
  2491.    int sLeft = midX - square;
  2492.    int sTop = midY - square;
  2493.    int sRight = midX + square;
  2494.    int sBottom = midY + square;
  2495.         
  2496.    return CreateConvexPoly(sides, angle, sLeft, sTop, sRight, sBottom, completeness, multiplier, 360, 0 ,lines);
  2497. }
  2499. HXREGION* RectangleIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2500. {
  2501.    return CreateConvexPoly(4, 45, left, top, right, bottom, completeness, 75, 360, 0 , lines);
  2502. }
  2504. HXREGION* DiamondIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2505. {
  2506.    return ConvexPolyIris(4,0,left,top,right,bottom,completeness, 100, lines);
  2507. }
  2509. HXREGION* TriangleIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2510. {
  2511.    return ConvexPolyIris(3,0,left,top,right,bottom,completeness, 140, lines);
  2512. }
  2514. HXREGION* TriangleRightIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2515. {
  2516.    return ConvexPolyIris(3,90,left,top,right,bottom,completeness,140, lines);
  2517. }
  2519. HXREGION* TriangleUpsideDownIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2520. {
  2521.    return ConvexPolyIris(3,180,left,top,right,bottom,completeness, 140, lines);
  2522. }
  2524. HXREGION* TriangleLeftIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2525. {
  2526.    return ConvexPolyIris(3,270,left,top,right,bottom,completeness, 140, lines);
  2527. }
  2529. HXREGION* PentagonIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2530. {
  2531.    return ConvexPolyIris(5,0,left,top,right,bottom,completeness, 66, lines);
  2532. }
  2534. HXREGION* PentagonUpsideDownLeftIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2535. {
  2536.    return ConvexPolyIris(5,180,left,top,right,bottom,completeness,66, lines);
  2537. }
  2539. HXREGION* HexagonIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2540. {
  2541.    return ConvexPolyIris(6,60,left,top,right,bottom,completeness,85, lines);
  2542. }
  2544. HXREGION* HexagonSideIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2545. {
  2546.    return ConvexPolyIris(6,30,left,top,right,bottom,completeness,85, lines);
  2547. }
  2549. HXREGION* CircleIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2550. {
  2551.    return ConvexPolyIris(50,0,left,top,right,bottom,completeness,60, lines);
  2552. }
  2554. HXREGION* OvalIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2555. {
  2556.    return CreateConvexPoly(50, 0, left - (right - left)/2, top, right + (right - left)/2, bottom, completeness, 60, 360, 0 , lines);
  2557. }
  2559. HXREGION* OvalSideIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2560. {
  2561.    return CreateConvexPoly(50, 0, left, top - (bottom - top)/2, right, bottom + (bottom - top)/2, completeness, 60, 360, 0 , lines);
  2562. }
  2564. HXREGION* StarIris(int sides, int angle, int left, int top, int right, int bottom, int completeness, int multiplier = 100, tranLines* lines = NULL)
  2565. {
  2566.    if (completeness >= 1000)
  2567.       return HXCreateRectRegion(left,top,right-left,bottom-top);
  2568.         
  2569.    int width = right - left;
  2570.    int height = bottom - top;
  2571.    int midX = left + width / 2;
  2572.    int midY = top + height / 2;
  2573.         
  2574.    int square = int(double(min(width, height) * double(multiplier) / 100.0 * completeness) / 1000.0);
  2575.         
  2576.    int sLeft = midX - square;
  2577.    int sTop = midY - square;
  2578.    int sRight = midX + square;
  2579.    int sBottom = midY + square;
  2580.         
  2581.    HXREGION* retRGN = CreateConcavePoly(sides, angle, sLeft, sTop, sRight, sBottom, completeness, 50, lines);
  2582.    return retRGN;
  2583. }
  2585. HXREGION* FourPointStarIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2586. {
  2587.    return StarIris(4,45,left,top,right,bottom,completeness,120, lines);
  2588. }
  2590. HXREGION* FivePointStarIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2591. {
  2592.    return StarIris(5,36,left,top,right,bottom,completeness,150, lines);
  2593. }
  2595. HXREGION* SixPointStarIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2596. {
  2597.    return StarIris(6,30,left,top,right,bottom,completeness,150, lines);
  2598. }
  2600. HXREGION* ArrowHeadIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2601. {
  2602.    return CreateArrowHeadPoly(0, left, top, right, bottom, completeness, 200, lines);
  2603. }
  2605. HXREGION* ArrowHeadRightIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2606. {
  2607.    return CreateArrowHeadPoly(90, left, top, right, bottom, completeness, 200, lines);
  2608. }
  2610. HXREGION* ArrowHeadUpsideDownIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2611. {
  2612.    return CreateArrowHeadPoly(180, left, top, right, bottom, completeness, 200, lines);
  2613. }
  2615. HXREGION* ArrowHeadLeftIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2616. {
  2617.    return CreateArrowHeadPoly(270, left, top, right, bottom, completeness, 200, lines);
  2618. }
  2620. HXREGION* HeartIris(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2621. {
  2622.    if (completeness >= 1000)
  2623.       return HXCreateRectRegion(left,top,right-left,bottom-top);
  2625.    int midX = (right - left) / 2;
  2626.    int midY = (bottom - top) / 2;
  2627.    int radius = int(double(midY - top) / 750.0 * completeness);
  2628.    int hLeft = midX - radius;
  2629.    int hTop = midY - radius;
  2630.    int startY = int(hTop + double(midY - hTop) * 2.0 / 5.0);
  2631.    int i;
  2633.    HXxPoint p[60];
  2635.    double angle = 0;
  2636.    for (i = 0; i <= 30; ++i, angle += 0.1309) // 7.5 degress
  2637.    {
  2638.       p[i].x = hLeft + int(cos(angle) * radius);
  2639.       p[i].y = startY - int(sin(angle) * radius);
  2640.    }
  2642.    p[30].x = midX;
  2643.    p[30].y = p[29].y + (5 * (midX - p[29].x)) / 4; // slope is 5/4 or 1.25
  2645.    for (i = 31; i < 60; ++i)
  2646.    {
  2647.       p[i].x = 2 * midX - p[60 - i].x;
  2648.       p[i].y = p[60 - i].y;
  2649.    }
  2651.    if (lines)
  2652.    {
  2653.       lines->m_pLines = new LineSegment[60];
  2655.       if(!lines->m_pLines)
  2656.       {
  2657.          lines->m_nLines = 0;
  2658.       }
  2659.       else
  2660.       {
  2661.          int j;
  2662.          lines->m_nLines = 60;
  2663.          for (i = 0, j = 1; i < 59; ++i, ++j)
  2664.          {
  2665.             lines->m_pLines[i].start.x = p[i].x;
  2666.             lines->m_pLines[i].start.y = p[i].y;
  2667.             lines->m_pLines[i].finish.x = p[j].x;
  2668.             lines->m_pLines[i].finish.y = p[j].y;
  2669.          }
  2670.          lines->m_pLines[59].start.x = p[59].x;
  2671.          lines->m_pLines[59].start.y = p[59].y;
  2672.          lines->m_pLines[59].finish.x = p[0].x;
  2673.          lines->m_pLines[59].finish.y = p[0].y;
  2674.       }
  2675.    }
  2677.    return HXPolygonRegion(p, 60, WindingRule);
  2678. }
  2681. HXREGION* EdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2682. {
  2683.    int x = (int)((double)left + (right - left)*((double)completeness)/1000.0);
  2685.    if (lines)
  2686.    {
  2687.       lines->m_nLines = 1;
  2688.       lines->m_pLines = new LineSegment[1];
  2689.       lines->m_pLines->start.x = lines->m_pLines->finish.x = x;
  2690.       lines->m_pLines->start.y = top;
  2691.       lines->m_pLines->finish.y = bottom;
  2692.    }
  2694.    return HXCreateRectRegion(left,
  2695.                               top,
  2696.                               x - left,
  2697.                               bottom - top);
  2698. }
  2700. HXREGION* SlideVerticalEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2701. {
  2702.    int y = (int) ((double)top + (double)(bottom - top)* ((double)completeness) / 1000.0);
  2704.    if (lines)
  2705.    {
  2706.       lines->m_nLines = 1;
  2707.       lines->m_pLines = new LineSegment[1];
  2708.       lines->m_pLines->start.x = left;
  2709.       lines->m_pLines->finish.x = right;
  2710.       lines->m_pLines->start.y = lines->m_pLines->finish.y = y;
  2711.    }
  2713.    return HXCreateRectRegion( left,
  2714.                                top,
  2715.                                right - left,
  2716.                                y - top
  2717.                                );
  2718. }
  2720. HXREGION* TopLeftEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2721. {
  2722.    HXxPoint points[4];
  2723.         
  2724.    points[0].x = left;
  2725.    points[0].y = top;
  2726.    points[1].x = left;
  2727.    points[1].y = top + ((bottom - top) * completeness  )/ 1000;
  2728.    points[2].x = left + ((right - left) * completeness )/ 1000;
  2729.    points[2].y = top + ((bottom - top) * completeness  )/ 1000;
  2730.    points[3].x = left + ((right - left) * completeness )/ 1000;
  2731.    points[3].y = top;
  2732.         
  2733.    if (lines)
  2734.    {
  2735.       lines->m_nLines = 2;
  2736.       lines->m_pLines = new LineSegment[2];
  2738.       if (!lines->m_pLines)
  2739.       {
  2740.          lines->m_nLines = 0;
  2741.       }
  2742.       else
  2743.       {
  2744.          lines->m_pLines[0].start.x = points[1].x;
  2745.          lines->m_pLines[0].start.y = points[1].y;
  2746.          lines->m_pLines[0].finish.x = points[2].x;
  2747.          lines->m_pLines[0].finish.y = points[2].y;
  2748.          lines->m_pLines[1].start.x = points[2].x;
  2749.          lines->m_pLines[1].start.y = points[2].y;
  2750.          lines->m_pLines[1].finish.x = points[3].x;
  2751.          lines->m_pLines[1].finish.y = points[3].y;
  2752.       }
  2753.    }
  2755.    return HXPolygonRegion( points, 4, WindingRule);
  2756. }
  2758. HXREGION* TopRightEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2759. {
  2760.    HXxPoint points[4];
  2761.         
  2762.    points[0].x = right;
  2763.    points[0].y = top;
  2764.    points[1].x = right;
  2765.    points[1].y = top + ((bottom - top) * completeness)/ 1000;
  2766.    points[2].x = right - ((right - left) * completeness)/ 1000;
  2767.    points[2].y = top + ((bottom - top) * completeness)/ 1000;
  2768.    points[3].x = right - ((right - left) * completeness)/ 1000;
  2769.    points[3].y = top;
  2770.         
  2771.    if (lines)
  2772.    {
  2773.       lines->m_nLines = 2;
  2774.       lines->m_pLines = new LineSegment[2];
  2776.       if (!lines->m_pLines)
  2777.       {
  2778.          lines->m_nLines = 0;
  2779.       }
  2780.       else
  2781.       {
  2782.          lines->m_pLines[0].start.x = points[1].x;
  2783.          lines->m_pLines[0].start.y = points[1].y;
  2784.          lines->m_pLines[0].finish.x = points[2].x;
  2785.          lines->m_pLines[0].finish.y = points[2].y;
  2786.          lines->m_pLines[1].start.x = points[2].x;
  2787.          lines->m_pLines[1].start.y = points[2].y;
  2788.          lines->m_pLines[1].finish.x = points[3].x;
  2789.          lines->m_pLines[1].finish.y = points[3].y;
  2790.       }
  2791.    }
  2793.    return HXPolygonRegion( points, 4, WindingRule);
  2794. }
  2797. HXREGION* BottomRightEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2798. {
  2799.    HXxPoint points[4];