function SendDrawT(obj) {

    if (!hasKey()) {
        return;
    }

    $.ajax({
        type: 'POST',
        dataType: 'text',
        url: lng_subfolder + 'draw.asmx/addSmallDraw',
        data: {
            solt: solt,
            sid: sid,
            startPosX: parseInt(obj.startPosX),
            startPosY: parseInt(obj.startPosY),
            currentPositionX: parseInt(obj.currentPositionX),
            currentPositionY: parseInt(obj.currentPositionY),
            action: parseInt(obj.a),
            FillColorR: obj.fillColorR,
            FillColorG: obj.fillColorG,
            FillColorB: obj.fillColorB,
            LineColorR: obj.strokeColorR,
            LineColorG: obj.strokeColorG,
            LineColorB: obj.strokeColorB,
            w: obj.w,
            this_page: this_page,
            isFilled: obj.isFilled,
            ts: obj.ts
        }
//        success: function (response) {
//           
//        },
//        error: function (response) {
//        }
    });
}


function SendDrawTxt(myName, msg) {

    if (!hasKey()) {
        return;
    }

    var dateObject = new Date();
    this_ts = dateObject.getTime();
    arrayTxtKey.push(this_ts);

    $.ajax({
        type: 'POST',
        dataType: 'text',
        url: lng_subfolder + 'draw.asmx/addTxt',
        data: {
            solt: solt,
            sid: sid,
            ts: this_ts,
            myName: EncodePomi(myName),
            msg: EncodePomi(msg)
        },
        success: function (response) {
            lastSynxMsg = lastSynxMsg + 1;
        }
        //       error: function (response) {
        //       }
    });
}

function SendDrawL(obj) {

    canvasPainter.fatNode = false;

    if (!hasKey()) {
        return;
    }

    parr = new Array();

    try {
        
        for (i = 0; i < obj.p.length; i++) {
            //parr.push('{x:' + obj.p[i].x + ',y:' + obj.p[i].y + '}');
            parr.push(obj.p[i].x + ',' + obj.p[i].y);
        }

        $.ajax({
            type: 'POST',
            dataType: 'text',
            url: lng_subfolder + 'draw.asmx/AddPpencil',
            data: {
                solt: solt,
                sid: sid,
                startPosX: parseInt(obj.startPosX),
                startPosY: parseInt(obj.startPosY),
                currentPositionX: parseInt(obj.currentPositionX),
                currentPositionY: parseInt(obj.currentPositionY),
                action: parseInt(obj.a),
                FillColorR: obj.fillColorR,
                FillColorG: obj.fillColorG,
                FillColorB: obj.fillColorB,
                LineColorR: obj.strokeColorR,
                LineColorG: obj.strokeColorG,
                LineColorB: obj.strokeColorB,
                w: obj.w,
                isFilled: obj.isFilled,
                this_page: this_page,
                ts: obj.ts,
                parr: parr.toString()
            }
//            success: function (response) {
//            }

        });
    }
    catch (e) { };
}


function SendPolygon(obj) {

    if (!hasKey() || obj.p.length > 25) {
        return;
    }

    parr = new Array();

    try {
        for (i = 0; i < obj.p.length; i++) {
            parr.push(obj.p[i].x + ',' + obj.p[i].y);
        }

        $.ajax({
            type: 'POST',
            dataType: 'text',
            url: lng_subfolder + 'draw.asmx/addPolygon',
            data: {
                solt: solt,
                sid:sid,
                startPosX: parseInt(obj.startPosX),
                startPosY: parseInt(obj.startPosY),
                currentPositionX: parseInt(obj.currentPositionX),
                currentPositionY: parseInt(obj.currentPositionY),
                FillColorR: obj.fillColorR,
                FillColorG: obj.fillColorG,
                FillColorB: obj.fillColorB,
                LineColorR: obj.strokeColorR,
                LineColorG: obj.strokeColorG,
                LineColorB: obj.strokeColorB,
                w: obj.w,
                isFilled: obj.isFilled,
                this_page: this_page,
                ts: obj.ts,
                parr: parr.toString()
            }
//            success: function (response) {
//            }
        });
    }
    catch (e) { };
}

var timeCount = 0;


function timerEvent() {

    if (!hasKey()) {
        return;
    }

    timeCount++;

//    document.title = timeCount;

    if (timeCount > 10 && timeCount == 2 * parseInt(timeCount / 2)) {
        return;
    }

    if (timeCount > 50 && timeCount == 3 * parseInt(timeCount / 3)) {
        return;
    }

    if (timeCount > 100 && timeCount == 5 * parseInt(timeCount / 5)) {
        return;
    }

    if (timeCount > 7000) {
        //setTimeout("timerEvent()", 1001);
        return;
    }

 // document.title = document.title + " random ::: " + Math.floor(Math.random() * 1000000001); ;


    $.ajax({
        type: 'POST',
        dataType: 'text',
        url: lng_subfolder + 'draw.asmx/get',
        async: true,
        cache: false,
        timeout: 15000,

        data: {
            lastSynx: lastSynx,
            lastSynxMsg: lastSynxMsg,
            this_page: this_page,
            sid:sid
        },
        error: function (XMLHttpRequest, textStatus, errorThrown) {
            //addmsg("error", textStatus + " (" + errorThrown + ")");
        },
        success: function (response) {

            if (response == "x") {
                alert(wrong_address_msg);

                if (lng != "en") {
                    location.href = 'http://pomidor.com/' + lng;
                }
                else {
                    location.href = 'http://pomidor.com/';
                }


                return;
            }

            UpdateCanvas(response);

            if (siteDB.isUndo()) {
                document.getElementById("idRemoveLastNodes").style.display = "block";
            }
            else {
                document.getElementById("idRemoveLastNodes").style.display = "none";
            }

        }
    });

    //setTimeout("timerEvent()", 1001);
    
}

//function UpdateMsgBoard(response) {
//    if (response == "" || response == "e") {
//        return;
//    }

//    var arr = response.split("&");
//  //  lastSynxMsg = arr[0];

//    for (i = 0; i < arr.length; i++) {

//        var arrField = arr[i].split("_");

//        newLastSynx = parseInt(arrField[0]);
//        if (newLastSynx > lastSynxMsg) {
//            lastSynxMsg = newLastSynx;
//        }

//        newTS = parseInt(arrField[1]);
//        if ($.inArray(newTS, arrayTxtKey) == -1) {
//            addTxtMsg(DecodePomi(arrField[2]), DecodePomi(arrField[3]));
//            arrayTxtKey.push(newTS);
//        }

//    }

//}


function UpdateCanvas(response) {
    if (response == "") {
        if (location.href.indexOf("debug") > 0) {            
            alert('empty');
        }
        return;
    }
    

    var needRedraw = false;
    var arrRecord = response.split("&");

    var NewPageCount = parseInt(arrRecord[0]);
    if (pageCount < NewPageCount) {
        pageCount = NewPageCount;
        pageCountUpdate();
    }

    for (iBug = 1; iBug < arrRecord.length; iBug++) {

        var arrField = arrRecord[iBug].split("_");

        if (arrField.length == 4) {
            acceptTxt(arrField);
        }

        if (arrField.length > 15) {
            acceptDraw(arrField);
        }
       
    }

    if (needRedraw) {
        siteDB.paintDrawing();
        timeCount = 0;
    }

    function acceptTxt(arrField) {

        newLastSynx = parseInt(arrField[0]);
        if (newLastSynx > lastSynxMsg) {
            lastSynxMsg = newLastSynx;
        }

        newTS = parseInt(arrField[1]);
        if ($.inArray(newTS, arrayTxtKey) == -1) {
            addTxtMsg(DecodePomi(arrField[2]), DecodePomi(arrField[3]));
            arrayTxtKey.push(newTS);
        }

    }

    function acceptDraw(arrField) {


        var newNode = {
            'startPosX': parseInt(arrField[0]),
            'startPosY': parseInt(arrField[1]),
            'currentPositionX': parseInt(arrField[2]),
            'currentPositionY': parseInt(arrField[3]),
            'a': parseInt(arrField[4]),
            'fillColorR': parseInt(arrField[5]),
            'fillColorG': parseInt(arrField[6]),
            'fillColorB': parseInt(arrField[7]),
            'strokeColorR': parseInt(arrField[8]),
            'strokeColorG': parseInt(arrField[9]),
            'strokeColorB': parseInt(arrField[10]),
            'w': parseInt(arrField[11]),
            'isFilled': parseInt(arrField[12]),
            'solt': parseInt(arrField[13]),
            'isDeleted': parseInt(arrField[14]),
            'lastSynx': parseInt(arrField[15]),
            'ts': parseInt(arrField[16])
        }
        // 'bigtext': arrField[17],
        // 'smalltext': arrField[18]

        if (newNode.a == 0) {
            newNode['p'] = Q2P(arrField[18]);
        }

        if (newNode.a == 1) {
            newNode['p'] = Q2P(arrField[17]);
        }

        if (newNode.lastSynx > lastSynx) {
            lastSynx = newNode.lastSynx;
        }

        if (newNode.isDeleted === 1) {
            paintDrawDel(newNode.ts)
            needRedraw = true;
        }
        else if ($.inArray(newNode.ts, arrayKey) == -1) {
            arrayKey.push(newNode.ts);
            siteDB.drawing.push(newNode);
            needRedraw = true;
        }
    }


}

function Q2P(objQ) {

    p = new Array();

    var q = objQ.split(",")

    for (i = 0; i < q.length; i++) {
        x = q[i];
        i++;
        y = q[i];
        p[p.length] = { x: x, y: y };
    }

    return p;
}


function paintDrawDel(my_ts) {

    for (var i = 0; i < siteDB.drawing.length; i++) {
        var drawingNode = siteDB.drawing[i];

        if (my_ts == drawingNode.ts) {
            siteDB.drawing.splice(i, 1);
            break;
        }
    }
};

function siteDB() {

    this.drawing = new Array();

    this.recordAction = function () {


        if (!canvasPainter.fatNode && canvasPainter.curDrawAction == 0) {
            if (canvasPainter.startPos.x == canvasPainter.currentPosition.x &&
                canvasPainter.startPos.y == canvasPainter.currentPosition.y) {
                return; 
            }
        }

        if (canvasPainter.curDrawAction != 0) {
            document.getElementById("idRemoveLastNodes").style.display = "block";
        }

        if (canvasPainter.fatNode && canvasPainter.curDrawAction < 2) {
            var currentNode = this.drawing[canvasPainter.currentNodeIndex];
            currentNode.p[currentNode.p.length] = canvasPainter.currentPosition;
        }
        else {
            this.drawing.push(this.addNode());
            canvasPainter.currentNodeIndex = this.drawing.length - 1;

            if (canvasPainter.curDrawAction < 2) {
                canvasPainter.fatNode = true;
            }
        }
    };

    this.addNode = function () {

        var drawingNode = new Object()

        drawingNode.solt = solt;

        drawingNode.startPosX = canvasPainter.startPos.x;
        drawingNode.startPosY = canvasPainter.startPos.y;
        drawingNode.currentPositionX = canvasPainter.currentPosition.x;
        drawingNode.currentPositionY = canvasPainter.currentPosition.y;
        drawingNode.a = canvasPainter.curDrawAction;


        drawingNode.fillColorR = canvasPainter.FillColorR;
        drawingNode.fillColorG = canvasPainter.FillColorG;
        drawingNode.fillColorB = canvasPainter.FillColorB;

        drawingNode.strokeColorR = canvasPainter.LineColorR;
        drawingNode.strokeColorG = canvasPainter.LineColorG;
        drawingNode.strokeColorB = canvasPainter.LineColorB;

        drawingNode.isFilled = canvasPainter.isFilled;
        drawingNode.w = context.lineWidth / canvasScale;

        var dateObject = new Date();
        drawingNode.ts = dateObject.getTime();

        arrayKey.push(drawingNode.ts);

        if (canvasPainter.curDrawAction == 2) {

            drawingNode.a = 5;
            //            drawingNode.startPosX = canvasPainter.startPos.x - canvasPainter.erzWidth;
            //            drawingNode.startPosY = canvasPainter.startPos.y - canvasPainter.erzWidth;
            //            drawingNode.currentPositionX = canvasPainter.startPos.x + canvasPainter.erzWidth;
            //            drawingNode.currentPositionY = canvasPainter.startPos.y + canvasPainter.erzWidth;

            //            if (canvasPainter.startPos.x != canvasPainter.currentPosition.x || canvasPainter.startPos.y != canvasPainter.currentPosition.y) {
            drawingNode.startPosX = canvasPainter.startPos.x;
            drawingNode.startPosY = canvasPainter.startPos.y;
            drawingNode.currentPositionX = canvasPainter.currentPosition.x;
            drawingNode.currentPositionY = canvasPainter.currentPosition.y;
            //            } 

            drawingNode.fillColorR = 255;
            drawingNode.fillColorG = 255;
            drawingNode.fillColorB = 255;
            drawingNode.strokeColorR = 255;
            drawingNode.strokeColorG = 255;
            drawingNode.strokeColorB = 255;
            drawingNode.w = 1;
            drawingNode.isFilled = 1;

        }


//        if (canvasPainter.curDrawAction == 5) {

//            if (canvasPainter.startPos.x == canvasPainter.currentPosition.x && canvasPainter.startPos.y == canvasPainter.currentPosition.y) {

//                drawingNode.startPosX = canvasPainter.startPos.x - canvasPainter.drawWidth;
//                drawingNode.startPosY = canvasPainter.startPos.y - canvasPainter.drawWidth;
//                drawingNode.currentPositionX = canvasPainter.startPos.x + canvasPainter.drawWidth;
//                drawingNode.currentPositionY = canvasPainter.startPos.y + canvasPainter.drawWidth;

//                drawingNode.w = 1;
//                drawingNode.isFilled = 1;
//            }
//        }


        if (canvasPainter.curDrawAction < 2) {
            drawingNode.p = new Array();
            drawingNode.p[0] = canvasPainter.startPos;
            drawingNode.p[1] = canvasPainter.currentPosition;
        }
        else {
            SendDrawT(drawingNode);
        }

        return drawingNode;
    };

    this.removeLastNode = function () {

        //canvasPainter.fatNode = false;
        // canvasPainter.mouseMoveTrigger = false;
        canvasPainter.currentNodeIndex = -1;

        if (this.drawing.length == 0) {
            document.getElementById("idRemoveLastNodes").style.display = "none";
            return;
        }
        
        var n = this.drawing.length;

        for (var i = 0; i < n; i++) {
            var drawingNode = this.drawing[n - i - 1];

            if (drawingNode.solt == solt) {
                delNode = this.drawing.splice(n - i - 1, 1);
                this.paintDrawing();
                break;
            }
        }


        if (this.isUndo()) {
            document.getElementById("idRemoveLastNodes").style.display = "block";
        }
        else {
            document.getElementById("idRemoveLastNodes").style.display = "none";
        }


        //if (delNode == null) return;

        if (!hasKey()) {
            return;
        }

        $.ajax({
            type: 'POST',
            dataType: 'text',
            url: lng_subfolder + 'draw.asmx/setDel',
            data: {
                solt: drawingNode.solt,
                ts: drawingNode.ts,
                this_page: this_page
            },
            error: function (response) {
            }
        });
    };

    this.isUndo = function () {

        for (myIndex = 0; myIndex < this.drawing.length; myIndex++) {
            var myNode = this.drawing[myIndex];
            if (myNode.solt == solt) {
                return true;
            }
        }

        return false;
    }


    this.paintDrawing = function () {

        context_fillStyle = context.fillStyle;
        context_strokeStyle = context.strokeStyle;
        context_lineWidth = context.lineWidth;

        pomi_clearCanvas();

        for (var i = 0; i < this.drawing.length; i++) {
            try {
                var drawingNode = this.drawing[i];
                context.fillStyle = 'rgb(' + drawingNode.fillColorR + ',' + drawingNode.fillColorG + ',' + drawingNode.fillColorB + ')';
                context.strokeStyle = 'rgb(' + drawingNode.strokeColorR + ',' + drawingNode.strokeColorG + ',' + drawingNode.strokeColorB + ')';
                context.lineWidth = canvasScale * drawingNode.w;
                //context.lineWidth = drawingNode.w;

                if (drawingNode.a == 0) {
                    drawLongPolygonUtil(drawingNode.isFilled, drawingNode.p);
                }
                else if (drawingNode.a == 1) {
                    drawLongPencilUtil(true, drawingNode.isFilled, drawingNode.p);
                }
                else if (drawingNode.a != 9) {
                    canvasPainter.drawActions(drawingNode.isFilled, drawingNode.a,
                    { x: drawingNode.startPosX, y: drawingNode.startPosY },
                    { x: drawingNode.currentPositionX, y: drawingNode.currentPositionY });
                }
            } catch (e) {
            }
        }

        context.fillStyle = context_fillStyle;
        context.strokeStyle = context_strokeStyle;
        context.lineWidth = context_lineWidth;


    };


};