sitetran.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

   }
   return retRGN;
}

HXREGION* ClockwiseBottomLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   HXREGION* retRGN = MirrorHorizontal(CounterClockwiseTopLeftMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
   if (lines)
      MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
   return retRGN;
}

HXREGION* CounterClockwiseTopLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   static CHXBuffer* z_ccwTopLeftDataBuffer = NULL;
        
   if (!z_ccwTopLeftDataBuffer || completeness == MATRIX_TRANSITION_INIT)
   {
      MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(8,8,64);
      MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
                
      int blockIdx = 0;
                
      for (int i = 8; i > 0; i -= 2)
      {
         int j;
         int horzOffset = (int)(5.0 - i / 2);
         int vertOffset = (int)((9.0 - i) / 2);
         int vertOffsetRt = (int)(i / 2+ 4);
                        
         for (j = 0; j < i; ++j, ++blockIdx)
         {
            blockTransList[blockIdx].CreateList(1);
            MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
                                
            list->block = (j + vertOffset) * 8 + vertOffset;
            list->invert = 0;
            list->transition = SlideVerticalEdgeWipe;
         }
         for (j = 0; j < i - 2; ++j, ++blockIdx)
         {
            blockTransList[blockIdx].CreateList(1);
            MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
                                
            list->block = j + (i / 2 + 3) * 8 + (10 - i) / 2;
            list->invert = 0;
            list->transition = EdgeWipe;
         }
         for (j = 0; j < i; ++j, ++blockIdx)
         {
            blockTransList[blockIdx].CreateList(1);
            MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
                                
            list->block = (vertOffsetRt - j) * 8 - vertOffset - 1;
            list->invert = 1;
            list->transition = SlideVerticalEdgeWipe;
         }
         for (j = 0; j < i - 2; ++j, ++blockIdx)
         {
            blockTransList[blockIdx].CreateList(1);
            MatrixBlockTransition* list = blockTransList[blockIdx].GetListPtr();
                                
            list->block = 7 * horzOffset - 1 - j;
            list->invert = 1;
            list->transition = EdgeWipe;
         }
      }
                
      z_ccwTopLeftDataBuffer = new CHXBuffer();
      z_ccwTopLeftDataBuffer->AddRef();
      z_ccwTopLeftDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
   }
   else if (completeness == MATRIX_TRANSITION_DELETE)
   {
      delete *((MatrixTransitionData**)z_ccwTopLeftDataBuffer->GetBuffer());
      if (!z_ccwTopLeftDataBuffer->Release())
      {
         z_ccwTopLeftDataBuffer = NULL;
         return HXCreateRegion();
      }
   }
        
   return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_ccwTopLeftDataBuffer->GetBuffer()),lines);
}

HXREGION* CounterClockwiseTopRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   HXREGION* retRGN = MirrorVertical(ClockwiseTopLeftMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2);
   if (lines)
      MirrorVertical(lines,left + (right - left + 1) / 2);
   return retRGN;
}

HXREGION* CounterClockwiseBottomRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   HXREGION* retRGN = MirrorHorizontal(MirrorVertical(CounterClockwiseTopLeftMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2),top + (bottom - top + 1) / 2);
   if (lines)
   {
      MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
      MirrorVertical(lines,left + (right - left + 1) / 2);
   }
   return retRGN;
}

HXREGION* CounterClockwiseBottomLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   HXREGION* retRGN = MirrorHorizontal(ClockwiseTopLeftMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
   if (lines)
      MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
   return retRGN;
}

HXREGION* VerticalStartTopMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   static CHXBuffer* z_verticalTopDataBuffer = NULL;
        
   if (!z_verticalTopDataBuffer || completeness == MATRIX_TRANSITION_INIT)
   {
      MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(8,1,4);
      MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
                
      for (int i = 0; i < 4; ++i)
      {
         blockTransList[i].CreateList(2);
         MatrixBlockTransition* list = blockTransList[i].GetListPtr();
                        
         list[0].invert = list[1].invert = i & 1;
         list[0].transition = list[1].transition = SlideVerticalEdgeWipe;
         list[0].block = i;
         list[1].block = 7 - i;
      }
                
      z_verticalTopDataBuffer = new CHXBuffer();
      z_verticalTopDataBuffer->AddRef();
      z_verticalTopDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
   }
   else if (completeness == MATRIX_TRANSITION_DELETE)
   {
      delete *((MatrixTransitionData**)z_verticalTopDataBuffer->GetBuffer());
      if (!z_verticalTopDataBuffer->Release())
      {
         z_verticalTopDataBuffer = NULL;
         return HXCreateRegion();
      }
   }
        
   return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_verticalTopDataBuffer->GetBuffer()),lines);
}

HXREGION* VerticalStartBottomMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   HXREGION* retRGN = MirrorHorizontal(VerticalStartTopMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
   if (lines)
      MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
   return retRGN;
}

HXREGION* VerticalStartTopOppositeMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   static CHXBuffer* z_verticalTopOppDataBuffer = NULL;
        
   if (!z_verticalTopOppDataBuffer || completeness == MATRIX_TRANSITION_INIT)
   {
      MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(8,1,4);
      MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
                
      for (int i = 0; i < 4; ++i)
      {
         blockTransList[i].CreateList(2);
         MatrixBlockTransition* list = blockTransList[i].GetListPtr();
                        
         list[0].invert = i & 1;
         list[1].invert = !list[0].invert;
         list[0].transition = list[1].transition = SlideVerticalEdgeWipe;
         list[0].block = i;
         list[1].block = 7 - i;
      }
                
      z_verticalTopOppDataBuffer = new CHXBuffer();
      z_verticalTopOppDataBuffer->AddRef();
      z_verticalTopOppDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
   }
   else if (completeness == MATRIX_TRANSITION_DELETE)
   {
      delete *((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer());
      if (!z_verticalTopOppDataBuffer->Release())
      {
         z_verticalTopOppDataBuffer = NULL;
         return HXCreateRegion();
      }
   }
        
   return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer()),lines);
}

HXREGION* VerticalStartBottomOppositeMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   HXREGION* retRGN = MirrorHorizontal(VerticalStartTopOppositeMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
   if (lines)
      MirrorHorizontal(lines,top + (bottom - top + 1) / 2);
   return retRGN;
}

HXREGION* HorizontalStartLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   static CHXBuffer* z_verticalTopOppDataBuffer = NULL;
        
   if (!z_verticalTopOppDataBuffer || completeness == MATRIX_TRANSITION_INIT)
   {
      MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(1,8,4);
      MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
                
      for (int i = 0; i < 4; ++i)
      {
         blockTransList[i].CreateList(2);
         MatrixBlockTransition* list = blockTransList[i].GetListPtr();
                        
         list[0].invert = list[1].invert = i & 1;
         list[0].transition = list[1].transition = EdgeWipe;
         list[0].block = i;
         list[1].block = 7 - i;
      }
                
      z_verticalTopOppDataBuffer = new CHXBuffer();
      z_verticalTopOppDataBuffer->AddRef();
      z_verticalTopOppDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
   }
   else if (completeness == MATRIX_TRANSITION_DELETE)
   {
      delete *((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer());
      if (!z_verticalTopOppDataBuffer->Release())
      {
         z_verticalTopOppDataBuffer = NULL;
         return HXCreateRegion();
      }
   }
        
   return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer()),lines);
}

HXREGION* HorizontalStartRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   HXREGION* retRGN = MirrorVertical(HorizontalStartLeftMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2);
   if (lines)
      MirrorVertical(lines,left + (right - left + 1) / 2);
   return retRGN;
}

HXREGION* HorizontalStartLeftOppositeMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   static CHXBuffer* z_verticalTopOppDataBuffer = NULL;
        
   if (!z_verticalTopOppDataBuffer || completeness == MATRIX_TRANSITION_INIT)
   {
      MatrixTransitionData* VerticalMatrixTransition = new MatrixTransitionData(1,8,4);
      MatrixBlockTransitionList* blockTransList = VerticalMatrixTransition->GetTransactionListPtr();
                
      for (int i = 0; i < 4; ++i)
      {
         blockTransList[i].CreateList(2);
         MatrixBlockTransition* list = blockTransList[i].GetListPtr();
                        
         list[0].invert = i & 1;
         list[1].invert = !list[0].invert;
         list[0].transition = list[1].transition = EdgeWipe;
         list[0].block = i;
         list[1].block = 7 - i;
      }
                
      z_verticalTopOppDataBuffer = new CHXBuffer();
      z_verticalTopOppDataBuffer->AddRef();
      z_verticalTopOppDataBuffer->Set((UCHAR*)&VerticalMatrixTransition, sizeof(UCHAR*));
   }
   else if (completeness == MATRIX_TRANSITION_DELETE)
   {
      delete *((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer());
      if (!z_verticalTopOppDataBuffer->Release())
      {
         z_verticalTopOppDataBuffer = NULL;
         return HXCreateRegion();
      }
   }
        
   return MatrixTransition(left,top,right,bottom,completeness,*((MatrixTransitionData**)z_verticalTopOppDataBuffer->GetBuffer()),lines);
}

HXREGION* HorizontalStartRightOppositeMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   HXREGION* retRGN = MirrorVertical(HorizontalStartLeftOppositeMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2);
   if (lines)
      MirrorVertical(lines,left + (right - left + 1) / 2);
   return retRGN;
}

HXREGION* DoubleSpiralTopMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   tranLines* tmpLines = NULL;

   if (lines)
      tmpLines = new tranLines;
   int ii = (int)(((float)(left + right)) / 2.0 + .5)-1;
   int jj = ii + 1;
   
   
   HXREGION* retRGN = CounterClockwiseTopLeftMatrix(left, top, ii, bottom, completeness,lines);
   HXREGION* rgn1 = ClockwiseTopRightMatrix(jj, top, right, bottom, completeness,tmpLines);
   HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_XOR);
   HXDestroyRegion(rgn1);

   if (lines)
      *lines += *tmpLines;
        
   return retRGN;
}

HXREGION* DoubleSpiralBottomMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   HXREGION* retRGN = MirrorHorizontal(DoubleSpiralTopMatrix(left,top,right,bottom,completeness,lines),top + (bottom - top + 1) / 2);
   if (lines)
      MirrorHorizontal(lines,top + (bottom - top + 1) / 2);

   return retRGN;
}

HXREGION* DoubleSpiralLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   tranLines* tmpLines = NULL;

   if (lines)
      tmpLines = new tranLines;

   HXREGION* retRGN = ClockwiseTopLeftMatrix(left, top, right, (top + bottom) / 2 + 1, completeness,lines);
   HXREGION* rgn1 = CounterClockwiseBottomLeftMatrix(left, (top + bottom) / 2, right, bottom, completeness,tmpLines);
   HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
   HXDestroyRegion(rgn1);
        
   if (lines)
      *lines += *tmpLines;
        
   return retRGN;
}

HXREGION* DoubleSpiralRightMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   HXREGION* retRGN = MirrorVertical(DoubleSpiralLeftMatrix(left,top,right,bottom,completeness,lines),left + (right - left + 1) / 2);
   if (lines)
      MirrorVertical(lines,left + (right - left + 1) / 2);

   return retRGN;
}

HXREGION* QuadSpiralVerticalMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   tranLines* tmpLines = NULL;

   if (lines)
      tmpLines = new tranLines;

   HXREGION* retRGN = DoubleSpiralTopMatrix(left, top, right, (top + bottom) / 2 + 1, completeness,lines);
   HXREGION* rgn1 = DoubleSpiralBottomMatrix(left, (top + bottom) / 2 , right, bottom, completeness,tmpLines);
   HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_OR);
   HXDestroyRegion(rgn1);

   if (lines)
      *lines += *tmpLines;
        
   return retRGN;
}

HXREGION* QuadSpiralHorizontalMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   tranLines* tmpLines = NULL;

   if (lines)
      tmpLines = new tranLines;

   HXREGION* retRGN = DoubleSpiralLeftMatrix(left, top, (left + right) / 2, bottom, completeness,lines);
   HXREGION* rgn1 = DoubleSpiralRightMatrix((left + right) / 2 + 1, top, right, bottom, completeness,tmpLines);
   HXCombineRgn(retRGN, retRGN, rgn1, HX_RGN_XOR);
   HXDestroyRegion(rgn1);

   if (lines)
      *lines += *tmpLines;
        
   return retRGN;
}

HXREGION* VerticalWaterfallLeftMatrix(int left, int top, int right, int bottom, int completeness, tranLines* lines)
{
   static CHXBuffer* z_waterfallLeftDataBuffer = NULL;
        
   if (!z_waterfallLeftDataBuffer || completeness == MATRIX_T