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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
sitetran.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：180k
源码类别：

Symbian

开发平台：

C/C++

sitetran.cpp：源码内容
  1.    points[3].x = right - ((right - left) * completeness)/ 1000;
  2.    points[3].y = bottom;
  3.         
  4.    if (lines)
  5.    {
  6.       lines->m_nLines = 2;
  7.       lines->m_pLines = new LineSegment[2];
  9.       if (!lines->m_pLines)
  10.       {
  11.          lines->m_nLines = 0;
  12.       }
  13.       else
  14.       {
  15.          lines->m_pLines[0].start.x = points[1].x;
  16.          lines->m_pLines[0].start.y = points[1].y;
  17.          lines->m_pLines[0].finish.x = points[2].x;
  18.          lines->m_pLines[0].finish.y = points[2].y;
  19.          lines->m_pLines[1].start.x = points[2].x;
  20.          lines->m_pLines[1].start.y = points[2].y;
  21.          lines->m_pLines[1].finish.x = points[3].x;
  22.          lines->m_pLines[1].finish.y = points[3].y;
  23.       }
  24.    }
  26.    return HXPolygonRegion( points, 4, WindingRule);
  27. }
  29. HXREGION* BottomLeftEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  30. {
  31.    HXxPoint points[4];
  32.         
  33.    points[0].x = left;
  34.    points[0].y = bottom;
  35.    points[1].x = left;
  36.    points[1].y = bottom - ((bottom - top) * completeness )/ 1000;
  37.    points[2].y = bottom - ((bottom - top) * completeness )/ 1000;
  38.    points[2].x = left + ((right - left) * completeness )/ 1000;
  39.    points[3].x = left + ((right - left) * completeness )/ 1000;
  40.    points[3].y = bottom;
  41.         
  42.    if (lines)
  43.    {
  44.       lines->m_nLines = 2;
  45.       lines->m_pLines = new LineSegment[2];
  47.       if (!lines->m_pLines)
  48.       {
  49.          lines->m_nLines = 0;
  50.       }
  51.       else
  52.       {
  53.          lines->m_pLines[0].start.x = points[1].x;
  54.          lines->m_pLines[0].start.y = points[1].y;
  55.          lines->m_pLines[0].finish.x = points[2].x;
  56.          lines->m_pLines[0].finish.y = points[2].y;
  57.          lines->m_pLines[1].start.x = points[2].x;
  58.          lines->m_pLines[1].start.y = points[2].y;
  59.          lines->m_pLines[1].finish.x = points[3].x;
  60.          lines->m_pLines[1].finish.y = points[3].y;
  61.       }
  62.    }
  64.    return HXPolygonRegion( points, 4, WindingRule);
  65. }
  67. HXREGION* FourCornerEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  68. {
  69.    tranLines *tl1 = NULL, *tl2 = NULL, *tl3 = NULL;
  71.    if (lines)
  72.    {
  73.       tl1 = new tranLines;
  74.       tl2 = new tranLines;
  75.       tl3 = new tranLines;
  76.    }
  78.    HXREGION* retRGN = HXCreateRectRegion(0, 0, 0, 0);
  79.    HXREGION* rgn1 = TopLeftEdgeWipe(left, top, left+(right-left)/2, top+(bottom-top)/2, completeness,lines);
  80.    HXREGION* rgn2 = TopRightEdgeWipe(left+(right-left)/2, top, right, top+(bottom-top)/2, completeness,tl1);
  81.    HXREGION* rgn3 = BottomRightEdgeWipe(left+(right-left)/2, top+(bottom-top)/2, right, bottom, completeness,tl2);
  82.    HXREGION* rgn4 = BottomLeftEdgeWipe(left, top+(bottom-top)/2, left+(right-left)/2, bottom, completeness,tl3);
  84.    if (lines)
  85.    {
  86.       *lines += *tl1;
  87.       *lines += *tl2;
  88.       *lines += *tl3;
  89.       delete tl1;
  90.       delete tl2;
  91.       delete tl3;
  92.    }
  93.     
  94.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  95.    HXCombineRgn(retRGN, retRGN, rgn2, HX_RGN_OR);
  96.    HXCombineRgn(retRGN, retRGN, rgn3, HX_RGN_OR);
  97.    HXCombineRgn(retRGN, retRGN, rgn4, HX_RGN_OR);
  98.         
  99.    HXDestroyRegion(rgn1);
  100.    HXDestroyRegion(rgn2);
  101.    HXDestroyRegion(rgn3);
  102.    HXDestroyRegion(rgn4);
  103.     
  104.    return retRGN;
  105. }
  107. HXREGION* BoxEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  108. {
  109.    double dleft     = left;
  110.    double dtop              = top;
  111.    double dright            = right;
  112.    double dbottom           = bottom;
  113.    double dcompleteness    = completeness;
  115.    int l = (int) (((dleft+dright)/2.0 ) - ((dright - dleft)/2.0 ) * dcompleteness/1000.0);
  116.    int t = (int) (((dtop+dbottom)/2.0 ) - ((dbottom - dtop)/2.0 ) * dcompleteness/1000.0);
  117.    int r = (int) (((dleft+dright)/2.0 ) + ((dright - dleft)/2.0 ) * dcompleteness/1000.0);
  118.    int b = (int) (((dtop+dbottom)/2.0 ) + ((dbottom - dtop)/2.0 ) * dcompleteness/1000.0);
  120.    if (lines)
  121.    {
  122.       lines->m_nLines = 4;
  123.       lines->m_pLines = new LineSegment[4];
  125.       if (!lines->m_pLines)
  126.       {
  127.          lines->m_nLines = 0;
  128.       }
  129.       else
  130.       {
  131.          lines->m_pLines[0].start.x = l;
  132.          lines->m_pLines[0].start.y = t;
  133.          lines->m_pLines[0].finish.x = r;
  134.          lines->m_pLines[0].finish.y = t;
  135.          lines->m_pLines[1].start.x = r;
  136.          lines->m_pLines[1].start.y = t;
  137.          lines->m_pLines[1].finish.x = r;
  138.          lines->m_pLines[1].finish.y = b;
  139.          lines->m_pLines[2].start.x = r;
  140.          lines->m_pLines[2].start.y = b;
  141.          lines->m_pLines[2].finish.x = l;
  142.          lines->m_pLines[2].finish.y = b;
  143.          lines->m_pLines[3].start.x = l;
  144.          lines->m_pLines[3].start.y = b;
  145.          lines->m_pLines[3].finish.x = l;
  146.          lines->m_pLines[3].finish.y = t;
  147.       }
  148.    }
  149.    return HXCreateRectRegion(l,t,r-l,b-t);
  150. }
  152. HXREGION* FourBoxEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  153. {
  154.    tranLines *tl1 = NULL, *tl2 = NULL, *tl3 = NULL;
  156.    if (lines)
  157.    {
  158.       tl1 = new tranLines;
  159.       tl2 = new tranLines;
  160.       tl3 = new tranLines;
  161.    }
  163.    HXREGION* retRGN = HXCreateRectRegion(0, 0, 0, 0);
  164.    HXREGION* rgn1 = BoxEdgeWipe(left, top, left+(right-left)/2, top+(bottom-top)/2, completeness,lines);
  165.    HXREGION* rgn2 = BoxEdgeWipe(left+(right-left)/2, top, right, top+(bottom-top)/2, completeness,tl1);
  166.    HXREGION* rgn3 = BoxEdgeWipe(left+(right-left)/2, top+(bottom-top)/2, right, bottom, completeness,tl2);
  167.    HXREGION* rgn4 = BoxEdgeWipe(left, top+(bottom-top)/2, left+(right-left)/2, bottom, completeness,tl3);
  168.         
  169.    if (lines)
  170.    {
  171.       *lines += *tl1;
  172.       *lines += *tl2;
  173.       *lines += *tl3;
  174.       delete tl1;
  175.       delete tl2;
  176.       delete tl3;
  177.    }
  178.         
  179.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  180.    HXCombineRgn(retRGN, retRGN, rgn2, HX_RGN_OR);
  181.    HXCombineRgn(retRGN, retRGN, rgn3, HX_RGN_OR);
  182.    HXCombineRgn(retRGN, retRGN, rgn4, HX_RGN_OR);
  183.         
  184.    HXDestroyRegion(rgn1);
  185.    HXDestroyRegion(rgn2);
  186.    HXDestroyRegion(rgn3);
  187.    HXDestroyRegion(rgn4);
  188.         
  189.    return retRGN;
  190. }
  192. HXREGION* BarnVerticalEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  193. {
  194.    int l = (int)(((double)(left+right)/2)-((double) (right - left)/2 ) * ((double)completeness/1000.0));
  195.    int r = (int) (((double) (left+right)/2 ) + ((double) (right - left)/2 ) * ((double)completeness/1000.0));
  197.    if (lines)
  198.    {
  199.       lines->m_nLines = 2;
  200.       lines->m_pLines = new LineSegment[2];
  202.       if (!lines->m_pLines)
  203.       {
  204.          lines->m_nLines = 0;
  205.       }
  206.       else
  207.       {
  208.          lines->m_pLines[0].start.x = l;
  209.          lines->m_pLines[0].start.y = top;
  210.          lines->m_pLines[0].finish.x = l;
  211.          lines->m_pLines[0].finish.y = bottom;
  212.          lines->m_pLines[1].start.x = r;
  213.          lines->m_pLines[1].start.y = top;
  214.          lines->m_pLines[1].finish.x = r;
  215.          lines->m_pLines[1].finish.y = bottom;
  216.       }
  217.    }
  219.    return HXCreateRectRegion(l,top,r-l,bottom-top);
  220. }
  222. HXREGION* BarnHorizontalEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  223. {
  224.    int t = (int) (((double) (top+bottom)/2 ) - ((double) (bottom - top)/2 ) * ((double)completeness/1000.0));
  225.    int b = (int) (((double) (top+bottom)/2 ) + ((double) (bottom - top)/2 ) * ((double)completeness/1000.0));
  227.    if (lines)
  228.    {
  229.       lines->m_nLines = 2;
  230.       lines->m_pLines = new LineSegment[2];
  232.       if (!lines->m_pLines)
  233.       {
  234.          lines->m_nLines = 0;
  235.       }
  236.       else
  237.       {
  238.          lines->m_pLines[0].start.x = left;
  239.          lines->m_pLines[0].start.y = t;
  240.          lines->m_pLines[0].finish.x = right;
  241.          lines->m_pLines[0].finish.y = t;
  242.          lines->m_pLines[1].start.x = left;
  243.          lines->m_pLines[1].start.y = b;
  244.          lines->m_pLines[1].finish.x = right;
  245.          lines->m_pLines[1].finish.y = b;
  246.       }
  247.    }
  249.    return HXCreateRectRegion(left,t,right-left,b-t);
  250. }
  252. HXREGION* TopCenterEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  253. {
  254.    int l = (int) (((double) (left+right)/2 ) - ((double) (right - left)/2 ) * ((double)completeness/1000.0));
  255.    int r = (int) (((double) (left+right)/2 ) + ((double) (right - left)/2 ) * ((double)completeness/1000.0));
  256.    int b = (int) (((double) top + ((double) (bottom - top) )) * ((double)completeness/1000.0));
  258.    if (lines)
  259.    {
  260.       lines->m_nLines = 3;
  261.       lines->m_pLines = new LineSegment[3];
  263.       if (!lines->m_pLines)
  264.       {
  265.          lines->m_nLines = 0;
  266.       }
  267.       else
  268.       {
  269.          lines->m_pLines[0].start.x = l;
  270.          lines->m_pLines[0].start.y = top;
  271.          lines->m_pLines[0].finish.x = l;
  272.          lines->m_pLines[0].finish.y = b;
  273.          lines->m_pLines[1].start.x = l;
  274.          lines->m_pLines[1].start.y = b;
  275.          lines->m_pLines[1].finish.x = r;
  276.          lines->m_pLines[1].finish.y = b;
  277.          lines->m_pLines[2].start.x = r;
  278.          lines->m_pLines[2].start.y = b;
  279.          lines->m_pLines[2].finish.x = r;
  280.          lines->m_pLines[2].finish.y = top;
  281.       }
  282.    }
  284.    HXREGION* retRGN = HXCreateRectRegion(l,top,r-l,b-top);
  285.         
  286.    return retRGN;
  287. }
  289. HXREGION* CenterRightEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  290. {
  291.    int l = (int) (left + ((double) (right - left) ) * ( 1.0 - (double)completeness/1000.0));
  292.    int t = (int) (((double) (top+bottom)/2 ) - ((double) (bottom - top)/2 ) * ((double)completeness/1000.0));
  293.    int b = (int) (((double) (top+bottom)/2 ) + ((double) (bottom - top)/2 ) * ((double)completeness/1000.0));
  295.    if (lines)
  296.    {
  297.       lines->m_nLines = 3;
  298.       lines->m_pLines = new LineSegment[3];
  300.       if (!lines->m_pLines)
  301.       {
  302.          lines->m_nLines = 0;
  303.       }
  304.       else
  305.       {
  306.          lines->m_pLines[0].start.x = right;
  307.          lines->m_pLines[0].start.y = t;
  308.          lines->m_pLines[0].finish.x = l;
  309.          lines->m_pLines[0].finish.y = t;
  310.          lines->m_pLines[1].start.x = l;
  311.          lines->m_pLines[1].start.y = t;
  312.          lines->m_pLines[1].finish.x = l;
  313.          lines->m_pLines[1].finish.y = b;
  314.          lines->m_pLines[2].start.x = l;
  315.          lines->m_pLines[2].start.y = b;
  316.          lines->m_pLines[2].finish.x = right;
  317.          lines->m_pLines[2].finish.y = b;
  318.       }
  319.    }
  321.    HXREGION* retRGN = HXCreateRectRegion(l,t,right-l,b-t);
  322.     
  323.    return retRGN;
  324. }
  326. HXREGION* BottomCenterEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  327. {
  328.    int l = (int) (((double) (left+right)/2 ) - ((double) (right - left)/2 ) * ((double)completeness/1000.0));
  329.    int t = (int) (bottom - ((double) (bottom - top) ) * ((double)completeness/1000.0));
  330.    int r = (int) (((double) (left+right)/2 ) + ((double) (right - left)/2 ) * ((double)completeness/1000.0));
  332.    if (lines)
  333.    {
  334.       lines->m_nLines = 3;
  335.       lines->m_pLines = new LineSegment[3];
  337.       if (!lines->m_pLines)
  338.       {
  339.          lines->m_nLines = 0;
  340.       }
  341.       else
  342.       {
  343.          lines->m_pLines[0].start.x = l;
  344.          lines->m_pLines[0].start.y = bottom;
  345.          lines->m_pLines[0].finish.x = l;
  346.          lines->m_pLines[0].finish.y = t;
  347.          lines->m_pLines[1].start.x = l;
  348.          lines->m_pLines[1].start.y = t;
  349.          lines->m_pLines[1].finish.x = r;
  350.          lines->m_pLines[1].finish.y = t;
  351.          lines->m_pLines[2].start.x = r;
  352.          lines->m_pLines[2].start.y = t;
  353.          lines->m_pLines[2].finish.x = r;
  354.          lines->m_pLines[2].finish.y = bottom;
  355.       }
  356.    }
  358.    HXREGION* retRGN = HXCreateRectRegion(l,t,r-l,bottom-t);
  359.     
  360.    return retRGN;
  361. }
  363. HXREGION* LeftCenterEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  364. {
  365.    int t = (int) (((double) (top+bottom)/2 ) - ((double) (bottom - top)/2 ) * ((double)completeness/1000.0));
  366.    int r = (int) (left + ((double) (right - left) ) * ((double)completeness/1000.0));
  367.    int b = (int) (((double) (top+bottom)/2 ) + ((double) (bottom - top)/2 ) * ((double)completeness/1000.0));
  369.    if (lines)
  370.    {
  371.       lines->m_nLines = 3;
  372.       lines->m_pLines = new LineSegment[3];
  374.       if (!lines->m_pLines)
  375.       {
  376.          lines->m_nLines = 0;
  377.       }
  378.       else
  379.       {
  380.          lines->m_pLines[0].start.x = left;
  381.          lines->m_pLines[0].start.y = t;
  382.          lines->m_pLines[0].finish.x = r;
  383.          lines->m_pLines[0].finish.y = t;
  384.          lines->m_pLines[1].start.x = r;
  385.          lines->m_pLines[1].start.y = t;
  386.          lines->m_pLines[1].finish.x = r;
  387.          lines->m_pLines[1].finish.y = b;
  388.          lines->m_pLines[2].start.x = r;
  389.          lines->m_pLines[2].start.y = b;
  390.          lines->m_pLines[2].finish.x = left;
  391.          lines->m_pLines[2].finish.y = b;
  392.       }
  393.    }
  395.    HXREGION* retRGN = HXCreateRectRegion(left,t,r-left,b-t);
  396.     
  397.    return retRGN;
  398. }
  400. HXREGION* DiagonalLeftDownEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  401. {
  402.    HXREGION* retRGN = HXCreateRectRegion(left, top, right-left, bottom-top);
  403.    HXxPoint points[4];
  404.         
  405.    points[0].x = left;
  406.    points[0].y = top;
  407.    points[1].x = left + ((right - left) * completeness * 2)/ 1000;
  408.    points[1].y = top;
  409.    points[2].x = left;
  410.    points[2].y = top + ((bottom - top) * completeness * 2)/ 1000;
  412.    if (lines)
  413.    {
  414.       lines->m_nLines = 1;
  415.       lines->m_pLines = new LineSegment[1];
  417.       if (!lines->m_pLines)
  418.       {
  419.          lines->m_nLines = 0;
  420.       }
  421.       else
  422.       {
  423.          lines->m_pLines->start.x = points[1].x;
  424.          lines->m_pLines->start.y = points[1].y;
  425.          lines->m_pLines->finish.x = points[2].x;
  426.          lines->m_pLines->finish.y = points[2].y;
  427.       }
  428.    }
  429.         
  430.    HXREGION* tempRGN = HXPolygonRegion( points, 3, WindingRule);
  431.         
  432.    HXCombineRgn(retRGN, retRGN, tempRGN, HX_RGN_AND);
  433.    HXDestroyRegion(tempRGN);
  434.    return retRGN;
  435. }
  437. HXREGION* DiagonalRightDownEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  438. {
  439.    HXREGION* retRGN = HXCreateRectRegion(left, top, right-left, bottom-top);
  440.    HXxPoint points[4];
  441.         
  442.    points[0].x = right;
  443.    points[0].y = top;
  444.    points[1].x = right - ((right - left) * completeness * 2)/ 1000;
  445.    points[1].y = top;
  446.    points[2].x = right;
  447.    points[2].y = top + ((bottom - top) * completeness * 2)/ 1000;
  448.         
  449.    if (lines)
  450.    {
  451.       lines->m_nLines = 1;
  452.       lines->m_pLines = new LineSegment[1];
  454.       if (!lines->m_pLines)
  455.       {
  456.          lines->m_nLines = 0;
  457.       }
  458.       else
  459.       {
  460.          lines->m_pLines->start.x = points[1].x;
  461.          lines->m_pLines->start.y = points[1].y;
  462.          lines->m_pLines->finish.x = points[2].x;
  463.          lines->m_pLines->finish.y = points[2].y;
  464.       }
  465.    }
  466.         
  467.    HXREGION* tempRGN = HXPolygonRegion( points, 3, WindingRule);
  468.         
  469.    HXCombineRgn(retRGN, retRGN, tempRGN, HX_RGN_AND);
  470.    HXDestroyRegion(tempRGN);
  471.    return retRGN;
  472. }
  474. HXREGION* HalfBowTieEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  475. {
  476.    HXREGION* retRGN = NULL;
  477.    HXxPoint points[5];
  479.    if (completeness < 500)
  480.    {
  481.       points[0].x = left;
  482.       points[0].y = top;
  483.       points[1].x = (int) ((right + left) / 2 - ((double)(right - left)) * (double)completeness / 1000.0);
  484.       points[1].y = top;
  485.       points[2].x = points[1].x + (right + left) / 2;
  486.       points[2].y = (top + bottom) / 2;
  487.       points[3].x = points[1].x;
  488.       points[3].y = bottom;
  489.       points[4].x = left;
  490.       points[4].y = bottom;
  492.       if (lines)
  493.       {
  494.          lines->m_nLines = 2;
  495.          lines->m_pLines = new LineSegment[2];
  497.          if (!lines->m_pLines)
  498.          {
  499.             lines->m_nLines = 0;
  500.          }
  501.          else
  502.          {
  503.             lines->m_pLines[0].start.x = points[1].x;
  504.             lines->m_pLines[0].start.y = points[1].y;
  505.             lines->m_pLines[0].finish.x = points[2].x;
  506.             lines->m_pLines[0].finish.y = points[2].y;
  507.             lines->m_pLines[1].start.x = points[2].x;
  508.             lines->m_pLines[1].start.y = points[2].y;
  509.             lines->m_pLines[1].finish.x = points[3].x;
  510.             lines->m_pLines[1].finish.y = points[3].y;
  511.          }
  512.       }
  514.       retRGN = InvertRGN(HXPolygonRegion(points, 5, WindingRule),left, top, right, bottom);
  515.    }
  516.    else
  517.    {
  518.       int vOffset = (int)((bottom - top) / 2 * (double)(completeness - 500) / 500.0);
  520.       points[0].x = left;
  521.       points[0].y = top + vOffset;
  522.       points[1].x = (right + left) / 2 - (int)((left + right) / 2 * (double)(completeness - 500) / 500.0);
  523.       points[1].y = (top + bottom) / 2;
  524.       points[2].x = left;
  525.       points[2].y = bottom - vOffset;
  527.       if (lines)
  528.       {
  529.          lines->m_nLines = 2;
  530.          lines->m_pLines = new LineSegment[2];
  532.          if (!lines->m_pLines)
  533.          {
  534.             lines->m_nLines = 0;
  535.          }
  536.          else
  537.          {
  538.             lines->m_pLines[0].start.x = points[0].x;
  539.             lines->m_pLines[0].start.y = points[0].y;
  540.             lines->m_pLines[0].finish.x = points[1].x;
  541.             lines->m_pLines[0].finish.y = points[1].y;
  542.             lines->m_pLines[1].start.x = points[1].x;
  543.             lines->m_pLines[1].start.y = points[1].y;
  544.             lines->m_pLines[1].finish.x = points[2].x;
  545.             lines->m_pLines[1].finish.y = points[2].y;
  546.          }
  547.       }
  549.       retRGN = InvertRGN(HXPolygonRegion(points, 3, WindingRule),left, top, right, bottom);
  550.    }
  552.    return retRGN;
  553. }
  555. HXREGION* VerticalBowTieEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  556. {
  557.    HXREGION* retRGN = HalfBowTieEdgeWipe(left, top, right, bottom, completeness,  NULL);
  558.    HXREGION* tempRGN = MirrorVertical(HalfBowTieEdgeWipe(left, top, right, bottom, completeness,lines),(left + right) / 2);
  559.    HXCombineRgn(retRGN, retRGN, tempRGN, HX_RGN_AND);
  560.    HXDestroyRegion(tempRGN);
  562.    if (lines)
  563.    {
  564.       tranLines tmpLines;
  565.       tmpLines += *lines;
  566.       MirrorVertical(&tmpLines,(left + right) / 2);
  567.       *lines += tmpLines;
  568.    }
  569.    return retRGN;
  570. }
  572. HXREGION* HorizontalBowTieEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  573. {
  574.    HXREGION* retRGN = InvertRGN(VerticalBowTieEdgeWipe(left, top, right, bottom, 1000 - completeness,lines), left, top, right, bottom);
  576.    if (lines && lines->m_nLines == 4)
  577.    {
  578.       MirrorHorizontal(lines,(top + bottom) / 2);
  579.       lines->m_pLines[0].Clip(left,top,(right + left) / 2, bottom);
  580.       lines->m_pLines[1].Clip(left,top,(right + left) / 2, bottom);
  581.       lines->m_pLines[2].Clip((right + left) / 2,top,right, bottom);
  582.       lines->m_pLines[3].Clip((right + left) / 2,top,right, bottom);
  583.    }
  585.    return retRGN;
  586. }
  588. HXREGION* DiagonaLeftOutEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  589. {
  590.    HXxPoint points[6];
  591.         
  592.    points[0].x = (int) (right - ((double)(right - left)) * ((double)completeness / 1000.0));
  593.    points[0].y = top;
  594.    points[1].x = right;
  595.    points[1].y = top;
  596.    points[2].x = right;
  597.    points[2].y = (int) (top + ((double)(bottom - top)) * ((double)completeness/ 1000.0));
  598.    points[3].x = (int) (left + ((double)(right - left)) * ((double)completeness/ 1000.0));
  599.    points[3].y = bottom;
  600.    points[4].x = left;
  601.    points[4].y = bottom;
  602.    points[5].x = left;
  603.    points[5].y = (int) (bottom - ((double)(bottom - top)) * ((double)completeness/ 1000.0));
  604.         
  605.    if (lines)
  606.    {
  607.       lines->m_nLines = 2;
  608.       lines->m_pLines = new LineSegment[2];
  610.       if (!lines->m_pLines)
  611.       {
  612.          lines->m_nLines = 0;
  613.       }
  614.       else
  615.       {
  616.          lines->m_pLines[0].start.x = points[0].x;
  617.          lines->m_pLines[0].start.y = points[0].y;
  618.          lines->m_pLines[0].finish.x = points[5].x;
  619.          lines->m_pLines[0].finish.y = points[5].y;
  620.          lines->m_pLines[1].start.x = points[2].x;
  621.          lines->m_pLines[1].start.y = points[2].y;
  622.          lines->m_pLines[1].finish.x = points[3].x;
  623.          lines->m_pLines[1].finish.y = points[3].y;
  624.       }
  625.    }
  627.    return HXPolygonRegion(points, 6, WindingRule);
  628. }
  631. HXREGION* DiagonaRightOutEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  632. {
  633.    HXREGION* retRGN = DiagonaLeftOutEdgeWipe(left,top,right,bottom,completeness,lines);
  634.    if (lines)
  635.       MirrorVertical(lines,(right - left) / 2);
  637.    return MirrorVertical(retRGN,(right - left) / 2);
  638. }
  640. HXREGION* DiagonaCrossEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  641. {
  642.    LineSegment ls;
  643.    HXxPoint p[16];
  645.    int xOff = int(double(right - left) / 2000.0 * completeness);
  646.    int yOff = int(double(bottom - top) / 2000.0 * completeness);
  647.    int midX = (right + left) / 2;
  648.    int midY = (bottom + top) / 2;
  650.    p[0].x = left + xOff;
  651.    p[0].y = top;
  652.    p[1].x = midX;
  653.    p[1].y = midY - yOff;
  654.    p[2].x = right - xOff;
  655.    p[2].y = top;
  657.    p[3].x = right;
  658.    p[3].y = top;
  660.    if (lines)
  661.    {
  662.       ls.start.x = p[0].x;
  663.       ls.start.y = p[0].y;
  664.       ls.finish.x = p[1].x;
  665.       ls.finish.y = p[1].y;
  666.       *lines += ls;
  667.       ls.start.x = p[2].x;
  668.       ls.start.y = p[2].y;
  669.       ls.finish.x = p[1].x;
  670.       ls.finish.y = p[1].y;
  671.       *lines += ls;
  672.    }
  674.    p[4].x = right;
  675.    p[4].y = top + yOff;
  676.    p[5].x = midX + xOff;
  677.    p[5].y = midY;
  678.    p[6].x = right;
  679.    p[6].y = bottom - yOff;
  681.    p[7].x = right;
  682.    p[7].y = bottom;
  684.    if (lines)
  685.    {
  686.       ls.start.x = p[4].x;
  687.       ls.start.y = p[4].y;
  688.       ls.finish.x = p[5].x;
  689.       ls.finish.y = p[5].y;
  690.       *lines += ls;
  691.       ls.start.x = p[6].x;
  692.       ls.start.y = p[6].y;
  693.       ls.finish.x = p[5].x;
  694.       ls.finish.y = p[5].y;
  695.       *lines += ls;
  696.    }
  697.         
  698.    p[8].x = right - xOff;
  699.    p[8].y = bottom;
  700.    p[9].x = midX;
  701.    p[9].y = midY + yOff;
  702.    p[10].x = left + xOff;
  703.    p[10].y = bottom;
  705.    p[11].x = left;
  706.    p[11].y = bottom;
  708.    if (lines)
  709.    {
  710.       ls.start.x = p[8].x;
  711.       ls.start.y = p[8].y;
  712.       ls.finish.x = p[9].x;
  713.       ls.finish.y = p[9].y;
  714.       *lines += ls;
  715.       ls.start.x = p[10].x;
  716.       ls.start.y = p[10].y;
  717.       ls.finish.x = p[9].x;
  718.       ls.finish.y = p[9].y;
  719.       *lines += ls;
  720.    }
  722.    p[12].x = left;
  723.    p[12].y = bottom - yOff;
  724.    p[13].x = midX - xOff;
  725.    p[13].y = midY;
  726.    p[14].x = left;
  727.    p[14].y = top + yOff;
  729.    p[15].x = left;
  730.    p[15].y = top;
  732.    if (lines)
  733.    {
  734.       ls.start.x = p[12].x;
  735.       ls.start.y = p[12].y;
  736.       ls.finish.x = p[13].x;
  737.       ls.finish.y = p[13].y;
  738.       *lines += ls;
  739.       ls.start.x = p[14].x;
  740.       ls.start.y = p[14].y;
  741.       ls.finish.x = p[13].x;
  742.       ls.finish.y = p[13].y;
  743.       *lines += ls;
  744.    }
  745.         
  746.    return HXPolygonRegion(p, 16, WindingRule);
  747. }
  749. HXREGION* DiagonalBoxEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  750. {
  751.    tranLines* tmpLines = NULL;
  752.    if (lines)
  753.       tmpLines = new tranLines;
  755.    HXREGION* retRGN = DiamondIris(left, top, right, bottom, completeness/2+500,lines);
  756.    HXREGION* rgn1 = DiamondIris(left, top, right, bottom, 500 - completeness/2,tmpLines);
  757.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_XOR);
  758.    HXDestroyRegion(rgn1);
  760.    if (lines)
  761.    {
  762.       *lines += *tmpLines;
  763.       delete tmpLines;
  764.    }
  765.         
  766.    return retRGN;
  767. }
  770. HXREGION* FilledVEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  771. {
  772.    HXxPoint points[3];
  773.         
  774.    points[0].x = (int) ((right+left)/2 + ((double)(right - left)) * (  (double)completeness/ 1000.0));
  775.    points[0].y = top;
  776.    points[1].x = (int) ((right+left)/2 - ((double)(right - left)) * (  (double)completeness/ 1000.0));
  777.    points[1].y = top;
  778.    points[2].x = (right+left)/2;
  779.    points[2].y = (int) (top + ((double)(bottom - top)) * 2.0  * ( (double)completeness/ 1000.0));
  780.         
  781.    if (lines)
  782.    {
  783.       lines->m_nLines = 2;
  784.       lines->m_pLines = new LineSegment[2];
  786.       if (!lines->m_pLines)
  787.       {
  788.          lines->m_nLines = 0;
  789.       }
  790.       else
  791.       {
  792.          lines->m_pLines[0].start.x = points[0].x;
  793.          lines->m_pLines[0].start.y = points[0].y;
  794.          lines->m_pLines[0].finish.x = points[2].x;
  795.          lines->m_pLines[0].finish.y = points[2].y;
  796.          lines->m_pLines[1].start.x = points[1].x;
  797.          lines->m_pLines[1].start.y = points[1].y;
  798.          lines->m_pLines[1].finish.x = points[2].x;
  799.          lines->m_pLines[1].finish.y = points[2].y;
  800.       }
  801.    }
  803.    return HXPolygonRegion( points, 3, WindingRule);
  804. }
  806. HXREGION* FilledVRightEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  807. {
  808.    HXxPoint points[3];
  809.         
  810.    points[0].x = right; 
  811.    points[0].y = (int) ((bottom+top)/2 + ((double)(bottom - top)) * (  (double)completeness/ 1000.0));
  812.    points[1].x = right; 
  813.    points[1].y = (int) ((bottom+top)/2 - ((double)(bottom - top)) * (  (double)completeness/ 1000.0));
  814.    points[2].x = (int) (right - ((double)(right - top)) * 2.0  * ( (double)completeness/ 1000.0));
  815.    points[2].y = (bottom+top)/2;
  816.         
  817.    if (lines)
  818.    {
  819.       lines->m_nLines = 2;
  820.       lines->m_pLines = new LineSegment[2];
  822.       if (!lines->m_pLines)
  823.       {
  824.          lines->m_nLines = 0;
  825.       }
  826.       else
  827.       {
  828.          lines->m_pLines[0].start.x = points[0].x;
  829.          lines->m_pLines[0].start.y = points[0].y;
  830.          lines->m_pLines[0].finish.x = points[2].x;
  831.          lines->m_pLines[0].finish.y = points[2].y;
  832.          lines->m_pLines[1].start.x = points[1].x;
  833.          lines->m_pLines[1].start.y = points[1].y;
  834.          lines->m_pLines[1].finish.x = points[2].x;
  835.          lines->m_pLines[1].finish.y = points[2].y;
  836.       }
  837.    }
  839.    return HXPolygonRegion( points, 3, WindingRule);
  840. }
  842. HXREGION* FilledVBottomEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  843. {
  844.    HXREGION* retRgn = FilledVEdgeWipe(left,top,right,bottom,completeness,lines);
  845.    if (lines)
  846.       MirrorHorizontal(lines,(top + bottom) / 2);
  848.    return MirrorHorizontal(retRgn,(top + bottom) / 2);
  849. }
  851. HXREGION* FilledVLeftEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  852. {
  853.    HXREGION* retRgn = FilledVRightEdgeWipe(left,top,right,bottom,completeness,lines);
  854.    if (lines)
  855.       MirrorVertical(lines,(left + right) / 2);
  857.    return MirrorVertical(retRgn,(left + right) / 2);
  858. }
  860. HXREGION* HollowVEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  861. {
  862.    tranLines* tmp = NULL;
  864.    if (lines)
  865.       tmp = new tranLines;
  867.    HXREGION* retRGN = FilledVEdgeWipe(left, top, right, bottom, 500+ completeness/2,lines);
  868.    HXREGION* rgn1 = FilledVEdgeWipe(left, top, right, bottom, 500 - completeness/2,tmp);
  870.    if (lines)
  871.    {
  872.       *lines += *tmp;
  873.       delete tmp;
  874.    }
  875.         
  876.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_XOR);
  877.    HXDestroyRegion(rgn1);
  878.         
  879.    return retRGN;
  880. }
  882. HXREGION* HollowVRightEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  883. {
  884.    tranLines* tmp = NULL;
  886.    if (lines)
  887.       tmp = new tranLines;
  889.    HXREGION* retRGN = FilledVRightEdgeWipe(left, top, right, bottom, 500+ completeness/2,lines);
  890.    HXREGION* rgn1 = FilledVRightEdgeWipe(left, top, right, bottom, 500 - completeness/2,tmp);
  891.         
  892.    if (lines)
  893.    {
  894.       *lines += *tmp;
  895.       delete tmp;
  896.    }
  897.         
  898.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_XOR);
  899.    HXDestroyRegion(rgn1);
  900.         
  901.    return retRGN;
  902. }
  904. HXREGION* HollowVLeftEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  905. {
  906.    HXREGION* retRgn = HollowVRightEdgeWipe(left,top,right,bottom,completeness,lines);
  907.    if (lines)
  908.       MirrorVertical(lines,(left + right) / 2);
  910.    return MirrorVertical(retRgn,(left + right) / 2);
  911. }
  913. HXREGION* HollowVBottomEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  914. {
  915.    HXREGION* retRgn = HollowVEdgeWipe(left,top,right,bottom,completeness,lines);
  916.    if (lines)
  917.       MirrorHorizontal(lines,(top + bottom) / 2);
  919.    return MirrorHorizontal(retRgn,(top + bottom) / 2);
  920. }
  922. HXREGION* VerticalZigZagEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  923. {
  924.    int width = right - left;
  925.         
  926.    if (!width)
  927.       ++width;
  928.         
  929.    HXxPoint points[13];
  930.    // this is the width of the zigzag portion
  931.    int zigzag = (int) ((float)(bottom - top + 1) / 10.0+.5);
  932.    int tmpCompleteness = (int) ((float)completeness * (float)(right - left + zigzag + 1) / (float)width+.5);
  933.         
  934.    points[0].x = left - zigzag;
  935.    points[0].y = top;
  936.    points[1].x = left + (width * tmpCompleteness) / 1000 - zigzag;
  937.    points[1].y = top;
  938.         
  939.    for(int i = 1; i< 11; i++)
  940.    {
  941.       points[i+1].x = left + (width * tmpCompleteness) / 1000 - !(i & 1) * zigzag;
  942.       points[i+1].y = top + zigzag * i;
  943.    }
  944.         
  945.    points[12].x = left-zigzag;
  946.    points[12].y = bottom;
  947.         
  948.    if (lines)
  949.    {
  950.       lines->m_nLines = 10;
  951.       lines->m_pLines = new LineSegment[10];
  953.       if (!lines->m_pLines)
  954.       {
  955.          lines->m_nLines = 0;
  956.       }
  957.       else
  958.       {
  959.          for(int i = 1; i < 11; i++)
  960.          {
  961.             lines->m_pLines[i-1].start.x = points[i].x;
  962.             lines->m_pLines[i-1].start.y = points[i].y;
  963.             lines->m_pLines[i-1].finish.x = points[i + 1].x;
  964.             lines->m_pLines[i-1].finish.y = points[i + 1].y;
  965.          }
  966.       }
  967.    }
  968.         
  969.    return HXPolygonRegion( points, 13, WindingRule);
  970. }
  972. HXREGION* HorizontalZigZagEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  973. {
  974.    // this is the height of the zigzag portion
  975.    int height = bottom - top;
  976.         
  977.    if (!height)
  978.       ++height;
  979.         
  980.    int zigzag = (int)(((float)right - (float)left) / 10.0 +.5);
  981.    int tmpCompleteness = completeness * (bottom - top + zigzag + 1) / height;
  982.    int worknow = (int)(((float)height * (float)tmpCompleteness) / 1000.0 +.5);
  983.    
  984.    HXxPoint points[13];
  985.         
  986.    points[0].x = left;
  987.    points[0].y = top - zigzag;
  988.    points[1].x = left;
  989.    points[1].y = top  + worknow - zigzag;
  990.         
  991.    for(int i = 1; i< 11; i++)
  992.    {
  993.       points[i+1].y = top + worknow - !(i & 1) * zigzag;
  994.       points[i+1].x = left + zigzag * i ;
  995.    }
  996.         
  997.    points[12].x = right;
  998.    points[12].y = top  - zigzag;
  999.         
  1000.    if (lines)
  1001.    {
  1002.       lines->m_nLines = 10;
  1003.       lines->m_pLines = new LineSegment[10];
  1005.       if (!lines->m_pLines)
  1006.       {
  1007.          lines->m_nLines = 0;
  1008.       }
  1009.       else
  1010.       {
  1011.          for(int i = 1; i < 11; i++)
  1012.          {
  1013.             lines->m_pLines[i-1].start.x = points[i].x;
  1014.             lines->m_pLines[i-1].start.y = points[i].y;
  1015.             lines->m_pLines[i-1].finish.x = points[i + 1].x;
  1016.             lines->m_pLines[i-1].finish.y = points[i + 1].y;
  1017.          }
  1018.       }
  1019.    }
  1020.         
  1021.    return HXPolygonRegion( points, 13, WindingRule);
  1022. }
  1025. HXREGION* HorizontalBarnZigZagEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1026. {
  1027.    tranLines* tmp = NULL;
  1029.    if (lines)
  1030.       tmp = new tranLines;
  1032.    HXREGION* retRGN = HorizontalZigZagEdgeWipe(left, top, right, bottom, (int) (500 - (double)completeness/2),lines);
  1033.    HXREGION* rgn1 = HorizontalZigZagEdgeWipe(left, top, right, bottom, 500 + completeness/2,tmp);
  1034.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_XOR);
  1035.    HXDestroyRegion(rgn1);
  1037.    if (lines)
  1038.    {
  1039.       *lines += *tmp;
  1040.       delete tmp;
  1041.    }
  1043.    return retRGN;
  1044. }
  1046. HXREGION* VerticalBarnZigZagEdgeWipe(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1047. {
  1048.    tranLines* tmp = NULL;
  1050.    if (lines)
  1051.       tmp = new tranLines;
  1053.    HXREGION* retRGN = VerticalZigZagEdgeWipe(left, top, right, bottom, (int) (500 - (double)completeness/2),lines);
  1054.    HXREGION* rgn1 = VerticalZigZagEdgeWipe(left, top, right, bottom, 500 + completeness/2,tmp);
  1055.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_XOR);
  1056.    HXDestroyRegion(rgn1);
  1058.    if (lines)
  1059.    {
  1060.       *lines += *tmp;
  1061.       delete tmp;
  1062.    }
  1064.    return retRGN;
  1065. }
  1067. HXREGION* InternalRotatingTopRadial(int left, int top, int right, int bottom, int completeness = NULL, tranLines* lines = NULL)
  1068. {
  1069.    HXxPoint points[8];
  1070.         
  1071.    points[0].x = (left+right)/2;
  1072.    points[0].y = (top+bottom)/2;
  1073.    points[1].x = points[0].x; //(left+right)/2;
  1074.    points[1].y = top;
  1076.    int count = 2;
  1077.    for(int temp = completeness; temp >= 125; temp-=250)
  1078.    {
  1079.       points[count].x = count < 4 ? right : left;
  1080.       points[count].y = (count>2) && (count<5) ? bottom : top;
  1081.       count++;
  1082.    }
  1083.         
  1084.    double r = max(right - left, bottom - top);
  1085.    r*=2.0;
  1086.         
  1087.    double angle = ((double)completeness/1000.0) * PI * 2.0;
  1088.    points[count].x = (left+right)/2 + (int) (r * sin(angle));
  1089.    points[count].y = (top+bottom)/2 - (int) (r * cos(angle));
  1090.    count++;
  1091.         
  1092.    HXREGION* retRGN  = HXPolygonRegion( points, count, WindingRule);
  1094.    if (lines)
  1095.    {
  1096.       lines->m_nLines = 1;
  1097.       lines->m_pLines = new LineSegment[1];
  1098.       lines->m_pLines->start.x = points[0].x;
  1099.       lines->m_pLines->start.y = points[0].y;
  1100.       lines->m_pLines->finish.x = points[count-1].x;
  1101.       lines->m_pLines->finish.y = points[count-1].y;
  1102.    }
  1103.         
  1104.    return retRGN;
  1105. }
  1107. HXREGION* RotatingTopRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1108. {
  1109.    HXREGION* retRGN = InternalRotatingTopRadial(left, top, right, bottom, completeness, lines);
  1110.    if (lines)
  1111.    {
  1112.       LineSegment ls;
  1113.       ls.start.x = (left + right) / 2;
  1114.       ls.start.y = (top + bottom) / 2;
  1115.       ls.finish.x = ls.start.x;
  1116.       ls.finish.y = top;
  1117.       *lines += ls;
  1118.    }
  1120.    return retRGN;
  1121. }
  1123. HXREGION* InternalRotatingRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines = NULL)
  1124. {
  1125.    HXREGION* retRGN = InternalRotatingTopRadial(left, top, right, bottom, (completeness+250)> 1000 ? 1000: completeness+250,lines);
  1126.    HXREGION* rgn1 = InternalRotatingTopRadial(left, top, right, bottom, 250);
  1127.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_DIFF);
  1128.    HXDestroyRegion(rgn1);
  1129.         
  1130.    if (completeness > 750)
  1131.    {
  1132.       if (lines)
  1133.       {
  1134.          lines->Destroy(); // need to remove the ones we put in by the 1st call to IRTR()
  1135.       }
  1137.       HXREGION* rgn1 = InternalRotatingTopRadial(left, top, right, bottom, completeness - 750,  lines);
  1138.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1139.       HXDestroyRegion(rgn1);
  1140.    }
  1141.         
  1142.    return retRGN;
  1143. }
  1145. HXREGION* RotatingRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1146. {
  1147.    HXREGION* retRGN = InternalRotatingRightRadial(left, top, right, bottom, completeness,lines);
  1149.    if (lines)
  1150.    {
  1151.       LineSegment ls;
  1152.       ls.start.x = (left + right) / 2;
  1153.       ls.start.y = (top + bottom) / 2;
  1154.       ls.finish.x = right;
  1155.       ls.finish.y = ls.start.y;
  1156.       *lines += ls;
  1157.    }
  1158.    return retRGN;
  1159. }
  1161. HXREGION* InternalRotatingBottomRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines = NULL)
  1162. {
  1163.    HXREGION* retRGN = InternalRotatingTopRadial(left, top, right, bottom, (completeness+500)> 1000 ? 1000: completeness+500, lines);
  1164.    HXREGION* rgn1 = InternalRotatingTopRadial(left, top, right, bottom, 500);
  1165.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_DIFF);
  1166.    HXDestroyRegion(rgn1);
  1167.         
  1168.    if (completeness > 500)
  1169.    {
  1170.       if (lines)
  1171.       {
  1172.          lines->Destroy(); // need to remove the ones we put in by the 1st call to IRTR()
  1173.       }
  1175.       HXREGION* rgn1 = InternalRotatingTopRadial(left, top, right, bottom, completeness - 500, lines);
  1176.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1177.       HXDestroyRegion(rgn1);
  1178.    }
  1179.         
  1180.    return retRGN;
  1181. }
  1183. HXREGION* RotatingBottomRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1184. {
  1185.    HXREGION* retRGN = InternalRotatingBottomRadial(left, top, right, bottom, completeness,lines);
  1187.    if (lines)
  1188.    {
  1189.       LineSegment ls;
  1190.       ls.start.x = (left + right) / 2;
  1191.       ls.start.y = (top + bottom) / 2;
  1192.       ls.finish.x = ls.start.x;
  1193.       ls.finish.y = bottom;
  1194.       *lines += ls;
  1195.    }
  1196.    return retRGN;
  1197. }
  1199. HXREGION* InternalRotatingLeftRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines = NULL)
  1200. {
  1201.    HXREGION* retRGN = InternalRotatingTopRadial(left, top, right, bottom, (completeness+750)> 1000 ? 1000: completeness+750, lines);
  1202.    HXREGION* rgn1 = InternalRotatingTopRadial(left, top, right, bottom, 750);
  1203.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_DIFF);
  1204.    HXDestroyRegion(rgn1);
  1205.         
  1206.    if (completeness > 250)
  1207.    {
  1208.       if (lines)
  1209.       {
  1210.          lines->Destroy(); // need to remove the ones we put in by the 1st call to IRTR()
  1211.       }
  1213.       HXREGION* rgn1 = InternalRotatingTopRadial(left, top, right, bottom, completeness - 250, lines);
  1214.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1215.       HXDestroyRegion(rgn1);
  1216.    }
  1217.         
  1218.    return retRGN;
  1219. }
  1221. HXREGION* RotatingLeftRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1222. {
  1223.    HXREGION* retRGN = InternalRotatingLeftRadial(left, top, right, bottom, completeness,lines);
  1225.    if (lines)
  1226.    {
  1227.       LineSegment ls;
  1228.       ls.start.x = (left + right) / 2;
  1229.       ls.start.y = (top + bottom) / 2;
  1230.       ls.finish.x = left;
  1231.       ls.finish.y = ls.start.y;
  1232.       *lines += ls;
  1233.    }
  1234.    return retRGN;
  1235. }
  1237. HXREGION* RotatingTopBottomRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1238. {
  1239.    tranLines* tmpLines = NULL;
  1241.    if (lines)
  1242.       tmpLines = new tranLines;
  1244.    HXREGION* rgn1 = InternalRotatingTopRadial(left, top, right, bottom, completeness/2, lines);
  1245.    HXREGION* retRGN = InternalRotatingBottomRadial(left, top, right, bottom, completeness/2, tmpLines);
  1247.    if (lines)
  1248.    {
  1249.       *lines += *tmpLines;
  1250.       delete tmpLines;
  1251.       LineSegment ls;
  1252.       ls.start.x = (left + right) / 2;
  1253.       ls.start.y = top;
  1254.       ls.finish.x = ls.start.x;
  1255.       ls.finish.y = bottom;
  1256.       *lines += ls;
  1257.    }
  1258.         
  1259.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1260.    HXDestroyRegion(rgn1);
  1261.    return retRGN;
  1262. }
  1264. HXREGION* RotatingLeftRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1265. {
  1266.    tranLines* tmpLines = NULL;
  1268.    if (lines)
  1269.       tmpLines = new tranLines;
  1271.    HXREGION* rgn1 = InternalRotatingLeftRadial(left, top, right, bottom, completeness/2,  lines);
  1272.    HXREGION* retRGN = InternalRotatingRightRadial(left, top, right, bottom, completeness/2,  tmpLines);
  1273.         
  1274.    if (lines)
  1275.    {
  1276.       *lines += *tmpLines;
  1277.       delete tmpLines;
  1278.       LineSegment ls;
  1279.       ls.start.x = left;
  1280.       ls.start.y = (top + bottom) / 2;
  1281.       ls.finish.x = right;
  1282.       ls.finish.y = ls.start.y;
  1283.       *lines += ls;
  1284.    }
  1285.         
  1286.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1287.    HXDestroyRegion(rgn1);
  1288.    return retRGN;
  1289. }
  1291. HXREGION* RotatingQuadrantRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1292. {
  1293.    tranLines* tmpLines = NULL;
  1295.    if (lines)
  1296.       tmpLines = new tranLines;
  1298.    HXREGION* rgn1 = InternalRotatingLeftRadial(left, top, right, bottom, completeness/4,  lines);
  1299.    HXREGION* retRGN = InternalRotatingRightRadial(left, top, right, bottom, completeness/4,  tmpLines);
  1300.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1301.    HXDestroyRegion(rgn1);
  1302.    if (lines)
  1303.    {
  1304.       *lines += *tmpLines;
  1305.       delete tmpLines;
  1306.       tmpLines = new tranLines;
  1307.    }
  1308.         
  1309.    rgn1 = InternalRotatingTopRadial(left, top, right, bottom, completeness/4,  tmpLines);
  1310.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1311.    HXDestroyRegion(rgn1);
  1312.    if (lines)
  1313.    {
  1314.       *lines += *tmpLines;
  1315.       delete tmpLines;
  1316.       tmpLines = new tranLines;
  1317.    }
  1318.         
  1319.    rgn1 = InternalRotatingBottomRadial(left, top, right, bottom, completeness/4,  tmpLines);
  1320.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1321.    HXDestroyRegion(rgn1);
  1322.    if (lines)
  1323.    {
  1324.       *lines += *tmpLines;
  1325.       delete tmpLines;
  1326.       tmpLines = new tranLines;
  1327.       LineSegment ls;
  1328.       ls.start.x = (left + right) / 2;
  1329.       ls.start.y = top;
  1330.       ls.finish.x = ls.start.x;
  1331.       ls.finish.y = bottom;
  1332.       *lines += ls;
  1333.       ls.start.x = left;
  1334.       ls.start.y = (top + bottom) / 2;
  1335.       ls.finish.x = right;
  1336.       ls.finish.y = ls.start.y;
  1337.       *lines += ls;
  1338.    }
  1340.    return retRGN;
  1341. }
  1343. HXREGION* TopBottom180Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1344. {
  1345.    tranLines* tmpLines = NULL;
  1347.    if (lines)
  1348.       tmpLines = new tranLines;
  1350.    HXREGION* retRGN = HXCreateRectRegion(left, top, right-left, bottom-top);
  1351.    HXREGION* rgn1 = InternalRotatingTopRadial(left, top, right, bottom, 1000 - completeness / 2,  lines);
  1352.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_DIFF);
  1353.    HXDestroyRegion(rgn1);
  1354.    HXREGION* ret1 = InternalRotatingTopRadial(left, top, right, bottom, completeness / 2,  tmpLines);
  1355.    HXCombineRgn(retRGN, retRGN, ret1, HX_RGN_OR);
  1356.    HXDestroyRegion(ret1);
  1357.         
  1358.    if (lines)
  1359.    {
  1360.       *lines += *tmpLines;
  1361.       delete tmpLines;
  1362.    }
  1364.    return retRGN;
  1365. }
  1367. HXREGION* RightToLeft180Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1368. {
  1369.    tranLines* tmpLines = NULL;
  1371.    if (lines)
  1372.       tmpLines = new tranLines;
  1374.    HXREGION* retRGN = HXCreateRectRegion(left, top, right-left,bottom-top);
  1375.    HXREGION* rgn1 = InternalRotatingRightRadial(left, top, right, bottom, 1000 - completeness / 2,  lines);
  1376.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_DIFF);
  1377.    HXDestroyRegion(rgn1);
  1378.    HXREGION* ret1 = InternalRotatingRightRadial(left, top, right, bottom, completeness / 2,  tmpLines);
  1379.    HXCombineRgn(retRGN, retRGN, ret1, HX_RGN_OR);
  1380.    HXDestroyRegion(ret1);
  1381.         
  1382.    if (lines)
  1383.    {
  1384.       *lines += *tmpLines;
  1385.       delete tmpLines;
  1386.    }
  1388.    return retRGN;
  1389. }
  1391. HXREGION* topBottom90Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1392. {
  1393.    tranLines* tmpLines = NULL;
  1395.    if (lines)
  1396.       tmpLines = new tranLines;
  1398.    HXREGION* retRGN= InternalRotatingBottomRadial(left, top, right, bottom, 500 - completeness / 4,  lines);
  1399.    HXREGION* rgn1 = InternalRotatingBottomRadial(left, top, right, bottom, 500+ completeness / 4,  tmpLines);
  1400.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_XOR);
  1401.    HXDestroyRegion(rgn1);
  1402.    if (lines)
  1403.    {
  1404.       *lines += *tmpLines;
  1405.       delete tmpLines;
  1406.       tmpLines = new tranLines;
  1407.    }
  1408.         
  1409.    rgn1 = InternalRotatingTopRadial(left, top, right, bottom, 500 - completeness / 4,  tmpLines);
  1410.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_XOR);
  1411.    HXDestroyRegion(rgn1);
  1412.    if (lines)
  1413.    {
  1414.       *lines += *tmpLines;
  1415.       delete tmpLines;
  1416.       tmpLines = new tranLines;
  1417.    }
  1418.         
  1419.    rgn1 = InternalRotatingTopRadial(left, top, right, bottom, 500+ completeness / 4,  tmpLines);
  1420.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_XOR);
  1421.    HXDestroyRegion(rgn1);
  1422.    if (lines)
  1423.    {
  1424.       *lines += *tmpLines;
  1425.       delete tmpLines;
  1426.       tmpLines = new tranLines;
  1427.    }
  1428.         
  1429.    return retRGN;
  1430. }
  1433. HXREGION* RightToLeft90Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1434. {
  1435.    tranLines* tmpLines = NULL;
  1437.    if (lines)
  1438.       tmpLines = new tranLines;
  1440.    HXREGION* retRGN= InternalRotatingBottomRadial(left, top, right, bottom, 250 - completeness / 4,  lines);
  1441.    HXREGION* rgn1 = InternalRotatingBottomRadial(left, top, right, bottom, 250+ completeness / 4,  tmpLines);
  1442.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_XOR);
  1443.    HXDestroyRegion(rgn1);
  1444.    if (lines)
  1445.    {
  1446.       *lines += *tmpLines;
  1447.       delete tmpLines;
  1448.       tmpLines = new tranLines;
  1449.    }
  1450.         
  1451.    rgn1 = InternalRotatingTopRadial(left, top, right, bottom, 250 - completeness / 4,  tmpLines);
  1452.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_XOR);
  1453.    HXDestroyRegion(rgn1);
  1454.    if (lines)
  1455.    {
  1456.       *lines += *tmpLines;
  1457.       delete tmpLines;
  1458.       tmpLines = new tranLines;
  1459.    }
  1460.         
  1461.    rgn1 = InternalRotatingTopRadial(left, top, right, bottom, 250+ completeness / 4,  tmpLines);
  1462.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_XOR);
  1463.    HXDestroyRegion(rgn1);
  1464.    if (lines)
  1465.    {
  1466.       *lines += *tmpLines;
  1467.       delete tmpLines;
  1468.       tmpLines = new tranLines;
  1469.    }
  1470.         
  1471.    return retRGN;
  1472. }
  1474. HXREGION* InternalTop180Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines = NULL)
  1475. {
  1476.    return InternalRotatingRightRadial(left, top - (bottom-top), right, bottom, completeness / 2,  lines);
  1477. }
  1479. HXREGION* Top180Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1480. {
  1481.    return InternalTop180Radial(left, top, right, bottom, completeness,  lines);
  1482. }
  1484. HXREGION* InternalRight180Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines = NULL)
  1485. {
  1486.    HXREGION* retRGN = InternalRotatingBottomRadial(left - (right -left), top, right, bottom, completeness / 2,  lines);
  1487.    HXOffsetRegion(retRGN, (right -left), 0);
  1488.    if (lines)
  1489.       lines->Offset(right - left, 0);
  1491.    return retRGN;
  1492. }
  1494. HXREGION* Right180Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1495. {
  1496.    return InternalRight180Radial(left, top, right, bottom, completeness,  lines);
  1497. }
  1499. HXREGION* InternalBottom180Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines = NULL)
  1500. {
  1501.    HXREGION* retRGN = InternalRotatingLeftRadial(left, top - (bottom-top), right, bottom, completeness / 2,  lines);
  1502.    HXOffsetRegion(retRGN, 0, bottom - top);
  1503.    if (lines)
  1504.       lines->Offset(0, bottom - top);
  1506.    return retRGN;
  1507. }
  1509. HXREGION* Bottom180Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1510. {
  1511.    return InternalBottom180Radial(left, top, right, bottom, completeness,  lines);
  1512. }
  1514. HXREGION* InternalLeft180Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines = NULL)
  1515. {
  1516.    return InternalRotatingTopRadial(left - (right -left), top, right, bottom, completeness / 2,  lines);
  1517. }
  1519. HXREGION* Left180Radial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1520. {
  1521.    return InternalLeft180Radial(left, top, right, bottom, completeness,  lines);
  1522. }
  1524. HXREGION* CounterRotatingTopBottomRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1525. {
  1526.    tranLines* tmpLines = NULL;
  1527.    if (lines)
  1528.       tmpLines = new tranLines;
  1530.    HXREGION* retRGN = InternalTop180Radial(left, top, right, bottom, completeness / 2,  lines);
  1531.    HXREGION* rgn1 = InternalBottom180Radial(left, top, right, bottom, completeness / 2,  tmpLines);
  1532.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1533.    HXDestroyRegion(rgn1);
  1535.    if (lines)
  1536.    {
  1537.       *lines += *tmpLines;
  1538.       delete tmpLines;
  1539.    }
  1541.    return retRGN;
  1542. }
  1544. HXREGION* CounterRotatingLeftRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1545. {
  1546.    tranLines* tmpLines = NULL;
  1547.    if (lines)
  1548.       tmpLines = new tranLines;
  1550.    HXREGION* retRGN = InternalLeft180Radial(left, top, right, bottom, completeness / 2,  lines);
  1551.    HXREGION* rgn1 = InternalRight180Radial(left, top, right, bottom, completeness / 2,  tmpLines);
  1552.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1553.    HXDestroyRegion(rgn1);
  1555.    if (lines)
  1556.    {
  1557.       *lines += *tmpLines;
  1558.       delete tmpLines;
  1559.    }
  1561.    return retRGN;
  1562. }
  1564. HXREGION* DoubleRotatingTopBottomRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1565. {
  1566.    tranLines* tmpLines = NULL;
  1567.    if (lines)
  1568.       tmpLines = new tranLines;
  1570.    HXREGION* retRGN       = InternalBottom180Radial(left, top, right, bottom, 1000 - completeness,lines);
  1571.    HXREGION* rgn1 = HXCreateRectRegion(left, top, right-left,bottom-top);
  1572.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_DIFF);
  1573.    HXDestroyRegion(rgn1);
  1574.    rgn1 = InternalTop180Radial(left, top, right, bottom, completeness, tmpLines);
  1575.    if (completeness > 500)
  1576.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_AND);
  1577.    else
  1578.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1580.    HXDestroyRegion(rgn1);
  1581.    if (lines)
  1582.    {
  1583.       lines->Clip(left,(top + bottom) / 2,right,bottom);
  1584.       tmpLines->Clip(left,top,right,(top + bottom) / 2);
  1585.       *lines += *tmpLines;
  1586.       delete tmpLines;
  1587.    }
  1588.    return retRGN;
  1589. }
  1591. HXREGION* DoubleRotatingLeftRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1592. {
  1593.    tranLines* tmpLines = NULL;
  1594.    if (lines)
  1595.       tmpLines = new tranLines;
  1598.    HXREGION* retRGN = InternalRight180Radial(left, top, right, bottom, 1000 - completeness,  lines);
  1599.    HXREGION* rgn1 = HXCreateRectRegion(left, top, right-left,bottom-top);
  1600.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_DIFF);
  1601.    HXDestroyRegion(rgn1);
  1602.    rgn1 = InternalLeft180Radial(left, top, right, bottom, completeness,  tmpLines);
  1603.    if (completeness > 500)
  1604.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_AND);
  1605.    else
  1606.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1608.    HXDestroyRegion(rgn1);
  1609.    if (lines)
  1610.    {
  1611.       lines->Clip((left + right) / 2,top,right,bottom);
  1612.       tmpLines->Clip(left,top,(left + right) / 2,bottom);
  1613.       *lines += *tmpLines;
  1614.       delete tmpLines;
  1615.    }
  1616.    return retRGN;
  1617. }
  1619. HXREGION* OpenVTopRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1620. {
  1621.    HXREGION* retRgn = MirrorHorizontal(OpenVBottomRadial(left,top,right,bottom,completeness,lines),(top + bottom) / 2);
  1622.    if (lines)
  1623.       MirrorHorizontal(lines,(top + bottom) / 2);
  1625.    return retRgn;
  1626. }
  1628. HXREGION* OpenVRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1629. {
  1630.    HXREGION* retRgn = MirrorVertical(OpenVLeftRadial(left,top,right,bottom,completeness,lines),(left + right) / 2);
  1631.    if (lines)
  1632.       MirrorVertical(lines,(left + right) / 2);
  1634.    return retRgn;
  1635. }
  1637. HXREGION* OpenVBottomRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1638. {
  1639.    tranLines* tmpLines = NULL;
  1640.    if (lines)
  1641.       tmpLines = new tranLines;
  1643.    HXREGION* retRGN = InternalRotatingLeftRadial(left, top - (bottom - top), right, bottom, 250 - completeness/4,  lines);
  1644.    HXOffsetRegion(retRGN, 0, bottom - top);
  1645.    retRGN       = InvertRGN(retRGN, left, top, left + (right - left)/2, bottom);
  1646.    HXREGION* rgn1 = InternalRotatingTopRadial(left, top - (bottom - top), right, bottom, completeness/4,  tmpLines);
  1647.    HXOffsetRegion(rgn1, 0, bottom - top);
  1648.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_OR);
  1649.    HXDestroyRegion(rgn1);
  1651.    if (lines)
  1652.    {
  1653.       *lines += *tmpLines;
  1654.       delete tmpLines;
  1655.       lines->Offset(0, bottom - top);
  1656.    }
  1657.    return retRGN;
  1658. }
  1660. HXREGION* OpenVLeftRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1661. {
  1662.    tranLines* tmpLines = NULL;
  1663.    if (lines)
  1664.       tmpLines = new tranLines;
  1666.    HXREGION* retRGN = InternalRotatingRightRadial(left - (right - left), top, right, bottom, completeness/4,  lines);
  1667.    HXREGION* rgn1 = InternalRotatingTopRadial(left - (right - left), top, right, bottom, 250 - completeness/4,  tmpLines);
  1668.    rgn1 = InvertRGN(rgn1, left, top, right, top + (bottom - top) / 2);
  1669.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_OR);
  1670.    HXDestroyRegion(rgn1);
  1672.    if (lines)
  1673.    {
  1674.       *lines += *tmpLines;
  1675.       delete tmpLines;
  1676.    }
  1677.    return retRGN;
  1678. }
  1680. HXREGION* OpenVTopBottomRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1681. {
  1682.    tranLines* tmpLines = NULL;
  1683.    if (lines)
  1684.       tmpLines = new tranLines;
  1686.    HXREGION* retRGN = OpenVBottomRadial(left, top, right, bottom, completeness,  lines);
  1687.    HXREGION* rgn1  = OpenVTopRadial(left, top, right, bottom, completeness,  tmpLines);
  1688.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_AND);
  1689.    HXDestroyRegion(rgn1);
  1691.    if (lines)
  1692.    {
  1693.       *lines += *tmpLines;
  1694.       delete tmpLines;
  1695.    }
  1696.    return retRGN;
  1697. }
  1699. HXREGION* OpenVLeftRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1700. {
  1701.    tranLines* tmpLines = NULL;
  1702.    if (lines)
  1703.       tmpLines = new tranLines;
  1705.    HXREGION* retRGN = OpenVLeftRadial(left, top, right, bottom, completeness,  lines);
  1706.    HXREGION* rgn1 = OpenVRightRadial(left, top, right, bottom, completeness,  tmpLines);
  1707.    HXCombineRgn(retRGN, rgn1, retRGN, HX_RGN_AND);
  1708.    HXDestroyRegion(rgn1);
  1710.    if (lines)
  1711.    {
  1712.       *lines += *tmpLines;
  1713.       delete tmpLines;
  1714.    }
  1715.    return retRGN;
  1716. }
  1718. HXREGION* RotatingTopLeftRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1719. {
  1720.    HXREGION* retRGN = RotatingRightRadial(left - (right - left), top - (bottom - top), right, bottom, completeness / 4,  lines);
  1722.    if (lines)
  1723.    {
  1724.       //XXXSMJ This is cheap!  Changes to RotatingRightRadial() might break this
  1725.       lines->m_nLines = 1;
  1726.    }
  1727.    return retRGN;
  1728. }
  1730. HXREGION* RotatingBottomLeftRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1731. {
  1732.    HXREGION* retRGN = InvertRGN(RotatingRightRadial(left - (right - left), top, right, bottom +  (bottom - top), 1000 - completeness / 4,  lines), left, top, right, bottom);
  1733.    if (lines)
  1734.    {
  1735.       //XXXSMJ This is cheap!  Changes to RotatingRightRadial() might break this
  1736.       lines->m_nLines = 1;
  1737.    }
  1738.    return retRGN;
  1739. }
  1741. HXREGION* RotatingBottomRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1742. {
  1743.    HXREGION* retRGN = RotatingLeftRadial(left, top, right + (right - left), bottom  + (bottom - top), completeness / 4,  lines);
  1744.    if (lines)
  1745.    {
  1746.       //XXXSMJ This is cheap!  Changes to RotatingLeftRadial() might break this
  1747.       lines->m_nLines = 1;
  1748.    }
  1749.    return retRGN;
  1750. }
  1752. HXREGION* RotatingTopRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1753. {
  1754.    HXREGION* retRGN = InvertRGN(RotatingLeftRadial(left, top - (bottom - top), right + (right - left), bottom, 1000 - completeness / 4,  lines), left, top, right, bottom);
  1755.    if (lines)
  1756.    {
  1757.       //XXXSMJ This is cheap!  Changes to RotatingLeftRadial() might break this
  1758.       lines->m_nLines = 1;
  1759.    }
  1760.    return retRGN;
  1761. }
  1763. HXREGION* RotatingTopLeftBottomRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1764. {
  1765.    LineSegment ls;
  1766.    HXxPoint points[3];
  1767.         
  1768.    points[0].x = left;
  1769.    points[0].y = top;
  1770.    points[1].x = right;
  1771.    points[1].y = (int) (bottom - ((double)(bottom - top)) * ( 1.0 - (double)completeness/ 1000.0));
  1772.    points[2].x = right;
  1773.    points[2].y = top;
  1774.         
  1775.    HXREGION* retRGN = HXPolygonRegion( points, 3, WindingRule);
  1776.    if (lines)
  1777.    {
  1778.       ls.start.x = points[0].x;
  1779.       ls.start.y = points[0].y;
  1780.       ls.finish.x = points[1].x;
  1781.       ls.finish.y = points[1].y;
  1782.       *lines += ls;
  1783.    }
  1784.     
  1785.    points[0].x = right;
  1786.    points[0].y = bottom;
  1787.    points[1].x = left;
  1788.    points[1].y = (int) (bottom - ((double)(bottom - top)) * ((double)completeness/ 1000.0));
  1789.    points[2].x = left;
  1790.    points[2].y = bottom;
  1791.         
  1792.    HXREGION* tempRGN = HXPolygonRegion( points, 3, WindingRule);
  1793.    if (lines)
  1794.    {
  1795.       ls.start.x = points[0].x;
  1796.       ls.start.y = points[0].y;
  1797.       ls.finish.x = points[1].x;
  1798.       ls.finish.y = points[1].y;
  1799.       *lines += ls;
  1800.    }
  1802.    HXCombineRgn(retRGN, retRGN, tempRGN, HX_RGN_OR);
  1803.    HXDestroyRegion(tempRGN);
  1804.         
  1805.    return retRGN;
  1806. }
  1808. HXREGION* RotatingBottomLeftTopRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1809. {
  1810.    LineSegment ls;
  1811.    HXxPoint points[3];
  1812.         
  1813.    points[0].x = left;
  1814.    points[0].y = bottom;
  1815.    points[1].x = int(left + double(right - left) * double(completeness) / 1000.0);
  1816.    points[1].y = top;
  1817.    points[2].x = left;
  1818.    points[2].y = top;
  1819.         
  1820.    HXREGION* retRGN = HXPolygonRegion( points, 3, WindingRule);
  1821.    if (lines)
  1822.    {
  1823.       ls.start.x = points[0].x;
  1824.       ls.start.y = points[0].y;
  1825.       ls.finish.x = points[1].x;
  1826.       ls.finish.y = points[1].y;
  1827.       *lines += ls;
  1828.    }
  1830.     
  1831.    points[0].x = right;
  1832.    points[0].y = top;
  1833.    points[1].x = int(right - double(right - left) * double(completeness) / 1000.0);
  1834.    points[1].y = bottom;
  1835.    points[2].x = right;
  1836.    points[2].y = bottom;
  1837.         
  1838.    HXREGION* tempRGN = HXPolygonRegion( points, 3, WindingRule);
  1839.    if (lines)
  1840.    {
  1841.       ls.start.x = points[0].x;
  1842.       ls.start.y = points[0].y;
  1843.       ls.finish.x = points[1].x;
  1844.       ls.finish.y = points[1].y;
  1845.       *lines += ls;
  1846.    }
  1848.    HXCombineRgn(retRGN, retRGN, tempRGN, HX_RGN_OR);
  1849.    HXDestroyRegion(tempRGN);
  1850.         
  1851.    return retRGN;
  1852. }
  1854. HXREGION* RotatingTopLeftRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1855. {
  1856.    tranLines* tmpLines = NULL;
  1857.    if (lines)
  1858.       tmpLines = new tranLines;
  1860.    HXREGION* retRGN = RotatingTopLeftRadial(left, top, right, bottom, completeness,  lines);
  1861.    HXREGION* rgn1 = RotatingTopRightRadial(left, top, right, bottom, completeness,  tmpLines);
  1862.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_AND);
  1863.    HXDestroyRegion(rgn1);
  1865.    if (lines)
  1866.    {
  1867.       *lines += *tmpLines;
  1868.       delete tmpLines;
  1869.    }
  1871.    return retRGN;
  1872. }
  1874. HXREGION* RotatingLeftTopBottomRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1875. {
  1876.    tranLines* tmpLines = NULL;
  1877.    if (lines)
  1878.       tmpLines = new tranLines;
  1880.    HXREGION* retRGN = RotatingTopLeftRadial(left, top, right, bottom, 1000 - completeness,  lines);
  1881.    HXREGION* rgn1 = RotatingBottomLeftRadial(left, top, right, bottom, 1000 - completeness,  tmpLines);
  1882.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1883.    HXDestroyRegion(rgn1);
  1885.    if (lines)
  1886.    {
  1887.       *lines += *tmpLines;
  1888.       delete tmpLines;
  1889.    }
  1891.    return InvertRGN(retRGN, left, top, right, bottom);
  1892. }
  1894. HXREGION* RotatingBottomLeftRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1895. {
  1896.    HXREGION* retRGN = MirrorHorizontal(RotatingTopLeftRightRadial(left, top, right, bottom, completeness,  lines),(top + bottom) / 2);
  1897.    if (lines)
  1898.       MirrorHorizontal(lines,(top + bottom) / 2);
  1900.    return retRGN;
  1901. }
  1903. HXREGION* RotatingRightTopBottomRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1904. {
  1905.    HXREGION* retRGN = MirrorVertical(RotatingLeftTopBottomRadial(left, top, right, bottom, completeness,  lines),(left + right) / 2);
  1906.    if (lines)
  1907.       MirrorVertical(lines,(left + right) / 2);
  1909.    return retRGN;
  1910. }
  1912. HXREGION* RotatingDoubleCenterRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1913. {
  1914.    tranLines* tmpLines = NULL;
  1915.    if (lines)
  1916.       tmpLines = new tranLines;
  1918.    HXREGION* retRGN = RotatingBottomRadial(left, top, right, bottom, 1000 - completeness,  lines);
  1919.    HXREGION* rgn1 = RotatingTopRadial(left, top, right, bottom, completeness,  tmpLines);
  1920.    rgn1 = InvertRGN(rgn1, left, top, right, bottom);
  1921.    HXOffsetRegion(retRGN,0,-(bottom - top) / 4);
  1922.    HXOffsetRegion(rgn1,0,(bottom - top) / 4);
  1923.    if (completeness > 750)
  1924.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_AND);
  1925.    else
  1926.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1928.    HXDestroyRegion(rgn1);
  1930.    if (lines)
  1931.    {
  1932.       lines->Offset(0,-(bottom - top) / 4);
  1933.       lines->Clip(left,top,right,(top + bottom) / 2);
  1934.       tmpLines->Offset(0,(bottom - top) / 4);
  1935.       tmpLines->Clip(left,(top + bottom) / 2,right,bottom);
  1936.       *lines += *tmpLines;
  1937.       delete tmpLines;
  1938.    }
  1940.    return InvertRGN(retRGN, left, top, right, bottom);
  1941. }
  1943. HXREGION* RotatingDoubleCenterTopRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1944. {
  1945.    tranLines* tmpLines = NULL;
  1946.    if (lines)
  1947.       tmpLines = new tranLines;
  1949.    HXREGION* retRGN = RotatingLeftRadial(left, top, right, bottom, completeness,lines);
  1950.    retRGN  = InvertRGN(retRGN, left, top, right, bottom);
  1951.    HXREGION* rgn1 = RotatingRightRadial(left, top, right, bottom, 1000 - completeness,  tmpLines);
  1952.    HXOffsetRegion(retRGN,(right - left) / 4, 0);
  1953.    HXOffsetRegion(rgn1,-(right - left) / 4, 0);
  1954.    if (completeness > 750)
  1955.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_AND);
  1956.    else
  1957.       HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1959.    HXDestroyRegion(rgn1);
  1961.    if (lines)
  1962.    {
  1963.       lines->Offset((right - left) / 4, 0);
  1964.       lines->Clip((right + left) / 2,top,right,bottom);
  1965.       tmpLines->Offset(-(right - left) / 4, 0);
  1966.       tmpLines->Clip(left,top,(right + left) / 2,bottom);
  1967.       *lines += *tmpLines;
  1968.       delete tmpLines;
  1969.    }
  1971.    return InvertRGN(retRGN, left, top, right, bottom);
  1972. }
  1974. HXREGION* RotatingDoubleCenterTopBottomRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  1975. {
  1976.    tranLines* tmpLines = NULL;
  1977.    if (lines)
  1978.       tmpLines = new tranLines;
  1980.    HXREGION* retRGN = InternalRotatingTopRadial(left, top, right, bottom, completeness / 2,  lines);
  1981.    HXOffsetRegion(retRGN,0,-(bottom - top) / 4);
  1982.    HXREGION* rgn1 = HXCreateRegion();
  1983.    CopyRegion(rgn1,retRGN);
  1984.    MirrorHorizontal(rgn1,(bottom + top) / 2);
  1985.    if (lines)
  1986.    {
  1987.       lines->Offset(0,-(bottom - top) / 4);
  1988.       lines->Clip(left,top,right,(top + bottom) / 2);
  1989.       *tmpLines += *lines;
  1990.       MirrorHorizontal(tmpLines,(bottom + top) / 2);
  1991.       *lines += *tmpLines;
  1992.       tmpLines->Destroy();
  1993.    }
  1994.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1995.    CopyRegion(rgn1,retRGN);
  1996.    MirrorVertical(rgn1,(left + right) / 2);
  1997.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  1998.    HXDestroyRegion(rgn1);
  1999.    if (lines)
  2000.    {
  2001.       *tmpLines += *lines;
  2002.       MirrorVertical(tmpLines,(left + right) / 2);
  2003.       *lines += *tmpLines;
  2004.       delete tmpLines;
  2005.    }
  2006.    return retRGN;
  2007. }
  2010. HXREGION* RotatingDoubleCenterLeftRightRadial(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2011. {
  2012.    tranLines* tmpLines = NULL;
  2013.    if (lines)
  2014.       tmpLines = new tranLines;
  2016.    HXREGION* retRGN = InternalRotatingLeftRadial(left, top, right, bottom, completeness / 2,  lines);
  2017.    HXOffsetRegion(retRGN,-(right + left) / 4, 0);
  2018.    HXREGION* rgn1 = HXCreateRegion();
  2019.    CopyRegion(rgn1,retRGN);
  2020.    MirrorHorizontal(rgn1,(bottom + top) / 2);
  2021.    if (lines)
  2022.    {
  2023.       lines->Offset(-(right + left) / 4, 0);
  2024.       lines->Clip(left,top,(left + right) / 2,bottom);
  2025.       *tmpLines += *lines;
  2026.       MirrorHorizontal(tmpLines,(bottom + top) / 2);
  2027.       *lines += *tmpLines;
  2028.       tmpLines->Destroy();
  2029.    }
  2030.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  2031.    CopyRegion(rgn1,retRGN);
  2032.    MirrorVertical(rgn1,(left + right) / 2);
  2033.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
  2034.    HXDestroyRegion(rgn1);
  2035.    if (lines)
  2036.    {
  2037.       *tmpLines += *lines;
  2038.       MirrorVertical(tmpLines,(left + right) / 2);
  2039.       *lines += *tmpLines;
  2040.       delete tmpLines;
  2041.    }
  2042.    return retRGN;
  2043. }
  2045. HXREGION* DoubleDiagonalBottom(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2046. {
  2047.    if (completeness <= 0)
  2048.       return HXCreateRegion();
  2049.     
  2050.    HXxPoint p[7];
  2051.    tranLines* tmpLines = NULL;
  2053.    GetTopLeftDiagonalCoords(left,top,right,bottom,500 + completeness / 2,p,lines);
  2054.    HXREGION* retRGN = HXPolygonRegion(p, 7, WindingRule);
  2055.    HXREGION* rgn1 = MirrorHorizontal(MirrorVertical(HXPolygonRegion(p, 7, WindingRule),(left + right) / 2),top + (bottom - top) / 2);
  2056.    HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_AND);
  2058.    if (lines)
  2059.    {
  2060.       tmpLines = new tranLines;
  2061.       *tmpLines += *lines;
  2062.       MirrorVertical(tmpLines,(left + right) / 2);
  2063.       MirrorHorizontal(tmpLines,top + (bottom - top) / 2);
  2064.       *lines += *tmpLines;
  2065.    }
  2067.    if (completeness < 120) // deal with slight overlap until the two snakes meet
  2068.    {
  2069.       HXREGION* blank1 = InvertRGN(HXCreateRectRegion(left,bottom - p[3].y,right,p[3].y),left,top,right-left,bottom-top);
  2070.       HXCombineRgn(retRGN, retRGN, blank1, HX_RGN_AND);
  2072.       HXDestroyRegion(blank1);
  2073.    }
  2075.    HXDestroyRegion(rgn1);
  2076.     
  2077.    return retRGN;
  2078. }
  2080. HXREGION* DoubleDiagonalTop(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2081. {
  2082.    HXREGION* retRGN = MirrorVertical(DoubleDiagonalBottom(left, top, right, bottom, completeness,lines),(left + right) / 2);
  2083.    if (lines)
  2084.       MirrorVertical(lines,(left + right) / 2);
  2086.    return retRGN;
  2087. }
  2089. HXREGION* SlideFromLeft(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2090. {
  2091.    if (lines)
  2092.    {
  2093.       lines->m_nLines = 0;
  2094.       HX_VECTOR_DELETE( lines->m_pLines );
  2095.    }
  2096.    return HXCreateRectRegion(left, top, right - left, bottom - top);
  2097. }
  2099. HXREGION* SlideFromTop(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2100. {
  2101.    if (lines)
  2102.    {
  2103.       lines->m_nLines = 0;
  2104.       HX_VECTOR_DELETE( lines->m_pLines );
  2105.    }
  2106.    return HXCreateRectRegion(left, top, right - left, bottom - top);
  2107. }
  2109. HXREGION* SlideFromRight(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2110. {
  2111.    if (lines)
  2112.    {
  2113.       lines->m_nLines = 0;
  2114.       HX_VECTOR_DELETE( lines->m_pLines );
  2115.    }
  2116.    return HXCreateRectRegion(left, top, right - left, bottom - top);
  2117. }
  2119. HXREGION* SlideFromBottom(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2120. {
  2121.    if (lines)
  2122.    {
  2123.       lines->m_nLines = 0;
  2124.       HX_VECTOR_DELETE( lines->m_pLines );
  2125.    }
  2126.    return HXCreateRectRegion(left, top, right - left, bottom - top);
  2127. }
  2129. HXREGION* Crossfade(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2130. {
  2131.    if(lines)
  2132.    {
  2133.       lines->m_nLines = 0;
  2134.       HX_VECTOR_DELETE(lines->m_pLines);
  2135.    }
  2136.    return HXCreateRectRegion(left, top, right - left, bottom - top);
  2137. }
  2139. HXREGION* FadeToColor(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2140. {
  2141.    if (lines)
  2142.    {
  2143.       lines->m_nLines = 0;
  2144.       HX_VECTOR_DELETE( lines->m_pLines );
  2145.    }
  2146.    return HXCreateRectRegion(left, top, right - left, bottom - top);
  2147. }
  2149. HXREGION* FadeFromColor(int left, int top, int right, int bottom, int completeness, tranLines* lines)
  2150. {
  2151.    if (lines)
  2152.    {
  2153.       lines->m_nLines = 0;
  2154.       HX_VECTOR_DELETE( lines->m_pLines );
  2155.    }
  2156.    return HXCreateRectRegion(left, top, right - left, bottom - top);
  2157. }
  2159. #endif //_TRANSITIONS_ON_
  2169. #ifdef _TESTING_TRANITIONS_
  2171. #define FORWARD
  2173. // sloppy, but cheap for this test program
  2174. int z_PaneWidth = 280;
  2175. int z_PaneHeight = 250;
  2178. struct tranMap
  2179. {
  2180.    int in;
  2181.    int type;
  2182.    int subType;
  2183. };
  2185. tranMap theTranMap[200];
  2187. extern tranType     z_TransitionTable[];
  2188. extern int          z_nNumberTransitions;
  2191. HWND    zm_hwnd;
  2192. HWND    zm_comboHWND;
  2193. HWND    zm_displayOuter;
  2194. HWND    zm_displayInner;
  2196. char*   zm_pszWindowClassName = "TestRGNClass";
  2197. char*   zm_pszWindowName = "TestRGNWindow";
  2198. HFONT   zm_theFONT = 0;
  2199. HFONT   zm_theSmallFONT = 0;
  2200. HBITMAP zm_hBitmapOLD= 0;
  2201. HBITMAP zm_hBitmapNEW= 0;
  2202. HBITMAP zm_hScratchSurface= 0;
  2203. HBITMAP zm_oldSurface = 0;
  2204. HBITMAP zm_oldSurface2 = 0;
  2205. HDC     zm_memDC = 0;
  2206. HDC     zm_memDC2 = 0;
  2208. int currentPosition = 0;
  2209. int CurrentTransition = 1;
  2210. int CurrentSubType = 0;
  2211. int zm_maxRects = 0;
  2212. int zm_numFrames = 0;
  2213. double zm_startTime;
  2214. double zm_totalCPUTime;
  2215. int     zm_bRegionEffect = 1;
  2216. int     z_pPixelValues[300][300];
  2218. double GetAngle(int x, int y, int x1, int y1)
  2219. {
  2220.    int dx = x- x1;
  2221.    int dy = y - y1;
  2222.         
  2223.    return atan2(dx, dy);
  2224. }
  2226. int GetRange(int x, int y, int x1, int y1)
  2227. {
  2228.    return (int) sqrt( (double) ((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y)));
  2229. }
  2231. void DoPixelTransition(HBITMAP back, HBITMAP front, HBITMAP scratch, int completeness, tranLines* lines)
  2232. {
  2233.    if (!zm_memDC2)
  2234.    {
  2235.       HDC hdc = GetDC(0);
  2236.       zm_memDC2 = CreateCompatibleDC(hdc);
  2237.       ReleaseDC(0, hdc);
  2238.    }
  2239.         
  2240.    zm_oldSurface = (HBITMAP)SelectObject(zm_memDC, back);
  2241.    zm_oldSurface2 = (HBITMAP)SelectObject(zm_memDC2, zm_hScratchSurface);
  2242.    SelectObject(zm_memDC, front);
  2243.         
  2244.    if (!z_pPixelValues[0][0])
  2245.    {
  2246.       for(int y = 0; y<z_PaneWidth; y++)
  2247.       {
  2248.          for(int x = 0; x< z_PaneWidth; x++)
  2249.          {
  2250.             z_pPixelValues[x][y]= GetPixel(zm_memDC, x, y);
  2251.             if (!x && !y && !z_pPixelValues[x][y])
  2252.             {   
  2253.                z_pPixelValues[x][y] = 1;
  2254.             }
  2255.          }
  2256.       }
  2257.    }
  2258.         
  2259.    int implodex = 140;
  2260.    int implodey = 140;
  2261.         
  2262.    for(int y = 0; y<z_PaneWidth; y++)
  2263.    {
  2264.       for(int x = 0; x< z_PaneWidth; x++)
  2265.       {
  2266.          int color = z_pPixelValues[x][y];
  2267.          double  angle= GetAngle(x,y,implodex, implodey);
  2268.          int range = GetRange(x,y,implodex, implodey);
  2269.          range = (range * (1000 - completeness)) / 1000;
  2270.          double mess = (double)completeness/500.0  * PI;
  2271.          double scaleFactor = sin(angle*3 + mess)*cos(angle*2 + mess);
  2272.          scaleFactor = (1.0 - scaleFactor)* (1000.0 - completeness) / 1000.0 + scaleFactor;
  2273.          range = (int) (range * scaleFactor + 0.5);
  2274.          int newx = (int) ((double) range * sin (angle + mess / 4) + implodex + 0.5);
  2275.          int newy = (int) ((double) range * cos (angle + mess / 4)  + implodey + 0.5);
  2276.          SetPixel(zm_memDC2, newx, newy, color);
  2277.       }
  2278.    }
  2279.    SelectObject(zm_memDC, zm_oldSurface);
  2280.    SelectObject(zm_memDC2, zm_oldSurface2);
  2281. }
  2283. double currentTime()
  2284. {
  2285.    static LARGE_INTEGER QueryPerformanceCounterResult = {0,0};
  2286.    static LARGE_INTEGER QueryPerformanceFrequencyResult = {0,0};
  2287.         
  2288.    QueryPerformanceFrequency(&QueryPerformanceFrequencyResult);
  2289.         
  2290.    double frequency = ((double)QueryPerformanceFrequencyResult.LowPart + 4294967296.0*QueryPerformanceFrequencyResult.HighPart);
  2291.    QueryPerformanceCounter(&QueryPerformanceCounterResult);
  2292.         
  2293.    return ((double)QueryPerformanceCounterResult.LowPart + 4294967296.0*QueryPerformanceCounterResult.HighPart)/frequency;
  2294. }
  2296. void PrintStat(int x, int y, char* pszStatName, int stat)
  2297. {
  2298.    LOGBRUSH logBrush;
  2299.    logBrush.lbStyle = BS_SOLID;
  2300.    logBrush.lbColor = 0x00000000;
  2301.    logBrush.lbHatch = 0;
  2302.    HBRUSH brush = CreateBrushIndirect(&logBrush);
  2303.         
  2304.     
  2305.    HDC hdc = GetDC(zm_hwnd);
  2306.    char buffer[20]; /* Flawfinder: ignore */
  2307.    SetTextColor(hdc, 0x00FFFFFF);
  2308.    SetBkColor(hdc, 0x00000000);
  2309.    SetBkMode(hdc, OPAQUE);
  2310.    HBRUSH oldBrush = (HBRUSH) SelectObject(hdc, brush);
  2311.         
  2312.    TextOut(hdc, x, y, pszStatName, strlen(pszStatName));
  2313.    Rectangle(hdc, x+90, y, x+230, y+20);
  2314.    sprintf(buffer, "%d", stat); /* Flawfinder: ignore */
  2315.    TextOut(hdc, x+90, y, buffer, strlen(buffer));
  2316.    SelectObject(hdc, oldBrush);
  2317.    DeleteObject(brush);
  2318.    ReleaseDC(zm_hwnd, hdc);
  2319. }
  2320. #ifdef NO_GRAPHICS
  2321. void DoTransition(int currentPosition)
  2322. {
  2323.    RECT rect;
  2324.         
  2325.    rect.left    = 0;
  2326.    rect.top     = 0;
  2327.    rect.right   = z_PaneWidth;
  2328.    rect.bottom = z_PaneHeight;
  2329.         
  2330.    HXDestroyRegion(z_TransitionTable[CurrentTransition].m_pSubTypes[CurrentSubType].m_fpTranFunction(rect.left, rect.top, rect.right, rect.bottom, currentPosition));
  2331. }
  2332. #endif
  2334. LRESULT __declspec(dllexport) __stdcall CWindowProc
  2335. (
  2336.    HWND hWnd,
  2337.    UINT message,
  2338.    WPARAM wParam,
  2339.    LPARAM lParam
  2340.    )
  2341. {
  2342.    switch (message)
  2343.    {
  2344.       case WM_TIMER:
  2345.       {
  2346.          /*  The following commented out code is for determing which 
  2347.           *     region is supposed to be old and which is supposed to be new.
  2348.           */
  2349.                         
  2350.          /*
  2351.            {
  2352.            RECT rect;
  2353.            GetClientRect(zm_displayInner, &rect);
  2354.            HRGN rgn = CreateRectRgn(rect.left, rect.top, rect.right, rect.bottom);
  2355.            SetWindowRgn(zm_displayInner, rgn, FALSE);
  2356.            HDC hdc = GetDC(zm_displayInner);
  2357.            FillRect(hdc, &rect, (HBRUSH)GetStockObject(BLACK_BRUSH));
  2358.            GdiFlush();
  2359.            ReleaseDC(zm_displayInner, hdc);
  2360.            }
  2361.          */
  2362.                         
  2363.          double startTime = currentTime();
  2364.                         
  2365.          RECT rect;
  2366.                         
  2367.          rect.left      = 0;
  2368.          rect.top       = 0;
  2369.          rect.right     = z_PaneWidth;// - 1;
  2370.          rect.bottom = z_PaneHeight;// - 1;
  2371.                         
  2372. #ifdef FORWARD
  2373.          currentPosition += 5;
  2374.          if (currentPosition > 1000) currentPosition = 1000;
  2375. #else
  2376.          currentPosition -= 5;
  2377.          if (currentPosition < 0) currentPosition = 0;
  2378. #endif
  2379.                         
  2380.          HXREGION* XclipRgn = InvertRGN(z_TransitionTable[CurrentTransition].m_pSubTypes[CurrentSubType].m_fpTranFunction(rect.left, rect.top, rect.right, rect.bottom, currentPosition),rect.left, rect.top, rect.right, rect.bottom);
  2381.                         
  2382.          HRGN clipRgn = CreateRectRgn(0,0,0,0);
  2383.          for(int i=0 ; i<XclipRgn->numRects ; i++ )
  2384.          {
  2385.             HRGN tmp = CreateRectRgn(
  2386.                XclipRgn->rects[i].x1,
  2387.                XclipRgn->rects[i].y1,
  2388.                XclipRgn->rects[i].x2,
  2389.                XclipRgn->rects[i].y2
  2390.                );       
  2391.             CombineRgn( clipRgn, clipRgn, tmp, RGN_OR );
  2392.             DeleteObject( tmp );
  2393.          }
  2394.          HXDestroyRegion(XclipRgn);
  2395.          if (!zm_theSmallFONT)
  2396.          {
  2397.             zm_theSmallFONT = CreateFont(15, 0, 0, 0, 700, FALSE, FALSE, FALSE, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, "Ariel");
  2398.          }
  2399.                         
  2400.          if (!zm_theFONT)
  2401.          {
  2402.             zm_theFONT = CreateFont(115, 0, 0, 0, 700, FALSE, FALSE, FALSE, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, "Ariel");
  2403.          }
  2404.          int totalrects;
  2405.          totalrects = 0;
  2406.                         
  2407.          {
  2408.             LPRGNDATA   lpRgnData;
  2409.             DWORD sizeNeeed = GetRegionData(clipRgn, 0, NULL); 
  2410.             lpRgnData = (LPRGNDATA) new char[sizeNeeed];
  2411.             GetRegionData(clipRgn, sizeNeeed, lpRgnData); 
  2412.             PrintStat(z_PaneWidth + 20, 50, "Old Rects:", lpRgnData->rdh.nCount);
  2413.             totalrects += lpRgnData->rdh.nCount;
  2414.             delete lpRgnData;
  2415.          }
  2416.                         
  2417.          //  Create Initial Objects.
  2418.                         
  2419.          if (!zm_memDC)
  2420.          {
  2421.             HDC hdc = GetDC(0);
  2422.             zm_memDC = CreateCompatibleDC(hdc);
  2423.             ReleaseDC(0, hdc);
  2424.          }
  2425.                         
  2426.          if (!zm_hBitmapNEW)
  2427.          {
  2428.             HDC hdc = GetDC(0);
  2429.             zm_hBitmapNEW = CreateCompatibleBitmap(hdc, z_PaneWidth, z_PaneHeight);
  2430.             ReleaseDC(0, hdc);
  2431.                                 
  2432.             zm_oldSurface = (HBITMAP)SelectObject(zm_memDC, zm_hBitmapNEW);
  2433.             LOGBRUSH logBrush;
  2434.             logBrush.lbStyle = BS_SOLID;
  2435.             logBrush.lbColor = 0x000000FF;
  2436.             logBrush.lbHatch = 0;
  2437.             HBRUSH brush = CreateBrushIndirect(&logBrush);
  2438.                                 
  2439.             HFONT   oldfont             = (HFONT)SelectObject(zm_memDC, zm_theFONT);
  2440.             HBRUSH  oldBrush    = (HBRUSH)SelectObject(zm_memDC, brush);
  2441.             Rectangle(zm_memDC, 0,0,z_PaneWidth, z_PaneHeight);
  2442.             SetBkMode(zm_memDC, TRANSPARENT);
  2443.             SIZE stringSize;
  2444.             GetTextExtentPoint32(zm_memDC,"NEW",3,&stringSize);
  2445.             TextOut(zm_memDC, (z_PaneWidth - stringSize.cx) / 2, (z_PaneHeight - stringSize.cy) / 2, "NEW", 3);
  2446.             GdiFlush();
  2447.             SelectObject(zm_memDC, oldBrush);
  2448.             DeleteObject(brush);
  2449.             SelectObject(zm_memDC, oldfont);
  2450.             SelectObject(zm_memDC, zm_oldSurface);
  2451.          }
  2452.                         
  2453.          if (!zm_hBitmapOLD)
  2454.          {
  2455.             HDC hdc = GetDC(0);
  2456.             zm_hBitmapOLD = CreateCompatibleBitmap(hdc, z_PaneWidth, z_PaneHeight);
  2457.             ReleaseDC(0, hdc);
  2458.                                 
  2459.             zm_oldSurface = (HBITMAP)SelectObject(zm_memDC, zm_hBitmapOLD);
  2460.             LOGBRUSH logBrush;
  2461.             logBrush.lbStyle = BS_SOLID;
  2462.             logBrush.lbColor = 0x0000FFFF;
  2463.             logBrush.lbHatch = 0;
  2464.             HBRUSH brush = CreateBrushIndirect(&logBrush);
  2465.                                 
  2466.             HFONT   oldfont             = (HFONT)SelectObject(zm_memDC, zm_theFONT);
  2467.             HBRUSH  oldBrush    = (HBRUSH)SelectObject(zm_memDC, brush);
  2468.             Rectangle(zm_memDC, 0,0,z_PaneWidth, z_PaneHeight);
  2469.             SetBkMode(zm_memDC, TRANSPARENT);
  2470.             SIZE stringSize;
  2471.             GetTextExtentPoint32(zm_memDC,"OLD",3,&stringSize);
  2472.             TextOut(zm_memDC, (z_PaneWidth - stringSize.cx) / 2, (z_PaneHeight - stringSize.cy) / 2, "OLD", 3);
  2473.             GdiFlush();
  2474.             SelectObject(zm_memDC, oldBrush);
  2475.             DeleteObject(brush);
  2476.             SelectObject(zm_memDC, oldfont);
  2477.             SelectObject(zm_memDC, zm_oldSurface);
  2478.          }
  2479.                         
  2480.          if (zm_bRegionEffect)
  2481.          {
  2482.             HRGN oldRGN;
  2483.             oldRGN = CreateRectRgn(0,0,0,0);
  2484.             GetWindowRgn(zm_displayInner, oldRGN);
  2485.                                 
  2486.             SetWindowRgn(zm_displayInner, clipRgn, FALSE);
  2487.             HDC hdc = GetDC(zm_displayInner);
  2488.             zm_oldSurface = (HBITMAP)SelectObject(zm_memDC, zm_hBitmapOLD);
  2489.             BitBlt(hdc, 0,0,z_PaneWidth, z_PaneHeight, zm_memDC, 0,0, SRCCOPY);
  2490.                                 
  2491.             HXREGION* ZclipRgn =  InvertRGN(z_TransitionTable[CurrentTransition].m_pSubTypes[CurrentSubType].m_fpTranFunction(rect.left, rect.top, rect.right, rect.bottom, currentPosition),rect.left, rect.top, rect.right, rect.bottom);
  2492.             static LARGE_INTEGER QueryPerformanceCounterResult = {0,0};
  2493.             static LARGE_INTEGER QueryPerformanceFrequencyResult = {0,0};
  2494.                                 
  2495.             QueryPerformanceFrequency(&QueryPerformanceFrequencyResult);
  2496.                                 
  2497.             double frequency = ((double)QueryPerformanceFrequencyResult.LowPart + 4294967296.0*QueryPerformanceFrequencyResult.HighPart);
  2498.             QueryPerformanceCounter(&QueryPerformanceCounterResult);
  2499.                                 
  2500.             double startTime = ((double)QueryPerformanceCounterResult.LowPart + 4294967296.0*QueryPerformanceCounterResult.HighPart)/frequency;
  2501.                                 
  2502.             clipRgn = CreateRectRgn(0,0,0,0);
  2503.             for(int i=0 ; i<ZclipRgn->numRects ; i++ )
  2504.             {
  2505.                HRGN tmp = CreateRectRgn(
  2506.                   ZclipRgn->rects[i].x1,
  2507.                   ZclipRgn->rects[i].y1,
  2508.                   ZclipRgn->rects[i].x2,
  2509.                   ZclipRgn->rects[i].y2
  2510.                   );    
  2511.                CombineRgn( clipRgn, clipRgn, tmp, RGN_OR);
  2512.                DeleteObject( tmp );
  2513.             }
  2514.                                 
  2515.             HXDestroyRegion(ZclipRgn);
  2516.                                 
  2517.                                 
  2518.             QueryPerformanceCounter(&QueryPerformanceCounterResult);
  2519.             double endTime = ((double)QueryPerformanceCounterResult.LowPart + 4294967296.0*QueryPerformanceCounterResult.HighPart)/frequency;
  2520.                                 
  2521.             static UINT32 z_nNumTimes = 0;
  2522.             static double z_fTotalTime;
  2523.             static double z_fAverageTime;
  2524.                                 
  2525.             z_nNumTimes++;
  2526.             z_fTotalTime += endTime - startTime;
  2527.             z_fAverageTime = z_fTotalTime / (double) z_nNumTimes;
  2528.                                 /*
  2529.                                   if (! (z_nNumTimes % 25))
  2530.                                   {
  2531.                                   FILE* f1 = ::fopen("c:\performance.txt", "a+"); 
  2532.                                   ::fprintf(f1, "WINDRAW2 - BltToPrimary: %d blts. Total CPU time: %f, CPU/Blt: %f -- Blt/s Second Max: %fn", z_nNumTimes, z_fTotalTime, z_fAverageTime, 1.0/z_fAverageTime);
  2533.                                   fclose(f1);
  2534.                                   }
  2535.                                 
  2536.                                 */
  2537.                                 
  2538.             HRGN tempRgn = CreateRectRgn(rect.left, rect.top, rect.right, rect.bottom);
  2539.             CombineRgn(tempRgn, tempRgn, clipRgn, RGN_XOR);
  2540.                                 
  2541.                                 
  2542.                                 //  Print Region Stats
  2543.                                 
  2544.             {
  2545.                LPRGNDATA        lpRgnData;
  2546.                DWORD sizeNeeed = GetRegionData(tempRgn, 0, NULL); 
  2547.                lpRgnData = (LPRGNDATA) new char[sizeNeeed];
  2548.                GetRegionData(tempRgn, sizeNeeed, lpRgnData); 
  2549.                PrintStat(z_PaneWidth + 20, 70, "New Rects:", lpRgnData->rdh.nCount);
  2550.                totalrects += lpRgnData->rdh.nCount;
  2551.                delete lpRgnData;
  2552.             }
  2553.                                 
  2554.             SetWindowRgn(zm_displayInner, tempRgn, FALSE);
  2555.             SelectObject(zm_memDC, zm_hBitmapNEW);
  2556.             BitBlt(hdc, 0,0,z_PaneWidth, z_PaneHeight, zm_memDC, 0,0, SRCCOPY);
  2557.             ReleaseDC(zm_displayInner, hdc);
  2558.             DeleteObject(clipRgn);
  2559.             SelectObject(zm_memDC, zm_oldSurface);
  2560.             SetWindowRgn(zm_displayInner, oldRGN, 0);
  2561.          }
  2562.          else
  2563.          {
  2564.                                 //  Pixel based effects.
  2565.                                 
  2566.             if (!zm_hScratchSurface)
  2567.             {
  2568.                HDC hdc = GetDC(0);
  2569.                zm_hScratchSurface = CreateCompatibleBitmap(hdc, 300,300);
  2570.                ReleaseDC(0, hdc);
  2571.             }
  2572.                                 
  2573.             DoPixelTransition(zm_hBitmapNEW, zm_hBitmapOLD, zm_hScratchSurface, currentPosition);
  2574.             HDC hdc = GetDC(zm_displayInner);
  2575.             zm_oldSurface = (HBITMAP)SelectObject(zm_memDC, zm_hScratchSurface);
  2576.             BitBlt(hdc, 0,0,z_PaneWidth, z_PaneHeight, zm_memDC, 0,0, SRCCOPY);
  2577.             ReleaseDC(zm_displayInner, hdc);
  2578.             SelectObject(zm_memDC, zm_oldSurface);
  2579.             PrintStat(z_PaneWidth + 20, 170, "Frames:", zm_numFrames);
  2580.          }
  2581.                         
  2582.          //      Print More Stats
  2583.          PrintStat(z_PaneWidth + 20, 90, "Sum Rects:", totalrects);
  2584.          if (totalrects > zm_maxRects)
  2585.          {
  2586.             zm_maxRects = totalrects;
  2587.          }
  2588.          PrintStat(z_PaneWidth + 20, 110, "Max Rects:", zm_maxRects);
  2589.          zm_totalCPUTime = zm_totalCPUTime + (currentTime() - startTime);
  2590.          PrintStat(z_PaneWidth + 20, 130, "% CPU:", (int) (zm_totalCPUTime*100.0 / (currentTime() - zm_startTime)));
  2591.                         
  2592.          zm_numFrames++;
  2593.          PrintStat(z_PaneWidth + 20, 150, "FPS:", (int) (zm_numFrames/ (currentTime() - zm_startTime)));
  2594.                         
  2595.          PrintStat(z_PaneWidth + 20, 170, "Complete:", currentPosition);
  2596.          break;
  2597.       }
  2598.       case WM_COMMAND:
  2599.       {
  2600.          int wNotifyCode = HIWORD(wParam);
  2601.          if (wNotifyCode == CBN_SELCHANGE)
  2602.          {
  2603. #ifdef FORWARD
  2604.             currentPosition = -5;
  2605. #else
  2606.             currentPosition = 1005;
  2607. #endif
  2608.             int currentSel = SendMessage(zm_comboHWND, CB_GETCURSEL , 0, 0);
  2609.                                 
  2610.                                 // clear out the previous transitions memory
  2611.             HXDestroyRegion(z_TransitionTable[CurrentTransition].m_pSubTypes[CurrentSubType].m_fpTranFunction(0, 0, 0, 0, MATRIX_TRANSITION_DELETE));
  2612.                                 
  2613.             CurrentTransition = theTranMap[currentSel].type;
  2614.             CurrentSubType = theTranMap[currentSel].subType;
  2615.             zm_maxRects = 0;
  2616.             zm_startTime = currentTime();
  2617.             zm_totalCPUTime = 0;
  2618.             zm_numFrames = 0;
  2620. #ifdef NO_GRAPHICS
  2621.             double startTime = currentTime();
  2622.                                 
  2623.             for (int i = 0; i <= 1000; i += 5)
  2624.             {
  2625.                DoTransition(i);
  2626.             }
  2627.                                   
  2628.             double endTime = currentTime();
  2629.             PrintStat(z_PaneWidth + 20, 130, "Time (mu):", (int) ((endTime - startTime) * 1000000));
  2630. #endif
  2631.          }
  2632.          break;
  2633.       }
  2634.       case WM_DESTROY:
  2635.       {
  2636.          // clear out the previous transitions memory
  2637.          HXDestroyRegion(z_TransitionTable[CurrentTransition].m_pSubTypes[CurrentSubType].m_fpTranFunction(0, 0, 0, 0, MATRIX_TRANSITION_DELETE));
  2638.                         
  2639.          PostQuitMessage(0);
  2640.          break;
  2641.       }
  2642.    }
  2643.     
  2644.    return (DefWindowProc(hWnd, message, wParam, lParam));
  2645. }
  2647. int WINAPI WinMain( HINSTANCE hInstance, 
  2648.                     HINSTANCE hPrevInstance, 
  2649.                     LPSTR lpCmdLine, 
  2650.                     int nCmdShow 
  2651.                     )
  2652. {
  2653.    // get the size of the window from command line
  2654.    char* pCLine = strstr(lpCmdLine,"Width");
  2655.    if (pCLine)
  2656.    {
  2657.       pCLine = strchr(pCLine,'=');
  2658.       if (pCLine)
  2659.       {
  2660.          pCLine++;
  2661.          z_PaneWidth = atoi(pCLine);
  2662.       }
  2663.    }
  2664.    pCLine = strstr(lpCmdLine,"Height");
  2665.    if (pCLine)
  2666.    {
  2667.       pCLine = strchr(pCLine,'=');
  2668.       if (pCLine)
  2669.       {
  2670.          pCLine++;
  2671.          z_PaneHeight = atoi(pCLine);
  2672.       }
  2673.    }
  2674.         
  2675.    WNDCLASS wndClass;
  2676.         
  2677.    wndClass.style               = 0; 
  2678.    wndClass.lpfnWndProc = CWindowProc;
  2679.    wndClass.cbClsExtra          = 0;    
  2680.    wndClass.cbWndExtra          = 0; 
  2681.    wndClass.hInstance           = hInstance;
  2682.    wndClass.hIcon               = NULL; 
  2683.    wndClass.hCursor             = LoadCursor(NULL, IDC_ARROW); 
  2684.    wndClass.hbrBackground       = (HBRUSH)GetStockObject(BLACK_BRUSH);
  2685.    wndClass.lpszMenuName        = NULL; 
  2686.    wndClass.lpszClassName       = zm_pszWindowClassName; 
  2687.         
  2688.    ::RegisterClass(&wndClass);
  2689.         
  2690.    wndClass.lpfnWndProc = DefWindowProc;
  2691.    wndClass.lpszClassName       = "DefWindowProc"; 
  2692.    ::RegisterClass(&wndClass);
  2693.         
  2694.    ::RegisterClass(&wndClass);
  2695.     
  2696.    zm_hwnd = CreateWindow(
  2697.       zm_pszWindowClassName, 
  2698.       zm_pszWindowName, 
  2699.       WS_BORDER | WS_CAPTION | WS_CLIPCHILDREN | WS_VISIBLE | WS_SYSMENU, 
  2700.       100, 
  2701.       100,
  2702.       z_PaneWidth + 200,
  2703.       z_PaneHeight + 70,
  2704.       NULL, 
  2705.       NULL, 
  2706.       hInstance, 
  2707.       NULL);
  2708.         
  2709.    zm_comboHWND= CreateWindow(
  2710.       "COMBOBOX", 
  2711.       "combo", 
  2712.       WS_VISIBLE | WS_CHILD | CBS_DROPDOWN | WS_VSCROLL, 
  2713.       10, 
  2714.       10,
  2715.       400,
  2716.       300,
  2717.       zm_hwnd, 
  2718.       NULL, 
  2719.       hInstance, 
  2720.       NULL);
  2721.         
  2722.    zm_displayOuter = CreateWindow(
  2723.       "DefWindowProc", 
  2724.       "combo", 
  2725.       WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN, 
  2726.       10, 
  2727.       40,
  2728.       z_PaneWidth,
  2729.       z_PaneHeight,
  2730.       zm_hwnd, 
  2731.       NULL, 
  2732.       hInstance, 
  2733.       NULL);
  2734.         
  2735.    zm_displayInner = CreateWindow(
  2736.       "DefWindowProc", 
  2737.       "combo", 
  2738.       WS_VISIBLE | WS_CHILD, 
  2739.       0, 
  2740.       0,
  2741.       z_PaneWidth,
  2742.       z_PaneHeight,
  2743.       zm_displayOuter, 
  2744.       NULL, 
  2745.       hInstance, 
  2746.       NULL);
  2747.         
  2748.    int count = 0;
  2749.    char name[200]; /* Flawfinder: ignore */
  2750.    for(int j = 0; j < z_nNumberTransitionTypes; ++j)
  2751.    {
  2752.       for(int i = 0; i< z_TransitionTable[j].m_nNum; ++i)
  2753.       {
  2754.          if (count < 200)
  2755.          {
  2756.             if (z_TransitionTable[j].m_pSubTypes[i].m_pTranName)
  2757.             {
  2758.                SafeSprintf(name,200, "%s - %s (%d)",z_TransitionTable[j].m_pName,z_TransitionTable[j].m_pSubTypes[i].m_pTranName,z_TransitionTable[j].m_pSubTypes[i].m_SMPTE);
  2759.                SendMessage(zm_comboHWND, CB_ADDSTRING, 0, (long)name);
  2760.                theTranMap[count].in = count;
  2761.                theTranMap[count].type = j;
  2762.                theTranMap[count].subType = i;
  2763.                count++;
  2764.             }
  2765.          }
  2766.       }
  2767.    }
  2768.         
  2769.    int number = SendMessage(zm_comboHWND, CB_GETCOUNT, 0, 0);
  2770.    SendMessage(zm_comboHWND, CB_SETCURSEL, CurrentTransition, 0);
  2772. #ifndef NO_GRAPHICS
  2773.    SetTimer(zm_hwnd, 1, 1, NULL);
  2774. #endif
  2776.    MSG msg;
  2777.    while (GetMessage(&msg,NULL,0,0))
  2778.    {
  2779.       if (msg.message == WM_QUIT)
  2780.          break;
  2781.                 
  2782.       TranslateMessage(&msg);
  2783.       // Dispatches message to window
  2784.       DispatchMessage(&msg);
  2785.    }
  2786.         
  2787.    return msg.wParam ;
  2788. }
  2790. #endif