/*
 * Copyright 2005, Stephan Aßmus <superstippi@gmx.de>.
 * Copyright 2008, Andrej Spielmann <andrej.spielmann@seh.ox.ac.uk>
 * All rights reserved. Distributed under the terms of the MIT License.
 *
 * Copyright 2002-2004 Maxim Shemanarev (http://www.antigrain.com)
 *
 * A class implementing the AGG "pixel format" interface which maintains
 * a PatternHandler and pointers to blending functions implementing the
 * different BeOS "drawing_modes".
 *
 */

#include "PixelFormat.h"

#include <stdio.h>

#include "DrawingModeAdd.h"
#include "DrawingModeAlphaCC.h"
#include "DrawingModeAlphaCO.h"
#include "DrawingModeAlphaCOSolid.h"
#include "DrawingModeAlphaPC.h"
#include "DrawingModeAlphaPCSolid.h"
#include "DrawingModeAlphaPO.h"
#include "DrawingModeAlphaPOSolid.h"
#include "DrawingModeBlend.h"
#include "DrawingModeCopy.h"
#include "DrawingModeCopySolid.h"
#include "DrawingModeErase.h"
#include "DrawingModeInvert.h"
#include "DrawingModeMin.h"
#include "DrawingModeMax.h"
#include "DrawingModeOver.h"
#include "DrawingModeOverSolid.h"
#include "DrawingModeSelect.h"
#include "DrawingModeSubtract.h"

#include "DrawingModeAddSUBPIX.h"
#include "DrawingModeAlphaCCSUBPIX.h"
#include "DrawingModeAlphaCOSUBPIX.h"
#include "DrawingModeAlphaCOSolidSUBPIX.h"
#include "DrawingModeAlphaPCSUBPIX.h"
#include "DrawingModeAlphaPOSUBPIX.h"
#include "DrawingModeAlphaPOSolidSUBPIX.h"
#include "DrawingModeBlendSUBPIX.h"
#include "DrawingModeCopySUBPIX.h"
#include "DrawingModeCopySolidSUBPIX.h"
#include "DrawingModeEraseSUBPIX.h"
#include "DrawingModeInvertSUBPIX.h"
#include "DrawingModeMinSUBPIX.h"
#include "DrawingModeMaxSUBPIX.h"
#include "DrawingModeOverSUBPIX.h"
#include "DrawingModeOverSolidSUBPIX.h"
#include "DrawingModeSelectSUBPIX.h"
#include "DrawingModeSubtractSUBPIX.h"

#include "PatternHandler.h"

// blend_pixel_empty
void
blend_pixel_empty(int x, int y, const color_type& c, uint8 cover,
                                  agg_buffer* buffer, const PatternHandler* pattern)
{
        printf("blend_pixel_empty()\n");
}

// blend_hline_empty
void
blend_hline_empty(int x, int y, unsigned len,
                                  const color_type& c, uint8 cover,
                                  agg_buffer* buffer, const PatternHandler* pattern)
{
        printf("blend_hline_empty()\n");
}

// blend_vline_empty
void
blend_vline_empty(int x, int y, unsigned len,
                                  const color_type& c, uint8 cover,
                                  agg_buffer* buffer, const PatternHandler* pattern)
{
        printf("blend_vline_empty()\n");
}

// blend_solid_hspan_empty
void
blend_solid_hspan_empty(int x, int y, unsigned len,
                                                const color_type& c, const uint8* covers,
                                                agg_buffer* buffer, const PatternHandler* pattern)
{
        printf("blend_solid_hspan_empty()\n");
}

// blend_solid_hspan_subpix_empty
void
blend_solid_hspan_empty_subpix(int x, int y, unsigned len,
                                                const color_type& c, const uint8* covers,
                                                agg_buffer* buffer, const PatternHandler* pattern)
{
        printf("blend_solid_hspan_empty_subpix()\n");
}

// blend_solid_vspan_empty
void
blend_solid_vspan_empty(int x, int y,
                                                unsigned len, const color_type& c,
                                                const uint8* covers,
                                                agg_buffer* buffer, const PatternHandler* pattern)
{
        printf("blend_solid_vspan_empty()\n");
}

// blend_color_hspan_empty
void
blend_color_hspan_empty(int x, int y, unsigned len,
                                                const color_type* colors,
                                                const uint8* covers, uint8 cover,
                                                agg_buffer* buffer, const PatternHandler* pattern)
{
        printf("blend_color_hspan_empty()\n");
}

// blend_color_vspan_empty
void
blend_color_vspan_empty(int x, int y, unsigned len,
                                                const color_type* colors,
                                                const uint8* covers, uint8 cover,
                                                agg_buffer* buffer, const PatternHandler* pattern)
{
        printf("blend_color_vspan_empty()\n");
}

// #pragma mark -

// constructor
PixelFormat::PixelFormat(agg::rendering_buffer& rb,
                                                 const PatternHandler* handler)
        : fBuffer(&rb),
          fPatternHandler(handler),

          fBlendPixel(blend_pixel_empty),
          fBlendHLine(blend_hline_empty),
          fBlendVLine(blend_vline_empty),
          fBlendSolidHSpan(blend_solid_hspan_empty),
          fBlendSolidHSpanSubpix(blend_solid_hspan_empty_subpix),
          fBlendSolidVSpan(blend_solid_vspan_empty),
          fBlendColorHSpan(blend_color_hspan_empty),
          fBlendColorVSpan(blend_color_vspan_empty)
{
}

// destructor
PixelFormat::~PixelFormat()
{
}

// SetDrawingMode
void
PixelFormat::SetDrawingMode(drawing_mode mode, source_alpha alphaSrcMode,
                                                        alpha_function alphaFncMode)
{
        switch (mode) {
                // These drawing modes discard source pixels
                // which have the current low color.
                case B_OP_OVER:
                        if (fPatternHandler->IsSolid()) {
                                fBlendPixel = blend_pixel_over_solid;
                                fBlendHLine = blend_hline_over_solid;
                                fBlendSolidHSpan = blend_solid_hspan_over_solid;
                                fBlendSolidVSpan = blend_solid_vspan_over_solid;
                                fBlendSolidHSpanSubpix = blend_solid_hspan_over_solid_subpix;
                        } else {
                                fBlendPixel = blend_pixel_over;
                                fBlendHLine = blend_hline_over;
                                fBlendSolidHSpanSubpix = blend_solid_hspan_over_subpix;
                                fBlendSolidHSpan = blend_solid_hspan_over;
                                fBlendSolidVSpan = blend_solid_vspan_over;
                        }
                        fBlendColorHSpan = blend_color_hspan_over;
                        break;
                case B_OP_ERASE:
                        fBlendPixel = blend_pixel_erase;
                        fBlendHLine = blend_hline_erase;
                        fBlendSolidHSpanSubpix = blend_solid_hspan_erase_subpix;
                        fBlendSolidHSpan = blend_solid_hspan_erase;
                        fBlendSolidVSpan = blend_solid_vspan_erase;
                        fBlendColorHSpan = blend_color_hspan_erase;
                        break;
                case B_OP_INVERT:
                        fBlendPixel = blend_pixel_invert;
                        fBlendHLine = blend_hline_invert;
                        fBlendSolidHSpanSubpix = blend_solid_hspan_invert_subpix;
                        fBlendSolidHSpan = blend_solid_hspan_invert;
                        fBlendSolidVSpan = blend_solid_vspan_invert;
                        fBlendColorHSpan = blend_color_hspan_invert;
                        break;
                case B_OP_SELECT:
                        fBlendPixel = blend_pixel_select;
                        fBlendHLine = blend_hline_select;
                        fBlendSolidHSpanSubpix = blend_solid_hspan_select_subpix;
                        fBlendSolidHSpan = blend_solid_hspan_select;
                        fBlendSolidVSpan = blend_solid_vspan_select;
                        fBlendColorHSpan = blend_color_hspan_select;
                        break;

                // In these drawing modes, the current high
                // and low color are treated equally.
                case B_OP_COPY:
                        if (fPatternHandler->IsSolid()) {
                                fBlendPixel = blend_pixel_copy_solid;
                                fBlendHLine = blend_hline_copy_solid;
                                fBlendSolidHSpanSubpix = blend_solid_hspan_copy_solid_subpix;
                                fBlendSolidHSpan = blend_solid_hspan_copy_solid;
                                fBlendSolidVSpan = blend_solid_vspan_copy_solid;
                                fBlendColorHSpan = blend_color_hspan_copy_solid;
                        } else {
                                fBlendPixel = blend_pixel_copy;
                                fBlendHLine = blend_hline_copy;
                                fBlendSolidHSpanSubpix = blend_solid_hspan_copy_subpix;
                                fBlendSolidHSpan = blend_solid_hspan_copy;
                                fBlendSolidVSpan = blend_solid_vspan_copy;
                                fBlendColorHSpan = blend_color_hspan_copy;
                        }
                        break;
                case B_OP_ADD:
                        fBlendPixel = blend_pixel_add;
                        fBlendHLine = blend_hline_add;
                        fBlendSolidHSpanSubpix = blend_solid_hspan_add_subpix;
                        fBlendSolidHSpan = blend_solid_hspan_add;
                        fBlendSolidVSpan = blend_solid_vspan_add;
                        fBlendColorHSpan = blend_color_hspan_add;
                        break;
                case B_OP_SUBTRACT:
                        fBlendPixel = blend_pixel_subtract;
                        fBlendHLine = blend_hline_subtract;
                        fBlendSolidHSpanSubpix = blend_solid_hspan_subtract_subpix;
                        fBlendSolidHSpan = blend_solid_hspan_subtract;
                        fBlendSolidVSpan = blend_solid_vspan_subtract;
                        fBlendColorHSpan = blend_color_hspan_subtract;
                        break;
                case B_OP_BLEND:
                        fBlendPixel = blend_pixel_blend;
                        fBlendHLine = blend_hline_blend;
                        fBlendSolidHSpanSubpix = blend_solid_hspan_blend_subpix;
                        fBlendSolidHSpan = blend_solid_hspan_blend;
                        fBlendSolidVSpan = blend_solid_vspan_blend;
                        fBlendColorHSpan = blend_color_hspan_blend;
                        break;
                case B_OP_MIN:
                        fBlendPixel = blend_pixel_min;
                        fBlendHLine = blend_hline_min;
                        fBlendSolidHSpanSubpix = blend_solid_hspan_min_subpix;
                        fBlendSolidHSpan = blend_solid_hspan_min;
                        fBlendSolidVSpan = blend_solid_vspan_min;
                        fBlendColorHSpan = blend_color_hspan_min;
                        break;
                case B_OP_MAX:
                        fBlendPixel = blend_pixel_max;
                        fBlendHLine = blend_hline_max;
                        fBlendSolidHSpanSubpix = blend_solid_hspan_max_subpix;
                        fBlendSolidHSpan = blend_solid_hspan_max;
                        fBlendSolidVSpan = blend_solid_vspan_max;
                        fBlendColorHSpan = blend_color_hspan_max;
                        break;

                // This drawing mode is the only one considering
                // alpha at all. In B_CONSTANT_ALPHA, the alpha
                // value from the current high color is used for
                // all computations. In B_PIXEL_ALPHA, the alpha
                // is considered at every source pixel.
                // To simplify the implementation, four separate
                // DrawingMode classes are used to cover the
                // four possible combinations of alpha enabled drawing.
                case B_OP_ALPHA:
                        if (alphaSrcMode == B_CONSTANT_ALPHA) {
                                if (alphaFncMode == B_ALPHA_OVERLAY) {
                                        if (fPatternHandler->IsSolid()) {
                                                fBlendPixel = blend_pixel_alpha_co_solid;
                                                fBlendHLine = blend_hline_alpha_co_solid;
                                                fBlendSolidHSpanSubpix = blend_solid_hspan_alpha_co_solid_subpix;
                                                fBlendSolidHSpan = blend_solid_hspan_alpha_co_solid;
                                                fBlendSolidVSpan = blend_solid_vspan_alpha_co_solid;
                                        } else {
                                                fBlendPixel = blend_pixel_alpha_co;
                                                fBlendHLine = blend_hline_alpha_co;
                                                fBlendSolidHSpanSubpix = blend_solid_hspan_alpha_co_subpix;
                                                fBlendSolidHSpan = blend_solid_hspan_alpha_co;
                                                fBlendSolidVSpan = blend_solid_vspan_alpha_co;
                                        }
                                        fBlendColorHSpan = blend_color_hspan_alpha_co;
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE) {
                                        fBlendPixel = blend_pixel_alpha_cc;
                                        fBlendHLine = blend_hline_alpha_cc;
                                        fBlendSolidHSpanSubpix = blend_solid_hspan_alpha_cc_subpix;
                                        fBlendSolidHSpan = blend_solid_hspan_alpha_cc;
                                        fBlendSolidVSpan = blend_solid_vspan_alpha_cc;
                                        fBlendColorHSpan = blend_color_hspan_alpha_cc;
                                }
                        } else if (alphaSrcMode == B_PIXEL_ALPHA){
                                if (alphaFncMode == B_ALPHA_OVERLAY) {
                                        if (fPatternHandler->IsSolid()) {
                                                fBlendPixel = blend_pixel_alpha_po_solid;
                                                fBlendHLine = blend_hline_alpha_po_solid;
                                                fBlendSolidHSpanSubpix = blend_solid_hspan_alpha_po_solid_subpix;
                                                fBlendSolidHSpan = blend_solid_hspan_alpha_po_solid;
                                                fBlendSolidVSpan = blend_solid_vspan_alpha_po_solid;
                                        } else {
                                                fBlendPixel = blend_pixel_alpha_po;
                                                fBlendHLine = blend_hline_alpha_po;
                                                fBlendSolidHSpanSubpix = blend_solid_hspan_alpha_po_subpix;
                                                fBlendSolidHSpan = blend_solid_hspan_alpha_po;
                                                fBlendSolidVSpan = blend_solid_vspan_alpha_po;
                                        }
                                        fBlendColorHSpan = blend_color_hspan_alpha_po;
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE) {
                                        if (fPatternHandler->IsSolid()) {
                                                fBlendPixel = blend_pixel_alpha_pc_solid;
                                                fBlendHLine = blend_hline_alpha_pc_solid;
                                                fBlendSolidHSpanSubpix = blend_solid_hspan_alpha_pc_subpix;
                                                fBlendSolidHSpan = blend_solid_hspan_alpha_pc_solid;
                                                fBlendSolidVSpan = blend_solid_vspan_alpha_pc_solid;
                                                fBlendColorHSpan = blend_color_hspan_alpha_pc_solid;
                                        } else {
                                                fBlendPixel = blend_pixel_alpha_pc;
                                                fBlendHLine = blend_hline_alpha_pc;
                                                fBlendSolidHSpanSubpix = blend_solid_hspan_alpha_pc_subpix;
                                                fBlendSolidHSpan = blend_solid_hspan_alpha_pc;
                                                fBlendSolidVSpan = blend_solid_vspan_alpha_pc;
                                                fBlendColorHSpan = blend_color_hspan_alpha_pc;
                                        }
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_SOURCE_IN) {
                                        SetAggCompOpAdapter<alpha_src_in>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_SOURCE_OUT) {
                                        SetAggCompOpAdapter<alpha_src_out>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_SOURCE_ATOP) {
                                        SetAggCompOpAdapter<alpha_src_atop>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_DESTINATION_OVER) {
                                        SetAggCompOpAdapter<alpha_dst_over>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_DESTINATION_IN) {
                                        SetAggCompOpAdapter<alpha_dst_in>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_DESTINATION_OUT) {
                                        SetAggCompOpAdapter<alpha_dst_out>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_DESTINATION_ATOP) {
                                        SetAggCompOpAdapter<alpha_dst_atop>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_XOR) {
                                        SetAggCompOpAdapter<alpha_xor>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_CLEAR) {
                                        SetAggCompOpAdapter<alpha_clear>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_DIFFERENCE) {
                                        SetAggCompOpAdapter<alpha_difference>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_LIGHTEN) {
                                        SetAggCompOpAdapter<alpha_lighten>();
                                } else if (alphaFncMode == B_ALPHA_COMPOSITE_DARKEN) {
                                        SetAggCompOpAdapter<alpha_darken>();
                                }
                        }
                        break;

                default:
fprintf(stderr, "PixelFormat::SetDrawingMode() - drawing_mode not implemented\n");
//                      return fDrawingModeBGRA32Copy;
                        break;
        }
}