• Говорят, что в правильно поставленном вопросе уже есть половина ответа

    Spetros
    @Spetros
    IT-шник
    Например, HIMEM.SYS
    Ответ написан
    Комментировать
  • Двухсторонний шаблонизатор?

    k12th
    @k12th
    console.log(`You're pulling my leg, right?`);
    mustache имеет реализации на нескольких языках.
    Ответ написан
    Комментировать
  • Нужен слайдер, как у Газпрома?

    Shultc
    @Shultc
    RnD Developer
    Там не так уж много кода:
    Скрытый текст
    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.*;
    
    Ответ написан
    3 комментария
  • Хранение HDD

    Temikus
    @Temikus
    Я использую такие силиконовые шкурки для хранения дисков. Они замечательно складываются друг на друга и защищают от случайных ударов внутри ящиков. Посмотрите, может, вам тоже подойдет.
    Ответ написан
    Комментировать
  • Развод в скайпе

    Пол года назад получил такое же сообщение. Отправил какеру 100к с кодом. И ответ «Код отправил в смс на твой номер» ))
    Потом с ним часик проболтал… Хакер жаловался что студент и денег нет, вот и вынужден ломать акки. Пожалел, отправил еще 1к рублей уже без кода и прочитал лекцию как зарабатывать без кидалова.
    Перевод в 1к вернул и сказал что завязывает с такими делами.
    Ответ написан
    1 комментарий
  • Диагностика качества интернет соединения?

    opium
    @opium
    Просто люблю качественно работать
    Пусть приложение работает так как будто всегда плохое соединение.
    Ответ написан
    Комментировать
  • Как заблокировать клавиатуру PC оставив работающей мышь?

    creage
    @creage
    Оно? Интересно только, за чем вам это. Неужели от кота страхуетесь?)
    Ответ написан
    3 комментария
  • Как называется ступень между junior и senior?

    Sannis
    @Sannis
    Прилагательное пропускается? :)
    Ответ написан
    Комментировать
  • [solved] в новом TextMate (TM2) некоторые элементы интерфейса не отображаются?

    deus
    @deus Автор вопроса
    в файле ~/Library/Preferences/.GlobalPreferences.plist удалить property NSToolTipsFontSize
    Ответ написан
    Комментировать
  • Программа для сохранения аудио потока

    rasa
    @rasa
    Я использовал Total Recorder для таких же целей (чтобы записать звук из Принца Персии до появления первых геймэктракторов)
    Ответ написан
    2 комментария
  • Алгоритмы распознавания подписи?

    anmipo
    @anmipo
    Можно позаимствовать подход у распознавателей жестов (например, All-in-one Gestures).
    По мере рисования жеста (подписи), программа определяет направление движения мыши (стилуса), «округляя» его до одного из четырёх основных направлений: left, right, up, down. Повторение одного и того же направления игнорируется (то есть «LLLLL» считается одной «L») — это нивелирует разницу в масштабах жестов.

    В результате, даже такой сложный жест как подпись можно представить в виде сравнительно короткой последовательности а-ля ULDRUDRULDR (символ @ в моём исполнении), где каждый символ занимает всего два бита. Таким образом, десятка байт с лихвой хватит на хранение даже сложной подписи.

    Символ @ в направлениях

    Распознавание направления легко делается на лету: когда стилус сместился на N пикселей от начальной точки, сравниваем Δx c Δy, и их знаки; если полученное направление отличается от предыдущего — добавляем его в цепочку распознанных и goto 1. Мелкие дрожания руки можно отфильтровать, задав N > 1.

    Только прежде, чем реализовывать в железе, проверьте точность распознавания на компьютере, хоть в том же браузере. На всякий случай :)
    Ответ написан
    Комментировать
  • Чем сделать скриншоты большого разрешения?

    girichev
    @girichev
    Единственный выход сделать качественный снимок — нарисовать его самому, GUI в PSD полно сейчас.

    Вам для какой модели нужно?

    www.teehanlax.com/blog/ios-5-gui-psd-iphone-4s/
    Ответ написан
    1 комментарий
  • Что выбрать: ставить или не ставить слэш на конце URL?

    @IlVin
    В www.ietf.org/rfc/rfc1738.txt этот вопрос не регламентирован.

    ; HTTP
    httpurl = «http://» hostport [ "/" hpath [ "?" search ]]
    hpath = hsegment *[ "/" hsegment ]
    hsegment = *[ uchar | ";" | ":" | "@" | "&" | "=" ]
    search = *[ uchar | ";" | ":" | "@" | "&" | "=" ]

    Хотите ставьте '/' в конце, а хотите не ставьте — главное, чтобы ваш сервер этот URL понимал.

    Проблемы подстерегают с другой стороны — обычно браузер получает HTML документы, в которых могут быть картинки, с относительными URI, для которых браузер вычисляет абсолютный URL и получается веселуха: /path/to/page.html/image.gif и т.п.

    Так что совет — для папок в конце пишите '/', а для файлов не пишите. И тогда браузер правильно вычислит адреса для подключаемых ресурсов.
    Ответ написан
    1 комментарий