Created
May 22, 2014 09:39
-
-
Save ZoczuS/823db7a0db5bdd96a0d1 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
* Source code for kraski-universal-blogplayer.swf (C) Yandex | |
* | |
* Decompiled using flaczki - https://github.com/chung-leong/flaczki | |
* | |
*/ | |
package ru.yandex.kraski.universalpainter.preloader | |
{ | |
public class KraskiPreloader extends flash.display::Sprite implements {mx.preloaders}::IPreloaderDisplay | |
{ | |
//========================= Variables | |
private var preloaderImage : Loader; | |
public var preloaderSWF : String; | |
private var prevFrame : uint; | |
//========================= Methods | |
public static function KraskiPreloader() | |
{ | |
return; | |
} | |
public function KraskiPreloader() | |
{ | |
super(); | |
return; | |
} | |
private function handleComplete(arg0:flash.events::Event) | |
{ | |
return; | |
} | |
public Getter function stageHeight() : Number | |
{ | |
return 700; | |
} | |
public Getter function backgroundImage() : Object | |
{ | |
return null; | |
} | |
public Getter function backgroundSize() : String | |
{ | |
return null; | |
} | |
public Setter function stageHeight(arg0:Number) | |
{ | |
return; | |
} | |
public Getter function backgroundColor() : uint | |
{ | |
return 0; | |
} | |
public function initialize() | |
{ | |
var loc0:* = stage.loaderInfo.url; | |
var loc1:* = ""; | |
var loc2:* = loc0.indexOf("?"); | |
loc0 = loc0.substr(0, loc2); | |
loc2 = loc0.lastIndexOf("/"); | |
loc0 = loc0.substr(0, loc2); | |
loc1 = loc0 + "/" + this.preloaderSWF; | |
this.preloaderImage = new Loader(); | |
addEventListener(Event.COMPLETE, this.loader_completeHandler); | |
preloaderImage.load(new URLRequest(loc1)); | |
return; | |
} | |
public Setter function backgroundImage(arg0:Object) | |
{ | |
return; | |
} | |
public Setter function backgroundSize(arg0:String) | |
{ | |
return; | |
} | |
public Setter function backgroundAlpha(arg0:Number) | |
{ | |
return; | |
} | |
private function enterFrameHandler(arg0:flash.events::Event) | |
{ | |
if(this.prevFrame == MovieClip(this.preloaderImage.content).currentFrame) | |
{ | |
removeEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
dispatchEvent(new Event(Event.COMPLETE)); | |
} | |
this.prevFrame = MovieClip(this.preloaderImage.content).currentFrame; | |
return; | |
} | |
private function handleInitProgress(arg0:flash.events::Event) | |
{ | |
return; | |
} | |
public Getter function backgroundAlpha() : Number | |
{ | |
return 0; | |
} | |
public Getter function stageWidth() : Number | |
{ | |
return 1000; | |
} | |
private function handleInitComplete(arg0:flash.events::Event) | |
{ | |
this.startEnterFrame(); | |
return; | |
} | |
public Setter function stageWidth(arg0:Number) | |
{ | |
return; | |
} | |
private function handleProgress(arg0:flash.events::ProgressEvent) | |
{ | |
var loc0:* = 0; | |
if(this.preloaderImage.content) | |
{ | |
loc0 = Math.round(arg0.bytesLoaded / arg0.bytesTotal * 100); | |
gotoAndStop(loc0); | |
} | |
return; | |
} | |
private function startEnterFrame(arg0:flash.events::TimerEvent = null) | |
{ | |
var loc0:* = null; | |
if(this.preloaderImage && this.preloaderImage.content) | |
{ | |
this.prevFrame = MovieClip(this.preloaderImage.content).currentFrame; | |
play(); | |
addEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
} | |
else | |
{ | |
loc0 = new Timer(2000, 1); | |
loc0.addEventListener(TimerEvent.TIMER, this.startEnterFrame); | |
loc0.start(); | |
} | |
return; | |
} | |
public Setter function backgroundColor(arg0:uint) | |
{ | |
return; | |
} | |
public Setter function preloader(arg0:flash.display::Sprite) | |
{ | |
arg0.addEventListener(ProgressEvent.PROGRESS, this.handleProgress); | |
arg0.addEventListener(Event.COMPLETE, this.handleComplete); | |
arg0.addEventListener(FlexEvent.INIT_PROGRESS, this.handleInitProgress); | |
arg0.addEventListener(FlexEvent.INIT_COMPLETE, this.handleInitComplete); | |
return; | |
} | |
private function loader_completeHandler(arg0:flash.events::Event) | |
{ | |
addChild(this.preloaderImage); | |
stop(); | |
return; | |
} | |
} | |
public class BlogPlayerPreloader extends ru.yandex.kraski.universalpainter.preloader::KraskiPreloader | |
{ | |
//========================= Methods | |
public static function BlogPlayerPreloader() | |
{ | |
return; | |
} | |
public function BlogPlayerPreloader() | |
{ | |
super(); | |
this.preloaderSWF = "blogPlayerPreloader.swf"; | |
return; | |
} | |
public Getter function stageWidth() : Number | |
{ | |
return 500; | |
} | |
public Getter function stageHeight() : Number | |
{ | |
return 560; | |
} | |
} | |
} | |
package [Global] | |
{ | |
public dynamic class blogPlayAgainButton_skin extends mx.flash::UIMovieClip | |
{ | |
//========================= Methods | |
public static function blogPlayAgainButton_skin() | |
{ | |
return; | |
} | |
public function blogPlayAgainButton_skin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class blogDownloadButton_skin extends mx.flash::UIMovieClip | |
{ | |
//========================= Methods | |
public static function blogDownloadButton_skin() | |
{ | |
return; | |
} | |
public function blogDownloadButton_skin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class blogPaintYourselfButton_skin extends mx.flash::UIMovieClip | |
{ | |
//========================= Methods | |
public static function blogPaintYourselfButton_skin() | |
{ | |
return; | |
} | |
public function blogPaintYourselfButton_skin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class blogPlayerStartButton_skin extends mx.flash::UIMovieClip | |
{ | |
//========================= Methods | |
public static function blogPlayerStartButton_skin() | |
{ | |
return; | |
} | |
public function blogPlayerStartButton_skin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class blogGetCodeButton_skin extends mx.flash::UIMovieClip | |
{ | |
//========================= Methods | |
public static function blogGetCodeButton_skin() | |
{ | |
return; | |
} | |
public function blogGetCodeButton_skin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class BlogPlayer extends mx.core::Application implements {mx.binding}::IBindingClient | |
{ | |
//========================= Variables | |
private static var _watcherSetupUtil : IWatcherSetupUtil; | |
public static var _BlogPlayer_StylesInit_done : Boolean = False; | |
private var _1763239082paintCanvas : PaintCanvas; | |
private var _235964214traceTarget : TraceTarget; | |
private var _2056864585isDebug : Boolean = False; | |
private var card : Card; | |
private var _1354231074playAgainButton : HandCursorButton; | |
private var _1631133009preloaderAftertaste : BlogPlayerPreloaderAftertaste; | |
private var _model : Model; | |
private var _embed_css__2093910380 : Class; | |
private var _159077850downloadButton : HandCursorButton; | |
private var _1704619147getCodeButton : HandCursorButton; | |
private var currentVisualIndex : int; | |
public var _bindingsByDestination : Object; | |
private var _1435122461loggerWrapper : UIComponent; | |
private var _embed_css__2078891259 : Class; | |
private var _318184504preview : Canvas; | |
private var loadLibraryController : LoadLibraryController; | |
private var _416447130screenshot : Image; | |
private var _1613058925playerStartButton : HandCursorButton; | |
private var _1937158641paintYourselfButton : HandCursorButton; | |
private var customCursorManager : CustomCursorManager; | |
private var loadConfigController : LoadConfigController; | |
public var _BlogPlayer_HBox2 : HBox; | |
public var _watchers : Array; | |
private var _embed_css__1502235314 : Class; | |
private var _1554553085viewstack : ViewStack; | |
private var paintTypes : PaintType; | |
public var _bindingsBeginWithWord : Object; | |
private var _embed_css__162016752 : Class; | |
private var _embed_css__1017935931 : Class; | |
private var player : Player; | |
private var cardXML : XML; | |
public var _bindings : Array; | |
private var _documentDescriptor_ : UIComponentDescriptor; | |
//========================= Methods | |
public static function BlogPlayer() | |
{ | |
this._BlogPlayer_StylesInit_done = false; | |
return; | |
} | |
public function BlogPlayer() | |
{ | |
this._documentDescriptor_ = new UIComponentDescriptor({"type" : Application, "propertiesFactory" : function() | |
{ | |
return {"width" : 500, "height" : 560, "childDescriptors" : [new UIComponentDescriptor({"type" : VBox, "stylesFactory" : function() | |
{ | |
this.horizontalAlign = "center"; | |
this.verticalGap = 6; | |
this.paddingTop = 12; | |
return; | |
}, "propertiesFactory" : function() | |
{ | |
return {"width" : 500, "height" : 560, "styleName" : "PaintCanvasOuterContainerStyle", "childDescriptors" : [new UIComponentDescriptor({"type" : ViewStack, "id" : "viewstack", "propertiesFactory" : function() | |
{ | |
return {"width" : 475, "height" : 475, "creationPolicy" : "all", "styleName" : "PaintCanvasInnerContainerStyle", "childDescriptors" : [new UIComponentDescriptor({"type" : Canvas, "id" : "preview", "propertiesFactory" : function() | |
{ | |
return {"percentWidth" : 100, "percentHeight" : 100, "horizontalScrollPolicy" : "off", "verticalScrollPolicy" : "off", "childDescriptors" : [new UIComponentDescriptor({"type" : Image, "id" : "screenshot", "events" : {"complete" : "__screenshot_complete"}, "propertiesFactory" : function() | |
{ | |
return {"x" : 0, "y" : 0}; | |
}}), new UIComponentDescriptor({"type" : HandCursorButton, "id" : "playerStartButton", "events" : {"click" : "__playerStartButton_click"}, "stylesFactory" : function() | |
{ | |
this.horizontalCenter = "0"; | |
this.verticalCenter = "0"; | |
return; | |
}, "propertiesFactory" : function() | |
{ | |
return {"styleName" : "BlogPlayerStartButtonStyle", "visible" : false}; | |
}})]}; | |
}}), new UIComponentDescriptor({"type" : Canvas, "propertiesFactory" : function() | |
{ | |
return {"percentWidth" : 100, "percentHeight" : 100, "horizontalScrollPolicy" : "off", "verticalScrollPolicy" : "off", "childDescriptors" : [new UIComponentDescriptor({"type" : PaintCanvas, "id" : "paintCanvas"})]}; | |
}})]}; | |
}}), new UIComponentDescriptor({"type" : HBox, "stylesFactory" : function() | |
{ | |
this.horizontalAlign = "center"; | |
this.verticalAlign = "middle"; | |
return; | |
}, "propertiesFactory" : function() | |
{ | |
return {"width" : 320, "height" : 60, "styleName" : "BlogControlsBoxStyle", "childDescriptors" : [new UIComponentDescriptor({"type" : HandCursorButton, "id" : "downloadButton", "events" : {"click" : "__downloadButton_click"}, "propertiesFactory" : function() | |
{ | |
return {"styleName" : "DownloadButtonStyle", "enabled" : false}; | |
}}), new UIComponentDescriptor({"type" : HandCursorButton, "id" : "paintYourselfButton", "events" : {"click" : "__paintYourselfButton_click"}, "propertiesFactory" : function() | |
{ | |
return {"styleName" : "PaintYourselfButtonStyle", "enabled" : false}; | |
}}), new UIComponentDescriptor({"type" : HandCursorButton, "id" : "getCodeButton", "events" : {"click" : "__getCodeButton_click"}, "propertiesFactory" : function() | |
{ | |
return {"styleName" : "GetCodeButtonStyle", "enabled" : false}; | |
}}), new UIComponentDescriptor({"type" : HandCursorButton, "id" : "playAgainButton", "events" : {"click" : "__playAgainButton_click"}, "propertiesFactory" : function() | |
{ | |
return {"styleName" : "PlayAgainButtonStyle", "enabled" : false}; | |
}})]}; | |
}})]}; | |
}}), new UIComponentDescriptor({"type" : BlogPlayerPreloaderAftertaste, "id" : "preloaderAftertaste", "propertiesFactory" : function() | |
{ | |
return {"x" : 0, "y" : 0, "width" : 500, "height" : 560}; | |
}}), new UIComponentDescriptor({"type" : HBox, "id" : "_BlogPlayer_HBox2", "stylesFactory" : function() | |
{ | |
this.left = "0"; | |
this.bottom = "0"; | |
return; | |
}, "propertiesFactory" : function() | |
{ | |
return {"childDescriptors" : [new UIComponentDescriptor({"type" : FpsMeter}), new UIComponentDescriptor({"type" : MemoryUsageMeter})]}; | |
}}), new UIComponentDescriptor({"type" : UIComponent, "id" : "loggerWrapper", "propertiesFactory" : function() | |
{ | |
return {"mouseEnabled" : false, "percentWidth" : 100, "percentHeight" : 100}; | |
}})]}; | |
}}); | |
this.loadConfigController = LoadConfigController.instance; | |
this.loadLibraryController = LoadLibraryController.instance; | |
this._embed_css__1017935931 = BlogPlayer__embed_css__1017935931; | |
this._embed_css__1502235314 = BlogPlayer__embed_css__1502235314; | |
this._embed_css__162016752 = BlogPlayer__embed_css__162016752; | |
this._embed_css__2078891259 = BlogPlayer__embed_css__2078891259; | |
this._embed_css__2093910380 = BlogPlayer__embed_css__2093910380; | |
this._bindings = []; | |
this._watchers = []; | |
this._bindingsByDestination = {}; | |
this._bindingsBeginWithWord = {}; | |
super(); | |
mx_internal._document = this; | |
if(this.styleDeclaration) | |
{ | |
this.styleDeclaration = new CSSStyleDeclaration(); | |
} | |
this.styleDeclaration.defaultFactory = ; | |
var loc1:* = this; | |
this.layout = "absolute"; | |
this.width = 500; | |
this.height = 560; | |
this.horizontalScrollPolicy = "off"; | |
this.verticalScrollPolicy = "off"; | |
this._BlogPlayer_TraceTarget1_i(); | |
this.addEventListener("applicationComplete", this.___BlogPlayer_Application1_applicationComplete); | |
return; | |
} | |
public static Setter function watcherSetupUtil(arg0:mx.binding::IWatcherSetupUtil) | |
{ | |
*::_watcherSetupUtil._watcherSetupUtil = ; | |
return; | |
} | |
public function __playAgainButton_click(arg0:flash.events::MouseEvent) | |
{ | |
this.playAgain(); | |
return; | |
} | |
private function loadLibraryClipartsXML() | |
{ | |
this.loadLibraryController.data = ; | |
loadLibraryController.addEventListener(ModelEvent.LIBRARY_LOAD_COMPLETE, this.library_loadCompleteHandler); | |
loadLibraryController.load(); | |
return; | |
} | |
public Setter function viewstack(arg0:mx.containers::ViewStack) | |
{ | |
var loc0:* = this._1554553085viewstack; | |
if(loc0 !== arg0) | |
{ | |
this._1554553085viewstack = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "viewstack", loc0, arg0)); | |
} | |
return; | |
} | |
private function _BlogPlayer_TraceTarget1_i() : mx.logging.targets::TraceTarget | |
{ | |
var loc0:* = new TraceTarget(); | |
this.traceTarget = loc0; | |
loc0.includeCategory = true; | |
loc0.includeLevel = true; | |
loc0.includeTime = true; | |
loc0.fieldSeparator = " -> "; | |
BindingManager.executeBindings(this, "traceTarget", this.traceTarget); | |
loc0.initialized(this, "traceTarget"); | |
return loc0; | |
} | |
public function __screenshot_complete(arg0:flash.events::Event) | |
{ | |
this.playerStartButton.visible = true; | |
return; | |
} | |
public Getter function downloadButton() : ru.yandex.kraski.universalpainter.view.comps::HandCursorButton | |
{ | |
return this._159077850downloadButton; | |
} | |
private function playInitEffect() | |
{ | |
preloaderAftertaste.gotoAndPlay(0); | |
addEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
return; | |
} | |
private function loadCard() | |
{ | |
var loc0:* = ServiceLocator.loadCardForPlayService; | |
loc0.addEventListener(ResultEvent.RESULT, this.resultHandler); | |
loc0.addEventListener(FaultEvent.FAULT, this.faultHandler); | |
loc0.load(Config.instance.cardHash); | |
return; | |
} | |
public Getter function viewstack() : mx.containers::ViewStack | |
{ | |
return this._1554553085viewstack; | |
} | |
private function enterFrameHandler(arg0:flash.events::Event) | |
{ | |
if(this.preloaderAftertaste.totalFrames == this.preloaderAftertaste.currentFrame) | |
{ | |
preloaderAftertaste.stop(); | |
removeChild(this.preloaderAftertaste); | |
removeEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
} | |
return; | |
} | |
private function init() | |
{ | |
this.isDebug = "false" == "true"; | |
this.addVersionToContextMenu(); | |
this.initCursorVisibility(); | |
this.initCursorManager(); | |
callLater(this.playInitEffect); | |
Log.addTarget(this.traceTarget); | |
var loc0:* = new Logger(); | |
loc0.mouseEnabled = false; | |
loc0.target.filters = ; | |
Log.addTarget(loc0.target); | |
loggerWrapper.addChild(loc0); | |
if(parameters.mode == "local") | |
{ | |
ServiceLocator.implementation = new FakeServiceLocatorImpl(); | |
} | |
else | |
{ | |
ServiceLocator.implementation = new WebServiceLocatorImpl(); | |
} | |
this._model = new Model(this); | |
this.paintCanvas.model = ; | |
SmoothPaint.smoothingEnabled = false; | |
this.screenshot.source = 0; | |
return; | |
} | |
public Setter function paintYourselfButton(arg0:ru.yandex.kraski.universalpainter.view.comps::HandCursorButton) | |
{ | |
var loc0:* = this._1937158641paintYourselfButton; | |
if(loc0 !== arg0) | |
{ | |
this._1937158641paintYourselfButton = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "paintYourselfButton", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function playerStartButton(arg0:ru.yandex.kraski.universalpainter.view.comps::HandCursorButton) | |
{ | |
var loc0:* = this._1613058925playerStartButton; | |
if(loc0 !== arg0) | |
{ | |
this._1613058925playerStartButton = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "playerStartButton", loc0, arg0)); | |
} | |
return; | |
} | |
public Getter function model() : ru.yandex.kraski.universalpainter.data::Model | |
{ | |
return this._model; | |
} | |
public Getter function paintYourselfButton() : ru.yandex.kraski.universalpainter.view.comps::HandCursorButton | |
{ | |
return this._1937158641paintYourselfButton; | |
} | |
private function usedResources_loadCompleteHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
removeEventListener(ModelEvent.CLIPARTS_LOAD_COMPLETE, this.usedResources_loadCompleteHandler); | |
debug("Ready to show card"); | |
this.card = Card.fromXML(this.model.clipartDescriptors, this.cardXML); | |
this.card.hash = Config.instance.cardHash; | |
this.cardXML = null; | |
CustomCursorManager.setCursorByName(CursorType.POINTER); | |
this.downloadButton.enabled = true; | |
this.paintYourselfButton.enabled = true; | |
this.getCodeButton.enabled = true; | |
this.player = new Player(); | |
this.player.paintCanvas = paintCanvas; | |
this.player.card = ; | |
if(this.viewstack.selectedIndex == 0) | |
{ | |
this.viewstack.selectedIndex = 1; | |
} | |
this.playCard(); | |
return; | |
} | |
public function ___BlogPlayer_Application1_applicationComplete(arg0:mx.events::FlexEvent) | |
{ | |
this.init(); | |
return; | |
} | |
private function initCursorVisibility() | |
{ | |
var loc0:* = new Rectangle(1, 1, width - 1, height - 1); | |
if(loc0.containsPoint(new Point(mouseX, mouseY))) | |
{ | |
CustomCursorManager.setCursorByName(CursorType.POINTER); | |
} | |
else | |
{ | |
addEventListener(MouseEvent.ROLL_OVER, this.app_rollOverHandler); | |
} | |
return; | |
} | |
public Getter function traceTarget() : mx.logging.targets::TraceTarget | |
{ | |
return this._235964214traceTarget; | |
} | |
private function initCursorManager() | |
{ | |
this.customCursorManager = new CustomCursorManager(); | |
this.customCursorManager.stage = stage; | |
return; | |
} | |
public Getter function isDebug() : Boolean | |
{ | |
return this._2056864585isDebug; | |
} | |
public Getter function preloaderAftertaste() : BlogPlayerPreloaderAftertaste | |
{ | |
return this._1631133009preloaderAftertaste; | |
} | |
public Getter function paintCanvas() : ru.yandex.kraski.universalpainter.view::PaintCanvas | |
{ | |
return this._1763239082paintCanvas; | |
} | |
private function loadBackgroundsXml() | |
{ | |
var loc0:* = BackgroundsLoadingController.instance; | |
loc0.model = ; | |
loc0.register(); | |
loc0.addEventListener(ModelEvent.BACKGROUNDS_LOAD_COMPLETE, this.backgrounds_completeHandler); | |
loc0.load(); | |
return; | |
} | |
public function __getCodeButton_click(arg0:flash.events::MouseEvent) | |
{ | |
this.gotoCardPlayerPage(); | |
return; | |
} | |
private function playCard() | |
{ | |
this.playAgainButton.enabled = false; | |
player.play(); | |
player.addEventListener(PlayerEvent.PLAY_FINISNED, this.playFinishedHandler); | |
return; | |
} | |
public function getUsedPhotoframePictures(arg0:XML) : Array | |
{ | |
result = null; | |
photoframeNode = null; | |
pictureNode = null; | |
cardXML = arg0; | |
result = []; | |
var loc2:* = 0; | |
var loc3:* = cardXML.visual; | |
var loc1:* = new XMLList(""); | |
for(loc2 in loc3) | |
{ | |
var loc4:* = loc3.__getNextEnumerablePropertyValue(); | |
var loc5:* = loc3.__getNextEnumerablePropertyValue(); | |
if(type == "Photoframe") | |
{ | |
loc1.loc4 = 0; | |
} | |
} | |
photoframeNode = loc1; | |
loc1 = 0; | |
loc4 = 0; | |
loc5 = photoframeNode.photos.visual; | |
loc3 = new XMLList(""); | |
for(loc4 in loc5) | |
{ | |
var loc6:* = loc5.__getNextEnumerablePropertyValue(); | |
var loc7:* = loc5.__getNextEnumerablePropertyValue(); | |
if(type == "PhotoframePicture") | |
{ | |
loc3.loc6 = 0; | |
} | |
} | |
loc2 = loc3; | |
for(loc1 in loc2) | |
{ | |
pictureNode = loc2.__getNextEnumerablePropertyValue(); | |
push(parseInt(pictureNode.pictureIndex)); | |
} | |
return result; | |
} | |
private function resultHandler(arg0:mx.rpc.events::ResultEvent) | |
{ | |
this.removeLoadCardServiceListeners(ILoadCardService(arg0.target)); | |
this.cardXML = (arg0.result) as XML; | |
this.restoreCard(this.cardXML); | |
return; | |
} | |
public Setter function traceTarget(arg0:mx.logging.targets::TraceTarget) | |
{ | |
var loc0:* = this._235964214traceTarget; | |
if(loc0 !== arg0) | |
{ | |
this._235964214traceTarget = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "traceTarget", loc0, arg0)); | |
} | |
return; | |
} | |
public Getter function getCodeButton() : ru.yandex.kraski.universalpainter.view.comps::HandCursorButton | |
{ | |
return this._1704619147getCodeButton; | |
} | |
public function __paintYourselfButton_click(arg0:flash.events::MouseEvent) | |
{ | |
this.gotoServiceMainPage(); | |
return; | |
} | |
private function getUsedClipartVOs(arg0:XML) : Array | |
{ | |
clipartNode = null; | |
clipartVO = null; | |
cardXML = arg0; | |
result = []; | |
var loc1:* = 0; | |
var loc4:* = 0; | |
var loc5:* = cardXML.visual; | |
var loc3:* = new XMLList(""); | |
for(loc4 in loc5) | |
{ | |
var loc6:* = loc5.__getNextEnumerablePropertyValue(); | |
var loc7:* = loc5.__getNextEnumerablePropertyValue(); | |
if(type == "Clipart") | |
{ | |
loc3.loc6 = 0; | |
} | |
} | |
var loc2:* = loc3; | |
for(loc1 in loc2) | |
{ | |
clipartNode = loc2.__getNextEnumerablePropertyValue(); | |
clipartVO = getClipartVOByClassName(clipartNode.resource.symbol); | |
if(clipartVO) | |
{ | |
push(clipartVO); | |
} | |
} | |
return result; | |
} | |
private function addVersionToContextMenu() | |
{ | |
var loc0:* = new ContextMenuManager(); | |
loc0.addVersionToContextMenu(Model.blogPlayerAppName); | |
return; | |
} | |
public Getter function screenshot() : mx.controls::Image | |
{ | |
return this._416447130screenshot; | |
} | |
private function gotoCardPlayerPage() | |
{ | |
var loc0:* = new URLRequest(URLsBuilder.getCardPlayerPage(Config.instance.cardHash)); | |
navigateToURL(loc0, "_blank"); | |
return; | |
} | |
private function library_loadCompleteHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
this.loadBackgroundsXml(); | |
return; | |
} | |
public function getUsedPictures(arg0:XML) : Array | |
{ | |
pictureNode = null; | |
cardXML = arg0; | |
result = []; | |
var loc1:* = 0; | |
var loc4:* = 0; | |
var loc5:* = cardXML.visual; | |
var loc3:* = new XMLList(""); | |
for(loc4 in loc5) | |
{ | |
var loc6:* = loc5.__getNextEnumerablePropertyValue(); | |
var loc7:* = loc5.__getNextEnumerablePropertyValue(); | |
if(type == "Picture") | |
{ | |
loc3.loc6 = 0; | |
} | |
} | |
var loc2:* = loc3; | |
for(loc1 in loc2) | |
{ | |
pictureNode = loc2.__getNextEnumerablePropertyValue(); | |
push(parseInt(pictureNode.pictureIndex)); | |
} | |
return result; | |
} | |
private function playAgain() | |
{ | |
if(this.player) | |
{ | |
player.stop(); | |
} | |
this.playCard(); | |
return; | |
} | |
private function config_loadCompleteHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
this.loadLibraryClipartsXML(); | |
return; | |
} | |
public function initialize() | |
{ | |
target = null; | |
watcherSetupUtilClass = null; | |
var loc1:* = setDocumentDescriptor; | |
bindings = this._BlogPlayer_bindingsSetup(); | |
watchers = []; | |
target = this; | |
if(this._watcherSetupUtil == null) | |
{ | |
watcherSetupUtilClass = getDefinitionByName("_BlogPlayerWatcherSetupUtil"); | |
loc1 = watcherSetupUtilClass; | |
} | |
_watcherSetupUtil.setup(this, function() | |
{ | |
return target.loc0; | |
}, bindings, watchers); | |
i = 0; | |
while(i < bindings.length) | |
{ | |
execute(); | |
i = i + 1; | |
} | |
this._bindings = 0; | |
this._watchers = 0; | |
this.initialize(); | |
return; | |
} | |
public Getter function playerStartButton() : ru.yandex.kraski.universalpainter.view.comps::HandCursorButton | |
{ | |
return this._1613058925playerStartButton; | |
} | |
private function loadPhotoframes() | |
{ | |
var loc0:* = PhotoframesLoadingController.instance; | |
loc0.model = ; | |
loc0.register(); | |
loc0.addEventListener(ModelEvent.PHOTOFRAMES_LOAD_COMPLETE, this.photoframes_completeHandler); | |
loc0.load(); | |
return; | |
} | |
private function backgrounds_completeHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
removeEventListener(ModelEvent.BACKGROUNDS_LOAD_COMPLETE, this.backgrounds_completeHandler); | |
this.loadPhotoframes(); | |
return; | |
} | |
public Setter function preview(arg0:mx.containers::Canvas) | |
{ | |
var loc0:* = this._318184504preview; | |
if(loc0 !== arg0) | |
{ | |
this._318184504preview = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "preview", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function isDebug(arg0:Boolean) | |
{ | |
var loc0:* = this._2056864585isDebug; | |
if(loc0 !== arg0) | |
{ | |
this._2056864585isDebug = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "isDebug", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function preloaderAftertaste(arg0:BlogPlayerPreloaderAftertaste) | |
{ | |
var loc0:* = this._1631133009preloaderAftertaste; | |
if(loc0 !== arg0) | |
{ | |
this._1631133009preloaderAftertaste = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "preloaderAftertaste", loc0, arg0)); | |
} | |
return; | |
} | |
private function playFinishedHandler(arg0:ru.yandex.kraski.universalpainter.events::PlayerEvent) | |
{ | |
player.removeEventListener(PlayerEvent.PLAY_FINISNED, this.playFinishedHandler); | |
this.playAgainButton.enabled = true; | |
return; | |
} | |
public Setter function paintCanvas(arg0:ru.yandex.kraski.universalpainter.view::PaintCanvas) | |
{ | |
var loc0:* = this._1763239082paintCanvas; | |
if(loc0 !== arg0) | |
{ | |
this._1763239082paintCanvas = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "paintCanvas", loc0, arg0)); | |
} | |
return; | |
} | |
public function _BlogPlayer_StylesInit() | |
{ | |
style = null; | |
effects = null; | |
if(mx_internal._BlogPlayer_StylesInit_done) | |
{ | |
return; | |
} | |
mx_internal._BlogPlayer_StylesInit_done = true; | |
style = StyleManager.getStyleDeclaration(".GetCodeButtonStyle"); | |
if(style) | |
{ | |
style = new CSSStyleDeclaration(); | |
StyleManager.setStyleDeclaration(".GetCodeButtonStyle", style, false); | |
} | |
if(style.factory == null) | |
{ | |
style.factory = ; | |
} | |
style = StyleManager.getStyleDeclaration(".BlogControlsBoxStyle"); | |
if(style) | |
{ | |
style = new CSSStyleDeclaration(); | |
StyleManager.setStyleDeclaration(".BlogControlsBoxStyle", style, false); | |
} | |
if(style.factory == null) | |
{ | |
style.factory = ; | |
} | |
style = StyleManager.getStyleDeclaration(".PaintCanvasInnerContainerStyle"); | |
if(style) | |
{ | |
style = new CSSStyleDeclaration(); | |
StyleManager.setStyleDeclaration(".PaintCanvasInnerContainerStyle", style, false); | |
} | |
if(style.factory == null) | |
{ | |
style.factory = ; | |
} | |
style = StyleManager.getStyleDeclaration(".PaintCanvasOuterContainerStyle"); | |
if(style) | |
{ | |
style = new CSSStyleDeclaration(); | |
StyleManager.setStyleDeclaration(".PaintCanvasOuterContainerStyle", style, false); | |
} | |
if(style.factory == null) | |
{ | |
style.factory = ; | |
} | |
style = StyleManager.getStyleDeclaration("Application"); | |
if(style) | |
{ | |
style = new CSSStyleDeclaration(); | |
StyleManager.setStyleDeclaration("Application", style, false); | |
} | |
if(style.factory == null) | |
{ | |
style.factory = ; | |
} | |
style = StyleManager.getStyleDeclaration(".PlayAgainButtonStyle"); | |
if(style) | |
{ | |
style = new CSSStyleDeclaration(); | |
StyleManager.setStyleDeclaration(".PlayAgainButtonStyle", style, false); | |
} | |
if(style.factory == null) | |
{ | |
style.factory = ; | |
} | |
style = StyleManager.getStyleDeclaration(".DownloadButtonStyle"); | |
if(style) | |
{ | |
style = new CSSStyleDeclaration(); | |
StyleManager.setStyleDeclaration(".DownloadButtonStyle", style, false); | |
} | |
if(style.factory == null) | |
{ | |
style.factory = ; | |
} | |
style = StyleManager.getStyleDeclaration(".PaintYourselfButtonStyle"); | |
if(style) | |
{ | |
style = new CSSStyleDeclaration(); | |
StyleManager.setStyleDeclaration(".PaintYourselfButtonStyle", style, false); | |
} | |
if(style.factory == null) | |
{ | |
style.factory = ; | |
} | |
style = StyleManager.getStyleDeclaration(".BlogPlayerStartButtonStyle"); | |
if(style) | |
{ | |
style = new CSSStyleDeclaration(); | |
StyleManager.setStyleDeclaration(".BlogPlayerStartButtonStyle", style, false); | |
} | |
if(style.factory == null) | |
{ | |
style.factory = ; | |
} | |
var loc1:* = StyleManager; | |
return; | |
} | |
public Setter function downloadButton(arg0:ru.yandex.kraski.universalpainter.view.comps::HandCursorButton) | |
{ | |
var loc0:* = this._159077850downloadButton; | |
if(loc0 !== arg0) | |
{ | |
this._159077850downloadButton = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "downloadButton", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function playAgainButton(arg0:ru.yandex.kraski.universalpainter.view.comps::HandCursorButton) | |
{ | |
var loc0:* = this._1354231074playAgainButton; | |
if(loc0 !== arg0) | |
{ | |
this._1354231074playAgainButton = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "playAgainButton", loc0, arg0)); | |
} | |
return; | |
} | |
private function restoreCard(arg0:XML) | |
{ | |
var loc0:* = ResourceManager.instance; | |
loc0.model = ; | |
var loc1:* = this.getUsedClipartVOs(arg0); | |
var loc2:* = 0; | |
while(loc2 < loc1.length) | |
{ | |
loc0.queueClipart(loc1[loc2]); | |
loc2++; | |
} | |
var loc3:* = this.getUsedPictures(arg0); | |
var loc4:* = 0; | |
while(loc4 < loc3.length) | |
{ | |
loc0.queuePicture(loc3[loc4]); | |
loc4++; | |
} | |
var loc5:* = this.getBackgroundVO(arg0); | |
if(this.getBackgroundVO(arg0)) | |
{ | |
loc0.queueClipart(loc5); | |
} | |
var loc6:* = this.getPhotoframeVO(arg0); | |
if(this.getPhotoframeVO(arg0)) | |
{ | |
loc0.queueClipart(loc6); | |
} | |
var loc7:* = this.getUsedPhotoframePictures(arg0); | |
var loc8:* = 0; | |
while(loc8 < loc7.length) | |
{ | |
loc0.queuePicture(loc7[loc8]); | |
loc8++; | |
} | |
loc0.addEventListener(ModelEvent.CLIPARTS_LOAD_COMPLETE, this.usedResources_loadCompleteHandler); | |
loc0.loadQueuedResources(); | |
return; | |
} | |
public function __downloadButton_click(arg0:flash.events::MouseEvent) | |
{ | |
this.gotoServiceMainPage(); | |
return; | |
} | |
private function loadConfig() | |
{ | |
this.playerStartButton.enabled = false; | |
CustomCursorManager.showBusyCursor(); | |
this.loadConfigController.data = this._model.config; | |
addEventListener(ModelEvent.XML_LOAD_COMPLETE, this.config_loadCompleteHandler); | |
loadConfigController.load(); | |
return; | |
} | |
public Setter function loggerWrapper(arg0:mx.core::UIComponent) | |
{ | |
var loc0:* = this._1435122461loggerWrapper; | |
if(loc0 !== arg0) | |
{ | |
this._1435122461loggerWrapper = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "loggerWrapper", loc0, arg0)); | |
} | |
return; | |
} | |
private function faultHandler(arg0:mx.rpc.events::FaultEvent) | |
{ | |
this.removeLoadCardServiceListeners(ILoadCardService(arg0.target)); | |
return; | |
} | |
public Setter function screenshot(arg0:mx.controls::Image) | |
{ | |
var loc0:* = this._416447130screenshot; | |
if(loc0 !== arg0) | |
{ | |
this._416447130screenshot = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "screenshot", loc0, arg0)); | |
} | |
return; | |
} | |
private function _BlogPlayer_bindingExprs() | |
{ | |
var loc0:* = undefined; | |
loc0 = ( (this.isDebug)? LogEventLevel.ALL : LogEventLevel.WARN ); | |
loc0 = this.isDebug; | |
loc0 = this.isDebug; | |
return; | |
} | |
public Getter function preview() : mx.containers::Canvas | |
{ | |
return this._318184504preview; | |
} | |
private function gotoServiceMainPage() | |
{ | |
var loc0:* = new URLRequest(Config.instance.serviceURL); | |
navigateToURL(loc0, "_blank"); | |
return; | |
} | |
private function getBackgroundVO(arg0:XML) : ru.yandex.kraski.universalpainter.data::ClipartVO | |
{ | |
var loc0:* = arg0.background[0]; | |
return ( (loc0)? getClipartVOByClassName(loc0.resource.symbol) : null ); | |
} | |
public Getter function playAgainButton() : ru.yandex.kraski.universalpainter.view.comps::HandCursorButton | |
{ | |
return this._1354231074playAgainButton; | |
} | |
public Getter function loggerWrapper() : mx.core::UIComponent | |
{ | |
return this._1435122461loggerWrapper; | |
} | |
private function removeLoadCardServiceListeners(arg0:ru.yandex.kraski.universalpainter.services::ILoadCardService) | |
{ | |
arg0.removeEventListener(ResultEvent.RESULT, this.resultHandler); | |
arg0.removeEventListener(FaultEvent.FAULT, this.faultHandler); | |
return; | |
} | |
private function photoframes_completeHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
debug("photoframes's library loaded"); | |
removeEventListener(ModelEvent.PHOTOFRAMES_LOAD_COMPLETE, this.photoframes_completeHandler); | |
this.loadCard(); | |
return; | |
} | |
private function getPhotoframeVO(arg0:XML) : ru.yandex.kraski.universalpainter.data::ClipartVO | |
{ | |
photoframeNode = null; | |
cardXML = arg0; | |
var loc2:* = 0; | |
var loc3:* = cardXML.visual; | |
var loc1:* = new XMLList(""); | |
for(loc2 in loc3) | |
{ | |
var loc4:* = loc3.__getNextEnumerablePropertyValue(); | |
var loc5:* = loc3.__getNextEnumerablePropertyValue(); | |
if(type == "Photoframe") | |
{ | |
loc1.loc4 = 0; | |
} | |
} | |
photoframeNode = loc1; | |
return ( (photoframeNode)? getClipartVOByClassName(photoframeNode.resource.symbol) : null ); | |
} | |
private function _BlogPlayer_bindingsSetup() : Array | |
{ | |
binding = null; | |
result = []; | |
binding = new Binding(this, function() | |
{ | |
return ( (isDebug)? LogEventLevel.ALL : LogEventLevel.WARN ); | |
}, function() | |
{ | |
traceTarget.level = ; | |
return; | |
}, "traceTarget.level"); | |
result[0] = binding; | |
binding = new Binding(this, function() | |
{ | |
return isDebug; | |
}, function() | |
{ | |
_BlogPlayer_HBox2.visible = ; | |
return; | |
}, "_BlogPlayer_HBox2.visible"); | |
result[1] = binding; | |
binding = new Binding(this, function() | |
{ | |
return isDebug; | |
}, function() | |
{ | |
_BlogPlayer_HBox2.includeInLayout = ; | |
return; | |
}, "_BlogPlayer_HBox2.includeInLayout"); | |
result[2] = binding; | |
return result; | |
} | |
public Setter function getCodeButton(arg0:ru.yandex.kraski.universalpainter.view.comps::HandCursorButton) | |
{ | |
var loc0:* = this._1704619147getCodeButton; | |
if(loc0 !== arg0) | |
{ | |
this._1704619147getCodeButton = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "getCodeButton", loc0, arg0)); | |
} | |
return; | |
} | |
private function app_rollOverHandler(arg0:flash.events::MouseEvent) | |
{ | |
CustomCursorManager.setCursorByName(CursorType.POINTER); | |
removeEventListener(MouseEvent.ROLL_OVER, this.app_rollOverHandler); | |
return; | |
} | |
public function __playerStartButton_click(arg0:flash.events::MouseEvent) | |
{ | |
this.loadConfig(); | |
return; | |
} | |
} | |
public class BlogPlayer__embed_css__2078891259 extends blogPlayAgainButton_skin implements {mx.core}::IBorder, {mx.core}::IFlexAsset, {mx.core}::IFlexDisplayObject | |
{ | |
//========================= Methods | |
public static function BlogPlayer__embed_css__2078891259() | |
{ | |
return; | |
} | |
public function BlogPlayer__embed_css__2078891259() | |
{ | |
super(); | |
try { | |
NEW_ACTIVATION_OBJECT.name = NameUtil.createUniqueName(this); | |
} catch (e:Error) { | |
var loc1:* = e; | |
someVal = null; | |
} | |
return; | |
} | |
public function toString() : String | |
{ | |
return NameUtil.displayObjectToString(this); | |
} | |
public Getter function borderMetrics() : mx.core::EdgeMetrics | |
{ | |
if(scale9Grid == null) | |
{ | |
return EdgeMetrics.EMPTY; | |
} | |
return new EdgeMetrics(scale9Grid.left, scale9Grid.top, Math.ceil(measuredWidth - scale9Grid.right), Math.ceil(measuredHeight - scale9Grid.bottom)); | |
} | |
} | |
public class BlogPlayer__embed_css__2093910380 extends blogPaintYourselfButton_skin implements {mx.core}::IBorder, {mx.core}::IFlexAsset, {mx.core}::IFlexDisplayObject | |
{ | |
//========================= Methods | |
public static function BlogPlayer__embed_css__2093910380() | |
{ | |
return; | |
} | |
public function BlogPlayer__embed_css__2093910380() | |
{ | |
super(); | |
try { | |
NEW_ACTIVATION_OBJECT.name = NameUtil.createUniqueName(this); | |
} catch (e:Error) { | |
var loc1:* = e; | |
someVal = null; | |
} | |
return; | |
} | |
public function toString() : String | |
{ | |
return NameUtil.displayObjectToString(this); | |
} | |
public Getter function borderMetrics() : mx.core::EdgeMetrics | |
{ | |
if(scale9Grid == null) | |
{ | |
return EdgeMetrics.EMPTY; | |
} | |
return new EdgeMetrics(scale9Grid.left, scale9Grid.top, Math.ceil(measuredWidth - scale9Grid.right), Math.ceil(measuredHeight - scale9Grid.bottom)); | |
} | |
} | |
public class _BlogPlayerWatcherSetupUtil extends flash.display::Sprite implements {mx.binding}::IWatcherSetupUtil | |
{ | |
//========================= Methods | |
public static function _BlogPlayerWatcherSetupUtil() | |
{ | |
return; | |
} | |
public function _BlogPlayerWatcherSetupUtil() | |
{ | |
super(); | |
return; | |
} | |
public static function init(arg0:mx.core::IFlexModuleFactory) | |
{ | |
BlogPlayer.watcherSetupUtil = ; | |
return; | |
} | |
public function setup(arg0:Object, arg1:Function, arg2:Array, arg3:Array) | |
{ | |
arg3[0] = new PropertyWatcher("isDebug", {"propertyChange" : true}, [arg2[0], arg2[1], arg2[2]], arg1); | |
updateParent(arg0); | |
return; | |
} | |
} | |
public class BlogPlayer__embed_css__162016752 extends blogPlayerStartButton_skin implements {mx.core}::IBorder, {mx.core}::IFlexAsset, {mx.core}::IFlexDisplayObject | |
{ | |
//========================= Methods | |
public static function BlogPlayer__embed_css__162016752() | |
{ | |
return; | |
} | |
public function BlogPlayer__embed_css__162016752() | |
{ | |
super(); | |
try { | |
NEW_ACTIVATION_OBJECT.name = NameUtil.createUniqueName(this); | |
} catch (e:Error) { | |
var loc1:* = e; | |
someVal = null; | |
} | |
return; | |
} | |
public function toString() : String | |
{ | |
return NameUtil.displayObjectToString(this); | |
} | |
public Getter function borderMetrics() : mx.core::EdgeMetrics | |
{ | |
if(scale9Grid == null) | |
{ | |
return EdgeMetrics.EMPTY; | |
} | |
return new EdgeMetrics(scale9Grid.left, scale9Grid.top, Math.ceil(measuredWidth - scale9Grid.right), Math.ceil(measuredHeight - scale9Grid.bottom)); | |
} | |
} | |
public dynamic class BlogPlayerPreloaderAftertaste extends mx.flash::UIMovieClip | |
{ | |
//========================= Methods | |
public static function BlogPlayerPreloaderAftertaste() | |
{ | |
return; | |
} | |
public function BlogPlayerPreloaderAftertaste() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class BlogPlayer__embed_css__1502235314 extends blogGetCodeButton_skin implements {mx.core}::IBorder, {mx.core}::IFlexAsset, {mx.core}::IFlexDisplayObject | |
{ | |
//========================= Methods | |
public static function BlogPlayer__embed_css__1502235314() | |
{ | |
return; | |
} | |
public function BlogPlayer__embed_css__1502235314() | |
{ | |
super(); | |
try { | |
NEW_ACTIVATION_OBJECT.name = NameUtil.createUniqueName(this); | |
} catch (e:Error) { | |
var loc1:* = e; | |
someVal = null; | |
} | |
return; | |
} | |
public function toString() : String | |
{ | |
return NameUtil.displayObjectToString(this); | |
} | |
public Getter function borderMetrics() : mx.core::EdgeMetrics | |
{ | |
if(scale9Grid == null) | |
{ | |
return EdgeMetrics.EMPTY; | |
} | |
return new EdgeMetrics(scale9Grid.left, scale9Grid.top, Math.ceil(measuredWidth - scale9Grid.right), Math.ceil(measuredHeight - scale9Grid.bottom)); | |
} | |
} | |
public class BlogPlayer__embed_css__1017935931 extends blogDownloadButton_skin implements {mx.core}::IBorder, {mx.core}::IFlexAsset, {mx.core}::IFlexDisplayObject | |
{ | |
//========================= Methods | |
public static function BlogPlayer__embed_css__1017935931() | |
{ | |
return; | |
} | |
public function BlogPlayer__embed_css__1017935931() | |
{ | |
super(); | |
try { | |
NEW_ACTIVATION_OBJECT.name = NameUtil.createUniqueName(this); | |
} catch (e:Error) { | |
var loc1:* = e; | |
someVal = null; | |
} | |
return; | |
} | |
public function toString() : String | |
{ | |
return NameUtil.displayObjectToString(this); | |
} | |
public Getter function borderMetrics() : mx.core::EdgeMetrics | |
{ | |
if(scale9Grid == null) | |
{ | |
return EdgeMetrics.EMPTY; | |
} | |
return new EdgeMetrics(scale9Grid.left, scale9Grid.top, Math.ceil(measuredWidth - scale9Grid.right), Math.ceil(measuredHeight - scale9Grid.bottom)); | |
} | |
} | |
public dynamic class PhotoframeCursorIcon extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function PhotoframeCursorIcon() | |
{ | |
return; | |
} | |
public function PhotoframeCursorIcon() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class PointerCursorIcon extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function PointerCursorIcon() | |
{ | |
return; | |
} | |
public function PointerCursorIcon() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class FingerCursorIcon extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function FingerCursorIcon() | |
{ | |
return; | |
} | |
public function FingerCursorIcon() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class TextCursorIcon extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function TextCursorIcon() | |
{ | |
return; | |
} | |
public function TextCursorIcon() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class Brush extends ru.yandex.kraski.universalpainter.cursors::BrushCursorClass | |
{ | |
//========================= Methods | |
public static function Brush() | |
{ | |
return; | |
} | |
public function Brush() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class DragCursorIcon extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function DragCursorIcon() | |
{ | |
return; | |
} | |
public function DragCursorIcon() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class HandCursorIcon extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function HandCursorIcon() | |
{ | |
return; | |
} | |
public function HandCursorIcon() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class RectPaintSymbol extends flash.display::MovieClip | |
{ | |
//========================= Variables | |
public var mc : MovieClip; | |
//========================= Methods | |
public static function RectPaintSymbol() | |
{ | |
return; | |
} | |
public function RectPaintSymbol() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class HeartPaintSymbol extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function HeartPaintSymbol() | |
{ | |
return; | |
} | |
public function HeartPaintSymbol() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class FlowerPaintSymbol extends flash.display::MovieClip | |
{ | |
//========================= Variables | |
public var mc : MovieClip; | |
//========================= Methods | |
public static function FlowerPaintSymbol() | |
{ | |
return; | |
} | |
public function FlowerPaintSymbol() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class PentaPaintSymbol extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function PentaPaintSymbol() | |
{ | |
return; | |
} | |
public function PentaPaintSymbol() | |
{ | |
super(); | |
addFrameScript(39, this.frame40); | |
return; | |
} | |
internal function frame40() | |
{ | |
gotoAndPlay(6); | |
return; | |
} | |
} | |
} | |
package skins_fla | |
{ | |
public dynamic class blog_icon_play_7 extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function blog_icon_play_7() | |
{ | |
return; | |
} | |
public function blog_icon_play_7() | |
{ | |
super(); | |
addFrameScript(0, this.frame1); | |
return; | |
} | |
internal function frame1() | |
{ | |
stop(); | |
return; | |
} | |
} | |
public dynamic class blog_icon_save_2 extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function blog_icon_save_2() | |
{ | |
return; | |
} | |
public function blog_icon_save_2() | |
{ | |
super(); | |
addFrameScript(0, this.frame1); | |
return; | |
} | |
internal function frame1() | |
{ | |
stop(); | |
return; | |
} | |
} | |
public dynamic class blog_icon_brush_main_12 extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function blog_icon_brush_main_12() | |
{ | |
return; | |
} | |
public function blog_icon_brush_main_12() | |
{ | |
super(); | |
addFrameScript(0, this.frame1); | |
return; | |
} | |
internal function frame1() | |
{ | |
stop(); | |
return; | |
} | |
} | |
public dynamic class blog_icon_mail_main_9 extends flash.display::MovieClip | |
{ | |
//========================= Methods | |
public static function blog_icon_mail_main_9() | |
{ | |
return; | |
} | |
public function blog_icon_mail_main_9() | |
{ | |
super(); | |
addFrameScript(0, this.frame1); | |
return; | |
} | |
internal function frame1() | |
{ | |
stop(); | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.services | |
{ | |
public class URLsBuilder extends Object | |
{ | |
//========================= Methods | |
public static function URLsBuilder() | |
{ | |
return; | |
} | |
public function URLsBuilder() | |
{ | |
super(); | |
return; | |
} | |
public static function getLoadCardURL(arg0:String) : String | |
{ | |
return Config.instance.servantURL + "/get-xml/" + this.getFullStoragePath(arg0) + "?kraski_ver=2&nocache=" + valueOf(); | |
} | |
private static function extractStorageNum(arg0:String) : String | |
{ | |
return arg0.split(".")[1]; | |
} | |
public static function getPictureUploadURL(arg0:String, arg1:int) : String | |
{ | |
return Config.instance.uploadURL + "/custom-image-upload" + "?slide_n=" + arg1 + "&hash=" + arg0 + "&kraski_ver=2"; | |
} | |
public static function getSaveCardURL(arg0:String) : String | |
{ | |
return Config.instance.uploadURL + "/upload-xml"; | |
} | |
public static function getCreateNewCardURL(arg0:String) : String | |
{ | |
return Config.instance.serviceURL + "/pre.xml?hash=" + arg0 + "&kraski_ver=2"; | |
} | |
public static function getScreenshotUploadURL() : String | |
{ | |
return Config.instance.uploadURL + "/screenshot-upload"; | |
} | |
public static function getScreenshotURL(arg0:String) : String | |
{ | |
return Config.instance.servantURL + "/get/" + this.getFullStoragePath(arg0) + "_scr"; | |
} | |
public static function getCardPlayerPage(arg0:String) : String | |
{ | |
return Config.instance.serviceURL + "/view.xml?hash=" + arg0; | |
} | |
public static function getNewHashURL() : String | |
{ | |
return Config.instance.serviceURL + "/newcard.xml?kraski_ver=2"; | |
} | |
public static function getHelpURL() : String | |
{ | |
return Config.instance.serviceURL + "/help.xml"; | |
} | |
private static function extractStorageDirectory(arg0:String) : String | |
{ | |
return arg0.substr(0, 4); | |
} | |
private static function getFullStoragePath(arg0:String) : String | |
{ | |
return this.extractStorageNum(arg0) + "/" + this.extractStorageDirectory(arg0) + "/" + arg0; | |
} | |
public static function getConfigURL() : String | |
{ | |
return Config.instance.appBaseURL + "/config.xml"; | |
} | |
public static function getPictureDownloadURL(arg0:String, arg1:int = 0) : String | |
{ | |
return Config.instance.servantURL + "/get-custom/" + this.getFullStoragePath(arg0) + "_img" + arg1 + "?kraski_ver=2"; | |
} | |
} | |
public class ServiceLocatorImpl extends Object | |
{ | |
//========================= Variables | |
public var _createNewCardService : ICreateNewCardService; | |
public var _saveCardService : ISaveCardService; | |
public var _loadCardForPlayService : ILoadCardService; | |
public var _loadConfigService : ILoadConfigService; | |
public var _loadCardForEditService : ILoadCardService; | |
public var _loadPictureService : ILoadPictureService; | |
//========================= Methods | |
public static function ServiceLocatorImpl() | |
{ | |
return; | |
} | |
public function ServiceLocatorImpl() | |
{ | |
super(); | |
return; | |
} | |
public Getter function createNewCardService() : ru.yandex.kraski.universalpainter.services::ICreateNewCardService | |
{ | |
return this._createNewCardService; | |
} | |
public Getter function loadCardForPlayService() : ru.yandex.kraski.universalpainter.services::ILoadCardService | |
{ | |
return this._loadCardForPlayService; | |
} | |
public Getter function saveCardService() : ru.yandex.kraski.universalpainter.services::ISaveCardService | |
{ | |
return this._saveCardService; | |
} | |
public Getter function loadConfigService() : ru.yandex.kraski.universalpainter.services::ILoadConfigService | |
{ | |
return this._loadConfigService; | |
} | |
public Getter function loadPictureService() : ru.yandex.kraski.universalpainter.services::ILoadPictureService | |
{ | |
return this._loadPictureService; | |
} | |
public Getter function loadCardForEditService() : ru.yandex.kraski.universalpainter.services::ILoadCardService | |
{ | |
return this._loadCardForEditService; | |
} | |
} | |
public interface ILoadCardServiceimplements {flash.events}::IEventDispatcher | |
{ | |
//========================= Methods | |
public function load(arg0:String); | |
} | |
public class ServiceLocator extends Object | |
{ | |
//========================= Variables | |
private static var _impl : ServiceLocatorImpl; | |
//========================= Methods | |
public static function ServiceLocator() | |
{ | |
return; | |
} | |
public function ServiceLocator() | |
{ | |
super(); | |
return; | |
} | |
public static Getter function createNewCardService() : ru.yandex.kraski.universalpainter.services::ICreateNewCardService | |
{ | |
return this._impl.createNewCardService; | |
} | |
public static Getter function loadConfigService() : ru.yandex.kraski.universalpainter.services::ILoadConfigService | |
{ | |
return this._impl.loadConfigService; | |
} | |
public static Getter function loadCardForPlayService() : ru.yandex.kraski.universalpainter.services::ILoadCardService | |
{ | |
return this._impl.loadCardForPlayService; | |
} | |
public static Getter function loadCardForEditService() : ru.yandex.kraski.universalpainter.services::ILoadCardService | |
{ | |
return this._impl.loadCardForEditService; | |
} | |
public static Getter function saveCardService() : ru.yandex.kraski.universalpainter.services::ISaveCardService | |
{ | |
return this._impl.saveCardService; | |
} | |
public static Getter function implementation() : ru.yandex.kraski.universalpainter.services::ServiceLocatorImpl | |
{ | |
return this._impl; | |
} | |
public static Setter function implementation(arg0:ru.yandex.kraski.universalpainter.services::ServiceLocatorImpl) | |
{ | |
this._impl = ; | |
return; | |
} | |
public static Getter function loadPictureService() : ru.yandex.kraski.universalpainter.services::ILoadPictureService | |
{ | |
return this._impl.loadPictureService; | |
} | |
} | |
public interface ICreateNewCardServiceimplements {flash.events}::IEventDispatcher | |
{ | |
//========================= Methods | |
public function createCard(); | |
} | |
public interface ILoadConfigServiceimplements {flash.events}::IEventDispatcher | |
{ | |
//========================= Methods | |
public function load(); | |
} | |
public interface ILoadPictureServiceimplements {flash.events}::IEventDispatcher | |
{ | |
//========================= Methods | |
public function downloadPicture(arg0:int); | |
public function load(arg0:ru.yandex.kraski.universalpainter.data::Card); | |
} | |
public interface ISaveCardServiceimplements {flash.events}::IEventDispatcher | |
{ | |
//========================= Methods | |
public function save(arg0:ru.yandex.kraski.universalpainter.data::Card, arg1:flash.display::DisplayObject); | |
} | |
public class KraskiService extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
private var _className : String; | |
//========================= Methods | |
public static function KraskiService() | |
{ | |
return; | |
} | |
public function KraskiService() | |
{ | |
super(); | |
return; | |
} | |
public Getter function className() : String | |
{ | |
if(this._className) | |
{ | |
this._className = join("."); | |
} | |
return this._className; | |
} | |
} | |
} | |
package ru.yandex.profiling | |
{ | |
public class FpsMeter extends mx.controls::Label | |
{ | |
//========================= Variables | |
private var _frames : int = 0; | |
private var _timestamp : int; | |
//========================= Methods | |
public static function FpsMeter() | |
{ | |
return; | |
} | |
public function FpsMeter() | |
{ | |
super(); | |
this.addEventListener("addedToStage", this.___FpsMeter_Label1_addedToStage); | |
this.addEventListener("removedFromStage", this.___FpsMeter_Label1_removedFromStage); | |
return; | |
} | |
private function start() | |
{ | |
addEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
this._timestamp = getTimer(); | |
return; | |
} | |
private function stop() | |
{ | |
removeEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
return; | |
} | |
public function ___FpsMeter_Label1_addedToStage(arg0:flash.events::Event) | |
{ | |
this.start(); | |
return; | |
} | |
public function initialize() | |
{ | |
this.initialize(); | |
return; | |
} | |
private function enterFrameHandler(arg0:flash.events::Event) | |
{ | |
var loc0:* = 0; | |
var loc1:* = this; | |
var loc2:* = this._frames + 1; | |
loc1._frames = this._frames; | |
if(this._frames == 10) | |
{ | |
loc0 = getTimer(); | |
this = "fps: " + Math.round(10000 / loc0 - this._timestamp); | |
this._timestamp = loc0; | |
this._frames = 0; | |
} | |
return; | |
} | |
public function ___FpsMeter_Label1_removedFromStage(arg0:flash.events::Event) | |
{ | |
this.stop(); | |
return; | |
} | |
public Setter function text(arg0:String) | |
{ | |
return; | |
} | |
public Setter function htmlText(arg0:String) | |
{ | |
return; | |
} | |
} | |
public class MemoryUsageMeter extends mx.controls::Label | |
{ | |
//========================= Variables | |
private var _timer : Timer; | |
//========================= Methods | |
public static function MemoryUsageMeter() | |
{ | |
return; | |
} | |
public function MemoryUsageMeter() | |
{ | |
this._timer = new Timer(500); | |
super(); | |
this.addEventListener("addedToStage", this.___MemoryUsageMeter_Label1_addedToStage); | |
this.addEventListener("removedFromStage", this.___MemoryUsageMeter_Label1_removedFromStage); | |
return; | |
} | |
public function initialize() | |
{ | |
this.initialize(); | |
return; | |
} | |
public function ___MemoryUsageMeter_Label1_removedFromStage(arg0:flash.events::Event) | |
{ | |
this.stop(); | |
return; | |
} | |
private function start() | |
{ | |
_timer.addEventListener(TimerEvent.TIMER, this.timerHandler); | |
_timer.start(); | |
return; | |
} | |
private function timerHandler(arg0:flash.events::TimerEvent) | |
{ | |
this = "memory: " + Math.round(System.totalMemory / 1024 * 1024) + " MB"; | |
return; | |
} | |
private function stop() | |
{ | |
_timer.stop(); | |
_timer.removeEventListener(TimerEvent.TIMER, this.timerHandler); | |
return; | |
} | |
public Setter function text(arg0:String) | |
{ | |
return; | |
} | |
public function ___MemoryUsageMeter_Label1_addedToStage(arg0:flash.events::Event) | |
{ | |
this.start(); | |
return; | |
} | |
public Setter function htmlText(arg0:String) | |
{ | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.services.fake | |
{ | |
public class FakeServiceLocatorImpl extends ru.yandex.kraski.universalpainter.services::ServiceLocatorImpl | |
{ | |
//========================= Methods | |
public static function FakeServiceLocatorImpl() | |
{ | |
return; | |
} | |
public function FakeServiceLocatorImpl() | |
{ | |
super(); | |
this._loadPictureService = new FakeLoadPictureService(); | |
this._saveCardService = new FakeSaveCardService(); | |
this._createNewCardService = new FakeCreateNewCardService(); | |
this._loadCardForEditService = new FakeLoadCardService(); | |
this._loadCardForPlayService = new FakeLoadCardService(); | |
this._loadConfigService = new FakeLoadConfigService(); | |
return; | |
} | |
} | |
public class FakeLoadPictureService extends flash.events::EventDispatcher implements {ru.yandex.kraski.universalpainter.services}::ILoadPictureService | |
{ | |
//========================= Variables | |
private static const className : String = "ru.yandex.kraski.universalpainter.services.FakeLoadPictureService"; | |
//========================= Methods | |
public static function FakeLoadPictureService() | |
{ | |
this.className = "ru.yandex.kraski.universalpainter.services.FakeLoadPictureService"; | |
return; | |
} | |
public function FakeLoadPictureService() | |
{ | |
super(); | |
return; | |
} | |
private function download_completeHandler(arg0:flash.events::Event) | |
{ | |
info("picture loaded"); | |
var loc0:* = LoaderInfo(arg0.target); | |
this.removeDownloadListeners(loc0); | |
dispatchEvent(new ResultEvent(ResultEvent.RESULT, false, true, loc0.content)); | |
return; | |
} | |
public function downloadPicture(arg0:int) | |
{ | |
var loc0:* = new Loader(); | |
this.addDownloadListeners(loc0.contentLoaderInfo); | |
loc0.load(new URLRequest("testData/testPicture.jpg"), new LoaderContext(false, ApplicationDomain.currentDomain)); | |
return; | |
} | |
private function removeDownloadListeners(arg0:flash.display::LoaderInfo) | |
{ | |
arg0.removeEventListener(Event.COMPLETE, this.download_completeHandler); | |
arg0.removeEventListener(IOErrorEvent.IO_ERROR, this.download_ioErrorHandler); | |
arg0.removeEventListener(ProgressEvent.PROGRESS, this.download_progressHandler); | |
return; | |
} | |
private function download_progressHandler(arg0:flash.events::ProgressEvent) | |
{ | |
info("download progress: {0} of {1} Kbytes loaded ({2}%)", toFixed(0), toFixed(0), toFixed(0)); | |
return; | |
} | |
private function addDownloadListeners(arg0:flash.display::LoaderInfo) | |
{ | |
arg0.addEventListener(Event.COMPLETE, this.download_completeHandler); | |
arg0.addEventListener(IOErrorEvent.IO_ERROR, this.download_ioErrorHandler); | |
arg0.addEventListener(ProgressEvent.PROGRESS, this.download_progressHandler); | |
return; | |
} | |
public function load(arg0:ru.yandex.kraski.universalpainter.data::Card) | |
{ | |
this.downloadPicture(0); | |
return; | |
} | |
private function download_ioErrorHandler(arg0:flash.events::IOErrorEvent) | |
{ | |
info(arg0.toString()); | |
this.removeDownloadListeners(LoaderInfo(arg0.target)); | |
dispatchEvent(FaultEvent.createEvent(new Fault(arg0.type, arg0.toString()))); | |
return; | |
} | |
} | |
public class FakeLoadConfigService extends ru.yandex.kraski.universalpainter.services::KraskiService implements {ru.yandex.kraski.universalpainter.services}::ILoadConfigService | |
{ | |
//========================= Methods | |
public static function FakeLoadConfigService() | |
{ | |
return; | |
} | |
public function FakeLoadConfigService() | |
{ | |
super(); | |
return; | |
} | |
private function completeHandler(arg0:flash.events::Event) | |
{ | |
var loc0:* = URLLoader(arg0.target); | |
this.removeListeners(loc0); | |
dispatchEvent(ResultEvent.createEvent(XML(loc0.data))); | |
return; | |
} | |
private function removeListeners(arg0:flash.net::URLLoader) | |
{ | |
arg0.removeEventListener(Event.COMPLETE, this.completeHandler); | |
arg0.removeEventListener(IOErrorEvent.IO_ERROR, this.errorHandler); | |
arg0.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, this.errorHandler); | |
return; | |
} | |
private function errorHandler(arg0:flash.events::ErrorEvent) | |
{ | |
this.removeListeners(URLLoader(arg0.target)); | |
dispatchEvent(FaultEvent.createEvent(new Fault("ConfigLoadingError", arg0.toString()))); | |
return; | |
} | |
public function load() | |
{ | |
var loc0:* = new URLLoader(); | |
loc0.addEventListener(Event.COMPLETE, this.completeHandler); | |
loc0.addEventListener(IOErrorEvent.IO_ERROR, this.errorHandler); | |
loc0.addEventListener(SecurityErrorEvent.SECURITY_ERROR, this.errorHandler); | |
loc0.load(new URLRequest(URLsBuilder.getConfigURL())); | |
return; | |
} | |
} | |
public class FakeCreateNewCardService extends flash.events::EventDispatcher implements {ru.yandex.kraski.universalpainter.services}::ICreateNewCardService | |
{ | |
//========================= Methods | |
public static function FakeCreateNewCardService() | |
{ | |
return; | |
} | |
public function FakeCreateNewCardService() | |
{ | |
super(); | |
return; | |
} | |
public function createCard() | |
{ | |
dispatchEvent(ResultEvent.createEvent(new XML("<new hash=\"7569f8dc55cdfd6994e34879e13bff10.0\"/>"))); | |
return; | |
} | |
} | |
public class FakeLoadCardService extends flash.events::EventDispatcher implements {ru.yandex.kraski.universalpainter.services}::ILoadCardService | |
{ | |
//========================= Methods | |
public static function FakeLoadCardService() | |
{ | |
return; | |
} | |
public function FakeLoadCardService() | |
{ | |
super(); | |
return; | |
} | |
public function load(arg0:String) | |
{ | |
dispatchEvent(ResultEvent.createEvent(new XML("<card picturesTotal=\"0\"> | |
</card>"))); | |
return; | |
} | |
} | |
public class FakeSaveCardService extends flash.events::EventDispatcher implements {ru.yandex.kraski.universalpainter.services}::ISaveCardService | |
{ | |
//========================= Variables | |
private static const CLASS_NAME : String = "ru.yandex.kraski.universalpainter.services.FakeSaveCardService"; | |
//========================= Methods | |
public static function FakeSaveCardService() | |
{ | |
this.CLASS_NAME = "ru.yandex.kraski.universalpainter.services.FakeSaveCardService"; | |
return; | |
} | |
public function FakeSaveCardService() | |
{ | |
super(); | |
return; | |
} | |
public function save(arg0:ru.yandex.kraski.universalpainter.data::Card, arg1:flash.display::DisplayObject) | |
{ | |
info("Sending request emulation: | |
" + "url: {0} | |
" + "method: POST | |
" + "xml_data: {1} | |
" + "hash: {2}", URLsBuilder.getSaveCardURL(arg0.hash), toXMLString(), arg0.hash); | |
dispatchEvent(ResultEvent.createEvent(new XML("<save-result hash=\"" + Escape(arg0.hash) + "\"/>"))); | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.cursors | |
{ | |
public class CursorType extends Object | |
{ | |
//========================= Variables | |
public static const FINGER : String = "finger"; | |
public static const PHOTOFRAME : String = "photoframe"; | |
public static const ERASER : String = "eraser"; | |
public static const TEXT : String = "text"; | |
public static const HAND : String = "hand"; | |
public static const DRAG : String = "drag"; | |
public static const BRUSH : String = "brush"; | |
public static const POINTER : String = "pointer"; | |
//========================= Methods | |
public static function CursorType() | |
{ | |
this.POINTER = "pointer"; | |
this.DRAG = "drag"; | |
this.ERASER = "eraser"; | |
this.FINGER = "finger"; | |
this.HAND = "hand"; | |
this.TEXT = "text"; | |
this.BRUSH = "brush"; | |
this.PHOTOFRAME = "photoframe"; | |
return; | |
} | |
public function CursorType() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class CustomCursorManager extends Object | |
{ | |
//========================= Variables | |
private var _stage : Stage; | |
//========================= Methods | |
public static function CustomCursorManager() | |
{ | |
return; | |
} | |
public function CustomCursorManager() | |
{ | |
super(); | |
return; | |
} | |
public static function showCursor() | |
{ | |
CursorManager.showCursor(); | |
return; | |
} | |
public static function hideCursor() | |
{ | |
CursorManager.hideCursor(); | |
return; | |
} | |
public static function setCursorByClass(arg0:Class) : int | |
{ | |
CursorManager.removeAllCursors(); | |
return CursorManager.setCursor(arg0); | |
} | |
public static function setCursorByName(arg0:String) : int | |
{ | |
CursorManager.removeAllCursors(); | |
return CursorManager.setCursor(CursorFactory.create(arg0)); | |
} | |
public static function showBusyCursor() | |
{ | |
CursorManager.removeAllCursors(); | |
CursorManager.setBusyCursor(); | |
return; | |
} | |
public static function removeCursorAt(arg0:int) | |
{ | |
CursorManager.removeCursor(arg0); | |
return; | |
} | |
private function addStageListeners() | |
{ | |
stage.addEventListener(Event.MOUSE_LEAVE, this.stage_mouseLeaveHandler); | |
return; | |
} | |
private function stage_mouseMoveHandler(arg0:flash.events::MouseEvent) | |
{ | |
stage.removeEventListener(MouseEvent.MOUSE_MOVE, this.stage_mouseMoveHandler); | |
this.showCursor(); | |
return; | |
} | |
private function stage_mouseLeaveHandler(arg0:flash.events::Event) | |
{ | |
this.hideCursor(); | |
stage.addEventListener(MouseEvent.MOUSE_MOVE, this.stage_mouseMoveHandler); | |
return; | |
} | |
public Setter function stage(arg0:flash.display::Stage) | |
{ | |
if(this._stage) | |
{ | |
} | |
this._stage = arg0; | |
this.addStageListeners(); | |
return; | |
} | |
public Getter function stage() : flash.display::Stage | |
{ | |
return this._stage; | |
} | |
} | |
public class CursorFactory extends Object | |
{ | |
//========================= Methods | |
public static function CursorFactory() | |
{ | |
return; | |
} | |
public function CursorFactory() | |
{ | |
super(); | |
return; | |
} | |
public static function create(arg0:String) : Class | |
{ | |
var loc0:* = arg0; | |
switch(loc0) | |
{ | |
case CursorType.POINTER: | |
return PointerCursorIcon; | |
case CursorType.HAND: | |
return HandCursorIcon; | |
case CursorType.DRAG: | |
return DragCursorIcon; | |
case CursorType.FINGER: | |
return FingerCursorIcon; | |
case CursorType.TEXT: | |
return TextCursorIcon; | |
case CursorType.BRUSH: | |
return Brush; | |
case CursorType.PHOTOFRAME: | |
return PhotoframeCursorIcon; | |
default: | |
break; | |
} | |
} | |
} | |
public class BrushCursorClass extends flash.display::MovieClip | |
{ | |
//========================= Variables | |
private var _color : uint; | |
private var _oldRotation : Number; | |
private var _oldX : Number; | |
private var _oldY : Number; | |
//========================= Methods | |
public static function BrushCursorClass() | |
{ | |
return; | |
} | |
public function BrushCursorClass() | |
{ | |
super(); | |
CursorModel.setCurrentInstance(this); | |
this.mouseChildren = false; | |
this.mouseEnabled = false; | |
addEventListener(Event.ADDED_TO_STAGE, this.addedToStageHandler); | |
return; | |
} | |
public Getter function color() : uint | |
{ | |
return this._color; | |
} | |
private function addedToStageHandler(arg0:flash.events::Event) | |
{ | |
addEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
addEventListener(Event.REMOVED_FROM_STAGE, this.removedFromStageHandler); | |
return; | |
} | |
private function applyFilter(arg0:flash.filters::BitmapFilter) | |
{ | |
this["brush"]["tip"]["body"].filters = ; | |
return; | |
} | |
private function enterFrameHandler(arg0:flash.events::Event) | |
{ | |
if(isNaN(this["brush"].rotation)) | |
{ | |
this["brush"].rotation = 0; | |
} | |
this["brush"].rotation = 0; | |
this["shadow"].rotation = 0; | |
var loc0:* = stage.mouseX - this._oldX; | |
var loc1:* = stage.mouseY - this._oldY; | |
this._oldRotation = -loc0 + loc1; | |
this._oldX = stage.mouseX; | |
this._oldY = stage.mouseY; | |
return; | |
} | |
private function removedFromStageHandler(arg0:flash.events::Event) | |
{ | |
removeEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
removeEventListener(Event.REMOVED_FROM_STAGE, this.removedFromStageHandler); | |
return; | |
} | |
private function validate() | |
{ | |
this.applyFilter(new ColorMatrixFilter(ColorUtils.createFilterMatrix(this._color))); | |
return; | |
} | |
public Setter function color(arg0:uint) | |
{ | |
this._color = arg0; | |
this.validate(); | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.controller | |
{ | |
public class Controller extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
public var _app : Application; | |
private var _className : String; | |
public var _model : Model; | |
//========================= Methods | |
public static function Controller() | |
{ | |
return; | |
} | |
public function Controller() | |
{ | |
super(); | |
return; | |
} | |
public Getter function app() : mx.core::Application | |
{ | |
return this._app; | |
} | |
public function register() | |
{ | |
debug("registering controller: {0}", this); | |
this._app = Application(Application.application); | |
dispatchEvent(new ControllerEvent(ControllerEvent.REGISTER)); | |
return; | |
} | |
public Getter function model() : ru.yandex.kraski.universalpainter.data::Model | |
{ | |
return this._model; | |
} | |
public Setter function model(arg0:ru.yandex.kraski.universalpainter.data::Model) | |
{ | |
this._model = arg0; | |
return; | |
} | |
public Getter function className() : String | |
{ | |
if(this._className) | |
{ | |
this._className = join("."); | |
} | |
return this._className; | |
} | |
public function unregister() | |
{ | |
debug("unregistering controller: {0}", this); | |
dispatchEvent(new ControllerEvent(ControllerEvent.UNREGISTER)); | |
return; | |
} | |
} | |
public class ResourceManager extends ru.yandex.kraski.universalpainter.controller::Controller | |
{ | |
//========================= Variables | |
private static var allowInstantiation : Boolean = False; | |
private static const IMAGE_NEED_LOAD : String = "needLoad"; | |
private static const LOADING_STATE : String = "loading"; | |
private static var _instance : ResourceManager; | |
private static const WAITING_STATE : String = "waiting"; | |
private var picturesQueued : int = 0; | |
private var currentImageIndex : int; | |
private var state : String; | |
private var currentClipartIndex : int = 1342177279; | |
private var currentClipartDescriptor : ClipartDescriptor; | |
private var images : Array; | |
//========================= Methods | |
public static function ResourceManager() | |
{ | |
this.WAITING_STATE = "waiting"; | |
this.LOADING_STATE = "loading"; | |
this.IMAGE_NEED_LOAD = "needLoad"; | |
this.allowInstantiation = false; | |
return; | |
} | |
public function ResourceManager() | |
{ | |
this.images = []; | |
super(); | |
if(this.allowInstantiation) | |
{ | |
} | |
this.state = this.WAITING_STATE; | |
return; | |
} | |
public static Getter function instance() : ru.yandex.kraski.universalpainter.controller::ResourceManager | |
{ | |
if(this._instance) | |
{ | |
this.allowInstantiation = true; | |
this._instance = ; | |
this.allowInstantiation = false; | |
} | |
return this._instance; | |
} | |
public function queueClipart(arg0:ru.yandex.kraski.universalpainter.data::ClipartVO) | |
{ | |
var loc0:* = _model.clipartDescriptors; | |
var loc1:* = loc0.getDescriptorByBriefUrl(arg0.briefUrl); | |
if(loc1) | |
{ | |
loc0.createClipartDescriptor(_model.config.clipartURL, arg0); | |
} | |
return; | |
} | |
private function image_faultHandler(arg0:mx.rpc.events::FaultEvent) | |
{ | |
this.removeImageDownloadListeners(ILoadPictureService(arg0.target)); | |
error(arg0.toString()); | |
delete images.currentImageIndex; | |
var loc0:* = this; | |
var loc1:* = this.picturesQueued - 1; | |
loc0.picturesQueued = this.picturesQueued; | |
this.loadNextClipart(); | |
return; | |
} | |
public function queuePhotoframes() | |
{ | |
var loc0:* = _model.libraryClipartData.photoframesCategory; | |
var loc1:* = 0; | |
while(loc1 < loc0.categoryItems.length) | |
{ | |
this.queueClipart(loc0.categoryItems[loc1]); | |
loc1++; | |
} | |
return; | |
} | |
private function image_resultHandler(arg0:mx.rpc.events::ResultEvent) | |
{ | |
this.removeImageDownloadListeners(ILoadPictureService(arg0.target)); | |
this.images[currentImageIndex] = arg0.result; | |
var loc0:* = this; | |
var loc1:* = this.picturesQueued - 1; | |
loc0.picturesQueued = this.picturesQueued; | |
this.loadNextClipart(); | |
return; | |
} | |
private function clipart_loadErrorHandler(arg0:flash.events::IOErrorEvent) | |
{ | |
error("Clipart loading error. {0}", this.currentClipartDescriptor.fullURL); | |
this.loadNextClipart(); | |
return; | |
} | |
public function queueClipartsFromCategory(arg0:int) | |
{ | |
var loc0:* = _model.libraryClipartData.clipartsCategories[arg0]; | |
var loc1:* = 0; | |
while(loc1 < loc0.categoryItems.length) | |
{ | |
this.queueClipart(loc0.categoryItems[loc1]); | |
loc1++; | |
} | |
return; | |
} | |
private function loadNextClipart() | |
{ | |
if(this.currentClipartIndex == _model.clipartDescriptors.count - 1) | |
{ | |
if(this.picturesQueued > 0) | |
{ | |
this.loadNextImage(); | |
return; | |
} | |
this.state = this.WAITING_STATE; | |
debug("Loading complete, i'm waiting..."); | |
dispatchEvent(new ModelEvent(ModelEvent.CLIPARTS_LOAD_COMPLETE)); | |
return; | |
} | |
var loc1:* = this; | |
var loc2:* = this.currentClipartIndex + 1; | |
loc1.currentClipartIndex = this.currentClipartIndex; | |
this.currentClipartDescriptor = _model.clipartDescriptors.descriptorsList[currentClipartIndex]; | |
debug("begin loading clipart {0} (index: {1}) from url {2}", this.currentClipartDescriptor.className, this.currentClipartIndex, this.currentClipartDescriptor.fullURL); | |
var loc0:* = new Loader(); | |
addEventListener(Event.COMPLETE, this.clipart_loadCompleteHandler); | |
addEventListener(IOErrorEvent.IO_ERROR, this.clipart_loadErrorHandler); | |
addEventListener(IOErrorEvent.NETWORK_ERROR, this.clipart_loadErrorHandler); | |
addEventListener(IOErrorEvent.VERIFY_ERROR, this.clipart_loadErrorHandler); | |
addEventListener(ProgressEvent.PROGRESS, this.clipart_progressHandler); | |
loc0.load(new URLRequest(this.currentClipartDescriptor.fullURL), new LoaderContext(false, ApplicationDomain.currentDomain)); | |
this.state = this.LOADING_STATE; | |
return; | |
} | |
private function clipart_loadCompleteHandler(arg0:flash.events::Event) | |
{ | |
this.currentClipartDescriptor.fullURL = LoaderInfo(arg0.target).url; | |
this.currentClipartDescriptor.loaded = true; | |
debug("complete loading clipart {0} (index: {1})", this.currentClipartDescriptor.className, this.currentClipartIndex); | |
this.loadNextClipart(); | |
return; | |
} | |
public Setter function model(arg0:ru.yandex.kraski.universalpainter.data::Model) | |
{ | |
this = arg0; | |
register(); | |
return; | |
} | |
public function clearClipartsQueue() | |
{ | |
splice(this.currentClipartIndex + 1, _model.clipartDescriptors.count - this.currentClipartIndex - 1); | |
return; | |
} | |
private function removeImageDownloadListeners(arg0:ru.yandex.kraski.universalpainter.services::ILoadPictureService) | |
{ | |
arg0.removeEventListener(ResultEvent.RESULT, this.image_resultHandler); | |
arg0.removeEventListener(FaultEvent.FAULT, this.image_faultHandler); | |
return; | |
} | |
private function loadNextImage() | |
{ | |
var loc0:* = 0; | |
while(this.images[loc0] != this.IMAGE_NEED_LOAD) | |
{ | |
loc0++; | |
} | |
this.currentImageIndex = loc0; | |
var loc1:* = ServiceLocator.loadPictureService; | |
loc1.addEventListener(ResultEvent.RESULT, this.image_resultHandler); | |
loc1.addEventListener(FaultEvent.FAULT, this.image_faultHandler); | |
loc1.downloadPicture(this.currentImageIndex); | |
return; | |
} | |
public function loadQueuedResources() | |
{ | |
if(this.state == this.WAITING_STATE) | |
{ | |
this.loadNextClipart(); | |
} | |
return; | |
} | |
public function queuePicture(arg0:int) | |
{ | |
if(this.images[arg0]) | |
{ | |
info("Reloading image {0}", arg0); | |
} | |
this.images.IMAGE_NEED_LOAD = ; | |
var loc0:* = this; | |
var loc1:* = this.picturesQueued + 1; | |
loc0.picturesQueued = this.picturesQueued; | |
return; | |
} | |
private function clipart_progressHandler(arg0:flash.events::ProgressEvent) | |
{ | |
this.currentClipartDescriptor.bytesLoaded = arg0.bytesLoaded; | |
this.currentClipartDescriptor.bytesTotal = arg0.bytesTotal; | |
dispatchEvent(new ModelEvent(ModelEvent.CLIPART_LOAD_PROGRESS)); | |
return; | |
} | |
public function queueBackgrounds() | |
{ | |
var loc0:* = _model.libraryClipartData.backgroundsCategory; | |
var loc1:* = 0; | |
while(loc1 < loc0.categoryItems.length) | |
{ | |
this.queueClipart(loc0.categoryItems[loc1]); | |
loc1++; | |
} | |
return; | |
} | |
public function loadAllCliparts() | |
{ | |
var loc0:* = _model.libraryClipartData.clipartsCategories; | |
var loc1:* = 0; | |
while(loc1 < loc0.length) | |
{ | |
this.queueClipartsFromCategory(loc1); | |
loc1++; | |
} | |
return; | |
} | |
public function getPictureContent(arg0:int) : flash.display::Bitmap | |
{ | |
return (this.images[arg0]) as Bitmap; | |
} | |
} | |
public class PhotoframesLoadingController extends ru.yandex.kraski.universalpainter.controller::Controller | |
{ | |
//========================= Variables | |
private static var _instance : PhotoframesLoadingController; | |
private static var allowInstantiation : Boolean = False; | |
//========================= Methods | |
public static function PhotoframesLoadingController() | |
{ | |
this.allowInstantiation = false; | |
return; | |
} | |
public function PhotoframesLoadingController() | |
{ | |
super(); | |
if(this.allowInstantiation) | |
{ | |
} | |
return; | |
} | |
public static Getter function instance() : ru.yandex.kraski.universalpainter.controller::PhotoframesLoadingController | |
{ | |
if(this._instance) | |
{ | |
this.allowInstantiation = true; | |
this._instance = ; | |
this.allowInstantiation = false; | |
} | |
return this._instance; | |
} | |
private function photoframesCategory_completeHandler(arg0:flash.events::Event) | |
{ | |
removeEventListener(Event.COMPLETE, this.photoframesLibrary_completeHandler); | |
model.libraryClipartData.photoframesCategory.categoryXML = 0; | |
dispatchEvent(new ModelEvent(ModelEvent.PHOTOFRAMES_LOAD_COMPLETE)); | |
return; | |
} | |
private function photoframesLibrary_completeHandler(arg0:flash.events::Event) | |
{ | |
removeEventListener(Event.COMPLETE, this.photoframesLibrary_completeHandler); | |
var loc0:* = XML(arg0.target.data); | |
var loc1:* = new LibraryClipartCategory(loc0.name, loc0.path); | |
model.libraryClipartData.photoframesCategory = new LibraryClipartCategory(loc0.name, loc0.path); | |
var loc2:* = new URLLoader(); | |
addEventListener(Event.COMPLETE, this.photoframesCategory_completeHandler); | |
loc2.load(new URLRequest(model.config.clipartURL + "/" + loc1.url)); | |
return; | |
} | |
public function load() | |
{ | |
var loc0:* = new URLLoader(); | |
loc0.addEventListener(Event.COMPLETE, this.photoframesLibrary_completeHandler); | |
loc0.load(new URLRequest(model.config.photoframesLibraryURL)); | |
return; | |
} | |
} | |
public class LoadLibraryController extends ru.yandex.kraski.universalpainter.controller::Controller | |
{ | |
//========================= Variables | |
private static var _instance : LoadLibraryController; | |
private static var allowInstantiation : Boolean = False; | |
private var _data : Model; | |
private var currentCategoryIndex : int; | |
private var categories : Array; | |
//========================= Methods | |
public static function LoadLibraryController() | |
{ | |
this.allowInstantiation = false; | |
return; | |
} | |
public function LoadLibraryController() | |
{ | |
super(); | |
if(this.allowInstantiation) | |
{ | |
} | |
return; | |
} | |
public static Getter function instance() : ru.yandex.kraski.universalpainter.controller::LoadLibraryController | |
{ | |
if(this._instance) | |
{ | |
this.allowInstantiation = true; | |
this._instance = ; | |
this.allowInstantiation = false; | |
} | |
return this._instance; | |
} | |
private function libraryClipart_loadCompleteHandler(arg0:flash.events::Event) | |
{ | |
this._data.libraryClipartData.libraryXML = 0; | |
this.categories = this._data.libraryClipartData.clipartsCategories; | |
this.currentCategoryIndex = 0; | |
this.loadCategoryXML(this.categories.currentCategoryIndex); | |
return; | |
} | |
private function categoryXML_loadCompleteHandler(arg0:flash.events::Event) | |
{ | |
var loc0:* = this.categories.currentCategoryIndex; | |
loc0.categoryXML = 0; | |
var loc1:* = this; | |
var loc2:* = this.currentCategoryIndex + 1; | |
loc1.currentCategoryIndex = this.currentCategoryIndex; | |
if(this.currentCategoryIndex < this.categories.length) | |
{ | |
this.loadCategoryXML(this.categories.currentCategoryIndex); | |
} | |
else | |
{ | |
dispatchEvent(new ModelEvent(ModelEvent.LIBRARY_LOAD_COMPLETE)); | |
} | |
return; | |
} | |
public function load() | |
{ | |
var loc0:* = new URLLoader(); | |
loc0.addEventListener(Event.COMPLETE, this.libraryClipart_loadCompleteHandler); | |
debug("loadind library from url {0}", this._data.config.libraryClipartURL); | |
loc0.load(new URLRequest(this._data.config.libraryClipartURL)); | |
return; | |
} | |
public Setter function data(arg0:ru.yandex.kraski.universalpainter.data::Model) | |
{ | |
this._data = arg0; | |
register(); | |
return; | |
} | |
private function loadCategoryXML(arg0:ru.yandex.kraski.universalpainter.data::LibraryClipartCategory) | |
{ | |
var loc0:* = new URLLoader(); | |
loc0.addEventListener(Event.COMPLETE, this.categoryXML_loadCompleteHandler); | |
loc0.load(new URLRequest(this._data.config.clipartURL + "/" + arg0.url)); | |
return; | |
} | |
} | |
public class BackgroundsLoadingController extends ru.yandex.kraski.universalpainter.controller::Controller | |
{ | |
//========================= Variables | |
private static var _instance : BackgroundsLoadingController; | |
private static var allowInstantiation : Boolean = False; | |
//========================= Methods | |
public static function BackgroundsLoadingController() | |
{ | |
this.allowInstantiation = false; | |
return; | |
} | |
public function BackgroundsLoadingController() | |
{ | |
super(); | |
if(this.allowInstantiation) | |
{ | |
} | |
return; | |
} | |
public static Getter function instance() : ru.yandex.kraski.universalpainter.controller::BackgroundsLoadingController | |
{ | |
if(this._instance) | |
{ | |
this.allowInstantiation = true; | |
this._instance = ; | |
this.allowInstantiation = false; | |
} | |
return this._instance; | |
} | |
private function backgroundsLibrary_completeHandler(arg0:flash.events::Event) | |
{ | |
removeEventListener(Event.COMPLETE, this.backgroundsLibrary_completeHandler); | |
var loc0:* = XML(arg0.target.data); | |
var loc1:* = new LibraryClipartCategory(loc0.name, loc0.path); | |
model.libraryClipartData.backgroundsCategory = new LibraryClipartCategory(loc0.name, loc0.path); | |
var loc2:* = new URLLoader(); | |
addEventListener(Event.COMPLETE, this.backgroundsCategory_completeHandler); | |
loc2.load(new URLRequest(model.config.clipartURL + "/" + loc1.url)); | |
return; | |
} | |
private function backgroundsCategory_completeHandler(arg0:flash.events::Event) | |
{ | |
removeEventListener(Event.COMPLETE, this.backgroundsCategory_completeHandler); | |
model.libraryClipartData.backgroundsCategory.categoryXML = 0; | |
dispatchEvent(new ModelEvent(ModelEvent.BACKGROUNDS_LOAD_COMPLETE)); | |
return; | |
} | |
public function load() | |
{ | |
var loc0:* = new URLLoader(); | |
loc0.addEventListener(Event.COMPLETE, this.backgroundsLibrary_completeHandler); | |
loc0.load(new URLRequest(model.config.backgroundsLibraryURL)); | |
return; | |
} | |
} | |
public class Player extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
private var currentVisualIndex : int; | |
private var logger : ILogger; | |
private var _paintCanvas : PaintCanvas; | |
private var _card : Card; | |
private var background : Background; | |
private var visualList : Array; | |
//========================= Methods | |
public static function Player() | |
{ | |
return; | |
} | |
public function Player() | |
{ | |
this.logger = Log.getLogger("ru.yandex.kraski.universalpainter.controller.Player"); | |
super(); | |
return; | |
} | |
private function addAnimatedBackground() | |
{ | |
logger.debug("addAnimatedBackground()"); | |
paintCanvas.setBackground(this.background); | |
background.addEventListener(VisualEvent.PLAY_FINISH, this.backgroundFinishHandler); | |
background.showDrawingProcess(); | |
return; | |
} | |
public function stop() | |
{ | |
this.stopCard(); | |
return; | |
} | |
private function addAnimatedVisual(arg0:int) | |
{ | |
var loc0:* = Visual(this.visualList[arg0]); | |
loc0.addEventListener(VisualEvent.PLAY_FINISH, this.visualFinishHandler); | |
addVisual(loc0, loc0.depth); | |
debug("begin showing visual {0}", loc0); | |
loc0.showDrawingProcess(); | |
return; | |
} | |
private function stopPlayingVisuals() | |
{ | |
var loc1:* = null; | |
if(this.paintCanvas.background) | |
{ | |
removeEventListener(VisualEvent.PLAY_FINISH, this.backgroundFinishHandler); | |
showDrawingResult(); | |
} | |
var loc0:* = 0; | |
while(loc0 < this.paintCanvas.visualsContainer.numChildren) | |
{ | |
loc1 = Visual(getChildAt(loc0)); | |
loc1.removeEventListener(VisualEvent.PLAY_FINISH, this.visualFinishHandler); | |
loc1.showDrawingResult(); | |
loc0++; | |
} | |
return; | |
} | |
private function recreateVisuals() | |
{ | |
paintCanvas.setBackground(this.background); | |
if(this.background) | |
{ | |
this.background.animationEnabled = true; | |
} | |
var loc0:* = 0; | |
while(loc0 < this.visualList.length) | |
{ | |
Visual(this.visualList[loc0]).animationEnabled = true; | |
addVisual(Visual(this.visualList[loc0]), Visual(this.visualList[loc0]).depth); | |
loc0++; | |
} | |
return; | |
} | |
public Getter function paintCanvas() : ru.yandex.kraski.universalpainter.view::PaintCanvas | |
{ | |
return this._paintCanvas; | |
} | |
public Getter function card() : ru.yandex.kraski.universalpainter.data::Card | |
{ | |
return this._card; | |
} | |
private function playCard() | |
{ | |
logger.debug("playCard()"); | |
this.background = this.card.background; | |
this.visualList = concat(); | |
logger.debug("card visuals list: {0}", visualList.toString()); | |
visualList.sortOn("creationOrder", Array.NUMERIC); | |
this.cleanCard(); | |
this.currentVisualIndex = 0; | |
if(this.background) | |
{ | |
this.addAnimatedBackground(); | |
} | |
else | |
{ | |
this.startPlayingVisuals(); | |
} | |
return; | |
} | |
private function visualFinishHandler(arg0:ru.yandex.kraski.universalpainter.events::VisualEvent) | |
{ | |
removeEventListener(VisualEvent.PLAY_FINISH, this.visualFinishHandler); | |
var loc0:* = this; | |
var loc1:* = this.currentVisualIndex + 1; | |
loc0.currentVisualIndex = this.currentVisualIndex; | |
if(this.currentVisualIndex < this.visualList.length) | |
{ | |
this.addAnimatedVisual(this.currentVisualIndex); | |
} | |
else | |
{ | |
dispatchEvent(new PlayerEvent(PlayerEvent.PLAY_FINISNED)); | |
} | |
return; | |
} | |
private function startPlayingVisuals() | |
{ | |
if(this.visualList.length == 0) | |
{ | |
dispatchEvent(new PlayerEvent(PlayerEvent.PLAY_FINISNED)); | |
} | |
else | |
{ | |
this.addAnimatedVisual(this.currentVisualIndex); | |
} | |
return; | |
} | |
private function backgroundFinishHandler(arg0:ru.yandex.kraski.universalpainter.events::VisualEvent) | |
{ | |
background.removeEventListener(VisualEvent.PLAY_FINISH, this.backgroundFinishHandler); | |
this.startPlayingVisuals(); | |
return; | |
} | |
public Setter function paintCanvas(arg0:ru.yandex.kraski.universalpainter.view::PaintCanvas) | |
{ | |
this._paintCanvas = arg0; | |
return; | |
} | |
private function stopCard() | |
{ | |
this.currentVisualIndex = 0; | |
this.stopPlayingVisuals(); | |
this.cleanCard(); | |
this.recreateVisuals(); | |
return; | |
} | |
public function play() | |
{ | |
this.playCard(); | |
return; | |
} | |
public Setter function card(arg0:ru.yandex.kraski.universalpainter.data::Card) | |
{ | |
this._card = arg0; | |
return; | |
} | |
private function cleanCard() | |
{ | |
logger.debug("cleanCard()"); | |
paintCanvas.setBackground(null); | |
clean(); | |
return; | |
} | |
} | |
public class ContextMenuManager extends Object | |
{ | |
//========================= Methods | |
public static function ContextMenuManager() | |
{ | |
return; | |
} | |
public function ContextMenuManager() | |
{ | |
super(); | |
return; | |
} | |
public function addVersionToContextMenu(arg0:String) | |
{ | |
var loc0:* = new ContextMenu(); | |
loc0.hideBuiltInItems(); | |
var loc1:* = new ContextMenuItem(arg0 + " " + "1.1.2"); | |
push(loc1); | |
Application.application.contextMenu = new ContextMenu(); | |
return; | |
} | |
} | |
public class LoadConfigController extends ru.yandex.kraski.universalpainter.controller::Controller | |
{ | |
//========================= Variables | |
private static var _instance : LoadConfigController; | |
private static var allowInstantiation : Boolean = False; | |
private var _data : Config; | |
//========================= Methods | |
public static function LoadConfigController() | |
{ | |
this.allowInstantiation = false; | |
return; | |
} | |
public function LoadConfigController() | |
{ | |
super(); | |
if(this.allowInstantiation) | |
{ | |
} | |
return; | |
} | |
public static Getter function instance() : ru.yandex.kraski.universalpainter.controller::LoadConfigController | |
{ | |
if(this._instance) | |
{ | |
this.allowInstantiation = true; | |
this._instance = ; | |
this.allowInstantiation = false; | |
} | |
return this._instance; | |
} | |
public Setter function data(arg0:ru.yandex.kraski.universalpainter.data::Config) | |
{ | |
this._data = arg0; | |
register(); | |
return; | |
} | |
public function load() | |
{ | |
var loc0:* = ServiceLocator.loadConfigService; | |
loc0.addEventListener(ResultEvent.RESULT, this.resultHandler); | |
loc0.addEventListener(FaultEvent.FAULT, this.faultHandler); | |
loc0.load(); | |
return; | |
} | |
private function faultHandler(arg0:mx.rpc.events::FaultEvent) | |
{ | |
this.removeServiceListeners(ILoadConfigService(arg0.target)); | |
error(arg0.toString()); | |
return; | |
} | |
private function resultHandler(arg0:mx.rpc.events::ResultEvent) | |
{ | |
this.removeServiceListeners(ILoadConfigService(arg0.target)); | |
_data.parseXML(XML(arg0.result)); | |
return; | |
} | |
private function removeServiceListeners(arg0:ru.yandex.kraski.universalpainter.services::ILoadConfigService) | |
{ | |
arg0.removeEventListener(ResultEvent.RESULT, this.resultHandler); | |
arg0.removeEventListener(FaultEvent.FAULT, this.faultHandler); | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.events | |
{ | |
public class PlayerEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const PLAY_FINISNED : String = "playFinished"; | |
//========================= Methods | |
public static function PlayerEvent() | |
{ | |
this.PLAY_FINISNED = "playFinished"; | |
return; | |
} | |
public function PlayerEvent(arg0:String, arg1:Boolean = false, arg2:Boolean = false) | |
{ | |
super(arg0, arg1, arg2); | |
return; | |
} | |
} | |
public class ModelEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const PHOTOFRAME_CHANGE : String = "photoframeChange"; | |
public static const TEXT_COLOR_CHANGE : String = "textColorChange"; | |
public static const VISUAL_CHANGE : String = "visualChange"; | |
public static const BACKGROUNDS_LOAD_COMPLETE : String = "backgroundsLoadComplete"; | |
public static const CLIPART_LOAD_PROGRESS : String = "clipartsLoadPrtogress"; | |
public static const BACKGROUND_COLOR_CHANGE : String = "backgroundColorChange"; | |
public static const XML_LOAD_COMPLETE : String = "xmlLoadComplete"; | |
public static const PHOTOFRAMES_LOAD_COMPLETE : String = "photoframesLoadComplete"; | |
public static const PAINT_SIZE_CHANGE : String = "paintSizeChange"; | |
public static const BRUSH_COLOR_CHANGE : String = "brushColorChange"; | |
public static const CLIPARTS_LOAD_COMPLETE : String = "clipartsLoadComplete"; | |
public static const CARD_CLEAR : String = "cardClear"; | |
public static const CARD_CHANGE : String = "cardChange"; | |
public static const CURRENT_FONT_CHANGE : String = "currentFontChange"; | |
public static const ACTIVE_COLOR_CHANGE : String = "activeColorChange"; | |
public static const CHANGE_TOOL : String = "changeTool"; | |
public static const LIBRARY_LOAD_COMPLETE : String = "libraryLoadComplete"; | |
public static const PAINT_CLASS_CHANGE : String = "paintClassChange"; | |
public static const VISUAL_SELECT : String = "visualSelect"; | |
public static const CARD_FULL : String = "cardFull"; | |
public static const BACKGROUND_CHANGE : String = "backgroundChange"; | |
public static const VISUAL_REMOVE : String = "visualRemove"; | |
public static const CARD_WEIGHT_CHANGE : String = "cardWeightChange"; | |
public static const STROKE_POINT_APPEND : String = "strokePointAppend"; | |
public static const XML_PARSE_ERROR : String = "xmlParseError"; | |
public static const CLIPART_COLOR_CHANGE : String = "clipartColorChange"; | |
public static const VISUAL_APPEND : String = "visualAppend"; | |
public var visual : Visual; | |
public var index : int; | |
public var message : String = ""; | |
public var result : String = ""; | |
//========================= Methods | |
public static function ModelEvent() | |
{ | |
this.XML_LOAD_COMPLETE = "xmlLoadComplete"; | |
this.XML_PARSE_ERROR = "xmlParseError"; | |
this.CLIPARTS_LOAD_COMPLETE = "clipartsLoadComplete"; | |
this.CLIPART_LOAD_PROGRESS = "clipartsLoadPrtogress"; | |
this.LIBRARY_LOAD_COMPLETE = "libraryLoadComplete"; | |
this.BACKGROUNDS_LOAD_COMPLETE = "backgroundsLoadComplete"; | |
this.PHOTOFRAMES_LOAD_COMPLETE = "photoframesLoadComplete"; | |
this.VISUAL_APPEND = "visualAppend"; | |
this.VISUAL_CHANGE = "visualChange"; | |
this.VISUAL_REMOVE = "visualRemove"; | |
this.BACKGROUND_CHANGE = "backgroundChange"; | |
this.PHOTOFRAME_CHANGE = "photoframeChange"; | |
this.STROKE_POINT_APPEND = "strokePointAppend"; | |
this.CHANGE_TOOL = "changeTool"; | |
this.CARD_CLEAR = "cardClear"; | |
this.CARD_CHANGE = "cardChange"; | |
this.CARD_WEIGHT_CHANGE = "cardWeightChange"; | |
this.CARD_FULL = "cardFull"; | |
this.PAINT_SIZE_CHANGE = "paintSizeChange"; | |
this.PAINT_CLASS_CHANGE = "paintClassChange"; | |
this.VISUAL_SELECT = "visualSelect"; | |
this.CURRENT_FONT_CHANGE = "currentFontChange"; | |
this.ACTIVE_COLOR_CHANGE = "activeColorChange"; | |
this.BACKGROUND_COLOR_CHANGE = "backgroundColorChange"; | |
this.BRUSH_COLOR_CHANGE = "brushColorChange"; | |
this.CLIPART_COLOR_CHANGE = "clipartColorChange"; | |
this.TEXT_COLOR_CHANGE = "textColorChange"; | |
return; | |
} | |
public function ModelEvent(arg0:String, arg1:Boolean = false, arg2:Boolean = false) | |
{ | |
super(arg0, arg1, arg2); | |
return; | |
} | |
} | |
public class ControllerEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const REGISTER : String = "register"; | |
public static const UNREGISTER : String = "unregister"; | |
//========================= Methods | |
public static function ControllerEvent() | |
{ | |
this.REGISTER = "register"; | |
this.UNREGISTER = "unregister"; | |
return; | |
} | |
public function ControllerEvent(arg0:String, arg1:Boolean = false, arg2:Boolean = false) | |
{ | |
super(arg0, arg1, arg2); | |
return; | |
} | |
} | |
public class SwapVisualDepthEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const SWAP_DEPTH : String = "swapDepth"; | |
public var visual : Visual; | |
public var newDepth : int; | |
public var oldDepth : int; | |
//========================= Methods | |
public static function SwapVisualDepthEvent() | |
{ | |
this.SWAP_DEPTH = "swapDepth"; | |
return; | |
} | |
public function SwapVisualDepthEvent(arg0:String, arg1:ru.yandex.kraski.universalpainter.visual::Visual, arg2:int, arg3:int, arg4:Boolean = false, arg5:Boolean = false) | |
{ | |
super(arg0, arg4, arg5); | |
this.visual = arg1; | |
this.oldDepth = arg2; | |
this.newDepth = arg3; | |
return; | |
} | |
public function clone() : flash.events::Event | |
{ | |
return new SwapVisualDepthEvent(type, this.visual, this.oldDepth, this.newDepth, bubbles, cancelable); | |
} | |
} | |
public class LineEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const ADD_POINT : String = "addPoint"; | |
public static const FINISH : String = "finish"; | |
public static const FILL : String = "fill"; | |
public var x : Number; | |
public var y : Number; | |
//========================= Methods | |
public static function LineEvent() | |
{ | |
this.ADD_POINT = "addPoint"; | |
this.FINISH = "finish"; | |
this.FILL = "fill"; | |
return; | |
} | |
public function LineEvent(arg0:String, arg1:Boolean = false, arg2:Boolean = false) | |
{ | |
super(arg0, arg1, arg2); | |
return; | |
} | |
public function clone() : flash.events::Event | |
{ | |
return new LineEvent(type, bubbles, cancelable); | |
} | |
} | |
public class VisualEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const GEOM_CHANGE : String = "geomChange"; | |
public static const CREATION_COMPLETE : String = "creationComplete"; | |
public static const DESERIALIZING_COMPLETE : String = "deserializingComplete"; | |
public static const PLAY_FINISH : String = "playFinish"; | |
//========================= Methods | |
public static function VisualEvent() | |
{ | |
this.GEOM_CHANGE = "geomChange"; | |
this.PLAY_FINISH = "playFinish"; | |
this.CREATION_COMPLETE = "creationComplete"; | |
this.DESERIALIZING_COMPLETE = "deserializingComplete"; | |
return; | |
} | |
public function VisualEvent(arg0:String, arg1:Boolean = false, arg2:Boolean = false) | |
{ | |
super(arg0, arg1, arg2); | |
return; | |
} | |
public function clone() : flash.events::Event | |
{ | |
return new VisualEvent(type, bubbles, cancelable); | |
} | |
} | |
public class PhotoframeEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const UPLOAD_PHOTO : String = "uploadPhoto"; | |
public var container : MovieClip; | |
public var button : MovieClip; | |
//========================= Methods | |
public static function PhotoframeEvent() | |
{ | |
this.UPLOAD_PHOTO = "uploadPhoto"; | |
return; | |
} | |
public function PhotoframeEvent(arg0:String, arg1:flash.display::MovieClip, arg2:flash.display::MovieClip, arg3:Boolean = false, arg4:Boolean = false) | |
{ | |
super(arg0, arg3, arg4); | |
this.container = arg1; | |
this.button = arg2; | |
return; | |
} | |
} | |
public class PhotoframePictureEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const SELECT_PHOTO : String = "selectPhoto"; | |
public var photo : PhotoframePicture; | |
//========================= Methods | |
public static function PhotoframePictureEvent() | |
{ | |
this.SELECT_PHOTO = "selectPhoto"; | |
return; | |
} | |
public function PhotoframePictureEvent(arg0:String, arg1:ru.yandex.kraski.universalpainter.visual::PhotoframePicture = null, arg2:Boolean = false, arg3:Boolean = false) | |
{ | |
super(arg0, arg2, arg3); | |
this.photo = arg1; | |
return; | |
} | |
} | |
public class LibraryAssetEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const INTRO_FINISH : String = "introFinish"; | |
//========================= Methods | |
public static function LibraryAssetEvent() | |
{ | |
this.INTRO_FINISH = "introFinish"; | |
return; | |
} | |
public function LibraryAssetEvent(arg0:String, arg1:Boolean = false, arg2:Boolean = false) | |
{ | |
super(arg0, arg1, arg2); | |
return; | |
} | |
} | |
public class TextEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const TEXT_CHANGE : String = "textChange"; | |
public static const TEXT_CHANGING : String = "textChanging"; | |
public var oldText : String; | |
public var newText : String; | |
//========================= Methods | |
public static function TextEvent() | |
{ | |
this.TEXT_CHANGE = "textChange"; | |
this.TEXT_CHANGING = "textChanging"; | |
return; | |
} | |
public function TextEvent(arg0:String, arg1:Boolean = false, arg2:Boolean = false) | |
{ | |
super(arg0, arg1, arg2); | |
return; | |
} | |
public function clone() : flash.events::Event | |
{ | |
var loc0:* = new TextEvent(type, bubbles, cancelable); | |
loc0.oldText = ; | |
loc0.newText = ; | |
return loc0; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.paints | |
{ | |
public class PaintType extends Object implements {flash.events}::IEventDispatcher | |
{ | |
//========================= Variables | |
private static var _268885634SNOW_PAINT : Class; | |
private static var _1223207963PENTA_PAINT : Class; | |
private static var _141578861SMOOTH_PAINT : Class; | |
private static var _staticBindingEventDispatcher : EventDispatcher; | |
private static var _1513347355HEART_PAINT : Class; | |
private static var _1746188835RECT_PAINT : Class; | |
private static var _1748840007SPRAYER_PAINT : Class; | |
private static var _2145674SOLID_PAINT : Class; | |
private static var _1401527974FLOWER_PAINT : Class; | |
private static var _10424734RUNNING_PAINT : Class; | |
private var _bindingEventDispatcher : EventDispatcher; | |
//========================= Methods | |
public static function PaintType() | |
{ | |
this._2145674SOLID_PAINT = SolidPaint; | |
this._141578861SMOOTH_PAINT = SmoothPaint; | |
this._10424734RUNNING_PAINT = RunningPaint; | |
this._1748840007SPRAYER_PAINT = SprayerPaint; | |
this._1513347355HEART_PAINT = HeartPaint; | |
this._1746188835RECT_PAINT = RectPaint; | |
this._1401527974FLOWER_PAINT = FlowerPaint; | |
this._1223207963PENTA_PAINT = PentaPaint; | |
this._268885634SNOW_PAINT = SnowPaint; | |
this._staticBindingEventDispatcher = new EventDispatcher(); | |
return; | |
} | |
public function PaintType() | |
{ | |
this._bindingEventDispatcher = new EventDispatcher(IEventDispatcher(this)); | |
super(); | |
return; | |
} | |
public static Getter function SNOW_PAINT() : Class | |
{ | |
return PaintType._268885634SNOW_PAINT; | |
} | |
public static Setter function SNOW_PAINT(arg0:Class) | |
{ | |
var loc1:* = null; | |
var loc0:* = PaintType._268885634SNOW_PAINT; | |
if(loc0 !== arg0) | |
{ | |
PaintType._268885634SNOW_PAINT = ; | |
loc1 = PaintType.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(PaintType, "SNOW_PAINT", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Getter function SOLID_PAINT() : Class | |
{ | |
return PaintType._2145674SOLID_PAINT; | |
} | |
public static Setter function RECT_PAINT(arg0:Class) | |
{ | |
var loc1:* = null; | |
var loc0:* = PaintType._1746188835RECT_PAINT; | |
if(loc0 !== arg0) | |
{ | |
PaintType._1746188835RECT_PAINT = ; | |
loc1 = PaintType.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(PaintType, "RECT_PAINT", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Getter function SPRAYER_PAINT() : Class | |
{ | |
return PaintType._1748840007SPRAYER_PAINT; | |
} | |
public static Getter function staticEventDispatcher() : flash.events::IEventDispatcher | |
{ | |
return this._staticBindingEventDispatcher; | |
} | |
public static Setter function HEART_PAINT(arg0:Class) | |
{ | |
var loc1:* = null; | |
var loc0:* = PaintType._1513347355HEART_PAINT; | |
if(loc0 !== arg0) | |
{ | |
PaintType._1513347355HEART_PAINT = ; | |
loc1 = PaintType.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(PaintType, "HEART_PAINT", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Setter function SMOOTH_PAINT(arg0:Class) | |
{ | |
var loc1:* = null; | |
var loc0:* = PaintType._141578861SMOOTH_PAINT; | |
if(loc0 !== arg0) | |
{ | |
PaintType._141578861SMOOTH_PAINT = ; | |
loc1 = PaintType.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(PaintType, "SMOOTH_PAINT", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Setter function SOLID_PAINT(arg0:Class) | |
{ | |
var loc1:* = null; | |
var loc0:* = PaintType._2145674SOLID_PAINT; | |
if(loc0 !== arg0) | |
{ | |
PaintType._2145674SOLID_PAINT = ; | |
loc1 = PaintType.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(PaintType, "SOLID_PAINT", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Getter function RUNNING_PAINT() : Class | |
{ | |
return PaintType._10424734RUNNING_PAINT; | |
} | |
public static Setter function SPRAYER_PAINT(arg0:Class) | |
{ | |
var loc1:* = null; | |
var loc0:* = PaintType._1748840007SPRAYER_PAINT; | |
if(loc0 !== arg0) | |
{ | |
PaintType._1748840007SPRAYER_PAINT = ; | |
loc1 = PaintType.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(PaintType, "SPRAYER_PAINT", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Getter function HEART_PAINT() : Class | |
{ | |
return PaintType._1513347355HEART_PAINT; | |
} | |
public static Getter function FLOWER_PAINT() : Class | |
{ | |
return PaintType._1401527974FLOWER_PAINT; | |
} | |
public static Getter function RECT_PAINT() : Class | |
{ | |
return PaintType._1746188835RECT_PAINT; | |
} | |
public static Getter function SMOOTH_PAINT() : Class | |
{ | |
return PaintType._141578861SMOOTH_PAINT; | |
} | |
public static Setter function PENTA_PAINT(arg0:Class) | |
{ | |
var loc1:* = null; | |
var loc0:* = PaintType._1223207963PENTA_PAINT; | |
if(loc0 !== arg0) | |
{ | |
PaintType._1223207963PENTA_PAINT = ; | |
loc1 = PaintType.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(PaintType, "PENTA_PAINT", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Setter function FLOWER_PAINT(arg0:Class) | |
{ | |
var loc1:* = null; | |
var loc0:* = PaintType._1401527974FLOWER_PAINT; | |
if(loc0 !== arg0) | |
{ | |
PaintType._1401527974FLOWER_PAINT = ; | |
loc1 = PaintType.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(PaintType, "FLOWER_PAINT", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Setter function RUNNING_PAINT(arg0:Class) | |
{ | |
var loc1:* = null; | |
var loc0:* = PaintType._10424734RUNNING_PAINT; | |
if(loc0 !== arg0) | |
{ | |
PaintType._10424734RUNNING_PAINT = ; | |
loc1 = PaintType.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(PaintType, "RUNNING_PAINT", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Getter function PENTA_PAINT() : Class | |
{ | |
return PaintType._1223207963PENTA_PAINT; | |
} | |
public function dispatchEvent(arg0:flash.events::Event) : Boolean | |
{ | |
return _bindingEventDispatcher.dispatchEvent(arg0); | |
} | |
public function hasEventListener(arg0:String) : Boolean | |
{ | |
return _bindingEventDispatcher.hasEventListener(arg0); | |
} | |
public function willTrigger(arg0:String) : Boolean | |
{ | |
return _bindingEventDispatcher.willTrigger(arg0); | |
} | |
public function addEventListener(arg0:String, arg1:Function, arg2:Boolean = false, arg3:int = 0, arg4:Boolean = false) | |
{ | |
_bindingEventDispatcher.addEventListener(arg0, arg1, arg2, arg3, arg4); | |
return; | |
} | |
public function removeEventListener(arg0:String, arg1:Function, arg2:Boolean = false) | |
{ | |
_bindingEventDispatcher.removeEventListener(arg0, arg1, arg2); | |
return; | |
} | |
} | |
public class Paint extends Object | |
{ | |
//========================= Variables | |
public var size : Number; | |
private var _width : Number = 0; | |
private var _height : Number = 0; | |
public var color : uint; | |
private var _className : String; | |
public var _pointWeight : Number = 0; | |
public var points : Array; | |
public var _context : Sprite; | |
//========================= Methods | |
public static function Paint() | |
{ | |
return; | |
} | |
public function Paint(arg0:uint, arg1:Number) | |
{ | |
this.points = []; | |
super(); | |
this.color = arg0; | |
this.size = arg1; | |
this._pointWeight = PaintsWeight.DEFAULT_PAINT_WEIGHT; | |
return; | |
} | |
public function fill(arg0:flash.display::Sprite) | |
{ | |
this.context = ; | |
return; | |
} | |
public function finish() | |
{ | |
return; | |
} | |
public function clear(arg0:flash.display::Sprite) | |
{ | |
clear(); | |
DisplayUtil.removeAllChildren(arg0); | |
return; | |
} | |
public function appendPoint(arg0:flash.display::Sprite, arg1:Number, arg2:Number) | |
{ | |
this.context = ; | |
points.push({"x" : arg1, "y" : arg2}); | |
return; | |
} | |
public function resumeAnimation() | |
{ | |
return; | |
} | |
public Setter function width(arg0:Number) | |
{ | |
this._width = arg0; | |
return; | |
} | |
public Setter function height(arg0:Number) | |
{ | |
this._height = arg0; | |
return; | |
} | |
public Getter function xml() : XML | |
{ | |
return new XML("<paint type=\"" + Escape(this.className) + "\" color=\"" + Escape(toString(16)) + "\" size=\"" + Escape(this.size) + "\"/>"); | |
} | |
public Setter function context(arg0:flash.display::Sprite) | |
{ | |
if(this._context != arg0) | |
{ | |
this.setNewContext(arg0); | |
} | |
return; | |
} | |
public Getter function height() : Number | |
{ | |
return this._height; | |
} | |
public Getter function width() : Number | |
{ | |
return this._width; | |
} | |
public function pauseAnimation() | |
{ | |
return; | |
} | |
public Getter function pointWeight() : Number | |
{ | |
return this._pointWeight; | |
} | |
public function setNewContext(arg0:flash.display::Sprite) | |
{ | |
debug("change context"); | |
this._context = arg0; | |
return; | |
} | |
public Getter function className() : String | |
{ | |
if(this._className) | |
{ | |
this._className = join("."); | |
} | |
return this._className; | |
} | |
public Getter function distance() : Number | |
{ | |
return Math.sqrt(this.size) * 10; | |
} | |
public Getter function context() : flash.display::Sprite | |
{ | |
return this._context; | |
} | |
} | |
public class PaintsWeight extends Object | |
{ | |
//========================= Variables | |
public static var ART_PAINT_WEIGHT : Number = 1,5; | |
public static var SPRAYER_PAINT_WEIGHT : Number = 4; | |
public static var DEFAULT_PAINT_WEIGHT : Number = 0,4; | |
public static var SNOW_PAINT_WEIGHT : Number = 4; | |
public static var FLOWER_PAINT_WEIGHT : Number = 0,8; | |
//========================= Methods | |
public static function PaintsWeight() | |
{ | |
this.DEFAULT_PAINT_WEIGHT = 0,4; | |
this.FLOWER_PAINT_WEIGHT = 0,8; | |
this.ART_PAINT_WEIGHT = 1,5; | |
this.SNOW_PAINT_WEIGHT = 4; | |
this.SPRAYER_PAINT_WEIGHT = 4; | |
return; | |
} | |
public function PaintsWeight() | |
{ | |
super(); | |
return; | |
} | |
} | |
} | |
package ru.yandex.lib.logger | |
{ | |
public class Logger extends flash.display::Sprite | |
{ | |
//========================= Variables | |
private static const OPEN_PASSWORD : String = "iddqd"; | |
private var passwordTimer : Timer; | |
private var _target : ConsoleTarget; | |
private var console : Console; | |
private var password : String = ""; | |
//========================= Methods | |
public static function Logger() | |
{ | |
this.OPEN_PASSWORD = "iddqd"; | |
return; | |
} | |
public function Logger() | |
{ | |
this.passwordTimer = new Timer(1000); | |
super(); | |
this.mouseEnabled = false; | |
this.console = new Console(); | |
addChild(this.console); | |
this._target = new ConsoleTarget(this.console); | |
addEventListener(Event.ADDED_TO_STAGE, this.addedToStageHandler); | |
return; | |
} | |
private function addedToStageHandler(arg0:flash.events::Event) | |
{ | |
stage.addEventListener(Event.RESIZE, this.stage_resiseHandler); | |
stage.addEventListener(KeyboardEvent.KEY_DOWN, this.keyDownHandler); | |
passwordTimer.addEventListener(TimerEvent.TIMER, this.password_timerHandler); | |
passwordTimer.start(); | |
return; | |
} | |
private function password_timerHandler(arg0:flash.events::TimerEvent) | |
{ | |
this.password = ""; | |
return; | |
} | |
private function stage_resiseHandler(arg0:flash.events::Event) | |
{ | |
console.setSize(); | |
return; | |
} | |
public Getter function target() : ru.yandex.lib.logger.target::LineFormattedTarget | |
{ | |
return this._target; | |
} | |
private function keyDownHandler(arg0:flash.events::KeyboardEvent) | |
{ | |
passwordTimer.stop(); | |
passwordTimer.start(); | |
var loc0:* = String.fromCharCode(arg0.charCode); | |
this.password = this.password + loc0; | |
if(this.password == this.OPEN_PASSWORD) | |
{ | |
this.console.visible = true; | |
this.password = ""; | |
} | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.data | |
{ | |
public class Card extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
public static const MAX_WEIGHT : int = 1000; | |
private var _isCardXMLActual : Boolean = True; | |
public var picturesTotal : int = 0; | |
private var logger : ILogger; | |
private var _weight : Number = 0; | |
private var _photoframe : Photoframe; | |
private var _cardXML : XML; | |
private var _modified : Boolean = False; | |
private var _visualsList : Array; | |
private var _background : Background; | |
private var _empty : Boolean = True; | |
private var _currentLine : Line; | |
private var _hash : String; | |
//========================= Methods | |
public static function Card() | |
{ | |
this.MAX_WEIGHT = 1000; | |
return; | |
} | |
public function Card(arg0:ru.yandex.kraski.universalpainter.data::ClipartDescriptorsList) | |
{ | |
this.logger = Log.getLogger("ru.yandex.kraski.universalpainter.data.Card"); | |
this._visualsList = []; | |
this._cardXML = new XML("<card v=\"1.0\"/>"); | |
super(); | |
return; | |
} | |
public static function fromXML(arg0:ru.yandex.kraski.universalpainter.data::ClipartDescriptorsList, arg1:XML = null) : ru.yandex.kraski.universalpainter.data::Card | |
{ | |
var loc2:* = null; | |
var loc3:* = null; | |
var loc4:* = null; | |
var loc5:* = null; | |
var loc6:* = null; | |
var loc0:* = new this(arg0); | |
if(arg1) | |
{ | |
return loc0; | |
} | |
loc0.picturesTotal = 0; | |
var loc1:* = new VisualFactory(arg0); | |
var loc7:* = 0; | |
var loc8:* = arg1.background; | |
for(loc7 in loc8) | |
{ | |
loc2 = loc8.__getNextEnumerablePropertyValue(); | |
loc4 = arg0.getDescriptorByBriefUrl(loc2.resource.src); | |
loc5 = new Background(loc4); | |
deserialize(loc2); | |
loc0.addBackground(loc5); | |
} | |
loc7 = 0; | |
loc8 = arg1.visual; | |
for(loc7 in loc8) | |
{ | |
loc3 = loc8.__getNextEnumerablePropertyValue(); | |
loc6 = loc1.create(loc3); | |
loc0.addElement(loc6); | |
if(loc6 is Photoframe) | |
{ | |
hideUploadButtons(); | |
Photoframe(loc6).mouseChildren = false; | |
Photoframe(loc6).mouseEnabled = false; | |
} | |
} | |
loc0._isCardXMLActual = false; | |
loc0.modified = false; | |
return loc0; | |
} | |
private Setter function _615513399modified(arg0:Boolean) | |
{ | |
this._modified = arg0; | |
return; | |
} | |
private Setter function _2058039875isEmpty(arg0:Boolean) | |
{ | |
if(arg0) | |
{ | |
if((! || this.visualsList.length > 0)) | |
{ | |
} | |
} | |
else | |
{ | |
if(this._background == null && this.visualsList.length == 0) | |
{ | |
} | |
} | |
this._isCardXMLActual = this._isCardXMLActual && this._empty == arg0; | |
this._empty = arg0; | |
return; | |
} | |
private function swapItemsInArray(arg0:Array, arg1:int, arg2:int) | |
{ | |
if(arg2 >= arg0.length) | |
{ | |
return; | |
} | |
var loc0:* = arg0.concat(); | |
var loc1:* = arg0.concat()[arg1]; | |
arg0[arg1] = loc0[arg2]; | |
arg0.loc1 = ; | |
this.updateDepths(); | |
return; | |
} | |
public function swapVisualListElements(arg0:ru.yandex.kraski.universalpainter.visual::Visual, arg1:int, arg2:int) | |
{ | |
this.swapItemsInArray(this.visualsList, arg1, arg2); | |
this._isCardXMLActual = false; | |
this.modified = true; | |
dispatchEvent(new SwapVisualDepthEvent(SwapVisualDepthEvent.SWAP_DEPTH, arg0, arg1, arg2)); | |
return; | |
} | |
public Setter function isEmpty(arg0:Boolean) | |
{ | |
var loc0:* = this.isEmpty; | |
if(loc0 !== arg0) | |
{ | |
this._2058039875isEmpty = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "isEmpty", loc0, arg0)); | |
} | |
return; | |
} | |
public Getter function hash() : String | |
{ | |
return this._hash; | |
} | |
public Setter function modified(arg0:Boolean) | |
{ | |
var loc0:* = this.modified; | |
if(loc0 !== arg0) | |
{ | |
this._615513399modified = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "modified", loc0, arg0)); | |
} | |
return; | |
} | |
public function addElement(arg0:ru.yandex.kraski.universalpainter.visual::Visual, arg1:int = 1342177279) | |
{ | |
logger.debug("adding element: {0}", arg0); | |
var loc0:* = ( (arg1 == 255)? this._visualsList.length : arg1 ); | |
arg0.creationOrder = this.visualsList.length; | |
arg0.depth = ; | |
_visualsList.splice(loc0, 0, arg0); | |
if(arg0 is Photoframe) | |
{ | |
this._photoframe = (arg0) as Photoframe; | |
} | |
if(arg0 is Line) | |
{ | |
this._currentLine = (arg0) as Line; | |
addEventListener(LineEvent.ADD_POINT, this.validateWeight, false, 0, true); | |
} | |
this.updateCardStatus(); | |
this.validateWeight(); | |
this._isCardXMLActual = false; | |
this.modified = true; | |
var loc1:* = new ModelEvent(ModelEvent.VISUAL_APPEND); | |
new ModelEvent(ModelEvent.VISUAL_APPEND).visual = ; | |
loc1.index = ; | |
dispatchEvent(loc1); | |
return; | |
} | |
public Setter function hash(arg0:String) | |
{ | |
if(this._hash) | |
{ | |
} | |
debug("card hash={0}", arg0); | |
this._hash = arg0; | |
return; | |
} | |
private function generateCardXML() | |
{ | |
logger.debug("generating card xml..."); | |
this.deleteCardXMLNodes(); | |
if(this._background) | |
{ | |
_cardXML.appendChild(_background.serialize()); | |
} | |
i = 0; | |
while(i < this._visualsList.length) | |
{ | |
try { | |
_cardXML.appendChild(serialize()); | |
} catch (e:flash.errors::ScriptTimeoutError) { | |
var loc1:* = e; | |
i = null; | |
i = i - 1; | |
} | |
i = i + 1; | |
} | |
this._cardXML.picturesTotal = 0; | |
this._isCardXMLActual = true; | |
return; | |
} | |
public function validateWeight(arg0:flash.events::Event = null) | |
{ | |
var loc0:* = 0; | |
if(this.background) | |
{ | |
loc0 = loc0 + this.background.weight; | |
} | |
var loc1:* = 0; | |
while(loc1 < this.visualsTotal) | |
{ | |
loc0 = loc0 + Visual(this._visualsList[loc1]).weight; | |
loc1++; | |
} | |
this.weight = loc0; | |
return; | |
} | |
public function addBackground(arg0:ru.yandex.kraski.universalpainter.visual::Background) | |
{ | |
this._background = arg0; | |
this.updateCardStatus(); | |
this.validateWeight(); | |
this._isCardXMLActual = false; | |
this.modified = true; | |
var loc0:* = new ModelEvent(ModelEvent.BACKGROUND_CHANGE); | |
loc0.visual = ; | |
dispatchEvent(loc0); | |
return; | |
} | |
public Getter function background() : ru.yandex.kraski.universalpainter.visual::Background | |
{ | |
return this._background; | |
} | |
private function updateDepths() | |
{ | |
var loc0:* = 0; | |
while(loc0 < this.visualsList.length) | |
{ | |
Visual(this.visualsList[loc0]).depth = 0; | |
loc0++; | |
} | |
return; | |
} | |
public Getter function isEmpty() : Boolean | |
{ | |
return this._empty; | |
} | |
public Getter function modified() : Boolean | |
{ | |
return this._modified; | |
} | |
private function updateCardStatus() | |
{ | |
this.isEmpty = this._background == null && this.visualsList.length == 0; | |
return; | |
} | |
public Getter function visualsTotal() : int | |
{ | |
return this._visualsList.length; | |
} | |
public function clear() | |
{ | |
this._visualsList = []; | |
this._background = null; | |
this._photoframe = null; | |
this.updateCardStatus(); | |
this.validateWeight(); | |
this._isCardXMLActual = false; | |
this.modified = true; | |
dispatchEvent(new ModelEvent(ModelEvent.CARD_CLEAR)); | |
return; | |
} | |
public function removeElement(arg0:ru.yandex.kraski.universalpainter.visual::Visual) | |
{ | |
var loc0:* = _visualsList.indexOf(arg0); | |
var loc1:* = new ModelEvent(ModelEvent.VISUAL_REMOVE); | |
loc1.visual = this._visualsList[loc0]; | |
_visualsList.splice(loc0, 1); | |
if(arg0 is Photoframe) | |
{ | |
this._photoframe = null; | |
} | |
this.updateCardStatus(); | |
this.validateWeight(); | |
this._isCardXMLActual = false; | |
this.modified = true; | |
dispatchEvent(loc1); | |
return; | |
} | |
private function deleteCardXMLNodes() | |
{ | |
delete _cardXML.visual; | |
delete _cardXML.background; | |
return; | |
} | |
public Setter function cardXML(arg0:XML) | |
{ | |
} | |
public Getter function cardXML() : XML | |
{ | |
this.generateCardXML(); | |
return this._cardXML; | |
} | |
public Setter function weight(arg0:Number) | |
{ | |
this._weight = arg0; | |
if(this._weight >= this.MAX_WEIGHT) | |
{ | |
dispatchEvent(new ModelEvent(ModelEvent.CARD_FULL)); | |
} | |
else | |
{ | |
dispatchEvent(new ModelEvent(ModelEvent.CARD_WEIGHT_CHANGE)); | |
} | |
return; | |
} | |
public Getter function visualsList() : Array | |
{ | |
return this._visualsList; | |
} | |
public Getter function weight() : Number | |
{ | |
return this._weight; | |
} | |
public function destroy() | |
{ | |
var loc0:* = 0; | |
while(loc0 < this._visualsList.length) | |
{ | |
destroy(); | |
loc0++; | |
} | |
this._visualsList = null; | |
if(this._background) | |
{ | |
_background.destroy(); | |
this._background = null; | |
} | |
this._photoframe = null; | |
this._currentLine = null; | |
return; | |
} | |
public Getter function photoframe() : ru.yandex.kraski.universalpainter.visual::Photoframe | |
{ | |
return this._photoframe; | |
} | |
} | |
public class Config extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
private static var _instance : Config; | |
private var _backgroundsLibraryUrl : String; | |
private var _urlLibraryClipart : String; | |
private var _cardId : String; | |
private var _appParameters : Object; | |
private var _photoframesLibraryUrl : String; | |
private var _urlClipartDir : String; | |
//========================= Methods | |
public static function Config() | |
{ | |
return; | |
} | |
public function Config() | |
{ | |
super(); | |
if(this._instance) | |
{ | |
} | |
return; | |
} | |
public static Setter function instance(arg0:ru.yandex.kraski.universalpainter.data::Config) | |
{ | |
this._instance = ; | |
return; | |
} | |
public static Getter function instance() : ru.yandex.kraski.universalpainter.data::Config | |
{ | |
if(this._instance) | |
{ | |
this._instance = ; | |
this._instance._appParameters = Application.application.stage.loaderInfo.parameters; | |
} | |
return this._instance; | |
} | |
public function parseXML(arg0:XML) | |
{ | |
swfConfigItems = null; | |
value = arg0; | |
try { | |
swfConfigItems = children(); | |
var loc2:* = 0; | |
var loc3:* = swfConfigItems; | |
var loc1:* = new XMLList(""); | |
for(loc2 in loc3) | |
{ | |
var loc4:* = loc3.__getNextEnumerablePropertyValue(); | |
var loc5:* = loc3.__getNextEnumerablePropertyValue(); | |
if(name == "urlClipartDir") | |
{ | |
loc1.loc4 = 0; | |
} | |
} | |
this._urlClipartDir = loc1.value; | |
loc2 = 0; | |
loc3 = swfConfigItems; | |
loc1 = new XMLList(""); | |
for(loc2 in loc3) | |
{ | |
loc4 = loc3.__getNextEnumerablePropertyValue(); | |
loc5 = loc3.__getNextEnumerablePropertyValue(); | |
if(name == "urlLibraryClipart") | |
{ | |
loc1.loc4 = 0; | |
} | |
} | |
this._urlLibraryClipart = loc1.value; | |
loc2 = 0; | |
loc3 = swfConfigItems; | |
loc1 = new XMLList(""); | |
for(loc2 in loc3) | |
{ | |
loc4 = loc3.__getNextEnumerablePropertyValue(); | |
loc5 = loc3.__getNextEnumerablePropertyValue(); | |
if(name == "backgroundsLibraryUrl") | |
{ | |
loc1.loc4 = 0; | |
} | |
} | |
_backgroundsLibraryUrl = loc1.value; | |
loc2 = 0; | |
loc3 = swfConfigItems; | |
loc1 = new XMLList(""); | |
for(loc2 in loc3) | |
{ | |
loc4 = loc3.__getNextEnumerablePropertyValue(); | |
loc5 = loc3.__getNextEnumerablePropertyValue(); | |
if(name == "photoframesLibraryUrl") | |
{ | |
loc1.loc4 = 0; | |
} | |
} | |
_photoframesLibraryUrl = loc1.value; | |
dispatchEvent(new ModelEvent(ModelEvent.XML_LOAD_COMPLETE)); | |
} catch (error:Error) { | |
loc1 = error; | |
value = null; | |
dispatchEvent(new ModelEvent(ModelEvent.XML_PARSE_ERROR)); | |
} | |
return; | |
} | |
public Getter function photoframesLibraryURL() : String | |
{ | |
return this.appBaseURL + "/" + this._photoframesLibraryUrl; | |
} | |
public Getter function serviceURL() : String | |
{ | |
return this._appParameters.baseUrl; | |
} | |
public Setter function cardHash(arg0:String) | |
{ | |
this._cardId = arg0; | |
return; | |
} | |
public Getter function uploadURL() : String | |
{ | |
return this._appParameters.uploadUrl; | |
} | |
public Getter function cardHash() : String | |
{ | |
return ( (this._cardId)? this._cardId : this._appParameters.cardHash ); | |
} | |
public Getter function libraryClipartURL() : String | |
{ | |
return this.appBaseURL + "/" + this._urlLibraryClipart; | |
} | |
public Getter function backgroundsLibraryURL() : String | |
{ | |
return this.appBaseURL + "/" + this._backgroundsLibraryUrl; | |
} | |
public Getter function clipartURL() : String | |
{ | |
return this.appBaseURL + "/" + this._urlClipartDir; | |
} | |
public Getter function appBaseURL() : String | |
{ | |
var loc0:* = Application.application.systemManager.loaderInfo.url; | |
return loc0.substr(0, loc0.lastIndexOf("/")); | |
} | |
public Getter function servantURL() : String | |
{ | |
return this._appParameters.servantUrl; | |
} | |
} | |
public class Model extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
private static var _1067928431desktopPlayerAppName : String = "Плеер"; | |
private static var _2136642985blogPlayerAppName : String = "Плеер"; | |
private static var _1859882851desktopEditorAppName : String = "Редактор рисунков"; | |
private static var _1672547127webPlayerAppName : String = "Плеер"; | |
private static var _1830465749webEditorAppName : String = "Редактор рисунков"; | |
private static var _staticBindingEventDispatcher : EventDispatcher; | |
private var _paintSize : int; | |
private var _fonts : Array; | |
private var _sizes : ArrayCollection; | |
private var _backgroundColor : YaColor; | |
private var className : String = "DataModel"; | |
private var _currentFont : Font = Null; | |
private var _configData : Config; | |
private var _currentAssetsType : int; | |
private var _currentClipartsCategory : LibraryClipartCategory; | |
private var _textColor : YaColor; | |
private var _libraryClipartData : LibraryClipartData; | |
private var _activeColor : YaColor; | |
private var _paintClass : Class; | |
private var _selectedVisual : EditableVisual; | |
private var _brushColor : YaColor; | |
private var _clipartColor : YaColor; | |
private var _currentTool : String; | |
private var _card : Card; | |
private var _clipartDescriptors : ClipartDescriptorsList; | |
private var _fontNamesList : Array; | |
//========================= Methods | |
public static function Model() | |
{ | |
this._1830465749webEditorAppName = "Редактор рисунков"; | |
this._1672547127webPlayerAppName = "Плеер"; | |
this._2136642985blogPlayerAppName = "Плеер"; | |
this._1859882851desktopEditorAppName = "Редактор рисунков"; | |
this._1067928431desktopPlayerAppName = "Плеер"; | |
this._staticBindingEventDispatcher = new EventDispatcher(); | |
return; | |
} | |
public function Model(arg0:mx.core::Application, arg1:flash.events::IEventDispatcher = null) | |
{ | |
this._paintClass = SmoothPaint; | |
this._brushColor = new YaColor(16711680); | |
this._clipartColor = new YaColor(); | |
this._textColor = new YaColor(); | |
this._backgroundColor = new YaColor(16777215); | |
this._activeColor = new YaColor(16711680); | |
this._sizes = new ArrayCollection([4, 8, 12, 18, 24]); | |
this._paintSize = this._sizes[2]; | |
this._fontNamesList = ["VeraCrouz", "dsnote", "ITCOfficinaSans-Book"]; | |
this._fonts = []; | |
super(arg1); | |
this.initFonts(); | |
this._configData = Config.instance; | |
this._libraryClipartData = new LibraryClipartData(); | |
this._clipartDescriptors = new ClipartDescriptorsList(); | |
return; | |
} | |
public static Getter function desktopEditorAppName() : String | |
{ | |
return Model._1859882851desktopEditorAppName; | |
} | |
public static Setter function desktopPlayerAppName(arg0:String) | |
{ | |
var loc1:* = null; | |
var loc0:* = Model._1067928431desktopPlayerAppName; | |
if(loc0 !== arg0) | |
{ | |
Model._1067928431desktopPlayerAppName = ; | |
loc1 = Model.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(Model, "desktopPlayerAppName", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Getter function desktopPlayerAppName() : String | |
{ | |
return Model._1067928431desktopPlayerAppName; | |
} | |
public static Getter function webEditorAppName() : String | |
{ | |
return Model._1830465749webEditorAppName; | |
} | |
public static Setter function desktopEditorAppName(arg0:String) | |
{ | |
var loc1:* = null; | |
var loc0:* = Model._1859882851desktopEditorAppName; | |
if(loc0 !== arg0) | |
{ | |
Model._1859882851desktopEditorAppName = ; | |
loc1 = Model.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(Model, "desktopEditorAppName", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Getter function blogPlayerAppName() : String | |
{ | |
return Model._2136642985blogPlayerAppName; | |
} | |
public static Setter function blogPlayerAppName(arg0:String) | |
{ | |
var loc1:* = null; | |
var loc0:* = Model._2136642985blogPlayerAppName; | |
if(loc0 !== arg0) | |
{ | |
Model._2136642985blogPlayerAppName = ; | |
loc1 = Model.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(Model, "blogPlayerAppName", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Getter function staticEventDispatcher() : flash.events::IEventDispatcher | |
{ | |
return this._staticBindingEventDispatcher; | |
} | |
public static Setter function webPlayerAppName(arg0:String) | |
{ | |
var loc1:* = null; | |
var loc0:* = Model._1672547127webPlayerAppName; | |
if(loc0 !== arg0) | |
{ | |
Model._1672547127webPlayerAppName = ; | |
loc1 = Model.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(Model, "webPlayerAppName", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Setter function webEditorAppName(arg0:String) | |
{ | |
var loc1:* = null; | |
var loc0:* = Model._1830465749webEditorAppName; | |
if(loc0 !== arg0) | |
{ | |
Model._1830465749webEditorAppName = ; | |
loc1 = Model.staticEventDispatcher; | |
if(loc1 != null) | |
{ | |
loc1.dispatchEvent(PropertyChangeEvent.createUpdateEvent(Model, "webEditorAppName", loc0, arg0)); | |
} | |
} | |
return; | |
} | |
public static Getter function webPlayerAppName() : String | |
{ | |
return Model._1672547127webPlayerAppName; | |
} | |
public Setter function activeColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
var loc0:* = this.activeColor; | |
if(loc0 !== arg0) | |
{ | |
this._1077332995activeColor = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "activeColor", loc0, arg0)); | |
} | |
return; | |
} | |
private Setter function _1936508347selectedVisual(arg0:ru.yandex.kraski.universalpainter.visual::EditableVisual) | |
{ | |
this._selectedVisual = arg0; | |
dispatchEvent(new ModelEvent(ModelEvent.VISUAL_SELECT)); | |
return; | |
} | |
public Getter function fonts() : Array | |
{ | |
return this._fonts; | |
} | |
public Getter function paintSize() : int | |
{ | |
return this._paintSize; | |
} | |
private Setter function _600824168currentFont(arg0:flash.text::Font) | |
{ | |
this._currentFont = arg0; | |
info("Current font changed: {0}", this._currentFont.fontName); | |
dispatchEvent(new ModelEvent(ModelEvent.CURRENT_FONT_CHANGE)); | |
return; | |
} | |
public Setter function paintClass(arg0:Class) | |
{ | |
var loc0:* = this.paintClass; | |
if(loc0 !== arg0) | |
{ | |
this._774720442paintClass = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "paintClass", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function paintSize(arg0:int) | |
{ | |
var loc0:* = this.paintSize; | |
if(loc0 !== arg0) | |
{ | |
this._1360007809paintSize = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "paintSize", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function selectedVisual(arg0:ru.yandex.kraski.universalpainter.visual::EditableVisual) | |
{ | |
var loc0:* = this.selectedVisual; | |
if(loc0 !== arg0) | |
{ | |
this._1936508347selectedVisual = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "selectedVisual", loc0, arg0)); | |
} | |
return; | |
} | |
public Getter function card() : ru.yandex.kraski.universalpainter.data::Card | |
{ | |
return this._card; | |
} | |
public Getter function sizes() : mx.collections::ArrayCollection | |
{ | |
return this._sizes; | |
} | |
public Getter function currentFont() : flash.text::Font | |
{ | |
return this._currentFont; | |
} | |
public Getter function clipartColor() : ru.yandex.utils::YaColor | |
{ | |
return _clipartColor.clone(); | |
} | |
public Setter function brushColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
var loc0:* = this.brushColor; | |
if(loc0 !== arg0) | |
{ | |
this._2101943369brushColor = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "brushColor", loc0, arg0)); | |
} | |
return; | |
} | |
private Setter function _1077332995activeColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
if(_activeColor.isEquals(arg0)) | |
{ | |
_activeColor.copy(arg0); | |
dispatchEvent(new ModelEvent(ModelEvent.ACTIVE_COLOR_CHANGE)); | |
} | |
return; | |
} | |
public Setter function currentClipartsCategory(arg0:ru.yandex.kraski.universalpainter.data::LibraryClipartCategory) | |
{ | |
var loc0:* = this.currentClipartsCategory; | |
if(loc0 !== arg0) | |
{ | |
this._1871864201currentClipartsCategory = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "currentClipartsCategory", loc0, arg0)); | |
} | |
return; | |
} | |
private Setter function _1063571914textColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
if(_textColor.isEquals(arg0)) | |
{ | |
_textColor.copy(arg0); | |
dispatchEvent(new ModelEvent(ModelEvent.TEXT_COLOR_CHANGE)); | |
} | |
return; | |
} | |
public Setter function card(arg0:ru.yandex.kraski.universalpainter.data::Card) | |
{ | |
var loc0:* = this.card; | |
if(loc0 !== arg0) | |
{ | |
this._3046160card = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "card", loc0, arg0)); | |
} | |
return; | |
} | |
public Getter function libraryClipartData() : ru.yandex.kraski.universalpainter.data::LibraryClipartData | |
{ | |
return this._libraryClipartData; | |
} | |
private Setter function _109453458sizes(arg0:mx.collections::ArrayCollection) | |
{ | |
return; | |
} | |
public Setter function textColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
var loc0:* = this.textColor; | |
if(loc0 !== arg0) | |
{ | |
this._1063571914textColor = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "textColor", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function clipartColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
var loc0:* = this.clipartColor; | |
if(loc0 !== arg0) | |
{ | |
this._1897062896clipartColor = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "clipartColor", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function backgroundColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
var loc0:* = this.backgroundColor; | |
if(loc0 !== arg0) | |
{ | |
this._1287124693backgroundColor = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "backgroundColor", loc0, arg0)); | |
} | |
return; | |
} | |
private Setter function _601241265currentTool(arg0:String) | |
{ | |
if(arg0 == null) | |
{ | |
return; | |
} | |
if(arg0 == this._currentTool) | |
{ | |
return; | |
} | |
info("current tool change: {0} -> {1}", this._currentTool, arg0); | |
this._currentTool = arg0; | |
dispatchEvent(new ModelEvent(ModelEvent.CHANGE_TOOL)); | |
return; | |
} | |
public Getter function currentTool() : String | |
{ | |
return this._currentTool; | |
} | |
public Getter function currentAssetsType() : int | |
{ | |
return this._currentAssetsType; | |
} | |
private Setter function _1287124693backgroundColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
if(_backgroundColor.isEquals(arg0)) | |
{ | |
_backgroundColor.copy(arg0); | |
info("background color: {0}", this._backgroundColor); | |
dispatchEvent(new ModelEvent(ModelEvent.BACKGROUND_COLOR_CHANGE)); | |
} | |
return; | |
} | |
public Getter function paintClass() : Class | |
{ | |
return this._paintClass; | |
} | |
public Getter function selectedVisual() : ru.yandex.kraski.universalpainter.visual::EditableVisual | |
{ | |
return this._selectedVisual; | |
} | |
public Setter function sizes(arg0:mx.collections::ArrayCollection) | |
{ | |
var loc0:* = this.sizes; | |
if(loc0 !== arg0) | |
{ | |
this._109453458sizes = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "sizes", loc0, arg0)); | |
} | |
return; | |
} | |
public Getter function textColor() : ru.yandex.utils::YaColor | |
{ | |
return _textColor.clone(); | |
} | |
public Getter function config() : ru.yandex.kraski.universalpainter.data::Config | |
{ | |
return this._configData; | |
} | |
public Getter function brushColor() : ru.yandex.utils::YaColor | |
{ | |
return _brushColor.clone(); | |
} | |
private Setter function _2101943369brushColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
if(_brushColor.isEquals(arg0)) | |
{ | |
_brushColor.copy(arg0); | |
info("brush color: {0}", this._brushColor); | |
dispatchEvent(new ModelEvent(ModelEvent.BRUSH_COLOR_CHANGE)); | |
} | |
return; | |
} | |
public Getter function clipartDescriptors() : ru.yandex.kraski.universalpainter.data::ClipartDescriptorsList | |
{ | |
return this._clipartDescriptors; | |
} | |
private function initFonts() | |
{ | |
var loc2:* = 0; | |
var loc0:* = Font.enumerateFonts(); | |
var loc1:* = 0; | |
while(loc1 < loc0.length) | |
{ | |
loc2 = 0; | |
while(loc2 < this._fontNamesList.length) | |
{ | |
if(Font(loc0[loc1]).fontName == this._fontNamesList[loc2]) | |
{ | |
fonts.push(loc0[loc1]); | |
} | |
loc2++; | |
} | |
loc1++; | |
} | |
return; | |
} | |
public Getter function backgroundColor() : ru.yandex.utils::YaColor | |
{ | |
return _backgroundColor.clone(); | |
} | |
public Setter function currentFont(arg0:flash.text::Font) | |
{ | |
var loc0:* = this.currentFont; | |
if(loc0 !== arg0) | |
{ | |
this._600824168currentFont = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "currentFont", loc0, arg0)); | |
} | |
return; | |
} | |
private Setter function _774720442paintClass(arg0:Class) | |
{ | |
this._paintClass = arg0; | |
dispatchEvent(new ModelEvent(ModelEvent.PAINT_CLASS_CHANGE)); | |
return; | |
} | |
private Setter function _1897062896clipartColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
if(_clipartColor.isEquals(arg0)) | |
{ | |
_clipartColor.copy(arg0); | |
dispatchEvent(new ModelEvent(ModelEvent.CLIPART_COLOR_CHANGE)); | |
} | |
return; | |
} | |
public Setter function currentTool(arg0:String) | |
{ | |
var loc0:* = this.currentTool; | |
if(loc0 !== arg0) | |
{ | |
this._601241265currentTool = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "currentTool", loc0, arg0)); | |
} | |
return; | |
} | |
private Setter function _1203055690currentAssetsType(arg0:int) | |
{ | |
if(this._currentAssetsType != arg0) | |
{ | |
info("changing assets type: {0} -> {1}", AssetsType.getName(this._currentAssetsType), AssetsType.getName(arg0)); | |
this._currentAssetsType = arg0; | |
} | |
return; | |
} | |
public Setter function currentAssetsType(arg0:int) | |
{ | |
var loc0:* = this.currentAssetsType; | |
if(loc0 !== arg0) | |
{ | |
this._1203055690currentAssetsType = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "currentAssetsType", loc0, arg0)); | |
} | |
return; | |
} | |
private Setter function _1360007809paintSize(arg0:int) | |
{ | |
this._paintSize = arg0; | |
dispatchEvent(new ModelEvent(ModelEvent.PAINT_SIZE_CHANGE)); | |
return; | |
} | |
private Setter function _3046160card(arg0:ru.yandex.kraski.universalpainter.data::Card) | |
{ | |
this._card = arg0; | |
dispatchEvent(new ModelEvent(ModelEvent.CARD_CHANGE)); | |
return; | |
} | |
private Setter function _1871864201currentClipartsCategory(arg0:ru.yandex.kraski.universalpainter.data::LibraryClipartCategory) | |
{ | |
this._currentClipartsCategory = arg0; | |
return; | |
} | |
public Getter function activeColor() : ru.yandex.utils::YaColor | |
{ | |
return _activeColor.clone(); | |
} | |
public Getter function currentClipartsCategory() : ru.yandex.kraski.universalpainter.data::LibraryClipartCategory | |
{ | |
return this._currentClipartsCategory; | |
} | |
} | |
public class ClipartVO extends Object | |
{ | |
//========================= Variables | |
private var _defaultColor : uint; | |
private var _photoButtonsNames : Array; | |
private var _className : String; | |
private var _colorableMovieClips : Array; | |
private var _id : String; | |
private var _briefUrl : String; | |
//========================= Methods | |
public static function ClipartVO() | |
{ | |
return; | |
} | |
public function ClipartVO() | |
{ | |
super(); | |
return; | |
} | |
public Setter function defaultColor(arg0:uint) | |
{ | |
this._defaultColor = arg0; | |
return; | |
} | |
public Setter function className(arg0:String) | |
{ | |
this._className = arg0; | |
return; | |
} | |
public Getter function briefUrl() : String | |
{ | |
return this._briefUrl; | |
} | |
public Getter function photoButtonsNames() : Array | |
{ | |
return _photoButtonsNames.concat(); | |
} | |
public Getter function id() : String | |
{ | |
return this._id; | |
} | |
public Setter function colorableMovieClips(arg0:Array) | |
{ | |
this._colorableMovieClips = arg0.concat(); | |
return; | |
} | |
public Getter function className() : String | |
{ | |
return this._className; | |
} | |
public Getter function defaultColor() : uint | |
{ | |
return this._defaultColor; | |
} | |
public Setter function briefUrl(arg0:String) | |
{ | |
this._briefUrl = arg0; | |
return; | |
} | |
public Getter function colorableMovieClips() : Array | |
{ | |
return _colorableMovieClips.concat(); | |
} | |
public Setter function photoButtonsNames(arg0:Array) | |
{ | |
this._photoButtonsNames = arg0.concat(); | |
return; | |
} | |
public Setter function id(arg0:String) | |
{ | |
this._id = arg0; | |
return; | |
} | |
} | |
public class LibraryClipartCategory extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
private var _categoryItems : Array; | |
private var _path : String; | |
private var _name : String; | |
private var _isDefault : Boolean = False; | |
//========================= Methods | |
public static function LibraryClipartCategory() | |
{ | |
return; | |
} | |
public function LibraryClipartCategory(arg0:String, arg1:String) | |
{ | |
this._categoryItems = []; | |
super(); | |
this._name = arg0; | |
this._path = arg1; | |
return; | |
} | |
public Getter function categoryItems() : Array | |
{ | |
return this._categoryItems; | |
} | |
public Getter function name() : String | |
{ | |
return this._name; | |
} | |
public Setter function isDefault(arg0:Boolean) | |
{ | |
this._isDefault = arg0; | |
return; | |
} | |
public Getter function url() : String | |
{ | |
return this._path + "/" + "props.xml"; | |
} | |
public Setter function categoryXML(arg0:XML) | |
{ | |
xmlList = null; | |
itemXML = null; | |
clipartVO = null; | |
value = arg0; | |
try { | |
xmlList = elements("item"); | |
var loc1:* = 0; | |
var loc2:* = xmlList; | |
for(loc1 in loc2) | |
{ | |
itemXML = loc2.__getNextEnumerablePropertyValue(); | |
clipartVO = new ClipartVO(); | |
clipartVO.briefUrl = 0; | |
clipartVO.className = itemXML.className; | |
clipartVO.defaultColor = 0; | |
clipartVO.colorableMovieClips = 0; | |
clipartVO.photoButtonsNames = 0; | |
clipartVO.id = itemXML.id; | |
categoryItems.push(clipartVO); | |
} | |
dispatchEvent(new ModelEvent(ModelEvent.XML_LOAD_COMPLETE)); | |
} catch (error:Error) { | |
loc1 = error; | |
value = null; | |
dispatchEvent(new ModelEvent(ModelEvent.XML_PARSE_ERROR)); | |
} | |
return; | |
} | |
public function getClipartVOByClassName(arg0:String) : ru.yandex.kraski.universalpainter.data::ClipartVO | |
{ | |
var loc1:* = null; | |
var loc0:* = 0; | |
while(loc0 < this._categoryItems.length) | |
{ | |
loc1 = this._categoryItems[loc0]; | |
if(loc1.className == arg0) | |
{ | |
return loc1; | |
} | |
loc0++; | |
} | |
return null; | |
} | |
public Getter function isDefault() : Boolean | |
{ | |
return this._isDefault; | |
} | |
private Setter function _3373707name(arg0:String) | |
{ | |
this._name = arg0; | |
return; | |
} | |
public Setter function name(arg0:String) | |
{ | |
var loc0:* = this.name; | |
if(loc0 !== arg0) | |
{ | |
this._3373707name = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "name", loc0, arg0)); | |
} | |
return; | |
} | |
} | |
public class ClipartDescriptor extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
private var _defaultColor : uint; | |
private var _briefURL : String; | |
private var _clipartClass : Class; | |
private var _bytesLoaded : Number; | |
private var _photoButtonsNames : Array; | |
private var _fullURL : String; | |
private var _className : String; | |
private var _loaded : Boolean = False; | |
private var _colorableMovieClips : Array; | |
private var _bytesTotal : Number; | |
private var _id : String; | |
//========================= Methods | |
public static function ClipartDescriptor() | |
{ | |
return; | |
} | |
public function ClipartDescriptor() | |
{ | |
this._colorableMovieClips = []; | |
this._photoButtonsNames = []; | |
super(); | |
return; | |
} | |
public Getter function loaded() : Boolean | |
{ | |
return this._loaded; | |
} | |
public Setter function loaded(arg0:Boolean) | |
{ | |
var loc0:* = this.loaded; | |
if(loc0 !== arg0) | |
{ | |
this._1097519099loaded = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "loaded", loc0, arg0)); | |
} | |
return; | |
} | |
private Setter function _195384981briefURL(arg0:String) | |
{ | |
this._briefURL = arg0; | |
return; | |
} | |
private Setter function _511252384fullURL(arg0:String) | |
{ | |
this._fullURL = arg0; | |
return; | |
} | |
public Getter function briefURL() : String | |
{ | |
return this._briefURL; | |
} | |
public Getter function bytesTotal() : Number | |
{ | |
return this._bytesTotal; | |
} | |
public Getter function id() : String | |
{ | |
return this._id; | |
} | |
public function getNewInstance() : ru.yandex.kraski.universalpainter.visual::LibraryAsset | |
{ | |
var loc0:* = new this._clipartClass(); | |
loc0.colorableMovieClips = colorableMovieClips; | |
loc0.color = defaultColor; | |
return loc0; | |
} | |
public Getter function photoButtonsNames() : Array | |
{ | |
return _photoButtonsNames.concat(); | |
} | |
public Getter function defaultColor() : uint | |
{ | |
return this._defaultColor; | |
} | |
public Getter function className() : String | |
{ | |
return this._className; | |
} | |
public Setter function bytesLoaded(arg0:Number) | |
{ | |
var loc0:* = this.bytesLoaded; | |
if(loc0 !== arg0) | |
{ | |
this._326983600bytesLoaded = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "bytesLoaded", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function briefURL(arg0:String) | |
{ | |
var loc0:* = this.briefURL; | |
if(loc0 !== arg0) | |
{ | |
this._195384981briefURL = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "briefURL", loc0, arg0)); | |
} | |
return; | |
} | |
private Setter function _326983600bytesLoaded(arg0:Number) | |
{ | |
this._bytesLoaded = arg0; | |
return; | |
} | |
public Setter function bytesTotal(arg0:Number) | |
{ | |
var loc0:* = this.bytesTotal; | |
if(loc0 !== arg0) | |
{ | |
this._1382331801bytesTotal = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "bytesTotal", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function id(arg0:String) | |
{ | |
var loc0:* = this.id; | |
if(loc0 !== arg0) | |
{ | |
this._3355id = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "id", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function photoButtonsNames(arg0:Array) | |
{ | |
var loc0:* = this.photoButtonsNames; | |
if(loc0 !== arg0) | |
{ | |
this._501712793photoButtonsNames = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "photoButtonsNames", loc0, arg0)); | |
} | |
return; | |
} | |
private Setter function _676255326defaultColor(arg0:uint) | |
{ | |
this._defaultColor = arg0; | |
return; | |
} | |
private Setter function _1382331801bytesTotal(arg0:Number) | |
{ | |
this._bytesTotal = arg0; | |
return; | |
} | |
public Setter function fullURL(arg0:String) | |
{ | |
var loc0:* = this.fullURL; | |
if(loc0 !== arg0) | |
{ | |
this._511252384fullURL = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "fullURL", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function defaultColor(arg0:uint) | |
{ | |
var loc0:* = this.defaultColor; | |
if(loc0 !== arg0) | |
{ | |
this._676255326defaultColor = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "defaultColor", loc0, arg0)); | |
} | |
return; | |
} | |
public Setter function className(arg0:String) | |
{ | |
var loc0:* = this.className; | |
if(loc0 !== arg0) | |
{ | |
this._9888733className = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "className", loc0, arg0)); | |
} | |
return; | |
} | |
public Getter function bytesLoaded() : Number | |
{ | |
return this._bytesLoaded; | |
} | |
private Setter function _501712793photoButtonsNames(arg0:Array) | |
{ | |
this._photoButtonsNames = arg0.concat(); | |
return; | |
} | |
private Setter function _9888733className(arg0:String) | |
{ | |
this._className = arg0; | |
return; | |
} | |
public Getter function fullURL() : String | |
{ | |
return this._fullURL; | |
} | |
public Setter function colorableMovieClips(arg0:Array) | |
{ | |
var loc0:* = this.colorableMovieClips; | |
if(loc0 !== arg0) | |
{ | |
this._2040945424colorableMovieClips = ; | |
this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "colorableMovieClips", loc0, arg0)); | |
} | |
return; | |
} | |
public function toString() : String | |
{ | |
return "ClipartDescriptor for " + this.className; | |
} | |
private Setter function _1097519099loaded(arg0:Boolean) | |
{ | |
if(! && arg0) | |
{ | |
this._loaded = arg0; | |
this._clipartClass = (getDefinitionByName(this.className)) as Class; | |
} | |
return; | |
} | |
private Setter function _3355id(arg0:String) | |
{ | |
this._id = arg0; | |
return; | |
} | |
private Setter function _2040945424colorableMovieClips(arg0:Array) | |
{ | |
this._colorableMovieClips = arg0.concat(); | |
return; | |
} | |
public Getter function colorableMovieClips() : Array | |
{ | |
return _colorableMovieClips.concat(); | |
} | |
} | |
public class ClipartDescriptorsList extends Object | |
{ | |
//========================= Variables | |
private var _descriptorsList : Array; | |
//========================= Methods | |
public static function ClipartDescriptorsList() | |
{ | |
return; | |
} | |
public function ClipartDescriptorsList() | |
{ | |
super(); | |
this._descriptorsList = []; | |
return; | |
} | |
public Getter function descriptorsList() : Array | |
{ | |
return this._descriptorsList; | |
} | |
public function getDescriptorByFullUrl(arg0:String) : ru.yandex.kraski.universalpainter.data::ClipartDescriptor | |
{ | |
return this.findDescriptorByField("fullURL", arg0); | |
} | |
public function createClipartDescriptor(arg0:String, arg1:ru.yandex.kraski.universalpainter.data::ClipartVO) | |
{ | |
var loc0:* = arg1.briefUrl; | |
if(loc0.length == 0) | |
{ | |
} | |
var loc1:* = arg0 + "/" + loc0; | |
if(this.getDescriptorByFullUrl(loc1) != null) | |
{ | |
} | |
var loc2:* = new ClipartDescriptor(); | |
new ClipartDescriptor().id = arg1.id; | |
loc2.briefURL = arg1.briefUrl; | |
loc2.fullURL = 0; | |
loc2.className = arg1.className; | |
loc2.colorableMovieClips = arg1.colorableMovieClips; | |
loc2.photoButtonsNames = arg1.photoButtonsNames; | |
loc2.defaultColor = arg1.defaultColor; | |
_descriptorsList.push(loc2); | |
return; | |
} | |
public function toString() : String | |
{ | |
return "Clipart Descriptors: " + this._descriptorsList; | |
} | |
public Getter function count() : int | |
{ | |
return this._descriptorsList.length; | |
} | |
public function getDescriptorByBriefUrl(arg0:String) : ru.yandex.kraski.universalpainter.data::ClipartDescriptor | |
{ | |
return this.findDescriptorByField("briefURL", arg0); | |
} | |
public function addResourceUrls(arg0:String, arg1:String) | |
{ | |
if(arg1.length == 0) | |
{ | |
} | |
var loc0:* = arg0 + "/" + arg1; | |
if(this.getDescriptorByFullUrl(loc0) != null) | |
{ | |
} | |
var loc1:* = new ClipartDescriptor(); | |
new ClipartDescriptor().briefURL = ; | |
loc1.fullURL = 0; | |
_descriptorsList.push(loc1); | |
return; | |
} | |
public function getDescriptorById(arg0:String) : ru.yandex.kraski.universalpainter.data::ClipartDescriptor | |
{ | |
return this.findDescriptorByField("id", arg0); | |
} | |
public function filter(arg0:Array) : Array | |
{ | |
var loc2:* = 0; | |
var loc3:* = 0; | |
var loc4:* = null; | |
if((!arg0 || arg0.length == 0)) | |
{ | |
return this.toArray(); | |
} | |
var loc0:* = []; | |
var loc1:* = 0; | |
while(loc1 < arg0.length) | |
{ | |
loc2 = LibraryClipartCategory(arg0[loc1]).categoryItems.length; | |
loc3 = 0; | |
while(loc3 < loc2) | |
{ | |
loc4 = arg0[loc1].categoryItems[loc3]; | |
loc0.push(this.getDescriptorByBriefUrl(loc4.briefUrl)); | |
loc3++; | |
} | |
loc1++; | |
} | |
return loc0; | |
} | |
private function findDescriptorByField(arg0:String, arg1:Object) : ru.yandex.kraski.universalpainter.data::ClipartDescriptor | |
{ | |
var loc1:* = null; | |
var loc0:* = 0; | |
while(loc0 < this.count) | |
{ | |
loc1 = this._descriptorsList[loc0]; | |
if(this._descriptorsList[loc0][arg0] == arg1) | |
{ | |
return loc1; | |
} | |
loc0++; | |
} | |
return null; | |
} | |
public function toArray() : Array | |
{ | |
return _descriptorsList.concat(); | |
} | |
} | |
public class AnimationType extends Object | |
{ | |
//========================= Variables | |
public static const ALL : String = "all"; | |
public static const NONE : String = "none"; | |
public static const LINES_ONLY : String = "linesOnly"; | |
//========================= Methods | |
public static function AnimationType() | |
{ | |
this.NONE = "none"; | |
this.ALL = "all"; | |
this.LINES_ONLY = "linesOnly"; | |
return; | |
} | |
public function AnimationType() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class AssetsType extends Object | |
{ | |
//========================= Variables | |
public static const CLIPARTS : int = 0; | |
public static const PHOTO_FRAMES : int = 3; | |
public static const FONTS : int = 2; | |
public static const BACKGROUNDS : int = 1; | |
private static const NAMES : Array; | |
//========================= Methods | |
public static function AssetsType() | |
{ | |
this.CLIPARTS = 0; | |
this.BACKGROUNDS = 1; | |
this.FONTS = 2; | |
this.PHOTO_FRAMES = 3; | |
this.NAMES = ["cliparts", "backgrounds", "fonts", "photoframes"]; | |
return; | |
} | |
public function AssetsType() | |
{ | |
super(); | |
return; | |
} | |
public static function getName(arg0:int) : String | |
{ | |
return this.NAMES[arg0]; | |
} | |
} | |
public class LibraryClipartData extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
private var _defaultClipartCategoryIndex : int = 0; | |
private var _backgroundsCategory : LibraryClipartCategory; | |
private var _photoframesCategory : LibraryClipartCategory; | |
private var _clipartsCategories : Array; | |
//========================= Methods | |
public static function LibraryClipartData() | |
{ | |
return; | |
} | |
public function LibraryClipartData() | |
{ | |
this._clipartsCategories = []; | |
super(); | |
return; | |
} | |
public Getter function defaultClipartCategoryIndex() : int | |
{ | |
return this._defaultClipartCategoryIndex; | |
} | |
public Getter function photoframesCategory() : ru.yandex.kraski.universalpainter.data::LibraryClipartCategory | |
{ | |
return this._photoframesCategory; | |
} | |
public Getter function backgroundsCategory() : ru.yandex.kraski.universalpainter.data::LibraryClipartCategory | |
{ | |
return this._backgroundsCategory; | |
} | |
public Setter function photoframesCategory(arg0:ru.yandex.kraski.universalpainter.data::LibraryClipartCategory) | |
{ | |
this._photoframesCategory = arg0; | |
return; | |
} | |
public Setter function backgroundsCategory(arg0:ru.yandex.kraski.universalpainter.data::LibraryClipartCategory) | |
{ | |
this._backgroundsCategory = arg0; | |
return; | |
} | |
public function getClipartVOByClassName(arg0:String) : ru.yandex.kraski.universalpainter.data::ClipartVO | |
{ | |
var loc1:* = null; | |
var loc0:* = 0; | |
while(loc0 < this._clipartsCategories.length) | |
{ | |
loc1 = getClipartVOByClassName(arg0); | |
if(loc1) | |
{ | |
return loc1; | |
} | |
loc0++; | |
} | |
} | |
public Setter function libraryXML(arg0:XML) | |
{ | |
xmlList = null; | |
itemXML = null; | |
clipartCategoryData = null; | |
currentCategoryIndex = 0; | |
value = arg0; | |
try { | |
xmlList = elements("category"); | |
currentCategoryIndex = 0; | |
var loc1:* = 0; | |
var loc2:* = xmlList; | |
for(loc1 in loc2) | |
{ | |
itemXML = loc2.__getNextEnumerablePropertyValue(); | |
clipartCategoryData = new LibraryClipartCategory(itemXML.name, itemXML.path); | |
clipartCategoryData.isDefault = false; | |
if(clipartCategoryData.isDefault) | |
{ | |
this._defaultClipartCategoryIndex = currentCategoryIndex; | |
} | |
clipartsCategories.push(clipartCategoryData); | |
currentCategoryIndex = currentCategoryIndex + 1; | |
} | |
dispatchEvent(new ModelEvent(ModelEvent.XML_LOAD_COMPLETE)); | |
} catch (error:Error) { | |
loc1 = error; | |
value = null; | |
dispatchEvent(new ModelEvent(ModelEvent.XML_PARSE_ERROR)); | |
} | |
return; | |
} | |
public Getter function clipartsCategories() : Array | |
{ | |
return this._clipartsCategories; | |
} | |
} | |
public class EmbeddedFonts extends Object | |
{ | |
//========================= Variables | |
private static var Font1 : Class; | |
private static var Font2 : Class; | |
//========================= Methods | |
public static function EmbeddedFonts() | |
{ | |
this.Font1 = EmbeddedFonts_Font1; | |
this.Font2 = EmbeddedFonts_Font2; | |
return; | |
} | |
public function EmbeddedFonts() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class LineDescriptor extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
private var _points : Array; | |
private var _height : Number; | |
private var _width : Number; | |
private const FILL_DENSITY : Number = 50; | |
private var _paintClass : Class; | |
private var _size : Number; | |
private var _color : uint; | |
//========================= Methods | |
public static function LineDescriptor() | |
{ | |
return; | |
} | |
public function LineDescriptor() | |
{ | |
this._points = []; | |
super(); | |
return; | |
} | |
public Getter function size() : Number | |
{ | |
return this._size; | |
} | |
public function fill() | |
{ | |
var loc0:* = 0; | |
while(loc0 < this.FILL_DENSITY) | |
{ | |
_points.push({"x" : int(Math.random() * this.width), "y" : int(Math.random() * this.height)}); | |
loc0++; | |
} | |
dispatchEvent(new LineEvent(LineEvent.FILL)); | |
return; | |
} | |
public Setter function size(arg0:Number) | |
{ | |
this._size = arg0; | |
return; | |
} | |
public Setter function color(arg0:uint) | |
{ | |
this._color = arg0; | |
return; | |
} | |
private function dispatchAddPointEvent(arg0:Number, arg1:Number) | |
{ | |
var loc0:* = new LineEvent(LineEvent.ADD_POINT); | |
loc0.x = ; | |
loc0.y = ; | |
dispatchEvent(loc0); | |
return; | |
} | |
public Setter function points(arg0:Array) | |
{ | |
this._points = arg0.concat(); | |
return; | |
} | |
private function distanceBetween(arg0:Number, arg1:Number, arg2:Number, arg3:Number) : Number | |
{ | |
var loc0:* = arg2 - arg0; | |
var loc1:* = arg3 - arg1; | |
return Math.sqrt(loc0 * loc0 + loc1 * loc1); | |
} | |
public Setter function width(arg0:Number) | |
{ | |
this._width = arg0; | |
return; | |
} | |
public Setter function height(arg0:Number) | |
{ | |
this._height = arg0; | |
return; | |
} | |
public Getter function width() : Number | |
{ | |
return this._width; | |
} | |
public function finish() | |
{ | |
dispatchEvent(new LineEvent(LineEvent.FINISH)); | |
return; | |
} | |
public Getter function color() : uint | |
{ | |
return this._color; | |
} | |
public Getter function height() : Number | |
{ | |
return this._height; | |
} | |
public Getter function points() : Array | |
{ | |
return this._points; | |
} | |
public function addPoint(arg0:Number, arg1:Number) | |
{ | |
if((this.paintClass is SmoothPaint || this.paintClass is RunningPaint || this.points.length < 1)) | |
{ | |
points.push({"x" : arg0, "y" : arg1}); | |
this.dispatchAddPointEvent(arg0, arg1); | |
} | |
else | |
{ | |
if(this.distanceBetween(arg0, arg1, this.points[this.points.length].x, this.points[this.points.length].y) > this.size) | |
{ | |
points.push({"x" : arg0, "y" : arg1}); | |
this.dispatchAddPointEvent(arg0, arg1); | |
} | |
} | |
return; | |
} | |
public Setter function paintClass(arg0:Class) | |
{ | |
this._paintClass = arg0; | |
return; | |
} | |
public Getter function paintClass() : Class | |
{ | |
return this._paintClass; | |
} | |
} | |
public class VisualsWeight extends Object | |
{ | |
//========================= Variables | |
public static var PICTURE_WEIGHT : Number = 25; | |
public static var CLIPART_WEIGHT : Number = 25; | |
public static var TEXT_WEIGHT : Number = 5; | |
public static var BACKGROUND_WEIGHT : Number = 0; | |
public static var PHOTOFRAME_WEIGHT : Number = 20; | |
//========================= Methods | |
public static function VisualsWeight() | |
{ | |
this.BACKGROUND_WEIGHT = 0; | |
this.CLIPART_WEIGHT = 25; | |
this.PHOTOFRAME_WEIGHT = 20; | |
this.PICTURE_WEIGHT = 25; | |
this.TEXT_WEIGHT = 5; | |
return; | |
} | |
public function VisualsWeight() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class PhotoframeState extends Object | |
{ | |
//========================= Variables | |
public static const DEFAULT : int = 0; | |
public static const EDIT : int = 1; | |
//========================= Methods | |
public static function PhotoframeState() | |
{ | |
this.DEFAULT = 0; | |
this.EDIT = 1; | |
return; | |
} | |
public function PhotoframeState() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class EmbeddedFonts_Font2 extends mx.core::FontAsset | |
{ | |
//========================= Methods | |
public static function EmbeddedFonts_Font2() | |
{ | |
return; | |
} | |
public function EmbeddedFonts_Font2() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class EmbeddedFonts_Font1 extends mx.core::FontAsset | |
{ | |
//========================= Methods | |
public static function EmbeddedFonts_Font1() | |
{ | |
return; | |
} | |
public function EmbeddedFonts_Font1() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class CursorModel extends Object | |
{ | |
//========================= Variables | |
private static var _currentInstance : BrushCursorClass; | |
//========================= Methods | |
public static function CursorModel() | |
{ | |
return; | |
} | |
public function CursorModel() | |
{ | |
super(); | |
return; | |
} | |
public static function getCurrentInstance() : ru.yandex.kraski.universalpainter.cursors::BrushCursorClass | |
{ | |
return this._currentInstance; | |
} | |
public static function setCurrentInstance(arg0:ru.yandex.kraski.universalpainter.cursors::BrushCursorClass) | |
{ | |
this._currentInstance = ; | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.paints.simple | |
{ | |
public class SimplePaint extends ru.yandex.kraski.universalpainter.paints::Paint | |
{ | |
//========================= Methods | |
public static function SimplePaint() | |
{ | |
return; | |
} | |
public function SimplePaint(arg0:uint, arg1:Number) | |
{ | |
super(arg0, arg1); | |
return; | |
} | |
public function fill(arg0:flash.display::Sprite) | |
{ | |
this.fill(arg0); | |
clear(); | |
beginFill(color); | |
drawRect(0, 0, width, height); | |
endFill(); | |
return; | |
} | |
} | |
public class SmoothPaint extends ru.yandex.kraski.universalpainter.paints.simple::SimplePaint | |
{ | |
//========================= Variables | |
public static var smoothingEnabled : Boolean = True; | |
//========================= Methods | |
public static function SmoothPaint() | |
{ | |
this.smoothingEnabled = true; | |
return; | |
} | |
public function SmoothPaint(arg0:uint, arg1:Number) | |
{ | |
super(arg0, arg1); | |
return; | |
} | |
public function finish() | |
{ | |
var loc0:* = null; | |
var loc1:* = 0; | |
var loc2:* = 0; | |
var loc3:* = null; | |
var loc4:* = NaN; | |
var loc5:* = NaN; | |
var loc6:* = null; | |
this.finish(); | |
if(this.smoothingEnabled && points.length > 2) | |
{ | |
clear(context); | |
loc0 = []; | |
loc1 = 0; | |
while(loc1 < points.length) | |
{ | |
loc3 = [points[loc1]]; | |
loc4 = [points[loc1]][0].x; | |
loc5 = loc3[0].y; | |
loc1++; | |
while((loc1 < points.length && !)) | |
{ | |
loc6 = points[loc1]; | |
if((points[loc1].x - loc4 * loc6.x - loc4 + loc6.y - loc5 * loc6.y - loc5 > 100 * size || loc1 == points.length - 1 || points[0].gap)) | |
{ | |
loc4 = loc6.x; | |
loc5 = loc6.y; | |
loc3.push(loc6); | |
} | |
loc1++; | |
} | |
loc0.push(loc3); | |
} | |
loc2 = 0; | |
while(loc2 < loc0.length) | |
{ | |
this.drawSmoothLine(loc0[loc2]); | |
loc2++; | |
} | |
} | |
return; | |
} | |
private function drawSmoothLine(arg0:Array) | |
{ | |
var loc0:* = 0; | |
var loc1:* = NaN; | |
var loc2:* = NaN; | |
var loc3:* = NaN; | |
var loc4:* = NaN; | |
var loc5:* = NaN; | |
var loc6:* = NaN; | |
var loc7:* = NaN; | |
var loc8:* = NaN; | |
lineStyle(size, color); | |
moveTo(arg0[0].x, arg0[0].y); | |
if(arg0.length < 2) | |
{ | |
} | |
else | |
{ | |
if(arg0.length == 2) | |
{ | |
lineTo(arg0[1].x, arg0[1].y); | |
} | |
else | |
{ | |
curveTo(arg0[1].x - arg0[2].x - arg0[0].x / 2, arg0[1].y - arg0[2].y - arg0[0].y / 2, arg0[1].x, arg0[1].y); | |
loc0 = 1; | |
while(loc0 < arg0.length - 2) | |
{ | |
loc1 = arg0[loc0].x; | |
loc2 = arg0[loc0].y; | |
loc3 = arg0[loc0].x; | |
loc4 = arg0[loc0].y; | |
loc5 = arg0[0].x; | |
loc6 = arg0[0].y; | |
loc7 = arg0[0].x; | |
loc8 = arg0[0].y; | |
curveTo(loc1 + loc5 - loc3 / 6, loc2 + loc6 - loc4 / 6, loc1 + loc5 - loc3 / 6 + loc5 - loc7 - loc1 / 6 / 2, loc2 + loc6 - loc4 / 6 + loc6 - loc8 - loc2 / 6 / 2); | |
curveTo(loc5 - loc7 - loc1 / 6, loc6 - loc8 - loc2 / 6, loc5, loc6); | |
loc0++; | |
} | |
curveTo(arg0[0].x - arg0[0].x - arg0[arg0.length].x / 2, arg0[0].y - arg0[0].y - arg0[arg0.length].y / 2, arg0[arg0.length].x, arg0[arg0.length].y); | |
} | |
} | |
return; | |
} | |
public function appendPoint(arg0:flash.display::Sprite, arg1:Number, arg2:Number) | |
{ | |
this.appendPoint(arg0, arg1, arg2); | |
lineStyle(size, color); | |
if(points.length == 1) | |
{ | |
moveTo(arg1, arg2); | |
lineTo(arg1 + 1, arg2 + 1); | |
} | |
else | |
{ | |
lineTo(arg1, arg2); | |
} | |
return; | |
} | |
} | |
public class SolidPaint extends ru.yandex.kraski.universalpainter.paints.simple::SimplePaint | |
{ | |
//========================= Variables | |
private var point : Object; | |
//========================= Methods | |
public static function SolidPaint() | |
{ | |
return; | |
} | |
public function SolidPaint(arg0:uint, arg1:Number) | |
{ | |
super(arg0, arg1); | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.view.comps | |
{ | |
public class HandCursorButton extends mx.controls::Button | |
{ | |
//========================= Variables | |
private var _isOver : Boolean = False; | |
//========================= Methods | |
public static function HandCursorButton() | |
{ | |
return; | |
} | |
public function HandCursorButton() | |
{ | |
super(); | |
return; | |
} | |
public function initialize() | |
{ | |
this.initialize(); | |
return; | |
} | |
public Setter function enabled(arg0:Boolean) | |
{ | |
this = arg0; | |
if(!arg0 && this._isOver) | |
{ | |
CustomCursorManager.setCursorByName(CursorType.POINTER); | |
} | |
return; | |
} | |
public function rollOutHandler(arg0:flash.events::MouseEvent) | |
{ | |
this.rollOutHandler(arg0); | |
this._isOver = false; | |
if(arg0.buttonDown) | |
{ | |
CustomCursorManager.setCursorByName(CursorType.POINTER); | |
} | |
return; | |
} | |
public function rollOverHandler(arg0:flash.events::MouseEvent) | |
{ | |
this.rollOverHandler(arg0); | |
this._isOver = true; | |
if(this.enabled && !) | |
{ | |
CustomCursorManager.setCursorByName(CursorType.FINGER); | |
} | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.view | |
{ | |
public class PaintCanvas extends mx.core::UIComponent | |
{ | |
//========================= Variables | |
public static const WIDTH : int = 475; | |
public static const HEIGHT : int = 475; | |
private var _animation : String; | |
private var _model : Model; | |
private var highlightedClipart : Clipart; | |
private var _resizerContainer : SimpleContainer; | |
private var _background : Background; | |
private var _bgColor : YaColor; | |
private var _visualsContainer : VisualsContainer; | |
private var _card : Card; | |
//========================= Methods | |
public static function PaintCanvas() | |
{ | |
this.WIDTH = 475; | |
this.HEIGHT = 475; | |
return; | |
} | |
public function PaintCanvas() | |
{ | |
this._bgColor = new YaColor(16777215); | |
super(); | |
this.addEventListener("initialize", this.___PaintCanvas_UIComponent1_initialize); | |
return; | |
} | |
private function card_visualAppendedHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
visualsContainer.addVisual(arg0.visual, arg0.index); | |
this.updateVisualAnimation(arg0.visual); | |
return; | |
} | |
public Setter function animation(arg0:String) | |
{ | |
if(this._animation != arg0) | |
{ | |
this._animation = arg0; | |
this.updateCardContentAnimation(); | |
} | |
return; | |
} | |
private function card_swapDepthHandler(arg0:ru.yandex.kraski.universalpainter.events::SwapVisualDepthEvent) | |
{ | |
visualsContainer.swapChildrenAt(arg0.oldDepth, arg0.newDepth); | |
return; | |
} | |
private function card_changeHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
this.card = this._model.card; | |
return; | |
} | |
private function createVisualContainer() | |
{ | |
this.visualsContainer = new VisualsContainer(); | |
visualsContainer.setSize(this.WIDTH, this.HEIGHT); | |
addChild(this.visualsContainer); | |
return; | |
} | |
public Getter function visualsContainer() : ru.yandex.kraski.universalpainter.view::VisualsContainer | |
{ | |
return this._visualsContainer; | |
} | |
private function removeVisuals() | |
{ | |
visualsContainer.clean(); | |
this.setBackground(null); | |
return; | |
} | |
private function init() | |
{ | |
this.createVisualContainer(); | |
this.createResizerContainer(); | |
return; | |
} | |
private function card_backgroundChangedHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
this.setBackground(Background(arg0.visual)); | |
return; | |
} | |
public function initialize() | |
{ | |
this.initialize(); | |
return; | |
} | |
private function updateVisualAnimation(arg0:ru.yandex.kraski.universalpainter.visual::Visual) | |
{ | |
var loc0:* = this._animation; | |
switch(loc0) | |
{ | |
case AnimationType.ALL: | |
arg0.animationEnabled = true; | |
break; | |
case AnimationType.NONE: | |
arg0.animationEnabled = false; | |
break; | |
case AnimationType.LINES_ONLY: | |
arg0.animationEnabled = true; | |
break; | |
default: | |
break; | |
} | |
debug("{0} animation {1}", arg0, ( (arg0.animationEnabled)? "enabled" : "disabled" )); | |
return; | |
} | |
public Setter function visualsContainer(arg0:ru.yandex.kraski.universalpainter.view::VisualsContainer) | |
{ | |
if(this._visualsContainer) | |
{ | |
} | |
this._visualsContainer = arg0; | |
return; | |
} | |
private function addModelListeners() | |
{ | |
_model.addEventListener(ModelEvent.CARD_CHANGE, this.card_changeHandler); | |
return; | |
} | |
public Setter function card(arg0:ru.yandex.kraski.universalpainter.data::Card) | |
{ | |
if(this._card) | |
{ | |
this.removeCardListeners(); | |
this.removeVisuals(); | |
this._card = null; | |
} | |
this._card = arg0; | |
if(this._card) | |
{ | |
this.addCardListeners(); | |
this.addVisuals(); | |
this.updateCardContentAnimation(); | |
} | |
return; | |
} | |
private function updateCardContentAnimation() | |
{ | |
if(this._card) | |
{ | |
return; | |
} | |
if(this._card.background) | |
{ | |
this.updateVisualAnimation(this._card.background); | |
} | |
var loc0:* = 0; | |
while(loc0 < this._card.visualsList.length) | |
{ | |
this.updateVisualAnimation(this._card.visualsList[loc0]); | |
loc0++; | |
} | |
return; | |
} | |
public Getter function bgColor() : ru.yandex.utils::YaColor | |
{ | |
return _bgColor.clone(); | |
} | |
public function erase(arg0:ru.yandex.kraski.universalpainter.visual::Eraser) | |
{ | |
return; | |
} | |
public Getter function card() : ru.yandex.kraski.universalpainter.data::Card | |
{ | |
return this._card; | |
} | |
public Getter function model() : ru.yandex.kraski.universalpainter.data::Model | |
{ | |
return this._model; | |
} | |
public Getter function background() : ru.yandex.kraski.universalpainter.visual::Background | |
{ | |
return this._background; | |
} | |
public function setBackground(arg0:ru.yandex.kraski.universalpainter.visual::Background) | |
{ | |
if(this._background) | |
{ | |
this._background.animationEnabled = false; | |
removeChild(this._background); | |
} | |
this._background = arg0; | |
if(arg0) | |
{ | |
addChildAt(this._background, 0); | |
this.updateVisualAnimation(this._background); | |
invalidateDisplayList(); | |
} | |
return; | |
} | |
public Getter function animation() : String | |
{ | |
return this._animation; | |
} | |
public function highlight(arg0:ru.yandex.kraski.universalpainter.visual::Clipart) | |
{ | |
if(this.highlightedClipart == arg0) | |
{ | |
return; | |
} | |
if(this.highlightedClipart) | |
{ | |
highlightedClipart.hideBox(); | |
} | |
this.highlightedClipart = arg0; | |
if(this.highlightedClipart) | |
{ | |
highlightedClipart.drawBox(); | |
} | |
return; | |
} | |
private function removeModelListeners() | |
{ | |
_model.removeEventListener(ModelEvent.CARD_CHANGE, this.card_changeHandler); | |
return; | |
} | |
public Setter function bgColor(arg0:ru.yandex.utils::YaColor) | |
{ | |
info("bgColor = #{0}", arg0); | |
_bgColor.copy(arg0); | |
if(this._background) | |
{ | |
this._background.color = ; | |
} | |
return; | |
} | |
public function getTopmostEditableVisualUnderPoint(arg0:Number, arg1:Number) : ru.yandex.kraski.universalpainter.visual::EditableVisual | |
{ | |
return visualsContainer.getTopmostEditableVisualUnderPoint(localToGlobal(new Point(arg0, arg1))); | |
} | |
public function ___PaintCanvas_UIComponent1_initialize(arg0:mx.events::FlexEvent) | |
{ | |
this.init(); | |
return; | |
} | |
private function card_cardClearHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
this.removeVisuals(); | |
return; | |
} | |
private function addVisuals() | |
{ | |
this.setBackground(this.card.background); | |
var loc0:* = 0; | |
while(loc0 < this.card.visualsList.length) | |
{ | |
visualsContainer.addVisual(this.card.visualsList[loc0]); | |
loc0++; | |
} | |
return; | |
} | |
public Setter function model(arg0:ru.yandex.kraski.universalpainter.data::Model) | |
{ | |
if(this._model) | |
{ | |
} | |
this._model = arg0; | |
this.addModelListeners(); | |
this.card = this._model.card; | |
return; | |
} | |
private function card_loadCompleteHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
this.addVisuals(); | |
return; | |
} | |
public function measure() | |
{ | |
var loc0:* = this.WIDTH; | |
this.width = this.WIDTH; | |
this.minWidth = loc0; | |
loc0 = this.HEIGHT; | |
this.height = this.HEIGHT; | |
this.minHeight = loc0; | |
return; | |
} | |
public Getter function resizerContainer() : flash.display::Sprite | |
{ | |
return this._resizerContainer; | |
} | |
public Getter function screenshot() : String | |
{ | |
var loc0:* = ImageSnapshot.captureImage(this.visualsContainer, 0, new JPEGEncoder(80)); | |
return ImageSnapshot.encodeImageAsBase64(loc0); | |
} | |
private function removeCardListeners() | |
{ | |
_card.removeEventListener(ModelEvent.CARD_CLEAR, this.card_cardClearHandler); | |
_card.removeEventListener(ModelEvent.VISUAL_APPEND, this.card_visualAppendedHandler); | |
_card.removeEventListener(ModelEvent.BACKGROUND_CHANGE, this.card_backgroundChangedHandler); | |
_card.removeEventListener(ModelEvent.XML_LOAD_COMPLETE, this.card_loadCompleteHandler); | |
_card.removeEventListener(ModelEvent.VISUAL_REMOVE, this.card_visualRemovedHandler); | |
_card.removeEventListener(SwapVisualDepthEvent.SWAP_DEPTH, this.card_swapDepthHandler); | |
return; | |
} | |
private function addCardListeners() | |
{ | |
_card.addEventListener(ModelEvent.CARD_CLEAR, this.card_cardClearHandler); | |
_card.addEventListener(ModelEvent.VISUAL_APPEND, this.card_visualAppendedHandler); | |
_card.addEventListener(ModelEvent.BACKGROUND_CHANGE, this.card_backgroundChangedHandler); | |
_card.addEventListener(ModelEvent.XML_LOAD_COMPLETE, this.card_loadCompleteHandler); | |
_card.addEventListener(ModelEvent.VISUAL_REMOVE, this.card_visualRemovedHandler); | |
_card.addEventListener(SwapVisualDepthEvent.SWAP_DEPTH, this.card_swapDepthHandler); | |
return; | |
} | |
public function updateDisplayList(arg0:Number, arg1:Number) | |
{ | |
this.updateDisplayList(arg0, arg1); | |
graphics.clear(); | |
graphics.beginFill(16777215); | |
graphics.drawRect(0, 0, arg0, arg1); | |
graphics.endFill(); | |
if(this._background) | |
{ | |
this._background.width = ; | |
this._background.height = ; | |
} | |
return; | |
} | |
private function card_visualRemovedHandler(arg0:ru.yandex.kraski.universalpainter.events::ModelEvent) | |
{ | |
arg0.visual.animationEnabled = false; | |
visualsContainer.removeChild(arg0.visual); | |
return; | |
} | |
private function createResizerContainer() | |
{ | |
this._resizerContainer = new SimpleContainer(); | |
_resizerContainer.setSize(this.WIDTH, this.HEIGHT); | |
this._resizerContainer.mouseEnabled = false; | |
this._resizerContainer.mouseChildren = false; | |
addChild(this._resizerContainer); | |
return; | |
} | |
} | |
public class SimpleContainer extends flash.display::Sprite | |
{ | |
//========================= Methods | |
public static function SimpleContainer() | |
{ | |
return; | |
} | |
public function SimpleContainer() | |
{ | |
super(); | |
return; | |
} | |
public function clean() | |
{ | |
DisplayUtil.removeAllChildren(this); | |
return; | |
} | |
public function setSize(arg0:int, arg1:int) | |
{ | |
graphics.clear(); | |
graphics.beginFill(16777215, 0); | |
graphics.drawRect(0, 0, arg0, arg1); | |
graphics.endFill(); | |
this.scrollRect = new Rectangle(0, 0, arg0, arg1); | |
return; | |
} | |
} | |
public class VisualsContainer extends ru.yandex.kraski.universalpainter.view::SimpleContainer | |
{ | |
//========================= Methods | |
public static function VisualsContainer() | |
{ | |
return; | |
} | |
public function VisualsContainer() | |
{ | |
super(); | |
return; | |
} | |
public function clean() | |
{ | |
var loc0:* = 0; | |
while(loc0 < numChildren) | |
{ | |
if(getChildAt(loc0) is Visual) | |
{ | |
Visual(getChildAt(loc0)).animationEnabled = false; | |
} | |
loc0++; | |
} | |
this.clean(); | |
return; | |
} | |
public function addVisual(arg0:ru.yandex.kraski.universalpainter.visual::Visual, arg1:int = 1342177279) | |
{ | |
if(arg0 is Eraser) | |
{ | |
addChild(new Sprite()); | |
} | |
else | |
{ | |
this.addVisualToDepth(arg0, arg1); | |
} | |
return; | |
} | |
public function getTopmostEditableVisualUnderPoint(arg0:flash.geom::Point) : ru.yandex.kraski.universalpainter.visual::EditableVisual | |
{ | |
var loc1:* = null; | |
var loc0:* = numChildren - 1; | |
while(loc0 >= 0) | |
{ | |
loc1 = (getChildAt(loc0)) as EditableVisual; | |
if(loc1 && loc1.hitTest(arg0.x, arg0.y)) | |
{ | |
return loc1; | |
} | |
loc0 = loc0 - 1; | |
} | |
return null; | |
} | |
private function addVisualToDepth(arg0:ru.yandex.kraski.universalpainter.visual::Visual, arg1:int) | |
{ | |
if((arg1 == 255 || arg1 > numChildren)) | |
{ | |
addChild(arg0); | |
} | |
else | |
{ | |
addChildAt(arg0, arg1); | |
} | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.services.web | |
{ | |
public class WebServiceLocatorImpl extends ru.yandex.kraski.universalpainter.services::ServiceLocatorImpl | |
{ | |
//========================= Methods | |
public static function WebServiceLocatorImpl() | |
{ | |
return; | |
} | |
public function WebServiceLocatorImpl() | |
{ | |
super(); | |
this._loadPictureService = new LoadPictureService(); | |
this._saveCardService = new SaveCardService(); | |
this._createNewCardService = new CreateNewCardService(); | |
this._loadCardForEditService = new LoadCardService(); | |
this._loadCardForPlayService = new LoadCardService(); | |
this._loadConfigService = new LoadConfigService(); | |
return; | |
} | |
} | |
public class LoadPictureService extends ru.yandex.kraski.universalpainter.services::KraskiService implements {ru.yandex.kraski.universalpainter.services}::ILoadPictureService | |
{ | |
//========================= Variables | |
private var card : Card; | |
private var file : FileReference; | |
//========================= Methods | |
public static function LoadPictureService() | |
{ | |
return; | |
} | |
public function LoadPictureService() | |
{ | |
super(); | |
return; | |
} | |
private function upload_progressHandler(arg0:flash.events::ProgressEvent) | |
{ | |
this.logProgress("upload picture progress:", arg0.bytesLoaded, arg0.bytesTotal); | |
return; | |
} | |
private function removeDownloadListeners(arg0:flash.display::LoaderInfo) | |
{ | |
arg0.removeEventListener(Event.COMPLETE, this.download_completeHandler); | |
arg0.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, this.download_errorHandler); | |
arg0.removeEventListener(IOErrorEvent.IO_ERROR, this.download_errorHandler); | |
return; | |
} | |
public function load(arg0:ru.yandex.kraski.universalpainter.data::Card) | |
{ | |
this.card = ; | |
this.file = new FileReference(); | |
file.addEventListener(Event.CANCEL, this.cancelHandler); | |
file.addEventListener(Event.SELECT, this.selectHandler); | |
file.browse([new FileFilter("Изображения", "*.jpg;*.gif;*.png")]); | |
return; | |
} | |
private function upload_securityErrorHandler(arg0:flash.events::SecurityErrorEvent) | |
{ | |
this.removeUploadListeners(); | |
this.abort(new Fault("UploadPictureSecurityError", arg0.toString())); | |
return; | |
} | |
private function download_errorHandler(arg0:flash.events::IOErrorEvent) | |
{ | |
this.removeDownloadListeners(LoaderInfo(arg0.target)); | |
this.abort(new Fault("DownloadPictureError", arg0.toString())); | |
return; | |
} | |
private function logProgress(arg0:String, arg1:Number, arg2:Number) | |
{ | |
info(arg0 + " {0} of {1} Kbytes ({2}%)", toFixed(0), toFixed(0), toFixed(0)); | |
return; | |
} | |
private function upload_completeHandler(arg0:flash.events::Event) | |
{ | |
this.removeUploadListeners(); | |
this.downloadPicture(this.card.picturesTotal); | |
return; | |
} | |
private function selectHandler(arg0:flash.events::Event) | |
{ | |
this.removeBrowseListeners(); | |
dispatchEvent(new Event("startProgress")); | |
this.uploadPicture(); | |
return; | |
} | |
private function removeBrowseListeners() | |
{ | |
file.removeEventListener(Event.CANCEL, this.cancelHandler); | |
file.removeEventListener(Event.SELECT, this.selectHandler); | |
return; | |
} | |
private function download_completeHandler(arg0:flash.events::Event) | |
{ | |
var loc0:* = LoaderInfo(arg0.target); | |
this.removeDownloadListeners(loc0); | |
this.complete(Bitmap(loc0.content)); | |
return; | |
} | |
private function upload_ioErrorHandler(arg0:flash.events::IOErrorEvent) | |
{ | |
this.removeUploadListeners(); | |
this.abort(new Fault("UploadPictureError", arg0.toString())); | |
return; | |
} | |
public function downloadPicture(arg0:int) | |
{ | |
var loc0:* = new Loader(); | |
addEventListener(Event.COMPLETE, this.download_completeHandler); | |
addEventListener(SecurityErrorEvent.SECURITY_ERROR, this.download_errorHandler); | |
addEventListener(IOErrorEvent.IO_ERROR, this.download_errorHandler); | |
var loc1:* = new URLRequest(URLsBuilder.getPictureDownloadURL(Config.instance.cardHash, arg0)); | |
debug("beginning image loading: {0}", loc1.url); | |
var loc2:* = new LoaderContext(true, ApplicationDomain.currentDomain); | |
loc0.load(loc1, loc2); | |
return; | |
} | |
private function cancelHandler(arg0:flash.events::Event) | |
{ | |
this.removeBrowseListeners(); | |
dispatchEvent(new Event(Event.CANCEL)); | |
return; | |
} | |
private function complete(arg0:flash.display::Bitmap) | |
{ | |
debug("image loaded"); | |
dispatchEvent(ResultEvent.createEvent(new Bitmap(clone(), PixelSnapping.AUTO, true))); | |
return; | |
} | |
private function removeUploadListeners() | |
{ | |
file.removeEventListener(Event.COMPLETE, this.upload_completeHandler); | |
file.removeEventListener(IOErrorEvent.IO_ERROR, this.upload_ioErrorHandler); | |
file.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, this.upload_securityErrorHandler); | |
file.removeEventListener(ProgressEvent.PROGRESS, this.upload_progressHandler); | |
return; | |
} | |
private function uploadPicture() | |
{ | |
file.addEventListener(Event.COMPLETE, this.upload_completeHandler); | |
file.addEventListener(IOErrorEvent.IO_ERROR, this.upload_ioErrorHandler); | |
file.addEventListener(SecurityErrorEvent.SECURITY_ERROR, this.upload_securityErrorHandler); | |
file.addEventListener(ProgressEvent.PROGRESS, this.upload_progressHandler); | |
var loc0:* = this.card; | |
var loc1:* = this.card.picturesTotal + 1; | |
loc0.picturesTotal = this.card.picturesTotal; | |
file.upload(new URLRequest(URLsBuilder.getPictureUploadURL(this.card.hash, this.card.picturesTotal))); | |
return; | |
} | |
private function download_progressHandler(arg0:flash.events::ProgressEvent) | |
{ | |
this.logProgress("download picture progress:", arg0.bytesLoaded, arg0.bytesTotal); | |
return; | |
} | |
private function abort(arg0:mx.rpc::Fault) | |
{ | |
error(arg0.faultCode, arg0.message); | |
dispatchEvent(FaultEvent.createEvent(arg0)); | |
return; | |
} | |
} | |
public class CreateNewCardService extends flash.events::EventDispatcher implements {ru.yandex.kraski.universalpainter.services}::ICreateNewCardService | |
{ | |
//========================= Variables | |
private static const CLASS_NAME : String = "ru.yandex.kraski.universalpainter.services.CreateNewCardService"; | |
private var newHash : String; | |
//========================= Methods | |
public static function CreateNewCardService() | |
{ | |
this.CLASS_NAME = "ru.yandex.kraski.universalpainter.services.CreateNewCardService"; | |
return; | |
} | |
public function CreateNewCardService() | |
{ | |
super(); | |
return; | |
} | |
private function abort(arg0:mx.rpc::Fault) | |
{ | |
error(arg0.faultCode, arg0.message); | |
dispatchEvent(FaultEvent.createEvent(arg0)); | |
return; | |
} | |
private function validateResult(arg0:XML) | |
{ | |
var loc0:* = null; | |
if(length() > 0) | |
{ | |
this.newHash = arg0.hash; | |
loc0 = new HTTPService(); | |
loc0.url = 0; | |
loc0.resultFormat = "e4x"; | |
loc0.addEventListener(ResultEvent.RESULT, this.createCard_resultHandler); | |
loc0.addEventListener(FaultEvent.FAULT, this.faultHandler); | |
loc0.send(); | |
} | |
else | |
{ | |
dispatchEvent(FaultEvent.createEvent(new Fault("GetNewHashError", "Invalid server response: | |
" + arg0))); | |
} | |
return; | |
} | |
private function getNewHash_resultHandler(arg0:mx.rpc.events::ResultEvent) | |
{ | |
this.removeServiceListeners(HTTPService(arg0.target)); | |
this.validateResult(XML(arg0.result)); | |
return; | |
} | |
private function faultHandler(arg0:mx.rpc.events::FaultEvent) | |
{ | |
this.removeServiceListeners(HTTPService(arg0.target)); | |
dispatchEvent(FaultEvent.createEvent(arg0.fault)); | |
return; | |
} | |
private function createCard_resultHandler(arg0:mx.rpc.events::ResultEvent) | |
{ | |
this.removeServiceListeners(HTTPService(arg0.target)); | |
var loc0:* = XML(arg0.result); | |
if(loc0.auth.value == "ok") | |
{ | |
dispatchEvent(ResultEvent.createEvent(this.newHash)); | |
} | |
else | |
{ | |
if(loc0.auth.value == "failed") | |
{ | |
this.abort(new Fault("UserNotAuthorized", "Picture can not be uploaded because user not authorized.")); | |
} | |
else | |
{ | |
this.abort(new Fault("InvalidCheckAuthResponse", "Picture can not be uploaded because check auth response " + "is not valid: | |
" + loc0.toXMLString())); | |
} | |
} | |
return; | |
} | |
public function createCard() | |
{ | |
var loc0:* = new HTTPService(); | |
loc0.url = 0; | |
loc0.resultFormat = "e4x"; | |
loc0.addEventListener(ResultEvent.RESULT, this.getNewHash_resultHandler); | |
loc0.addEventListener(FaultEvent.FAULT, this.faultHandler); | |
loc0.send(); | |
return; | |
} | |
private function removeServiceListeners(arg0:mx.rpc.http::HTTPService) | |
{ | |
arg0.removeEventListener(ResultEvent.RESULT, this.getNewHash_resultHandler); | |
arg0.removeEventListener(ResultEvent.RESULT, this.createCard_resultHandler); | |
arg0.removeEventListener(FaultEvent.FAULT, this.faultHandler); | |
return; | |
} | |
} | |
public class LoadConfigService extends flash.events::EventDispatcher implements {ru.yandex.kraski.universalpainter.services}::ILoadConfigService | |
{ | |
//========================= Methods | |
public static function LoadConfigService() | |
{ | |
return; | |
} | |
public function LoadConfigService() | |
{ | |
super(); | |
return; | |
} | |
private function completeHandler(arg0:flash.events::Event) | |
{ | |
var loc0:* = URLLoader(arg0.target); | |
this.removeListeners(loc0); | |
dispatchEvent(ResultEvent.createEvent(XML(loc0.data))); | |
return; | |
} | |
private function removeListeners(arg0:flash.net::URLLoader) | |
{ | |
arg0.removeEventListener(Event.COMPLETE, this.completeHandler); | |
arg0.removeEventListener(IOErrorEvent.IO_ERROR, this.errorHandler); | |
arg0.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, this.errorHandler); | |
return; | |
} | |
private function errorHandler(arg0:flash.events::ErrorEvent) | |
{ | |
this.removeListeners(URLLoader(arg0.target)); | |
dispatchEvent(FaultEvent.createEvent(new Fault("ConfigLoadingError", arg0.toString()))); | |
return; | |
} | |
public function load() | |
{ | |
var loc0:* = new URLLoader(); | |
loc0.addEventListener(Event.COMPLETE, this.completeHandler); | |
loc0.addEventListener(IOErrorEvent.IO_ERROR, this.errorHandler); | |
loc0.addEventListener(SecurityErrorEvent.SECURITY_ERROR, this.errorHandler); | |
loc0.load(new URLRequest(URLsBuilder.getConfigURL())); | |
return; | |
} | |
} | |
public class LoadCardService extends ru.yandex.kraski.universalpainter.services::KraskiService implements {ru.yandex.kraski.universalpainter.services}::ILoadCardService | |
{ | |
//========================= Variables | |
private var service : HTTPService; | |
//========================= Methods | |
public static function LoadCardService() | |
{ | |
return; | |
} | |
public function LoadCardService() | |
{ | |
super(); | |
this.service = new HTTPService(); | |
this.service.resultFormat = "text"; | |
return; | |
} | |
private function resultHandler(arg0:mx.rpc.events::ResultEvent) | |
{ | |
this.removeServiceListeners(HTTPService(arg0.target)); | |
var loc0:* = new XML(arg0.result); | |
if(loc0 && loc0.name() == "card") | |
{ | |
dispatchEvent(ResultEvent.createEvent(loc0)); | |
} | |
else | |
{ | |
error("Invalid card XML: {0}", loc0); | |
dispatchEvent(FaultEvent.createEvent(new Fault("InvalidCardXML", "Invalid card XML: | |
" + loc0))); | |
} | |
return; | |
} | |
private function faultHandler(arg0:mx.rpc.events::FaultEvent) | |
{ | |
this.removeServiceListeners(HTTPService(arg0.target)); | |
error("Card loading error: {0}", arg0.toString()); | |
dispatchEvent(FaultEvent.createEvent(arg0.fault)); | |
return; | |
} | |
public function load(arg0:String) | |
{ | |
this.service.url = 0; | |
service.addEventListener(ResultEvent.RESULT, this.resultHandler); | |
service.addEventListener(FaultEvent.FAULT, this.faultHandler); | |
service.send(); | |
return; | |
} | |
private function removeServiceListeners(arg0:mx.rpc.http::HTTPService) | |
{ | |
arg0.removeEventListener(ResultEvent.RESULT, this.resultHandler); | |
arg0.removeEventListener(FaultEvent.FAULT, this.faultHandler); | |
return; | |
} | |
} | |
public class SaveCardService extends flash.events::EventDispatcher implements {ru.yandex.kraski.universalpainter.services}::ISaveCardService | |
{ | |
//========================= Variables | |
private static const CLASS_NAME : String = "ru.yandex.kraski.universalpainter.services.SaveCardService"; | |
private var screenshotSource : DisplayObject; | |
private var cardHash : String; | |
//========================= Methods | |
public static function SaveCardService() | |
{ | |
this.CLASS_NAME = "ru.yandex.kraski.universalpainter.services.SaveCardService"; | |
return; | |
} | |
public function SaveCardService() | |
{ | |
super(); | |
return; | |
} | |
public function save(arg0:ru.yandex.kraski.universalpainter.data::Card, arg1:flash.display::DisplayObject) | |
{ | |
this.cardHash = arg0.hash; | |
this.screenshotSource = ; | |
var loc0:* = new HTTPService(); | |
loc0.url = 0; | |
loc0.method = "POST"; | |
loc0.resultFormat = "e4x"; | |
loc0.request = ; | |
loc0.addEventListener(ResultEvent.RESULT, this.save_resultHandler); | |
loc0.addEventListener(FaultEvent.FAULT, this.save_faultHandler); | |
loc0.send(); | |
return; | |
} | |
private function upload_faultHandler(arg0:mx.rpc.events::FaultEvent) | |
{ | |
this.removeUploadServiceListeners(HTTPService(arg0.target)); | |
error(arg0.toString()); | |
dispatchEvent(FaultEvent.createEvent(new Fault("UploadScreenshotError", arg0.toString()))); | |
return; | |
} | |
private function uploadScreenshot() | |
{ | |
var loc0:* = ImageSnapshot.captureImage(this.screenshotSource, 0, new JPEGEncoder()); | |
var loc1:* = new HTTPService(); | |
loc1.url = 0; | |
loc1.resultFormat = "e4x"; | |
loc1.method = "POST"; | |
loc1.request = ; | |
loc1.addEventListener(ResultEvent.RESULT, this.upload_resultHandler); | |
loc1.addEventListener(FaultEvent.FAULT, this.upload_faultHandler); | |
loc1.send(); | |
return; | |
} | |
private function save_faultHandler(arg0:mx.rpc.events::FaultEvent) | |
{ | |
this.removeSaveServiceListeners(HTTPService(arg0.target)); | |
error(arg0.toString()); | |
dispatchEvent(FaultEvent.createEvent(arg0.fault)); | |
return; | |
} | |
private function save_resultHandler(arg0:mx.rpc.events::ResultEvent) | |
{ | |
this.removeSaveServiceListeners(HTTPService(arg0.target)); | |
if(this.cardHash == XML(arg0.result).hash.value) | |
{ | |
this.uploadScreenshot(); | |
} | |
else | |
{ | |
dispatchEvent(FaultEvent.createEvent(new Fault("SaveImageError", "Invalid server response: " + arg0.result))); | |
} | |
return; | |
} | |
private function removeUploadServiceListeners(arg0:mx.rpc.http::HTTPService) | |
{ | |
arg0.removeEventListener(ResultEvent.RESULT, this.upload_resultHandler); | |
arg0.removeEventListener(FaultEvent.FAULT, this.upload_faultHandler); | |
return; | |
} | |
private function removeSaveServiceListeners(arg0:mx.rpc.http::HTTPService) | |
{ | |
arg0.removeEventListener(ResultEvent.RESULT, this.save_resultHandler); | |
arg0.removeEventListener(FaultEvent.FAULT, this.save_faultHandler); | |
return; | |
} | |
private function upload_resultHandler(arg0:mx.rpc.events::ResultEvent) | |
{ | |
this.removeUploadServiceListeners(HTTPService(arg0.target)); | |
dispatchEvent(ResultEvent.createEvent(this.cardHash)); | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.paints.art | |
{ | |
public class ArtPaint extends ru.yandex.kraski.universalpainter.paints::Paint | |
{ | |
//========================= Methods | |
public static function ArtPaint() | |
{ | |
return; | |
} | |
public function ArtPaint(arg0:uint, arg1:Number) | |
{ | |
super(arg0, arg1); | |
this._pointWeight = PaintsWeight.ART_PAINT_WEIGHT; | |
return; | |
} | |
public function fill(arg0:flash.display::Sprite) | |
{ | |
this.fill(arg0); | |
var loc0:* = 0; | |
while(loc0 < points.length) | |
{ | |
appendPoint(arg0, points[loc0].x, points[loc0].y); | |
loc0++; | |
} | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.paints.art.wave | |
{ | |
public class WavePaint extends ru.yandex.kraski.universalpainter.paints.art::ArtPaint | |
{ | |
//========================= Variables | |
private var symbolClass : Class; | |
private var colorTransform : ColorTransform; | |
private var curFrame : int = 1; | |
//========================= Methods | |
public static function WavePaint() | |
{ | |
return; | |
} | |
public function WavePaint(arg0:uint, arg1:Number, arg2:Class) | |
{ | |
super(arg0, arg1); | |
this.symbolClass = arg2; | |
this.colorTransform = new ColorTransform(1, 1, 1, 1, arg0 >> 16, arg0 >> 8 & 255, arg0 & 255); | |
return; | |
} | |
public function appendPoint(arg0:flash.display::Sprite, arg1:Number, arg2:Number) | |
{ | |
var loc1:* = null; | |
this.appendPoint(arg0, arg1, arg2); | |
var loc0:* = size / 20; | |
loc1 = new this.symbolClass(); | |
new this.symbolClass().transform.colorTransform = ; | |
loc1.x = ; | |
loc1.y = ; | |
var loc2:* = loc0; | |
loc1.scaleY = 0; | |
loc1.scaleX = undefined; | |
loc1.play(); | |
arg0.addChild(loc1); | |
return; | |
} | |
public function pauseAnimation() | |
{ | |
this.pauseAnimation(); | |
if(context == null) | |
{ | |
return; | |
} | |
var loc0:* = 0; | |
while(loc0 < context.numChildren) | |
{ | |
stop(); | |
loc0++; | |
} | |
return; | |
} | |
public function resumeAnimation() | |
{ | |
var loc1:* = null; | |
this.resumeAnimation(); | |
if(context == null) | |
{ | |
return; | |
} | |
var loc0:* = 0; | |
while(loc0 < context.numChildren) | |
{ | |
loc1 = MovieClip(context.getChildAt(loc0)); | |
if(this.curFrame <= 1) | |
{ | |
this.curFrame = loc1.totalFrames; | |
} | |
else | |
{ | |
var loc2:* = this; | |
var loc3:* = this.curFrame - 1; | |
loc2.curFrame = this.curFrame; | |
} | |
loc1.gotoAndPlay(this.curFrame); | |
loc0++; | |
} | |
return; | |
} | |
} | |
public class RectPaint extends ru.yandex.kraski.universalpainter.paints.art.wave::WavePaint | |
{ | |
//========================= Methods | |
public static function RectPaint() | |
{ | |
return; | |
} | |
public function RectPaint(arg0:uint, arg1:Number) | |
{ | |
super(arg0, arg1, RectPaintSymbol); | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.paints.art.snow | |
{ | |
public class SnowPaint extends ru.yandex.kraski.universalpainter.paints.art::ArtPaint | |
{ | |
//========================= Variables | |
public var snowballs : Array; | |
//========================= Methods | |
public static function SnowPaint() | |
{ | |
return; | |
} | |
public function SnowPaint(arg0:uint, arg1:Number) | |
{ | |
super(arg0, arg1); | |
this.snowballs = []; | |
return; | |
} | |
public function clear(arg0:flash.display::Sprite) | |
{ | |
this.clear(arg0); | |
this.snowballs = []; | |
return; | |
} | |
private function enterFrameHandler(arg0:flash.events::Event) | |
{ | |
var loc2:* = null; | |
if(_context == null) | |
{ | |
return; | |
} | |
var loc0:* = this.snowballs.length; | |
var loc1:* = 0; | |
while(loc1 < loc0) | |
{ | |
loc2 = this.snowballs[loc1]; | |
if(this.snowballs[loc1].visible) | |
{ | |
loc2.move(); | |
} | |
loc1++; | |
} | |
return; | |
} | |
public function appendPoint(arg0:flash.display::Sprite, arg1:Number, arg2:Number) | |
{ | |
this.appendPoint(_context, arg1, arg2); | |
this._pointWeight = PaintsWeight.SNOW_PAINT_WEIGHT; | |
this.context = ; | |
var loc0:* = new SnowBuilder(); | |
createSnowForPoint(this, arg1, arg2, color, 1 + size / 10); | |
return; | |
} | |
public function resumeAnimation() | |
{ | |
this.resumeAnimation(); | |
if(_context) | |
{ | |
_context.addEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
} | |
return; | |
} | |
public function setNewContext(arg0:flash.display::Sprite) | |
{ | |
if(_context) | |
{ | |
_context.removeEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
} | |
this.setNewContext(arg0); | |
if(_context) | |
{ | |
_context.addEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
} | |
return; | |
} | |
public function erase(arg0:flash.display::Sprite, arg1:flash.display::Sprite) | |
{ | |
var loc2:* = null; | |
var loc0:* = this.snowballs.length; | |
var loc1:* = 0; | |
while(loc1 < loc0) | |
{ | |
loc2 = this.snowballs[loc1]; | |
if(hitTestObject(arg1)) | |
{ | |
loc2.visible = false; | |
} | |
loc1++; | |
} | |
return; | |
} | |
public function pauseAnimation() | |
{ | |
this.pauseAnimation(); | |
if(_context) | |
{ | |
_context.removeEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
} | |
return; | |
} | |
} | |
public class SnowBall extends flash.display::Shape | |
{ | |
//========================= Variables | |
private var scaleIncrement : Number = 0,05; | |
private var _startX : Number; | |
private var _startY : Number; | |
private var snowDistance : Number = -28; | |
private var _vx : Number; | |
private var _color : uint; | |
private var initialScale : Number = 0,5; | |
private var _vy : Number; | |
private var _radius : Number; | |
private var initialAlpha : Number = 1; | |
//========================= Methods | |
public static function SnowBall() | |
{ | |
return; | |
} | |
public function SnowBall(arg0:uint, arg1:Number) | |
{ | |
super(); | |
this._color = arg0; | |
this._radius = arg1; | |
var loc0:* = this.initialScale; | |
this.scaleY = this.initialScale; | |
this.scaleX = loc0; | |
this.drawCircle(); | |
return; | |
} | |
private function drawCircle() | |
{ | |
var loc0:* = graphics; | |
loc0.clear(); | |
loc0.beginFill(this._color); | |
loc0.drawCircle(0, 0, this._radius); | |
loc0.endFill(); | |
return; | |
} | |
public Setter function vy(arg0:Number) | |
{ | |
this._vy = arg0; | |
return; | |
} | |
public Getter function vx() : Number | |
{ | |
return this._vx; | |
} | |
public Setter function vx(arg0:Number) | |
{ | |
this._vx = arg0; | |
return; | |
} | |
public function move() | |
{ | |
if(y - this._startY > this.snowDistance) | |
{ | |
this.alpha = this.initialAlpha; | |
this.x = this._startX; | |
this.y = this._startY; | |
var loc0:* = this.initialScale; | |
this.scaleY = this.initialScale; | |
this.scaleX = loc0; | |
} | |
else | |
{ | |
this.alpha = 0,98 - y - this._startY / this.snowDistance; | |
this.x = x + this._vx; | |
this.y = y + this._vy; | |
this.scaleX = scaleX + this.scaleIncrement; | |
this.scaleY = scaleX; | |
} | |
return; | |
} | |
public Getter function vy() : Number | |
{ | |
return this._vy; | |
} | |
public Setter function startY(arg0:Number) | |
{ | |
this._startY = arg0; | |
this.y = arg0; | |
return; | |
} | |
public Getter function startX() : Number | |
{ | |
return this._startX; | |
} | |
public Getter function startY() : Number | |
{ | |
return this._startY; | |
} | |
public Setter function startX(arg0:Number) | |
{ | |
this._startX = arg0; | |
this.x = arg0; | |
return; | |
} | |
} | |
public class SnowBuilder extends Object | |
{ | |
//========================= Variables | |
private var _size : int; | |
private var _color : uint; | |
private var _currrentSnowIndex : int = 0; | |
private const SNOW_QUANTITY : int = 4; | |
private var _interval : int; | |
private var _context : Sprite; | |
private const SNOW_DELAY : int = 300; | |
private var _x : Number; | |
private var _y : Number; | |
private var _targetPaint : SnowPaint; | |
//========================= Methods | |
public static function SnowBuilder() | |
{ | |
return; | |
} | |
public function SnowBuilder() | |
{ | |
super(); | |
return; | |
} | |
public function createSnowForPoint(arg0:ru.yandex.kraski.universalpainter.paints.art.snow::SnowPaint, arg1:Number, arg2:Number, arg3:uint, arg4:Number) | |
{ | |
this._targetPaint = arg0; | |
this._context = arg0.context; | |
this._x = arg1; | |
this._y = arg2; | |
this._color = arg3; | |
this._size = arg4; | |
this.addSnow(); | |
this._interval = setInterval(this.addSnow, this.SNOW_DELAY); | |
return; | |
} | |
private function addSnow() | |
{ | |
var loc1:* = this; | |
var loc2:* = this._currrentSnowIndex + 1; | |
loc1._currrentSnowIndex = this._currrentSnowIndex; | |
if(this._currrentSnowIndex >= this.SNOW_QUANTITY) | |
{ | |
clearInterval(this._interval); | |
} | |
var loc0:* = new SnowBall(this._color, this._size); | |
loc0.startX = 0; | |
loc0.startY = 0; | |
loc0.vx = 0; | |
loc0.vy = 2; | |
_context.addChild(loc0); | |
push(loc0); | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.paints.art.sprayer | |
{ | |
public class SprayerPaint extends ru.yandex.kraski.universalpainter.paints.art::ArtPaint | |
{ | |
//========================= Variables | |
private var numDots : Number; | |
private const DOT_PER_POINT : int = 20; | |
//========================= Methods | |
public static function SprayerPaint() | |
{ | |
return; | |
} | |
public function SprayerPaint(arg0:uint, arg1:Number) | |
{ | |
super(arg0, arg1); | |
this.numDots = arg1 * this.DOT_PER_POINT; | |
this._pointWeight = PaintsWeight.SPRAYER_PAINT_WEIGHT; | |
return; | |
} | |
private function makeSpot(arg0:Number, arg1:Number, arg2:Number) : flash.display::Sprite | |
{ | |
var loc0:* = null; | |
loc0 = new Sprite(); | |
new Sprite().x = 0; | |
loc0.y = 0; | |
lineStyle(1, color); | |
var loc1:* = 0; | |
while(loc1 < this.numDots) | |
{ | |
this.drawDot(loc0.graphics, YaNumberUtil.getRandomFromRange(0, 2 * arg2), YaNumberUtil.getRandomFromRange(0, 2 * arg2)); | |
loc1++; | |
} | |
return loc0; | |
} | |
private function drawDot(arg0:flash.display::Graphics, arg1:Number, arg2:Number) | |
{ | |
arg0.moveTo(arg1, arg2); | |
arg0.lineTo(arg1 + 0,1, arg2 + 0,1); | |
return; | |
} | |
public function appendPoint(arg0:flash.display::Sprite, arg1:Number, arg2:Number) | |
{ | |
this.appendPoint(arg0, arg1, arg2); | |
var loc0:* = 1 + size; | |
arg0.addChild(this.makeSpot(arg1, arg2, loc0)); | |
return; | |
} | |
public function erase(arg0:flash.display::Sprite, arg1:flash.display::Sprite) | |
{ | |
var loc0:* = 0; | |
while(loc0 < arg0.numChildren) | |
{ | |
if(hitTestObject(arg1)) | |
{ | |
arg0.getChildAt(loc0).visible = false; | |
} | |
loc0++; | |
} | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.paints.art.random | |
{ | |
public class RandomPaint extends ru.yandex.kraski.universalpainter.paints.art::ArtPaint | |
{ | |
//========================= Variables | |
private var symbolClass : Class; | |
private var frameToGo : uint = 1; | |
private var colorTransform : ColorTransform; | |
//========================= Methods | |
public static function RandomPaint() | |
{ | |
return; | |
} | |
public function RandomPaint(arg0:Class, arg1:uint, arg2:Number) | |
{ | |
super(arg1, arg2); | |
this.symbolClass = arg0; | |
this.colorTransform = new ColorTransform(1, 1, 1, 1, arg1 >> 16 & 255, arg1 >> 8 & 255, arg1 & 255); | |
return; | |
} | |
public function resumeAnimation() | |
{ | |
this.resumeAnimation(); | |
if(context == null) | |
{ | |
return; | |
} | |
var loc0:* = 0; | |
while(loc0 < context.numChildren) | |
{ | |
play(); | |
loc0++; | |
} | |
return; | |
} | |
public function appendPoint(arg0:flash.display::Sprite, arg1:Number, arg2:Number) | |
{ | |
var loc0:* = null; | |
this.appendPoint(arg0, arg1, arg2); | |
loc0 = new this.symbolClass(); | |
loc0 = new this.symbolClass(); | |
new this.symbolClass().transform.colorTransform = ; | |
var loc1:* = points.length * 0,1; | |
while(loc1 > 1) | |
{ | |
loc1 = loc1 - 1; | |
} | |
loc0.x = ; | |
loc0.y = ; | |
var loc3:* = 4 * size / 100; | |
loc0.scaleY = 0; | |
loc0.scaleX = undefined; | |
loc0.rotation = 0; | |
var loc2:* = int(loc0.totalFrames * loc1); | |
if(int(loc0.totalFrames * loc1) > loc0.totalFrames) | |
{ | |
loc2 = loc2 - loc0.totalFrames; | |
} | |
loc0.gotoAndPlay(loc2); | |
arg0.addChild(loc0); | |
return; | |
} | |
public function erase(arg0:flash.display::Sprite, arg1:flash.display::Sprite) | |
{ | |
var loc0:* = 0; | |
while(loc0 < arg0.numChildren) | |
{ | |
if(hitTestObject(arg1)) | |
{ | |
arg0.getChildAt(loc0).visible = false; | |
} | |
loc0++; | |
} | |
return; | |
} | |
public function pauseAnimation() | |
{ | |
this.pauseAnimation(); | |
if(context == null) | |
{ | |
return; | |
} | |
var loc0:* = 0; | |
while(loc0 < context.numChildren) | |
{ | |
stop(); | |
loc0++; | |
} | |
return; | |
} | |
} | |
public class HeartPaint extends ru.yandex.kraski.universalpainter.paints.art.random::RandomPaint | |
{ | |
//========================= Methods | |
public static function HeartPaint() | |
{ | |
return; | |
} | |
public function HeartPaint(arg0:uint, arg1:Number) | |
{ | |
super(HeartPaintSymbol, arg0, arg1); | |
return; | |
} | |
} | |
public class FlowerPaint extends ru.yandex.kraski.universalpainter.paints.art.random::RandomPaint | |
{ | |
//========================= Methods | |
public static function FlowerPaint() | |
{ | |
return; | |
} | |
public function FlowerPaint(arg0:uint, arg1:Number) | |
{ | |
super(FlowerPaintSymbol, arg0, arg1); | |
this._pointWeight = PaintsWeight.FLOWER_PAINT_WEIGHT; | |
return; | |
} | |
} | |
public class PentaPaint extends ru.yandex.kraski.universalpainter.paints.art.random::RandomPaint | |
{ | |
//========================= Methods | |
public static function PentaPaint() | |
{ | |
return; | |
} | |
public function PentaPaint(arg0:uint, arg1:Number) | |
{ | |
super(PentaPaintSymbol, arg0, arg1); | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.paints.dotted | |
{ | |
public class RunningPaint extends ru.yandex.kraski.universalpainter.paints::Paint | |
{ | |
//========================= Variables | |
private var timer : Timer; | |
private var phase : Number; | |
//========================= Methods | |
public static function RunningPaint() | |
{ | |
return; | |
} | |
public function RunningPaint(arg0:uint, arg1:Number) | |
{ | |
super(arg0, arg1); | |
return; | |
} | |
private function timerHandler(arg0:flash.events::TimerEvent = null) | |
{ | |
clear(); | |
this.drawDotted(points, this.phase); | |
this.phase = this.phase + 0,02 % 1; | |
return; | |
} | |
private function drawDotted(arg0:Array, arg1:Number) | |
{ | |
var loc5:* = NaN; | |
var loc6:* = NaN; | |
var loc8:* = null; | |
var loc9:* = NaN; | |
var loc10:* = NaN; | |
var loc11:* = NaN; | |
var loc12:* = NaN; | |
var loc13:* = NaN; | |
debug("drawing from phase {0}", arg1); | |
var loc0:* = 10 * size; | |
var loc1:* = arg0[0].x; | |
var loc2:* = arg0[0].y; | |
lineStyle(size, color, 1, false, LineScaleMode.NONE, CapsStyle.NONE); | |
moveTo(loc1, loc2); | |
var loc3:* = arg1 < 0,5; | |
var loc4:* = loc0 * arg1 * 2 % 1; | |
var loc7:* = 0; | |
while(loc7 < arg0.length) | |
{ | |
loc8 = arg0[loc7]; | |
loc9 = loc1 - loc8.x; | |
loc10 = loc2 - loc8.y; | |
loc11 = Math.sqrt(loc9 * loc9 + loc10 * loc10); | |
loc12 = 255 * loc10 / loc11; | |
loc13 = 255 * loc9 / loc11; | |
while(loc11 > loc4) | |
{ | |
loc5 = loc1 + loc13 * loc4; | |
loc6 = loc2 + loc12 * loc4; | |
this.drawSegment(loc3, loc5, loc6); | |
loc1 = loc5; | |
loc2 = loc6; | |
loc11 = loc11 - loc4; | |
loc4 = loc0; | |
loc3 = !loc3; | |
} | |
loc1 = loc8.x; | |
loc2 = loc8.y; | |
loc4 = loc4 - loc11; | |
this.drawSegment(loc3, loc1, loc2); | |
loc7++; | |
} | |
return; | |
} | |
public function clear(arg0:flash.display::Sprite) | |
{ | |
this.clear(arg0); | |
if(this.timer) | |
{ | |
timer.stop(); | |
timer.removeEventListener(TimerEvent.TIMER, this.timerHandler); | |
} | |
return; | |
} | |
public function pauseAnimation() | |
{ | |
this.pauseAnimation(); | |
if(this.timer) | |
{ | |
timer.stop(); | |
} | |
return; | |
} | |
private function drawSegment(arg0:Boolean, arg1:Number, arg2:Number) | |
{ | |
if(arg0) | |
{ | |
lineTo(arg1, arg2); | |
} | |
else | |
{ | |
moveTo(arg1, arg2); | |
} | |
return; | |
} | |
public function finish() | |
{ | |
this.finish(); | |
if(points.length > 2) | |
{ | |
this.phase = 0,5; | |
this.timer = new Timer(20); | |
timer.addEventListener(TimerEvent.TIMER, this.timerHandler); | |
timer.start(); | |
this.timerHandler(); | |
} | |
return; | |
} | |
public Getter function distance() : Number | |
{ | |
return size * 2; | |
} | |
public function resumeAnimation() | |
{ | |
this.resumeAnimation(); | |
if(this.timer && !) | |
{ | |
timer.start(); | |
} | |
return; | |
} | |
public function appendPoint(arg0:flash.display::Sprite, arg1:Number, arg2:Number) | |
{ | |
this.appendPoint(arg0, arg1, arg2); | |
clear(); | |
this.drawDotted(points, 1); | |
return; | |
} | |
} | |
} | |
package ru.yandex.lib.logger.target | |
{ | |
public class AbstractTarget extends Object implements {mx.logging}::ILoggingTarget, {mx.core}::IMXMLObject | |
{ | |
//========================= Variables | |
private var _level : int = 0; | |
private var _loggerCount : uint = 0; | |
private var _id : String; | |
private var _filters : Array; | |
//========================= Methods | |
public static function AbstractTarget() | |
{ | |
return; | |
} | |
public function AbstractTarget() | |
{ | |
this._filters = ["*"]; | |
super(); | |
this._id = UIDUtil.createUID(); | |
return; | |
} | |
public Getter function filters() : Array | |
{ | |
return this._filters; | |
} | |
public Getter function level() : int | |
{ | |
return this._level; | |
} | |
public Setter function level(arg0:int) | |
{ | |
Log.removeTarget(this); | |
this._level = arg0; | |
Log.addTarget(this); | |
return; | |
} | |
public function removeLogger(arg0:mx.logging::ILogger) | |
{ | |
if(arg0) | |
{ | |
var loc0:* = this; | |
var loc1:* = this._loggerCount - 1; | |
loc0._loggerCount = this._loggerCount; | |
arg0.removeEventListener(LogEvent.LOG, this.logHandler); | |
} | |
return; | |
} | |
public function logEvent(arg0:mx.logging::LogEvent) | |
{ | |
return; | |
} | |
public function initialized(arg0:Object, arg1:String) | |
{ | |
this._id = arg1; | |
Log.addTarget(this); | |
return; | |
} | |
public function addLogger(arg0:mx.logging::ILogger) | |
{ | |
if(arg0) | |
{ | |
var loc0:* = this; | |
var loc1:* = this._loggerCount + 1; | |
loc0._loggerCount = this._loggerCount; | |
arg0.addEventListener(LogEvent.LOG, this.logHandler); | |
} | |
return; | |
} | |
public Getter function id() : String | |
{ | |
return this._id; | |
} | |
private function logHandler(arg0:mx.logging::LogEvent) | |
{ | |
if(arg0.level >= this.level) | |
{ | |
this.logEvent(arg0); | |
} | |
return; | |
} | |
public Setter function filters(arg0:Array) | |
{ | |
var loc0:* = null; | |
var loc1:* = 0; | |
var loc2:* = null; | |
var loc3:* = 0; | |
if(arg0 && arg0.length > 0) | |
{ | |
loc3 = 0; | |
while(loc3 < arg0.length) | |
{ | |
loc0 = arg0[loc3]; | |
if(Log.hasIllegalCharacters(loc0)) | |
{ | |
loc2 = "chars invalid"; | |
} | |
loc1 = loc0.indexOf("*"); | |
if(loc1 >= 0 && !) | |
{ | |
loc2 = "char placement"; | |
} | |
loc3 = loc3 + 1; | |
} | |
} | |
else | |
{ | |
arg0 = ["*"]; | |
} | |
if(this._loggerCount > 0) | |
{ | |
Log.removeTarget(this); | |
this._filters = arg0; | |
Log.addTarget(this); | |
} | |
else | |
{ | |
this._filters = arg0; | |
} | |
return; | |
} | |
} | |
public class LineFormattedTarget extends ru.yandex.lib.logger.target::AbstractTarget | |
{ | |
//========================= Variables | |
public var includeCategory : Boolean; | |
public var fieldSeparator : String = " "; | |
public var includeTime : Boolean; | |
public var includeLevel : Boolean; | |
public var includeDate : Boolean; | |
//========================= Methods | |
public static function LineFormattedTarget() | |
{ | |
return; | |
} | |
public function LineFormattedTarget() | |
{ | |
super(); | |
this.includeTime = false; | |
this.includeDate = false; | |
this.includeCategory = false; | |
this.includeLevel = false; | |
return; | |
} | |
private function padTime(arg0:Number, arg1:Boolean = false) : String | |
{ | |
if(arg1) | |
{ | |
if(arg0 < 10) | |
{ | |
return "00" + arg0.toString(); | |
} | |
if(arg0 < 100) | |
{ | |
return "0" + arg0.toString(); | |
} | |
return arg0.toString(); | |
} | |
else | |
{ | |
} | |
return ( (arg0 > 9)? arg0.toString() : "0" + arg0.toString() ); | |
} | |
public function logEvent(arg0:mx.logging::LogEvent) | |
{ | |
var loc3:* = null; | |
var loc4:* = null; | |
var loc5:* = null; | |
var loc0:* = ""; | |
if((this.includeDate || this.includeTime)) | |
{ | |
loc3 = new Date(); | |
if(this.includeDate) | |
{ | |
loc0 = loc3.getFullYear() + "-"; | |
loc4 = toString(); | |
if(Number(loc3.getMonth() + 1) < 10) | |
{ | |
loc4 = "0" + loc4; | |
} | |
loc5 = toString(); | |
if(loc3.getDate() < 10) | |
{ | |
loc5 = "0" + loc5; | |
} | |
loc0 = loc0 + loc4 + "-" + loc5 + this.fieldSeparator; | |
} | |
if(this.includeTime) | |
{ | |
loc0 = loc0 + this.padTime(loc3.getHours()) + ":" + this.padTime(loc3.getMinutes()) + ":" + this.padTime(loc3.getSeconds()) + "." + this.padTime(loc3.getMilliseconds(), true) + this.fieldSeparator; | |
} | |
} | |
var loc1:* = ""; | |
if(this.includeLevel) | |
{ | |
loc1 = "[" + LogEvent.getLevelString(arg0.level) + "]" + this.fieldSeparator; | |
} | |
var loc2:* = ( (this.includeCategory)? ILogger(arg0.target).category + this.fieldSeparator : "" ); | |
this.internalLog(loc0 + loc1 + loc2 + arg0.message); | |
return; | |
} | |
public function internalLog(arg0:String) | |
{ | |
return; | |
} | |
} | |
public class ConsoleTarget extends ru.yandex.lib.logger.target::LineFormattedTarget | |
{ | |
//========================= Variables | |
private var console : Console; | |
private var currentLevel : int; | |
//========================= Methods | |
public static function ConsoleTarget() | |
{ | |
return; | |
} | |
public function ConsoleTarget(arg0:ru.yandex.lib.logger.view::Console) | |
{ | |
super(); | |
this.includeTime = true; | |
this.includeDate = true; | |
this.includeCategory = false; | |
this.includeLevel = true; | |
this.console = arg0; | |
return; | |
} | |
public function logEvent(arg0:mx.logging::LogEvent) | |
{ | |
this.currentLevel = arg0.level; | |
this.logEvent(arg0); | |
return; | |
} | |
public function internalLog(arg0:String) | |
{ | |
var loc0:* = 0; | |
var loc1:* = this.currentLevel; | |
switch(loc1) | |
{ | |
case LogEventLevel.DEBUG: | |
loc0 = 0; | |
break; | |
case LogEventLevel.INFO: | |
loc0 = 13056; | |
break; | |
case LogEventLevel.WARN: | |
loc0 = 255; | |
break; | |
case LogEventLevel.ERROR: | |
loc0 = 10040064; | |
break; | |
case LogEventLevel.FATAL: | |
loc0 = 16711680; | |
break; | |
default: | |
loc0 = 0; | |
break; | |
} | |
console.addMessage(arg0, loc0); | |
return; | |
} | |
} | |
public class UIDUtil extends Object | |
{ | |
//========================= Variables | |
private static const ALPHA_CHAR_CODES : Array; | |
//========================= Methods | |
public static function UIDUtil() | |
{ | |
this.ALPHA_CHAR_CODES = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70]; | |
return; | |
} | |
public function UIDUtil() | |
{ | |
super(); | |
return; | |
} | |
public static function createUID() : String | |
{ | |
var loc2:* = 0; | |
var loc3:* = 0; | |
var loc0:* = new Array(36); | |
var loc1:* = 0; | |
loc2 = 0; | |
while(loc2 < 8) | |
{ | |
loc1 = loc1 + 1; | |
var loc6:* = loc1; | |
loc0[loc1] = this.ALPHA_CHAR_CODES[0]; | |
loc2++; | |
} | |
loc2 = 0; | |
while(loc2 < 3) | |
{ | |
loc1 = loc1 + 1; | |
loc6 = loc1; | |
loc0[loc1] = 45; | |
loc3 = 0; | |
while(loc3 < 4) | |
{ | |
loc1 = loc1 + 1; | |
var loc7:* = loc1; | |
loc0[loc1] = this.ALPHA_CHAR_CODES[0]; | |
loc3++; | |
} | |
loc2++; | |
} | |
loc1 = loc1 + 1; | |
loc6 = loc1; | |
loc0[loc1] = 45; | |
var loc4:* = getTime(); | |
var loc5:* = substr(248); | |
loc2 = 0; | |
while(loc2 < 8) | |
{ | |
loc1 = loc1 + 1; | |
loc7 = loc1; | |
loc0[loc1] = 0; | |
loc2++; | |
} | |
loc2 = 0; | |
while(loc2 < 4) | |
{ | |
loc1 = loc1 + 1; | |
loc7 = loc1; | |
loc0[loc1] = this.ALPHA_CHAR_CODES[0]; | |
loc2++; | |
} | |
return apply(null, loc0); | |
} | |
} | |
} | |
package ru.yandex.lib.logger.view | |
{ | |
public class Console extends flash.display::Sprite | |
{ | |
//========================= Variables | |
private var maxCountRowsTextField : TextField; | |
private var scrollBar : ScrollBar; | |
private var CloseButtonSkin : Class; | |
private var CopyButtonSkin : Class; | |
private var TextBackgroundSkin : Class; | |
private var ConsoleBackgroundSkin : Class; | |
private var _maxCountRows : int = 30; | |
private var logTextField : TextField; | |
private var background : Sprite; | |
private var copy : Sprite; | |
private var logMessages : Array; | |
private var close : Sprite; | |
private var textBackground : Sprite; | |
private var logTextMessages : Array; | |
//========================= Methods | |
public static function Console() | |
{ | |
return; | |
} | |
public function Console() | |
{ | |
this.logMessages = new Array(); | |
this.logTextMessages = new Array(); | |
this.ConsoleBackgroundSkin = Console_ConsoleBackgroundSkin; | |
this.TextBackgroundSkin = Console_TextBackgroundSkin; | |
this.CloseButtonSkin = Console_CloseButtonSkin; | |
this.CopyButtonSkin = Console_CopyButtonSkin; | |
super(); | |
addEventListener(Event.ADDED_TO_STAGE, this.addedToStageHandler); | |
return; | |
} | |
public function setSize() | |
{ | |
this.background.width = 0; | |
this.background.height = 0; | |
this.textBackground.width = 0; | |
this.textBackground.height = 0; | |
this.textBackground.x = 10; | |
this.textBackground.y = 20; | |
this.logTextField.width = this.textBackground.width; | |
this.logTextField.height = this.textBackground.height; | |
this.logTextField.x = this.textBackground.x; | |
this.logTextField.y = this.textBackground.y; | |
this.scrollBar.x = 0; | |
this.scrollBar.y = this.textBackground.y; | |
scrollBar.setHeight(this.textBackground.height); | |
this.close.x = 0; | |
this.close.y = 5; | |
this.copy.x = 0; | |
this.copy.y = 5; | |
this.maxCountRowsTextField.x = 10; | |
this.maxCountRowsTextField.y = 5; | |
this.x = stage.stageWidth - this.background.width / 2; | |
this.y = stage.stageHeight - this.background.height / 2; | |
return; | |
} | |
private Getter function logMessagesLength() : int | |
{ | |
var loc0:* = this.maxCountRows; | |
if(this.logMessages.length < loc0) | |
{ | |
loc0 = this.logMessages.length; | |
} | |
return loc0; | |
} | |
public Setter function maxCountRows(arg0:int) | |
{ | |
var loc0:* = null; | |
if(arg0 > 0) | |
{ | |
this._maxCountRows = arg0; | |
loc0 = SharedObject.getLocal("yalogger"); | |
loc0.data.size = 30; | |
loc0.flush(); | |
} | |
return; | |
} | |
public Getter function maxCountRows() : int | |
{ | |
return this._maxCountRows; | |
} | |
private function maxCountRowsTextField_keyDownHandler(arg0:flash.events::KeyboardEvent) | |
{ | |
var loc0:* = 0; | |
if(arg0.keyCode == Keyboard.ENTER) | |
{ | |
loc0 = int(this.maxCountRowsTextField.text); | |
this.maxCountRows = loc0; | |
} | |
return; | |
} | |
private function getHTMLSpecial(arg0:String) : String | |
{ | |
return replace(new RegExp(">", "gm"), ">"); | |
} | |
private function createChildren() | |
{ | |
this.background = new this.ConsoleBackgroundSkin(); | |
addChild(this.background); | |
this.textBackground = new this.TextBackgroundSkin(); | |
addChild(this.textBackground); | |
this.logTextField = new TextField(); | |
this.logTextField.selectable = true; | |
this.logTextField.multiline = true; | |
this.logTextField.wordWrap = true; | |
this.logTextField.htmlText = logHTMLText; | |
addChild(this.logTextField); | |
this.scrollBar = new ScrollBar(); | |
addChild(this.scrollBar); | |
this.close = new this.CloseButtonSkin(); | |
addChild(this.close); | |
close.addEventListener(MouseEvent.CLICK, this.close_mouseClickHandler); | |
this.visible = false; | |
this.copy = new this.CopyButtonSkin(); | |
addChild(this.copy); | |
this.maxCountRowsTextField = new TextField(); | |
this.maxCountRowsTextField.type = TextFieldType.INPUT; | |
this.maxCountRowsTextField.width = 50; | |
this.maxCountRowsTextField.height = 14; | |
var loc0:* = new TextFormat(null, 10); | |
this.maxCountRowsTextField.defaultTextFormat = new TextFormat(null, 10); | |
this.maxCountRowsTextField.border = true; | |
this.maxCountRowsTextField.background = true; | |
this.maxCountRowsTextField.backgroundColor = 16777215; | |
addChild(this.maxCountRowsTextField); | |
var loc1:* = SharedObject.getLocal("yalogger"); | |
if(! && !) | |
{ | |
this._maxCountRows = loc1.data.size; | |
} | |
this.maxCountRowsTextField.text = 0; | |
copy.addEventListener(MouseEvent.CLICK, this.copy_mouseClickHandler); | |
maxCountRowsTextField.addEventListener(KeyboardEvent.KEY_DOWN, this.maxCountRowsTextField_keyDownHandler); | |
scrollBar.addEventListener(ScrollBarEvent.UPDATE_SCROLL_POSITION, this.scrollBar_updateScrollPositionHandler); | |
logTextField.addEventListener(MouseEvent.MOUSE_WHEEL, this.logTextField_mouseWhellHandler); | |
return; | |
} | |
private function copy_mouseClickHandler(arg0:flash.events::MouseEvent) | |
{ | |
System.setClipboard(this.logTextForClipboard); | |
this.logTextField.stage.focus = ; | |
logTextField.setSelection(0, this.logTextField.text.length); | |
return; | |
} | |
private function getFormattedMessage(arg0:String, arg1:uint) : String | |
{ | |
return "<p><font color='#" + arg1.toString(16) + "'>" + this.getHTMLSpecial(arg0) + "</font></p>"; | |
} | |
private function logTextField_mouseWhellHandler(arg0:flash.events::Event) | |
{ | |
this.scrollBar.position = this.logTextField.scrollV; | |
return; | |
} | |
public function addMessage(arg0:String, arg1:uint = 0) | |
{ | |
logTextMessages.push(arg0); | |
if(this.logTextMessages.length > this.maxCountRows) | |
{ | |
logTextMessages.shift(); | |
} | |
logMessages.push(this.getFormattedMessage(arg0, arg1)); | |
if(this.logMessages.length > this.maxCountRows) | |
{ | |
logMessages.shift(); | |
} | |
if(this.logTextField != null) | |
{ | |
this.logTextField.htmlText = logHTMLText; | |
this.logTextField.scrollV = this.logTextField.maxScrollV; | |
if(this.logTextField.maxScrollV > 1) | |
{ | |
this.scrollBar.rowsPerScreen = 0; | |
this.scrollBar.numRows = this.logTextField.numLines; | |
this.scrollBar.position = this.logTextField.numLines; | |
} | |
} | |
return; | |
} | |
private function addedToStageHandler(arg0:flash.events::Event) | |
{ | |
this.createChildren(); | |
this.setSize(); | |
return; | |
} | |
private function close_mouseClickHandler(arg0:flash.events::MouseEvent) | |
{ | |
this.visible = false; | |
return; | |
} | |
private function scrollBar_updateScrollPositionHandler(arg0:ru.yandex.lib.logger.events::ScrollBarEvent) | |
{ | |
this.logTextField.scrollV = this.scrollBar.position; | |
return; | |
} | |
private Getter function logHTMLText() : String | |
{ | |
var loc0:* = ""; | |
var loc1:* = 0; | |
while(loc1 < this.logMessagesLength) | |
{ | |
loc0 = loc0 + this.logMessages[loc1]; | |
loc1++; | |
} | |
return loc0; | |
} | |
private Getter function logTextForClipboard() : String | |
{ | |
var loc0:* = ""; | |
var loc1:* = 0; | |
while(loc1 < this.logMessagesLength) | |
{ | |
loc0 = loc0 + this.logTextMessages[loc1] + " | |
"; | |
loc1++; | |
} | |
return loc0; | |
} | |
} | |
public class Console_CopyButtonSkin extends mx.core::SpriteAsset | |
{ | |
//========================= Methods | |
public static function Console_CopyButtonSkin() | |
{ | |
return; | |
} | |
public function Console_CopyButtonSkin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class Console_ConsoleBackgroundSkin extends mx.core::SpriteAsset | |
{ | |
//========================= Methods | |
public static function Console_ConsoleBackgroundSkin() | |
{ | |
return; | |
} | |
public function Console_ConsoleBackgroundSkin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class Console_TextBackgroundSkin extends mx.core::SpriteAsset | |
{ | |
//========================= Methods | |
public static function Console_TextBackgroundSkin() | |
{ | |
return; | |
} | |
public function Console_TextBackgroundSkin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class Console_CloseButtonSkin extends mx.core::SpriteAsset | |
{ | |
//========================= Methods | |
public static function Console_CloseButtonSkin() | |
{ | |
return; | |
} | |
public function Console_CloseButtonSkin() | |
{ | |
super(); | |
return; | |
} | |
} | |
} | |
package ru.yandex.kraski.universalpainter.visual | |
{ | |
public class VisualFactory extends Object | |
{ | |
//========================= Variables | |
private var data : ClipartDescriptorsList; | |
//========================= Methods | |
public static function VisualFactory() | |
{ | |
return; | |
} | |
public function VisualFactory(arg0:ru.yandex.kraski.universalpainter.data::ClipartDescriptorsList) | |
{ | |
super(); | |
this.data = arg0; | |
return; | |
} | |
private function picture_deserializingCompleteHandler(arg0:ru.yandex.kraski.universalpainter.events::VisualEvent) | |
{ | |
var loc0:* = Picture(arg0.target); | |
loc0.removeEventListener(VisualEvent.DESERIALIZING_COMPLETE, this.picture_deserializingCompleteHandler); | |
if(loc0.content) | |
{ | |
loc0.content = 0; | |
} | |
return; | |
} | |
/* here's the magic ;-) */ | |
public function create(arg0:XML) : ru.yandex.kraski.universalpainter.visual::Visual | |
{ | |
coords = null; | |
xy = null; | |
clipartDescriptor = null; | |
clipart = null; | |
line = null; | |
lineDescriptor = null; | |
text = null; | |
picture = null; | |
photoframeDescriptor = null; | |
photoframe = null; | |
picNode = null; | |
pic = null; | |
photoframePicture = null; | |
eraser = null; | |
xml = arg0; | |
i = 0; | |
if(xml.type == "Clipart") | |
{ | |
clipartDescriptor = data.getDescriptorByBriefUrl(xml.resource.src); | |
if(clipartDescriptor != null) | |
{ | |
clipart = new Clipart(clipartDescriptor); | |
deserialize(xml); | |
} | |
return clipart; | |
} | |
if(xml.type == "Line") | |
{ | |
line = new Line(); | |
lineDescriptor = new LineDescriptor(); | |
lineDescriptor.color = 0; | |
lineDescriptor.size = xml.paint.size; | |
lineDescriptor.paintClass = 0; | |
coords = split(";"); | |
i = 0; | |
while(i < coords.length) | |
{ | |
xy = split(","); | |
addPoint(xy[0], xy[1]); | |
i = i + 1; | |
} | |
finish(); | |
line.lineData = lineDescriptor; | |
deserialize(xml); | |
return line; | |
} | |
if(xml.type == "Text") | |
{ | |
text = new Text(); | |
deserialize(xml); | |
return text; | |
} | |
/* HERE! */ | |
if(xml.type == "Picture") | |
{ | |
picture = new Picture(); | |
addEventListener(VisualEvent.DESERIALIZING_COMPLETE, this.picture_deserializingCompleteHandler); | |
deserialize(xml); | |
return picture; | |
} | |
if(xml.type == "Photoframe") | |
{ | |
photoframeDescriptor = data.getDescriptorByBriefUrl(xml.resource.src); | |
if(photoframeDescriptor != null) | |
{ | |
photoframe = new Photoframe(photoframeDescriptor); | |
deserialize(xml); | |
var loc1:* = 0; | |
var loc4:* = 0; | |
var loc5:* = xml.photos.visual; | |
var loc3:* = new XMLList(""); | |
for(loc4 in loc5) | |
{ | |
var loc6:* = loc5.__getNextEnumerablePropertyValue(); | |
var loc7:* = loc5.__getNextEnumerablePropertyValue(); | |
if(type == "PhotoframePicture") | |
{ | |
loc3.loc6 = 0; | |
} | |
} | |
var loc2:* = loc3; | |
for(loc1 in loc2) | |
{ | |
picNode = loc2.__getNextEnumerablePropertyValue(); | |
pic = (this.create(picNode[0])) as PhotoframePicture; | |
addPicture(pic); | |
} | |
} | |
return photoframe; | |
} | |
if(xml.type == "PhotoframePicture") | |
{ | |
photoframePicture = new PhotoframePicture(); | |
deserialize(xml); | |
photoframePicture.content = 0; | |
return photoframePicture; | |
} | |
if(xml.type == "Eraser") | |
{ | |
eraser = new Eraser(); | |
coords = split(";"); | |
i = 0; | |
while(i < coords.length) | |
{ | |
if(coords[i] != "") | |
{ | |
xy = split(","); | |
addPoint(Number(xy[0]), Number(xy[1])); | |
} | |
i = i + 1; | |
} | |
updateAfterLoad(); | |
return eraser; | |
} | |
return null; | |
} | |
} | |
public class Visual extends flash.display::Sprite | |
{ | |
//========================= Variables | |
private var _depth : int = 0; | |
public var _weight : Number = 0; | |
private var _creationOrder : int = 0; | |
private var _animationEnabled : Boolean = True; | |
//========================= Methods | |
public static function Visual() | |
{ | |
return; | |
} | |
public function Visual() | |
{ | |
super(); | |
return; | |
} | |
public Setter function animationEnabled(arg0:Boolean) | |
{ | |
if(this._animationEnabled != arg0) | |
{ | |
this._animationEnabled = arg0; | |
if(this._animationEnabled) | |
{ | |
this.resumeAnimation(); | |
} | |
else | |
{ | |
this.pauseAnimation(); | |
} | |
} | |
return; | |
} | |
public Getter function depth() : int | |
{ | |
return this._depth; | |
} | |
public Setter function depth(arg0:int) | |
{ | |
this._depth = arg0; | |
return; | |
} | |
public function clear() | |
{ | |
return; | |
} | |
public function showDrawingProcess() | |
{ | |
return; | |
} | |
public Setter function color(arg0:ru.yandex.utils::YaColor) | |
{ | |
return; | |
} | |
public function resumeAnimation() | |
{ | |
return; | |
} | |
public Getter function animationEnabled() : Boolean | |
{ | |
return this._animationEnabled; | |
} | |
public Setter function creationOrder(arg0:int) | |
{ | |
this._creationOrder = arg0; | |
return; | |
} | |
public function deserialize(arg0:XML) | |
{ | |
this.x = arg0.transform.x; | |
this.y = arg0.transform.y; | |
this.scaleX = arg0.transform.scaleX; | |
this.scaleY = arg0.transform.scaleY; | |
this.rotation = arg0.transform.rotation; | |
return; | |
} | |
public Getter function className() : String | |
{ | |
var loc0:* = getQualifiedClassName(this); | |
loc0 = loc0.substring(loc0.search("::") + 2); | |
return loc0; | |
} | |
public function showDrawingResult() | |
{ | |
return; | |
} | |
public function serialize() : XML | |
{ | |
return new XML("<visual type=\"" + Escape(this.className) + "\" creationOrder=\"" + Escape(this.creationOrder) + "\" depth=\"" + Escape(this.depth) + "\"> | |
" + "<transform x=\"" + Escape(x) + "\" y=\"" + Escape(y) + "\" scaleX=\"" + Escape(scaleX) + "\" scaleY=\"" + Escape(scaleY) + "\" rotation=\"" + Escape(rotation) + "\"/>" + " | |
</visual>"); | |
} | |
public Getter function color() : ru.yandex.utils::YaColor | |
{ | |
return new YaColor(); | |
} | |
public function pauseAnimation() | |
{ | |
return; | |
} | |
public Getter function creationOrder() : int | |
{ | |
return this._creationOrder; | |
} | |
public function distance(arg0:Number, arg1:Number) : Number | |
{ | |
return NaN; | |
} | |
public Getter function weight() : Number | |
{ | |
return this._weight; | |
} | |
public function destroy() | |
{ | |
return; | |
} | |
} | |
public class Line extends ru.yandex.kraski.universalpainter.visual::Visual | |
{ | |
//========================= Variables | |
private var _pointIndex : int; | |
private var timer : Timer; | |
private var _savedPoints : Array; | |
private var _paintClass : Class; | |
private var _lineData : LineDescriptor; | |
private var _paint : Paint; | |
private var _size : Number; | |
private var _color : YaColor; | |
private const DRAWING_INTERVAL : Number = 20; | |
//========================= Methods | |
public static function Line() | |
{ | |
return; | |
} | |
public function Line() | |
{ | |
this._color = new YaColor(); | |
this.timer = new Timer(this.DRAWING_INTERVAL); | |
super(); | |
this.mouseChildren = false; | |
this.mouseEnabled = false; | |
return; | |
} | |
private function destroyCurrentPaint() | |
{ | |
if(this._paint) | |
{ | |
_paint.clear(this); | |
this._paint = null; | |
} | |
return; | |
} | |
private function fillHandler(arg0:ru.yandex.kraski.universalpainter.events::LineEvent) | |
{ | |
this.restorePaint(); | |
return; | |
} | |
public function clear() | |
{ | |
this.clear(); | |
if(this.timer) | |
{ | |
this.stopTimer(); | |
} | |
return; | |
} | |
public function showDrawingProcess() | |
{ | |
this.showDrawingProcess(); | |
this._pointIndex = 255; | |
this._savedPoints = concat(); | |
this.setPoints([]); | |
timer.addEventListener(TimerEvent.TIMER, this.timerHandler); | |
timer.start(); | |
this.timerHandler(); | |
return; | |
} | |
private function finishPaint() | |
{ | |
_paint.finish(); | |
return; | |
} | |
private function timerHandler(arg0:flash.events::TimerEvent = null) | |
{ | |
if(this._pointIndex >= this._savedPoints.length - 1) | |
{ | |
this.stopTimer(); | |
this.finishPaint(); | |
dispatchEvent(new VisualEvent(VisualEvent.PLAY_FINISH)); | |
} | |
else | |
{ | |
var loc0:* = this; | |
var loc1:* = this._pointIndex + 1; | |
loc0._pointIndex = this._pointIndex; | |
_paint.appendPoint(this, this._savedPoints._pointIndex.x, this._savedPoints._pointIndex.y); | |
} | |
return; | |
} | |
public function resumeAnimation() | |
{ | |
this.resumeAnimation(); | |
_paint.resumeAnimation(); | |
return; | |
} | |
private function removeListeners() | |
{ | |
_lineData.removeEventListener(LineEvent.ADD_POINT, this.updateLineHandler); | |
_lineData.removeEventListener(LineEvent.FILL, this.fillHandler); | |
_lineData.removeEventListener(LineEvent.FINISH, this.finishHandler); | |
return; | |
} | |
private function updateProperties() | |
{ | |
this._size = this.lineData.size; | |
this._paintClass = this.lineData.paintClass; | |
_color.copy(new YaColor(this.lineData.color)); | |
this._paint = new this._paintClass(this._color.value, this._size); | |
this._paint.width = this.lineData.width; | |
this._paint.height = this.lineData.height; | |
this.restorePaint(); | |
return; | |
} | |
public function showDrawingResult() | |
{ | |
this.showDrawingResult(); | |
this.stopTimer(); | |
this.setPoints(this._savedPoints); | |
return; | |
} | |
private function stopTimer() | |
{ | |
timer.stop(); | |
timer.removeEventListener(TimerEvent.TIMER, this.timerHandler); | |
return; | |
} | |
private function addListeners() | |
{ | |
_lineData.addEventListener(LineEvent.ADD_POINT, this.updateLineHandler); | |
_lineData.addEventListener(LineEvent.FILL, this.fillHandler); | |
_lineData.addEventListener(LineEvent.FINISH, this.finishHandler); | |
return; | |
} | |
public function serialize() : XML | |
{ | |
var loc0:* = this.serialize(); | |
var loc1:* = ""; | |
var loc2:* = 0; | |
while(loc2 < this.lineData.points.length) | |
{ | |
loc1 = loc1 + this.lineData.points[loc2].x + "," + this.lineData.points[loc2].y; | |
if(loc2 != this.lineData.points.length - 1) | |
{ | |
loc1 = loc1 + ";"; | |
} | |
loc2++; | |
} | |
loc0.points = 0; | |
loc0.paint = this._paint.xml; | |
return loc0; | |
} | |
public Getter function lineData() : ru.yandex.kraski.universalpainter.data::LineDescriptor | |
{ | |
return this._lineData; | |
} | |
private function setPoints(arg0:Array) | |
{ | |
this.lineData.points = 0; | |
this.destroyCurrentPaint(); | |
this.updateProperties(); | |
return; | |
} | |
private function updateLineHandler(arg0:ru.yandex.kraski.universalpainter.events::LineEvent) | |
{ | |
_paint.appendPoint(this, arg0.x, arg0.y); | |
return; | |
} | |
public function pauseAnimation() | |
{ | |
this.pauseAnimation(); | |
_paint.pauseAnimation(); | |
return; | |
} | |
private function restorePaint() | |
{ | |
_paint.clear(this); | |
var loc0:* = 0; | |
while(loc0 < this.lineData.points.length) | |
{ | |
_paint.appendPoint(this, this.lineData.points[loc0].x, this.lineData.points[loc0].y); | |
loc0++; | |
} | |
this.finishPaint(); | |
return; | |
} | |
private function finishHandler(arg0:ru.yandex.kraski.universalpainter.events::LineEvent) | |
{ | |
this.finishPaint(); | |
return; | |
} | |
public Getter function weight() : Number | |
{ | |
return this._paint.pointWeight * this.lineData.points.length; | |
} | |
public Setter function lineData(arg0:ru.yandex.kraski.universalpainter.data::LineDescriptor) | |
{ | |
if(this._lineData) | |
{ | |
this.removeListeners(); | |
} | |
this._lineData = arg0; | |
this.addListeners(); | |
this.updateProperties(); | |
return; | |
} | |
public function deserialize(arg0:XML) | |
{ | |
this.deserialize(arg0); | |
return; | |
} | |
} | |
public class Background extends ru.yandex.kraski.universalpainter.visual::Visual | |
{ | |
//========================= Variables | |
public var _descriptor : ClipartDescriptor; | |
public var clipart : LibraryAsset; | |
public var _color : YaColor; | |
private var _playTimer : Timer; | |
//========================= Methods | |
public static function Background() | |
{ | |
return; | |
} | |
public function Background(arg0:ru.yandex.kraski.universalpainter.data::ClipartDescriptor) | |
{ | |
this._color = new YaColor(); | |
this._playTimer = new Timer(50); | |
super(); | |
this.mouseChildren = false; | |
this.mouseEnabled = false; | |
this._weight = VisualsWeight.BACKGROUND_WEIGHT; | |
this.descriptor = arg0; | |
this.clipart = arg0.getNewInstance(); | |
this.mouseChildren = false; | |
addChild(this.clipart); | |
this.clipart.colorableMovieClips = arg0.colorableMovieClips; | |
this.clipart.color = arg0.defaultColor; | |
this.color = new YaColor(this.clipart.color); | |
return; | |
} | |
private function startTimer() | |
{ | |
_playTimer.addEventListener(TimerEvent.TIMER, this.playTimerHandler); | |
_playTimer.start(); | |
return; | |
} | |
public Setter function color(arg0:ru.yandex.utils::YaColor) | |
{ | |
_color.copy(arg0); | |
this.clipart.color = this._color.value; | |
return; | |
} | |
public function clear() | |
{ | |
this.clear(); | |
if(this._playTimer) | |
{ | |
this.stopTimer(); | |
} | |
return; | |
} | |
private function setEffect() | |
{ | |
this.alpha = 0; | |
this.startTimer(); | |
return; | |
} | |
public function showDrawingProcess() | |
{ | |
this.showDrawingProcess(); | |
this.setEffect(); | |
return; | |
} | |
public function resumeAnimation() | |
{ | |
this.resumeAnimation(); | |
clipart.play(); | |
return; | |
} | |
private function playTimerHandler(arg0:flash.events::TimerEvent) | |
{ | |
if(alpha >= 1) | |
{ | |
this.clearEffect(); | |
dispatchEvent(new VisualEvent(VisualEvent.PLAY_FINISH)); | |
} | |
else | |
{ | |
this.alpha = alpha + 0,05; | |
} | |
return; | |
} | |
public Setter function descriptor(arg0:ru.yandex.kraski.universalpainter.data::ClipartDescriptor) | |
{ | |
this._descriptor = arg0; | |
return; | |
} | |
public function serialize() : XML | |
{ | |
var loc0:* = new XML("<background type=\"" + Escape(className) + "\"/>"); | |
loc0.appendChild(new XML("<resource src=\"" + Escape(this.descriptor.briefURL) + "\" symbol=\"" + Escape(this.descriptor.className) + "\" colorable=\"" + Escape(this.descriptor.colorableMovieClips) + "\" color=\"" + Escape(this.color.value) + "\"/>")); | |
return loc0; | |
} | |
public Getter function color() : ru.yandex.utils::YaColor | |
{ | |
return _color.clone(); | |
} | |
public function showDrawingResult() | |
{ | |
this.showDrawingResult(); | |
this.clearEffect(); | |
return; | |
} | |
private function stopTimer() | |
{ | |
_playTimer.stop(); | |
_playTimer.removeEventListener(TimerEvent.TIMER, this.playTimerHandler); | |
return; | |
} | |
public function pauseAnimation() | |
{ | |
this.pauseAnimation(); | |
clipart.stop(); | |
return; | |
} | |
public Getter function descriptor() : ru.yandex.kraski.universalpainter.data::ClipartDescriptor | |
{ | |
return this._descriptor; | |
} | |
private function clearEffect() | |
{ | |
this.alpha = 1; | |
this.stopTimer(); | |
return; | |
} | |
public function deserialize(arg0:XML) | |
{ | |
this.descriptor.briefURL = arg0.resource.src; | |
this.color = new YaColor(parseInt(arg0.resource.color)); | |
return; | |
} | |
} | |
public class Photoframe extends ru.yandex.kraski.universalpainter.visual::Visual | |
{ | |
//========================= Variables | |
private var _descriptor : ClipartDescriptor; | |
private var clipart : LibraryAsset; | |
private var photoButtonsNames : Array; | |
private var _color : YaColor; | |
private var showDrawingProcessIntervalId : uint; | |
//========================= Methods | |
public static function Photoframe() | |
{ | |
return; | |
} | |
public function Photoframe(arg0:ru.yandex.kraski.universalpainter.data::ClipartDescriptor) | |
{ | |
this._color = new YaColor(); | |
super(); | |
this._weight = VisualsWeight.PHOTOFRAME_WEIGHT; | |
this.descriptor = arg0; | |
this.clipart = arg0.getNewInstance(); | |
addChild(this.clipart); | |
this.photoButtonsNames = arg0.photoButtonsNames; | |
this.frameClip.mouseChildren = false; | |
this.frameClip.mouseEnabled = false; | |
this.initPhotoHandlers(); | |
return; | |
} | |
public function showUploadButtons() | |
{ | |
var loc1:* = null; | |
var loc2:* = null; | |
var loc0:* = 0; | |
while(loc0 < this.photoButtonsNames.length) | |
{ | |
loc1 = this.clipart[this.photoButtonsNames[loc0]]; | |
loc2 = this.clipart[0]; | |
if(this.getPhoto(loc2) == null) | |
{ | |
loc1.visible = true; | |
} | |
loc0++; | |
} | |
return; | |
} | |
private function initPhotoHandlers() | |
{ | |
var loc1:* = null; | |
var loc0:* = 0; | |
while(loc0 < this.photoButtonsNames.length) | |
{ | |
loc1 = this.clipart[this.photoButtonsNames[loc0]]; | |
loc1.addEventListener(MouseEvent.CLICK, this.photoButton_clickHandler); | |
loc1.addEventListener(MouseEvent.ROLL_OVER, this.photoButton_overHandler); | |
loc1.addEventListener(MouseEvent.ROLL_OUT, this.photoButton_outHandler); | |
loc0++; | |
} | |
loc0 = 0; | |
while(loc0 < this.photoButtonsNames.length) | |
{ | |
loc1 = this.clipart[0]; | |
loc1.addEventListener(MouseEvent.CLICK, this.photoContainer_clickHandler); | |
loc0++; | |
} | |
return; | |
} | |
public function setState(arg0:int) | |
{ | |
var loc0:* = arg0; | |
switch(loc0) | |
{ | |
case PhotoframeState.EDIT: | |
this.frameClip.alpha = 0,3; | |
return; | |
case PhotoframeState.DEFAULT: | |
this.frameClip.alpha = 1; | |
return; | |
default: | |
break; | |
} | |
return; | |
} | |
private function getUsedPhotos() : XML | |
{ | |
var loc2:* = null; | |
var loc0:* = ""; | |
var loc1:* = 0; | |
while(loc1 < this.photoButtonsNames.length) | |
{ | |
loc2 = this.clipart[0]; | |
if(this.getPhoto(loc2) != null) | |
{ | |
loc0 = loc0 + serialize(); | |
} | |
loc1++; | |
} | |
return new XML("<photos>" + loc0 + "</photos>"); | |
} | |
public function showDrawingProcess() | |
{ | |
this.showDrawingProcess(); | |
this.showDrawingProcessIntervalId = setTimeout(this.delayFinish, 700); | |
return; | |
} | |
private function photoButton_overHandler(arg0:flash.events::MouseEvent) | |
{ | |
CustomCursorManager.setCursorByName(CursorType.PHOTOFRAME); | |
return; | |
} | |
public function addPicture(arg0:ru.yandex.kraski.universalpainter.visual::PhotoframePicture) | |
{ | |
var loc0:* = (clipart.getChildByName(arg0.relativeContainerName)) as MovieClip; | |
var loc1:* = (clipart.getChildByName(arg0.relativeButtonName)) as MovieClip; | |
arg0.relativeContainer = 0; | |
arg0.relativeButton = 0; | |
arg0.relativeButton.visible = false; | |
loc0.addChild(arg0); | |
return; | |
} | |
public function hideUploadButtons() | |
{ | |
var loc0:* = 0; | |
while(loc0 < this.photoButtonsNames.length) | |
{ | |
MovieClip(this.clipart[this.photoButtonsNames[loc0]]).visible = false; | |
loc0++; | |
} | |
return; | |
} | |
public function serialize() : XML | |
{ | |
var loc0:* = new XML("<visual type=\"" + Escape(className) + "\" creationOrder=\"" + Escape(creationOrder) + "\" depth=\"" + Escape(depth) + "\"/>"); | |
loc0.appendChild(new XML("<resource src=\"" + Escape(this.descriptor.briefURL) + "\" symbol=\"" + Escape(this.descriptor.className) + "\" photoButtonsNames=\"" + Escape(this.descriptor.photoButtonsNames) + "\" color=\"" + Escape(color.value) + "\"/>")); | |
loc0.appendChild(this.getUsedPhotos()); | |
return loc0; | |
} | |
public function showDrawingResult() | |
{ | |
this.showDrawingResult(); | |
return; | |
} | |
public function getFirstPhotoframePicture() : ru.yandex.kraski.universalpainter.visual::PhotoframePicture | |
{ | |
var loc0:* = 0; | |
while(loc0 < this.photoButtonsNames.length) | |
{ | |
return this.getPhoto(this.clipart[0]); | |
loc0++; | |
} | |
return null; | |
} | |
private Getter function frameClip() : flash.display::MovieClip | |
{ | |
debug("preparing to get \"frame\""); | |
return this.clipart["frame"]; | |
} | |
public Setter function descriptor(arg0:ru.yandex.kraski.universalpainter.data::ClipartDescriptor) | |
{ | |
this._descriptor = arg0; | |
return; | |
} | |
public Getter function descriptor() : ru.yandex.kraski.universalpainter.data::ClipartDescriptor | |
{ | |
return this._descriptor; | |
} | |
private function delayFinish() | |
{ | |
clearTimeout(this.showDrawingProcessIntervalId); | |
dispatchEvent(new VisualEvent(VisualEvent.PLAY_FINISH)); | |
return; | |
} | |
private function photoButton_outHandler(arg0:flash.events::MouseEvent) | |
{ | |
CustomCursorManager.setCursorByName(CursorType.POINTER); | |
return; | |
} | |
private function photoContainer_clickHandler(arg0:flash.events::MouseEvent) | |
{ | |
if(arg0.target is PhotoframePicture) | |
{ | |
arg0.stopPropagation(); | |
dispatchEvent(new PhotoframePictureEvent(PhotoframePictureEvent.SELECT_PHOTO, (arg0.target) as PhotoframePicture)); | |
} | |
return; | |
} | |
public function destroy() | |
{ | |
var loc1:* = null; | |
var loc2:* = null; | |
var loc3:* = null; | |
this.destroy(); | |
var loc0:* = 0; | |
while(loc0 < this.photoButtonsNames.length) | |
{ | |
loc1 = this.clipart[this.photoButtonsNames[loc0]]; | |
loc1.removeEventListener(MouseEvent.CLICK, this.photoButton_clickHandler); | |
loc1.removeEventListener(MouseEvent.ROLL_OVER, this.photoButton_overHandler); | |
loc1.removeEventListener(MouseEvent.ROLL_OUT, this.photoButton_outHandler); | |
loc0++; | |
} | |
loc0 = 0; | |
while(loc0 < this.photoButtonsNames.length) | |
{ | |
loc2 = this.clipart[0]; | |
loc2.removeEventListener(MouseEvent.CLICK, this.photoContainer_clickHandler); | |
loc3 = this.getPhoto(loc2); | |
if(this.getPhoto(loc2)) | |
{ | |
loc3.destroy(); | |
} | |
loc0++; | |
} | |
removeChild(this.clipart); | |
this.clipart = null; | |
this.photoButtonsNames = null; | |
this._descriptor = null; | |
return; | |
} | |
private function getPhoto(arg0:flash.display::MovieClip) : ru.yandex.kraski.universalpainter.visual::PhotoframePicture | |
{ | |
if(arg0.numChildren == 1 && arg0.getChildAt(0) is PhotoframePicture) | |
{ | |
return (arg0.getChildAt(0)) as PhotoframePicture; | |
} | |
return null; | |
} | |
private function photoButton_clickHandler(arg0:flash.events::MouseEvent) | |
{ | |
var loc0:* = (clipart.getChildByName(arg0.target.name + "_container")) as MovieClip; | |
dispatchEvent(new PhotoframeEvent(PhotoframeEvent.UPLOAD_PHOTO, loc0, (arg0.target) as MovieClip)); | |
return; | |
} | |
public function deserialize(arg0:XML) | |
{ | |
this.descriptor.briefURL = arg0.resource.src; | |
return; | |
} | |
} | |
public class EditableVisual extends ru.yandex.kraski.universalpainter.visual::Visual implements {ru.yandex.transformer}::ITransformerClient | |
{ | |
//========================= Methods | |
public static function EditableVisual() | |
{ | |
return; | |
} | |
public function EditableVisual() | |
{ | |
super(); | |
return; | |
} | |
public function shift(arg0:Number, arg1:Number) | |
{ | |
this.x = x + arg0; | |
this.y = y + arg1; | |
return; | |
} | |
public function hitTest(arg0:Number, arg1:Number) : Boolean | |
{ | |
return false; | |
} | |
private function printGeom(arg0:String, arg1:flash.display::DisplayObject) | |
{ | |
debug("{0} | |
geom = {1}", arg0, arg1.transform.matrix); | |
debug("scaleX: {0}, scaleY: {1} | |
rotation: {2}", arg1.scaleX, arg1.scaleY, arg1.rotation); | |
return; | |
} | |
public function scale(arg0:Number) | |
{ | |
this.scaleX = scaleX * arg0; | |
this.scaleY = scaleY * arg0; | |
return; | |
} | |
public function flip() | |
{ | |
this.scaleX = scaleX * 255; | |
return; | |
} | |
public function unselect() | |
{ | |
return; | |
} | |
public function rotate(arg0:Number) | |
{ | |
this.rotation = rotation + arg0 / Math.PI * 180; | |
return; | |
} | |
public function select() | |
{ | |
return; | |
} | |
public Getter function transformerBounds() : flash.geom::Rectangle | |
{ | |
return getBounds(this); | |
} | |
public function setGeom(arg0:flash.geom::Matrix) | |
{ | |
this.printGeom("before geometry change:", this); | |
debug("setting new geom: {0}", arg0.clone()); | |
transform.matrix = 0; | |
this.printGeom("after geometry change:", this); | |
dispatchEvent(new VisualEvent(VisualEvent.GEOM_CHANGE)); | |
return; | |
} | |
} | |
public class Clipart extends ru.yandex.kraski.universalpainter.visual::EditableVisual | |
{ | |
//========================= Variables | |
private static const APPEARANCE_INTERVAL : Number = 500; | |
private var _descriptor : ClipartDescriptor; | |
private var clipart : LibraryAsset; | |
private var _color : YaColor; | |
//========================= Methods | |
public static function Clipart() | |
{ | |
this.APPEARANCE_INTERVAL = 500; | |
return; | |
} | |
public function Clipart(arg0:ru.yandex.kraski.universalpainter.data::ClipartDescriptor) | |
{ | |
this._color = new YaColor(); | |
super(); | |
this._weight = VisualsWeight.CLIPART_WEIGHT; | |
this.descriptor = arg0; | |
this.clipart = arg0.getNewInstance(); | |
this.mouseChildren = false; | |
var loc0:* = clipart.getBounds(this); | |
this.clipart.x = 0; | |
this.clipart.y = 0; | |
addChild(this.clipart); | |
this.clipart.colorableMovieClips = arg0.colorableMovieClips; | |
this.clipart.color = arg0.defaultColor; | |
this.color = new YaColor(this.clipart.color); | |
return; | |
} | |
public function hitTest(arg0:Number, arg1:Number) : Boolean | |
{ | |
return clipart.hitTestPoint(arg0, arg1, true); | |
} | |
public Setter function color(arg0:ru.yandex.utils::YaColor) | |
{ | |
_color.copy(arg0); | |
this.clipart.color = this._color.value; | |
return; | |
} | |
public function clear() | |
{ | |
this.clear(); | |
clipart.removeEventListener(LibraryAssetEvent.INTRO_FINISH, this.introFinishHandler); | |
clipart.stopAnimation(); | |
return; | |
} | |
public function showDrawingProcess() | |
{ | |
this.showDrawingProcess(); | |
clipart.addEventListener(LibraryAssetEvent.INTRO_FINISH, this.introFinishHandler); | |
clipart.startFullAnimation(); | |
return; | |
} | |
public function resumeAnimation() | |
{ | |
this.resumeAnimation(); | |
clipart.play(); | |
return; | |
} | |
public function playIntro() | |
{ | |
clipart.playIntro(); | |
return; | |
} | |
public function showDrawingResult() | |
{ | |
this.showDrawingResult(); | |
clipart.removeEventListener(LibraryAssetEvent.INTRO_FINISH, this.introFinishHandler); | |
clipart.stopAnimation(); | |
return; | |
} | |
public function serialize() : XML | |
{ | |
var loc0:* = this.serialize(); | |
loc0.resource = ; | |
return loc0; | |
} | |
public Getter function color() : ru.yandex.utils::YaColor | |
{ | |
return _color.clone(); | |
} | |
public Setter function descriptor(arg0:ru.yandex.kraski.universalpainter.data::ClipartDescriptor) | |
{ | |
this._descriptor = arg0; | |
return; | |
} | |
public function drawBox() | |
{ | |
var loc0:* = this.clipart.width; | |
var loc1:* = this.clipart.height; | |
graphics.clear(); | |
graphics.lineStyle(1, 0); | |
graphics.drawRect(-loc0 / 2, -loc1 / 2, loc0, loc1); | |
return; | |
} | |
public function hideBox() | |
{ | |
graphics.clear(); | |
return; | |
} | |
private function introFinishHandler(arg0:ru.yandex.kraski.universalpainter.events::LibraryAssetEvent) | |
{ | |
clipart.removeEventListener(LibraryAssetEvent.INTRO_FINISH, this.introFinishHandler); | |
dispatchEvent(new VisualEvent(VisualEvent.PLAY_FINISH)); | |
return; | |
} | |
public function startPreviewAnimation() | |
{ | |
clipart.startPreviewAnimation(); | |
return; | |
} | |
public Getter function descriptor() : ru.yandex.kraski.universalpainter.data::ClipartDescriptor | |
{ | |
return this._descriptor; | |
} | |
public function pauseAnimation() | |
{ | |
this.pauseAnimation(); | |
clipart.stop(); | |
return; | |
} | |
public function distance(arg0:Number, arg1:Number) : Number | |
{ | |
return ( (clipart.hitTestPoint(arg0, arg1, true))? 0 : 1000 ); | |
} | |
public Getter function transformerBounds() : flash.geom::Rectangle | |
{ | |
return clipart.getBounds(this); | |
} | |
public function deserialize(arg0:XML) | |
{ | |
this.deserialize(arg0); | |
this.descriptor.briefURL = arg0.resource.src; | |
this.color = new YaColor(parseInt(arg0.resource.color)); | |
return; | |
} | |
} | |
public class Eraser extends ru.yandex.kraski.universalpainter.visual::Visual | |
{ | |
//========================= Variables | |
private var size : Number; | |
private var _points : Array; | |
private var loaded : Boolean = False; | |
//========================= Methods | |
public static function Eraser() | |
{ | |
return; | |
} | |
public function Eraser(arg0:Number = 18) | |
{ | |
this._points = []; | |
super(); | |
this.size = arg0; | |
return; | |
} | |
public function serialize() : XML | |
{ | |
var loc0:* = this.serialize(); | |
var loc1:* = ""; | |
var loc2:* = 0; | |
while(loc2 < this._points.length) | |
{ | |
loc1 = loc1 + this._points[loc2].x + "," + this._points[loc2].y; | |
loc1 = loc1 + ";"; | |
loc2++; | |
} | |
loc0.points = 0; | |
return loc0; | |
} | |
public Setter function points(arg0:Array) | |
{ | |
this.loaded = true; | |
var loc0:* = 0; | |
while(loc0 < arg0.length) | |
{ | |
this.addPoint(arg0[loc0].x, arg0[loc0].y); | |
loc0++; | |
} | |
return; | |
} | |
public function addPoint(arg0:Number, arg1:Number) | |
{ | |
_points.push({"x" : arg0, "y" : arg1}); | |
if(this._points.length > 1) | |
{ | |
graphics.lineTo(arg0, arg1); | |
} | |
else | |
{ | |
graphics.beginFill(16777215); | |
graphics.lineStyle(0, 0, 0, false, "normal", "round"); | |
graphics.drawCircle(arg0, arg1, this.size / 2); | |
graphics.endFill(); | |
graphics.moveTo(arg0, arg1); | |
graphics.lineStyle(this.size, 0, 1, false, "normal", "round"); | |
} | |
return; | |
} | |
public Getter function weight() : Number | |
{ | |
return 0; | |
} | |
public function updateAfterLoad() | |
{ | |
this.loaded = true; | |
return; | |
} | |
public Getter function lastRect() : flash.geom::Rectangle | |
{ | |
var loc0:* = 0; | |
var loc1:* = NaN; | |
var loc2:* = NaN; | |
var loc3:* = NaN; | |
var loc4:* = NaN; | |
if(this.loaded) | |
{ | |
loc0 = this._points.length; | |
loc1 = Math.min(this._points[loc0].x, this._points[0].x) - this.size / 2; | |
loc2 = Math.min(this._points[loc0].y, this._points[0].y) - this.size / 2; | |
loc3 = this.size + Math.abs(this._points[0].x - this._points[loc0].x); | |
loc4 = this.size + Math.abs(this._points[0].y - this._points[loc0].y); | |
return new Rectangle(loc1, loc2, loc3, loc4); | |
} | |
return new Rectangle(0, 0, PaintCanvas.WIDTH, PaintCanvas.HEIGHT); | |
} | |
} | |
public class LibraryAsset extends flash.display::MovieClip | |
{ | |
//========================= Variables | |
private var _color : uint; | |
private var _brightness : Number = 0; | |
private var _colorableMovieClips : Array; | |
//========================= Methods | |
public static function LibraryAsset() | |
{ | |
return; | |
} | |
public function LibraryAsset() | |
{ | |
super(); | |
return; | |
} | |
public Getter function color() : uint | |
{ | |
return this._color; | |
} | |
public Setter function color(arg0:uint) | |
{ | |
this._color = arg0; | |
this.validate(); | |
return; | |
} | |
public Setter function colorableMovieClips(arg0:Array) | |
{ | |
this._colorableMovieClips = arg0.concat(); | |
return; | |
} | |
public function stopAnimation() | |
{ | |
this["_playFullAnimation"] = false; | |
gotoAndStop("stop"); | |
return; | |
} | |
public Getter function brightness() : Number | |
{ | |
return this._brightness; | |
} | |
private function applyFilter(arg0:flash.filters::BitmapFilter) | |
{ | |
var loc1:* = null; | |
var loc0:* = 0; | |
while(loc0 < this.colorableMovieClips.length) | |
{ | |
loc1 = (this[this.colorableMovieClips[loc0]]) as MovieClip; | |
loc1["mc_color"].filters = ; | |
loc0++; | |
} | |
return; | |
} | |
public Setter function brightness(arg0:Number) | |
{ | |
if(arg0 > 1) | |
{ | |
arg0 = 1; | |
} | |
else | |
{ | |
if(arg0 < 255) | |
{ | |
arg0 = 255; | |
} | |
} | |
this._brightness = arg0; | |
this.validate(); | |
return; | |
} | |
private function enterFrameHandler(arg0:flash.events::Event) | |
{ | |
if(this["_introAnimationFinished"]) | |
{ | |
dispatchEvent(new LibraryAssetEvent(LibraryAssetEvent.INTRO_FINISH)); | |
removeEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
this["_introAnimationFinished"] = false; | |
} | |
return; | |
} | |
private function validate() | |
{ | |
this.applyFilter(new ColorMatrixFilter(ColorUtils.createFilterMatrix(this.color, this.brightness))); | |
return; | |
} | |
public Getter function colorableMovieClips() : Array | |
{ | |
return _colorableMovieClips.concat(); | |
} | |
public function playIntro() | |
{ | |
this["_playFullAnimation"] = false; | |
gotoAndPlay("intro"); | |
return; | |
} | |
public function startFullAnimation() | |
{ | |
this["_playFullAnimation"] = true; | |
gotoAndPlay("intro"); | |
addEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
return; | |
} | |
public function startPreviewAnimation() | |
{ | |
this["_playFullAnimation"] = false; | |
gotoAndPlay("loop"); | |
return; | |
} | |
} | |
public class Picture extends ru.yandex.kraski.universalpainter.visual::EditableVisual | |
{ | |
//========================= Variables | |
private static var _serializeContent : Boolean = False; | |
private var _jpegData : ByteArray; | |
private var _index : int; | |
private var _content : Bitmap; | |
//========================= Methods | |
public static function Picture() | |
{ | |
this._serializeContent = false; | |
return; | |
} | |
public function Picture() | |
{ | |
super(); | |
this._weight = VisualsWeight.PICTURE_WEIGHT; | |
return; | |
} | |
public static Getter function serializeContent() : Boolean | |
{ | |
return this._serializeContent; | |
} | |
public static Setter function serializeContent(arg0:Boolean) | |
{ | |
this._serializeContent = ; | |
return; | |
} | |
public Getter function content() : flash.display::Bitmap | |
{ | |
return this._content; | |
} | |
public Getter function jpegData() : flash.utils::ByteArray | |
{ | |
return this._jpegData; | |
} | |
public function hitTest(arg0:Number, arg1:Number) : Boolean | |
{ | |
return ( (this._content)? _content.hitTestPoint(arg0, arg1, true) : false ); | |
} | |
public Setter function color(arg0:ru.yandex.utils::YaColor) | |
{ | |
return; | |
} | |
public function destroy() | |
{ | |
this.destroy(); | |
this.clearEffect(); | |
this._jpegData = null; | |
removeChild(this._content); | |
dispose(); | |
this._content = null; | |
return; | |
} | |
public function showDrawingProcess() | |
{ | |
this.showDrawingProcess(); | |
this.setEffect(); | |
return; | |
} | |
public Getter function index() : int | |
{ | |
return this._index; | |
} | |
private function setEffect() | |
{ | |
this.alpha = 0; | |
addEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
return; | |
} | |
private function enterFrameHandler(arg0:flash.events::Event) | |
{ | |
if(alpha >= 1) | |
{ | |
this.clearEffect(); | |
dispatchEvent(new VisualEvent(VisualEvent.PLAY_FINISH)); | |
} | |
else | |
{ | |
this.alpha = alpha + 0,05; | |
} | |
return; | |
} | |
private function completeHandler(arg0:flash.events::Event) | |
{ | |
var loc0:* = LoaderInfo(arg0.target); | |
loc0.removeEventListener(Event.COMPLETE, this.completeHandler); | |
this.content = Bitmap(loc0.content); | |
dispatchEvent(new VisualEvent(VisualEvent.CREATION_COMPLETE)); | |
return; | |
} | |
public function showDrawingResult() | |
{ | |
this.showDrawingResult(); | |
this.clearEffect(); | |
return; | |
} | |
public function serialize() : XML | |
{ | |
var loc1:* = null; | |
var loc0:* = this.serialize(); | |
loc0.pictureIndex = ; | |
if(Picture.serializeContent) | |
{ | |
debug("serializing content of {0}", this); | |
loc1 = new Base64Encoder(); | |
loc1.insertNewLines = false; | |
loc1.encodeBytes(this._jpegData); | |
loc0.appendChild(new XML("<content>" + loc1.toString().ToXmlString() + "</content>")); | |
} | |
return loc0; | |
} | |
public Setter function jpegData(arg0:flash.utils::ByteArray) | |
{ | |
this._jpegData = arg0; | |
var loc0:* = new Loader(); | |
addEventListener(Event.COMPLETE, this.completeHandler); | |
loc0.loadBytes(this._jpegData); | |
return; | |
} | |
public Setter function index(arg0:int) | |
{ | |
this._index = arg0; | |
return; | |
} | |
public Setter function content(arg0:flash.display::Bitmap) | |
{ | |
if(this._content) | |
{ | |
removeChild(this._content); | |
dispose(); | |
} | |
this._content = arg0; | |
if(this._content) | |
{ | |
this._content.smoothing = true; | |
this._content.x = 0; | |
this._content.y = 0; | |
addChild(this._content); | |
} | |
return; | |
} | |
public function distance(arg0:Number, arg1:Number) : Number | |
{ | |
return ( (_content.hitTestPoint(arg0, arg1, true))? 0 : 1000 ); | |
} | |
private function creationCompleteHandler(arg0:ru.yandex.kraski.universalpainter.events::VisualEvent) | |
{ | |
removeEventListener(VisualEvent.CREATION_COMPLETE, this.creationCompleteHandler); | |
dispatchEvent(new VisualEvent(VisualEvent.DESERIALIZING_COMPLETE)); | |
return; | |
} | |
public Getter function transformerBounds() : flash.geom::Rectangle | |
{ | |
return _content.getBounds(this); | |
} | |
private function clearEffect() | |
{ | |
this.alpha = 1; | |
removeEventListener(Event.ENTER_FRAME, this.enterFrameHandler); | |
return; | |
} | |
public function deserialize(arg0:XML) | |
{ | |
var loc0:* = null; | |
var loc1:* = null; | |
this.deserialize(arg0); | |
this._index = arg0.pictureIndex; | |
if(length() > 0) | |
{ | |
loc0 = text(); | |
loc1 = new Base64Decoder(); | |
loc1.decode(loc0); | |
addEventListener(VisualEvent.CREATION_COMPLETE, this.creationCompleteHandler); | |
this.jpegData = loc1.toByteArray(); | |
} | |
else | |
{ | |
dispatchEvent(new VisualEvent(VisualEvent.DESERIALIZING_COMPLETE)); | |
} | |
return; | |
} | |
} | |
public class Text extends ru.yandex.kraski.universalpainter.visual::EditableVisual | |
{ | |
//========================= Variables | |
private static const APPEARANCE_INTERVAL : int = 400; | |
private static const DEFAULT_FONT_SIZE : int = 24; | |
private var _text : String = ""; | |
private var _color : YaColor; | |
private var _font : Font; | |
private var tf : TextField; | |
//========================= Methods | |
public static function Text() | |
{ | |
this.APPEARANCE_INTERVAL = 400; | |
this.DEFAULT_FONT_SIZE = 24; | |
return; | |
} | |
public function Text() | |
{ | |
this._color = new YaColor(); | |
super(); | |
this._weight = VisualsWeight.TEXT_WEIGHT; | |
this.createTextField(); | |
return; | |
} | |
public function getBounds(arg0:flash.display::DisplayObject) : flash.geom::Rectangle | |
{ | |
var loc0:* = this.getBounds(arg0); | |
debug("bounds: {0}", loc0); | |
return loc0; | |
} | |
public function hitTest(arg0:Number, arg1:Number) : Boolean | |
{ | |
return tf.hitTestPoint(arg0, arg1, true); | |
} | |
public Setter function color(arg0:ru.yandex.utils::YaColor) | |
{ | |
_color.copy(arg0); | |
this.updateTextFormat(); | |
return; | |
} | |
public function showDrawingProcess() | |
{ | |
this.showDrawingProcess(); | |
dispatchEvent(new VisualEvent(VisualEvent.PLAY_FINISH)); | |
return; | |
} | |
public Getter function font() : flash.text::Font | |
{ | |
return this._font; | |
} | |
public function startEdit() | |
{ | |
info("Begin text edit"); | |
this.setTextEditable(); | |
this.tf.y = 0; | |
stage.focus = ; | |
tf.addEventListener(FocusEvent.FOCUS_OUT, this.focusOutHandler); | |
return; | |
} | |
private function focusOutHandler(arg0:flash.events::FocusEvent) | |
{ | |
if(stage) | |
{ | |
stage.focus = ; | |
} | |
return; | |
} | |
public Setter function text(arg0:String) | |
{ | |
this._text = arg0; | |
this.tf.text = ""; | |
dispatchEvent(new VisualEvent(VisualEvent.GEOM_CHANGE)); | |
return; | |
} | |
public Getter function selection() : ru.yandex.utils::Range | |
{ | |
return new Range(this.tf.selectionBeginIndex, this.tf.selectionEndIndex); | |
} | |
public function endEdit() | |
{ | |
info("End text edit"); | |
this.setTextNotEditable(); | |
tf.removeEventListener(FocusEvent.FOCUS_OUT, this.focusOutHandler); | |
return; | |
} | |
public function showDrawingResult() | |
{ | |
this.showDrawingResult(); | |
return; | |
} | |
public Setter function selection(arg0:ru.yandex.utils::Range) | |
{ | |
tf.setSelection(arg0.begin, arg0.end); | |
return; | |
} | |
public function serialize() : XML | |
{ | |
var loc0:* = this.serialize(); | |
loc0.text = this.tf.text; | |
loc0.font = this._font.fontName; | |
loc0.color = this.color.value; | |
return loc0; | |
} | |
public Getter function color() : ru.yandex.utils::YaColor | |
{ | |
return _color.clone(); | |
} | |
public Setter function font(arg0:flash.text::Font) | |
{ | |
this._font = arg0; | |
this.updateTextFormat(); | |
dispatchEvent(new VisualEvent(VisualEvent.GEOM_CHANGE)); | |
return; | |
} | |
private function setTextNotEditable() | |
{ | |
this.tf.type = TextFieldType.DYNAMIC; | |
this.tf.selectable = false; | |
this.tf.border = false; | |
tf.setSelection(0, 0); | |
return; | |
} | |
private function keyDownHandler(arg0:flash.events::KeyboardEvent) | |
{ | |
dispatchEvent(new TextEvent(TextEvent.TEXT_CHANGING)); | |
return; | |
} | |
private function updateTextFormat() | |
{ | |
var loc0:* = this.tf.defaultTextFormat; | |
if(this._font) | |
{ | |
loc0.font = this._font.fontName; | |
} | |
if(this._color) | |
{ | |
loc0.color = this._color.value; | |
} | |
this.tf.defaultTextFormat = this.tf.defaultTextFormat; | |
tf.setTextFormat(loc0); | |
return; | |
} | |
private function getDefaultTextFormat() : flash.text::TextFormat | |
{ | |
var loc0:* = new TextFormat(); | |
loc0.size = 24; | |
loc0.align = TextFormatAlign.CENTER; | |
return loc0; | |
} | |
private function createTextField() | |
{ | |
this.tf = new TextField(); | |
this.tf.x = 0; | |
this.tf.autoSize = TextFieldAutoSize.CENTER; | |
this.tf.multiline = true; | |
this.tf.embedFonts = true; | |
this.tf.defaultTextFormat = 0; | |
this.setTextNotEditable(); | |
tf.addEventListener(Event.CHANGE, this.changeHandler); | |
tf.addEventListener(KeyboardEvent.KEY_DOWN, this.keyDownHandler); | |
addChild(this.tf); | |
return; | |
} | |
private function setTextEditable() | |
{ | |
this.tf.type = TextFieldType.INPUT; | |
this.tf.selectable = true; | |
this.tf.border = true; | |
tf.setSelection(0, this.tf.length); | |
return; | |
} | |
public Getter function text() : String | |
{ | |
return this._text; | |
} | |
private function changeHandler(arg0:flash.events::Event) | |
{ | |
var loc0:* = this._text; | |
this._text = this.tf.text; | |
this.tf.y = 0; | |
var loc1:* = new TextEvent(TextEvent.TEXT_CHANGE); | |
loc1.oldText = ""; | |
loc1.newText = ""; | |
dispatchEvent(loc1); | |
return; | |
} | |
public function deserialize(arg0:XML) | |
{ | |
this.deserialize(arg0); | |
this.color = new YaColor(parseInt(arg0.color[0])); | |
this.text = arg0.text[0]; | |
var loc0:* = Font.enumerateFonts(); | |
var loc1:* = 0; | |
while(loc1 < loc0.length) | |
{ | |
if(loc0[loc1].fontName == arg0.font[0]) | |
{ | |
this.font = loc0[loc1]; | |
} | |
loc1++; | |
} | |
this.tf.y = 0; | |
return; | |
} | |
} | |
public class PhotoframePicture extends ru.yandex.kraski.universalpainter.visual::Picture | |
{ | |
//========================= Variables | |
private var _relativeContainerName : String; | |
private var _relativeButtonName : String; | |
private var _relativeContainer : MovieClip; | |
private var _relativeButton : MovieClip; | |
//========================= Methods | |
public static function PhotoframePicture() | |
{ | |
return; | |
} | |
public function PhotoframePicture() | |
{ | |
super(); | |
return; | |
} | |
public function serialize() : XML | |
{ | |
var loc0:* = this.serialize(); | |
loc0.relativeContainerName = this.relativeContainer.name; | |
loc0.relativeButtonName = this.relativeButton.name; | |
return loc0; | |
} | |
public Getter function relativeContainerName() : String | |
{ | |
return this._relativeContainerName; | |
} | |
public Setter function relativeContainer(arg0:flash.display::MovieClip) | |
{ | |
this._relativeContainer = arg0; | |
return; | |
} | |
public Setter function relativeContainerName(arg0:String) | |
{ | |
this._relativeContainerName = arg0; | |
return; | |
} | |
public Setter function relativeButtonName(arg0:String) | |
{ | |
this._relativeButtonName = arg0; | |
return; | |
} | |
public Getter function relativeContainer() : flash.display::MovieClip | |
{ | |
return this._relativeContainer; | |
} | |
public Getter function relativeButtonName() : String | |
{ | |
return this._relativeButtonName; | |
} | |
public function destroy() | |
{ | |
this.destroy(); | |
this._relativeButton = null; | |
this._relativeContainer = null; | |
var loc0:* = numChildren; | |
while(loc0 > 0) | |
{ | |
removeChildAt(0); | |
loc0 = loc0 - 1; | |
} | |
return; | |
} | |
public Setter function relativeButton(arg0:flash.display::MovieClip) | |
{ | |
this._relativeButton = arg0; | |
return; | |
} | |
public Getter function relativeButton() : flash.display::MovieClip | |
{ | |
return this._relativeButton; | |
} | |
public function deserialize(arg0:XML) | |
{ | |
this.deserialize(arg0); | |
this.relativeButtonName = arg0.relativeButtonName; | |
this.relativeContainerName = arg0.relativeContainerName; | |
return; | |
} | |
} | |
} | |
package ru.yandex.utils | |
{ | |
public class DisplayUtil extends Object | |
{ | |
//========================= Methods | |
public static function DisplayUtil() | |
{ | |
return; | |
} | |
public function DisplayUtil() | |
{ | |
super(); | |
return; | |
} | |
public static function removeAllChildren(arg0:flash.display::DisplayObjectContainer) | |
{ | |
while(arg0.numChildren) | |
{ | |
arg0.removeChildAt(0); | |
} | |
return; | |
} | |
} | |
public class YaColor extends flash.events::EventDispatcher | |
{ | |
//========================= Variables | |
private var _base : uint; | |
private var _value : uint; | |
private var _brightness : Number; | |
//========================= Methods | |
public static function YaColor() | |
{ | |
return; | |
} | |
public function YaColor(arg0:uint = 0) | |
{ | |
super(); | |
this.value = arg0; | |
return; | |
} | |
public static Getter function WHITE() : ru.yandex.utils::YaColor | |
{ | |
return new this(16777215); | |
} | |
public static Getter function BLACK() : ru.yandex.utils::YaColor | |
{ | |
return new this(0); | |
} | |
private function getIntermediateValue(arg0:uint, arg1:uint, arg2:Number) : uint | |
{ | |
if(arg2 <= 0) | |
{ | |
return arg0; | |
} | |
if(arg2 >= 1) | |
{ | |
return arg1; | |
} | |
return arg0 + uint(Math.round(arg2 * arg1 - arg0)); | |
} | |
public Getter function green() : uint | |
{ | |
return uint(this._value & 65280) >> 8; | |
} | |
public function isEquals(arg0:ru.yandex.utils::YaColor) : Boolean | |
{ | |
return this._base == arg0._base && this._brightness == arg0._brightness; | |
} | |
public function setRGB(arg0:uint, arg1:uint, arg2:uint) | |
{ | |
this.value = uint(arg0 << 16) + uint(arg1 << 8) + arg2; | |
return; | |
} | |
public Getter function base() : uint | |
{ | |
return this._base; | |
} | |
private function setBrightness(arg0:Number) | |
{ | |
if(arg0 < 255) | |
{ | |
this._brightness = 255; | |
} | |
else | |
{ | |
if(arg0 > 1) | |
{ | |
this._brightness = 1; | |
} | |
else | |
{ | |
this._brightness = arg0; | |
} | |
} | |
dispatchEvent(new Event("brightnessChange")); | |
return; | |
} | |
public function getTransformMatrix(arg0:ru.yandex.utils::YaColor) : Array | |
{ | |
return null; | |
} | |
public Getter function brightness() : Number | |
{ | |
return this._brightness; | |
} | |
private function setBase(arg0:int) | |
{ | |
this._base = arg0; | |
dispatchEvent(new Event("baseChange")); | |
return; | |
} | |
public function clone() : ru.yandex.utils::YaColor | |
{ | |
var loc0:* = new YaColor(this._base); | |
loc0.brightness = ; | |
return loc0; | |
} | |
public Getter function blue() : uint | |
{ | |
return uint(this._value & 255); | |
} | |
public Setter function brightness(arg0:Number) | |
{ | |
this.setBrightness(arg0); | |
this.updateValue(); | |
return; | |
} | |
private function updateValue() | |
{ | |
var loc0:* = new YaColor(this._base); | |
if(this._brightness > 0) | |
{ | |
loc0 = loc0.getIntermediateColor(this.WHITE, this._brightness); | |
} | |
else | |
{ | |
loc0 = BLACK.getIntermediateColor(loc0, this._brightness + 1); | |
} | |
this.setValue(loc0.value); | |
return; | |
} | |
public Setter function value(arg0:uint) | |
{ | |
this.setBrightness(0); | |
this.setBase(arg0); | |
this.setValue(arg0); | |
return; | |
} | |
public function toString() : String | |
{ | |
return "#" + _value.toString(16); | |
} | |
private function setValue(arg0:uint) | |
{ | |
this._value = arg0; | |
dispatchEvent(new Event("valueChange")); | |
return; | |
} | |
public Getter function value() : uint | |
{ | |
return this._value; | |
} | |
public function getIntermediateColor(arg0:ru.yandex.utils::YaColor, arg1:Number) : ru.yandex.utils::YaColor | |
{ | |
var loc0:* = new YaColor(); | |
loc0.setRGB(this.getIntermediateValue(this.red, arg0.red, arg1), this.getIntermediateValue(this.green, arg0.green, arg1), this.getIntermediateValue(this.blue, arg0.blue, arg1)); | |
return loc0; | |
} | |
public function copy(arg0:ru.yandex.utils::YaColor) | |
{ | |
this.setBase(arg0._base); | |
this.setBrightness(arg0._brightness); | |
this.updateValue(); | |
return; | |
} | |
public Setter function base(arg0:uint) | |
{ | |
this.setBase(arg0); | |
this.updateValue(); | |
return; | |
} | |
public Getter function red() : uint | |
{ | |
return uint(this._value & 16711680) >> 16; | |
} | |
} | |
public class YaNumberUtil extends Object | |
{ | |
//========================= Methods | |
public static function YaNumberUtil() | |
{ | |
return; | |
} | |
public function YaNumberUtil() | |
{ | |
super(); | |
return; | |
} | |
public static function getRandomFromRange(arg0:Number, arg1:Number) : Number | |
{ | |
return Math.random() * arg1 - arg0 + arg0; | |
} | |
public static function getLeadingZeroCount(arg0:Number) : Number | |
{ | |
var loc2:* = null; | |
var loc0:* = 0; | |
var loc1:* = arg0.toString(); | |
var loc3:* = 0; | |
while(loc3 < loc1.length) | |
{ | |
loc2 = loc1.charAt(loc3); | |
if(! && !) | |
{ | |
return loc0; | |
} | |
if(loc2 == "0") | |
{ | |
loc0 = loc0 + 1; | |
} | |
loc3++; | |
} | |
return loc0; | |
} | |
public static function equals(arg0:Number, arg1:Number, arg2:Number = 1E-06) : Boolean | |
{ | |
return Math.abs(arg0 - arg1) < arg2; | |
} | |
} | |
public class ColorUtils extends Object | |
{ | |
//========================= Methods | |
public static function ColorUtils() | |
{ | |
return; | |
} | |
public function ColorUtils() | |
{ | |
super(); | |
return; | |
} | |
public static function getRGB_R(arg0:Number) : Number | |
{ | |
return arg0 & 16711680 >> 16; | |
} | |
public static function getRGB_B(arg0:Number) : Number | |
{ | |
return arg0 & 255; | |
} | |
public static function createFilterMatrix(arg0:uint, arg1:Number = 0) : Array | |
{ | |
var loc0:* = new Array(); | |
var loc1:* = this.getRGB_R(arg0) / 255; | |
var loc2:* = this.getRGB_G(arg0) / 255; | |
var loc3:* = this.getRGB_B(arg0) / 255; | |
var loc4:* = arg1 * 255; | |
loc0 = loc0.concat([loc1, 0, 0, 0, loc4]); | |
loc0 = loc0.concat([0, loc2, 0, 0, loc4]); | |
loc0 = loc0.concat([0, 0, loc3, 0, loc4]); | |
loc0 = loc0.concat([0, 0, 0, 1, 0]); | |
return loc0; | |
} | |
public static function getRGB_G(arg0:Number) : Number | |
{ | |
return arg0 & 65280 >> 8; | |
} | |
} | |
public class Range extends Object | |
{ | |
//========================= Variables | |
private var _begin : int; | |
private var _end : int; | |
//========================= Methods | |
public static function Range() | |
{ | |
return; | |
} | |
public function Range(arg0:int = 0, arg1:int = 0) | |
{ | |
super(); | |
this._begin = arg0; | |
this._end = arg1; | |
return; | |
} | |
public Setter function begin(arg0:int) | |
{ | |
this._begin = arg0; | |
return; | |
} | |
public function copy(arg0:ru.yandex.utils::Range) | |
{ | |
this._begin = arg0._begin; | |
this._end = arg0._end; | |
return; | |
} | |
public Setter function end(arg0:int) | |
{ | |
this._end = arg0; | |
return; | |
} | |
public Getter function begin() : int | |
{ | |
return this._begin; | |
} | |
public Getter function end() : int | |
{ | |
return this._end; | |
} | |
} | |
} | |
package ru.yandex.transformer | |
{ | |
public interface ITransformerClient | |
{ | |
//========================= Methods | |
public Getter function transformerBounds() : flash.geom::Rectangle; | |
} | |
} | |
package ru.yandex.lib.logger.log | |
{ | |
public class Log extends Object | |
{ | |
//========================= Variables | |
private static var _targets : Array; | |
private static var _loggers : Array; | |
private static var _targetLevel : int; | |
private static var NONE : int = 2147483647; | |
//========================= Methods | |
public static function Log() | |
{ | |
this.NONE = int.MAX_VALUE; | |
this._targetLevel = 2147483647; | |
this._targets = ; | |
return; | |
} | |
public function Log() | |
{ | |
super(); | |
return; | |
} | |
public static function isDebug() : Boolean | |
{ | |
return ( (this._targetLevel <= LogEventLevel.DEBUG)? true : false ); | |
} | |
public static function flush() | |
{ | |
this._loggers = ; | |
this._targets = ; | |
this._targetLevel = 2147483647; | |
return; | |
} | |
private static function checkCategory(arg0:String) | |
{ | |
var loc0:* = null; | |
if((arg0 == null || arg0.length == 0)) | |
{ | |
loc0 = "invalid category length"; | |
} | |
if((this.hasIllegalCharacters(arg0) || !)) | |
{ | |
loc0 = "invalid category chars"; | |
} | |
return; | |
} | |
public static function getLogger(arg0:String) : mx.logging::ILogger | |
{ | |
var loc1:* = null; | |
this.checkCategory(arg0); | |
if(this._loggers) | |
{ | |
this._loggers = ; | |
} | |
var loc0:* = this._loggers[arg0]; | |
if(loc0 == null) | |
{ | |
loc0 = new LogLogger(arg0); | |
this._loggers.loc0 = ; | |
} | |
var loc2:* = 0; | |
while(loc2 < this._targets.length) | |
{ | |
loc1 = ILoggingTarget(this._targets[loc2]); | |
if(this.categoryMatchInFilterList(arg0, loc1.filters)) | |
{ | |
loc1.addLogger(loc0); | |
} | |
loc2++; | |
} | |
return loc0; | |
} | |
private static function categoryMatchInFilterList(arg0:String, arg1:Array) : Boolean | |
{ | |
var loc1:* = null; | |
var loc0:* = false; | |
var loc2:* = 255; | |
var loc3:* = 0; | |
while(loc3 < arg1.length) | |
{ | |
loc1 = arg1[loc3]; | |
loc2 = indexOf("*"); | |
if(indexOf("*") == 0) | |
{ | |
return true; | |
} | |
if(loc2 < 0) | |
{ | |
var loc4:* = arg0.length; | |
loc2 = arg0.length; | |
} | |
else | |
{ | |
} | |
loc2 = loc2 - 1; | |
if(arg0.substring(0, loc2) == loc1.substring(0, loc2)) | |
{ | |
return true; | |
} | |
loc3 = loc3 + 1; | |
} | |
return false; | |
} | |
public static function addTarget(arg0:mx.logging::ILoggingTarget) | |
{ | |
var loc0:* = null; | |
var loc1:* = null; | |
var loc2:* = null; | |
var loc3:* = null; | |
if(arg0) | |
{ | |
loc0 = arg0.filters; | |
var loc4:* = 0; | |
var loc5:* = this._loggers; | |
for(loc4 in loc5) | |
{ | |
loc2 = loc5.__getNextEnumerablePropertyName(); | |
if(this.categoryMatchInFilterList(loc2, loc0)) | |
{ | |
arg0.addLogger(ILogger(this._loggers[loc2])); | |
} | |
} | |
_targets.push(arg0); | |
if(this._targetLevel == this.NONE) | |
{ | |
this._targetLevel = arg0.level; | |
} | |
else | |
{ | |
if(arg0.level < this._targetLevel) | |
{ | |
this._targetLevel = arg0.level; | |
} | |
} | |
} | |
else | |
{ | |
loc3 = "invalid target!"; | |
} | |
return; | |
} | |
public static function hasIllegalCharacters(arg0:String) : Boolean | |
{ | |
return !; | |
} | |
public static function removeTarget(arg0:mx.logging::ILoggingTarget) | |
{ | |
var loc0:* = null; | |
var loc1:* = null; | |
var loc2:* = null; | |
var loc3:* = 0; | |
var loc4:* = null; | |
if(arg0) | |
{ | |
loc0 = arg0.filters; | |
var loc5:* = 0; | |
var loc6:* = this._loggers; | |
for(loc5 in loc6) | |
{ | |
loc2 = loc6.__getNextEnumerablePropertyName(); | |
if(this.categoryMatchInFilterList(loc2, loc0)) | |
{ | |
arg0.removeLogger(ILogger(this._loggers[loc2])); | |
} | |
} | |
loc3 = 0; | |
while(loc3 < this._targets.length) | |
{ | |
if(arg0 == this._targets[loc3]) | |
{ | |
_targets.splice(loc3, 1); | |
loc3 = loc3 - 1; | |
} | |
loc3++; | |
} | |
this.resetTargetLevel(); | |
} | |
else | |
{ | |
loc4 = "invalid target!"; | |
} | |
return; | |
} | |
public static function isWarn() : Boolean | |
{ | |
return ( (this._targetLevel <= LogEventLevel.WARN)? true : false ); | |
} | |
public static function isFatal() : Boolean | |
{ | |
return ( (this._targetLevel <= LogEventLevel.FATAL)? true : false ); | |
} | |
private static function resetTargetLevel() | |
{ | |
var loc0:* = this.NONE; | |
var loc1:* = 0; | |
while(loc1 < this._targets.length) | |
{ | |
if((loc0 == this.NONE || this._targets[loc1].level < loc0)) | |
{ | |
loc0 = this._targets[loc1].level; | |
} | |
loc1++; | |
} | |
this._targetLevel = this._targets[loc1].level; | |
return; | |
} | |
public static function isError() : Boolean | |
{ | |
return ( (this._targetLevel <= LogEventLevel.ERROR)? true : false ); | |
} | |
public static function isInfo() : Boolean | |
{ | |
return ( (this._targetLevel <= LogEventLevel.INFO)? true : false ); | |
} | |
} | |
public class LogLogger extends flash.events::EventDispatcher implements {mx.logging}::ILogger | |
{ | |
//========================= Variables | |
private var _category : String; | |
//========================= Methods | |
public static function LogLogger() | |
{ | |
return; | |
} | |
public function LogLogger(arg0:String) | |
{ | |
super(); | |
this._category = arg0; | |
return; | |
} | |
public function log(arg0:int, arg1:String) | |
{ | |
var loc1:* = null; | |
var loc2:* = 0; | |
if(arg0 < LogEventLevel.DEBUG) | |
{ | |
loc1 = "level limit!"; | |
} | |
if(hasEventListener(LogEvent.LOG)) | |
{ | |
loc2 = 0; | |
while(loc2 < loc0.length) | |
{ | |
arg1 = arg1.replace(new RegExp("\\{" + loc2 + "\\}", "g"), loc0[loc2]); | |
loc2++; | |
} | |
dispatchEvent(new LogEvent(arg1, arg0)); | |
} | |
return; | |
} | |
public Getter function category() : String | |
{ | |
return this._category; | |
} | |
public function fatal(arg0:String) | |
{ | |
var loc1:* = 0; | |
if(hasEventListener(LogEvent.LOG)) | |
{ | |
loc1 = 0; | |
while(loc1 < loc0.length) | |
{ | |
arg0 = arg0.replace(new RegExp("\\{" + loc1 + "\\}", "g"), loc0[loc1]); | |
loc1++; | |
} | |
dispatchEvent(new LogEvent(arg0, LogEventLevel.FATAL)); | |
} | |
return; | |
} | |
public function error(arg0:String) | |
{ | |
var loc1:* = 0; | |
if(hasEventListener(LogEvent.LOG)) | |
{ | |
loc1 = 0; | |
while(loc1 < loc0.length) | |
{ | |
arg0 = arg0.replace(new RegExp("\\{" + loc1 + "\\}", "g"), loc0[loc1]); | |
loc1++; | |
} | |
dispatchEvent(new LogEvent(arg0, LogEventLevel.ERROR)); | |
} | |
return; | |
} | |
public function warn(arg0:String) | |
{ | |
var loc1:* = 0; | |
if(hasEventListener(LogEvent.LOG)) | |
{ | |
loc1 = 0; | |
while(loc1 < loc0.length) | |
{ | |
arg0 = arg0.replace(new RegExp("\\{" + loc1 + "\\}", "g"), loc0[loc1]); | |
loc1++; | |
} | |
dispatchEvent(new LogEvent(arg0, LogEventLevel.WARN)); | |
} | |
return; | |
} | |
public function info(arg0:String) | |
{ | |
var loc1:* = 0; | |
if(hasEventListener(LogEvent.LOG)) | |
{ | |
loc1 = 0; | |
while(loc1 < loc0.length) | |
{ | |
arg0 = arg0.replace(new RegExp("\\{" + loc1 + "\\}", "g"), loc0[loc1]); | |
loc1++; | |
} | |
dispatchEvent(new LogEvent(arg0, LogEventLevel.INFO)); | |
} | |
return; | |
} | |
public function debug(arg0:String) | |
{ | |
var loc1:* = 0; | |
if(hasEventListener(LogEvent.LOG)) | |
{ | |
loc1 = 0; | |
while(loc1 < loc0.length) | |
{ | |
arg0 = arg0.replace(new RegExp("\\{" + loc1 + "\\}", "g"), loc0[loc1]); | |
loc1++; | |
} | |
dispatchEvent(new LogEvent(arg0, LogEventLevel.DEBUG)); | |
} | |
return; | |
} | |
} | |
} | |
package ru.yandex.lib.logger.events | |
{ | |
public class ScrollBarEvent extends flash.events::Event | |
{ | |
//========================= Variables | |
public static const UPDATE_SCROLL_POSITION : String = "updateScrollPosition"; | |
public var position : int = 0; | |
//========================= Methods | |
public static function ScrollBarEvent() | |
{ | |
this.UPDATE_SCROLL_POSITION = "updateScrollPosition"; | |
return; | |
} | |
public function ScrollBarEvent(arg0:String, arg1:Boolean = false, arg2:Boolean = false) | |
{ | |
super(arg0, arg1, arg2); | |
return; | |
} | |
} | |
} | |
package ru.yandex.lib.logger.view.scrollbar | |
{ | |
public class ScrollBar extends flash.display::Sprite | |
{ | |
//========================= Variables | |
private var _numRows : int = 1; | |
private var ScrollBarScrubSkin : Class; | |
private var _rowsPerScreen : int = 1; | |
private var ScrollButtonUpSkin : Class; | |
private var ScrollButtonDownSkin : Class; | |
private var buttonUp : Sprite; | |
private var background : Sprite; | |
private var scrub : Sprite; | |
private var ScrollBarBackground : Class; | |
private var buttonDown : Sprite; | |
//========================= Methods | |
public static function ScrollBar() | |
{ | |
return; | |
} | |
public function ScrollBar() | |
{ | |
this.ScrollBarBackground = ScrollBar_ScrollBarBackground; | |
this.ScrollBarScrubSkin = ScrollBar_ScrollBarScrubSkin; | |
this.ScrollButtonDownSkin = ScrollBar_ScrollButtonDownSkin; | |
this.ScrollButtonUpSkin = ScrollBar_ScrollButtonUpSkin; | |
super(); | |
this.background = new this.ScrollBarBackground(); | |
addChild(this.background); | |
background.addEventListener(MouseEvent.CLICK, this.background_clickHandler); | |
this.scrub = new this.ScrollBarScrubSkin(); | |
addChild(this.scrub); | |
this.scrub.x = 1; | |
scrub.addEventListener(MouseEvent.MOUSE_DOWN, this.scrub_mouseDownHandler); | |
this.buttonDown = new this.ScrollButtonDownSkin(); | |
addChild(this.buttonDown); | |
this.buttonDown.x = 1; | |
buttonDown.addEventListener(MouseEvent.CLICK, this.buttonDown_clickHandler); | |
this.buttonUp = new this.ScrollButtonUpSkin(); | |
addChild(this.buttonUp); | |
this.buttonUp.x = 1; | |
buttonUp.addEventListener(MouseEvent.CLICK, this.buttonUp_clickHandler); | |
return; | |
} | |
private function buttonUp_clickHandler(arg0:flash.events::MouseEvent) | |
{ | |
if(this.position > 0) | |
{ | |
this.position = this.position - 1; | |
} | |
if(this.position >= this.numRows - this.rowsPerScreen) | |
{ | |
this.position = this.numRows - this.rowsPerScreen - 1; | |
} | |
this.sentUpdateEvent(); | |
return; | |
} | |
private function stage_mouseMoveHandler(arg0:flash.events::MouseEvent) | |
{ | |
this.sentUpdateEvent(); | |
return; | |
} | |
private function buttonDown_clickHandler(arg0:flash.events::MouseEvent) | |
{ | |
this.position = this.position + 1; | |
this.sentUpdateEvent(); | |
return; | |
} | |
public Getter function rowsPerScreen() : int | |
{ | |
return this._rowsPerScreen; | |
} | |
public Setter function position(arg0:int) | |
{ | |
if(arg0 >= this.numRows - this.rowsPerScreen) | |
{ | |
this.scrub.y = 0; | |
return; | |
} | |
if(arg0 >= 0) | |
{ | |
this.scrub.y = 0; | |
} | |
return; | |
} | |
private function background_clickHandler(arg0:flash.events::MouseEvent) | |
{ | |
if(mouseY <= this.buttonUp.height) | |
{ | |
this.scrub.y = this.buttonUp.height; | |
} | |
else | |
{ | |
if(mouseY >= this.buttonUp.height + this.scrubAreaHeight - this.scrub.height) | |
{ | |
this.scrub.y = 0; | |
} | |
else | |
{ | |
this.scrub.y = mouseY; | |
} | |
} | |
this.sentUpdateEvent(); | |
return; | |
} | |
private function sentUpdateEvent() | |
{ | |
var loc0:* = new ScrollBarEvent(ScrollBarEvent.UPDATE_SCROLL_POSITION); | |
dispatchEvent(loc0); | |
return; | |
} | |
public Setter function rowsPerScreen(arg0:int) | |
{ | |
if(arg0 > 0) | |
{ | |
this._rowsPerScreen = arg0; | |
} | |
return; | |
} | |
private Getter function scrubAreaHeight() : Number | |
{ | |
return this.background.height - this.buttonDown.height - this.buttonUp.height; | |
} | |
public function setHeight(arg0:Number) | |
{ | |
if(arg0 > 0) | |
{ | |
this.background.height = ; | |
this.buttonUp.y = 0; | |
this.buttonDown.y = 0; | |
this.scrub.y = this.buttonUp.height; | |
this.scrub.height = scrubAreaHeight; | |
} | |
return; | |
} | |
private function stage_mouseUpHandler(arg0:flash.events::MouseEvent) | |
{ | |
stage.removeEventListener(MouseEvent.MOUSE_MOVE, this.stage_mouseMoveHandler); | |
stage.removeEventListener(MouseEvent.MOUSE_UP, this.stage_mouseUpHandler); | |
scrub.stopDrag(); | |
this.sentUpdateEvent(); | |
return; | |
} | |
public Getter function position() : int | |
{ | |
return Math.ceil(this.scrub.y - this.buttonUp.height * this.numRows / this.scrubAreaHeight - this.scrub.height); | |
} | |
private function scrub_mouseDownHandler(arg0:flash.events::MouseEvent) | |
{ | |
var loc0:* = new Rectangle(this.scrub.x, this.buttonUp.y + this.buttonUp.height, 0, this.scrubAreaHeight - this.scrub.height); | |
stage.addEventListener(MouseEvent.MOUSE_MOVE, this.stage_mouseMoveHandler); | |
stage.addEventListener(MouseEvent.MOUSE_UP, this.stage_mouseUpHandler); | |
scrub.startDrag(false, loc0); | |
return; | |
} | |
public Setter function numRows(arg0:int) | |
{ | |
if(arg0 > 0) | |
{ | |
this._numRows = arg0; | |
this.scrub.height = 0; | |
} | |
return; | |
} | |
public Getter function numRows() : int | |
{ | |
return this._numRows; | |
} | |
} | |
public class ScrollBar_ScrollButtonUpSkin extends mx.core::SpriteAsset | |
{ | |
//========================= Methods | |
public static function ScrollBar_ScrollButtonUpSkin() | |
{ | |
return; | |
} | |
public function ScrollBar_ScrollButtonUpSkin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class ScrollBar_ScrollButtonDownSkin extends mx.core::SpriteAsset | |
{ | |
//========================= Methods | |
public static function ScrollBar_ScrollButtonDownSkin() | |
{ | |
return; | |
} | |
public function ScrollBar_ScrollButtonDownSkin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class ScrollBar_ScrollBarScrubSkin extends mx.core::SpriteAsset | |
{ | |
//========================= Methods | |
public static function ScrollBar_ScrollBarScrubSkin() | |
{ | |
return; | |
} | |
public function ScrollBar_ScrollBarScrubSkin() | |
{ | |
super(); | |
return; | |
} | |
} | |
public class ScrollBar_ScrollBarBackground extends mx.core::SpriteAsset | |
{ | |
//========================= Methods | |
public static function ScrollBar_ScrollBarBackground() | |
{ | |
return; | |
} | |
public function ScrollBar_ScrollBarBackground() | |
{ | |
super(); | |
return; | |
} | |
} | |
} | |
package BrushCursor_fla | |
{ | |
public dynamic class kist_4 extends flash.display::MovieClip | |
{ | |
//========================= Variables | |
public var tip : MovieClip; | |
//========================= Methods | |
public static function kist_4() | |
{ | |
return; | |
} | |
public function kist_4() | |
{ | |
super(); | |
return; | |
} | |
} | |
public dynamic class kraska_9 extends flash.display::MovieClip | |
{ | |
//========================= Variables | |
public var body : MovieClip; | |
//========================= Methods | |
public static function kraska_9() | |
{ | |
return; | |
} | |
public function kraska_9() | |
{ | |
super(); | |
return; | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment