// Gestisce una collezione di gels da disegnare con un certo stile (pennello)
// Gestisce le operazioni automatiche di disegno
// Permette di aggiungere o togliere gels al pannello o di azzerarli

// Esempi di stile :
// strokeStyle,    lineWidth, fillStyle,             param
// "rgb(0,0,255)", 4                                                        (fillStyle è solo per i tipi puntuali o poligonali)
// "rgb(0,0,255)", 4,         "rgba(0,144,255,0.5)"                         (radius è opzionale - solo per i tipi puntuali)
// "rgb(0,0,255)", 4,         "rgba(0,144,255,0.5)", 5                      (radius è impostato - per tipo puntuale)
// "rgb(0,0,255)", 4,         "",                    "img/pattern1.png"     (il poligono non ha fillstyle ma pattern)

// param corrisponde al radius per i tipi puntuali o alla url del pattern per i poligoni

function canvasDrawer (map, id, _type, _strokeStyle, _lineWidth, _fillStyle, _param)
{
	var canvasPanel   = null;
    var type  = _type;  // Assume i valori "Polygon" "Line" e "Point"

    var gels  = [];
    var brush;
    var strokeStyle;
    var lineWidth;
    var fillStyle;
    var param;


    function _move (map, delta)
    {
        draw (map);
    }
    
    function _refresh (map)
    {
        draw (map);
    }
    
    function _scale (map)
    {
        draw (map);
    }
    
    function pointsOutline (pointIterator, graphics)
    {
        if (pointIterator.move_next())
        {
            var geoPoint = pointIterator.get_current();
            graphics.moveTo(geoPoint.x, geoPoint.y);
        
            while (pointIterator.move_next())
            {                  
                geoPoint = pointIterator.get_current();
                graphics.lineTo(geoPoint.x, geoPoint.y);
            }
        }                      
    }
    

    function partsOutline (partIterator, coordConverter, graphics)
    {
        while (partIterator.move_next())
        {                  
            var geoPart = partIterator.get_current();
            var pointIterator = coordConverter.geo_2_dev (geoPart.get_iterator()).get_iterator();
    
            pointsOutline (pointIterator, graphics);
        }            
    }

    function draw (map) 
    {
    	canvasPanel.clear();

    	var coordConverter = map.build_converter();

        // Attiva lo stile del pennello    
        var graphics = brush.setStyle (_strokeStyle, _lineWidth, _fillStyle, _param);

        for (var i = 0; i < gels.length; i++)
        {
            var gel = gels[i];
            var partIterator = gel.get_iterator();  // Itera tra le parti
            
    	    graphics.beginPath();
    	    if (type == "Point")
    	    {
    	        partIterator.move_next();
                var geoPart = partIterator.get_current();
                var pointIterator = coordConverter.geo_2_dev (geoPart.get_iterator()).get_iterator();
                pointIterator.move_next();
    	        var geoPoint = pointIterator.get_current();
    	        brush.draw (geoPoint);
    	    }
    	    else
    	    {
        	    partsOutline (partIterator, coordConverter, graphics);
        	    
    	        if (type == "Polygon")
    	        {
                    graphics.fill();
                    if (browser_info.is_internet_explorer())
                    {
                        partIterator.reset();
    	                partsOutline (partIterator, coordConverter, graphics);
                    }    	                
                }            

                graphics.stroke();
            }                
        }            
    }

    
    this.addGel = function (gel)
    {
        gels.push (gel);
        draw(map);
    }

    this.addGels = function (arrGel, doNotRefresh)
    {
        for (var i = 0; i < arrGel.length; i++)
            gels.push (arrGel[i]);
            
        if (!doNotRefresh)
            draw(map);
    }

    
    this.removeGel = function (gel)
    {
        for (var i = 0; i < gels.length; i++)
        {
            if (gel === gels[i])
            {
                gels.splice(i,1);
                break;
            }                
        }
        draw(map);
    }
    
    this.redrawMap = function ()
    {
        draw(map);
    }
    

    this.removeGels = function (arrGel, doNotRefresh)
    {
        for (var i = 0; i < arrGel.length; i++)
        {
            for (var j = 0; j < gels.length; j++)
            {
                if (arrGel[i] === gels[j])
                {
                    gels.splice(j,1);
                    break;
                }                
            }                
        }
        if (!doNotRefresh)
            draw(map);
    }

    
    this.resetGels = function ()
    {
        gels = [];
        canvasPanel.clear();
    }


    /*********** INIZIALIZZAZIONE *************************/
    
    // Crea il vero e proprio canvas_drawer
    canvasPanel = new canvas_drawer();
	canvasPanel.unique_key = id;
	map.add_control(canvasPanel);

    // Definisci il pennello
    switch (_type)
    {
        case "Polygon":
            brush = new canvasPolygonBrush (canvasPanel.get_graphics_context());
            break;
        case "Line" :
            brush = new canvasLineBrush    (canvasPanel.get_graphics_context());
            break;
        case "Point" :
            brush = new canvasPointBrush   (canvasPanel.get_graphics_context());
            break;
    }    

    strokeStyle = _strokeStyle;
    lineWidth   = _lineWidth;  
    fillStyle   = _fillStyle;  
    param       = _param;      

	
    // Attiva lo stile del pennello    
    brush.setStyle (strokeStyle, lineWidth, fillStyle, param);


    // Attiva gli eventi
	var igo = new i_graphics_observer();
	igo.moved = _move;
    igo.refresh = _refresh;	
    igo.scaling = _scale;	
    canvasPanel.attach_graphics_observer (igo);
}