<?xml version="1.0" encoding="UTF-8"?>
<rmml>
<!--
$RCSfile: rnmc_stdDragging.xml $
$Revision: 1011 $

last change: $Date: 2009-03-16 14:43:50 +0300 (Пн, 16 мар 2009) $
             $Author: faja $

	Lacerta Project
	version 1.0.0.1
	Copyright (C) 2007-2009 RNMC
-->

<composition name="rnmc_stdDragging" class="rnmc_stdMediaGroup">
<script><![CDATA[
//	РЕЖИМ РАБОТЫ ОБЪЕКТА
	//	Обычное Перетаксивание
	this.type = "rnmc_Dragging";
	//	Классификация
	//this.type = "rnmc_Classification";

// ======================================================================
// 			настройки
// ======================================================================
//	появление объектов ('все'/'по одному')
	this.appearanceMode = DRAGGING_APPERANCE_ALL;
//	перемешивать объекты на старте
	this.randomOnStart = false; //true;
//	перемешивать Цели  на старте
	this.randomTargetOnStart = false; ///f		

//	разрешить выбор объекта (для режима 'по одному')
	this.allowObjectSelection = true;
//	момент проверки правильности устаноки объекта
	this.checkMode = DRAGGING_CHECK_IMMEDIATELY;//DRAGGING_CHECK_ONPLACED;

//	способ подсчёта результатов (простой и с весовыми коэффициентами)
	//this.resultCountStyle = DRAGGING_SIMPLE_CHECK;  f25.01.09

//	стиль заполнения стартового места
	this.startPlaceFillMode = STARTPLACE_FILLING_REPLACE;
//	для ауто-шифта - счетчик движущихся объектов
	this.autoShiftObjectsCount = 0;
	
//PG: Возможность повторного ответа (только для CHECK_AFTER)
	this.allowMultipleAttempts = false

//	чувствительность по умолчанию
	this.sensitivity = 20;

//	поведение по умолчанию (в конкретном таскаемом объекте можно задать своё)
//	для следующих событий:
//	объект поставлен нетуда
	this.wrongPlacedBehaviour = "Undefined";
//	при постановке не попали ни в одну цель
	this.noTargetsMatchedBehaviour = DRAGGING_RETURN_TO_START; 
    
	
//	настройки положения корзины
	this.trashBoxX = 0;
	this.trashBoxY = 0;

//	Данные статистики	========================
//	количество ошибок
	this.attempts = 0;   //кол попыток	
//	============================================

	this.regPointType = "LEFT_TOP";
//	this.regPointType = "CENTER";
//	this.regPointType = "MOUSE";
//	this.regPointType = "CUSTOM";
	this.regPointX = 0;
	this.regPointY = 0;
//F для быстрого возврата на место	
    this.flowquick = false;
//F	ПОЯВЛЕНИЕ кнопки "проверить" после установки объектов (только для CHECK_AFTER)
//F   если осталось targ или  drag
	this.appearanceCheck_targ = 0;
	this.appearanceCheck_drag = 0;
	this.showBtnCheck = false;
//	массив стартовых позиций
	this.startPlaces = null;	
//	массив объектов-целей
	this.targetsArray = null;
	this.targetsNoRandom = new Array();   //f список целей в порядке поступления
//	массив классов	(CLASSIFICACTION ONLY!!!)(DRAGGING  F )
	this.dragObjectsClasses = null;
//	массив таскаемых объектов
	this.dragObjects = null;
// количество оставшихся объектов, которые необходимо расставить
	this.dragObjectsRemaining = 0;	
//f   если есть 2  или более порции таскаемых объектов
    this.thereIsClass = false;	//f
    this.thereIsClassVisible = null;	//f  видимый в данный момент
	this.ClassFinished = 0;   //f   количество выполненных классов
	this.ClassAction = null;	//f   для Action классов
	this.ClassOwnStartplaces = false;   //f  если в каком-то классе есть свой startplaces
	this.ClassChangeStartplaces = false;   //f  произошла замена startplaces
	this.ExecClasses = new Array();    //f массив выполнения классов 0-не вып  1-вып
	this.random_Class_order = false;  //f  порядок выполнения классов произвольный или нет
	this.random_Class_orderArray = new Array(); //f САМ порядок выполнения классов
// количество одинаковых таскаемых объектов
	this.quantity = 1;
	
//	Специализированные кнопки (а зачем я не знаю, мона
//	генерить action на лету - тада даже если их нет - ничо страшного)
	this.btnPreviousDragObject = null;
	this.btnNextDragObject = null;
	this.btnCheck = null;
	this.btnReset = null;
	
	this.btnPrevClass = null;   //f21.01
	this.btnNextClass = null;   //f21.01
	
	function initFromNode(srcNode, useDelayLoad){
		var xmlNode = null;
		var xmlAttributeMap = null;
		var xmlAttribute = null;

		xmlAttributeMap = srcNode.attributes;
		if (xmlAttributeMap){
			xmlAttribute = xmlAttributeMap.getNamedItem("id");
			if (xmlAttribute != null && xmlAttribute.specified)
				this.id = xmlAttribute.value;
			xmlAttribute = xmlAttributeMap.getNamedItem("visible");
			if (xmlAttribute != null && xmlAttribute.specified){
				if(xmlAttribute.value == "true")
					this.visibility = OBJECT_VISIBILITY_TRUE;
				else if(xmlAttribute.value == "false")
					this.visibility = OBJECT_VISIBILITY_FALSE;
			}
			xmlAttribute = xmlAttributeMap.getNamedItem("enabled");
			if (xmlAttribute != null && xmlAttribute.specified
				&& xmlAttribute.value.toLowerCase() == "false")
				this.disabled = true;
				
			xmlAttribute = xmlAttributeMap.getNamedItem("type");
			if (xmlAttribute != null && xmlAttribute.specified){
				if (xmlAttribute.value.toLowerCase() == "dragging")
					this.type = "rnmc_Dragging";
				else if (xmlAttribute.value.toLowerCase() == "classification"){
					this.type = "rnmc_Classification";
				}
			}			
		}

		this.childObjects = new Array();
		if(this.type == "rnmc_Dragging"){
			this.dragObjects = new Array();
		} else if(this.type == "rnmc_Classification"){
			this.dragObjectsClasses = new Array();
		}

		this.targetsArray = new Array();
		this.startPlaces = new Array();
		this.startTargetsPlaces = new Array();   ///f области целей
		//this.deltaTargetsPlaces = new Array();   ///f для разницы между областью цели и прикреплённых к ней объектов 

		this.loadChildsObject(srcNode);

		xmlNode = srcNode.firstChild;
		while(xmlNode){
			if(xmlNode.nodeName == "settings"
				|| xmlNode.nodeName == "param"){

			// разбор стандартных настроек
				this.parseParamNode(xmlNode);

				var settingNode = xmlNode.firstChild;

			// разбор специфичных настроек
				while(settingNode){
					if(settingNode.nodeName == "trashbox"){
						xmlAttributeMap = settingNode.attributes;
						if (xmlAttributeMap){
							xmlAttribute =  xmlAttributeMap.getNamedItem("x");
							if (xmlAttribute != null && xmlAttribute.specified){
								this.trashBoxX = parseInt(xmlAttribute.value);
							};
							xmlAttribute =  xmlAttributeMap.getNamedItem("y");
							if (xmlAttribute != null && xmlAttribute.specified){
								this.trashBoxY = parseInt(xmlAttribute.value);
							};
						}
					} else if(settingNode.nodeName == "result"){
						xmlAttributeMap = settingNode.attributes;
						xmlAttribute = xmlAttributeMap.getNamedItem("mode");
						if (xmlAttribute != null && xmlAttribute.specified){
							if(xmlAttribute.value == "SIMPLE_COUNT"){
								//	простой подсчёт результатов - типа если поставлена
								//	галка не там где надо - ошибка сразу, процент 0
								//this.resultCountStyle = DRAGGING_SIMPLE_CHECK;
								this.crAlgorithm = "discrete";
							} else if(xmlAttribute.value == "MXK_COUNT"){
								//this.resultCountStyle = DRAGGING_MXK_CHECK;	
								this.crAlgorithm = "smooth_err";
							} else if(xmlAttribute.value == "MISTAKE_COUNT"){
								//this.resultCountStyle = DRAGGING_MISTAKE_CHECK;	
								this.crAlgorithm = "smooth";
							}
						}
					} else if(settingNode.nodeName == "dragobjects"){
						xmlAttributeMap = settingNode.attributes;
						if (xmlAttributeMap){
							xmlAttribute =  xmlAttributeMap.getNamedItem("sensitivity");
							if (xmlAttribute != null && xmlAttribute.specified){
								this.sensitivity = parseInt(xmlAttribute.value);
							};
						}
						xmlAttribute =  xmlAttributeMap.getNamedItem("checkMode");
						if (xmlAttribute != null && xmlAttribute.specified){
							if(xmlAttribute.value == "CHECK_AFTER"){
						//	означает что расположение будет проверяться после
						// нажатия кнопки проверить
								this.checkMode = DRAGGING_CHECK_AFTER;
							} else if(xmlAttribute.value == "CHECK_IMMEDIATELY"){
						//	означает что расположение будет проверяться сразу
								this.checkMode = DRAGGING_CHECK_IMMEDIATELY;
							}
						};
						xmlAttribute =  xmlAttributeMap.getNamedItem("regPoint");
						if (xmlAttribute != null && xmlAttribute.specified){
							switch(xmlAttribute.value){
							case "LEFT_TOP":
								this.regPointType = "LEFT_TOP";
								break;
							case "CENTER":
								this.regPointType = "CENTER";
								break;
							case "MOUSE":
								this.regPointType = "MOUSE";
								break;
							default:
							//	если указан конкретный регпоинт: 10;10
								var regPointCoords = (xmlAttribute.value).split(";");
								if(regPointCoords.length == 2){
									this.regPointType = "CUSTOM";
									this.regPointX = parseInt(regPointCoords[0]);
									this.regPointY = parseInt(regPointCoords[1]);
								}
								break;
							}
						};
						xmlAttribute =  xmlAttributeMap.getNamedItem("flowquick");  //f
// trace("flowquick"+xmlAttribute);
					    if (xmlAttribute != null && xmlAttribute.specified){					
					         if(xmlAttribute.value == "true")
							    this.flowquick = true;
					    };
						xmlAttribute =  xmlAttributeMap.getNamedItem("appearanceCheck_targ");  //f					  
					    if (xmlAttribute != null && xmlAttribute.specified){					        
								this.appearanceCheck_targ = parseInt(xmlAttribute.value);
								
					    };
						xmlAttribute =  xmlAttributeMap.getNamedItem("appearanceCheck_drag");  //f					  
					    if (xmlAttribute != null && xmlAttribute.specified){					        
								this.appearanceCheck_drag = parseInt(xmlAttribute.value);
								
					    };
					} else if(settingNode.nodeName == "appearance"){
						xmlAttributeMap = settingNode.attributes;
						if (xmlAttributeMap){
							xmlAttribute =  xmlAttributeMap.getNamedItem("random");
							if (xmlAttribute != null && xmlAttribute.specified){
								if(xmlAttribute.value == "true"){
									this.randomOnStart = true;
								} else if (xmlAttribute.value == "false"){
									this.randomOnStart = false;
								}
							};
							
							xmlAttribute =  xmlAttributeMap.getNamedItem("random_target");
							if (xmlAttribute != null && xmlAttribute.specified){
							//trace("Child.Object  "+this.childObjects);
								if(xmlAttribute.value.toLowerCase() == "true"){
									this.randomTargetOnStart = true;
								} else if (xmlAttribute.value.toLowerCase() == "false"){
									this.randomTargetOnStart = false;
								}
							};
							//trace("randomTargetOnStart= "+ this.randomTargetOnStart);
							xmlAttribute =  xmlAttributeMap.getNamedItem("select");
							if (xmlAttribute != null && xmlAttribute.specified){
								if(xmlAttribute.value == "true"){
									this.allowObjectSelection = true;
								} else if (xmlAttribute.value == "false"){
									this.allowObjectSelection = false;
								}
							};
							xmlAttribute =  xmlAttributeMap.getNamedItem("mode");
							if (xmlAttribute != null && xmlAttribute.specified){
								if(xmlAttribute.value == "all"){
									this.appearanceMode = DRAGGING_APPERANCE_ALL;
								} else if (xmlAttribute.value == "one"){
									this.appearanceMode = DRAGGING_APPERANCE_ONE;
								}
							};
							xmlAttribute = xmlAttributeMap.getNamedItem("thereIsClass");  ///ff
			                    if (xmlAttribute != null && xmlAttribute.specified){				
				                     if(xmlAttribute.value.toLowerCase() == "true"){
					                     this.thereIsClass = true;
										 if(this.type == "rnmc_Dragging"){
		                            	     this.dragObjectsClasses = new Array();	
											 this.ClassAction = new Array();
											 this.startPlacesAdd = new Array();   ///массив массивов для новых startplase 
											 this.ClassPlacesAdd = new Array();   ///массив id klaccoв параллельно  с this.startPlacesAdd 
											 this.totalRightClassTarget = 0;       //для подсчёта правильно поставленных в классах: сколько должно быть прав  
											 this.totalRightClassDrag = 0;       //для подсчёта правильно поставленных в классах:  сколько прав пост
										 }
                                     }										 
		                 	};
						//PG: Разрешение расставлять объекты несколько раз
						// 	(после проверки по требованию пользователя)
							xmlAttribute = xmlAttributeMap.getNamedItem("allowMultiple");
							if (xmlAttribute != null && xmlAttribute.specified){
								if(xmlAttribute.value.toLowerCase() == "true")
									this.allowMultipleAttempts = true;
								else if(xmlAttribute.value.toLowerCase() == "false")
									this.allowMultipleAttempts = false;
							}
							// мешается порядок вывода классов
							// переход к след классу осуществл с пом кнопок btnNextClass и btnPrevClass 
							xmlAttribute = xmlAttributeMap.getNamedItem("random_Class_order");
							if (xmlAttribute != null && xmlAttribute.specified){
							    if(xmlAttribute.value.toLowerCase() == "true"){
					                this.random_Class_order = true;
							    }	
                            }							
						}
					} else if(settingNode.nodeName == "behaviour"){
						xmlAttributeMap = settingNode.attributes;
						if (xmlAttributeMap){
							xmlAttribute =  xmlAttributeMap.getNamedItem("placedWrong");
							if (xmlAttribute != null && xmlAttribute.specified){
								switch(xmlAttribute.value){
								case "moveToTrashBox":
									this.wrongPlacedBehaviour = DRAGGING_MOVE_TO_TRASHBOX;
									break;
								case "returnToStart":
									this.wrongPlacedBehaviour = DRAGGING_RETURN_TO_START;
									break;
								case "removeFromScreen":
									this.wrongPlacedBehaviour = DRAGGING_REMOVE_FROM_SCREEN;
									break;
								case "leaveInPlace":
									this.wrongPlacedBehaviour = DRAGGING_LEAVE_IN_PLACE;
									break;
								}
							};
							xmlAttribute =  xmlAttributeMap.getNamedItem("noTargetsMatched");
							if (xmlAttribute != null && xmlAttribute.specified){
								switch(xmlAttribute.value){
								case "moveToTrashBox":
									this.noTargetsMatchedBehaviour = DRAGGING_MOVE_TO_TRASHBOX;
									break;
								case "returnToStart":
									this.noTargetsMatchedBehaviour = DRAGGING_RETURN_TO_START;
									break;
								case "removeFromScreen":
									this.noTargetsMatchedBehaviour = DRAGGING_REMOVE_FROM_SCREEN;
									break;
								}
							};
							/////this.noTargetsMatchedBehaviour
						}
					} else if(settingNode.nodeName == "startplaces"){
						xmlAttributeMap = settingNode.attributes;
						if (xmlAttributeMap){
							xmlAttribute =  xmlAttributeMap.getNamedItem("fillMode");
							if (xmlAttribute != null && xmlAttribute.specified){
								switch(xmlAttribute.value){
								case "AUTO_SHIFT":
									this.startPlaceFillMode = STARTPLACE_FILLING_AUTOSHIFT;
									break;
								case "REPLACE":
									this.startPlaceFillMode = STARTPLACE_FILLING_REPLACE;
									 break;
								}
							};
						}
						var startPlaceNode = settingNode.firstChild;
						while(startPlaceNode){
							if(startPlaceNode.nodeName == "place"){
								var startPlaceX = 0;
								var startPlaceY = 0;
								var startPlaceWidth = 0;
								var startPlaceHeight = 0;
								var startPlaceSensitivity = 30;
								var quantity = 1;
								xmlAttributeMap = startPlaceNode.attributes;
								if (xmlAttributeMap){
									xmlAttribute =  xmlAttributeMap.getNamedItem("x");
									if (xmlAttribute != null && xmlAttribute.specified){
										startPlaceX = parseInt(xmlAttribute.value);
									};
									xmlAttribute =  xmlAttributeMap.getNamedItem("y");
									if (xmlAttribute != null && xmlAttribute.specified){
										startPlaceY = parseInt(xmlAttribute.value);
									};
									xmlAttribute =  xmlAttributeMap.getNamedItem("width");
									if (xmlAttribute != null && xmlAttribute.specified){
										startPlaceWidth = parseInt(xmlAttribute.value);
									};
									xmlAttribute =  xmlAttributeMap.getNamedItem("height");
									if (xmlAttribute != null && xmlAttribute.specified){
										startPlaceHeight = parseInt(xmlAttribute.value);
									};
									xmlAttribute =  xmlAttributeMap.getNamedItem("quantity");
									if (xmlAttribute != null && xmlAttribute.specified){
										quantity = parseInt(xmlAttribute.value);										
									};
								}
								var newPlaceCoords = new Array(startPlaceX, startPlaceY,
															startPlaceWidth, startPlaceHeight,
															startPlaceSensitivity);
								newPlaceCoords.freePlace = true;
								newPlaceCoords.objectIndex = -1;
								this.startPlaces.push(newPlaceCoords);
								if (quantity > 1){
									for(var i = 1; i < quantity; i++){
										var newPlaceCoords2 = new Array(startPlaceX, startPlaceY,
															startPlaceWidth, startPlaceHeight,
															startPlaceSensitivity);
										newPlaceCoords2.freePlace = true;
										newPlaceCoords2.objectIndex = -1;
										this.startPlaces.push(newPlaceCoords2);
									}
								}
							}
							startPlaceNode = startPlaceNode.nextSibling;
						}
//trace("place_  "+this.startPlaces);  //neputannie!!!
					};
					settingNode = settingNode.nextSibling;
				};
				
			//PG: Установить поведение по-умолчанию для объекта поставленного не в свою цель,
			// для проверки "на месте" - это (вернуться в стартовую позицию)
			// для проверки по требованию - это остаться на своем месте
				if (this.wrongPlacedBehaviour == "Undefined"){
					switch (this.checkMode) {
						case DRAGGING_CHECK_AFTER:
						this.wrongPlacedBehaviour = DRAGGING_LEAVE_IN_PLACE;
							break;

						case DRAGGING_CHECK_IMMEDIATELY:
						default:
							this.wrongPlacedBehaviour = DRAGGING_RETURN_TO_START;						
							break;
					}
				}
			} else if(xmlNode.nodeName == "actions"){
				this.parseActionsNode(xmlNode);

				this.onAllObjectsPlacedActions =
					scene.Utils.parseActionsNode(xmlNode, "onAllObjectsPlaced");
	
	// Для совместимости со старым синтаксисом
				if (!this.onAllObjectsPlacedActions)
					this.onAllObjectsPlacedActions =
						scene.Utils.parseActionsNode(xmlNode, "onAllObjectPlaced");
			// конец части совместимости со старым синтаксисом

				this.onPlacedRightActions =
					scene.Utils.parseActionsNode(xmlNode, "onPlacedRight");
				this.onPlacedWrongActions =
					scene.Utils.parseActionsNode(xmlNode, "onPlacedWrong");
				this.onAllObjectsPlacedActionsRight =
					scene.Utils.parseActionsNode(xmlNode, "onAllObjectsPlacedRight");  ///ff
                this.onAllObjectsPlacedActionsWrong =
					scene.Utils.parseActionsNode(xmlNode, "onAllObjectsPlacedWrong");	 ///ff	
				this.onAllObjectPlacedClassActions =
					scene.Utils.parseActionsNode(xmlNode, "onAllObjectPlacedClass");   //fff
				
//trace("426--"+this.onAllObjectsPlacedActionsRight);	
			// Нужно добавить следующие события:
			//НадЗонойОбъект, НадЗонойПравильныйОбъект, НадЗонойНеправильныйОбъект
			} else if(xmlNode.nodeName == "effects"){
				this.parseEffectsNode(xmlNode);
			} else if(xmlNode.nodeName == "objectives"){
				this.parseObjectivesNode(xmlNode);
			} else if(xmlNode.nodeName == "conditions"){
				var conditionNode = xmlNode.firstChild;
				while(conditionNode){
					if(conditionNode.nodeName == "condition"){
						this.parseConditionNode(conditionNode);
					}
					conditionNode = conditionNode.nextSibling;
				}
				this.parseConditionNode(xmlNode);
			} else if(xmlNode.nodeName == "properties"){
				this.parsePropertiesNode(xmlNode);
			} else if(xmlNode.nodeName == "dragobject" && this.type == "rnmc_Dragging"){
				var newObject = new Composition();
				newObject._class = "dragging_dragobject";
				newObject.parent = this;
				newObject.visible = false;
			//	задание настроек по умолчанию
				newObject.sensitivity = this.sensitivity;
				newObject.regPointType = this.regPointType;
				newObject.flowquick = this.flowquick;   //f
				newObject.regPointX = this.regPointX;
				newObject.regPointY = this.regPointY;
				newObject.checkMode = this.checkMode;
				newObject.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
				newObject.noTargetsMatchedBehaviour = this.noTargetsMatchedBehaviour;
				newObject.initFromNode(xmlNode);
				this.dragObjects.push(newObject);
				if (newObject.quantity > 1){
					for(var i = 1; i < newObject.quantity; i++){
						var newObject2 = new Composition();
						newObject2._class = "dragging_dragobject";
						newObject2.parent = this;
						newObject2.visible = false;
						
					//	задание настроек по умолчанию	
						newObject2.sensitivity = this.sensitivity;
						newObject2.regPointType = this.regPointType;
						newObject2.regPointX = this.regPointX;
						newObject2.regPointY = this.regPointY;
						newObject2.checkMode = this.checkMode;
						newObject2.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
						newObject2.noTargetsMatchedBehaviour = this.noTargetsMatchedBehaviour;
						newObject2.initFromNode(xmlNode);
						this.dragObjects.push(newObject2);
					}
				}
			} else if(xmlNode.nodeName == "group_drag"){	//f
				 xmlAttributeMap = xmlNode.attributes;										 
				 if (xmlAttributeMap){
					xmlAttribute =  xmlAttributeMap.getNamedItem("drag_number");
					if (xmlAttribute != null && xmlAttribute.specified){
						var num_drag = parseInt(xmlAttribute.value);
					};													
				 }
				var rand_nomer_drag = Math.round((num_drag-1)*Math.random());
				//trace("group_drag+++"+rand_nomer_drag);
				var if_rand_nom = 0;
				var startPlaceNode = xmlNode.firstChild; 
				while(startPlaceNode){
					 if(startPlaceNode.nodeName == "dragobject"){							
					     if(if_rand_nom==rand_nomer_drag){
						//trace("group_drag--"+if_rand_nom);
							var newObject = new Composition();
						    newObject._class = "dragging_dragobject";
					       	newObject.parent = this;
							newObject.visible = false;
							//	задание настроек по умолчанию
							newObject.sensitivity = this.sensitivity;
							newObject.flowquick = this.flowquick;
							newObject.checkMode = this.checkMode;
							newObject.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
							newObject.noTargetsMatchedBehaviour = this.noTargetsMatchedBehaviour;
							if(targetsList && targetsList.length > 0)
								newObject.objectTargets = targetsList;
							 newObject.initFromNode(startPlaceNode);
							this.dragObjects.push(newObject);									
							if (newObject.quantity > 1){
								for(var i = 1; i < newObject.quantity; i++){
									var newObject2 = new Composition();
									newObject2._class = "dragging_dragobject";
									newObject2.parent = this;
									newObject2.visible = false;								
									//	задание настроек по умолчанию
									newObject2.sensitivity = this.sensitivity;
									newObject2.regPointType = this.regPointType;
									newObject2.regPointX = this.regPointX;
									newObject2.regPointY = this.regPointY;
									//newObject2.flowquick = this.flowquick; 
									newObject2.checkMode = this.checkMode;
									newObject2.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
									newObject2.noTargetsMatchedBehaviour =
										this.noTargetsMatchedBehaviour;
									newObject2.initFromNode(xmlNode);
									this.dragObjects.push(newObject2);
							    }
						    }
					     }							
						if_rand_nom++;
					  }
					startPlaceNode = startPlaceNode.nextSibling;
			    }
			//f			
			} else if(xmlNode.nodeName == "class"
						&& this.type == "rnmc_Classification"){
				//trace("class");		
				var classNode =  xmlNode.firstChild;
				var newClassDragObjects = new Array();
				var targetsList = null;
				var newClassId = null;
				xmlAttributeMap = xmlNode.attributes;
				if (xmlAttributeMap){
					xmlAttribute =  xmlAttributeMap.getNamedItem("id");
					if (xmlAttribute != null && xmlAttribute.specified){
						newClassDragObjects.id = xmlAttribute.value;
						newClassId = xmlAttribute.value;
					};
				}
				while(classNode){
					if(classNode.nodeName == "param"){
						xmlAttributeMap = classNode.attributes;
						if (xmlAttributeMap){
							xmlAttribute =  xmlAttributeMap.getNamedItem("select");
							if (xmlAttribute != null && xmlAttribute.specified){
								newClassDragObjects.totalSelect = parseInt(xmlAttribute.value);
							};
							xmlAttribute =  xmlAttributeMap.getNamedItem("random");
							if (xmlAttribute != null && xmlAttribute.specified){
								if(xmlAttribute.value == "true"){
									newClassDragObjects.random = true;
								} else if (xmlAttribute.value == "false"){
									newClassDragObjects.random = false;
								}
							};
							xmlAttribute = xmlAttributeMap.getNamedItem("targets");
							if (xmlAttribute != null && xmlAttribute.specified
								&& xmlAttribute.value != ""){
								targetsList = (xmlAttribute.value).split(";");
							}
						}
					} else if(classNode.nodeName == "group_drag"){	
					     xmlAttributeMap = classNode.attributes;										 
						 if (xmlAttributeMap){
							xmlAttribute =  xmlAttributeMap.getNamedItem("drag_number");
							if (xmlAttribute != null && xmlAttribute.specified){
								var num_drag = parseInt(xmlAttribute.value);
							};													
						 }
						var rand_nomer_drag = Math.round((num_drag-1)*Math.random());
						//trace("group_drag+++"+rand_nomer_drag);
						var if_rand_nom = 0;
						var startPlaceNode = classNode.firstChild; 
						while(startPlaceNode){
						    if(startPlaceNode.nodeName == "dragobject"){							
							    if(if_rand_nom==rand_nomer_drag){
								//trace("group_drag--"+if_rand_nom);
									var newObject = new Composition();
						            newObject._class = "dragging_dragobject";
					              	newObject.parent = this;
									newObject.visible = false;
									//	задание настроек по умолчанию
									newObject.sensitivity = this.sensitivity;
									newObject.flowquick = this.flowquick;
									newObject.checkMode = this.checkMode;
									newObject.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
									newObject.noTargetsMatchedBehaviour = this.noTargetsMatchedBehaviour;
									if(targetsList && targetsList.length > 0)
										newObject.objectTargets = targetsList;
									newObject.initFromNode(startPlaceNode);
									newClassDragObjects.push(newObject);
									if (newObject.quantity > 1){
										for(var i = 1; i < newObject.quantity; i++){
											var newObject2 = new Composition();
											newObject2._class = "dragging_dragobject";
											newObject2.parent = this;
											newObject2.visible = false;
								
											//	задание настроек по умолчанию
											newObject2.sensitivity = this.sensitivity;
											newObject2.regPointType = this.regPointType;
											newObject2.regPointX = this.regPointX;
											newObject2.regPointY = this.regPointY;
											//newObject2.flowquick = this.flowquick; 
											newObject2.checkMode = this.checkMode;
											newObject2.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
											newObject2.noTargetsMatchedBehaviour =
											this.noTargetsMatchedBehaviour;
											newObject2.initFromNode(xmlNode);
											this.newClassDragObjects.push(newObject2);
							            }
						            }
					            }							
							if_rand_nom++;
						    }
						startPlaceNode = startPlaceNode.nextSibling;
                        }						
					} else if(classNode.nodeName == "dragobject"){
					//trace("dragobject  477");
						var newObject = new Composition();
						newObject._class = "dragging_dragobject";
						newObject.parent = this;
						newObject.visible = false;
					//	задание настроек по умолчанию
						newObject.sensitivity = this.sensitivity;
						newObject.flowquick = this.flowquick;
						newObject.checkMode = this.checkMode;
						newObject.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
						newObject.noTargetsMatchedBehaviour = this.noTargetsMatchedBehaviour;
						if(targetsList && targetsList.length > 0)
							newObject.objectTargets = targetsList;
						newObject.initFromNode(classNode);
						newClassDragObjects.push(newObject);
						if (newObject.quantity > 1){
							for(var i = 1; i < newObject.quantity; i++){
								var newObject2 = new Composition();
								newObject2._class = "dragging_dragobject";
								newObject2.parent = this;
								newObject2.visible = false;
								
							//	задание настроек по умолчанию
								newObject2.sensitivity = this.sensitivity;
								newObject2.regPointType = this.regPointType;
								newObject2.regPointX = this.regPointX;
								newObject2.regPointY = this.regPointY;
								//newObject2.flowquick = this.flowquick; 
								newObject2.checkMode = this.checkMode;
								newObject2.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
								newObject2.noTargetsMatchedBehaviour =
									this.noTargetsMatchedBehaviour;
								newObject2.initFromNode(xmlNode);
								this.newClassDragObjects.push(newObject2);
							}
						}
					}
					classNode = classNode.nextSibling;
				}
				
				if(newClassDragObjects.length > 0){
					this.dragObjectsClasses.push(newClassDragObjects);
				}
			///<ffff 
			} else if(xmlNode.nodeName == "class" && this.type == "rnmc_Dragging"){
				//trace("class_dr  "+xmlNode.firstChild);
                this.ExecClasses.push(0);
				if(this.random_Class_orderArray.length>0){
				     var randomlength = this.random_Class_orderArray.length;
				     this.random_Class_orderArray.push(randomlength);
				} else { 					 
                     this.random_Class_orderArray.push(0);	
                }
//trace("726--"+this.random_Class_orderArray)	;			
				var classNode =  xmlNode.firstChild;
				var newClassDragObjects = new Array();
				var targetsList = null;
				var newClassId = null;
				newClassDragObjects.random = this.randomOnStart;
				newClassDragObjects.attempts = null;
				xmlAttributeMap = xmlNode.attributes;
				if (xmlAttributeMap){
					xmlAttribute =  xmlAttributeMap.getNamedItem("id");
					if (xmlAttribute != null && xmlAttribute.specified){
						newClassDragObjects.id = xmlAttribute.value;
						newClassId = xmlAttribute.value;
					};
					xmlAttribute = xmlAttributeMap.getNamedItem("visible");  //<ffff
						if (xmlAttribute != null && xmlAttribute.specified){
                                 if(xmlAttribute.value == "true"){							
								     newClassDragObjects.totalVisible = true;
									 this.thereIsClassVisible = newClassId;
								} else {
								     newClassDragObjects.totalVisible = false;
                                }								
						}   ////fff>
				}
				while(classNode){				
					if(classNode.nodeName == "param"){
						xmlAttributeMap = classNode.attributes;
						if (xmlAttributeMap){
							xmlAttribute =  xmlAttributeMap.getNamedItem("select");
							if (xmlAttribute != null && xmlAttribute.specified){
								newClassDragObjects.totalSelect = parseInt(xmlAttribute.value);
							};
							xmlAttribute =  xmlAttributeMap.getNamedItem("random");
							if (xmlAttribute != null && xmlAttribute.specified){
								if(xmlAttribute.value == "true"){
									newClassDragObjects.random = true;
								} else if (xmlAttribute.value == "false"){
									newClassDragObjects.random = false;
								}
							};
							xmlAttribute =  xmlAttributeMap.getNamedItem("attempts");
							if (xmlAttribute != null && xmlAttribute.specified){
								newClassDragObjects.attempts = xmlAttribute.value;						
					        };
						}
					} else if(classNode.nodeName == "actions"){ ////fff					
					     this.parseActionsNode(classNode);
						 var parse_ActionArray = new Array();
			          	var parse_Action = 
						scene.Utils.parseActionsNode(classNode, "onAllObjectPlacedClass");   //fff						
						//trace("#FF0000 parse_Action[0] = "+parse_Action[0]+", parse_Action[1] = "+parse_Action[1]);
						 parse_ActionArray.push(newClassId);
						 parse_ActionArray.push(parse_Action);
					    this.ClassAction.push(parse_ActionArray);  //[0]- id класса [1]- parseActions
						//trace("dddd  586  "+this.ClassAction);						
					} else if(classNode.nodeName == "dragobject"){
					//trace("dragobject  drag");
						var newObject = new Composition();
						newObject._class = "dragging_dragobject";
						newObject.parent = this;
						newObject.visible = false;
					//	задание настроек по умолчанию
						newObject.sensitivity = this.sensitivity;
						newObject.flowquick = this.flowquick;
						newObject.checkMode = this.checkMode;
						newObject.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
						newObject.noTargetsMatchedBehaviour = this.noTargetsMatchedBehaviour;
						if(targetsList && targetsList.length > 0)
							newObject.objectTargets = targetsList;
						newObject.initFromNode(classNode);
						
						newClassDragObjects.push(newObject);
						if (newObject.quantity > 1){
							for(var i = 1; i < newObject.quantity; i++){
								var newObject2 = new Composition();
								newObject2._class = "dragging_dragobject";
								newObject2.parent = this;
								newObject2.visible = false;
								
							//	задание настроек по умолчанию
								newObject2.sensitivity = this.sensitivity;
								newObject2.regPointType = this.regPointType;
								newObject2.regPointX = this.regPointX;
								newObject2.regPointY = this.regPointY;
								//newObject2.flowquick = this.flowquick; 
								newObject2.checkMode = this.checkMode;
								newObject2.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
								newObject2.noTargetsMatchedBehaviour =
									this.noTargetsMatchedBehaviour;
								newObject2.initFromNode(xmlNode);
								this.newClassDragObjects.push(newObject2);
							}
						}
					///}
					} else if(classNode.nodeName == "group_drag"){	
					     xmlAttributeMap = classNode.attributes;										 
						 if (xmlAttributeMap){
							xmlAttribute =  xmlAttributeMap.getNamedItem("drag_number");
							if (xmlAttribute != null && xmlAttribute.specified){
								var num_drag = parseInt(xmlAttribute.value);
							};													
						}
						var rand_nomer_drag = Math.round((num_drag-1)*Math.random());
						//trace("group_drag+++"+rand_nomer_drag);
						var if_rand_nom = 0;
						var startPlaceNode = classNode.firstChild; 
						while(startPlaceNode){
						    if(startPlaceNode.nodeName == "dragobject"){							
							    if(if_rand_nom==rand_nomer_drag){
								//trace("group_drag--"+if_rand_nom);
									var newObject = new Composition();
						            newObject._class = "dragging_dragobject";
					              	newObject.parent = this;
									newObject.visible = false;
									//	задание настроек по умолчанию
									newObject.sensitivity = this.sensitivity;
									newObject.flowquick = this.flowquick;
									newObject.checkMode = this.checkMode;
									newObject.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
									newObject.noTargetsMatchedBehaviour = this.noTargetsMatchedBehaviour;
									if(targetsList && targetsList.length > 0)
										newObject.objectTargets = targetsList;
									newObject.initFromNode(startPlaceNode);
									this.newClassDragObjects.push(newObject);
									if (newObject.quantity > 1){
										for(var i = 1; i < newObject.quantity; i++){
											var newObject2 = new Composition();
											newObject2._class = "dragging_dragobject";
											newObject2.parent = this;
											newObject2.visible = false;
								
											//	задание настроек по умолчанию
											newObject2.sensitivity = this.sensitivity;
											newObject2.regPointType = this.regPointType;
											newObject2.regPointX = this.regPointX;
											newObject2.regPointY = this.regPointY;
											//newObject2.flowquick = this.flowquick; 
											newObject2.checkMode = this.checkMode;
											newObject2.wrongPlacedBehaviour = this.wrongPlacedBehaviour;
											newObject2.noTargetsMatchedBehaviour =
											this.noTargetsMatchedBehaviour;
											newObject2.initFromNode(xmlNode);
											this.newClassDragObjects.push(newObject2);
							            }
						            }
					            }							
							if_rand_nom++;
						    }
						startPlaceNode = startPlaceNode.nextSibling;
						}
					} else if(classNode.nodeName == "startplaces"){						
						xmlAttributeMap = classNode.attributes;
						this.ClassOwnStartplaces = true; 
						//if (xmlAttributeMap){
							//xmlAttribute =  xmlAttributeMap.getNamedItem("fillMode");
							//if (xmlAttribute != null && xmlAttribute.specified){
								//switch(xmlAttribute.value){
								//case "AUTO_SHIFT":
									//this.startPlaceFillMode = STARTPLACE_FILLING_AUTOSHIFT;
								//	break;
								//case "REPLACE":
									//this.startPlaceFillMode = STARTPLACE_FILLING_REPLACE;
									// break;
								//}
							//};
						//}
						var startPlaceNode = classNode.firstChild;
						var startPlaces_class = new Array();
						while(startPlaceNode){
							if(startPlaceNode.nodeName == "place"){
								var startPlaceX = 0;
								var startPlaceY = 0;
								var startPlaceWidth = 0;
								var startPlaceHeight = 0;
								var startPlaceSensitivity = 30;
								var quantity = 1;
								xmlAttributeMap = startPlaceNode.attributes;
								if (xmlAttributeMap){
									xmlAttribute =  xmlAttributeMap.getNamedItem("x");
									if (xmlAttribute != null && xmlAttribute.specified){
										startPlaceX = parseInt(xmlAttribute.value);
									};
									xmlAttribute =  xmlAttributeMap.getNamedItem("y");
									if (xmlAttribute != null && xmlAttribute.specified){
										startPlaceY = parseInt(xmlAttribute.value);
									};
									xmlAttribute =  xmlAttributeMap.getNamedItem("width");
									if (xmlAttribute != null && xmlAttribute.specified){
										startPlaceWidth = parseInt(xmlAttribute.value);
									};
									xmlAttribute =  xmlAttributeMap.getNamedItem("height");
									if (xmlAttribute != null && xmlAttribute.specified){
										startPlaceHeight = parseInt(xmlAttribute.value);
									};
									xmlAttribute =  xmlAttributeMap.getNamedItem("quantity");
									if (xmlAttribute != null && xmlAttribute.specified){
										quantity = parseInt(xmlAttribute.value);										
									};
								}
								var newPlaceCoords = new Array(startPlaceX, startPlaceY,
															startPlaceWidth, startPlaceHeight,
															startPlaceSensitivity);
								newPlaceCoords.freePlace = true;
								newPlaceCoords.objectIndex = -1;
								//var startPlaces_class = new Array();
								startPlaces_class.push(newPlaceCoords);
								if (quantity > 1){
									for(var i = 1; i < quantity; i++){
										var newPlaceCoords2 = new Array(startPlaceX, startPlaceY,
															startPlaceWidth, startPlaceHeight,
															startPlaceSensitivity);
										newPlaceCoords2.freePlace = true;
										newPlaceCoords2.objectIndex = -1;
										startPlaces_class.push(newPlaceCoords2);
									}
								}
								
							}							
							startPlaceNode = startPlaceNode.nextSibling;
						}
						this.startPlacesAdd.push(startPlaces_class);   ///массив массивов для новых startplase	
						this.ClassPlacesAdd.push(newClassId);    //только если есть свой startplase	
//trace(this.ClassPlacesAdd+"-944--- place_add   "+this.startPlacesAdd);  //neputannie!!!
					};				
					classNode = classNode.nextSibling;
				}
				//trace(newClassDragObjects.id+"---612 -- "+newClassDragObjects.random);   
				this.dragObjectsRemaining = newClassDragObjects.length;   //сколько в классе таскаемых объектов
				if(newClassDragObjects.length > 0){
				    if(newClassDragObjects.attempts == null){					
					     newClassDragObjects.attempts = newClassDragObjects.length;
					}
					this.dragObjectsClasses.push(newClassDragObjects);
					
				}  //f>	
//trace("968  --  "+this.dragObjectsClasses.length+"   в классе таскаемых объектов="+newClassDragObjects.attempts);  ///сколько классов
			} else if(xmlNode.nodeName == "target"){
			
				var newObject = new Composition();
				newObject._class = "dragging_target";
				newObject.parent = this;
				newObject.visible = false;
				newObject.initFromNode(xmlNode);
				this.targetsArray.push(newObject);
				//if(this.randomTargetOnStart){
					var newTargetsXY = new Array();
					newTargetsXY.push(newObject.targetAreas[0][0]);
					newTargetsXY.push(newObject.targetAreas[0][1]);
					this.startTargetsPlaces.push(newTargetsXY);
				//}
				this.targetsNoRandom.push(newObject.id);
				///F Добавляем в массив области целей
			//trace("  target  "+newObject.targetAreas[0][0]+"   "+newObject.targetAreas[0][1]);	
			//trace("652  this.startTargetsPlaces  "+this.startTargetsPlaces);				
			};
			//trace("conec");
			xmlNode = xmlNode.nextSibling;
		};
		//trace("conec");
	//	поиск кнопок с соответствующимим id и установка callback'ов
		for(var i = 0; i < this.childObjects.length; i++){
			if(this.childObjects[i].type == "rnmc_stdButton"){
				switch(this.childObjects[i].id){
				case "btnPreviousDragObject":
				//	надобность этого мягко говоря под вопросом
					this.btnPreviousDragObject = this.childObjects[i];
					this.childObjects[i].setReleaseCallBack(this, this.buttonDispatcher);
					break;
				case "btnNextDragObject":
				//	надобность этого мягко говоря под вопросом
					this.btnNextDragObject = this.childObjects[i];
					this.childObjects[i].setReleaseCallBack(this, this.buttonDispatcher);
					break;
				case "btnCheck":
				//	надобность этого мягко говоря под вопросом
					this.btnCheck = this.childObjects[i];					
					this.childObjects[i].setReleaseCallBack(this, this.buttonDispatcher);
					break;
				case "btnReset":
				//	надобность этого мягко говоря под вопросом
					this.btnReset = this.childObjects[i];
					this.childObjects[i].setReleaseCallBack(this, this.buttonDispatcher);
					break;
				case "btnPrevClass":
				//	ff
					this.btnPrevClass = this.childObjects[i];
					this.childObjects[i].setReleaseCallBack(this, this.buttonDispatcher);
					break;
			    case "btnNextClass":
				//	ff
					this.btnNextClass = this.childObjects[i];
					this.childObjects[i].setReleaseCallBack(this, this.buttonDispatcher);
					break;
				}	
		    }
		}
          //<f  если есть классы, они перемешиваются(random_Class_order="true") и листаются кнопками"
		if(this.type == "rnmc_Dragging" && this.thereIsClass == true && this.random_Class_order == true){		
             var myar = new Array();
	         var rClasses_ = new Array();
	         var rmax = this.random_Class_orderArray.length-1;
             var ra = this.random_Class_orderArray.length-1;
		     for (var i = 0; i<rmax+1; i++) {
	             myar[i] = this.random_Class_orderArray[i];
             }
             for (var i = 0; i<rmax+1; i++) {
	             var rr = Math.round(ra*Math.random());			
	             ra--;
	             rClasses_.push(myar[rr]);
	             myar.splice(rr, 1);
             }
		     for (var i = 0; i<rmax+1; i++) {
	             this.random_Class_orderArray[i] = rClasses_[i];
             }
			this.number_of_random_Class_orderArray = 0;	
			 var nomer = this.random_Class_orderArray[this.number_of_random_Class_orderArray];
			 this.thereIsClassVisible = this.dragObjectsClasses[nomer].id;			 
			 //for(var i = 0; i < rmax+1; i++){			
			// if(this.dragObjectsClasses[i].id == this.thereIsClassVisible){
			// }
			// }
			 
		}
//trace("1038--"+this.random_Class_orderArray+"  выбран-- "+this.thereIsClassVisible);		
		//f>	
		return true;
	}

	function showObject(){
 	//trace("!!!!showObject 678");
		if(this.type == "rnmc_Dragging"){
		 if(this.thereIsClass==false){
			if(this.startOrder)
				this.startOrder = null;
			this.startOrder = new Array();
			if(this.randomOnStart){
				var tempSequence = new Array();
				for(var i = 0; i < this.dragObjects.length; i++)
					tempSequence.push(i);
				this.startOrder = scene.Utils.permutateArray(tempSequence);
				tempSequence = null;
				//trace("startOrder "+this.startOrder);  //startOrder 3,2,1,4,0  prosto spisok
			} else {
				for(var i = 0; i < this.dragObjects.length; i++)
					this.startOrder.push(i);
			}
		 } else {
trace("1080+this.thereIsClass");   ///<f
		     //	создаём список объектов 
			if(this.dragObjects)
				this.dragObjects = null;
			this.dragObjects = new Array();
		//	набираем в него по нужному количеству из видимого в этот момент класса
			this.nextClassAttempts = 0;   ////это кол-во попыток обнуляется при переходе в след класс
			for(var i = 0; i < this.dragObjectsClasses.length; i++){
//trace(this.dragObjectsClasses[i].id+"  795  "+this.thereIsClassVisible);
			 if(this.dragObjectsClasses[i].id == this.thereIsClassVisible){
				var totalFromClass = 0;
			//	если указано кол-во объектов, которое необходимо выбрать из данного класса
			//	то учитываем, в противном случае выбираем все объекты из класса
//trace(this.dragObjectsClasses[i].id+" 1080!!!!! "+this.dragObjectsClasses[i].totalVisible);
			    var rand_drag=this.dragObjectsClasses[i].random;
				if(this.dragObjectsClasses[i].totalSelect){
					totalFromClass = this.dragObjectsClasses[i].totalSelect;
					var tempSequence = new Array();
					if(this.dragObjectsClasses[i].random){
						for(var j = 0; j < this.dragObjectsClasses[i].length; j++)
							tempSequence.push(j);
						tempSequence = scene.Utils.permutateArray(tempSequence);
					} else {
						for(var j = 0; j < this.dragObjectsClasses[i].length; j++)
							tempSequence.push(j);
					}
					for(var j = 0; j < this.dragObjectsClasses[i].totalSelect; j++){
						this.dragObjects.push(this.dragObjectsClasses[i][tempSequence[j]]);
					}
				} else {
					for(var j = 0; j < this.dragObjectsClasses[i].length; j++){
						this.dragObjects.push(this.dragObjectsClasses[i][j]);
					}
				}
			 }
			}
trace("1116----"+this.dragObjects[0].id+"    "+this.dragObjects[1].id);
			if(rand_drag){   /////this.randomOnStart
				var tempSequence = new Array();
				for(var i = 0; i < this.dragObjects.length; i++)
					tempSequence.push(i);
				this.startOrder = scene.Utils.permutateArray(tempSequence);				
				tempSequence = null;
			} else {
				this.startOrder = new Array();
				for(var i = 0; i < this.dragObjects.length; i++)
					this.startOrder.push(i);
			}
			////fff>
		 }
		} else if(this.type == "rnmc_Classification"){
		//	создаём список объектов 
			if(this.dragObjects)
				this.dragObjects = null;
			this.dragObjects = new Array();
		//	набираем в него по нужному количсетву из каждого клсаа
			for(var i = 0; i < this.dragObjectsClasses.length; i++){
				var totalFromClass = 0;
			//	если указано кол-во объектов, которое необходимо выбрать из данного класса
			//	то учитываем, в противном случае выбираем все объекты из класса
				if(this.dragObjectsClasses[i].totalSelect){
					totalFromClass = this.dragObjectsClasses[i].totalSelect;
					var tempSequence = new Array();
					if(this.dragObjectsClasses[i].random){
						for(var j = 0; j < this.dragObjectsClasses[i].length; j++)
							tempSequence.push(j);
						tempSequence = scene.Utils.permutateArray(tempSequence);
					} else {
						for(var j = 0; j < this.dragObjectsClasses[i].length; j++)
							tempSequence.push(j);
					}
					for(var j = 0; j < this.dragObjectsClasses[i].totalSelect; j++){
						this.dragObjects.push(this.dragObjectsClasses[i][tempSequence[j]]);
					}
				} else {
					for(var j = 0; j < this.dragObjectsClasses[i].length; j++){
						this.dragObjects.push(this.dragObjectsClasses[i][j]);
					}
				}
			}
			if(this.randomOnStart){
				var tempSequence = new Array();
				for(var i = 0; i < this.dragObjects.length; i++)
					tempSequence.push(i);
				this.startOrder = scene.Utils.permutateArray(tempSequence);				
				tempSequence = null;
			} else {
				this.startOrder = new Array();
				for(var i = 0; i < this.dragObjects.length; i++)
					this.startOrder.push(i);
			}
			
		}
		this.prepareStartPlace();

		if(this.checkMode == DRAGGING_CHECK_AFTER){		
			if(this.btnCheck && this.btnCheck.visibility!=OBJECT_VISIBILITY_FALSE){			
				this.btnCheck.showObject();
				this.showBtnCheck = true;
				}
			if(this.btnReset)
				this.btnReset.showObject();
		}
		if(this.allowObjectSelection){
			if(this.btnPreviousDragObject)
				this.btnPreviousDragObject.showObject();
			if(this.btnNextDragObject)
				this.btnNextDragObject.showObject();
		} else {
			if(this.btnPreviousDragObject)
				this.btnPreviousDragObject.hideObject();
			if(this.btnNextDragObject)
				this.btnNextDragObject.hideObject();
		}

		this.objectResult = 0;

		rnmc_stdMediaGroup_showObject();
	}

	function hideObject(){
		rnmc_stdMediaGroup_hideObject();
	}

	function resetObject(){
		this.resetDragObjects();
		
		for (var i = 0; i < this.targetsArray.length; ++i)
			this.targetsArray[i].removeObjectsFromTarget();
			
		rnmc_stdMediaObject_resetObject();
	}

//	обновляет объекты на старте  (ходит один раз)
	function prepareStartPlace(){
//trace("prepareStartPlace()  "+this.targetsArray[0].targetAreas);
//trace("prepareStartPlace111()  "+this.startTargetsPlaces[0]);

////<f
/////путаем области целей  -  this.startTargetsPlaces
    if(this.randomTargetOnStart){
//trace("1221--prepareStartPlace   this.deltaTargetsPlaces  ");
      var myar = new Array();
      var startTargetsPlaces_ = new Array();		 		 
      var rmax = this.startTargetsPlaces.length-1;
      var ra = this.startTargetsPlaces.length-1;
      for (var i = 0; i<rmax+1; i++) {
        myar[i] = this.startTargetsPlaces[i];
    }  
//trace("ДО:  this.startTargetsPlaces  "+this.startTargetsPlaces);
    for (var i = 0; i<rmax; i++) {
      var rr = Math.round(ra*Math.random());
// trace("rr "+rr);
	    ra--;
	    startTargetsPlaces_.push(myar[rr]);
	    myar.splice(rr, 1);
    }
		startTargetsPlaces_.push(myar[0]);
    
//trace("startTargetsPlaces_  "+startTargetsPlaces_);
//trace("ДО-posle:  this.startTargetsPlaces  "+this.startTargetsPlaces);

  //находим разницу между первоначальными и новыми(перепутанными) координатами
  //заменяем  координаты в целях
		var del_x = new Array();
		var del_y = new Array();
		for (var i = 0; i<rmax+1; i++) {
			del_x[i]=startTargetsPlaces_[i][0]-this.startTargetsPlaces[i][0];
			del_y[i]=startTargetsPlaces_[i][1]-this.startTargetsPlaces[i][1];
			this.targetsArray[i].targetAreas[0][0]=startTargetsPlaces_[i][0];
			this.targetsArray[i].targetAreas[0][1]=startTargetsPlaces_[i][1];
      
      if (this.targetsArray[i].activeMarkObject)
      {
        this.targetsArray[i].activeMarkObject.objectX += del_x[i];
				this.targetsArray[i].activeMarkObject.objectY += del_y[i];
      }
      this.targetsArray[i].activeMarkXOffset += del_x[i];
			this.targetsArray[i].activeMarkYOffset += del_y[i];
		}
 
		for (var i = 0; i<this.targetsArray.length; i++) {
//trace("1240--"+this.targetsArray[i].id+" delta "+this.targetsArray[i].deltaTargetsPlaces);
			 var ar_del=this.targetsArray[i].deltaTargetsPlaces;
			 for (var i1 = 0; i1<ar_del.length; i1++) {
			     var ar_del_ = ar_del[i1];
//trace("ar_del_  "+ar_del_);
				 for (var i2 = 0; i2<this.childObjects.length; i2++) {
//trace("vv1 "+this.childObjects[i2].id);
		        if(this.childObjects[i2].id==ar_del_[1]){
//trace(this.childObjects[i2].objectX+"x   y"+this.childObjects[i2].objectY);//prav//
              if(ar_del_[0] == "rnmc_stdImage"){//this.childObjects[i2].type==ar_del_[0] and 
                this.childObjects[i2].objectX=this.childObjects[i2].objectX+del_x[i];
                this.childObjects[i2].objectY=this.childObjects[i2].objectY+del_y[i];
              }
              if(ar_del_[0] == "rnmc_stdText"){//this.childObjects[i2].type==ar_del_[0] and 
                this.childObjects[i2].objectX=this.childObjects[i2].objectX+del_x[i];
                this.childObjects[i2].objectY=this.childObjects[i2].objectY+del_y[i];
              }
              if(ar_del_[0] == "rnmc_stdButton"){//this.childObjects[i2].type==ar_del_[0] and 
                this.childObjects[i2].x=this.childObjects[i2].x+del_x[i];
                this.childObjects[i2].y=this.childObjects[i2].y+del_y[i];
              }
              if(ar_del_[0] == "rnmc_stdQTEmulation" || ar_del_[0] == "rnmc_stdVideo"){//11.01.09
                this.childObjects[i2].objectX=this.childObjects[i2].objectX+del_x[i];
                this.childObjects[i2].objectY=this.childObjects[i2].objectY+del_y[i];
              }
              if(ar_del_[0] == "rnmc_Crossword"){//11.01.09 
// trace(this.childObjects[i2].id+"  Cross do +"+del_x[i]+"  "+this.childObjects[i2].objectX);
                //this.childObjects[i2].objectX=this.childObjects[i2].objectX+del_x[i];
                //this.childObjects[i2].objectY=this.childObjects[i2].objectY+del_y[i];
                this.childObjects[i2].setObjects(del_x[i],del_y[i]);
// trace(this.childObjects[i2].id+"  Cross  +"+del_x[i]+"  "+this.childObjects[i2].objectX);
              }
              if(ar_del_[0] == "rnmc_stdFlash"){//11.01.09 						
                this.childObjects[i2].objectX=this.childObjects[i2].objectX+del_x[i];
                this.childObjects[i2].objectY=this.childObjects[i2].objectY+del_y[i];
// trace(this.childObjects[i2].id+"  Cross  +"+del_x[i]+"  "+this.childObjects[i2].objectX);
              }
              if(ar_del_[0] == "rnmc_stdAudio"){//
                this.childObjects[i2].x=this.childObjects[i2].x+del_x[i];
                this.childObjects[i2].y=this.childObjects[i2].y+del_y[i];
                this.childObjects[i2].controlX=this.childObjects[i2].controlX+del_x[i];
                this.childObjects[i2].controlY=this.childObjects[i2].controlY+del_y[i];
              }						 
              if(ar_del_[0] == "rnmc_stdAnimation"){
                this.childObjects[i2].objectX=this.childObjects[i2].objectX+del_x[i];
                this.childObjects[i2].objectY=this.childObjects[i2].objectY+del_y[i];
              }
            }
          }
        }

		     var placeList_=this.targetsArray[i].placeList;//f для путаницы списка целей  28.01
		     for (var i3 = 0; i3<this.targetsArray[i].placeList.length; i3++) {
//trace("1287----до---"+this.targetsArray[i].placeList[i3])
				 this.targetsArray[i].placeList[i3][0] =	this.targetsArray[i].placeList[i3][0]+del_x[i];
		         this.targetsArray[i].placeList[i3][1] =	this.targetsArray[i].placeList[i3][1]+del_y[i];
//trace("1290---после--"+this.targetsArray[i].placeList[i3])				 
		     }
		}		
		
	 }	
////f>
		if(this.appearanceMode == DRAGGING_APPERANCE_ONE){
			for(var i = 0; i < this.startOrder.length; i++){
				if(!this.dragObjects[this.startOrder[i]].placed){
					this.dragObjects[this.startOrder[i]].setStartPlace(0);
					this.dragObjects[this.startOrder[i]].showObject();
					this.currentDragObject = i;
					break;
				}
			}
		} else if(this.appearanceMode == DRAGGING_APPERANCE_ALL){
		  if(this.thereIsClass == false){
		//trace("DRAGGING_APPERANCE_ALL  990");
		//	далее в зависимости от режима заполнения стартовой позиции
			if(this.startPlaceFillMode == STARTPLACE_FILLING_REPLACE){
			//	режим замещения объекта (т.е на пустом месте появляется следующий
			//	объект из набора, в том случае если он есть)
				for(var i = 0; i < this.startPlaces.length; i++){
					if(this.startPlaces[i].freePlace){
						for(var j = 0; j < this.startOrder.length; j++){
						//	перебираем таскаемые объекты в той последовательности
						//    которая startOrder
						//	и выбираем из них те, которые еще не помещены
						//    и которые еще не на старте
							if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
								this.dragObjects[this.startOrder[j]].setStartPlace(i);
								this.dragObjects[this.startOrder[j]].showObject();
								this.startPlaces[i].freePlace = false;
								this.startPlaces[i].objectIndex = j;
								break;
							} 
						}
					}
				}
			} else if(this.startPlaceFillMode == STARTPLACE_FILLING_AUTOSHIFT){
				for(var i = 0; i < this.startPlaces.length - 1; i++){
					if(this.startPlaces[i].freePlace){
					//	если текущее место свободное, то ищем на остальных местах объект
					//	и передвигаем его на это место
						var j = i;
						var objectFoundOnPlace = -1;
						while(j < this.startPlaces.length){
							if(!this.startPlaces[j].freePlace){
								var objIndex = this.startPlaces[j].objectIndex;
								this.dragObjects[this.startOrder[objIndex]].moveToStartPlace(i);
								this.startPlaces[j].freePlace = true;
								this.startPlaces[j].objectIndex = -1;
								this.startPlaces[i].freePlace = false;
								this.startPlaces[i].objectIndex = objIndex;
								objectFoundOnPlace = j;
								break;
							}
							j++;
						}
						if(objectFoundOnPlace == -1){
							for(j = 0; j < this.startOrder.length; j++){
								if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
									this.dragObjects[this.startOrder[j]].setStartPlace(i);
									this.dragObjects[this.startOrder[j]].showObject();
									this.startPlaces[i].freePlace = false;
									this.startPlaces[i].objectIndex = j;
									break;
								}
							}
						}
					}
				}
				if(this.startPlaces[this.startPlaces.length - 1].freePlace){
					for(j = 0; j < this.startOrder.length; j++){
						if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
							this.dragObjects[this.startOrder[j]].setStartPlace(this.startPlaces.length - 1);
							this.dragObjects[this.startOrder[j]].showObject();
							this.startPlaces[i].freePlace = false;
							this.startPlaces[i].objectIndex = j;
							break;
						}
					}
				}
			}
		 } else {		                    //если есть классы перетаск объектов  fffff
	//	далее в зависимости от режима заполнения стартовой позиции	
		    if(this.ClassOwnStartplaces == true){			
			     for(j = 0; j < this.ClassPlacesAdd.length; j++){      ///есть ли в этом классе свой startplase f  
				 //trace(this.startPlacesAdd+" -1060--- "+this.ClassPlacesAdd);
				  if (this.ClassPlacesAdd[j] == this.thereIsClassVisible){
				         this.startPlacesDuble = null;
					     this.startPlacesDuble = new Array();
				     for(j1 = 0; j1 < this.startPlaces.length; j1++){
					     var startPlaces_class_= this.startPlaces[j1];
						 startPlaces_class_.freePlace = true;
						 startPlaces_class_.objectIndex = -1;
					     this.startPlacesDuble[j1] = startPlaces_class_;
					 }
					 this.startPlaces = null;
					 this.startPlaces = new Array();
					// trace(this.startPlacesDuble+"=this.startPlacesDuble   "+this.startPlaces );
					 var new_startPlacesAdd = this.startPlacesAdd[j];
					 //trace("1077----new_startPlacesAdd="+new_startPlacesAdd);
				     for(j1 = 0; j1 < new_startPlacesAdd.length; j1++){  ///массив массивов для новых startplase  f
					     var startPlaces_class_ = new_startPlacesAdd[j1];
						 startPlaces_class_.freePlace = true;
						 startPlaces_class_.objectIndex = -1;
						 this.startPlaces[j1] = startPlaces_class_;					    
					 }
					 //trace("this.startPlaces    new-----"+this.startPlaces)
					 this.ClassChangeStartplaces = true;
			      }								
				}
		    } 
			if(this.startPlaceFillMode == STARTPLACE_FILLING_REPLACE){
//trace("DRAGGING_APPERANCE_ALL  1392  "+this.startPlaces.length);
			//	режим замещения объекта (т.е на пустом месте появляется следующий
			//	объект из набора, в том случае если он есть)
				for(var i = 0; i < this.startPlaces.length; i++){
//trace("1396--"+this.startPlaces[i].freePlace);
					if(this.startPlaces[i].freePlace){
						for(var j = 0; j < this.startOrder.length; j++){
						//	перебираем таскаемые объекты в той последовательности 
						//    которая startOrder
						//	и выбираем из них те, которые еще не помещены 
						//    и которые еще не на старте
						//   сначала сост 0 затем 2  из labwork_const.mjs
//trace(this.startOrder[j]+"  "+this.dragObjectsClasses[1].id+"--1403-----"+this.dragObjects[this.startOrder[j]].id);
//trace(this.dragObjects[this.startOrder[j]].objectState);
							if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){							
								this.dragObjects[this.startOrder[j]].setStartPlace(i);
								this.dragObjects[this.startOrder[j]].showObject();
								this.startPlaces[i].freePlace = false;
								this.startPlaces[i].objectIndex = j;
								break;
							} 
						}
					}
				}
			} else if(this.startPlaceFillMode == STARTPLACE_FILLING_AUTOSHIFT){
				for(var i = 0; i < this.startPlaces.length - 1; i++){
					if(this.startPlaces[i].freePlace){
					//	если текущее место свободное, то ищем на остальных местах объект
					//	и передвигаем его на это место
						var j = i;
						var objectFoundOnPlace = -1;
						while(j < this.startPlaces.length){
							if(!this.startPlaces[j].freePlace){
								var objIndex = this.startPlaces[j].objectIndex;
								this.dragObjects[this.startOrder[objIndex]].moveToStartPlace(i);
								this.startPlaces[j].freePlace = true;
								this.startPlaces[j].objectIndex = -1;
								this.startPlaces[i].freePlace = false;
								this.startPlaces[i].objectIndex = objIndex;
								objectFoundOnPlace = j;
								break;
							}
							j++;
						}
						if(objectFoundOnPlace == -1){
							for(j = 0; j < this.startOrder.length; j++){
								if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
									this.dragObjects[this.startOrder[j]].setStartPlace(i);
									this.dragObjects[this.startOrder[j]].showObject();
									this.startPlaces[i].freePlace = false;
									this.startPlaces[i].objectIndex = j;
									break;
								}
							}
						}
					}
				}
				if(this.startPlaces[this.startPlaces.length - 1].freePlace){
					for(j = 0; j < this.startOrder.length; j++){
						if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
							this.dragObjects[this.startOrder[j]].setStartPlace(this.startPlaces.length - 1);
							this.dragObjects[this.startOrder[j]].showObject();
							this.startPlaces[i].freePlace = false;
							this.startPlaces[i].objectIndex = j;
							break;
						}
					}
				}
			}
		 }
		}
	}

	function refreshStartPlace(){
//trace("1464   refreshStartPlace()");
		if(this.appearanceMode == DRAGGING_APPERANCE_ONE){
			if(this.startPlaces[0].freePlace){
				for(var i = 0; i < this.startOrder.length; i++){
					if(!this.dragObjects[this.startOrder[i]].placed){
						this.dragObjects[this.startOrder[i]].setStartPlace(0);
						this.dragObjects[this.startOrder[i]].showObject();
						this.currentDragObject = i;
						break;
					}
				}
			}
		} else if(this.appearanceMode == DRAGGING_APPERANCE_ALL && this.thereIsClass == false){
		//trace("974  DRAGGING_APPERANCE_All  "+this.startPlaceFillMode);
			//	далее в зависимости от режима заполнения стартовой позиции
			if(this.startPlaceFillMode == STARTPLACE_FILLING_REPLACE){
//trace("!!! STARTPLACE_"+this.startPlaces.length);
			//	режим замещения объекта (т.е на пустом месте появляется следующий
			//	объект из набора, в том случае если он есть)
				for(var i = 0; i < this.startPlaces.length; ++i){
					if(this.startPlaces[i].freePlace){
						for(var j = 0; j < this.startOrder.length; ++j){
					//	перебираем таскаемые объекты в той последовательности которая startOrder
					//	и выбираем из них те, которые еще не помещены и которые еще не на старте
							if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
								this.dragObjects[this.startOrder[j]].setStartPlace(i);
								this.dragObjects[this.startOrder[j]].showObject();
								this.startPlaces[i].freePlace = false;
								this.startPlaces[i].objectIndex = j;
								this.startPlaces[i].placedObject = this.dragObjects[this.startOrder[j]].id;
								break;
							} 
						}
					}
				}
			} else if(this.startPlaceFillMode == STARTPLACE_FILLING_AUTOSHIFT){
				var availableDragObjects = 0;
				for(var j = 0; j < this.startOrder.length; j++){
					if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
						availableDragObjects++;
					} 
				}
				if(availableDragObjects > 0){
					this.autoShiftObjectsCount = 0;
					var shiftFound = true;
					while(shiftFound){
						var destPlace = -1;
						var sourcePlace = -1;
						for(var i = 0; i < this.startPlaces.length; i++){
							if(this.startPlaces[i].freePlace){
								if(destPlace < 0){
									destPlace = i;
									break;
								}
							}
						}
						if(destPlace >= 0){
							//	есть свободное место
							for(var i = 0; i < this.startPlaces.length; i++){
								if(sourcePlace < 0 && i > destPlace){
									sourcePlace = i;
									break;
								}
							}
						} else {
							//	дальше нефиг делать
							shiftFound = false;
							break;
						}
						if(sourcePlace < 0){
							shiftFound = false;
							break;
						} else {
							var objIndex = this.startPlaces[sourcePlace].objectIndex;
							if(objIndex >= 0){
								if(this.dragObjects[this.startOrder[objIndex]].objectState != DRAGOBJECT_STATE_PLACED){
									this.autoShiftObjectsCount++;
									this.dragObjects[this.startOrder[objIndex]].setOnFinishMoveCallBack(this, this.onFinishAutoshiftUpdate);
									this.dragObjects[this.startOrder[objIndex]].moveToStartPlace(destPlace);
									this.startPlaces[sourcePlace].freePlace = true;
									this.startPlaces[sourcePlace].objectIndex = -1;
									this.startPlaces[destPlace].freePlace = false;
									this.startPlaces[destPlace].objectIndex = objIndex;
								}
							}
						}
					}
					if(this.autoShiftObjectsCount == 0){
						this.fillFreeStartPlaces();
					}
				}
			}
		} else if(this.appearanceMode == DRAGGING_APPERANCE_ALL && this.thereIsClass == true){  ///<f
		this.dragObjectsRemaining--;
//trace("1128  DRAGGING_APPERANCE_All  "+this.startPlaceFillMode);
			//	далее в зависимости от режима заполнения стартовой позиции
			if(this.startPlaceFillMode == STARTPLACE_FILLING_REPLACE){
//trace("1137   STARTPLACE_"+this.dragObjectsRemaining);
			//	режим замещения объекта (т.е на пустом месте появляется следующий
			//	объект из набора, в том случае если он есть)
				for(var i = 0; i < this.startPlaces.length; i++){
					if(this.startPlaces[i].freePlace){
						for(var j = 0; j < this.startOrder.length; j++){
					//	перебираем таскаемые объекты в той последовательности которая startOrder
					//	и выбираем из них те, которые еще не помещены и которые еще не на старте
							if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
								this.dragObjects[this.startOrder[j]].setStartPlace(i);
								this.dragObjects[this.startOrder[j]].showObject();
								this.startPlaces[i].freePlace = false;
								this.startPlaces[i].objectIndex = j;
								this.startPlaces[i].placedObject = this.dragObjects[this.startOrder[j]].id;
								break;
							} 
						}
					}
				}
			} else if(this.startPlaceFillMode == STARTPLACE_FILLING_AUTOSHIFT){
				var availableDragObjects = 0;
				for(var j = 0; j < this.startOrder.length; j++){
					if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
						availableDragObjects++;
					} 
				}
				if(availableDragObjects > 0){
					this.autoShiftObjectsCount = 0;
					var shiftFound = true;
					while(shiftFound){
						var destPlace = -1;
						var sourcePlace = -1;
						for(var i = 0; i < this.startPlaces.length; i++){
							if(this.startPlaces[i].freePlace){
								if(destPlace < 0){
									destPlace = i;
									break;
								}
							}
						}
						if(destPlace >= 0){
							//	есть свободное место
							for(var i = 0; i < this.startPlaces.length; i++){
								if(sourcePlace < 0 && i > destPlace){
									sourcePlace = i;
									break;
								}
							}
						} else {
						//	дальше делать нечего
							shiftFound = false;
							break;
						}
						if(sourcePlace < 0){
							shiftFound = false;
							break;
						} else {
							var objIndex = this.startPlaces[sourcePlace].objectIndex;
							if(objIndex >= 0){
								if(this.dragObjects[this.startOrder[objIndex]].objectState != DRAGOBJECT_STATE_PLACED){
									this.autoShiftObjectsCount++;
									this.dragObjects[this.startOrder[objIndex]].setOnFinishMoveCallBack(this, this.onFinishAutoshiftUpdate);
									this.dragObjects[this.startOrder[objIndex]].moveToStartPlace(destPlace);
									this.startPlaces[sourcePlace].freePlace = true;
									this.startPlaces[sourcePlace].objectIndex = -1;
									this.startPlaces[destPlace].freePlace = false;
									this.startPlaces[destPlace].objectIndex = objIndex;
								}
							}
						}
					}
					if(this.autoShiftObjectsCount == 0){
						this.fillFreeStartPlaces();
					}
				}
			}  ///f>
			if(this.dragObjectsRemaining == 0){
			//trace("1212   CONEC");
			}
		}
	}

//	для краcивого обновления стартовой позиции
	function onFinishAutoshiftUpdate(){
		this.autoShiftObjectsCount--;
		if(this.autoShiftObjectsCount == 0){
			//	обнуляем callback'и
			for(var i = 0; i < this.startPlaces.length; i++){
				if(!this.startPlaces[i].freePlace){
					var objIndex = this.startPlaces[i].objectIndex;
					this.dragObjects[this.startOrder[objIndex]].clearOnFinishMoveCallBack();
				}
			}			
			this.fillFreeStartPlaces();
		}
	}

	function fillFreeStartPlaces(){
		//	заполняем оставшиеся места новыми объектами (еще не показанными)
		var availableDragObjects = 0;
		for(var j = 0; j < this.startOrder.length; j++){
			if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
				availableDragObjects++;
			} 
		}
		if(availableDragObjects > 0){
			for(var i = 0; i < this.startPlaces.length; i++){
				if(this.startPlaces[i].freePlace){
					for(j = 0; j < this.startOrder.length; j++){
						if(this.dragObjects[this.startOrder[j]].objectState == DRAGOBJECT_STATE_BEFORESTART){
							this.dragObjects[this.startOrder[j]].setStartPlace(i);
							this.dragObjects[this.startOrder[j]].showObject();
							this.startPlaces[i].freePlace = false;
							this.startPlaces[i].objectIndex = j;
							this.startPlaces[i].placedObject = this.dragObjects[this.startOrder[j]].id;
							break;
						}
					}
				}
			}
		}
	}

//	возвращет координаты i-ого стартового места
// 	(под местом понимается ячейка под один перетаскиваемый объект)
	function getStartPlaceCoords(placeIndex){
		if(placeIndex < this.startPlaces.length){
			var placeCoords = (this.startPlaces[placeIndex]).slice(0);
			return placeCoords;
		}
	}

//	возвращет координаты мусорного бАчка :)))
	function getTrashBoxCoords(){
		var trashBoxCoords = new Array(this.trashBoxX, this.trashBoxY);
		return trashBoxCoords;
	}

//	ссобщение от таскаемого объекта об освобождении некотрой стартовой позиции
	function notifyStartPlaceFree(placeIndex){
//trace("#FF00001270   notifyStartPlaceFree(" + placeIndex + ")");
		if(placeIndex >= 0 && placeIndex < this.startPlaces.length){
			this.startPlaces[placeIndex].freePlace = true;
			this.startPlaces[placeIndex].objectIndex = -1;
			this.refreshStartPlace();
		}
	}

	function notifyStartPlaceOccupied(placeIndex){
	}

//	возвращает - свободна ли стартовая позиция
	function isStartPlaceFree(placeIndex){
		if(placeIndex >= 0 && placeIndex < this.startPlaces.length){
			return this.startPlaces[placeIndex].freePlace;
		} else {
			return false;
		}
	}

//	возвращает id объекта, усьановленного на данной стартовой позиции
	function getStartPlaceCurrentObject(placeIndex){
		if(placeIndex >= 0 && placeIndex < this.startPlaces.length){
			return this.startPlaces[placeIndex].placedObject;
		} else {
			return null;
		}
	}
	function getMatchedTargets(xCoord, yCoord){
//trace("1306 x="+xCoord+"  y="+yCoord)
		if(this.checkMode == DRAGGING_CHECK_IMMEDIATELY){
			//	режим проверки правильности постановки сразу после отпускания мыши
			var matchedTargets = new Array();
			
			for(var j = 0 ; j < this.targetsArray.length; j++){
				if(this.targetsArray[j].testMatched(xCoord, yCoord)){					
					matchedTargets.push(this.targetsArray[j].id);
//trace("1314  id="+this.targetsArray[j].id);
				}
			}
			if(matchedTargets.length > 0){
				return matchedTargets;
			} else {
				return null;
			}
		} else if(this.checkMode == DRAGGING_CHECK_AFTER){
			//	режим проверки правильности постановки сразу после отпускания мыши
			var matchedTargets = new Array();
			for(var i = 0 ; i < this.targetsArray.length; i++){
				if(this.targetsArray[i].testMatched(xCoord, yCoord)){
					matchedTargets.push(this.targetsArray[i].id);
				}
			}
			if(matchedTargets.length > 0){
				return matchedTargets;
			} else {
				return null;
			}
		}
	}

//	функция проверяет попадание на некоторую стартовую позицию (для тех случаев,
//	када можно оттаскивать объекты назад на стартовую позицию)
	function getMatchedStartPlaces(xCoord, yCoord){
		var matchedPlace = -1;
		for(var i = 0; i < this.startPlaces.length; i++){
			if(this.startPlaces[i].freePlace){	// || (this.startPlaces[i].freePlace && this.startPlaces[i].placedObject == objectId)){
				//	ищем первое свободное стартовое место, куда мона поставить
				if((Math.abs(xCoord - this.startPlaces[i][0]) < this.startPlaces[i][4]) &&
					(Math.abs(yCoord - this.startPlaces[i][1]) < this.startPlaces[i][4])){
					matchedPlace = i;
					break;
				}
			}
		}
//trace("1351   Matched start place:" + matchedPlace);
		return matchedPlace;
	}

//	возвращает следующее свободное место в цели с некоторым id
	function getFreePlace(targetId, objectWidth, objectHeight){
		for(var j = 0 ; j < this.targetsArray.length; j++){		
			if(targetsArray[j].id == targetId){
				return this.targetsArray[j].getFreePlace();
				
			}
		}
		return null;
	}
// возвращает координаты цели до random	f
    function getnoRandomTargetCoord(targetId){
		for(var j = 0 ; j < this.targetsNoRandom.length; j++){
			if(this.targetsNoRandom[j] == targetId){
 ///trace(this.targetsNoRandom[j]+"  -1384-"+this.startTargetsPlaces);			
				return this.startTargetsPlaces[j];				
			}
		}
	}
	
//	возвращает наиболее близкое место для переданных координат для некоторой цели
	function getSuitablePlace(targetId, objectX, objectY){
		for(var i = 0 ; i < this.targetsArray.length; i++){
			if(this.targetsArray[i].id == targetId){
				return this.targetsArray[i].getSuitablePlace(objectX, objectY);
			}
		}
		return -1;
	}

	function getObjectsList(targetId){
		for(var i = 0; i < this.targetsArray.length; i++){
			if(this.targetsArray[i].id == targetId){
				return this.targetsArray[i].getObjectsList();
			}
		}
	}

//	служит для подсветки
	function notifyMouseCoords(xCoord, yCoord){
		for(var i = 0; i < this.targetsArray.length; i++){
			this.targetsArray[i].notifyMouseCoords(xCoord, yCoord);
		}
	}

//	добавляет заданный объект к заданной цели на заданное место
	function addObjectToTarget(objectId, targetId, placeIndex){
//trace("addObjectToTarget: "+ targetId + ", " + placeIndex);
		for(var k = 0 ; k < this.targetsArray.length; k++){
			if(this.targetsArray[k].id == targetId){
				this.targetsArray[k].addObjectToTarget(objectId, placeIndex);
			}
		}
	}

//	удаляет заданный объект из заданной цели
	function removeObjectFromTarget(objectId, targetId){
		for(var i = 0 ; i < this.targetsArray.length; i++){
			if(targetsArray[i].id == targetId){
				this.targetsArray[i].removeObjectFromTarget(objectId);
			}
		}
	}

//
	function sendObjectToStart(objectId){
		for(var i = 0; i < this.dragObjects.length; i++){ 
			if (this.dragObjects[i].id == objectId){
				var targetStartPlace = -1;
				for(var j = 0; j < this.startPlaces.length; j++){
					if(this.startPlaces[j].freePlace){
						this.dragObjects[i].objectState = DRAGOBJECT_STATE_ONSTART;
						this.startPlaces[j].freePlace = false;
						targetStartPlace = j;
						this.dragObjects[i].moveToStartPlace(j);
						break;
					}
				}
				if(targetStartPlace == -1){
					//	значит на стартовой позиции нет места
					//	и надо отправить этото объект в пул
					this.dragObjects[i].objectState = DRAGOBJECT_STATE_BEFORESTART;
					//			DEBUG: координаты пула - 800.800
					this.dragObjects[i].moveTo(800, 800);
				}
			}
		}
	}

//	проверяет, свободна ли цель с некоторым id
	function isTargetFree(targetId){
		for(var i = 0 ; i < this.targetsArray.length; i++){
			if(this.targetsArray[i].id == targetId){
				if(this.targetsArray[i].getFreePlace()){
					return true;
				} else {
					return false;
				}
			}
		}
	}
  
  function getTarget(targetId){
		for(var i = 0 ; i < this.targetsArray.length; i++){
			if(this.targetsArray[i].id == targetId){
        return this.targetsArray[i];
			}
		}
    return null;
  }

//	перебор: предыдущий объект
	function previousDragObject(){
//trace("previousDragObject()");
		if(this.appearanceMode == DRAGGING_APPERANCE_ONE){
			var nextFound = false;
			var i = this.currentDragObject;
			while(!nextFound){
				if(i == 0){
					i = this.startOrder.length - 1;
				} else {
					i--;
				};
				if(i == this.currentDragObject){
					break;
				} else if(this.dragObjects[this.startOrder[i]].placed == false){
					nextFound = true;
					if(!this.dragObjects[this.startOrder[this.currentDragObject]].placed)
						this.dragObjects[this.startOrder[this.currentDragObject]].hideObject();
					this.dragObjects[this.startOrder[i]].setStartPlace(0);
					this.dragObjects[this.startOrder[i]].showObject();
					this.currentDragObject = i;
					break;
				}
			};
		}
	}

//	перебор: следующий объект
	function nextDragObject(){
//trace("nextDragObject()");
		if(this.appearanceMode == DRAGGING_APPERANCE_ONE)
		{
			var nextFound = false;
			var i = this.currentDragObject;
			while(!nextFound){
				if(i == this.startOrder.length - 1){
					i = 0;
				} else {
					i++;
				};
				if(i == this.currentDragObject){
					break;
				} else if(this.dragObjects[this.startOrder[i]].placed == false){
					nextFound = true;
					if(!this.dragObjects[this.startOrder[this.currentDragObject]].placed)
						this.dragObjects[this.startOrder[this.currentDragObject]].hideObject();
					this.dragObjects[this.startOrder[i]].setStartPlace(0);
					this.dragObjects[this.startOrder[i]].showObject();
					this.currentDragObject = i;
					break;
				};
			};
		}
	}

//	сброс
	function resetDragObjects(){
//trace("#FF0000resetDragObjects()  1515  "+this.dragObjects.length);
		//	устанавливаем изначальное состояние объектов
		for(var i = 0; i < this.dragObjects.length; i++){
			this.dragObjects[i].startPlace = -1;
			this.dragObjects[i].objectState = DRAGOBJECT_STATE_BEFORESTART;
            this.dragObjects[i].useHandCursor = true;
			this.dragObjects[i].hideObject();
		}
		//	очищаем стартовые позиции
		for(var i = 0; i < this.startPlaces.length; i++){
			this.startPlaces[i].freePlace = true;
			this.startPlaces[i].objectIndex = -1;
		}
		//	очищаем цели от объектов
		/*
		
		for(var i = 0; i < this.startPlaces.length; i++){
			this.startPlaces[i].freePlace = true;
			this.startPlaces[i].objectIndex = -1;
		}
		*/
		this.objectResult = 0;
		this.objectErrors = 0;
		if(this.startOrder)
			this.startOrder = null;
		this.startOrder = new Array();
		if(this.randomOnStart){
			var tempSequence = new Array();
			for(var i = 0; i < this.dragObjects.length; i++)
				tempSequence.push(i);
			this.startOrder = scene.Utils.permutateArray(tempSequence);
			tempSequence = null;
		} else {
			for(var i = 0; i < this.dragObjects.length; i++)
				this.startOrder.push(i);
		}
		if(this.checkMode == DRAGGING_CHECK_AFTER){
			if(this.btnCheck)
				this.btnCheck.showObject();
			if(this.btnReset)
				this.btnReset.showObject();
		}
		this.prepareStartPlace();
	}

//	функция проверки ДЛЯ РЕЖИМА DRAGGING_CHECK_AFTER (ТОЛЬКО!!!!!!!!!!!!!!!)
//	потому что проверяются все цели сразу, а не та в которую только что был поставлен объект
//	и если проверять ей, то кол-во ошибок росло бы мегабыстро  this.targetsArray
	function checkDragObjectsPlacement(){
		if(this.checkMode == DRAGGING_CHECK_AFTER){
			var rightPlacedObjectsArray = new Array();
			var wrongPlacedObjectsArray = new Array();
			var rightDragObjectsArray = new Array();
			var wrongDragObjectsArray = new Array();
			var rightDragObjects = 0;    ///у таскаемых объектов есть цели
			var totalDragObjects = 0;    ///всего таскаемых объектов 
			var rightPlacedObjects = 0;  ///поставлены правильно
			var wrongPlacedObjects = 0;   ///поставлены неправильно
			var untargetedPlaced = 0;     ///объект поставлен, хотя у него не задано целей
			var untargetedObjects = 0;   ///у таскаемых объектов нет целей
	
		//	считаем количество правильных объектов (т.е тех у которых вообще есть цели)
			for(var i = 0; i < this.dragObjects.length; i++){
				totalDragObjects++;
				if (this.dragObjects[i].objectTargets && this.dragObjects[i].objectTargets.length > 0){
					rightDragObjects++;
trace(this.dragObjects[i].id+"  ---"+this.dragObjects[i].objectTargets);
				} else {
					untargetedObjects++;
				}
			}

//trace("1719---"+this.dragObjects.length+"  totalDragObjects= "+totalDragObjects);
			for(var i = 0; i < this.targetsArray.length; i++){
				var currentTargetObjects = this.targetsArray[i].getObjectsList();				
				//	получаем список объектов 
				if(currentTargetObjects){
					for(var j = 0; j < currentTargetObjects.length; j++){
						var objTargets = this.getTargetsListForObject(currentTargetObjects[j]);
//trace("objTargets--"+objTargets);
						if(objTargets){
							var placedRight = false;
							for(var k = 0; k < objTargets.length; k++){
							
								if(objTargets[k] == this.targetsArray[i].id){								
									placedRight = true;
									//currentTargetObjects.placed = true;
//trace("2066--"+currentTargetObjects[j]);
									rightDragObjectsArray.push(currentTargetObjects[j]);
									break;
								}
							}
							trace("__1727__"+placedRight+"  "+this.targetsArray[i].id);
							if(placedRight){
								rightPlacedObjects++;
								rightPlacedObjectsArray.push(currentTargetObjects);								
							} else {
								wrongPlacedObjects++;
								wrongPlacedObjectsArray.push(currentTargetObjects);
							}
							
						} else {
							//	для этого объекта нет целей (хотя он стоит в данной цели)
							untargetedPlaced++;
							this.objectErrors++;
						}
					}
				} else {
					//	в данной цели нет ни одного объекта
					//	увеличиваем число ошибок на величину возможных мест в данной целе
					wrongPlacedObjects += this.targetsArray[i].getTotalPlaces();
					this.objectErrors += this.targetsArray[i].getTotalPlaces();
				}
			}
			if(rightPlacedObjects == rightDragObjects){
				if(this.onAllObjectsPlacedActions){
					for(var i = 0; i < this.onAllObjectsPlacedActions.length; i++){
						this.dispatchAction(this.onAllObjectsPlacedActions[i]);
					}
				}
				if(this.onAllObjectsPlacedActionsRight){
					for(var i = 0; i < this.onAllObjectsPlacedActionsRight.length; i++){
						this.dispatchAction(this.onAllObjectsPlacedActionsRight[i]);
					}
				}
			} else {
				if(this.onAllObjectsPlacedActionsWrong){
					for(var i = 0; i < this.onAllObjectsPlacedActionsWrong.length; i++){
						this.dispatchAction(this.onAllObjectsPlacedActionsWrong[i]);
					}
				}			
			}
			//if(this.resultCountStyle == DRAGGING_SIMPLE_CHECK){
//trace("ПРОСТАЯ ПРОВЕРКА!!!");
				//if(rightPlacedObjects == rightDragObjects && wrongPlacedObjects == 0){
					//this.objectResult = 100;
				//} else {
					//this.objectResult = 0;
				//}
			//} else if(this.resultCountStyle == DRAGGING_MXK_CHECK){
//trace("ПРОВЕРКА МХК!!!"+ rightPlacedObjects+"  "+totalDragObjects+"  "+untargetedObjects+"  "+untargetedPlaced);
				//this.objectResult = Math.round(
				//(rightPlacedObjects + (untargetedObjects - untargetedPlaced))/totalDragObjects*100);
			//} else if(this.resultCountStyle == DRAGGING_MISTAKE_CHECK){
			//trace("!!!!!!!!!!!!!!!!! == ("+rightDragObjects+"/( "+rightDragObjects+" +  "+wrongPlacedObjects+"))");
			// Если расставлены все объекты то считаем по формуле:
			//	<число расставленных>/<число попыток>*100, в противном случае - 0
 				//if(rightPlacedObjects == rightDragObjects && wrongPlacedObjects == 0){
//trace("!!!!!!!!!!!!!!!!! == ("+rightDragObjects+"/( "+rightDragObjects+" +  "+wrongPlacedObjects+"))");
					//this.objectResult = Math.round(rightDragObjects/( rightDragObjects +  wrongPlacedObjects)*100);
				//}
				//else {
					//this.objectResult = 0;
				//}
				
			}
	
		//}	
		this.objectErrors = this.objectErrors+(wrongPlacedObjects + untargetedPlaced);
	    this.attempts++; 
		 var results;    //27.01  f
         results = new scene.Utils.resultParam();
         results.init();
         results.attemptsCount = this.attempts;   //попытки
         results.rightElements = rightPlacedObjects;    //прав пост
         results.allRightElements = rightDragObjects; //прав всего
         results.wrongElements = this.objectErrors;   //
         results.allWrongElements = untargetedObjects;
		 results.allElements = "unknown";
    
         results.countResult(this.crAlgorithm);
			 
         this.objectResult = results.objectResult;
		 
		this.btnCheck.hideObject();
		this.showBtnCheck = false;
trace("2127--попыток-"+this.attempts+"  прав_пост-"+rightPlacedObjects+"  прав_всего-"+rightDragObjects+"  ошибок-"+this.objectErrors);		
		//trace("right"+rightPlacedObjectsArray);
		// trace("wrong"+wrongPlacedObjectsArray);
		
	//PG: Добавлен для поддержки возможности многократной расстановки объектов
		for(var i = 0; i < this.dragObjects.length; i++){
			if (!this.allowMultipleAttempts){
				this.dragObjects[i].useHandCursor = false;
				this.dragObjects[i].onRelease = null;
				this.dragObjects[i].onReleaseOutside = null;
				this.dragObjects[i].onPress = null;
			}
			for(var i1 = 0; i1 < rightPlacedObjectsArray.length; i1++){
				if(this.dragObjects[i].id == rightPlacedObjectsArray[i1]){
					this.dragObjects[i].placed = true;					
					this.dragObjects[i].useHandCursor = false;
					this.dragObjects[i].onRelease = null;
					this.dragObjects[i].onReleaseOutside = null;
					this.dragObjects[i].onPress = null;
				}
			}
			for(var ir = 0; ir < rightDragObjectsArray.length; ir++){
			    if(this.dragObjects[i].id == rightDragObjectsArray[ir])
				this.dragObjects[i].placed = true;
			}
		}
trace("2182--"+rightDragObjectsArray);
	
		for(var i = 0; i < this.dragObjects.length; i++){
			this.dragObjects[i].placedWrongRight();
		}
	}
	

//	для проверки в режиме DRAGGING_CHECK_IMMEDIATELY  
	function notifyObjectPlaced(objectId, isPlacedRight){
	
		var objectsRemaining = 0;
		var totalTargets = 0;
		var rightTargets = 0;
		var noTarg_in_Drag = this.dragObjects.length;
        var rightDrag = this.dragObjects.length;
		if(!isPlacedRight){
			this.objectErrors++;  //когда неправильно
		}

		this.attempts++;    //кол попыток  в режиме IMMEDIATELY для таскалок
trace("Dragging 2150---ошибок-"+this.objectErrors+"  попыток-"+this.attempts+"  всего таск-"+rightDrag)
		for(var i = 0; i < this.dragObjects.length; i++){ 
//trace("2216---dragObjects[i].objectTargets.length"+this.dragObjects[i].objectTargets.length+"  objectState="+this.dragObjects[i].objectState+"  "+this.dragObjects[i].wrongPlacedBehaviour)
			if (this.dragObjects[i].objectTargets.length > 0){
				noTarg_in_Drag--;   //у таскалок нет целей , если =0 то лишних нет
			    if(this.dragObjects[i].objectState == DRAGOBJECT_STATE_PLACED)
				   rightDrag--;   //сколько не нужно ставить
				if(this.dragObjects[i].objectState != DRAGOBJECT_STATE_PLACED &&
					this.dragObjects[i].objectState != DRAGOBJECT_STATE_INTRASHBOX &&
					this.dragObjects[i].objectState != DRAGOBJECT_STATE_REMOVE_ERROR)
					if (this.dragObjects[i].objectTargets && this.dragObjects[i].objectTargets.length)
						objectsRemaining++;
			} else {
			    if(this.dragObjects[i].objectState != DRAGOBJECT_STATE_REMOVE_ERROR)
				     objectsRemaining++;
            }			
		}    ///это в основном для практик, когда число целей соответствует числу таскалок 
		
		
//trace(objectsRemaining+"  2233   "+noTarg_in_Drag+"  "+rightDrag);//objectId
		for(var i = 0; i < this.targetsArray.length; i++){
//trace("2226--"+this.targetsArray[i].totalPlaces);		
			totalTargets += this.targetsArray[i].totalPlaces;  ///общее количество мест во всех целях
			var currentTargetObjects = this.targetsArray[i].getObjectsList();  
			if(currentTargetObjects){
				for(var j = 0; j < currentTargetObjects.length; j++){
					var objTargets = this.getTargetsListForObject(currentTargetObjects[j]);
					
					if(objTargets){
						var placedRight = false;
						for(var k = 0; k < objTargets.length; k++){
							if(objTargets[k] == this.targetsArray[i].id){
								placedRight = true;
								break;
							} else {
							     if(objTargets.targetEnabled == false){
								     placedRight = true;
									 break;
								 }
							}
						}
						if(placedRight)
							rightTargets++;   ///правильно установленные цели
					}
				}
			}
		}
trace(this.appearanceCheck_drag+"  2249---drag="+objectsRemaining+"  targ="+rightTargets+" осталось_драг="+rightDrag+" totalTargets="+totalTargets);
		//<26.01 f if(this.resultCountStyle == DRAGGING_SIMPLE_CHECK){
		//	this.objectResult = Math.round((rightTargets/totalTargets)*100)
		//} else if(this.resultCountStyle == DRAGGING_MISTAKE_CHECK){
		//// Если расставлены все объекты то считаем по формуле:
		////	<число расставленных>/<число попыток>*100, в противном случае - 0		
		//	if(rightTargets == totalTargets)
		//		this.objectResult = Math.round(totalTargets/(totalTargets + objectErrors)*100);
		//	else
		//		this.objectResult = 0;
		// 26.01 f >}
		var prov_na_konec = 1;
		if(objectsRemaining == 0){   ///f если все таскалки поставлены
		    prov_na_konec = 0;
		} else {
		  if(this.type == "rnmc_Dragging"){
		    if(rightTargets == this.targetsArray.length){
			    prov_na_konec = 0;
			} else {
				    if (this.appearanceCheck_targ==0){
					     if (this.appearanceCheck_drag == objectsRemaining  && this.appearanceCheck_drag == rightDrag)
						     prov_na_konec = 0;
					} else {
					     if (this.appearanceCheck_targ == rightTargets &&  this.appearanceCheck_drag == objectsRemaining)
				             prov_na_konec = 0;
					}
			}
		  }
		}
		if (objectsRemaining == noTarg_in_Drag)
			prov_na_konec = 0;   //остались только те, кот. не надо ставить
		var _targetEnabled=0;
		for(var i = 0; i < this.targetsArray.length; i++){ 
			 if(this.targetsArray[i].targetEnabled == false)
			     _targetEnabled++;				
		}
		var prov_na_konec_targets = 1;
		if(_targetEnabled == this.targetsArray.length-this.appearanceCheck_targ)
		     prov_na_konec_targets = 0;
			 
		if(this.thereIsClass == true && this.crAlgorithm == "smooth" && this.random_Class_order == true){
			var nomer = this.random_Class_orderArray[this.number_of_random_Class_orderArray];
//trace(nomer+"2303--"+	this.dragObjectsClasses[nomer].attempts+"   "+this.nextClassAttempts);
			var ClassAttempts = this.dragObjectsClasses[nomer].attempts;   //ск-ко разрешено попыток
			this.nextClassAttempts++;    ///определяется в showObject для класса
			if (this.nextClassAttempts == 1){
				this.butt_NextPrevClass(false);
			}
			if (this.nextClassAttempts == ClassAttempts){
				prov_na_konec = 0;
				totalTargets = ClassAttempts;   ///иначе берёт общее кол целей
			}
		}	 
			 
		if(prov_na_konec == 0 || prov_na_konec_targets == 0){
//trace("2229   --"+prov_na_konec);


////это без классов!!!!! !!!!!!!!!!!! 
         if(this.thereIsClass == false){	  
			if(this.onAllObjectsPlacedActions){
				for(var i = 0; i < this.onAllObjectsPlacedActions.length; i++){
					this.dispatchAction(this.onAllObjectsPlacedActions[i]);
				}
			}
			if(prov_na_konec == 0){
				if(this.crAlgorithm == "smooth" && this.objectErrors>0){
					if(this.onAllObjectsPlacedActionsWrong){
						for(var i = 0; i < this.onAllObjectsPlacedActionsWrong.length; i++){
							this.dispatchAction(this.onAllObjectsPlacedActionsWrong[i]);
						}
					}
				}else{
					if(this.onAllObjectsPlacedActionsRight){			  
						for(var i = 0; i < this.onAllObjectsPlacedActionsRight.length; i++){
							this.dispatchAction(this.onAllObjectsPlacedActionsRight[i]);
						}
					}
				}
			}else{
		    	if(this.onAllObjectsPlacedActionsWrong){
					for(var i = 0; i < this.onAllObjectsPlacedActionsWrong.length; i++){
						this.dispatchAction(this.onAllObjectsPlacedActionsWrong[i]);
					}
				}
			}
////подсчёт результата
	   	     var results;
             results = new scene.Utils.resultParam();
             results.init();
             results.attemptsCount = this.attempts;   //попытки
             results.rightElements = rightTargets;    //прав постtotalTargets
             results.allRightElements = totalTargets-this.appearanceCheck_targ; //прав всего
             results.wrongElements = this.objectErrors;   //
             //results.allWrongElements = totalAnswers - rightRelations;
			 results.allElements = "unknown";
    
             results.countResult(this.crAlgorithm);
			 
             this.objectResult = results.objectResult;
trace("2352 attemptsCount"+this.attempt+"  rightElements="+rightTargets+"  allRightElements="+results.allRightElements+" "+this.objectErrors);			 
//////////////    это классы   !!!!!!!!!!!!!!!!!!!!	 //f	
		 } else {                                                   		 
             this.ClassFinished++;	   //кол выполненных классов
			 this.totalRightClassTarget  += totalTargets;
			 this.totalRightClassDrag += rightTargets;
			 var execClass_ = this.thereIsClassVisible;
trace("2330  прав отв="+this.totalRightClassTarget+"  ClassFinished"+this.thereIsClassVisible);	
			if(this.onAllObjectPlacedClassActions){              //после выполнения каждого класса    //[0]- id класса [1]- parseActions  
				     for(var i = 0; i < this.onAllObjectPlacedClassActions.length; i++){
					     this.dispatchAction(this.onAllObjectPlacedClassActions[i]);
				    }
			}
			
			for(var i = 0; i < this.ClassAction.length; i++){
				     var Action_class = this.ClassAction[i];
//trace(Action_class[0]+"--2363  "+Action_class[1]+"   " +this.thereIsClassVisible);
				     if(Action_class[0] == execClass_){
//trace("2372 --"+Action_class[1]);
						for (var j1=0; j1<Action_class[1].length;++j1){
							this.dispatchAction(Action_class[1][j1]);
						}
					 }
			}
			 if(this.ClassFinished == this.dragObjectsClasses.length){   //если выполнены все классы!!!!!
			 
			     if(this.onAllObjectsPlacedActions){
				     for(var i = 0; i < this.onAllObjectsPlacedActions.length; i++){
					     this.dispatchAction(this.onAllObjectsPlacedActions[i]);
				    }
			     }
				 if(this.totalRightClassDrag == this.totalRightClassTarget){
					if(this.onAllObjectsPlacedActionsRight){
						for(var i = 0; i < this.onAllObjectsPlacedActionsRight.length; i++){
							this.dispatchAction(this.onAllObjectsPlacedActionsRight[i]);
						}
			        }				 
				 } else {
					if(this.onAllObjectsPlacedActionsWrong){
				         for(var i = 0; i < this.onAllObjectsPlacedActionsWrong.length; i++){
							this.dispatchAction(this.onAllObjectsPlacedActionsWrong[i]);
						 }
					}
				 }
			    var results;
                 results = new scene.Utils.resultParam();
                 results.init();
                 results.attemptsCount = this.attempts;   //попытки
                 results.rightElements = this.totalRightClassDrag;    //прав пост
                 results.allRightElements = this.totalRightClassTarget; //прав всего
                 results.wrongElements = this.objectErrors;   //
                //results.allWrongElements = totalAnswers - rightRelations;
                //results.allElements = results.allRightElements + results.allWrongElements;
                 results.allElements = "unknown";
			
                 results.countResult(this.crAlgorithm);
    
                 this.objectResult = results.objectResult;
				 
			 } else {                  ///если классы не все выполнены                                 		 
			     
				 this.butt_NextPrevClass(true);
				 this.ExecClasses[this.number_of_random_Class_orderArray] = 1;
				 
				 if(this.ClassChangeStartplaces == true){
				     this.startPlaces = null;
					 this.startPlaces = new Array();				     
				     for(j1 = 0; j1 < this.startPlacesDuble.length; j1++){
					     var startPlaces_class_= this.startPlacesDuble[j1];
						 startPlaces_class_.freePlace = true;
						 startPlaces_class_.objectIndex = -1;
					     this.startPlaces[j1] = startPlaces_class_;
					 }
					 this.startPlacesDuble = null;
					 this.startPlacesDuble = new Array();
				 }
				 this.ClassChangeStartplaces = false;
			 }			
			//trace(this.dragObjectsClasses.length+"  "+alldragObjects);			
		 }
		}

		if(this.appearanceMode == DRAGGING_APPERANCE_ONE){
		//	если вывод по одному объекту
			if(objectsRemaining == 1){
				//	отключение кнопок перебора если остался всего один перетаскиваемый объект
				if(this.btnPreviousDragObject)
					this.btnPreviousDragObject.hideObject();
				if(this.btnNextDragObject)
					this.btnNextDragObject.hideObject();
			}

			if (isPlacedRight)
				this.nextDragObject();
		} else {
		//	тут должно быть отключение кнопок перебора для случая, когда
		//	объекты выводятся сразу все (т.е сколько стартовых мест) и соответственно
		//	надо отключать когда на старте осталось объектов <= стартовых позиций
		}
	}

//	вспомогаетльная функция. возвращает список целей для объекта с некоторым id
	function getTargetsListForObject(objectId){
		for(var i = 0; i < this.dragObjects.length; i++){
			if(this.dragObjects[i].id == objectId){
				return this.dragObjects[i].objectTargets;
			}
		}
	}	

//	диспетчер кнопок
	function buttonDispatcher(btnId){
//trace("1932----	btnId == "+btnId);
		switch(btnId){
		case "btnPreviousDragObject":
			this.previousDragObject();
			break;
		case "btnNextDragObject":
			this.nextDragObject();
			break;
		case "btnCheck":
			this.checkDragObjectsPlacement();
			break;
		case "btnReset":
			this.resetDragObjects();
			break;
		case "btnPrevClass":
			this.prevClass();
		    break;
		case "btnNextClass":
		    this.nextClass();
			break;	
		default:
			trace("DRAGGING: UNKNOWN BUTTON ID: " + btnId);
			break;
		};
	}

	function dispatchAction(singleAction){
		for (var i = 0; i < singleAction.length; ++i)
			singleAction[i] = scene.Utils.trim(singleAction[i]);
//trace("2447-  "+singleAction);				
		if(singleAction[0]=="showObjectInVisiblleClass"){	
		     this.doAction(singleAction);
				
        }else{
		switch (singleAction[0]) {
			case "enableTarget":
			case "disableTarget":
			case "showDragObject":
			case "hideDragObject":
			case "enableDragObject":
			case "disableDragObject":
			case "hideAllUntargeted":
			case "hideAllWrongTargeted":
			case "showObjectClass":
			
			case "moveAllUntargetedToTrashBox":
        if (singleAction[1] != null){
          if(singleAction[1].slice(0,8) == "LABWORK." ||
             singleAction[1].slice(0,8) == "LABWORK"){
          //  если написано ключевое слово LABWORK - значит целевой 
          //  объект - глобальный отправляем на обработку в Loader
            singleAction = singleAction.slice(0);
            singleAction[1] = singleAction[1].slice(8);
            scene.Labwork.doAction(singleAction);
          } else if(singleAction[1].charAt(0) == "."){
            if(singleAction[1].charAt(1) == "."){
            // !!!! Сделать копию массива !!!
              singleAction = singleAction.slice(0);
              singleAction[1] = singleAction[1].slice(1);
              parent.dispatchAction(singleAction);
			  //parent.doAction(singleAction);
            } else {
            // !!!! Сделать копию массива !!!
              singleAction = singleAction.slice(0);    
              singleAction[1] = singleAction[1].slice(1);
              this.doAction(singleAction);
            }
          } else {
            scene.Labwork.currentStep.doAction(singleAction);
          }
        } else
          this.doAction(singleAction);
				break;

			default:
				rnmc_stdMediaGroup_dispatchAction(singleAction);
				break;
		}
		}
	}


//	выполняет специфичные для объекта rnmc_stdDragging действия
	function doAction(singleAction){
//trace("2499dragging: " + this.id + " - doAction: " + singleAction);	
		switch(singleAction[0]){
		case "enableTarget":
			for(var i = 0 ; i < this.targetsArray.length; i++){
				if(this.targetsArray[i].id == singleAction[1]){
					this.targetsArray[i].enableTarget();
				}
			}
			break;
		case "disableTarget":
			for(var i = 0 ; i < this.targetsArray.length; i++){
			//trace("disableTarget "+this.targetsArray[i].id);
				if(this.targetsArray[i].id == singleAction[1]){
					this.targetsArray[i].disableTarget();
					//trace("disableTarget");
				}
			}
			break;
		case "showDragObject":
			for(var i = 0; i < this.dragObjects.length; i++){
				if(this.dragObjects[i].id == singleAction[1]){
					if(!this.dragObjects[i].disabled){
						this.dragObjects[i].showObject();
					}
				}
			}
			break;
		case "hideDragObject":
			for(var i = 0; i < this.dragObjects.length; i++){
				if(this.dragObjects[i].id == singleAction[1]){
					if(!this.dragObjects[i].disabled)
						this.dragObjects[i].hideObject();
				}
			}
			break;
		case "enableDragObject":
			for(var i = 0; i < this.dragObjects.length; i++){
				if(this.dragObjects[i].id == singleAction[1]){
					this.dragObjects[i].enableObject();
				}
			}
			break;
		case "disableDragObject":
			for(var i = 0; i < this.dragObjects.length; i++){
				if(this.dragObjects[i].id == singleAction[1]){
					this.dragObjects[i].disabledObject();
				}
			}
			break;
		case "hideAllUntargeted":
			for(var i = 0; i < this.dragObjects.length; i++){					
				if(this.dragObjects[i].objectTargets.length == 0){		
					this.dragObjects[i].hideObject();
				}
			}
			break;
		case "hideAllWrongTargeted":
//trace("2561--"+this.dragObjectsClasses	);
			if(this.thereIsClass == false){
				for(var i = 0; i < this.dragObjects.length; i++){
//trace("2563--"+this.dragObjects[i].id+"  "+this.dragObjects[i].objectState);							
					if(this.dragObjects[i].objectState != DRAGOBJECT_STATE_PLACED){			
						this.dragObjects[i].hideObject();
					}
				}
			}else{
			     for(var i = 0; i < this.dragObjectsClasses.length; i++){
			         if(this.dragObjectsClasses[i].id == this.thereIsClassVisible){
						for(var ii = 0; ii < this.dragObjectsClasses[i].length; ii++){
				             if(this.dragObjectsClasses[i][ii].objectState != DRAGOBJECT_STATE_PLACED){
//trace("2619--hide--"+this.dragObjectsClasses[i].id);				
						             this.dragObjectsClasses[i][ii].hideObject();
								 }
						}
					 }
			     }
				 for(var i = 0; i < this.startPlaces.length; i++){  ///очищ старт поз
					this.startPlaces[i].freePlace = true;
					this.startPlaces[i].objectIndex = -1;
				}
			}
			break;			
		case "moveAllUntargetedToTrashBox":
			for(var i = 0; i < this.dragObjects.length; i++){
				if(this.dragObjects[i].objectTargets.length == 0){
					this.dragObjects[i].objectState = DRAGOBJECT_STATE_INTRASHBOX;
					this.dragObjects[i].useHandCursor = false;
					this.dragObjects[i].onRelease = null;
					this.dragObjects[i].onReleaseOutside = null;
					this.dragObjects[i].onPress = null;
					this.dragObjects[i].moveTo(this.trashBoxX, trashBoxY);
				}
			}
			break;
		case "showObjectClass":    ///<ffff
//trace("2640--showObjectClass  "+singleAction[1]);
			 this.thereIsClassVisible = singleAction[1];
			 this.randomTargetOnStart = false;
			 for(var i = 0; i < this.dragObjectsClasses.length; i++){
			    if(this.dragObjectsClasses[i].id == this.thereIsClassVisible)
				     this.dragObjectsClasses[i].totalVisible=true;
			 }
			// trace(this.dragObjects.length+"  -1874-  "+this.dragObjectsClasses[1]);
			// this.fillFreeStartPlaces();
			// this.prepareStartPlace();
			 this.showObject();
		    break;                  ///>f
			
		case "showObjectInVisiblleClass":    ///<ffff
		     var class_obj = (singleAction[1]).split(",");
//trace("!!!!!!!!showObjectInVisiblleClass "+class_obj[0]+"    "+class_obj[1]);

			if(this.thereIsClassVisible == class_obj[0]){
//trace("=---"+class_obj[1]);
            var arr_class_obj=new Array();
			arr_class_obj.push("showObject");
			arr_class_obj.push(class_obj[1]);
			//this.doAction("showObject"+class_obj[1]);
            this.doAction(arr_class_obj);

			//class_obj[1].showObject();
             }			 
			 break;                  ///>f
			 
		default:
			rnmc_stdMediaGroup_doAction(singleAction);
			break;
		};
	}

	function applyDefaultActions(forEvent){
		switch(forEvent){
		case "onPlacedRight":
			if(this.onPlacedRightActions){
				for(var i = 0; i < this.onPlacedRightActions.length; i++){
					this.dispatchAction(this.onPlacedRightActions[i]);
				}
			}
			break;
		case "onPlacedWrong":
			if(this.onPlacedWrongActions){
				for(var i = 0; i < this.onPlacedWrongActions.length; i++){
					this.dispatchAction(this.onPlacedWrongActions[i]);
				}
			}
			break;
		}
	}
	
	function getResult(resultsArray){
		if(resultsArray && this.crAlgorithm != "none"){
			var resultString = this.objectResult + ";1.0";
			resultsArray.push(resultString);
		}

		rnmc_stdMediaGroup_getResult(resultsArray);
	}		
//f   возвращает 	сколько свободных мест-целей		=true-есть!!!!
   //DRAGOBJECT_STATE_BEFORESTART  = 0;DRAGOBJECT_STATE_ONSTART    = 1;
   //DRAGOBJECT_STATE_PLACED      = 2;DRAGOBJECT_STATE_INTRASHBOX   = 4;
	function getOccupiedStartPlaces(){     
	     var lengthPlace = this.startPlaces.length;
		 for(var j = 0; j < this.startPlaces.length; j++){
		     if(this.startPlaces[j].freePlace)   //	свободное место
			     lengthPlace--;
		 }

		 if(lengthPlace==this.appearanceCheck_targ){
			 this.btnCheck.showObject();
			 this.showBtnCheck = true;
		 }
		 var lengthPlaceDrag = this.startPlaces.length;
		 for(var j = 0; j < this.dragObjects.length; j++){
//trace("2091---"+this.dragObjects[j].objectState)	//
			 if(this.dragObjects[j].objectState == DRAGOBJECT_STATE_PLACED)
			    lengthPlaceDrag--;
        }
		if(lengthPlace==this.appearanceCheck_drag && this.showBtnCheck == false){	
			 this.btnCheck.showObject();
			 this.showBtnCheck = true;
		}
	}
	function gasimClass(){
        if(this.ExecClasses[this.number_of_random_Class_orderArray] == 0){    //надо гасить, ничего не поставлено
	         for(var i = 0; i < this.dragObjects.length; i++){
                 this.dragObjects[i].setStartPlace(0);			 
				if(!this.dragObjects[i].disabled)
					this.dragObjects[i].hideObject();
					this.dragObjects[i].objectState = DRAGOBJECT_STATE_BEFORESTART;									
	         }
			 for(var i = 0; i < this.startPlaces.length; i++){
			     this.startPlaces[i].freePlace = true;
			 }
    	 } else {
			//for(var i = 0; i < this.dragObjects.length; i++){				
				//if(!this.dragObjects[i].disabled)
				//	this.dragObjects[i].disabledObject();				
	      //   }
			 
		}
	}
	function nextClass(){
	     this.gasimClass();   	 
		
	     //f служит для показа следующего невыполненного класса  this.thereIsClassVisible- это сейчас id класса
	     //this.number_of_random_Class_orderArray это указатель в списке
	     this.dragObjectsClasses[this.number_of_random_Class_orderArray].totalVisible = false;
	     var nomer = this.number_of_random_Class_orderArray;
		
	     for(var i = 0; i < this.dragObjectsClasses.length; i++){		
		     nomer++;
		     if(nomer >= this.dragObjectsClasses.length)
		         nomer = 0;
		     if(this.ExecClasses[nomer] == 0)
		         break;	 
	    }

		var nomer1 = this.random_Class_orderArray[nomer];
		this.thereIsClassVisible = this.dragObjectsClasses[nomer1].id;			 
		this.number_of_random_Class_orderArray = nomer;
		
		 this.randomTargetOnStart = false;  //чтобы ещё раз не путать цели		
		 this.showObject();
	}
	function prevClass(){
	     this.gasimClass();   	 
		
	     //f служит для показа следующего невыполненного класса  this.thereIsClassVisible- это сейчас id класса
	     //this.number_of_random_Class_orderArray это указатель в списке
	     this.dragObjectsClasses[this.number_of_random_Class_orderArray].totalVisible = false;
	     var nomer = this.number_of_random_Class_orderArray;
		
	     for(var i = 0; i < this.dragObjectsClasses.length; i++){		
		     nomer--;
		     if(nomer < 0)
		         nomer = this.dragObjectsClasses.length-1;
		     if(this.ExecClasses[nomer] == 0)
		         break;	 
	    }
//trace("2574--"+nomer);
		var nomer1 = this.random_Class_orderArray[nomer];
		this.thereIsClassVisible = this.dragObjectsClasses[nomer1].id;			 
		this.number_of_random_Class_orderArray = nomer;
		
		 this.randomTargetOnStart = false;  //чтобы ещё раз не путать цели		
		 this.showObject();
	}
	function butt_NextPrevClass(par_visible){
//trace("2793--"+par_visible+this.ClassFinished);
	     if(par_visible==false){   //убираем кнопки листания классов
			 if(this.btnPrevClass){
			     this.btnPrevClass.hideObject();
			 }
			 if(this.btnNextClass){
			     this.btnNextClass.hideObject();
			 }
	     } else {
		     if(this.ClassFinished <= (this.dragObjectsClasses.length-1)){
			     if(this.btnPrevClass){
			         this.btnPrevClass.showObject();
			     }
			     if(this.btnNextClass){
			         this.btnNextClass.showObject();
			     }
		     } 
	    }
	}
//	============		DEBUG
	function printOccupiedStartPlaces(){
		for(var j = 0; j < this.startPlaces.length; j++){
			if(this.startPlaces[j].freePlace){
				trace(j + " - free");
			} else {
				trace(j + " - occupied");
			}
		}
	}
  
  function getErrors(){
    trace("#FF0000this.objectErrors = "+this.objectErrors);
    return this.objectErrors;
  }
]]></script>
</composition>

<!--		ОБъЕКТ  ЦЕЛЬ 		-->
<composition name="dragging_target">
<script><![CDATA[
	this.id = null;
	this.targetEnabled = true;

	this.targetAreas = null;

//	стиль расположения поставленных в цель элементов
	this.placementStyle = TARGET_PLACEMENT_UNDEFINED;

//	подсвечивающий элемент при наведении
	this.activeMarkObject = null;
	this.activeMarkDefined = false;
	this.activeMarkType = BUTTON_ACTIVEMARK_BORDER;
	this.activeMarkSrc = null;
	this.activeBorderColor = null;
	this.activeBorderSize = 0;
	this.activeBgColor = null;
	this.activeMarkXOffset = 0;
	this.activeMarkYOffset = 0;
	this.activeMarkWidth = 0;
	this.activeMarkHeight = 0;
	this.activeMarkDepth = 2;

//	списки действий
	this.onEnterTargetActions = null;
	this.onLeaveTargetActions = null;
	this.onObjectPlacedRightActions = null;
	this.onObjectPlacedErrorActions = null;

//	
	this.tableX			= 0;
	this.tableY			= 0;
	this.tableColumns	= 0;
	this.tableLines		= 0;
	this.placeList		= null;
	
///f для разницы между областью цели и прикреплённых к ней объектов 
	this.deltaTargetsPlaces = new Array(); 

//	для драггинга 	- одно место
	this.totalPlaces = 1;

//	список помещённых объектов
	this.placedObjects = null;
	this.placedObjectsCounter = 0;

	function initFromNode(srcNode){
		var xmlNode = null;
		var xmlAttributeMap = null;
		var xmlAttribute = null;

		this.targetAreas = new Array();

		xmlAttributeMap = srcNode.attributes;
		if (xmlAttributeMap){
			xmlAttribute = xmlAttributeMap.getNamedItem("id");
			if (xmlAttribute != null && xmlAttribute.specified)
				this.id = xmlAttribute.value;
			xmlAttribute = xmlAttributeMap.getNamedItem("enabled");
			if (xmlAttribute != null && xmlAttribute.specified && xmlAttribute.value == "false")
				this.targetEnabled = false;
		}

		xmlNode = srcNode.firstChild;
		while(xmlNode){
			if(xmlNode.nodeName == "placement"){
				//	разбор надстроек вывод объектов, отнесённых к заданной цели
				if (xmlAttributeMap){
				}
				var placementNode = xmlNode.firstChild;
				while(placementNode){
					if(placementNode.nodeName == "table"
						&& this.placementStyle == TARGET_PLACEMENT_UNDEFINED){
						xmlAttributeMap = srcNode.attributes;
						if (xmlAttributeMap){
							this.placementStyle == TARGET_PLACEMENT_TABLE;
							xmlAttribute = xmlAttributeMap.getNamedItem("columns");
							if (xmlAttribute != null && xmlAttribute.specified)
								this.tableColumns = parseInt(xmlAttribute.value);
							xmlAttribute = xmlAttributeMap.getNamedItem("lines");
							if (xmlAttribute != null && xmlAttribute.specified)
								this.tableLines = parseInt(xmlAttribute.value);
							xmlAttribute = xmlAttributeMap.getNamedItem("x");
							if (xmlAttribute != null && xmlAttribute.specified)
								this.tableX = parseInt(xmlAttribute.value);
							xmlAttribute = xmlAttributeMap.getNamedItem("y");
							if (xmlAttribute != null && xmlAttribute.specified)
								this.tableY = parseInt(xmlAttribute.value);
							xmlAttribute = xmlAttributeMap.getNamedItem("fillMode");
							if (xmlAttribute != null && xmlAttribute.specified){
								switch((xmlAttribute.value).toLowerCase){
								case "by_line":
									break;
								case "by_column":
									break;
								}
							}
						}
					} else if(placementNode.nodeName == "placelist"
						&& this.placementStyle == TARGET_PLACEMENT_UNDEFINED){
						var placeNode = placementNode.firstChild;
						this.placementStyle = TARGET_PLACEMENT_CUSTOM;
						this.placeList = new Array();
						while(placeNode){
							if(placeNode.nodeName == "place"){
								xmlAttributeMap = placeNode.attributes;
								if (xmlAttributeMap){
									var placeX = 0;
									var placeY = 0;
									var placeWidth = 0;
									var placeHeight = 0;
									xmlAttribute = xmlAttributeMap.getNamedItem("x");
									if (xmlAttribute != null && xmlAttribute.specified)
										placeX = parseInt(xmlAttribute.value);
									xmlAttribute = xmlAttributeMap.getNamedItem("y");
									if (xmlAttribute != null && xmlAttribute.specified)
										placeY = parseInt(xmlAttribute.value);
									xmlAttribute = xmlAttributeMap.getNamedItem("width");
									if (xmlAttribute != null && xmlAttribute.specified)
										placeWidth = parseInt(xmlAttribute.value);
									xmlAttribute = xmlAttributeMap.getNamedItem("height");
									if (xmlAttribute != null && xmlAttribute.specified)
										placeHeight = parseInt(xmlAttribute.value);
									var newPlace = new Array(placeX, placeY,
										placeWidth, placeHeight);
									newPlace.freePlace = true;
									newPlace.placedObject = null;
									this.placeList.push(newPlace);
								}
							}
							placeNode = placeNode.nextSibling;
						}
						//	устанавливаем количество свободных мест в данной целе
						this.totalPlaces = this.placeList.length;
					}
					placementNode = placementNode.nextSibling;
				}
			} else if(xmlNode.nodeName == "area"){
				if(xmlNode.textContent != null){
					var newPolygonalArea = new Button();
					newPolygonalArea.hitArea = xmlNode.textContent;
					newPolygonalArea.areaType = "POLYGON";
					newPolygonalArea.useHandCursor = 0;
					newPolygonalArea.x = 0;
					newPolygonalArea.y = 0;
					newPolygonalArea.visible = true;
					newPolygonalArea.enabled = true;
					newPolygonalArea.parent = this;
					this.visible = true;
					this.targetAreas.push(newPolygonalArea);
				} else {
					xmlAttributeMap = xmlNode.attributes;
					if (xmlAttributeMap){
					
						var areaX = 0;
						var areaY = 0;
						var areaWidth = 0;
						var areaHeight = 0;
						var areaSensitivity = 25;
						xmlAttribute = xmlAttributeMap.getNamedItem("x");
						if (xmlAttribute != null && xmlAttribute.specified){
//	!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ACHTUNG !!!!!!!!!!!!!!!
						//	Так как не понятно как быть в случае если указано несколько area
						//	какие координаты выбирать в качестве тех куда должен встать объект
						//	поэтому пока решил выбрать те которые указаны в последнем из всех area 
						//	- Никита
							this.destinationX = parseInt(xmlAttribute.value);
							areaX = parseInt(xmlAttribute.value);
						}
						xmlAttribute = xmlAttributeMap.getNamedItem("y");
						if (xmlAttribute != null && xmlAttribute.specified){
//	!!!!!!!!!!!!!!!!!!!! ACHTUNG !!!!!!!!!!!!!!!!!!!!!!!!
						//	Так как не понятно как быть в случае если указано несколько area
						//	какие координаты выбирать в качестве тех куда должен встать объект
						//	поэтому пока решил выбрать те которые указаны в последнем из всех area 
						//	- Никита
							this.destinationY = parseInt(xmlAttribute.value);
							areaY = parseInt(xmlAttribute.value);
						}
						xmlAttribute = xmlAttributeMap.getNamedItem("width");
						if (xmlAttribute != null && xmlAttribute.specified)
							areaWidth = parseInt(xmlAttribute.value);
						xmlAttribute = xmlAttributeMap.getNamedItem("height");
						if (xmlAttribute != null && xmlAttribute.specified)
							areaHeight = parseInt(xmlAttribute.value);
						xmlAttribute = xmlAttributeMap.getNamedItem("sensitivity");
						if (xmlAttribute != null && xmlAttribute.specified)
							areaSensitivity = parseInt(xmlAttribute.value);
						var newArea = new Array(areaX, areaY,
												areaWidth, areaHeight, areaSensitivity);
						if(areaWidth > 0 && areaHeight > 0){
							newArea.areaType = "RECT";
							this.activeMarkXOffset = areaX;
							this.activeMarkYOffset = areaY;
							this.activeMarkWidth   = areaWidth;
							this.activeMarkHeight  = areaHeight;							
						} else {
							newArea.areaType = "POINT";
							
							this.activeMarkXOffset = areaX - areaSensitivity;
							this.activeMarkYOffset = areaY - areaSensitivity;
							this.activeMarkWidth   = areaX + areaSensitivity;
							this.activeMarkHeight  = areaY + areaSensitivity;				
						}
					
						this.targetAreas.push(newArea);
					}
				}
			}  else if(xmlNode.nodeName == "mask"){
/*
				xmlAttributeMap = xmlNode.attributes;
				if (xmlAttributeMap){
					var newPolygonalArea = new Image();
					newPolygonalArea.hitArea = xmlNode.textContent;
					newPolygonalArea.areaType = "POLYGON";
					newPolygonalArea.useHandCursor = 0;
					newPolygonalArea.visible = true;
					newPolygonalArea.enabled = true;
					newPolygonalArea.parent = this;
					this.visible = true;
					this.targetAreas.push(newPolygonalArea);

					var newObject = new Image();
					newObject.visible = false;
					newObject.enabled = false;
					newObject.parent = this;
					xmlAttribute = xmlAttributeMap.getNamedItem("x");
					if (xmlAttribute != null && xmlAttribute.specified){
						newPolygonalArea.x = parseInt(xmlAttribute.value);
					};
					xmlAttribute = xmlAttributeMap.getNamedItem("y");
					if (xmlAttribute != null && xmlAttribute.specified){
						newPolygonalArea.y = parseInt(xmlAttribute.value);
					};
					xmlAttribute = xmlAttributeMap.getNamedItem("depth");
					if (xmlAttribute != null && xmlAttribute.specified){
						newPolygonalArea.depth = parseInt(xmlAttribute.value);
					};
					xmlAttribute = xmlAttributeMap.getNamedItem("src");
					if (xmlAttribute != null && xmlAttribute.specified){
						newPolygonalArea.src = xmlAttribute.value;
					};
					newPolygonalArea.hitArea = "opaque";
					this.targetAreas.push(newObject);
				}
*/
			} else if(xmlNode.nodeName == "activemark"){
				xmlAttributeMap = xmlNode.attributes;
				if(xmlAttributeMap){
					this.activeMarkDefined = true;
					xmlAttribute =  xmlAttributeMap.getNamedItem("type");
					if (xmlAttribute != null && xmlAttribute.specified){
						if(xmlAttribute.value == "border")
							this.activeMarkType = BUTTON_ACTIVEMARK_BORDER;
						if(xmlAttribute.value == "image")
							this.activeMarkType = BUTTON_ACTIVEMARK_IMAGE;
					}
					xmlAttribute =  xmlAttributeMap.getNamedItem("src");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.activeMarkSrc = xmlAttribute.value;
					}
					xmlAttribute =  xmlAttributeMap.getNamedItem("bordercolor");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.activeBorderColor = xmlAttribute.value;
					}
					xmlAttribute =  xmlAttributeMap.getNamedItem("bordersize");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.activeBorderSize = parseInt(xmlAttribute.value);
					}
					xmlAttribute =  xmlAttributeMap.getNamedItem("bgcolor");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.activeBgColor = xmlAttribute.value;
					}
					xmlAttribute =  xmlAttributeMap.getNamedItem("x");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.activeMarkXOffset = parseInt(xmlAttribute.value);
					}
					xmlAttribute =  xmlAttributeMap.getNamedItem("y");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.activeMarkYOffset = parseInt(xmlAttribute.value);
					}
					xmlAttribute =  xmlAttributeMap.getNamedItem("width");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.activeMarkWidth = parseInt(xmlAttribute.value);
					}
					xmlAttribute =  xmlAttributeMap.getNamedItem("height");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.activeMarkHeight = parseInt(xmlAttribute.value);
					}
					xmlAttribute =  xmlAttributeMap.getNamedItem("depth");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.activeMarkDepth = parseInt(xmlAttribute.value);
					}
				}
			} else if(xmlNode.nodeName == "actions"){
				this.onEnterTargetActions = 
					scene.Utils.parseActionsNode(xmlNode, "onEnterTarget");
				this.onLeaveTargetActions =
					scene.Utils.parseActionsNode(xmlNode, "onLeaveTarget");
				this.onObjectPlacedRightActions = 
					scene.Utils.parseActionsNode(xmlNode, "onObjectPlacedRight");
				this.onObjectPlacedErrorActions =
					scene.Utils.parseActionsNode(xmlNode, "onObjectPlacedError");
				//trace(this.onObjectPlacedErrorActions.length);	
			} else if(xmlNode.nodeName == "attachlist"){  //FF
			    // var deltaArray = new Array();				 
				 xmlAttributeMap = srcNode.attributes;
	      	     if (xmlAttributeMap){
			           xmlAttribute = xmlAttributeMap.getNamedItem("id");
					 //  this.deltaTargetsPlaces.push(xmlAttribute.value);
		         }
			     var placementNode = xmlNode.firstChild;
			    //f     пишем в this.deltaTargetsPlaces
				// trace(placementNode+"==="+xmlAttributeMap);
				 while(placementNode){
				  xmlAttributeMap = placementNode.attributes;						
			      xmlAttribute = xmlAttributeMap.getNamedItem("id");
				  var att_id = xmlAttribute.value;	
				  var ar_ =	new Array();		
				     switch(placementNode.nodeName){
		                 case "image":						   						 
						     ar_.push("rnmc_stdImage");
						     ar_.push(att_id);
							 this.deltaTargetsPlaces.push(ar_);
                         break;  
				   
				         case "text":					      						  
					         ar_.push("rnmc_stdText");
						     ar_.push(att_id);
							 this.deltaTargetsPlaces.push(ar_);
                         break; 						
				    
					     case "button":						                            						 
						     ar_.push("rnmc_stdButton");
						     ar_.push(att_id);
							 this.deltaTargetsPlaces.push(ar_);
                         break;
						 
						 case "video":						   						 
						     ar_.push("rnmc_stdVideo");
						     ar_.push(att_id);
							 this.deltaTargetsPlaces.push(ar_);
                         break;
						 
						 case "qt_emul":						   						 
						     ar_.push("rnmc_stdQTEmulation");
						     ar_.push(att_id);
							 this.deltaTargetsPlaces.push(ar_);
                         break;
						 
						 case "crossword":						   						 
						     ar_.push("rnmc_Crossword");
						     ar_.push(att_id);
							 this.deltaTargetsPlaces.push(ar_);
                         break;
						 
						 case "flash":						   						 
						     ar_.push("rnmc_stdFlash");
						     ar_.push(att_id);
							 this.deltaTargetsPlaces.push(ar_);
                         break;
						 
						 case "audio":						   						 
						     ar_.push("rnmc_stdAudio");
						     ar_.push(att_id);
							 this.deltaTargetsPlaces.push(ar_);
                         break;
						 
						 case "animation":						   						 
						     ar_.push("rnmc_stdAnimation");
						     ar_.push(att_id);
							 this.deltaTargetsPlaces.push(ar_);
                         break;
						 
						 default:
                           trace("неправильный атрибут "+ placementNode.nodeName + " в attachlist для  "+deltaArray[0] );	
						 break;
   				     }					 
					 placementNode = placementNode.nextSibling;
				}
//trace("3088--this.deltaTargetsPlaces  "+this.deltaTargetsPlaces);
			}
			xmlNode = xmlNode.nextSibling;
		}
		//	создание подсвечивающего объекта
		if(this.activeMarkDefined){
			if(activeMarkType == BUTTON_ACTIVEMARK_BORDER){
				this.activeMarkObject = new Composition();
				this.activeMarkObject._class = "rnmc_stdRectangle";
				this.activeMarkObject.parent = this;
				this.activeMarkObject.objectX = this.activeMarkXOffset;
				this.activeMarkObject.objectY = this.activeMarkYOffset;
				this.activeMarkObject.objectWidth = this.activeMarkWidth;
				this.activeMarkObject.objectHeight = this.activeMarkHeight;
				this.activeMarkObject.objectDepth = this.activeMarkDepth;
				this.activeMarkObject.borderColor = this.activeBorderColor;
				this.activeMarkObject.borderSize  = -this.activeBorderSize;
/*
				this.activeMarkBorder = new Text();
				this.activeMarkBorder.visible = false;
				this.activeMarkBorder.adjustHeight = false;
				this.activeMarkBorder.x = this.activeMarkXOffset - this.activeBorderSize;
				this.activeMarkBorder.y = this.activeMarkYOffset - this.activeBorderSize;
				this.activeMarkBorder.width = this.activeMarkWidth;
				this.activeMarkBorder.height = this.activeMarkHeight;
				this.activeMarkBorder.depth = this.activeMarkDepth + 1;
				if (this.activeBorderColor)
					this.activeMarkBorder.bkgColor = this.activeBorderColor;
				this.activeMarkBorder.enabled = false;
				this.activeMarkBorder.parent = this;

				this.activeMarkBackground = new Text();
				this.activeMarkBackground.visible = false;
				this.activeMarkBackground.adjustHeight = false;
				this.activeMarkBackground.x = this.activeMarkXOffset;// + this.activeBorderSize;
				this.activeMarkBackground.y = this.activeMarkYOffset;// + this.activeBorderSize;
				this.activeMarkBackground.width = 
					this.activeMarkWidth - 2*this.activeBorderSize;
				this.activeMarkBackground.height =
					this.activeMarkHeight - 2*this.activeBorderSize;
				this.activeMarkBackground.depth = this.activeMarkDepth;
				if (this.activeBgColor)
					this.activeMarkBackground.bkgColor = this.activeBgColor;
				this.activeMarkBackground.enabled = false;
				this.activeMarkBackground.parent = this;
*/
			} else if(activeMarkType == BUTTON_ACTIVEMARK_IMAGE){
				this.activeMarkBorder = new Image();
				this.activeMarkBorder.visible = false;
				this.activeMarkBorder.src = this.activeMarkSrc;
				this.activeMarkBorder.x = this.activeMarkXOffset;
				this.activeMarkBorder.y = this.activeMarkYOffset;
				this.activeMarkBorder.depth = this.activeMarkDepth;
				this.activeMarkBorder.enabled = false;
				this.activeMarkBorder.parent = this;
				//this.activeMarkBackground = this.activeMarkBorder;
			}
		}
		if(!this.placeList){
		//	Случай когда не задавалось расположение объектов в цели
			this.placeList = new Array();
			var placeX = this.targetAreas[0][0];
			var placeY = this.targetAreas[0][1];
			var newPlace = new Array(placeX, placeY);
			this.placeList.push(newPlace);
		}
		this.visible = true;
		return true;
	}

	function enableTarget(){
		this.targetEnabled = true;
	}

	function disableTarget(){
		this.targetEnabled = false;
//trace(this.id+"--2807--"+this.targetEnabled);
	}

	function testMatched(testX, testY){
		if (!this.targetEnabled)
			return false;
		var v_testX = testX;
		var v_testY = testY;
		var locCoord = parent.globalToLocal(testX, testY);
		testX = locCoord.x;// + scene.x;
		testY = locCoord.y;// + scene.y;
		if(this.targetEnabled){
			for(var i = 0; i < this.targetAreas.length; i++){			
				switch(this.targetAreas[i].areaType){
				case "POINT":
					if((Math.abs(testX - this.targetAreas[i][0]) < this.targetAreas[i][4])
						&& (Math.abs(testY - this.targetAreas[i][1]) < this.targetAreas[i][4])){
						return true;
					}
					break;
				case "RECT":
				//	в случае если целевая область задана как прямоугольник				
					if(testX > this.targetAreas[i][0] &&
						testX <  (this.targetAreas[i][0] + this.targetAreas[i][2]) &&
						(testY) > this.targetAreas[i][1] &&
						(testY)< (this.targetAreas[i][1] + this.targetAreas[i][3])){
						return true;
					}
					break;
				case "POLYGON":
				//	в случае если целевая область задана как произвльный регион
				//trace(this.targetAreas[i]+"  POLY   "+v_testX+v_testY);
					if(this.targetAreas[i].isPointIn(v_testX, v_testY))	
						return true;
					break;
				}
			}
		}
		return false;
	}	

	function notifyMouseCoords(xCoord, yCoord){
		if(this.testMatched(xCoord, yCoord)){
			this.showActiveMark();
		} else {
			this.hideActiveMark();
		}
		var inTarget = this.testMatched(xCoord, yCoord) && this.getSuitablePlace(xCoord, yCoord);
		if(inTarget){
			if(!this.objectInsideTarget){
				this.objectInsideTarget = true;
				//this.showActiveMark();
				if(this.onEnterTargetActions){
					for(var i = 0; i < this.onEnterTargetActions.length; i++){
						parent.dispatchAction(this.onEnterTargetActions[i]);
					}
				}
			}
		} else {
			if(this.objectInsideTarget){
				this.objectInsideTarget = false;
				//this.hideActiveMark();
				if(this.onLeaveTargetActions){
					for(var i = 0; i < this.onLeaveTargetActions.length; i++){
						parent.dispatchAction(this.onLeaveTargetActions[i]);
					}
				}
				
			}
		}
	}

	function getFreePlace(objectWidth, objectHeight){
		var newObjectX = 0;
		var newObjectY = 0;
		var newCoords = new Array();
		switch(this.placementStyle){
		case TARGET_PLACEMENT_UNDEFINED:
//trace("TARGET_PLACEMENT_UNDEFINED");
			newObjectX = this.targetAreas[0][0];
			newObjectY = this.targetAreas[0][1];
			newCoords.placeIndex = 0;
			newCoords.push(newObjectX, newObjectY);
			break;
		case TARGET_PLACEMENT_TABLE:
		//	без ресайза и проч лабуды - просто выдаём координаты
		//	свободного места
			if(this.layoutFillMode == 1){
			//	заполнение по колонкам
				var curObject = (this.placedObjectsCounter + 1) % this.tableLines;
				if(curObject == 0){
					newObjectX = this.destinationAreaX;
					newObjectY = this.dragObjects[this.startOrder[i]].height + this.allStartplaceSpaceY;
					newCoords.placeIndex = i;
					newCoords.push(newObjectX, newObjectY);
				} else {
					startX += this.dragObjects[this.startOrder[i]].width + this.allStartplaceSpaceX;
				};
				
			} else if(this.layoutFillMode == 0){
				//	заполнение по строкам
			}
			break;
		case TARGET_PLACEMENT_CUSTOM:
			//	что называется custom
			for(var i = 0; i < this.placeList.length; i++){
				if(this.placeList[i].freePlace){
					newCoords.push(this.placeList[i][0], this.placeList[i][1], this.placeList[i][2], this.placeList[i][3]);
					newCoords.placeIndex = i;
					break;
				}
			}
			break;
		}
		if(newCoords.length > 0){
			return newCoords;
		} else {
			return null;
		}
	}

//	ищет среди всех свободных мест в данной цели то, которое наиболее подходит 
//	для данных проверяемых координат
	function getSuitablePlace(objectX, objectY){
		var placeIndex = -1;
		var bestDistance = -1;
		for(var i = 0; i < this.placeList.length; i++){
			var newOffsetX = this.placeList[i][0] - objectX;
			var newOffsetY = this.placeList[i][1] - objectY;
			var newDistance = Math.sqrt((newOffsetX*newOffsetX) + (newOffsetY*newOffsetY));
			if(bestDistance < 0){
				bestDistance = newDistance;
				placeIndex = i;
			} else if(bestDistance >= 0 && newDistance < bestDistance){
				bestDistance = newDistance;
				placeIndex = i;
			}
		
		// PG: Проверяем объект, находящийся в данной позиции,
		// если объект уже прошел проверку,
		// то данная позиция недоступна для помещения в нее другого объекта.
		 if(placeIndex >= 0){
			if (!this.placeList[placeIndex].freePlace){
				var objectID = getObjectOnPlace(placeIndex);
				for (var j = 0; j < parent.dragObjects.length; ++j){
					if (objectID == parent.dragObjects[j].id){
						if (parent.dragObjects[j].placed)
							placeIndex = -1;
						break;
					}
				}
			}
		 }
		}
		if(placeIndex >= 0){
			var newCoords = new Array(this.placeList[placeIndex][0], this.placeList[placeIndex][1], this.placeList[placeIndex][2], this.placeList[placeIndex][3]);
			//	помимо координат, выставляем номер места (чтоб потом знать какой объект вытеснять)
			newCoords.placeIndex = placeIndex;
			return newCoords;
		} else {
			return null;
		}
	}

//	добавляет id объекта к данной цели
	function addObjectToTarget(objectId, placeIndex){
//trace("addObjectToTarget: " + objectId + ", place: " + placeIndex);
		if(placeIndex != undefined){
			//	если placeIndex задан, то помещаем на соответствующее место 
			if(!this.placeList[placeIndex].freePlace){
			//			отправляем объект на старт
				this.placeList[placeIndex].freePlace = true;
				parent.sendObjectToStart(this.placeList[placeIndex].placedObject);
			}
			this.placeList[placeIndex].freePlace = false;
			this.placeList[placeIndex].placedObject = objectId;
		} else {
			//	если placeIndex не задан, то помещаем в первое свободное место
			for(var i = 0; i < this.placeList.length; i++){
				if(!this.placeList[i].freePlace){
					this.placeList[i].freePlace = false;
					this.placeList[i].placedObject = objectId;					
					//this.placedObjectsCounter++;
					break;
				}
			}
		}
	}

//	исключает объект с данным id из цели
	function removeObjectFromTarget(objectId){
		for(var i = 0; i < this.placeList.length; i++){
			if(!this.placeList[i].freePlace && this.placeList[i].placedObject == objectId){
				this.placeList[i].freePlace = true;
				this.placeList[i].placedObject = null;
				this.placedObjectsCounter--;
				break;
			}
		}
	}

	function removeObjectsFromTarget(){
		for(var i = 0; i < this.placeList.length; ++i){
			this.placeList[i].freePlace = true;
			this.placeList[i].placedObject = null;
		}

		this.placedObjectsCounter = 0;
	}	

	function getObjectOnPlace(placeIndex){
		if(!this.placeList[placeIndex].freePlace){
			return this.placeList[placeIndex].placedObject;
		} else {
			return null;
		}
	}

//	возвращает список помещённых в данную цель объектов	
	function getObjectsList(){
		var newObjectList = new Array();
		for(var i = 0; i < this.placeList.length; i++){
			if(!this.placeList[i].freePlace){
				newObjectList.push(this.placeList[i].placedObject);
			}
		}
		if(newObjectList){
			return newObjectList;
		} else {
			return null;
		}
	}

//	возвращает общее количесвто мест для данной цели 
//	(т.е. то количество, после которого цель будет считаться занятой)
//	для classification определяется по количеству указанных мест в placement
	function getTotalPlaces(){
		return this.totalPlaces;
	}

	function showActiveMark(){
		if(this.activeMarkBorder)
			this.activeMarkBorder.visible = true;
		if (this.activeMarkObject)
			this.activeMarkObject.showObject();
	}

	function hideActiveMark(){
		if(this.activeMarkBorder)
			this.activeMarkBorder.visible = false;
		if (this.activeMarkObject)
			this.activeMarkObject.hideObject();
	}
]]></script>
</composition>

<!--	=============================================================================
					ПЕРЕТАСКИВАЕМЫЙ  ОБЪЕКТ
					
	=============================================================================
-->
<composition name="dragging_dragobject" class="rnmc_stdMediaGroup" >
<script><![CDATA[
//	чувствительность
	this.sensitivity = 20;
//	скорость движения
	this.flowdeltaX = 15;
	this.flowdeltaY = 15;
//  для медленного возврата на место
//	this.flowquick = false;  из родителя
//	номер стартового места
	this.startPlace = -1;
	this.releasedStartPlace = -1;
//	стартовые координаты
	this.startX = 0;
	this.startY = 0;

	this.destinationDefinedX = false;	
	this.destinationDefinedY = false;	
	this.destinationX = 0;
	this.destinationY = 0;

	this.moveDestinationX = 0;
	this.moveDestinationY = 0;

	this.destinationSize = false;  //f
	this.changeDestinationSize = false;   //f
	
	this.objectTargets = null;

//	текущая цель (в которую он помещён)
	this.currentTarget = null;
	
//   подцепляем кнопку увеличить	fff
	this.zoomButton = null;   //ID!!
	this.zoomButtonX = 0;
	this.zoomButtonY = 0;
	this.zoomButtonDestX = 0;
	this.zoomButtonDestY = 0;
//
	this.checkMode = DRAGGING_CHECK_IMMEDIATELY;

//
	this.regPointType = parent.regPointType;     // "LEFT_TOP"; // "CENTER" | "MOUSE" | "CUSTOM"
	this.regPointX = 0;
	this.regPointY = 0;

//
	this.DraggingBounMode  = "screen"; // "undound", "exactly"
	this.minDraggingBoundX = null;
	this.maxDraggingBoundX = null;
	this.minDraggingBoundY = null;
	this.maxDraggingBoundY = null;

//	захвачена или нет
	this.captured = true;
	this.flowsNow = false;

//	текущее состояние объекта
//	DRAGOBJECT_STATE_ONSTART
	this.objectState = DRAGOBJECT_STATE_BEFORESTART;
//trace("3076  this.objectState="+this.objectState);
//	правильная постановка 
	this.placed = false;

//	поведение по умолчанию при неправильной постановке объекта
//	возможны следующие варианты: 
//	DRAGGING_RETURN_TO_START - вернуть на старт
//	DRAGGING_MOVE_TO_TRASHBOX - отправить в корзину
	if(parent.wrongPlacedBehaviour == "Undefined"){
		this.wrongPlacedBehaviour = DRAGGING_REMOVE_FROM_SCREEN;
	} else{
		this.wrongPlacedBehaviour = parent.wrongPlacedBehaviour;
	}
//trace("3614--"+parent.wrongPlacedBehaviour);
//	поведение по умолчанию при непоппаданиии ни в одну цель
//	возможны следующие варианты: 
//	DRAGGING_RETURN_TO_START - вернуть на старт
//	DRAGGING_MOVE_TO_TRASHBOX - отправить в корзину
	this.noTargetsMatchedBehaviour = DRAGGING_RETURN_TO_START;

	this.useDefaultActions = true;

// при правильной постановке перетаскиваемого объекта
	this.placedRightActions = null;
// при неправильной постановке перетаскиваемого объекта
	this.placedWrongActions = null;

	this.aliasList = null;

	this.onFinishMoveCallbackObject = null;
	this.onFinishMoveCallbackFunction = null;

	function initFromNode(srcNode){
//trace("dragging_dragobject.initFromNode()");
		var xmlNode = null;
		var xmlAttributeMap = null;
		var xmlAttribute = null;

		xmlAttributeMap = srcNode.attributes;
		if (xmlAttributeMap){
			xmlAttribute = xmlAttributeMap.getNamedItem("id");
			if (xmlAttribute != null && xmlAttribute.specified)
				this.id = xmlAttribute.value;
		}
//trace("dragging_dragobject.initFromNode()"+this.id);
		this.childObjects = new Array();
		if(!this.objectTargets)
			this.objectTargets = new Array();

		this.loadChildsObject(srcNode);

		xmlNode = srcNode.firstChild;
		while(xmlNode){
			if(xmlNode.nodeName == "param"){
				xmlAttributeMap = xmlNode.attributes;
				if (xmlAttributeMap){
					xmlAttribute =  xmlAttributeMap.getNamedItem("checkMode");
					if (xmlAttribute != null && xmlAttribute.specified){
						if(xmlAttribute.value == "CHECK_AFTER"){
						//	означает что расположение будет проверяться после
						//		нажатия кнопки проверить
							this.checkMode = DRAGGING_CHECK_AFTER;
						} else if(xmlAttribute.value == "CHECK_IMMEDIATELY"){
						//	означает что расположение будет проверяться сразу
							this.checkMode = DRAGGING_CHECK_IMMEDIATELY;
						}
					};
					xmlAttribute =  xmlAttributeMap.getNamedItem("placedWrong");
					if (xmlAttribute != null && xmlAttribute.specified){
						switch(xmlAttribute.value){
						case "moveToTrashBox":
							this.wrongPlacedBehaviour = DRAGGING_MOVE_TO_TRASHBOX;
							break;
						case "returnToStart":
							this.wrongPlacedBehaviour = DRAGGING_RETURN_TO_START;
							break;
						case "removeFromScreen":
							this.wrongPlacedBehaviour = DRAGGING_REMOVE_FROM_SCREEN;
							break;
						}
					};
					xmlAttribute =  xmlAttributeMap.getNamedItem("useDefaultActions");
					if (xmlAttribute != null && xmlAttribute.specified){
						if(xmlAttribute.value == "false")
							this.useDefaultActions = false;
					};

					xmlAttribute =  xmlAttributeMap.getNamedItem("regPoint");
					if (xmlAttribute != null && xmlAttribute.specified){
						switch((xmlAttribute.value).toUpperCase()){
						case "LEFT_TOP":
							this.regPointType = "LEFT_TOP";
							break;
						case "CENTER":
							this.regPointType = "CENTER";
							break;
						case "MOUSE":
							this.regPointType = "MOUSE";
							break;
						default:
						//	если указан конкретный регпоинт: 10;10
							var regPointCoords = (xmlAttribute.value).split(";");
							if(regPointCoords.length == 2){
								this.regPointType = "CUSTOM";
								this.regPointX = parseInt(regPointCoords[0]);
								this.regPointY = parseInt(regPointCoords[1]);
							}
							break;
						}
					};	
// trace("2713   this.regPointType "+this.regPointType);
					xmlAttribute =  xmlAttributeMap.getNamedItem("flowquick");
//trace("flowquick"+xmlAttribute);
					if (xmlAttribute != null && xmlAttribute.specified){
					    if(xmlAttribute.value == "true")
							this.flowquick = true;
					}
//trace("--"+this.flowquick);//this.flowquick
					xmlAttribute = xmlAttributeMap.getNamedItem("targets");
					if (xmlAttribute != null && xmlAttribute.specified
						&& xmlAttribute.value != ""){
						var additionalTargets = (xmlAttribute.value).split(";");
						if(additionalTargets && additionalTargets.length > 0){
							for(var i = 0 ; i < additionalTargets.length; i++ ){
								this.objectTargets.push(additionalTargets[i]);
							}
						}
					}
//trace(this.id+"--"+this.objectTargets);					
					xmlAttribute =  xmlAttributeMap.getNamedItem("quantity");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.quantity = parseInt(xmlAttribute.value);
					}
					xmlAttribute = xmlAttributeMap.getNamedItem("destinationX");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.destinationDefinedX = true;
						this.destinationX = parseInt(xmlAttribute.value);
					}
					xmlAttribute = xmlAttributeMap.getNamedItem("destinationY");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.destinationDefinedY = true;
						this.destinationY = parseInt(xmlAttribute.value);
					}					
					xmlAttribute =  xmlAttributeMap.getNamedItem("destinationSize");  //<f
					if (xmlAttribute != null && xmlAttribute.specified){		   //вернуться к собственному размеру			
					    if(xmlAttribute.value == "true")
							this.destinationSize = true;
							this.changeDestinationSize = true;
					}
					xmlAttribute = xmlAttributeMap.getNamedItem("destinationWidth");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.changeDestinationSize = true;
						this.destinationWidth = parseInt(xmlAttribute.value);
					}
					xmlAttribute = xmlAttributeMap.getNamedItem("destinationHeight");
					if (xmlAttribute != null && xmlAttribute.specified){
						this.changeDestinationSize = true;
						this.destinationHeight = parseInt(xmlAttribute.value);   //f>
					}
				}
			} else if(xmlNode.nodeName == "aliases"){
				var aliasNode = xmlNode.firstChild;
				while(aliasNode){
					if(aliasNode.nodeName == "alias"){
						var newAlias = new Array();
						xmlAttributeMap = aliasNode.attributes;
						if (xmlAttributeMap){
							xmlAttribute = xmlAttributeMap.getNamedItem("classId");
							if (xmlAttribute != null && xmlAttribute.specified)
								newAlias.classId = xmlAttribute.value;
							xmlAttribute = xmlAttributeMap.getNamedItem("objectId");
							if (xmlAttribute != null && xmlAttribute.specified)
								newAlias.objectId = xmlAttribute.value;
						}
						if(newAlias.objectId){
							if(!this.aliasList){
								this.aliasList = new Array();
							}
							this.aliasList.push(newAlias);
						}
					}
					aliasNode = aliasNode.nextSibling;
				}
			} else if(xmlNode.nodeName == "effect") {
				this.parseEffectNode(srcNode)
			} else if(xmlNode.nodeName == "effects") {
				this.parseEffectsNode(xmlNode);
			} else if(xmlNode.nodeName == "hint") {
				this.parseHintNode(xmlNode);
			} else if(xmlNode.nodeName == "actions"){
				rnmc_stdMediaObject_parseActionsNode(xmlNode); 
				this.placedRightActions =
					scene.Utils.parseActionsNode(xmlNode, "onPlacedRight");
//trace("actions "+this.placedRightActions);
				this.placedWrongActions =
					scene.Utils.parseActionsNode(xmlNode, "onPlacedWrong");
//trace("3793--actions onPlacedWrong"+this.placedWrongActions);
			} else if(xmlNode.nodeName == "attachzoom"){   ///f
				xmlAttributeMap = xmlNode.attributes;
				
				if (xmlAttributeMap){
					xmlAttribute =  xmlAttributeMap.getNamedItem("id");
					if (xmlAttribute != null && xmlAttribute.specified)
					    this.zoomButton = xmlAttribute.value;
						
					xmlAttribute =  xmlAttributeMap.getNamedItem("x");
					if (xmlAttribute != null && xmlAttribute.specified)
					    this.zoomButtonX = parseInt(xmlAttribute.value);
						
					xmlAttribute =  xmlAttributeMap.getNamedItem("y");
					if (xmlAttribute != null && xmlAttribute.specified)
					    this.zoomButtonY = parseInt(xmlAttribute.value);
						
					xmlAttribute =  xmlAttributeMap.getNamedItem("destinationX");
					if (xmlAttribute != null && xmlAttribute.specified){
					    this.zoomButtonDestX = parseInt(xmlAttribute.value);	
					} else {
					    this.zoomButtonDestX = this.zoomButtonX;
					}
					
					xmlAttribute =  xmlAttributeMap.getNamedItem("destinationY");
					if (xmlAttribute != null && xmlAttribute.specified){
					    this.zoomButtonDestY = parseInt(xmlAttribute.value);	
					} else {
					    this.zoomButtonDestY = this.zoomButtonY;
					}
				}
//trace("3717-attachzoom  "+this.zoomButton+" zoomButtonY="+this.zoomButtonY);
			}
			xmlNode = xmlNode.nextSibling;
		};
	
		//	границы таскания
		this.minDraggingBoundX = 0;
		this.maxDraggingBoundX = Player.module.scenes.width;
		this.minDraggingBoundY = 0;
		this.maxDraggingBoundY = Player.module.scenes.height;
		return true;
	}

	function showObject(){
//trace("#FF00FFshowObject_dragg_   "+this.id);
		for(var i = 0; i < this.childObjects.length; i++){		
			this.childObjects[i].showObject();
			var ownSize=this.childObjects[i].getMediaSize();			
//trace(ownSize.height+"=h  --vse--  w="+ownSize.width);   ///f
			this.ownHeight = ownSize.height;
			this.ownWidth = ownSize.width;
		}

		this.x = this.startX;
		this.y = this.startY;

	//	выставляем регпоинт
		this.testOffsetX = 0;
		this.testOffsetY = 0;

		this.notifyOnMouseMove = true;

		this.originalDepth = this.depth;
		this.onRelease = releaseHandler;
		this.onReleaseOutside = releaseHandler;
		this.onPress = pressHandler;

		if(this.attachRollOverHandler){
			this.onRollOver = this.onRollOverHandlerAlias;
			this.objectMayBeDisabled = false;
		}
		if(this.attachRollOutHandler){
			this.onRollOut = this.onRollOutHandlerAlias;
			this.objectMayBeDisabled = false;
		}
		this.objectState = DRAGOBJECT_STATE_ONSTART;
		this.visible = true;
		
		for (var i2 = 0; i2<this.parent.childObjects.length; i2++) {
//trace("3765-- "+this.parent.childObjects[i2].id+this.parent.childObjects[i2].type);		             
			 if(this.zoomButton == this.parent.childObjects[i2].id && this.parent.childObjects[i2].type=="rnmc_stdButton"){			     
				this.parent.childObjects[i2].x = this.x + this.zoomButtonX;
				this.parent.childObjects[i2].y = this.y + this.zoomButtonY;
//trace(this.zoomButton+"  !!!popal "+this.parent.childObjects[i2].x);				
		     }	
			 if(this.zoomButton == this.parent.childObjects[i2].id && this.parent.childObjects[i2].type== "rnmc_stdImage"){
//trace(this.zoomButton+"-3772- "+this.parent.childObjects[i2].id+this.parent.childObjects[i2].objectY);	
				 this.parent.childObjects[i2].objectX = this.x + this.zoomButtonX;
				 this.parent.childObjects[i2].objectY = this.y + this.zoomButtonY;
// trace("vv2 "+this.parent.childObjects[i2].id+this.parent.childObjects[i2].objectY);	
			 }
			 if(this.zoomButton == this.parent.childObjects[i2].id && this.parent.childObjects[i2].type== "rnmc_stdText"){
//trace(this.zoomButton+"-3772- "+this.parent.childObjects[i2].id+this.parent.childObjects[i2].objectY);	
				 this.parent.childObjects[i2].objectX = this.x + this.zoomButtonX;
				 this.parent.childObjects[i2].objectY = this.y + this.zoomButtonY;
// trace("vv2 "+this.parent.childObjects[i2].id+this.parent.childObjects[i2].objectY);	
			 }
		}
	}

	function hideObject(){
		for(var i = 0; i < this.childObjects.length; i++){
			this.childObjects[i].hideObject();
		}
		this.visible = false;

		this.onRelease = null;
		this.onReleaseOutside = null;
		this.onPress = null;
		this.onRollOver = null;
		this.onRollOut = null;
	};

//	переопределение dispatchAction
	function dispatchAction(singleAction){
//trace("dispatchAction"+singleAction);
		if (singleAction[1] != null){
			if(singleAction[1].charAt(0) == "."){
				if(singleAction[1].charAt(1) == "."){
				// в данном случае родитель - сам шаг
					singleAction = singleAction.slice(0);
					singleAction[1] = singleAction[1].slice(1);
//					parent.doAction(singleAction);
					parent.dispatchAction(singleAction);
				} else {
					singleAction = singleAction.slice(0);
					singleAction[1] = singleAction[1].slice(1);
					this.doAction(singleAction);
				}
			} else {
				scene.Labwork.currentStep.doAction(singleAction);
			}
		} else {
			switch (singleAction[0]) {
				case "goToStep":
				case "goToStepWithId":
				case "goPreviousStep":
				case "goNextStep":
				case "goFirstStep":
				case "goLastStep":
				case "goToSummary":
					scene.Labwork.currentStep.doAction(singleAction);
					break;

				default:
				// действие без параметров - сразу перенаправить в doAction
					this.doAction(singleAction);
					break;
			}
		}
	}	
	
//	устанавливает занятую стартовую позицию
	function setStartPlace(placeIndex){
		this.startPlace = placeIndex;
		if(placeIndex >= 0){
			var startPlaceCoords = parent.getStartPlaceCoords(placeIndex);
			this.startX = startPlaceCoords[0];
			this.startY = startPlaceCoords[1];
		}
	}

	function restoreLastState(){
//trace("restoreLastState() "+this.lastPositionX);
		this.startPlace = this.lastPositionStartPlace; 
		this.currentTarget = this.lastPositionTarget;
		this.moveTo(this.lastPositionX, this.lastPositionY);
	}

//	производит стандартное действие с объектом
	function usePreDefinedBehaviour(currentBehaviour){
		switch(currentBehaviour){
		case DRAGGING_RETURN_TO_START:
		//PG: Удаляем объекты из целей и переносим в стартовые позиции.
		// При проверки после - переносим в первую свободную стартовую позицию,
		// а противном случае - туда от куда взяли
			if (parent.checkMode == DRAGGING_CHECK_AFTER){
				parent.removeObjectFromTarget(this.id, this.currentTarget);
				parent.sendObjectToStart(this.id);
			} else
				this.moveTo(this.startX, this.startY);
			break;
			
		case DRAGGING_MOVE_TO_TRASHBOX:
		//	//	выставляем статус объекта - в трэшбоксе
			this.objectState = DRAGOBJECT_STATE_INTRASHBOX;
			var trashBoxCoords = parent.getTrashBoxCoords();
			this.useHandCursor = false;
			this.onRelease = null;
			this.onReleaseOutside = null;
			this.onPress = null;
			this.moveTo(trashBoxCoords[0], trashBoxCoords[1]);
		//	сообщаем что стартовое место, которое занимал этот объект теперь свободно
			if(this.startPlace >= 0){
				parent.notifyStartPlaceFree(this.startPlace);
				this.startPlace = -1;
			}
			break;
		case DRAGGING_REMOVE_FROM_SCREEN:	
		//	обычное поведение
			this.objectState = DRAGOBJECT_STATE_REMOVE_ERROR;
			this.hideObject();
		//	сообщаем что стартовое место, которое занимал этот объект теперь свободно
			if(this.startPlace >= 0){
				parent.notifyStartPlaceFree(this.startPlace);
				this.startPlace = -1;
			}
			break;
		}
	}

//	обработчики событий
	function pressHandler(){
//trace("3655--dragging_dragobject.pressHandler()");

	//	сохраняем параметры последнего положения объекта 
		switch(this.regPointType){
		case "LEFT_TOP":
			this.testOffsetX = 0;
			this.testOffsetY = 0;
			break;
		case "CENTER":
			this.testOffsetX = parseInt(this.width/2);
			this.testOffsetY = parseInt(this.height/2);
			break;
		case "MOUSE":
			this.testOffsetX = this.xMouse;
			this.testOffsetY = this.yMouse;
			break;
		case "CUSTOM":
			this.testOffsetX = this.regPointX;
			this.testOffsetY = this.regPointY;
			break;
		}
		if(!this.flowsNow){
			this.lastPositionX = this.x;
			this.lastPositionY = this.y;
			this.lastPositionState = this.objectState;
			this.lastPositionStartPlace = this.startPlace;
			this.lastPositionTarget = this.currentTarget;
//	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
			this.lastPositionTargetPlace = 0;
		}

		updateSequencer.playing = false;
		this.depth += -500;
		this.onMouseMove = mouseMoveHandler;
		this.xOffset = this.xMouse;
		this.yOffset = this.yMouse;
		this.captured = true;

		rnmc_stdMediaObject_applyActions(EVENT_ON_PRESS);
	};

	function releaseHandler(){
//trace("releaseHandler  "+this.captured);
		if(this.captured){
			this.onMouseMove = null;
			this.captured = false;
			this.placeObject();
			updateSequencer.playing = true;
			rnmc_stdMediaObject_applyActions(EVENT_ON_RELEASE);
		};
	};

	// Функция перебирает все дочернии элементы и скрывает у них выслывающее меню
	function hideRollOverMenu(object) {
		var tmpObjects = object.childObjects;
		if (tmpObjects) {
			for (var i = 0; i < tmpObjects.length; ++i){
				if (tmpObjects[i].rolloverMenuObject)
					tmpObjects[i].rolloverMenuObject.hideObject();
				if (tmpObjects[i].childObjects)
					hideRollOverMenu(tmpObjects[i]);
			}
		}
	}

	function mouseMoveHandler(){
//trace("mouseMoveHandler");
	// При таскании всплывающее меню убираем
		this.hideRollOverMenu(this);

		if(this.captured){
            if (scene.Hint)
              scene.Hint.stopHint();

			if(this.notifyOnMouseMove){
				var globCoord = this.localToGlobal(this.testOffsetX, this.testOffsetY);
				parent.notifyMouseCoords(globCoord.x, globCoord.y);
			}
			var newX = this.x + (this.xMouse - this.xOffset);
			var newY = this.y + (this.yMouse - this.yOffset);

			var boundCordMin = parent.globalToLocal(scene.x, scene.y);
			var boundCordMax = parent.globalToLocal(scene.x + Player.module.scenes.width,
												scene.y + Player.module.scenes.height);
			if (this.DraggingBounMode  == "screen"){
				if(newX < boundCordMin.x)
					newX = boundCordMin.x;
				else if(newX + this.width > boundCordMax.x)
					newX = boundCordMax.x - this.width;

				if(newY < boundCordMin.y)
					newY = boundCordMin.y;
				else if(newY + this.height > boundCordMax.y)
					newY = boundCordMax.y - this.height;

			} else if (this.DraggingBounMode == "exactly"){
				if (this.minDraggingBoundX != null)
				{
					if(newX < this.minDraggingBoundX)
						newX = this.minDraggingBoundX;
					else if(newX  > this.maxDraggingBoundX - this.width)
						newX = this.maxDraggingBoundX - this.width;
				}

				if (this.minDraggingBoundY != null)
				{
					if(newY < this.minDraggingBoundY)
						newY = this.minDraggingBoundY;
					else if(newY  > this.maxDraggingBoundY - this.height)
						newY = this.maxDraggingBoundY - this.height;
				}
			}

			this.x = newX;
			this.y = newY;
//trace("mouseMoveHandler"+this.x);
		}
	}

	function moveTo(xDest, yDest){
//trace(this.x+" moveTo "+xDest);
		this.moveDestinationX = xDest;
		this.moveDestinationY = yDest;
		if(this.flowquick){
		   this.flowdeltaX = Math.abs(Math.round((this.moveDestinationX - this.x)/5));
		   this.flowdeltaY = Math.abs(Math.round((this.moveDestinationY - this.y)/5));
		}
		this.flowsNow = true;
		updateSequencer.playing = true;
	}

//	специальная функция
	function moveToStartPlace(placeIndex){
//trace("moveToStartPlace");  
		this.startPlace = placeIndex;
		if(placeIndex >= 0){
			var startPlaceCoords = parent.getStartPlaceCoords(placeIndex);
			this.startX = startPlaceCoords[0];
			this.startY = startPlaceCoords[1];
			this.moveDestinationX = this.startX;
			this.moveDestinationY = this.startY;
			updateSequencer.playing = true;
		} else {
			//	если отрицательная - сброс старотвой позиции
		}
	}

	function onFinishMove(){
//trace(this.objectState+"***//3908onFinishMove  "+this.placedRight);//ходит один раз после прав постановки каждого
		switch(this.objectState){
		case DRAGOBJECT_STATE_PLACED:		
			if(this.checkMode == DRAGGING_CHECK_IMMEDIATELY && this.placedRight){
//trace("++4131++DRAGOBJECT_"+this.placedRight);
				if(this.useDefaultActions)
					parent.applyDefaultActions("onPlacedRight");
				    parent.butt_NextPrevClass(false);	
				if(this.placedRightActions){
//trace("this.placedRightActions");
					for(var i = 0; i < this.placedRightActions.length; i++){
						parent.dispatchAction(this.placedRightActions[i]);
					}
				}
				if(this.placedRight)
					parent.notifyObjectPlaced(this.id, this.placedRight);
				if(this.releasedStartPlace >= 0){
					parent.notifyStartPlaceFree(this.releasedStartPlace);
				}
			} else {
			//parent.printOccupiedStartPlaces();
//trace("3341---"+parent.targetsArray.length);
		        if(parent.showBtnCheck == false){
		             parent.getOccupiedStartPlaces();
				 }
			}
		//	выключаем подсветку - искуственно прилепили -10000
			parent.notifyMouseCoords(-10000, -10000);
			break;
		}
		if(this.onFinishMoveCallbackObject && this.onFinishMoveCallbackFunction){		
			this.onFinishMoveCallbackFunction.call(this.onFinishMoveCallbackObject);
		}
	}

	function setOnFinishMoveCallBack(pointerToObject, callbackFunction){
		this.onFinishMoveCallbackObject = pointerToObject;
		this.onFinishMoveCallbackFunction = callbackFunction;
	};
	
	function clearOnFinishMoveCallBack(){
		this.onFinishMoveCallbackObject = null;
		this.onFinishMoveCallbackFunction = null;
	};
	
	function updateObject(){
		var xTargetOffset = this.moveDestinationX - this.x;
		var yTargetOffset = this.moveDestinationY - this.y;
	//(this.moveDestinationX    -куда должен уплыть);
		if((Math.abs(xTargetOffset) < Math.abs(this.flowdeltaX)) || (Math.abs(xTargetOffset) < 3)){
		   xTargetOffset = 0;
		   this.x = this.moveDestinationX;
		}
		if(Math.abs(yTargetOffset) < Math.abs(this.flowdeltaY) || (Math.abs(yTargetOffset) < 3)){
		   yTargetOffset = 0;
		   this.y = this.moveDestinationY;
        }		   
		if(xTargetOffset != 0){
			if (xTargetOffset > this.flowdeltaX)
				this.x += this.flowdeltaX;
			else if (xTargetOffset < - this.flowdeltaX)
				this.x -= this.flowdeltaX;
			else
				this.x += xTargetOffset;
		};

		if(yTargetOffset != 0){
			if (yTargetOffset > this.flowdeltaY)
				this.y += this.flowdeltaY;
			else if (yTargetOffset < - this.flowdeltaY)
				this.y -= this.flowdeltaY;
			else
				this.y += yTargetOffset;
		}; 
//trace(yTargetOffset+"  ---3379updateObject()   "+xTargetOffset);
		if (Math.round(xTargetOffset - 0.5) == 0 && Math.round(yTargetOffset - 0.5) == 0){
//trace(yTargetOffset+"  ---3381updateObject()   "+xTargetOffset);
			updateSequencer.playing = false;
			this.depth = this.originalDepth;
			this.flowsNow = false;
			this.onFinishMove();
		};
	};

	function placeObject(){
//trace("!!!!!!!!!!!!!!!!!!!!!!!!!!!!");				
//trace("  3685--placeObject  "+this.objectTargets.length);
//trace(this.moveDestinationX);

		var globCoord = this.localToGlobal(this.testOffsetX, this.testOffsetY);
		if(this.checkMode == DRAGGING_CHECK_IMMEDIATELY){
		//	Проверка происходит сразу при постановке объекта
		  var matchedTargets = parent.getMatchedTargets(globCoord.x, globCoord.y);

			if(!this.objectTargets || this.objectTargets.length == 0){
			// У объекта нет целей (пустышка)
				for(var i = 0 ; i < parent.targetsArray.length; i++){
					parent.targetsArray[i].hideActiveMark();
				}			
			}

			if(this.objectTargets && this.objectTargets.length > 0){

			//	у объекта есть цели
			//	получаем список целей которые подходят под координаты отпускания объекта

				if(matchedTargets && matchedTargets.length > 0){
				//	режим проверки правильности постановки сразу после отпускания мыши
					var newTargetId = null;

					for(var i = 0 ; i < matchedTargets.length; i++){
						for(var j = 0 ; j < this.objectTargets.length; j++){
							if(this.objectTargets[j] == matchedTargets[i]){
							//	если найдена свободная цель, куда нужно поставить данный объект
							//	получаем коодринаты свободного места в ней
								var targetCoords = null;
								if(!this.aliasList){
									targetCoords = parent.getFreePlace(this.objectTargets[j]);
								} else {
								//	проверка на наличие алиасов
									var aliasFound = false;
									var placedObj = parent.getObjectsList(this.objectTargets[j]);
									if(placedObj){
										for(var n = 0; n < placedObj.length; n++){
											for(var m = 0; m < this.aliasList.length; m++){
												if(placedObj[n] == this.aliasList[m].objectId){
													aliasFound = true;
													break;
												}
											}
											if(aliasFound){
												break;
											}
										}
									}
									if(!aliasFound){
										targetCoords = parent.getFreePlace(this.objectTargets[j]);
									}
								}
								if(targetCoords){
							//	для Сергеева - высвечивает правильный был ответ или нет !!!!!!!!!
									scene.Labwork.addNewResult(100, "");
									newTargetId = this.objectTargets[j];
									var delta_destinationX = 0;
									var delta_destinationY = 0;
									if(this.destinationDefinedX || this.destinationDefinedY){   ///f если надо сместить поставленную таскалку относительно цели
									   var noRandomTargetCoord = parent.getnoRandomTargetCoord(newTargetId);
									    if(this.destinationDefinedX)
									      delta_destinationX = this.destinationX - noRandomTargetCoord[0];
										if(this.destinationDefinedY)
											delta_destinationY = this.destinationY - noRandomTargetCoord[1];
									}

								  if(targetCoords[0] && targetCoords[1]){
									  this.destinationX = targetCoords[0]+delta_destinationX;
									  this.destinationY = targetCoords[1]+delta_destinationY;
									}

									this.useHandCursor = false;
									this.onRelease = null;
									this.onReleaseOutside = null;
									this.onPress = null;
								//	устанавливаем параметры расположения
									this.objectState = DRAGOBJECT_STATE_PLACED;
									this.placedRight = true;
									this.currentTarget = newTargetId;
									this.placed = true;
									parent.addObjectToTarget(this.id, this.objectTargets[j],  targetCoords.placeIndex);
									if(this.startPlace >= 0){
										this.releasedStartPlace = this.startPlace;
										this.startPlace = -1;
									}
									this.moveTo(this.destinationX, this.destinationY);

									if(this.changeDestinationSize){
										for(var i = 0; i < this.childObjects.length; i++){	
											var g_pos=this.childObjects[i].getPosition();
											var g_pos2 = g_pos[2];
											var g_pos3 = g_pos[3];
											if(this.destinationSize){
												//g_pos.originalWidth=this.ownWidth;
												//g_pos.originalHeight=this.ownHeight;
												g_pos[2]=this.ownWidth;
												g_pos[3]=this.ownHeight;
												//this.height = this.ownHeight;
												// this.width = this.ownWidth;
											} else{
												g_pos[2]=this.destinationWidth;
												g_pos[3]=this.destinationHeight;
											  //this.objectHeight = this.destinationHeight;
												//this.objectWidth = this.destinationWidth;
											}
											this.childObjects[i].setPosition(g_pos[0],g_pos[1],g_pos[2],g_pos[3]);
											this.childObjects[i].applyPositionChanges();
										} 
								     }
                                     for (var i2 = 0; i2<this.parent.childObjects.length; i2++) {
										if(this.zoomButton == this.parent.childObjects[i2].id
											&& this.parent.childObjects[i2].type=="rnmc_stdButton"){
											 this.parent.childObjects[i2].x = this.destinationX + this.zoomButtonDestX;
                                             this.parent.childObjects[i2].y = this.destinationY + this.zoomButtonDestY;
										}

										if(this.zoomButton == this.parent.childObjects[i2].id
											&& this.parent.childObjects[i2].type== "rnmc_stdImage"){
				                             this.parent.childObjects[i2].objectX = this.destinationX + this.zoomButtonDestX;
				                             this.parent.childObjects[i2].objectY = this.destinationY + this.zoomButtonDestY;
											 this.parent.childObjects[i2].setPosition(this.destinationX + this.zoomButtonDestX, this.destinationY + this.zoomButtonDestY);
			                            }
										if(this.zoomButton == this.parent.childObjects[i2].id
											&& this.parent.childObjects[i2].type== "rnmc_stdText"){
				                             this.parent.childObjects[i2].objectX = this.destinationX + this.zoomButtonDestX;
				                             this.parent.childObjects[i2].objectY = this.destinationY + this.zoomButtonDestY;
											 this.parent.childObjects[i2].setPosition(this.destinationX + this.zoomButtonDestX, this.destinationY + this.zoomButtonDestY);
			                            }
		                             }

                 // Если у цели есть action на постановку объекта в цель
                 // то выполнем его
                                     var theTarget = parent.getTarget(this.objectTargets[j]);
                                     if (theTarget && theTarget.onObjectPlacedRightActions){
										for(var ii = 0; ii < theTarget.onObjectPlacedRightActions.length; ii++){
											parent.dispatchAction(theTarget.onObjectPlacedRightActions[ii]);
										}
									 }									
									 break;
								} else {
									//	в текущей выбранной цели нет свободных мест
									//	значит надо перебирать возможные цели дальше
								}
							} else {
								if(this.wrongPlacedBehaviour == DRAGGING_REMOVE_FROM_SCREEN)
									this.objectState = DRAGOBJECT_STATE_REMOVE_ERROR;
									
								// объект ставится не в ту цель
								// Если у цели установлен обработчик события на неправильную постановку
								// объекта, то оповестим их
								var theTarget = parent.getTarget(matchedTargets[i]);
								theTarget.hideActiveMark();
								if (theTarget && theTarget.onObjectPlacedErrorActions){
//trace("3856--"+theTarget.onObjectPlacedErrorActions.length);
                                    for(var iii = 0; iii < theTarget.onObjectPlacedErrorActions.length; iii++){
//trace("3861--"+theTarget.onObjectPlacedErrorActions[iii][0]+"  "+theTarget.onObjectPlacedErrorActions[iii][1]);
										if(theTarget.onObjectPlacedErrorActions[iii][0] == "disableTarget"
											&& theTarget.onObjectPlacedErrorActions[iii].length==1){
											theTarget.disableTarget();
										} else {
											parent.dispatchAction(theTarget.onObjectPlacedErrorActions[iii]);
										}
									}
								}
							}
						}
					}

					if(!newTargetId){					
				//	если пришли сюда - значит либо поставили ваще не в ту цель
				//	либо в той цели куда поставили (хотя она и правильная нет места)
						this.placedRight = false;
						if(this.wrongPlacedBehaviour == DRAGGING_REMOVE_FROM_SCREEN)
						  this.objectState = DRAGOBJECT_STATE_REMOVE_ERROR;						  
					//	для Сергеева - высвечивает правильный был ответ или нет !!!!!!!!!
						scene.Labwork.addNewResult(0, "");
						if(this.useDefaultActions)
							parent.applyDefaultActions("onPlacedWrong");
						this.usePreDefinedBehaviour(this.wrongPlacedBehaviour);
						if(this.placedWrongActions){
							for(var i = 0; i < this.placedWrongActions.length; i++){
								parent.dispatchAction(this.placedWrongActions[i]);
							}
						}

						parent.notifyObjectPlaced(this.id, false);
					}
				} else {
				//	не попали ни в одну цель
					this.usePreDefinedBehaviour(this.noTargetsMatchedBehaviour);
				}
			} else {
//trace("	у объекта не задана ни одной цели--"+this.objectTargets.id);
			if(this.wrongPlacedBehaviour == DRAGGING_REMOVE_FROM_SCREEN)
			     this.objectState = DRAGOBJECT_STATE_REMOVE_ERROR;
				if(this.useDefaultActions)
					parent.applyDefaultActions("onPlacedWrong");
				this.usePreDefinedBehaviour(this.wrongPlacedBehaviour);

			//	пока стоит здесь, но НЕОБХОДИМО ПЕРЕНЕСТИ в парента !!!!!!!!! this.targetsArray[i].disableTarget();
				scene.Labwork.addNewResult(0, "");
				if(this.placedWrongActions){
					for(var iii = 0; iii < this.placedWrongActions.length; iii++){
						parent.dispatchAction(this.placedWrongActions[iii]);
					}
				}
				 var theTarget = parent.getTarget(matchedTargets);
// trace("3906--"+theTarget);
                 if (theTarget && theTarget.onObjectPlacedErrorActions){					 
                     for(var iii = 0; iii < theTarget.onObjectPlacedErrorActions.length; iii++){
//trace("3911--"+theTarget.onObjectPlacedErrorActions[iii][0]);
					     if(theTarget.onObjectPlacedErrorActions[iii][0] == "disableTarget" && theTarget.onObjectPlacedErrorActions[iii].length==1){
							theTarget.disableTarget();
							//theTarget.onObjectPlacedErrorActions[iii]=theTarget.onObjectPlacedErrorActions[iii]+","+theTarget.id;
						} else {
                             parent.dispatchAction(theTarget.onObjectPlacedErrorActions[iii]);
						}
                     }
                }
				parent.notifyObjectPlaced(this.id, false);  //f
			}
		} else if(this.checkMode == DRAGGING_CHECK_AFTER){
           	//	последующая проверка по кнопке");
		//	получаем список целей которые подходят под координаты отпускания объекта
			var matchedTargets = parent.getMatchedTargets(globCoord.x, globCoord.y);
			if(matchedTargets){
			//	режим проверки правильности постановки сразу после отпускания мыши
				for(var i = 0 ; i < matchedTargets.length; i++){
					var targetCoords = null;
				//	сначала смотрим - есть ли свободные места в данной цели
					targetCoords = parent.getFreePlace(matchedTargets[i]);
					if(!targetCoords){
					//	если их нет, то смотрим какое из мест в этой цели наиболее 
					//	близко к нашему объекту. Далее будем вытеснять объект с этого места
						targetCoords = parent.getSuitablePlace(matchedTargets[i],
															this.x, this.y);
					}
					if(targetCoords){
					//	если нашли цель куда таки можно поставить объект
					//	проверяем - стоял ли он перед этим в какой то цели.
					//	если да, то надо сообщить этой самой цели что его больше нету
						if(this.objectState == DRAGOBJECT_STATE_PLACED){
							parent.removeObjectFromTarget(this.id, this.currentTarget);
						} 
						this.destinationX = targetCoords[0];
						this.destinationY = targetCoords[1];
						
						var delta_destinationX = 0;    //<f
						var delta_destinationY = 0;
						if(this.destinationDefinedX || this.destinationDefinedY){   ///f если надо сместить поставленную таскалку относительно цели
							 var noRandomTargetCoord = parent.getnoRandomTargetCoord(newTargetId);
							 if(this.destinationDefinedX)
								 delta_destinationX = this.destinationX - noRandomTargetCoord[0];
							if(this.destinationDefinedY)
								delta_destinationY = this.destinationY - noRandomTargetCoord[1];
						}

						if(targetCoords[0] && targetCoords[1]){
							 this.destinationX = targetCoords[0]+delta_destinationX;
							 this.destinationY = targetCoords[1]+delta_destinationY;
						}   //f>

				//	устанавливаем параметры расположения");
						this.currentTarget = matchedTargets[i];
						this.objectState = DRAGOBJECT_STATE_PLACED;
					//	добавляем объект к цели newTargetId на место targetCoords.placeIndex
						parent.notifyStartPlaceFree(this.startPlace);
						this.startPlace = -1;
						parent.addObjectToTarget(this.id, matchedTargets[i], targetCoords.placeIndex);
						this.moveTo(this.destinationX, this.destinationY);
						if(this.changeDestinationSize){   ///<f
							for(var i = 0; i < this.childObjects.length; i++){	
								var g_pos=this.childObjects[i].getPosition();
								var g_pos2 = g_pos[2];
								var g_pos3 = g_pos[3];
								if(this.destinationSize){
									//g_pos.originalWidth=this.ownWidth;
									//g_pos.originalHeight=this.ownHeight;
									g_pos[2]=this.ownWidth;
									g_pos[3]=this.ownHeight;
									//this.height = this.ownHeight;
									// this.width = this.ownWidth;
								} else{
									g_pos[2]=this.destinationWidth;
									g_pos[3]=this.destinationHeight;
									//this.objectHeight = this.destinationHeight;
									//this.objectWidth = this.destinationWidth;
								}
								this.childObjects[i].setPosition(g_pos[0],g_pos[1],g_pos[2],g_pos[3]);
								this.childObjects[i].applyPositionChanges();
								} 
						}
                         for (var i2 = 0; i2<this.parent.childObjects.length; i2++) {
							if(this.zoomButton == this.parent.childObjects[i2].id
							                && this.parent.childObjects[i2].type=="rnmc_stdButton"){
							     this.parent.childObjects[i2].x = this.destinationX + this.zoomButtonDestX;
                                 this.parent.childObjects[i2].y = this.destinationY + this.zoomButtonDestY;
							}

							if(this.zoomButton == this.parent.childObjects[i2].id
											&& this.parent.childObjects[i2].type== "rnmc_stdImage"){
//trace(this.parent.childObjects[i2].objectY+"--4421--"+this.parent.childObjects[i2].id+"  zoomButtonDestX / Y ="+this.zoomButtonDestX+" / "+this.zoomButtonDestY);											
				                 this.parent.childObjects[i2].objectX = this.destinationX + this.zoomButtonDestX;
				                 this.parent.childObjects[i2].objectY = this.destinationY + this.zoomButtonDestY;
//trace("4424--"+this.parent.childObjects[i2].objectY );
                                 //this.parent.childObjects[i2].updatePosition();
								 this.parent.childObjects[i2].setPosition(this.destinationX + this.zoomButtonDestX, this.destinationY + this.zoomButtonDestY);
			                }
							if(this.zoomButton == this.parent.childObjects[i2].id
											&& this.parent.childObjects[i2].type== "rnmc_stdText"){
//trace(this.parent.childObjects[i2].objectY+"--4421--"+this.parent.childObjects[i2].id+"  zoomButtonDestX / Y ="+this.zoomButtonDestX+" / "+this.zoomButtonDestY);											
				                 this.parent.childObjects[i2].objectX = this.destinationX + this.zoomButtonDestX;
				                 this.parent.childObjects[i2].objectY = this.destinationY + this.zoomButtonDestY;
//trace("4424--"+this.parent.childObjects[i2].objectY );
                                 //this.parent.childObjects[i2].updatePosition();
								 this.parent.childObjects[i2].setPosition(this.destinationX + this.zoomButtonDestX, this.destinationY + this.zoomButtonDestY);
			                }
		                 }  ///f>
						
						break;
					} 
				}
				
			//PG:	не попали ни в одну цель или цель была "занята" объектом,
			//  который нельзя вытеснить.
				if (this.startPlace >= 0)
					this.usePreDefinedBehaviour(this.noTargetsMatchedBehaviour);
			} else {
			//	если не попали ни в одну цель - проверим -
			//		может попали в какую то стартовую позицию
				var matchedStartPlace = parent.getMatchedStartPlaces(globCoord.x, globCoord.y);
				if(matchedStartPlace >= 0){
					if(this.objectState == DRAGOBJECT_STATE_PLACED){
						parent.removeObjectFromTarget(this.id, this.currentTarget);
					} 
					if(parent.isStartPlaceFree(matchedStartPlace)
						|| (matchedStartPlace == this.lastPositionStartPlace)){
						var startPlaceCoords = parent.getStartPlaceCoords(matchedStartPlace);
						this.destinationX = startPlaceCoords[0];
						this.destinationY = startPlaceCoords[1];
					//	устанавливаем параметры расположения
						this.currentTarget = null;
					//	сообщаем об освобождении того места которое занимали перед тасканием
						if(this.startPlace >= 0)
							parent.notifyStartPlaceFree(this.startPlace);
					//	устанавливаем текущее место
						this.objectState = DRAGOBJECT_STATE_ONSTART;
						this.startPlace = matchedStartPlace;
					//	сообщаем об занятии этого места
						this.moveTo(this.destinationX, this.destinationY);
					}
				} else {
				//	если пришли сюда - значит не попали не в одну цель и ни в одну
				//	свободную стартовую позицию - значит надо вернуть объект туда,
				//	где он стоял до таскания
					this.restoreLastState();
				}
			}
			//parent.printOccupiedStartPlaces();
//trace("3657--");
		}
	};
  // вспомогательная. служит для вызова прикрепленных событий на неправильную
  // установку объекта в цель. Вызывается (пока) только при настройке драгинга
  // как проверка по кнопке
  function placedWrongRight(){
trace("4478--"+this.id+this.placed);  
	if(this.placed==false){
	// PG: Вызов предоопределенного действия на неправильное размещение объета
	//	(убрать с экрана, переместить на стартовую позицию или переместить в "корзину").
		this.usePreDefinedBehaviour(this.wrongPlacedBehaviour);
        if(this.placedWrongActions){
            for(var i = 0; i < this.placedWrongActions.length; i++){
                 parent.dispatchAction(this.placedWrongActions[i]);
			}
        }
    } else {
	    if(this.placedRightActions && this.placedRight){
             for(var i = 0; i < this.placedRightActions.length; i++){
                 parent.dispatchAction(this.placedRightActions[i]);
            }
		}
	}
  
  // вспомогательная. служит для вызова прикрепленных событий на правильную
  // установку объекта в цель. Вызывается (пока) только при настройке драгинга
  // как проверка по кнопке
   }
  //function placedRight(){    
 
]]></script>

<sequencer name="updateSequencer" playing="false" loop="true">
	<script>
	// При таскании всплывающее меню убираем
		this.hideRollOverMenu(this);
		updateObject();
	</script>
</sequencer>
</composition>
</rmml>
