package org.noregret.log {
import flash.events.*;
import flash.display.*;
import flash.system.*;
import flash.text.*;
import org.noregret.utils.*;
import flash.utils.*;
import flash.external.*;
import flash.ui.*;
public class LogPanel extends Sprite {
public static const INSTANCE:LogPanel = new (LogPanel)();
;
public static const TYPE_ERROR:String = "errorMessage";
private static const DEFAULT_SHORTCUT:Array = [Keyboard.CONTROL, Keyboard.SHIFT, Keyboard.SPACE];
private static const COPY_EVENT:String = "copyToClipboard";
public static const TYPE_PLAIN:String = "plainMessage";
public static const TYPE_NOTIFY:String = "notifyMessage";
public static const TYPE_WARNING:String = "warningMessage";
public static var COLOR_WARNING:uint = 0x990099;
private static var line_count:uint;
public static var enableTraceInform:Boolean = false;
public static var enableTraceErrors:Boolean = false;
private static var charHash:Object = {};
private static var keyCodeHash:Object;
public static var COLOR_DEFAULT:uint = COLOR_PLAIN;
private static var currentKey:uint;
public static var COLOR_PLAIN:uint = 0x333333;
private static var openKey:uint;
public static var enableTraceAll:Boolean = false;
public static var enabled:Boolean = true;
public static var COLOR_NOTIFY:uint = 153;
private static var messageList:Array;
public static var FONT:String = "_typewriter";
public static var maxMessages:Number = 100;
public static var enableTraceNotify:Boolean = false;
public static var COLOR_ERROR:uint = 0xFF0000;
public static var shortcutString:String;
private static var ERROR_SINGLTONE:Number = 0;
public static var enableTraceWarnings:Boolean = false;
private static var KEY_COPY:Number = "c".charCodeAt(0);
private var logTextField:TextField;
public function LogPanel(){
super();
if (INSTANCE){
throw (new Error((getQualifiedClassName(this) + " is a Singletone!"), ERROR_SINGLTONE));
};
logTextField = makeTextField(500, 500);
logTextField.addEventListener(TextEvent.LINK, onLinkTrigger);
addChild(logTextField);
messageList = new Array();
addEventListener(Event.ADDED_TO_STAGE, onAddToStage);
visible = false;
setShortcut(DEFAULT_SHORTCUT);
}
public static function setShortcut(... _args):String{
var code:uint;
var keyCount:int;
var key:String;
var char:String;
var validateFlag:Boolean;
var keyNameList:Array;
var i:int;
keyCodeHash = {};
charHash = {};
if ((_args[0] is Array)){
var list:Array = _args[0];
};
keyCount = 0;
key = "";
char = "";
validateFlag = false;
keyNameList = [];
i = 0;
for (;(((i < _args.length)) && ((keyCount < 4)));i++) {
char = null;
if ((_args[i] is String)){
char = (_args[i] as String).toLowerCase().substr(0, 1);
if (!char.length){
continue;
};
code = char.charCodeAt(0);
} else {
code = uint(_args[i]);
};
validateFlag = (((((code > 32)) && ((code <= 160)))) || (KeyboardHelper.isSpecialKey(code)));
if (((((((isNaN(code)) || (!(validateFlag)))) || (!((keyCodeHash[code] == null))))) || (!((charHash[char] == null))))){
} else {
if (char){
charHash[code] = keyCount;
} else {
keyCodeHash[code] = keyCount;
};
keyNameList.push(KeyboardHelper.getKeyName(code));
keyCount++;
key = (key + "1");
};
};
if (keyCount){
openKey = parseInt(key, 2);
} else {
return (setShortcut(DEFAULT_SHORTCUT));
};
currentKey = 0;
shortcutString = keyNameList.join("+");
return (shortcutString);
}
public static function warn(message:Object, sender=null):void{
if (((enableTraceWarnings) || (enableTraceAll))){
trace((("*** LogPanel.warn(" + arguments) + ")"));
};
add(addSender(message, sender), LogPanel.TYPE_WARNING);
}
public static function show():void{
INSTANCE.visible = true;
INSTANCE.buildDebugPanel();
if (INSTANCE.stage){
INSTANCE.stage.addChild(INSTANCE);
};
}
public static function error(message:Object, sender=null):void{
if (((enableTraceErrors) || (enableTraceAll))){
trace((("*** LogPanel.error(" + arguments) + ")"));
};
add(addSender(message, sender), LogPanel.TYPE_ERROR);
}
private static function add(message:String, type:String):void{
var str:String;
if (!enabled){
return;
};
line_count++;
str = (("<span class='count'>" + StringUtils.trimAndFormat(line_count, 3, 0)) + "</span>: ");
str = (str + (((("<span class='" + type) + "'>") + message) + "</span>"));
str = (str + (("<span class='time'> (" + getTimer()) + " msec)</span>"));
messageList.push(str);
while (messageList.length > LogPanel.maxMessages) {
messageList.shift();
};
if (INSTANCE.visible){
INSTANCE.buildDebugPanel();
};
}
private static function addSender(message, sender=null):String{
var msg:String;
msg = String(message);
msg = msg.split(">").join(">");
msg = msg.split("<").join("<");
if (sender){
return ((((("<span class='sender'>" + getQualifiedClassName(sender)) + "</span>: <span class='item'>") + msg) + "</span>"));
};
return (msg);
}
public static function hide():void{
INSTANCE.visible = false;
}
public static function notify(message:Object, sender=null):void{
if (((enableTraceNotify) || (enableTraceAll))){
trace((("*** LogPanel.notify(" + arguments) + ")"));
};
add(addSender(message, sender), LogPanel.TYPE_NOTIFY);
}
public static function clear():void{
messageList = new Array();
line_count = 0;
INSTANCE.logTextField.htmlText = getHeaders();
}
private static function getHeaders():String{
var html:String;
html = "";
html = (html + "<p class='headers'>");
html = (html + (("<p class='shortcut'>shortcut = " + shortcutString) + "</p>"));
html = (html + (("<p class='copy'><a href='event:" + COPY_EVENT) + "'>copy to clipboard</a></p>"));
html = (html + "<p class='break'></p>");
html = (html + (((("<p class='player'>Player: <b>" + Capabilities.version) + "</b> ") + Capabilities.playerType) + "</p>"));
html = (html + (("<p class='os'>OS: <b>" + Capabilities.os) + "</b>, "));
html = (html + (((("resolution: <b>" + Capabilities.screenResolutionX) + "×") + Capabilities.screenResolutionY) + "</b></p>"));
html = (html + (("<p class='externalinterface'>ExternalInterface: <b>" + ((ExternalInterface.available) ? "IS" : "IS NOT")) + "</b> available</p>"));
html = (html + "<p class='break'></p>");
html = (html + "</p>");
return (html);
}
public static function notifyIncomingParameters():void{
var message:String;
var params:Object;
var name:String;
message = "Incoming parameters: [";
if (INSTANCE.stage){
params = INSTANCE.root.loaderInfo.parameters;
for (name in params) {
message = (message + ((("\n " + name) + "=") + params[name]));
};
message = (message + "\n]");
} else {
message = (message + "not accessible]");
};
notify(message);
}
public static function inform(message, sender=null):void{
if (((enableTraceInform) || (enableTraceAll))){
trace((("LogPanel.inform(" + arguments) + ")"));
};
add(addSender(message, sender), LogPanel.TYPE_PLAIN);
}
private function onKeyUpHandler(event:KeyboardEvent):void{
var position:Number;
if (!enabled){
return;
};
position = getKeyPosition(event);
if (isNaN(position)){
return;
};
currentKey = (currentKey & (0xFFFFFFFF ^ (1 << position)));
}
private function onKeyDownHandler(event:KeyboardEvent):void{
var position:Number;
if (!enabled){
return;
};
position = getKeyPosition(event);
if (isNaN(position)){
return;
};
currentKey = (currentKey | (1 << position));
if (currentKey == openKey){
if (visible){
hide();
} else {
show();
};
};
}
private function makeTextField(w:uint, h:uint):TextField{
var TF:TextField;
TF = new TextField();
TF.border = true;
TF.width = w;
TF.height = h;
TF.background = true;
TF.multiline = true;
TF.wordWrap = true;
TF.backgroundColor = 0xFFFFFF;
TF.styleSheet = new StyleSheet();
TF.styleSheet.setStyle("p", {
fontFamily:FONT,
letterSpacing:0,
marginLeft:5
});
TF.styleSheet.setStyle("a", {textDecoration:"underline"});
TF.styleSheet.setStyle("a:hover", {
textDecoration:"underline",
color:"#CC0000"
});
TF.styleSheet.setStyle(".count", {
color:"#999999",
fontSize:10
});
TF.styleSheet.setStyle(".time", {
color:"#559955",
fontSize:10
});
TF.styleSheet.setStyle(".copy", {
color:"#000066",
fontSize:11,
fontWeight:"bold"
});
TF.styleSheet.setStyle(".shortcut", {color:"#000000"});
TF.styleSheet.setStyle(".headers", {
color:"#666600",
fontSize:11
});
TF.styleSheet.setStyle(".messages", {
color:("#" + StringUtils.addLeadingZeros(COLOR_DEFAULT.toString(16), 6)),
fontSize:12
});
TF.styleSheet.setStyle(".break", {fontSize:8});
TF.styleSheet.setStyle(("." + TYPE_PLAIN), {color:("#" + StringUtils.addLeadingZeros(COLOR_PLAIN.toString(16), 6))});
TF.styleSheet.setStyle(("." + TYPE_ERROR), {
color:("#" + StringUtils.addLeadingZeros(COLOR_ERROR.toString(16), 6)),
fontWeight:"bold"
});
TF.styleSheet.setStyle(("." + TYPE_WARNING), {
color:("#" + StringUtils.addLeadingZeros(COLOR_WARNING.toString(16), 6)),
fontStyle:"italic"
});
TF.styleSheet.setStyle(("." + TYPE_NOTIFY), {color:("#" + StringUtils.addLeadingZeros(COLOR_NOTIFY.toString(16), 6))});
return (TF);
}
private function onResize(event:Event=null):void{
if (((INSTANCE.stage) && (INSTANCE.visible))){
logTextField.height = (INSTANCE.stage.stageHeight - 1);
logTextField.width = (INSTANCE.stage.stageWidth / 2);
};
}
private function getKeyPosition(event:KeyboardEvent):Number{
if (isNaN(charHash[event.charCode])){
return (keyCodeHash[event.keyCode]);
};
return (charHash[event.charCode]);
}
private function buildDebugPanel():void{
var html:String;
if (INSTANCE.stage == null){
return;
};
html = getHeaders();
html = (html + (("<p class=\"messages\">" + messageList.join("<br/>")) + "</p>"));
logTextField.htmlText = html;
logTextField.scrollV = logTextField.maxScrollV;
onResize();
}
private function onAddToStage(event:Event):void{
INSTANCE.stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDownHandler);
INSTANCE.stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUpHandler);
INSTANCE.stage.addEventListener(KeyboardEvent.KEY_DOWN, onCopyKey);
INSTANCE.stage.addEventListener(Event.RESIZE, onResize);
logTextField.height = INSTANCE.stage.stageHeight;
onResize();
}
private function copyToClipboard():void{
buildDebugPanel();
System.setClipboard(logTextField.text);
}
private function onCopyKey(event:KeyboardEvent):void{
if (!enabled){
return;
};
if (((event.ctrlKey) && ((event.charCode == KEY_COPY)))){
copyToClipboard();
};
}
private function onLinkTrigger(event:TextEvent):void{
switch (event.text){
case COPY_EVENT:
copyToClipboard();
break;
};
copyToClipboard();
}
}
}//package org.noregret.log
package org.noregret.utils {
public final class StringUtils {
private static var CACHE_ZEROS:String = "0000000000000000000000000000000";
public function StringUtils(){
super();
}
public static function roundAndFormat(value:Number, intLength:Number, floatLength:Number, fractionDelimiter:String="."):String{
var decimalRange:Number;
if (((!(isNaN(floatLength))) && ((floatLength > 0)))){
decimalRange = Math.pow(10, floatLength);
value = (Math.round((value * decimalRange)) / decimalRange);
};
return (trimAndFormat(value, intLength, floatLength, fractionDelimiter));
}
public static function floorAndFormat(value:Number, intLength:Number, floatLength:Number, fractionDelimiter:String="."):String{
return (trimAndFormat(value, intLength, floatLength, fractionDelimiter));
}
public static function trimAndFormat(value:Number, intLength:Number, floatLength:Number, fractionDelimiter:String="."):String{
var decimalRange:Number;
var result:String;
var heap:Array;
var str:String;
if (((isNaN(intLength)) || ((intLength < 0)))){
str = String(int(value));
intLength = str.length;
if (str.charAt(0) == "-"){
intLength--;
};
};
if (((isNaN(floatLength)) || ((floatLength < 0)))){
floatLength = 0;
};
decimalRange = Math.pow(10, floatLength);
result = String((Math.floor((value * decimalRange)) / decimalRange));
heap = result.split(".");
if ((((heap.length < 2)) && ((floatLength > 0)))){
heap.push("");
};
heap[0] = StringUtils.addLeadingZeros(heap[0], intLength);
if (heap.length > 1){
heap[1] = StringUtils.addTrailingZeros(heap[1], floatLength);
};
return (heap.join(fractionDelimiter));
}
private static function getZeros(len:Number):String{
var count:Number;
var i:Number;
if (CACHE_ZEROS.length >= len){
return (CACHE_ZEROS);
};
count = CACHE_ZEROS.length;
i = 0;
while (i < (len - count)) {
CACHE_ZEROS = (CACHE_ZEROS + "0");
i++;
};
return (CACHE_ZEROS);
}
public static function addLeadingZeros(value:Object, len:Number):String{
var str:String;
var isNegative:Boolean;
var strLength:Number;
var lead:String;
var result:String;
str = String(value);
isNegative = (str.charAt(0) == "-");
strLength = (str.length - ((isNegative) ? 1 : 0));
if (((isNaN(len)) || ((strLength >= len)))){
return (str);
};
lead = getZeros(len);
result = lead.substr(0, (len - strLength));
if (isNegative){
return ((("-" + result) + str.substr(1)));
};
return ((result + str));
}
public static function ceilAndFormat(value:Number, intLength:Number, floatLength:Number, fractionDelimiter:String="."):String{
var decimalRange:Number;
if (((!(isNaN(floatLength))) && ((floatLength > 0)))){
decimalRange = Math.pow(10, floatLength);
value = (Math.ceil((value * decimalRange)) / decimalRange);
};
return (trimAndFormat(value, intLength, floatLength, fractionDelimiter));
}
public static function addTrailingZeros(value:String, len:Number):String{
var trail:String;
if (((isNaN(len)) || ((value.length >= len)))){
return (value);
};
trail = getZeros(len);
return ((value + trail.substr(0, (len - value.length))));
}
}
}//package org.noregret.utils
package org.noregret.utils {
import flash.ui.*;
public class KeyboardHelper {
private static const ARROW_HASH:Object = {};
private static const F_HASH:Object = {};
private static const NUMPAD_HASH:Object = {};
private static const CONTROL_HASH:Object = {};
private static const NAVIGATION_HASH:Object = {};
private static const KNOWN_LIST:Array = [ARROW_HASH, NUMPAD_HASH, F_HASH, NAVIGATION_HASH, CONTROL_HASH];
private static const KNOWN_KEYS_HASH:Object = {};
private static var i:int = 0;
private static var j:String;
public function KeyboardHelper(){
super();
trace("KeyboardHelper.KeyboardHelper(): Class is static! You don't need any instances.");
}
public static function getKeyName(keyCode:uint, charCode:uint=0):String{
if (KNOWN_KEYS_HASH[keyCode]){
return (KNOWN_KEYS_HASH[keyCode]);
};
if (keyCode < 32){
return ((((("key " + keyCode) + "(0x") + StringUtils.addLeadingZeros(keyCode.toString(16).toUpperCase(), 2)) + ")"));
};
if (keyCode > 160){
return (String.fromCharCode(((charCode) || (keyCode))));
};
return (String.fromCharCode(keyCode));
}
public static function isSpecialKey(keyCode:uint):Boolean{
return (Boolean(KNOWN_KEYS_HASH[keyCode]));
}
public static function isNumpad(keyCode:uint):Boolean{
return (Boolean(NUMPAD_HASH[keyCode]));
}
public static function isF(keyCode:uint):Boolean{
return (Boolean(F_HASH[keyCode]));
}
public static function isNavigation(keyCode:uint):Boolean{
return (Boolean(NAVIGATION_HASH[keyCode]));
}
public static function isArrow(keyCode:uint):Boolean{
return (Boolean(ARROW_HASH[keyCode]));
}
ARROW_HASH[Keyboard.UP] = "arrow up";
ARROW_HASH[Keyboard.DOWN] = "arrow down";
ARROW_HASH[Keyboard.LEFT] = "arrow left";
ARROW_HASH[Keyboard.RIGHT] = "arrow right";
NUMPAD_HASH[Keyboard.NUMPAD_0] = "numpad 0";
NUMPAD_HASH[Keyboard.NUMPAD_1] = "numpad 1";
NUMPAD_HASH[Keyboard.NUMPAD_2] = "numpad 2";
NUMPAD_HASH[Keyboard.NUMPAD_3] = "numpad 3";
NUMPAD_HASH[Keyboard.NUMPAD_4] = "numpad 4";
NUMPAD_HASH[Keyboard.NUMPAD_5] = "numpad 5";
NUMPAD_HASH[Keyboard.NUMPAD_6] = "numpad 6";
NUMPAD_HASH[Keyboard.NUMPAD_7] = "numpad 7";
NUMPAD_HASH[Keyboard.NUMPAD_8] = "numpad 8";
NUMPAD_HASH[Keyboard.NUMPAD_9] = "numpad 9";
NUMPAD_HASH[Keyboard.NUMPAD_ADD] = "numpad add";
NUMPAD_HASH[Keyboard.NUMPAD_MULTIPLY] = "numpad multiply";
NUMPAD_HASH[Keyboard.NUMPAD_DIVIDE] = "numpad divide";
NUMPAD_HASH[Keyboard.NUMPAD_SUBTRACT] = "numpad subtract";
NUMPAD_HASH[Keyboard.NUMPAD_ENTER] = "numpad enter";
NUMPAD_HASH[Keyboard.NUMPAD_DECIMAL] = "numpad decimal";
F_HASH[Keyboard.F1] = "f1";
F_HASH[Keyboard.F2] = "f2";
F_HASH[Keyboard.F3] = "f3";
F_HASH[Keyboard.F4] = "f4";
F_HASH[Keyboard.F5] = "f5";
F_HASH[Keyboard.F6] = "f6";
F_HASH[Keyboard.F7] = "f7";
F_HASH[Keyboard.F8] = "f8";
F_HASH[Keyboard.F9] = "f9";
F_HASH[Keyboard.F10] = "f10";
F_HASH[Keyboard.F11] = "f11";
F_HASH[Keyboard.F12] = "f12";
F_HASH[Keyboard.F13] = "f13";
F_HASH[Keyboard.F14] = "f14";
F_HASH[Keyboard.F15] = "f15";
NAVIGATION_HASH[Keyboard.PAGE_DOWN] = "page down";
NAVIGATION_HASH[Keyboard.PAGE_UP] = "page up";
NAVIGATION_HASH[Keyboard.HOME] = "home";
NAVIGATION_HASH[Keyboard.END] = "end";
NAVIGATION_HASH[Keyboard.INSERT] = "insert";
NAVIGATION_HASH[Keyboard.DELETE] = "delete";
CONTROL_HASH[Keyboard.CONTROL] = "control";
CONTROL_HASH[Keyboard.SHIFT] = "shift";
CONTROL_HASH[Keyboard.CAPS_LOCK] = "caps lock";
CONTROL_HASH[144] = "num lock";
while (i < KNOWN_LIST.length) {
for (j in KNOWN_LIST[i]) {
KNOWN_KEYS_HASH[j] = KNOWN_LIST[i][j];
};
i++;
};
KNOWN_KEYS_HASH[Keyboard.SPACE] = "space";
KNOWN_KEYS_HASH[160] = "non-breaking space";
KNOWN_KEYS_HASH[Keyboard.ENTER] = "enter";
KNOWN_KEYS_HASH[Keyboard.BACKSPACE] = "backspace";
}
}//package org.noregret.utils
package ru.isky.external {
import flash.events.*;
import flash.net.*;
public class ExternalConnector extends EventDispatcher {
private var connectionClient:Object;
private var connector:LocalConnection;
public function ExternalConnector(){
super();
}
private function onMessageRecieve(message:Array):void{
var methodName:String;
var parameters:Array;
methodName = message[0];
parameters = message[1];
dispatchEvent(new ExternalConnectorEvent(ExternalConnectorEvent.ON_MESSAGE, methodName, parameters));
}
public function connect(connectionID:String):void{
var connectionID:* = connectionID;
connectionClient = new Object();
connectionClient[SWFConnector.METHOD_NAME] = onMessageRecieve;
connector = new LocalConnection();
connector.client = connectionClient;
try {
connector.connect(connectionID);
} catch(error:ArgumentError) {
throw (new Error("Данное соединение занято"));
};
}
}
}//package ru.isky.external
package ru.isky.external {
import flash.display.*;
import flash.net.*;
public class SWFConnector extends Sprite {
public static const METHOD_NAME:String = "onCallbackHandler";
public function SWFConnector(){
var commands:* = null;
var commandList:* = null;
var commandXML:* = null;
var paramslist:* = null;
var parameters:* = null;
var i:* = NaN;
var k:* = NaN;
super();
commands = root.loaderInfo.parameters["xml_commands"];
if ((((commands == null)) || ((commands.length == 0)))){
throw (new Error("Variable xml_commands must contain commands"));
};
try {
commandList = new XMLList(commands);
} catch(error:Error) {
throw (new Error(("Content in xml_commands variable is not valid XML:" + commands)));
};
i = 0;
while (i < commandList.length()) {
commandXML = commandList[i];
parameters = [];
paramslist = commandXML..param;
k = 0;
while (k < paramslist.length()) {
parameters[k] = paramslist[k];
k = (k + 1);
};
executeCommand(commandXML, parameters);
i = (i + 1);
};
}
private function executeCommand(commandXML:XML, parameters:Array):void{
var connector:LocalConnection;
var connection_id:String;
var method_name:String;
connector = new LocalConnection();
connection_id = commandXML.attribute("targetConnectionID");
method_name = commandXML.attribute("methodName");
connector.send(connection_id, METHOD_NAME, [method_name, parameters]);
}
}
}//package ru.isky.external
package ru.isky.external {
import flash.events.*;
public class ExternalConnectorEvent extends Event {
public static const ON_CONNECTION_BUSY:String = "onConnectionBusy";
public static const ON_MESSAGE:String = "onMessageRecieved";
public var parameters:Array;
public var methodName:String;
public function ExternalConnectorEvent(type:String, _methodName:String=null, _parameters:Array=null, bubbles:Boolean=false, cancelable:Boolean=false){
super(type, bubbles, cancelable);
methodName = _methodName;
parameters = _parameters;
}
}
}//package ru.isky.external
package ru.isky.multiloader {
import flash.events.*;
public class DataLoaderEvent extends Event {
public static const ON_ERROR:String = "onError";
public static const ON_COMPLETE:String = "onComplete";
public static const ON_PROGRESS:String = "onProgress";
public var error:String;
public var id:uint;
public function DataLoaderEvent(type:String, _id:uint, _error:String=null, bubbles:Boolean=false, cancelable:Boolean=false){
super(type, bubbles, cancelable);
id = _id;
error = _error;
}
override public function toString():String{
return (((((("id:" + id) + ", error:") + error) + " ") + super.toString()));
}
}
}//package ru.isky.multiloader
package ru.isky.multiloader {
import flash.events.*;
public class MultiloaderEvent extends Event {
public static const ON_ITEM_LOADED:String = "onItemLoaded";
public static const ON_ERROR:String = "onError";
public static const ON_COMPLETE:String = "onComplete";
public static const ON_PROGRESS:String = "onProgress";
public static const ON_START:String = "onStart";
public var progress:Number;
public var itemID:Number;
public var error:String;
public function MultiloaderEvent(type:String, _itemID:Number=NaN, _error:String=null, _progress:Number=NaN, bubbles:Boolean=false, cancelable:Boolean=false){
super(type, bubbles, cancelable);
itemID = _itemID;
error = _error;
progress = _progress;
}
}
}//package ru.isky.multiloader
package ru.isky.multiloader {
import flash.events.*;
public class CustomLoader extends EventDispatcher {
private var started:Boolean;
protected var loader:Multiloader;
public function CustomLoader(){
super();
}
protected function onMyItemLoaded(item:Object, parameters:Array=null):void{
}
protected function refreshLoader():void{
removeLoader();
createLoader();
}
protected function onItemLoadError(event:MultiloaderEvent):void{
throw (new Error(event.error));
}
protected function onItemLoaded(event:MultiloaderEvent):void{
onMyItemLoaded(loader.getContentById(event.itemID), loader.getParametersById(event.itemID));
}
protected function createLoader():void{
loader = new Multiloader();
loader.addEventListener(MultiloaderEvent.ON_ITEM_LOADED, onItemLoaded);
loader.addEventListener(MultiloaderEvent.ON_START, onStartLoading);
loader.addEventListener(MultiloaderEvent.ON_PROGRESS, onLoadProgress);
loader.addEventListener(MultiloaderEvent.ON_COMPLETE, onLoadComplete);
loader.addEventListener(MultiloaderEvent.ON_ERROR, onItemLoadError);
}
protected function onLoadProgress(event:MultiloaderEvent):void{
}
protected function removeLoader():void{
if (loader){
loader.removeEventListener(MultiloaderEvent.ON_ITEM_LOADED, onItemLoaded);
loader.removeEventListener(MultiloaderEvent.ON_PROGRESS, onLoadProgress);
loader.removeEventListener(MultiloaderEvent.ON_COMPLETE, onLoadComplete);
loader.removeEventListener(MultiloaderEvent.ON_ERROR, onItemLoadError);
loader.clear();
loader = null;
started = false;
};
}
private function onStartLoading(event:MultiloaderEvent):void{
if (started){
throw (new Error("After second loading use CustomLoader.refreshLoader()"));
};
started = true;
}
public function destroy():void{
removeLoader();
}
protected function onLoadComplete(event:MultiloaderEvent):void{
}
}
}//package ru.isky.multiloader
package ru.isky.multiloader {
import flash.events.*;
import flash.system.*;
import flash.net.*;
import ru.isky.utils.*;
import flash.utils.*;
public class Multiloader extends EventDispatcher {
private static const STATUS_IDLE:String = "idle";
public static const DATA_TEXT:String = "TEXT";
public static const DATA_BITMAP:String = "BITMAP";
private static const STATUS_BUSY:String = "busy";
private static const DATA_TYPES:Object = {};
public static const DATA_SOUND:String = "SOUND";
public static const DATA_FLASH:String = "FLASH";
public static const DATA_BINARY:String = "BINARY";
private var loaded:Number = 0;
private var _added:uint;
private var start_time:Number;
private var load_time:Number;
public var progress:Number = 0;
private var loaders:Array;
private var nextid:uint = 0;
public var dataList:Array;
private var defaultLoaderContext:LoaderContext;
private var waitFramesBetweenLoadings:Number = 0;
private var waitId:uint;
private var status:String;
public function Multiloader(loaderContext:LoaderContext=null){
nextid = 0;
loaded = 0;
progress = 0;
waitFramesBetweenLoadings = 0;
super();
if (loaderContext == null){
defaultLoaderContext = new LoaderContext(false, ApplicationDomain.currentDomain);
} else {
defaultLoaderContext = loaderContext;
};
loaders = new Array();
dataList = new Array();
clear();
}
private function onItemError(event:DataLoaderEvent):void{
if (!hasEventListener(MultiloaderEvent.ON_ERROR)){
throw (new Error(event.error));
};
dispatchEvent(new MultiloaderEvent(MultiloaderEvent.ON_ERROR, event.id, event.error));
}
public function get added():Number{
return (_added);
}
public function add(dataType:String, url:String, parameters:Array=null):Number{
if (url == "null"){
throw (new Error("url is null"));
};
return (addItem(dataType, new URLRequest(url), parameters));
}
private function loadNextItem():void{
var dataLoader:DataLoader;
dataLoader = loaders[loaded];
trace("dataLoader", dataLoader);
dataLoader.addEventListener(DataLoaderEvent.ON_COMPLETE, onItemLoaded);
dataLoader.addEventListener(DataLoaderEvent.ON_ERROR, onItemError);
dataLoader.addEventListener(DataLoaderEvent.ON_PROGRESS, onItemProgress);
dataLoader.load();
}
public function getContentById(id:Number):Object{
return ((dataList[id] as DataHolder).content);
}
private function onItemLoaded(event:DataLoaderEvent):void{
loaded++;
dispatchEvent(new MultiloaderEvent(MultiloaderEvent.ON_ITEM_LOADED, event.id));
if ((((loaded == loaders.length)) && (!((loaded == 0))))){
load_time = (getTimer() - start_time);
dispatchEvent(new MultiloaderEvent(MultiloaderEvent.ON_COMPLETE));
} else {
if (status != STATUS_IDLE){
waitId = EnterFrameUtils.setTimeout(loadNextItem, waitFramesBetweenLoadings);
};
};
}
public function getParametersById(id:Number):Array{
return ((dataList[id] as DataHolder).parameters);
}
public function get loadTime():Number{
return (load_time);
}
private function addItem(dataType:String, request:URLRequest, parameters:Array=null):Number{
if (status != STATUS_IDLE){
throw (new Error("add() method must be called before start() method"));
};
if (!DATA_TYPES[dataType]){
throw (new Error(("unknown dataType:" + dataType)));
};
_added++;
loaders[nextid] = new DataLoader(nextid, dataType, request, parameters);
dataList[nextid] = (loaders[nextid] as DataLoader).dataholder;
nextid++;
return ((nextid - 1));
}
public function clear():void{
var dataLoader:DataLoader;
var i:Number;
EnterFrameUtils.clearTimeout(waitId);
waitFramesBetweenLoadings = 0;
i = 0;
while (i < loaders.length) {
dataLoader = loaders[i];
dataLoader.removeEventListener(DataLoaderEvent.ON_COMPLETE, onItemLoaded);
dataLoader.removeEventListener(DataLoaderEvent.ON_ERROR, onItemError);
dataLoader.removeEventListener(DataLoaderEvent.ON_PROGRESS, onItemProgress);
dataLoader.destroy();
dataLoader = null;
i++;
};
_added = 0;
progress = NaN;
start_time = 0;
load_time = 0;
loaded = 0;
loaders = [];
dataList = [];
nextid = 0;
status = STATUS_IDLE;
}
public function getDataHolderById(id:Number):DataHolder{
return (dataList[id]);
}
private function onItemProgress(event:DataLoaderEvent):void{
var newProgress:Number;
var dataloader:DataLoader;
var i:Number;
newProgress = 0;
i = 0;
while (i < loaders.length) {
dataloader = loaders[i];
if (dataloader.dataholder.bytesTotal > 0){
newProgress = (newProgress + (((1 / loaders.length) * (1 / dataloader.dataholder.bytesTotal)) * dataloader.dataholder.bytesLoaded));
};
i++;
};
if (newProgress >= 1){
newProgress = 1;
};
if (newProgress != progress){
progress = newProgress;
dispatchEvent(new MultiloaderEvent(MultiloaderEvent.ON_PROGRESS, NaN, null, progress));
};
}
public function start(framesTimeoutBetweenLoadings:Number=1):void{
trace("loader start");
waitFramesBetweenLoadings = framesTimeoutBetweenLoadings;
if (status == STATUS_IDLE){
if (loaders.length == 0){
throw (new Error("Use add() method before start()"));
};
loadNextItem();
status = STATUS_BUSY;
start_time = getTimer();
dispatchEvent(new MultiloaderEvent(MultiloaderEvent.ON_START));
} else {
throw (new Error("Multiloader уже был запущен"));
};
}
public function close():void{
var dataLoader:DataLoader;
var i:Number;
i = 0;
while (i < loaders.length) {
dataLoader = loaders[i];
dataLoader.close();
i++;
};
}
DATA_TYPES[DATA_TEXT] = true;
DATA_TYPES[DATA_BITMAP] = true;
DATA_TYPES[DATA_FLASH] = true;
DATA_TYPES[DATA_BINARY] = true;
DATA_TYPES[DATA_SOUND] = true;
}
}//package ru.isky.multiloader
package ru.isky.multiloader {
import flash.display.*;
import flash.net.*;
import flash.media.*;
public class DataHolder {
private var _loaderInfo:Object;
private var __datatype:String;
public var loader:Object;
private var __url:String;
public var loadTime:Number;
public var parameters:Array;
private var __id:Number;
public function DataHolder(_id:Number, _datatype:String, _url:String, _parameters:Array=null){
super();
__datatype = _datatype;
__url = _url;
__id = _id;
parameters = _parameters;
}
public function get dataType():String{
return (__datatype);
}
public function get bytesLoaded():Number{
return (loaderInfo["bytesLoaded"]);
}
public function get bytesTotal():Number{
return (loaderInfo["bytesTotal"]);
}
public function get id():Number{
return (__id);
}
private function get loaderInfo():Object{
if (_loaderInfo == null){
if ((((__datatype == Multiloader.DATA_FLASH)) || ((__datatype == Multiloader.DATA_BITMAP)))){
_loaderInfo = (loader as Loader).contentLoaderInfo;
};
if ((((__datatype == Multiloader.DATA_TEXT)) || ((__datatype == Multiloader.DATA_BINARY)))){
_loaderInfo = loader;
};
if (__datatype == Multiloader.DATA_SOUND){
_loaderInfo = loader;
};
};
return (_loaderInfo);
}
public function get url():String{
return (__url);
}
public function get content():Object{
var data:Object;
if ((((__datatype == Multiloader.DATA_BITMAP)) || ((__datatype == Multiloader.DATA_FLASH)))){
data = (loader as Loader).content;
};
if ((((__datatype == Multiloader.DATA_TEXT)) || ((__datatype == Multiloader.DATA_BINARY)))){
data = (loader as URLLoader).data;
};
if (__datatype == Multiloader.DATA_SOUND){
data = (loader as Sound);
};
return (data);
}
public function destroy():void{
_loaderInfo = null;
loader = null;
parameters = null;
}
}
}//package ru.isky.multiloader
package ru.isky.multiloader {
import flash.events.*;
import flash.display.*;
import flash.net.*;
import flash.utils.*;
import flash.media.*;
public class DataLoader extends EventDispatcher {
private var startTime:uint;
public var dataholder:DataHolder;
private var dispatcher:IEventDispatcher;
private var request:URLRequest;
public function DataLoader(_id:Number, _dataType:String, _request:URLRequest, _parameters:Array=null){
super();
dataholder = new DataHolder(_id, _dataType, _request.url, _parameters);
request = _request;
if ((((dataholder.dataType == Multiloader.DATA_FLASH)) || ((dataholder.dataType == Multiloader.DATA_BITMAP)))){
dataholder.loader = new Loader();
dispatcher = (dataholder.loader as Loader).contentLoaderInfo;
};
if ((((dataholder.dataType == Multiloader.DATA_TEXT)) || ((dataholder.dataType == Multiloader.DATA_BINARY)))){
dataholder.loader = new URLLoader();
if (dataholder.dataType == Multiloader.DATA_BINARY){
(dataholder.loader as URLLoader).dataFormat = URLLoaderDataFormat.BINARY;
};
dispatcher = (dataholder.loader as URLLoader);
};
if (dataholder.dataType == Multiloader.DATA_SOUND){
dataholder.loader = new Sound();
dispatcher = (dataholder.loader as Sound);
};
}
public function destroy():void{
close();
dataholder.destroy();
dataholder = null;
request = null;
}
private function onErrorHandler(event:IOErrorEvent):void{
dispatchEvent(new DataLoaderEvent(DataLoaderEvent.ON_ERROR, dataholder.id, event.toString()));
}
public function load():void{
startTime = getTimer();
dispatcher.addEventListener(Event.COMPLETE, onCompleteHandler);
dispatcher.addEventListener(IOErrorEvent.IO_ERROR, onErrorHandler);
dispatcher.addEventListener(ProgressEvent.PROGRESS, onProgressHandler);
try {
var _local2 = dataholder.loader;
_local2["load"](request);
} catch(loader_error:Error) {
onError(loader_error);
};
}
private function onError(error:Error):void{
dispatchEvent(new DataLoaderEvent(DataLoaderEvent.ON_ERROR, dataholder.id, error.toString()));
}
private function onCompleteHandler(event:Event):void{
dataholder.loadTime = (getTimer() - startTime);
dispatcher.removeEventListener(Event.COMPLETE, onCompleteHandler);
dispatcher.removeEventListener(IOErrorEvent.IO_ERROR, onErrorHandler);
dispatcher.removeEventListener(ProgressEvent.PROGRESS, onProgressHandler);
dispatchEvent(new DataLoaderEvent(DataLoaderEvent.ON_COMPLETE, dataholder.id));
}
public function close():void{
try {
var _local2 = dataholder.loader;
_local2["close"]();
} catch(error:Error) {
onError(error);
};
}
private function onProgressHandler(event:ProgressEvent):void{
dispatchEvent(new DataLoaderEvent(DataLoaderEvent.ON_PROGRESS, dataholder.id));
}
public function unload():void{
if ((((dataholder.dataType == Multiloader.DATA_BITMAP)) || ((dataholder.dataType == Multiloader.DATA_FLASH)))){
try {
(dataholder.loader as Loader).unload();
} catch(error:Error) {
onError(error);
};
};
dataholder.loader = null;
}
}
}//package ru.isky.multiloader
package ru.isky.geom.d2 {
import flash.geom.*;
public class Point2DTools {
public function Point2DTools(){
super();
}
public static function displace(src:Point, displaceX:Number=0, displaceY:Number=0):Point{
return (new Point((src.x + displaceX), (src.y + displaceY)));
}
public static function distance(_P1:Point, _P2:Point):Number{
var distance:Number;
var katetA:Number;
var katetB:Number;
katetA = Math.abs((_P1.x - _P2.x));
katetB = Math.abs((_P1.y - _P2.y));
if (katetA == 0){
distance = Math.abs((_P1.y - _P2.y));
} else {
if (katetB == 0){
distance = Math.abs((_P1.x - _P2.x));
} else {
distance = Math.sqrt(((katetA * katetA) + (katetB * katetB)));
};
};
return (distance);
}
public static function rotateAt(targetPoint:Point, centerPoint:Point, angle_rad:Number):Point{
var radius:Number;
var currentAngle:Number;
var newAngle:Number;
var endX:Number;
var endY:Number;
radius = distance(targetPoint, centerPoint);
currentAngle = (Math.atan2((targetPoint.x - centerPoint.x), (targetPoint.y - centerPoint.y)) * -1);
newAngle = (currentAngle + angle_rad);
endX = ((Math.cos(newAngle) * radius) + centerPoint.x);
endY = ((Math.sin(newAngle) * radius) + centerPoint.y);
return (new Point(endX, endY));
}
}
}//package ru.isky.geom.d2
package ru.isky.math {
import flash.geom.*;
public class RectangleUtils {
public static const SIT_TYPE_INSIDE:String = "inside";
public static const SIT_TYPE_OUTSIDE:String = "outside";
public function RectangleUtils(){
super();
}
public static function sitRectangle(rectangle0:Rectangle, rectangle1:Rectangle, type:String="inside"):Rectangle{
var w_prop:Number;
var h_prop:Number;
var prop0:Number;
rectangle0 = rectangle0.clone();
w_prop = (rectangle0.width / rectangle1.width);
h_prop = (rectangle1.height / rectangle1.height);
prop0 = (rectangle0.width / rectangle0.height);
if ((((w_prop > h_prop)) && ((type == SIT_TYPE_INSIDE)))){
rectangle0.width = rectangle1.width;
rectangle0.height = (rectangle0.width / prop0);
} else {
rectangle0.height = rectangle1.height;
rectangle0.width = (rectangle0.height * prop0);
};
return (rectangle0);
}
}
}//package ru.isky.math
package ru.isky.gazprom.gallery {
import flash.events.*;
import flash.display.*;
public class GalleryLoaderEvent extends Event {
public static const ON_COMPLETE:String = "ON_COMPLETE";
public static const ON_CONFIG_LOADED:String = "ON_CONFIG_LOADED";
public static const ON_DEFAULT_IMAGE_LOADED:String = "ON_DEFAULT_IMAGE_LOADED";
public static const ON_ALL_IMAGES_LOAD_PROGRESS:String = "ON_ALL_IMAGES_LOAD_PROGRESS";
public var allImagesProgress:Number;
public var defaultImage:Bitmap;
public function GalleryLoaderEvent(type:String, _defaultImage:Bitmap=null, _allImagesProgress:Number=0, bubbles:Boolean=false, cancelable:Boolean=false){
super(type, bubbles, cancelable);
defaultImage = _defaultImage;
allImagesProgress = _allImagesProgress;
}
}
}//package ru.isky.gazprom.gallery
package ru.isky.gazprom.gallery {
import flash.events.*;
import caurina.transitions.*;
import flash.geom.*;
import flash.display.*;
import flash.text.*;
import ru.isky.utils.*;
public class Preloader extends Sprite {
private var cellsAmount:Number;
private var image:Bitmap;
private var randomCells:Array;
private var lastVisibleAmount:Number = 0;
public var tf:TextField;
private var container:Sprite;
private var previousCell:Sprite;
public function Preloader(defaultImage:Bitmap){
lastVisibleAmount = 0;
randomCells = [];
super();
image = defaultImage;
container = new Sprite();
addChild(container);
tf = new TextField();
tf.autoSize = TextFieldAutoSize.LEFT;
}
public function updateProgress(value:Number):void{
var visibleAmount:Number;
tf.text = (Math.round((value * 100)) + "%");
visibleAmount = Math.round((value * cellsAmount));
if (lastVisibleAmount != visibleAmount){
lastVisibleAmount = visibleAmount;
trace(lastVisibleAmount);
showPartImage(lastVisibleAmount);
};
}
private function showPartImage(amount:Number):void{
var j:Number;
var i:Number;
var cell:Sprite;
j = 0;
while (j < amount) {
i = 0;
while (i < cellsAmount) {
cell = (container.getChildAt(i) as Sprite);
if (i == randomCells[j]){
if (cell.alpha != 1){
if (Tweener.isTweening(cell) != true){
Tweener.addTween(cell, {
alpha:1,
time:0.5
});
};
};
};
i++;
};
j++;
};
}
public function buildMatrix(amount:Number):void{
var arr:Array;
var w_images:Number;
var h_images:Number;
var matrixItemWidth:int;
var matrixItemHeight:int;
var i:Number;
var k:Number;
var j:Number;
var bitmapData:BitmapData;
var bmp:Bitmap;
var spr:Sprite;
arr = ImagesRectangle.getRectangleSidesQuantity(amount);
w_images = arr[0];
trace(w_images);
h_images = arr[1];
trace(h_images);
cellsAmount = (w_images * h_images);
matrixItemWidth = (image.width / w_images);
matrixItemHeight = (image.height / h_images);
i = 0;
while (i < h_images) {
j = 0;
while (j < w_images) {
bitmapData = new BitmapData(matrixItemWidth, matrixItemHeight, false);
bitmapData.copyPixels(image.bitmapData, new Rectangle((j * matrixItemWidth), (i * matrixItemHeight), matrixItemWidth, matrixItemHeight), new Point());
bmp = new Bitmap(bitmapData);
bmp.x = (j * matrixItemWidth);
bmp.y = (i * matrixItemHeight);
spr = new Sprite();
spr.addChild(bmp);
spr.alpha = 0;
spr.addEventListener(MouseEvent.MOUSE_OVER, onMouseOverHandler);
container.addChild(spr);
j++;
};
i++;
};
k = 0;
while (k < cellsAmount) {
randomCells.push(k);
k++;
};
ArrayUtils.shuffle(randomCells);
trace(randomCells);
}
private function onMouseOverHandler(event:MouseEvent):void{
var cell:Sprite;
trace("mouseOver");
cell = (event.target as Sprite);
if (cell.alpha <= 0.5){
Tweener.addTween(cell, {
alpha:0.6,
time:2
});
} else {
if (cell.alpha != 1){
Tweener.addTween(cell, {
alpha:0,
time:2
});
};
};
previousCell = cell;
}
}
}//package ru.isky.gazprom.gallery
package ru.isky.gazprom.gallery {
public class ImagesStorage extends DataStorage {
public var data:Array;
public function ImagesStorage(){
super();
data = [];
}
override public function addData(_data:Object, href:String):void{
super.addData(_data, href);
data.push(_data);
}
}
}//package ru.isky.gazprom.gallery
package ru.isky.gazprom.gallery {
public interface IClonableDisplayObject {
function set x(_arg1:Number):void;
function set y(_arg1:Number):void;
function get width():Number;
function get height():Number;
function get x():Number;
function get y():Number;
function clone():IClonableDisplayObject;
}
}//package ru.isky.gazprom.gallery
package ru.isky.gazprom.gallery {
import flash.display.*;
public class CloneGrid extends Sprite {
private var item:IClonableDisplayObject;
private var item_width:Number;
private var item_height:Number;
public var rows:Array;
public function CloneGrid(item:IClonableDisplayObject, item_width:Number=NaN, item_height:Number=NaN){
super();
rows = [];
this.item_width = ((item_width) || (item.width));
this.item_height = ((item_height) || (item.height));
this.item = item;
}
public function addBottomRow():void{
addRow();
}
public function addRightColumn():void{
addColumn();
}
private function removeArray(objects:Array=null):void{
var target:IClonableDisplayObject;
var i:Number;
if (!objects){
return;
};
i = 0;
while (i < objects.length) {
target = objects[i];
removeChild((target as DisplayObject));
target = null;
i++;
};
objects = null;
}
private function addColumn(left:Boolean=false):void{
var newItem:IClonableDisplayObject;
var row:Array;
var i:Number;
if (rows.length == 0){
rows.push([getItemCopy()]);
return;
};
i = 0;
while (i < rows.length) {
row = rows[i];
newItem = getItemCopy();
if (left){
newItem.x = (row[0].x - item_width);
newItem.y = row[0].y;
row.unshift(newItem);
} else {
newItem.x = (row[(row.length - 1)].x + item_width);
newItem.y = row[0].y;
row.push(newItem);
};
i++;
};
}
public function removeRightColumn():void{
removeColumn();
}
public function addTopRow():void{
addRow(true);
}
private function addRow(top:Boolean=false):void{
var row:Array;
var newRow:Array;
var newItem:IClonableDisplayObject;
var i:Number;
if (rows.length == 0){
rows.push([getItemCopy()]);
return;
};
row = rows[0];
newRow = [];
i = 0;
while (i < row.length) {
newItem = getItemCopy();
if (top){
row = rows[0];
newItem.x = row[i].x;
newItem.y = (row[0].y - item_height);
} else {
row = rows[(rows.length - 1)];
newItem.x = row[i].x;
newItem.y = (row[(row.length - 1)].y + item_height);
};
newRow.push(newItem);
i++;
};
if (top){
rows.unshift(newRow);
} else {
rows.push(newRow);
};
}
public function removeBottomRow():void{
removeRow();
}
private function removeRow(top:Boolean=false):void{
if (!rows.length){
return;
};
if (top){
removeArray(rows.shift());
} else {
removeArray(rows.pop());
};
}
public function addLeftColumn():void{
addColumn(true);
}
private function getItemCopy():IClonableDisplayObject{
return ((addChild((item.clone() as DisplayObject)) as IClonableDisplayObject));
}
public function removeLeftColumn():void{
removeColumn(true);
}
public function removeTopRow():void{
removeRow(true);
}
private function removeColumn(left:Boolean=false):void{
var itemIndex:int;
var row:Array;
var i:Number;
if (!rows.length){
return;
};
itemIndex = (rows[0].length - 1);
if (left){
itemIndex = 0;
};
i = 0;
while (i < rows.length) {
row = rows[i];
if (left){
removeChild(row.shift());
} else {
removeChild(row.pop());
};
i++;
};
if (row.length == 0){
rows = [];
};
}
}
}//package ru.isky.gazprom.gallery
package ru.isky.gazprom.gallery {
public class DataStorage {
private var _length:int = 0;
protected var storage:Object;
public function DataStorage(){
_length = 0;
super();
storage = new Object();
}
public function getDataByHref(href:String):Object{
return (storage[href]);
}
public function addData(data:Object, href:String):void{
if (storage[href] == null){
_length++;
};
storage[href] = data;
}
public function get length():int{
return (_length);
}
}
}//package ru.isky.gazprom.gallery
package ru.isky.gazprom.gallery {
import flash.events.*;
public class ImagesLoaderEvent extends Event {
public static const ON_COMPLETE:String = "onComplete";
public static const ON_PROGRESS:String = "onProgress";
public var progress:Number;
public function ImagesLoaderEvent(type:String, _progress:Number, bubbles:Boolean=false, cancelable:Boolean=false){
super(type, bubbles, cancelable);
progress = _progress;
}
}
}//package ru.isky.gazprom.gallery
package ru.isky.gazprom.gallery {
import flash.geom.*;
import flash.display.*;
import ru.isky.utils.*;
public class Gallery extends WEBDocument {
private var galleryLoader:GalleryLoader;
private var map:Map;
public var preloader:Preloader;
private var defaultImage:Bitmap;
public function Gallery(){
var configHref:String;
super();
galleryLoader = new GalleryLoader();
galleryLoader.addEventListener(GalleryLoaderEvent.ON_DEFAULT_IMAGE_LOADED, onDefaultImageLoaded);
galleryLoader.addEventListener(GalleryLoaderEvent.ON_ALL_IMAGES_LOAD_PROGRESS, onImagesLoadProgress);
galleryLoader.addEventListener(GalleryLoaderEvent.ON_COMPLETE, onImagesLoaded);
configHref = ((root.loaderInfo.parameters["config_href"]) || ("config.xml"));
galleryLoader.loadConfig(configHref);
}
private function onImagesLoaded(event:GalleryLoaderEvent):void{
removeChild(preloader);
defaultImage.visible = false;
map = new Map(new ImagesRectangle(galleryLoader.storage), new Rectangle(0, 0, 710, 350));
addChild(map);
map.initExternal();
map.addCallBacks();
map.showAll();
}
private function onImagesLoadProgress(event:GalleryLoaderEvent):void{
preloader.updateProgress(event.allImagesProgress);
}
private function onDefaultImageLoaded(event:GalleryLoaderEvent):void{
defaultImage = event.defaultImage;
preloader = new Preloader(defaultImage);
preloader.x = (preloader.y = 0);
addChild(preloader);
preloader.buildMatrix(galleryLoader.imagesAmount);
defaultImage.alpha = 0;
}
}
}//package ru.isky.gazprom.gallery
package ru.isky.gazprom.gallery {
import flash.events.*;
import caurina.transitions.*;
import flash.geom.*;
import ru.actionsmile.utils.*;
import flash.display.*;
import ru.isky.external.*;
import ru.isky.geom.d2.*;
import ru.isky.math.*;
import org.noregret.log.*;
import flash.utils.*;
Простой
