void MasterAlpha(int style, double alpha)
 {
     if (style >= 0)
     {
         while ((int)_masterAlpha.Size() <= style)
         {
             _masterAlpha.Add(AntiAliasingMask);
         }
         _masterAlpha.Array[style] = Basics.UnsignedRound(alpha * AntiAliasingMask);
     }
 }
        ///<summary>
        ///</summary>
        ///<returns></returns>
        ///<exception cref="NotImplementedException"></exception>
        public uint SweepStyles()
        {
            for (; ;)
            {
                if (_scanY > _rasterizer.MaxY())
                {
                    return(0);
                }
                int numCells = (int)_rasterizer.ScanlineNumCells((uint)_scanY);
                AntiAliasingCell[] cells;
                uint cellOffset;
                _rasterizer.ScanlineCells((uint)_scanY, out cells, out cellOffset);
                uint numStyles   = (uint)(_maxStyle - _minStyle + 2);
                int  styleOffset = 0;

                _cells.Allocate((uint)numCells * 2, 256);                 // Each cell can have two Styles
                _activeStyleTable.Capacity(numStyles, 64);
                _activeStyleMask.Allocate((numStyles + 7) >> 3, 8);
                _activeStyleMask.Zero();

                if (numCells > 0)
                {
                    // Pre-Add zero (for no-fill Style, that is, -1).
                    // We need that to ensure that the "-1 Style" would go first.
                    _activeStyleMask.Array[0] |= 1;
                    _activeStyleTable.Add(0);
                    _activeStyles.Array[styleOffset].StartCell = 0;
                    _activeStyles.Array[styleOffset].NumCells  = 0;
                    _activeStyles.Array[styleOffset].LastX     = -0x7FFFFFFF;

                    _scanlineStart  = cells[0].x;
                    _scanlineLength = (uint)(cells[numCells - 1].x - _scanlineStart + 1);
                    int curCellOffset;
                    while (numCells-- != 0)
                    {
                        curCellOffset = (int)cellOffset++;
                        AddStyle(cells[curCellOffset].left);
                        AddStyle(cells[curCellOffset].right);
                    }

                    // Convert the Y-histogram into the array of starting indexes
                    uint        i             = 0u;
                    uint        startCell     = 0;
                    StyleInfo[] stylesArray   = _activeStyles.Array;
                    int         indexToModify = (int)_activeStyleTable[i];
                    for (i = 0; i < _activeStyleTable.Size(); i++)
                    {
                        uint v = stylesArray[indexToModify].StartCell;
                        stylesArray[indexToModify].StartCell = startCell;
                        startCell += v;
                    }

                    numCells = (int)_rasterizer.ScanlineNumCells((uint)_scanY);
                    _rasterizer.ScanlineCells((uint)_scanY, out cells, out cellOffset);

                    while (numCells-- > 0)
                    {
                        curCellOffset = (int)cellOffset;
                        uint styleId = (uint)((cells[curCellOffset].left < 0) ? 0 :
                                              cells[curCellOffset].left - _minStyle + 1);

                        styleOffset = (int)styleId;
                        if (cells[curCellOffset].x == stylesArray[styleOffset].LastX)
                        {
                            cellOffset = stylesArray[styleOffset].StartCell + stylesArray[styleOffset].NumCells - 1;
                            unchecked
                            {
                                cells[cellOffset].area  += cells[curCellOffset].area;
                                cells[cellOffset].cover += cells[curCellOffset].cover;
                            }
                        }
                        else
                        {
                            cellOffset                     = stylesArray[styleOffset].StartCell + stylesArray[styleOffset].NumCells;
                            cells[cellOffset].x            = cells[curCellOffset].x;
                            cells[cellOffset].area         = cells[curCellOffset].area;
                            cells[cellOffset].cover        = cells[curCellOffset].cover;
                            stylesArray[styleOffset].LastX = cells[curCellOffset].x;
                            stylesArray[styleOffset].NumCells++;
                        }

                        styleId = (uint)((cells[curCellOffset].right < 0) ? 0 :
                                         cells[curCellOffset].right - _minStyle + 1);

                        styleOffset = (int)styleId;
                        if (cells[curCellOffset].x == stylesArray[styleOffset].LastX)
                        {
                            cellOffset = stylesArray[styleOffset].StartCell + stylesArray[styleOffset].NumCells - 1;
                            unchecked
                            {
                                cells[cellOffset].area  -= cells[curCellOffset].area;
                                cells[cellOffset].cover -= cells[curCellOffset].cover;
                            }
                        }
                        else
                        {
                            cellOffset                     = stylesArray[styleOffset].StartCell + stylesArray[styleOffset].NumCells;
                            cells[cellOffset].x            = cells[curCellOffset].x;
                            cells[cellOffset].area         = -cells[curCellOffset].area;
                            cells[cellOffset].cover        = -cells[curCellOffset].cover;
                            stylesArray[styleOffset].LastX = cells[curCellOffset].x;
                            stylesArray[styleOffset].NumCells++;
                        }
                    }
                }
                if (_activeStyleTable.Size() > 1)
                {
                    break;
                }
                ++_scanY;
            }
            ++_scanY;

            if (_layerOrder != ELayerOrder.LayerUnsorted)
            {
                VectorPOD_RangeAdaptor ra = new VectorPOD_RangeAdaptor(_activeStyleTable, 1, _activeStyleTable.Size() - 1);
                if (_layerOrder == ELayerOrder.LayerDirect)
                {
                    QuickSortRangeAdaptorUint mQSorter = new QuickSortRangeAdaptorUint();
                    mQSorter.Sort(ra);
                    //quick_sort(ra, uint_greater);
                }
                else
                {
                    throw new NotImplementedException();
                    //QuickSortRangeAdaptorUint m_QSorter = new QuickSortRangeAdaptorUint();
                    //m_QSorter.Sort(ra);
                    //quick_sort(ra, uint_less);
                }
            }

            return(_activeStyleTable.Size() - 1);
        }