Files
Burrowdev 04f468af2c feat: stats graphs, playtime, ip search against ban evasion, 150-char chat
- stats graphs for the admin and moderator panels (lib/stats.js, public/stats-view.html)
- playtime, private unless shown on the card's bio tab; set on the account page
- search accounts by ip address, only against ban evasion; mods see no addresses and each search is logged
- privacy policy for the above (terms version 2026-10-17)
- the per-second save looks only at accounts in play, with a slow sweep of the rest
- items in several dens at once; chat filter hides slurs and threats by default
- sexual usernames refused; moderators may enter full rooms; guide login allowed
- 150-character chat box (client build 55)
- fixes: gifts, trades, dens, pets in dens, den recycling, special animals' colours,
  jammer walls, settings switches; the buddy list sent at login
- the item giver, the rules screen and the art studio rework
2026-10-17 02:00:57 +03:00

4625 lines
159 KiB
ActionScript

// from Strawberry Jam (another AJ Classic client), its art studio rework, used
// with its author's permission; Burrow's changes: buying several copies at once
// (their QuantityInputPopup) is left out, so Buy is the game's one-copy flow.
package game.artStudioPainting
{
import collection.DenItemCollection;
import com.adobe.images.PNGEncoder;
import com.sbi.analytics.SBTracker;
import com.sbi.debug.DebugUtility;
import com.sbi.graphics.JPEGAsyncCompleteEvent;
import com.sbi.graphics.JpegAsynchEncoder;
import com.sbi.popup.SBOkPopup;
import com.sbi.popup.SBYesNoPopup;
import currency.UserCurrency;
import den.DenItem;
import den.DenXtCommManager;
import diamond.DiamondXtCommManager;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.DisplayObject;
import flash.display.GradientType;
import flash.display.Graphics;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.display.MovieClip;
import flash.display.Shape;
import flash.display.SpreadMethod;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.HTTPStatusEvent;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.events.ProgressEvent;
import flash.filters.BlurFilter;
import flash.filters.DropShadowFilter;
import flash.filters.GlowFilter;
import flash.geom.ColorTransform;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.media.SoundChannel;
import flash.net.FileFilter;
import flash.net.FileReference;
import flash.net.SharedObject;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.net.URLRequestHeader;
import flash.text.TextField;
import flash.text.TextFieldType;
import flash.text.TextFormat;
import flash.ui.Keyboard;
import flash.ui.Mouse;
import flash.ui.MouseCursor;
import flash.utils.ByteArray;
import flash.utils.getTimer;
import game.GameBase;
import game.IMinigame;
import game.MinigameManager;
import gui.DarkenManager;
import gui.GenericListGuiManager;
import gui.GuiManager;
import gui.GuiSoundButton;
import gui.ItemReceivedPopup;
import gui.LoadingSpiral;
import gui.MasterpiecePreview;
import gui.RecycleItems;
import gui.SubmissionRulesPopup;
import item.ItemXtCommManager;
import loader.MediaHelper;
import localization.LocalizationManager;
import shop.ShopManager;
import flash.events.FocusEvent;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import game.ArtStudioKit;
import flash.display.BitmapDataChannel;
import flash.filters.ColorMatrixFilter;
import flash.filters.ConvolutionFilter;
public class ArtStudioPainting extends GameBase implements IMinigame
{
private static const TYPE_ARTSTUDIO:int = 14;
private static const TYPE_ARTSTUDIO_MASTERPIECE:int = 20;
private static const POPUP_X:int = 450;
private static const POPUP_Y:int = 275;
private static const ORIGIN:Point = new Point(0,0);
private static const CHOOSE_MASTERPIECE_POPUP_ID:int = 4811;
private static const ITEMS_PER_SCREEN:int = 4;
private static var _blurMasks:Object = {};
private static const NUM_LAYERS:int = 7;
private static const MAX_UNDO:int = 40;
private static const PAN_MARGIN:int = 60;
private var _overCanvas:Boolean;
private var _placingSrc:BitmapData;
private var _layerBlends:Array = ["normal","normal","normal","normal","normal","normal","normal"];
private var _layerLocks:Array = [false,false,false,false,false,false,false];
private var _menuBtn:MovieClip;
private var _viewFlipped:Boolean;
private var _fillShapes:Boolean;
private var _smoothing:Number = 0;
private var _smX:Number = 0;
private var _smY:Number = 0;
private var _gradShape:Shape = new Shape();
private var _sizeRing:Shape = new Shape();
private var _sizeRingRadius:Number = -1;
private var _adjustBase:BitmapData;
private var _adjustKind:String;
private var _spaceHeld:Boolean;
private static const TOKEN_TIMEOUT_MS:int = 20000;
private static const COPY_GAP_MS:int = 1200;
private static const UPLOAD_TIMEOUT_MS:int = 60000;
private var _undoBtn:MovieClip;
private var _redoBtn:MovieClip;
private var _importBtn:MovieClip;
private var _exportBtn:MovieClip;
private var _colorPanel:MovieClip;
private var _toolBtns:Object;
private var _modTool:int;
private var _toolBeforePick:int = 1;
private var _sizeSlider:MovieClip;
private var _opacitySlider:MovieClip;
private var _softSlider:MovieClip;
private var _zoomInBtn:MovieClip;
private var _zoomOutBtn:MovieClip;
private var _zoomLabelBtn:MovieClip;
private var _layerChips:Array;
private var _layerThumbs:Array;
private var _thumbChecker:BitmapData;
private var _eyeBtn:MovieClip;
private var _upBtn:MovieClip;
private var _downBtn:MovieClip;
private var _mergeBtn:MovieClip;
private var _layerOpacitySlider:MovieClip;
private var _canvasW:int;
private var _canvasH:int;
private var _canvasMask:Shape;
private var _copyPopup:Object;
private var _copyFreeSlots:int = 1;
private var _copiesWanted:int = 1;
private var _copiesDone:int;
private var _copiesNote:String = "";
private var _copyBanner:Sprite;
private var _copyBannerStamp:int;
private var _submitPending:Boolean;
private var _submitTimer:uint;
private var _uploadLoader:URLLoader;
private var _pencilShape:Shape;
private var _prevFrameRate:Number;
private const FRAME_SELECT_FILTER_DARKER:GlowFilter = new GlowFilter(3047612,1,5,5,15);
private const FRAME_SELECT_FILTER_LIGHTER:GlowFilter = new GlowFilter(3648190,1,7,7,15);
private const FRAME_SELECT_FILTER_MOUSE_OVER:GlowFilter = new GlowFilter(16777215,1,10,10,15);
private const TOOL_BLUR:int = 9;
private const TOOL_EYEDROP:int = 10;
private var _myId:uint;
private var _pIDs:Array;
private var _dbIDs:Array;
private const TOOL_ERASER:int = 11;
private var _sceneLoaded:Boolean;
private var _bInit:Boolean;
private var _exitConfirmationActive:Boolean;
private var _interfaceObject:Object;
private const TOOL_PEN:int = 12;
private const TOOL_HAND:int = 13;
private const TOOL_GRADIENT:int = 14;
private static const SMOOTHING:Array = [0,0.55,0.8];
private var _brush:Object;
private var _layerBackground:Sprite;
private var _layerInterface:Sprite;
private var _layerMouse:Sprite;
private var _submitButton:MovieClip;
private var _clearAllButton:MovieClip;
private var _printBtn:MovieClip;
private var _masterpieceSubmitBtn:MovieClip;
private var _storageButton:MovieClip;
private var _brushOpacity:Number = 1;
private var _jpgEncoder:JpegAsynchEncoder;
private var _selectBackground:Object;
private var _drawBitmapUndoSnapShot:BitmapData;
private var _lastPenX:Number;
private var _lastPenY:Number;
private var _drawBitmapUndo:Bitmap;
private var _defaultBitmapData:BitmapData;
private const MIN_SIZE:int = 1;
private const MAX_SIZE:int = 300;
private var _brushSizeVal:int = 10;
private var _drawBitmapDataSnapShot:BitmapData;
private var _drawBitmapSnapShot:Bitmap;
private var _drawBitmapData:BitmapData;
private var _encodingBitmapData:BitmapData;
private var _layerBitmapDatas:Array;
private var _layerBitmaps:Array;
private var _activeLayerIndex:int = 0;
private var _layersContainer:Sprite;
private var _drawBitmap:Bitmap;
private var _drawGraphics:Sprite;
private var _drawCanvas:Sprite;
private var _drawSize:Number;
private var _activeBrush:Object;
private var _drawing:Boolean;
private var _drawStartX:Number;
private var _drawStartY:Number;
private var _currentTool:int;
private var _drawBitmapDataRect:Rectangle;
private var _drawPoint_0_0:Point;
private var _undoable:Boolean;
private var _undoStack:Array = [];
private var _redoStack:Array = [];
private var _airbrushes:Array;
private var _drawSizes:Array;
private var _printBackground:Object;
private var _smudges:Array;
private var _activeSmudge:Object;
private var _hasDrawn:Boolean;
private var _needsSave:Boolean;
private var _frameTime:Number;
private var _lastTime:Number;
private var _uploadFileRef:FileReference;
private var _timeSinceErase:Number;
private var _pencilMoved:Boolean = false;
private var _sharedObject:SharedObject;
private var _musicLoop:SoundChannel;
private var _keepAliveTimer:Number;
private var _mediaHelper:MediaHelper;
private var _chooseMasterpiecePopup:MovieClip;
private var _masterpiecePreviewIconIds:Array;
private var _masterpiecePreviewIcons:Array;
private var _masterpiecePreviewIconIdsOrdered:Array;
private var _iconMediaHelpers:Array;
private var _masterpiecePreviewPopup:MasterpiecePreview;
private var _masterpiecePreviewIconStrIds:Array;
private var _currPreviewIndex:int;
private var _currItemVersion:int;
private var _denPreviewInvId:int;
private var _airbrushCache:Object = {};
private var _smudgeCache:Object = {};
private var _recyclePopup:RecycleItems;
private var _submissionRules:SubmissionRulesPopup;
private var _itemReceivedPopup:ItemReceivedPopup;
private var _isMasterpieceSubmit:Boolean;
private var _exitAfterSave:Boolean;
private var _itemOffset:int;
private var _URLStatus:int;
private var _mediaLoader:MediaHelper;
private var _mediaObject:MovieClip;
private var _numMasterpieceTokens:int;
private var _isUsingTokens:Boolean;
private var _masterPieceSubmissionToken:String;
private var _brushHardness:Number = 1;
private var _masterpieceUuid:String;
private var _fileRef:FileReference;
private var _zoomLevel:Number = 1;
private var _minZoom:Number = 0.25;
private var _maxZoom:Number = 4;
private var _zoomStep:Number = 0.25;
private var _isPanning:Boolean = false;
private var _panStartX:Number;
private var _panStartY:Number;
private var _canvasOriginalX:Number;
private var _canvasOriginalY:Number;
private var _layerOpacities:Array = [1,1,1,1,1,1,1];
public function ArtStudioPainting()
{
super();
}
private static function px(n:Number) : int
{
return int(n + 0.5);
}
public function start(param1:uint, param2:Array) : void
{
_myId = param1;
_pIDs = param2;
DarkenManager.checkParentForPosition = false;
init();
}
public function end(param1:Array) : void
{
var k:int = 0;
stopSubmitWatchdog();
_submitPending = false;
_copiesWanted = 1;
_copiesDone = 0;
if(_copyPopup != null)
{
_copyPopup.destroy();
_copyPopup = null;
}
ArtStudioKit.cancelPlace();
ArtStudioKit.closeMenu();
ArtStudioKit.closeDialog(false);
ArtStudioKit.stopSliderDrag();
ArtStudioKit.setTipLayer(null);
if(_sharedObject != null && _interfaceObject != null && _interfaceObject.loader != null && _interfaceObject.loader.content != null)
{
_sharedObject.data.userColors = _interfaceObject.loader.content.saveColors();
try
{
_sharedObject.flush();
}
catch(e:Error)
{
}
}
DarkenManager.checkParentForPosition = true;
if(_chooseMasterpiecePopup != null)
{
try
{
DarkenManager.unDarken(_chooseMasterpiecePopup);
}
catch(e:Error)
{
}
}
Mouse.cursor = MouseCursor.AUTO;
Mouse.show();
try
{
releaseBase();
}
catch(e:Error)
{
trace("[ArtStudioPainting] end: ERROR in releaseBase() - " + e.message);
}
if(_musicLoop)
{
_musicLoop.stop();
_musicLoop = null;
}
if(_jpgEncoder != null)
{
try
{
_jpgEncoder.removeEventListener("JPEGAsyncComplete",asyncEncodingComplete);
_jpgEncoder.removeEventListener("progress",onEncodingProgress);
}
catch(e:Error)
{
}
_jpgEncoder = null;
}
_chooseMasterpiecePopup = null;
if(stage)
{
stage.removeEventListener("enterFrame",heartbeat);
stage.removeEventListener("mouseMove",moveMouse);
stage.removeEventListener("mouseUp",endDraw);
stage.removeEventListener("keyDown",onKeyDown);
stage.removeEventListener("keyUp",onKeyUp);
stage.removeEventListener(MouseEvent.MOUSE_MOVE,updatePan);
stage.removeEventListener(MouseEvent.MOUSE_UP,endPan);
stage.removeEventListener("mouseWheel",onMouseWheel);
}
if(_prevFrameRate && stage)
{
stage.frameRate = _prevFrameRate;
}
if(_drawCanvas)
{
_drawCanvas.removeEventListener("mouseDown",startDraw);
_drawCanvas.removeEventListener("mouseOver",drawCanvasMouseOver);
_drawCanvas.removeEventListener("mouseOut",drawCanvasMouseOut);
}
clearRedo();
while(_undoStack.length > 0)
{
disposeState(_undoStack.pop());
}
if(_layerThumbs != null)
{
k = 0;
while(k < _layerThumbs.length)
{
(_layerThumbs[k] as BitmapData).dispose();
k++;
}
_layerThumbs = null;
}
if(_thumbChecker != null)
{
_thumbChecker.dispose();
_thumbChecker = null;
}
_bInit = false;
try
{
removeLayer(_layerBackground);
removeLayer(_layerInterface);
removeLayer(_layerMouse);
removeLayer(_guiLayer);
if(_layerBitmapDatas != null)
{
k = 0;
while(k < _layerBitmapDatas.length)
{
(_layerBitmapDatas[k] as BitmapData).dispose();
k++;
}
}
_drawBitmapUndoSnapShot.dispose();
_drawBitmapUndo = null;
_defaultBitmapData.dispose();
_drawBitmapDataSnapShot.dispose();
_drawBitmapSnapShot = null;
_layerBackground = null;
_layerInterface = null;
_layerMouse = null;
_guiLayer = null;
}
catch(e:Error)
{
trace("[ArtStudioPainting] end: ERROR during cleanup - " + e.message);
}
try
{
MinigameManager.leave();
}
catch(e:Error)
{
trace("[ArtStudioPainting] end: ERROR calling MinigameManager.leave() - " + e.message);
throw e;
}
}
private function onMediaLoaded(param1:MovieClip) : void
{
_mediaObject = param1;
}
private function getCompositeColor(x:int, y:int) : uint
{
var sampler:BitmapData = new BitmapData(1,1,true,0);
var m:Matrix = new Matrix(1,0,0,1,-x,-y);
var i:int = 0;
while(i < _layerBitmaps.length)
{
var bmp:Bitmap = _layerBitmaps[i] as Bitmap;
if(!(!bmp || !bmp.visible))
{
sampler.draw(bmp,m,null,null,null,true);
}
i++;
}
var col:uint = sampler.getPixel32(0,0);
sampler.dispose();
return col;
}
private function init() : void
{
var _loc7_:Array;
var _loc10_:Matrix;
_undoStack = [];
_redoStack = [];
var _loc9_:int = 0;
var _loc1_:Shape = null;
var _loc11_:BitmapData = null;
var _loc8_:* = undefined;
var _loc2_:int = 0;
var _loc3_:int = 0;
var _loc5_:* = 0;
var _loc6_:* = 0;
var _loc12_:Shape = null;
var _loc4_:Matrix = null;
_mediaLoader = new MediaHelper();
_mediaLoader.init(5556,onMediaLoaded);
try
{
_sharedObject = SharedObject.getLocal(gMainFrame.userInfo.myUserName);
if(_sharedObject.data.userSubmits == null)
{
_sharedObject.data.userSubmits = [];
_sharedObject.flush();
}
}
catch(e:Error)
{
_sharedObject = null;
}
_lastTime = getTimer();
_frameTime = 0;
_timeSinceErase = 0;
_keepAliveTimer = 0;
_drawGraphics = new Sprite();
_drawSizes = new Array(2,5,10,20,35,50);
_loc7_ = new Array(3,4,5,6,7,8);
_airbrushes = [];
_smudges = [];
_masterpiecePreviewIconIds = [];
_masterpiecePreviewIcons = [];
_iconMediaHelpers = [];
_masterpiecePreviewIconStrIds = [];
_loc10_ = new Matrix();
_loc9_ = 0;
while(_loc9_ < _drawSizes.length)
{
_smudges[_loc9_] = {};
_smudges[_loc9_].radius = _loc7_[_loc9_];
_smudges[_loc9_].weightVector = new Vector.<Number>(_smudges[_loc9_].radius * 2 * _smudges[_loc9_].radius * 2,true);
_loc1_ = new Shape();
_loc11_ = new BitmapData(_smudges[_loc9_].radius * 2,_smudges[_loc9_].radius * 2,true,0);
_loc10_.createGradientBox(_smudges[_loc9_].radius * 2,_smudges[_loc9_].radius * 2,0,0,0);
_loc1_.graphics.beginGradientFill("radial",[16777215,16777215],[0.75,0],[0,255],_loc10_,"pad");
_loc1_.graphics.drawCircle(_smudges[_loc9_].radius,_smudges[_loc9_].radius,_smudges[_loc9_].radius);
_loc11_.draw(_loc1_);
_loc8_ = _loc11_.getVector(new Rectangle(0,0,_smudges[_loc9_].radius * 2,_smudges[_loc9_].radius * 2));
_loc2_ = 0;
while(_loc2_ < _smudges[_loc9_].radius * 2)
{
_loc3_ = 0;
while(_loc3_ < _smudges[_loc9_].radius * 2)
{
_loc5_ = _loc8_[_loc2_ * _smudges[_loc9_].radius * 2 + _loc3_];
_loc6_ = _loc5_ >> 24 & 0xFF;
_smudges[_loc9_].weightVector[_loc2_ * _smudges[_loc9_].radius * 2 + _loc3_] = (255 - _loc6_) / 255;
_loc3_++;
}
_loc2_++;
}
_airbrushes[_loc9_] = {};
_airbrushes[_loc9_].diameter = _drawSizes[_loc9_];
_airbrushes[_loc9_]._drawOffSet = Math.floor(_drawSizes[_loc9_] / 2);
_airbrushes[_loc9_]._drawTranslateMatrix = new Matrix();
_loc12_ = new Shape();
_loc12_.graphics.beginFill(2013265919,0.15);
_loc12_.graphics.drawCircle(0,0,_drawSizes[_loc9_] / 2);
_loc12_.graphics.endFill();
_loc4_ = new Matrix();
_loc4_.tx = _loc12_.width / 2;
_loc4_.ty = _loc12_.height / 2;
_airbrushes[_loc9_]._drawBrushData = new BitmapData(_loc12_.width,_loc12_.height,true,16711680);
_airbrushes[_loc9_]._drawBrushData.draw(_loc12_,_loc4_);
_loc9_++;
}
if(!_bInit)
{
_layerBackground = new Sprite();
_layerInterface = new Sprite();
_layerMouse = new Sprite();
_guiLayer = new Sprite();
addChild(_layerInterface);
addChild(_layerBackground);
addChild(_guiLayer);
addChild(_layerMouse);
loadScene("ArtStudioPaint/room_main.xroom");
_bInit = true;
_exitConfirmationActive = false;
}
else
{
startGame();
}
}
private function startDraw(param1:MouseEvent) : void
{
var _loc2_:* = 0;
if(ArtStudioKit.isPlacing() || ArtStudioKit.isDialogOpen())
{
return;
}
if(isHandActive())
{
startPan(param1);
return;
}
if(!_pauseGame && _brush && _brush.loader.content)
{
var _activeBitmapData:BitmapData = _layerBitmapDatas[_activeLayerIndex];
var preset:int = int(_interfaceObject.loader.content.brushSize);
if(preset >= 1 && preset <= _drawSizes.length)
{
_brushSizeVal = _drawSizes[preset - 1];
}
_drawSize = _brushSizeVal;
_currentTool = _interfaceObject.loader.content.currentTool;
if(_currentTool == TOOL_EYEDROP || param1.altKey)
{
pickColorAt(_drawCanvas.mouseX,_drawCanvas.mouseY,_currentTool == TOOL_EYEDROP);
return;
}
if(_currentTool == TOOL_ERASER && _layerLocks[_activeLayerIndex])
{
flashTip(_menuBtn,"This layer's transparency is locked (Menu > Lock Transparency).");
return;
}
if(!(_layerBitmaps[_activeLayerIndex] as Bitmap).visible)
{
flashTip(_eyeBtn,"This layer is hidden. Show it to paint on it.");
return;
}
pushUndo([_activeLayerIndex],false);
_interfaceObject.loader.content.newHistory(_interfaceObject.loader.content.red,_interfaceObject.loader.content.green,_interfaceObject.loader.content.blue);
switch(_currentTool - 1)
{
case 0:
if(_pencilShape)
{
if(_pencilShape.parent)
{
_pencilShape.parent.removeChild(_pencilShape);
}
_pencilShape.graphics.clear();
}
_pencilShape = new Shape();
_pencilMoved = false;
var penColor:uint = uint(_interfaceObject.loader.content.red << 16 | _interfaceObject.loader.content.green << 8 | _interfaceObject.loader.content.blue);
var penAlpha:Number = _brushOpacity;
_pencilShape.graphics.lineStyle(_drawSize,penColor,penAlpha,true);
var startX:int = Math.round(_drawCanvas.mouseX);
var startY:int = Math.round(_drawCanvas.mouseY);
_pencilShape.graphics.moveTo(startX,startY);
_smX = startX;
_smY = startY;
_drawCanvas.addChild(_pencilShape);
_drawing = true;
break;
case 2:
_activeBrush = getAirbrush(_brushSizeVal);
_drawing = true;
moveMouse(param1);
break;
case 1:
case 3:
case 5:
case 7:
_drawGraphics.graphics.clear();
_drawBitmapDataSnapShot.fillRect(_drawBitmapDataRect,0);
_drawCanvas.addChild(_drawBitmapSnapShot);
_drawStartX = _drawCanvas.mouseX;
_drawStartY = _drawCanvas.mouseY;
_drawing = true;
break;
case 4:
_loc2_ = uint(-16777216 | _interfaceObject.loader.content.red << 16 | _interfaceObject.loader.content.green << 8 | _interfaceObject.loader.content.blue);
_activeBitmapData.floodFill(_drawCanvas.mouseX,_drawCanvas.mouseY,_loc2_);
applyAlphaLock();
refreshLayerThumb(_activeLayerIndex);
syncCanvasButtons();
_needsSave = true;
break;
case 6:
_activeSmudge = getSmudge(_brushSizeVal >> 1);
_drawStartX = _drawCanvas.mouseX;
_drawStartY = _drawCanvas.mouseY;
_drawing = true;
break;
case TOOL_BLUR - 1:
_drawing = true;
_drawSize = _brushSizeVal;
break;
case TOOL_ERASER - 1:
_drawing = true;
_drawSize = _brushSizeVal;
_activeBitmapData = _layerBitmapDatas[_activeLayerIndex];
_drawGraphics.graphics.clear();
_drawGraphics.graphics.beginFill(0,1);
_drawGraphics.graphics.drawCircle(_drawCanvas.mouseX,_drawCanvas.mouseY,_drawSize / 2);
_drawGraphics.graphics.endFill();
_activeBitmapData.draw(_drawGraphics,null,null,BlendMode.ERASE);
_drawGraphics.graphics.clear();
_drawGraphics.graphics.lineStyle(_drawSize,0,1,false,"round","round",3);
_drawGraphics.graphics.moveTo(_drawCanvas.mouseX,_drawCanvas.mouseY);
_drawStartX = _drawCanvas.mouseX;
_drawStartY = _drawCanvas.mouseY;
break;
case TOOL_GRADIENT - 1:
_drawing = true;
_drawStartX = _drawCanvas.mouseX;
_drawStartY = _drawCanvas.mouseY;
_drawCanvas.addChild(_gradShape);
drawGradientPreview();
break;
case TOOL_PEN - 1:
_drawing = true;
stampPenCircleAt(_drawCanvas.mouseX,_drawCanvas.mouseY);
_lastPenX = _drawCanvas.mouseX;
_lastPenY = _drawCanvas.mouseY;
_smX = _lastPenX;
_smY = _lastPenY;
}
}
}
private function getCompositePixel(x:int, y:int) : uint
{
var i:int = _layerBitmapDatas.length - 1;
while(i >= 0)
{
var bmp:Bitmap = _layerBitmaps[i] as Bitmap;
if(!(!bmp || !bmp.visible))
{
var bd:BitmapData = _layerBitmapDatas[i];
if(!(x < 0 || y < 0 || x >= bd.width || y >= bd.height))
{
var px:uint = bd.getPixel32(x,y);
var a:uint = uint(px >> 24 & 0xFF);
if(a != 0)
{
return px;
}
}
}
i--;
}
return 0;
}
private function endDraw(param1:MouseEvent) : void
{
if(_drawing)
{
var _activeBitmapData:BitmapData = _layerBitmapDatas[_activeLayerIndex];
_drawing = false;
_masterpieceSubmitBtn.guiBtn.setGrayState(false);
if(_submitButton != null)
{
_submitButton.guiBtn.setGrayState(false);
}
_printBtn.guiBtn.setGrayState(false);
_clearAllButton.guiBtn.setGrayState(false);
_needsSave = true;
_hasDrawn = true;
if(_currentTool - 1 == 0 && _pencilShape != null)
{
var penColor2:uint = uint(_interfaceObject.loader.content.red << 16 | _interfaceObject.loader.content.green << 8 | _interfaceObject.loader.content.blue);
var penAlpha2:Number = _brushOpacity;
var softness:Number = 1 - _brushHardness;
var blurAmount:Number = softness * (_drawSize * 0.5);
if(!_pencilMoved)
{
var dot:Shape = new Shape();
dot.graphics.beginFill(penColor2,penAlpha2);
dot.graphics.drawCircle(_drawCanvas.mouseX,_drawCanvas.mouseY,_drawSize * 0.5);
dot.graphics.endFill();
if(softness <= 0)
{
dot = new Shape();
dot.graphics.beginFill(penColor2,penAlpha2);
dot.graphics.drawCircle(_drawCanvas.mouseX,_drawCanvas.mouseY,_drawSize * 0.5);
dot.graphics.endFill();
_activeBitmapData.draw(dot,null,null,BlendMode.NORMAL);
dot.graphics.clear();
}
else
{
var blurRad:int = Math.ceil(blurAmount);
var tempSize:int = _drawSize + 2 * blurRad;
var dotBD:BitmapData = new BitmapData(tempSize,tempSize,true,0);
dot = new Shape();
dot.graphics.beginFill(penColor2,penAlpha2);
dot.graphics.drawCircle(tempSize / 2,tempSize / 2,_drawSize * 0.5);
dot.graphics.endFill();
dotBD.draw(dot);
var bfDot:BlurFilter = new BlurFilter(blurAmount,blurAmount,1);
dotBD.applyFilter(dotBD,dotBD.rect,new Point(0,0),bfDot);
var stampX:Number = _drawCanvas.mouseX - tempSize * 0.5;
var stampY:Number = _drawCanvas.mouseY - tempSize * 0.5;
var placeMat:Matrix = new Matrix(1,0,0,1,stampX,stampY);
_activeBitmapData.draw(dotBD,placeMat,null,BlendMode.NORMAL);
dotBD.dispose();
dot.graphics.clear();
}
dot.graphics.clear();
}
else if(softness > 0)
{
var bounds:Rectangle = _pencilShape.getBounds(_drawCanvas);
blurRad = Math.ceil(blurAmount);
var padW:int = 2 * blurRad;
var padH:int = 2 * blurRad;
var pxBD:BitmapData = new BitmapData(Math.ceil(bounds.width) + padW,Math.ceil(bounds.height) + padH,true,0);
var mat:Matrix = new Matrix();
mat.translate(-bounds.x + blurRad,-bounds.y + blurRad);
pxBD.draw(_pencilShape,mat);
var bfStroke:BlurFilter = new BlurFilter(blurAmount,blurAmount,1);
pxBD.applyFilter(pxBD,pxBD.rect,new Point(0,0),bfStroke);
var drawMat:Matrix = new Matrix();
drawMat.translate(bounds.x - blurRad,bounds.y - blurRad);
_activeBitmapData.draw(pxBD,drawMat);
pxBD.dispose();
}
else
{
_activeBitmapData.draw(_pencilShape,null,null,BlendMode.NORMAL);
}
if(_pencilShape.parent)
{
_pencilShape.parent.removeChild(_pencilShape);
}
_pencilShape = null;
}
else
{
switch(_currentTool - 2)
{
case 0:
case 2:
case 4:
case 6:
_drawBitmapSnapShot.parent.removeChild(_drawBitmapSnapShot);
_drawBitmapDataSnapShot.copyPixels(_activeBitmapData,_drawBitmapDataRect,_drawPoint_0_0);
_activeBitmapData.draw(_drawGraphics);
}
if(_brushOpacity >= 1)
{
switch(_currentTool - 1)
{
case 0:
case 1:
case 3:
case 5:
case 7:
var diff:Object = _drawBitmapDataSnapShot.compare(_activeBitmapData);
if(diff)
{
var solidColor:uint = uint(-16777216 | _interfaceObject.loader.content.red << 16 | _interfaceObject.loader.content.green << 8 | _interfaceObject.loader.content.blue);
var diffBD:BitmapData = diff;
_activeBitmapData.threshold(diffBD,_drawBitmapDataRect,_drawPoint_0_0,"!=",0,solidColor);
break;
}
}
}
}
if(_currentTool == TOOL_GRADIENT)
{
commitGradient();
}
applyAlphaLock();
refreshLayerThumb(_activeLayerIndex);
}
}
private function moveMouse(param1:Event) : void
{
var _loc4_:Number = Number(NaN);
var _loc9_:Number = Number(NaN);
var _loc8_:* = NaN;
var _loc7_:* = NaN;
var _loc5_:* = NaN;
var _loc3_:* = NaN;
var _loc2_:int = 0;
var _loc6_:* = undefined;
if(_sceneLoaded && _brush)
{
var _activeBitmapData:BitmapData = _layerBitmapDatas[_activeLayerIndex];
_brush.loader.x = mouseX;
_brush.loader.y = mouseY;
updateSizeRing();
if(_drawing)
{
switch(_currentTool - 1)
{
case 0:
if(_pencilShape)
{
_pencilMoved = true;
smoothStep(_drawCanvas.mouseX,_drawCanvas.mouseY);
var nextX:int = Math.round(_smX);
var nextY:int = Math.round(_smY);
_pencilShape.graphics.lineTo(nextX,nextY);
}
break;
case 1:
_drawGraphics.graphics.clear();
_drawBitmapDataSnapShot.fillRect(_drawBitmapDataRect,0);
_drawGraphics.graphics.lineStyle(_drawSize,-16777216 | _interfaceObject.loader.content.red << 16 | _interfaceObject.loader.content.green << 8 | _interfaceObject.loader.content.blue,1,false,"normal","square","miter");
_drawGraphics.graphics.moveTo(_drawStartX,_drawStartY);
_drawGraphics.graphics.lineTo(_drawCanvas.mouseX,_drawCanvas.mouseY);
_drawGraphics.graphics.endFill();
_drawBitmapDataSnapShot.draw(_drawGraphics);
break;
case 2:
_activeBrush._drawTranslateMatrix.tx = _drawCanvas.mouseX - _activeBrush._drawOffSet;
_activeBrush._drawTranslateMatrix.ty = _drawCanvas.mouseY - _activeBrush._drawOffSet;
var ct2:ColorTransform = _brush.loader.content.brushTip.transform.colorTransform;
ct2.alphaMultiplier = _brushOpacity;
var softness2:Number = 1 - _brushHardness;
var blurAmt2:Number = softness2 * (_activeBrush.diameter * 0.5);
softness2 = 1 - _brushHardness;
blurAmt2 = softness2 * (_activeBrush.diameter * 0.5);
_activeBitmapData.lock();
if(softness2 > 0)
{
var blurRad2:int = Math.ceil(blurAmt2);
var tempBrushSize:int = _activeBrush.diameter + 2 * blurRad2;
var brushTempBD:BitmapData = new BitmapData(tempBrushSize,tempBrushSize,true,0);
var matCenter:Matrix = new Matrix();
matCenter.translate(blurRad2,blurRad2);
brushTempBD.draw(_activeBrush._drawBrushData,matCenter);
var bf2:BlurFilter = new BlurFilter(blurAmt2,blurAmt2,1);
brushTempBD.applyFilter(brushTempBD,brushTempBD.rect,new Point(0,0),bf2);
var stampX2:Number = _drawCanvas.mouseX - tempBrushSize * 0.5;
var stampY2:Number = _drawCanvas.mouseY - tempBrushSize * 0.5;
var placeMat2:Matrix = new Matrix(1,0,0,1,stampX2,stampY2);
_activeBitmapData.draw(brushTempBD,placeMat2,ct2,BlendMode.NORMAL,null,true);
brushTempBD.dispose();
}
else
{
_activeBitmapData.draw(_activeBrush._drawBrushData,_activeBrush._drawTranslateMatrix,ct2,BlendMode.NORMAL,null,true);
}
_activeBitmapData.unlock(new Rectangle(_drawCanvas.mouseX - _activeBrush._drawOffSet - blurRad2,_drawCanvas.mouseY - _activeBrush._drawOffSet - blurRad2,tempBrushSize,tempBrushSize));
break;
case 3:
_drawGraphics.graphics.clear();
_drawBitmapDataSnapShot.fillRect(_drawBitmapDataRect,0);
_drawGraphics.graphics.lineStyle(_drawSize,-16777216 | _interfaceObject.loader.content.red << 16 | _interfaceObject.loader.content.green << 8 | _interfaceObject.loader.content.blue,1,false,"normal","square","miter");
if(_fillShapes)
{
_drawGraphics.graphics.beginFill(ArtStudioKit.currentColor(_interfaceObject.loader.content),1);
}
_drawGraphics.graphics.drawRect(Math.min(_drawStartX,_drawCanvas.mouseX),Math.min(_drawStartY,_drawCanvas.mouseY),Math.abs(_drawCanvas.mouseX - _drawStartX),Math.abs(_drawCanvas.mouseY - _drawStartY));
_drawGraphics.graphics.endFill();
_drawBitmapDataSnapShot.draw(_drawGraphics);
break;
case 5:
_drawGraphics.graphics.clear();
_drawBitmapDataSnapShot.fillRect(_drawBitmapDataRect,0);
_drawGraphics.graphics.lineStyle(_drawSize,-16777216 | _interfaceObject.loader.content.red << 16 | _interfaceObject.loader.content.green << 8 | _interfaceObject.loader.content.blue);
if(_fillShapes)
{
_drawGraphics.graphics.beginFill(ArtStudioKit.currentColor(_interfaceObject.loader.content),1);
}
_drawGraphics.graphics.drawEllipse(_drawStartX - Math.abs(_drawCanvas.mouseX - _drawStartX),_drawStartY - Math.abs(_drawCanvas.mouseY - _drawStartY),Math.abs(_drawCanvas.mouseX - _drawStartX) * 2,Math.abs(_drawCanvas.mouseY - _drawStartY) * 2);
_drawGraphics.graphics.endFill();
_drawBitmapDataSnapShot.draw(_drawGraphics);
break;
case 6:
_loc8_ = _drawStartX;
_loc7_ = _drawStartY;
_loc5_ = _loc8_;
_loc3_ = _loc7_;
_loc2_ = 1;
_loc6_ = _activeBitmapData.getVector(_drawBitmapDataRect);
if(_drawCanvas.mouseX != _drawStartX)
{
_loc4_ = (_drawCanvas.mouseY - _drawStartY) / (_drawCanvas.mouseX - _drawStartX);
}
else
{
_loc4_ = 1;
}
_loc9_ = _drawStartY - _loc4_ * _drawStartX;
while(_loc5_ != _drawCanvas.mouseX || _loc3_ != _drawCanvas.mouseY)
{
if(_loc4_ < 1 && _loc4_ > -1)
{
if(_loc5_ < _drawCanvas.mouseX)
{
_loc5_ += _loc2_;
if(_loc5_ >= _drawCanvas.mouseX)
{
_loc5_ = _drawCanvas.mouseX;
}
}
else
{
_loc5_ -= _loc2_;
if(_loc5_ <= _drawCanvas.mouseX)
{
_loc5_ = _drawCanvas.mouseX;
}
}
if(_loc5_ != _drawCanvas.mouseX)
{
_loc3_ = _loc4_ * _loc5_ + _loc9_;
}
else
{
_loc3_ = _drawCanvas.mouseY;
}
}
else
{
if(_loc3_ < _drawCanvas.mouseY)
{
_loc3_ += _loc2_;
if(_loc3_ >= _drawCanvas.mouseY)
{
_loc3_ = _drawCanvas.mouseY;
}
}
else
{
_loc3_ -= _loc2_;
if(_loc3_ <= _drawCanvas.mouseY)
{
_loc3_ = _drawCanvas.mouseY;
}
}
if(_drawCanvas.mouseX != _drawStartX)
{
if(_loc3_ != _drawCanvas.mouseY)
{
_loc5_ = (_loc3_ - _loc9_) / _loc4_;
}
else
{
_loc5_ = _drawCanvas.mouseX;
}
}
else
{
_loc5_ = _drawStartX;
}
}
doSmudge(_loc6_,_loc8_,_loc7_,_loc5_,_loc3_);
_loc8_ = _loc5_;
_loc7_ = _loc3_;
}
_activeBitmapData.setVector(_drawBitmapDataRect,_loc6_);
_drawStartX = _drawCanvas.mouseX;
_drawStartY = _drawCanvas.mouseY;
break;
case 7:
_drawGraphics.graphics.clear();
_drawBitmapDataSnapShot.fillRect(_drawBitmapDataRect,0);
_drawGraphics.graphics.lineStyle(_drawSize,-16777216 | _interfaceObject.loader.content.red << 16 | _interfaceObject.loader.content.green << 8 | _interfaceObject.loader.content.blue,1,false,"normal","square","miter");
if(_fillShapes)
{
_drawGraphics.graphics.beginFill(ArtStudioKit.currentColor(_interfaceObject.loader.content),1);
}
_drawGraphics.graphics.drawTriangles(Vector.<Number>([(_drawCanvas.mouseX - _drawStartX) / 2 + _drawStartX,_drawCanvas.mouseY,_drawCanvas.mouseX,_drawStartY,_drawStartX,_drawStartY]));
_drawGraphics.graphics.endFill();
_drawBitmapDataSnapShot.draw(_drawGraphics);
break;
case TOOL_BLUR - 1:
var BLUR_RADII:Array = [1,2,3,4,6,8];
var bs:int = int(_interfaceObject.loader.content.brushSize);
if(bs < 1 || bs > BLUR_RADII.length)
{
bs = 1;
}
var diameter:int = _brushSizeVal;
var blurSigma:Number = Number(BLUR_RADII[bs - 1]);
var half:int = diameter >> 1;
var blurArea:Rectangle = new Rectangle(_drawCanvas.mouseX - half,_drawCanvas.mouseY - half,diameter,diameter).intersection(_drawBitmapDataRect);
if(blurArea.isEmpty())
{
break;
}
var compositeBelow:BitmapData = new BitmapData(blurArea.width,blurArea.height,true,0);
var mat:Matrix = new Matrix();
mat.translate(-blurArea.x,-blurArea.y);
var li:int = 0;
while(li <= _activeLayerIndex)
{
compositeBelow.draw(_layerBitmapDatas[li],mat,null,null,null,true);
li++;
}
var tmp:BitmapData = new BitmapData(blurArea.width,blurArea.height,false);
tmp.copyPixels(compositeBelow,compositeBelow.rect,ORIGIN);
var bf:BlurFilter = new BlurFilter(blurSigma,blurSigma,1);
tmp.applyFilter(tmp,tmp.rect,ORIGIN,bf);
var maskFull:BitmapData = getBlurMask(diameter);
if(blurArea.width == diameter && blurArea.height == diameter)
{
var mask:BitmapData = maskFull;
}
else
{
mask = new BitmapData(blurArea.width,blurArea.height,true,0);
mask.copyPixels(maskFull,new Rectangle(blurArea.x < 0 ? -blurArea.x : 0,blurArea.y < 0 ? -blurArea.y : 0,blurArea.width,blurArea.height),ORIGIN);
}
var _activeBD:BitmapData = _layerBitmapDatas[_activeLayerIndex];
_activeBD.copyPixels(tmp,tmp.rect,blurArea.topLeft,mask,null,true);
compositeBelow.dispose();
tmp.dispose();
if(mask != maskFull)
{
mask.dispose();
}
_hasDrawn = true;
_needsSave = true;
break;
case TOOL_GRADIENT - 1:
drawGradientPreview();
break;
case TOOL_ERASER - 1:
_drawGraphics.graphics.lineTo(_drawCanvas.mouseX,_drawCanvas.mouseY);
_activeBitmapData.draw(_drawGraphics,null,null,BlendMode.ERASE);
_drawStartX = _drawCanvas.mouseX;
_drawStartY = _drawCanvas.mouseY;
break;
case TOOL_PEN - 1:
if(_drawing)
{
smoothStep(_drawCanvas.mouseX,_drawCanvas.mouseY);
var cx:Number = _smX;
var cy:Number = _smY;
var dx:Number = cx - _lastPenX;
var dy:Number = cy - _lastPenY;
var dist:Number = Math.sqrt(dx * dx + dy * dy);
var r:int = Math.ceil(_drawSize * 0.5);
var count:int = Math.ceil(dist / 1);
var i:int = 1;
while(i <= count)
{
var t:Number = i / count;
stampPenCircleAt(_lastPenX + dx * t,_lastPenY + dy * t);
i++;
}
_lastPenX = cx;
_lastPenY = cy;
}
}
}
}
}
private function getBlurMask(diameter:int) : BitmapData
{
if(_blurMasks[diameter])
{
return _blurMasks[diameter];
}
var mask:BitmapData = new BitmapData(diameter,diameter,true,0);
var s:Shape = new Shape();
var m:Matrix = new Matrix();
m.createGradientBox(diameter,diameter,0,0,0);
s.graphics.beginGradientFill(GradientType.RADIAL,[16777215,16777215],[1,0],[0,255],m,SpreadMethod.PAD);
s.graphics.drawCircle(diameter >> 1,diameter >> 1,diameter >> 1);
s.graphics.endFill();
mask.draw(s);
_blurMasks[diameter] = mask;
return mask;
}
private function stampPenCircleAt(mx:Number, my:Number) : void
{
var penColor:uint = uint(_interfaceObject.loader.content.red << 16 | _interfaceObject.loader.content.green << 8 | _interfaceObject.loader.content.blue);
var bd:BitmapData = _layerBitmapDatas[_activeLayerIndex];
var r:int = Math.ceil(_drawSize * 0.5);
bd.lock();
var dy:int = -r;
while(dy <= r)
{
var yy:int = my + dy;
if(!(yy < 0 || yy >= bd.height))
{
var dxMax:int = Math.floor(Math.sqrt(r * r - dy * dy));
var dx:int = -dxMax;
while(dx <= dxMax)
{
var xx:int = mx + dx;
if(!(xx < 0 || xx >= bd.width))
{
bd.setPixel32(xx,yy,0xFF000000 | penColor);
}
dx++;
}
}
dy++;
}
bd.unlock();
}
protected function doSmudge(param1:Vector.<uint>, param2:Number, param3:Number, param4:Number, param5:Number) : void
{
var _loc6_:int = 0;
var _loc18_:int = 0;
var _loc23_:int = 0;
var _loc25_:int = 0;
var _loc15_:int = 0;
var _loc14_:int = 0;
var _loc8_:* = 0;
var _loc10_:* = 0;
var _loc11_:* = 0;
var _loc13_:* = 0;
var _loc12_:* = 0;
var _loc21_:* = 0;
var _loc7_:* = 0;
var _loc19_:* = 0;
var _loc9_:* = 0;
var _loc22_:* = 0;
var _loc17_:* = 0;
var _loc20_:Number = Number(NaN);
var _loc24_:Number = Number(NaN);
var _loc16_:int = 0;
_loc6_ = 0;
while(_loc6_ < _activeSmudge.radius * 2)
{
_loc18_ = 0;
while(_loc18_ < _activeSmudge.radius * 2)
{
_loc23_ = param4 - _activeSmudge.radius + _loc18_;
_loc25_ = param5 - _activeSmudge.radius + _loc6_;
if(_loc23_ >= 0 && _loc23_ < _drawBitmapDataRect.width && _loc25_ >= 0 && _loc25_ < _drawBitmapDataRect.height)
{
_loc15_ = param2 - _activeSmudge.radius + _loc18_;
_loc14_ = param3 - _activeSmudge.radius + _loc6_;
_loc8_ = param1[_loc25_ * _drawBitmapDataRect.width + _loc23_];
if(_loc15_ >= 0 && _loc15_ < _drawBitmapDataRect.width && _loc14_ >= 0 && _loc14_ < _drawBitmapDataRect.height)
{
_loc10_ = param1[_loc14_ * _drawBitmapDataRect.width + _loc15_];
_loc13_ = _loc10_ >> 16 & 0xFF;
_loc12_ = _loc10_ >> 8 & 0xFF;
_loc21_ = _loc10_ & 0xFF;
_loc7_ = _loc10_ >> 24 & 0xFF;
_loc19_ = _loc8_ >> 16 & 0xFF;
_loc9_ = _loc8_ >> 8 & 0xFF;
_loc22_ = _loc8_ & 0xFF;
_loc17_ = _loc8_ >> 24 & 0xFF;
_loc20_ = Number(_activeSmudge.weightVector[_loc16_]);
_loc24_ = (_loc19_ - _loc13_) * _loc20_;
_loc19_ = _loc13_ + Math.ceil(_loc24_);
_loc24_ = (_loc9_ - _loc12_) * _loc20_;
_loc9_ = _loc12_ + Math.ceil(_loc24_);
_loc24_ = (_loc22_ - _loc21_) * _loc20_;
_loc22_ = _loc21_ + Math.ceil(_loc24_);
_loc24_ = (_loc17_ - _loc7_) * _loc20_;
_loc17_ = _loc7_ + Math.ceil(_loc24_);
_loc11_ = uint(_loc17_ << 24 | _loc19_ << 16 | _loc9_ << 8 | _loc22_);
param1[_loc25_ * _drawBitmapDataRect.width + _loc23_] = _loc11_;
}
}
_loc16_++;
_loc18_++;
}
_loc6_++;
}
}
override protected function sceneLoaded(param1:Event) : void
{
var _loc4_:Object = null;
var bg:Shape = null;
var yy:int = 0;
var xx:int = 0;
var i:int = 0;
var layerBD:BitmapData = null;
var layerBmp:Bitmap = null;
var checkerSize:int = 8;
_loc4_ = _scene.getLayer("closeButton");
addBtn("CloseButton",_loc4_.x,_loc4_.y,onCloseButton);
_interfaceObject = _scene.getLayer("interface");
if(_sharedObject != null)
{
_submitButton = addBtn("artStudioPaint_submitButton",502,5139,onSubmitButton);
_submitButton.guiBtn.setGrayState(true);
if(_sharedObject.data.userColors != null)
{
_interfaceObject.loader.content.loadColors(_sharedObject.data.userColors);
}
}
_clearAllButton = addBtn("artStudioPaint_clearButton",502,519,onClearAllButton);
_clearAllButton.guiBtn.setGrayState(true);
_printBackground = _scene.getLayer("template");
_printBackground.loader.x = 10000;
_printBackground.loader.y = 10000;
_printBtn = addBtn("artStudioPaint_printButton",230,5219,onPrintButton);
_printBtn.guiBtn.setGrayState(true);
addBtn("artStudioPaint_sketchButton",170,5219,onSketchButton);
_masterpieceSubmitBtn = addBtn("artStudioPaint_createMasterpiece",740,519,onCreateMasterpieceBtn);
_masterpieceSubmitBtn.guiBtn.setGrayState(true);
_storageButton = addBtn("artStudioPaint_storageBtn",562,519,onStorageButton);
_storageButton.guiBtn.setUsePressedState();
_brush = _scene.getLayer("brush");
_brush.loader.mouseEnabled = false;
_brush.loader.mouseChildren = false;
_brush.loader.content.mouseEnabled = false;
_brush.loader.content.mouseChildren = false;
_brush.loader.content.brushTip.mouseEnabled = false;
_brush.loader.content.brushTip.mouseChildren = false;
_brush.loader.x = mouseX;
_brush.loader.y = mouseY;
_interfaceObject.loader.content.initBrush(_brush.loader.content);
_exitConfirmationActive = false;
_sceneLoaded = true;
stage.addEventListener("enterFrame",heartbeat,false,0,true);
stage.addEventListener("mouseMove",moveMouse);
stage.addEventListener("mouseUp",endDraw);
stage.addEventListener("keyDown",onKeyDown,false,0,true);
stage.addEventListener("keyUp",onKeyUp,false,0,true);
stage.addEventListener("mouseWheel",onMouseWheel,false,0,true);
startGame();
_layerMouse.visible = false;
_layerInterface.addChild(_interfaceObject.loader);
_layerMouse.addChild(_brush.loader);
_sizeRing.visible = false;
_layerMouse.addChild(_sizeRing);
_layerMouse.mouseEnabled = false;
_layerMouse.mouseChildren = false;
_prevFrameRate = stage.frameRate;
stage.frameRate = 60;
_layersContainer = new Sprite();
_layerBitmapDatas = [];
_layerBitmaps = [];
_canvasW = int(_interfaceObject.loader.content.canvas.width);
_canvasH = int(_interfaceObject.loader.content.canvas.height);
bg = new Shape();
yy = 0;
while(yy < _canvasH)
{
xx = 0;
while(xx < _canvasW)
{
bg.graphics.beginFill((xx / checkerSize + yy / checkerSize) % 2 == 0 ? 15658734 : 13421772);
bg.graphics.drawRect(xx,yy,checkerSize,checkerSize);
bg.graphics.endFill();
xx += checkerSize;
}
yy += checkerSize;
}
i = 0;
while(i < NUM_LAYERS)
{
layerBD = new BitmapData(_canvasW,_canvasH,true,0);
_layerBitmapDatas.push(layerBD);
layerBmp = new Bitmap(layerBD,"auto",false);
_layerBitmaps.push(layerBmp);
_layersContainer.addChild(layerBmp);
i++;
}
_drawCanvas = new Sprite();
_drawCanvas.addChild(bg);
_drawCanvas.addEventListener("mouseDown",startDraw);
_drawCanvas.addEventListener("mouseOver",drawCanvasMouseOver);
_drawCanvas.addEventListener("mouseOut",drawCanvasMouseOut);
_drawCanvas.addChild(_layersContainer);
_canvasOriginalX = 0;
_canvasOriginalY = 0;
_drawing = false;
_drawBitmapDataSnapShot = new BitmapData(_canvasW,_canvasH,true,4294967295);
_drawBitmapSnapShot = new Bitmap(_drawBitmapDataSnapShot,"auto",false);
_defaultBitmapData = new BitmapData(_canvasW,_canvasH,true,4294967295);
_drawBitmapUndoSnapShot = new BitmapData(_canvasW,_canvasH,true,4294967295);
_drawBitmapUndo = new Bitmap(_drawBitmapUndoSnapShot,"auto",false);
_drawBitmapDataRect = _layerBitmapDatas[0].rect;
_drawPoint_0_0 = new Point(0,0);
_canvasMask = new Shape();
_canvasMask.graphics.beginFill(0);
_canvasMask.graphics.drawRect(0,0,_canvasW,_canvasH);
_canvasMask.graphics.endFill();
_interfaceObject.loader.content.canvas.addChild(_drawCanvas);
_interfaceObject.loader.content.canvas.addChild(_canvasMask);
_drawCanvas.mask = _canvasMask;
buildModUI();
updateLayerVisuals();
super.sceneLoaded(param1);
}
private function drawCanvasMouseOver(param1:MouseEvent) : void
{
_overCanvas = true;
updateCanvasCursor();
}
private function drawCanvasMouseOut(param1:MouseEvent) : void
{
_overCanvas = false;
updateCanvasCursor();
}
private function onMergeLayerDown(e:MouseEvent) : void
{
var src:int = _activeLayerIndex;
var dst:int = src - 1;
var opacity:Number = NaN;
if(src <= 0)
{
return;
}
pushUndo([src,dst],true);
opacity = Number(_layerOpacities[src]);
if((_layerBitmaps[src] as Bitmap).visible)
{
(_layerBitmapDatas[dst] as BitmapData).draw(_layerBitmapDatas[src],null,opacity < 1 ? new ColorTransform(1,1,1,opacity) : null,_layerBlends[src]);
}
(_layerBitmapDatas[src] as BitmapData).fillRect(_drawBitmapDataRect,0);
_layerOpacities[src] = 1;
_layerBlends[src] = BlendMode.NORMAL;
_layerLocks[src] = false;
(_layerBitmaps[src] as Bitmap).visible = true;
_activeLayerIndex = dst;
updateLayerVisuals();
refreshLayerPanel(true);
_needsSave = true;
}
private function onMoveLayerUp(e:MouseEvent) : void
{
if(_activeLayerIndex < NUM_LAYERS - 1)
{
swapLayers(_activeLayerIndex,_activeLayerIndex + 1);
}
}
private function onMoveLayerDown(e:MouseEvent) : void
{
if(_activeLayerIndex > 0)
{
swapLayers(_activeLayerIndex,_activeLayerIndex - 1);
}
}
public function message(param1:Array) : void
{
var _loc2_:int = 0;
if(param1[0] != "ml")
{
if(param1[0] == "ms")
{
_dbIDs = [];
_loc2_ = 0;
while(_loc2_ < _pIDs.length)
{
_dbIDs[_loc2_] = param1[_loc2_ + 1];
_loc2_++;
}
}
else if(param1[0] == "mm")
{
if(param1[2] == "tkn")
{
handleMasterpieceTokenReply(param1[3] == "1",param1[5],parseInt(param1[7]));
}
}
}
}
public function handleMasterpieceTokenReply(param1:Boolean, param2:String, param3:int) : void
{
if(!_submitPending)
{
return;
}
if(!param1)
{
onSendError(null);
return;
}
_masterPieceSubmissionToken = param2;
if(param3 == 1)
{
startSubmitWatchdog(UPLOAD_TIMEOUT_MS);
setupRequest(onSendComplete,onSendError,20,_denPreviewInvId,false,0);
}
}
public function heartbeat(param1:Event) : void
{
if(_sceneLoaded)
{
_frameTime = (getTimer() - _lastTime) / 1000;
_lastTime = getTimer();
_timeSinceErase += _frameTime;
_gameIdleTimer = 0;
_keepAliveTimer += 1;
if(_keepAliveTimer >= 60)
{
MinigameManager.keepAlive();
_keepAliveTimer = 0;
}
if(_interfaceObject.loader.content.clickSound)
{
AJAudio.playHudBtnClick();
_interfaceObject.loader.content.clickSound = false;
}
syncNativeControls();
ArtStudioKit.syncColorPanel(_colorPanel);
}
}
public function startGame() : void
{
if(_sceneLoaded)
{
}
}
private function onExportClick(e:MouseEvent) : void
{
var exportBD:BitmapData = null;
var fr:FileReference = null;
try
{
exportBD = getCompositeBitmapData(false);
fr = new FileReference();
fr.save(PNGEncoder.encode(exportBD),"masterpiece.png");
}
catch(err:Error)
{
DebugUtility.debugTrace(err.message);
}
if(exportBD != null)
{
exportBD.dispose();
}
}
private function onZoomInClick(e:MouseEvent) : void
{
zoomIn();
}
private function onZoomOutClick(e:MouseEvent) : void
{
zoomOut();
}
private function onZoomResetClick(e:MouseEvent) : void
{
resetZoom();
}
private function startPan(e:MouseEvent) : void
{
var p:Point = _drawCanvas.parent.globalToLocal(new Point(e.stageX,e.stageY));
e.stopPropagation();
_isPanning = true;
_panStartX = p.x;
_panStartY = p.y;
stage.addEventListener(MouseEvent.MOUSE_MOVE,updatePan);
stage.addEventListener(MouseEvent.MOUSE_UP,endPan);
}
private function updatePan(e:MouseEvent) : void
{
var p:Point = null;
if(_isPanning)
{
p = _drawCanvas.parent.globalToLocal(new Point(e.stageX,e.stageY));
_drawCanvas.x += p.x - _panStartX;
_drawCanvas.y += p.y - _panStartY;
_panStartX = p.x;
_panStartY = p.y;
clampPan();
e.updateAfterEvent();
}
}
private function endPan(e:MouseEvent) : void
{
if(_isPanning)
{
_isPanning = false;
stage.removeEventListener(MouseEvent.MOUSE_MOVE,updatePan);
stage.removeEventListener(MouseEvent.MOUSE_UP,endPan);
updateCanvasCursor();
}
}
private function onKeyDown(e:KeyboardEvent) : void
{
if(stage.focus is TextField || _exitConfirmationActive || ArtStudioKit.isPlacing() || ArtStudioKit.isDialogOpen())
{
return;
}
if(e.ctrlKey && e.keyCode == 90 && !e.shiftKey)
{
e.preventDefault();
e.stopPropagation();
onUndoClick(null);
return;
}
if(e.ctrlKey && e.keyCode == 89 || e.ctrlKey && e.shiftKey && e.keyCode == 90)
{
e.preventDefault();
e.stopPropagation();
onRedoClick(null);
return;
}
if(e.ctrlKey && (e.keyCode == 187 || e.keyCode == 61))
{
e.preventDefault();
e.stopPropagation();
zoomIn();
return;
}
if(e.ctrlKey && e.keyCode == 189)
{
e.preventDefault();
e.stopPropagation();
zoomOut();
return;
}
if(e.ctrlKey && e.keyCode == 73)
{
e.preventDefault();
applyInstant("invert");
return;
}
if(e.ctrlKey && e.keyCode == 74)
{
e.preventDefault();
duplicateLayer();
return;
}
if(e.ctrlKey && e.keyCode == 48)
{
e.preventDefault();
e.stopPropagation();
resetZoom();
return;
}
if(e.ctrlKey || e.altKey)
{
return;
}
if(e.keyCode == Keyboard.SPACE)
{
e.preventDefault();
if(!_spaceHeld && !_drawing)
{
_spaceHeld = true;
updateCanvasCursor();
}
return;
}
switch(e.keyCode)
{
case 72:
selectModTool(TOOL_HAND);
break;
case 71:
selectModTool(TOOL_GRADIENT);
break;
case 86:
toggleFlipView();
break;
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
case 48:
_brushOpacity = e.keyCode == 48 ? 1 : (e.keyCode - 48) / 10;
ArtStudioKit.sliderSet(_opacitySlider,_brushOpacity * 100);
break;
case 219:
setBrushSize(_brushSizeVal - Math.max(1,Math.round(_brushSizeVal * 0.15)));
break;
case 221:
setBrushSize(_brushSizeVal + Math.max(1,Math.round(_brushSizeVal * 0.15)));
break;
case 80:
selectModTool(TOOL_PEN);
break;
case 69:
selectModTool(TOOL_ERASER);
break;
case 73:
selectModTool(TOOL_EYEDROP);
}
}
private function onMouseWheel(e:MouseEvent) : void
{
var c:Object = null;
if(e.ctrlKey)
{
e.preventDefault();
e.stopPropagation();
c = _interfaceObject.loader.content.canvas;
if(e.delta > 0)
{
zoomIn(c.mouseX,c.mouseY);
}
else
{
zoomOut(c.mouseX,c.mouseY);
}
}
}
private function zoomIn(anchorX:Number = -1e9, anchorY:Number = -1e9) : void
{
var newZoom:Number = _zoomLevel + _zoomStep;
if(newZoom <= _maxZoom)
{
setZoom(newZoom,anchorX,anchorY);
}
}
private function zoomOut(anchorX:Number = -1e9, anchorY:Number = -1e9) : void
{
var newZoom:Number = _zoomLevel - _zoomStep;
if(newZoom >= _minZoom)
{
setZoom(newZoom,anchorX,anchorY);
}
}
private function resetZoom() : void
{
_zoomLevel = 1;
if(_drawCanvas)
{
_drawCanvas.scaleX = _viewFlipped ? -1 : 1;
_drawCanvas.scaleY = 1;
_drawCanvas.x = _viewFlipped ? _canvasOriginalX + _canvasW : _canvasOriginalX;
_drawCanvas.y = _canvasOriginalY;
}
updateZoomUI();
}
// Zooms around an anchor point in canvas-frame coordinates (the pointer
// for Ctrl+wheel, the middle of the frame otherwise), keeping whatever
// is under it in place instead of re-centring and losing the pan.
// Burrow: -1e9 stands for "no anchor" (NaN): the JPEXS that builds this
// client takes no NaN as a default value
private function setZoom(zoom:Number, anchorX:Number = -1e9, anchorY:Number = -1e9) : void
{
if(anchorX == -1e9)
{
anchorX = NaN;
}
if(anchorY == -1e9)
{
anchorY = NaN;
}
var ratio:Number = zoom / _zoomLevel;
if(isNaN(anchorX) || isNaN(anchorY))
{
anchorX = _canvasW * 0.5;
anchorY = _canvasH * 0.5;
}
_zoomLevel = zoom;
if(_drawCanvas)
{
_drawCanvas.scaleX = _viewFlipped ? -_zoomLevel : _zoomLevel;
_drawCanvas.scaleY = _zoomLevel;
_drawCanvas.x = anchorX - (anchorX - _drawCanvas.x) * ratio;
_drawCanvas.y = anchorY - (anchorY - _drawCanvas.y) * ratio;
clampPan();
}
updateZoomUI();
}
private function updateZoomUI() : void
{
if(_zoomLabelBtn != null)
{
ArtStudioKit.setLabel(_zoomLabelBtn,Math.round(_zoomLevel * 100) + "%");
ArtStudioKit.setEnabled(_zoomInBtn,_zoomLevel < _maxZoom);
ArtStudioKit.setEnabled(_zoomOutBtn,_zoomLevel > _minZoom);
}
}
private function getAirbrush(dia:int) : Object
{
if(_airbrushCache[dia])
{
return _airbrushCache[dia];
}
var b:Object = {};
b.diameter = dia;
b._drawOffSet = Math.floor(dia / 2);
b._drawTranslateMatrix = new Matrix();
var s:Shape = new Shape();
s.graphics.beginFill(16777215,0.15);
s.graphics.drawCircle(0,0,dia / 2);
s.graphics.endFill();
var bmp:BitmapData = new BitmapData(s.width,s.height,true,0);
var m:Matrix = new Matrix();
m.tx = s.width / 2;
m.ty = s.height / 2;
bmp.draw(s,m);
b._drawBrushData = bmp;
_airbrushCache[dia] = b;
return b;
}
private function getSmudge(radius:int) : Object
{
if(_smudgeCache[radius])
{
return _smudgeCache[radius];
}
var obj:Object = {};
obj.radius = radius;
obj.weightVector = new Vector.<Number>(radius * 2 * radius * 2,true);
var s:Shape = new Shape();
var g:Graphics = s.graphics;
var m:Matrix = new Matrix();
m.createGradientBox(radius * 2,radius * 2,0,0,0);
g.beginGradientFill(GradientType.RADIAL,[16777215,16777215],[0.75,0],[0,255],m,SpreadMethod.PAD);
g.drawCircle(radius,radius,radius);
g.endFill();
var bd:BitmapData = new BitmapData(radius * 2,radius * 2,true,0);
bd.draw(s);
var vec:Vector.<uint> = bd.getVector(bd.rect);
var idx:int = 0;
var y:int = 0;
while(y < radius * 2)
{
var x:int = 0;
while(x < radius * 2)
{
obj.weightVector[idx] = (255 - (vec[idx] >> 24 & 0xFF)) / 255;
x++;
idx++;
}
y++;
}
_smudgeCache[radius] = obj;
return obj;
}
private function onToggleLayerClick(e:MouseEvent) : void
{
var bmp:Bitmap = _layerBitmaps[_activeLayerIndex] as Bitmap;
bmp.visible = !bmp.visible;
refreshLayerPanel(false);
ArtStudioKit.showTip(_eyeBtn,_eyeBtn.tip);
}
private function onUploadCancel(e:Event) : void
{
_uploadFileRef = null;
}
private function onUploadSelect(e:Event) : void
{
_uploadFileRef.removeEventListener(Event.SELECT,onUploadSelect);
_uploadFileRef.addEventListener(Event.COMPLETE,onUploadFileLoaded);
_uploadFileRef.load();
}
private function onUploadFileLoaded(e:Event) : void
{
_uploadFileRef.removeEventListener(Event.COMPLETE,onUploadFileLoaded);
var loader:Loader = new Loader();
loader.contentLoaderInfo.addEventListener(Event.COMPLETE,onUploadLoaderComplete);
loader.loadBytes(_uploadFileRef.data);
}
private function onUploadLoaderComplete(e:Event) : void
{
var srcBmp:Bitmap = e.target.content as Bitmap;
if(srcBmp == null)
{
return;
}
_placingSrc = srcBmp.bitmapData.clone();
srcBmp.bitmapData.dispose();
(e.target as LoaderInfo).loader.unloadAndStop();
_uploadFileRef = null;
ArtStudioKit.beginPlace(_drawCanvas,_placingSrc,_canvasW,_canvasH,_layerInterface,494,58,onImagePlaced);
updateCanvasCursor();
}
// The imported image is painted over the active layer where it was
// placed, at the size it was given.
private function onImagePlaced(m:Matrix) : void
{
if(m != null && _layerBitmapDatas != null)
{
pushUndo([_activeLayerIndex],false);
(_layerBitmapDatas[_activeLayerIndex] as BitmapData).draw(_placingSrc,m,null,null,null,true);
_needsSave = true;
refreshLayerThumb(_activeLayerIndex);
syncCanvasButtons();
}
if(_placingSrc != null)
{
_placingSrc.dispose();
_placingSrc = null;
}
if(_layerMouse != null)
{
updateCanvasCursor();
}
}
private function scaleAndCropToFill(src:BitmapData, tw:int, th:int) : BitmapData
{
var scale:Number = Math.max(tw / src.width,th / src.height);
var scaledW:int = Math.ceil(src.width * scale);
var scaledH:int = Math.ceil(src.height * scale);
var m:Matrix = new Matrix();
m.scale(scale,scale);
var tmp:BitmapData = new BitmapData(scaledW,scaledH,src.transparent,0);
tmp.draw(src,m,null,null,null,true);
var cropX:int = scaledW - tw >> 1;
var cropY:int = scaledH - th >> 1;
var out:BitmapData = new BitmapData(tw,th,src.transparent,0);
out.copyPixels(tmp,new Rectangle(cropX,cropY,tw,th),new Point(0,0));
tmp.dispose();
return out;
}
private function onStorage_Close() : void
{
hideDlg();
_storageButton.guiBtn.setPressedState(false);
}
private function onStorage_Save() : void
{
onSaveButton();
}
private function onStorage_Load() : void
{
onLoadButton();
}
private function onStorageButton() : void
{
var _loc1_:MovieClip = null;
if(!_exitConfirmationActive)
{
_exitAfterSave = false;
_loc1_ = showDlg("ArtStudioColor_StorageDlg",[{
"name":"button_close",
"f":onStorage_Close
},{
"name":"button_save",
"f":onStorage_Save,
"grayed":(_needsSave ? "no" : "yes")
},{
"name":"button_load",
"f":onStorage_Load
}],353,401,true,true);
}
}
private function onSketchButton() : void
{
if(!_exitConfirmationActive)
{
DarkenManager.showLoadingSpiral(true);
GenericListGuiManager.genericListVolumeClicked(77,{
"msg":"biggerFrame",
"width":768,
"height":432,
"shouldRepeat":false
});
}
}
private function onPrintButton() : void
{
var _loc6_:Sprite = null;
var _loc5_:Number = Number(NaN);
var _loc4_:Number = Number(NaN);
var _loc2_:Number = Number(NaN);
var _loc3_:Number = Number(NaN);
var _loc1_:Object = null;
if(!_exitConfirmationActive && _hasDrawn)
{
_loc6_ = _drawCanvas;
_loc5_ = _loc6_.x;
_loc4_ = _loc6_.y;
_loc2_ = _loc6_.scaleX;
_loc3_ = _loc6_.scaleY;
_loc1_ = _loc6_.parent;
_loc1_.removeChild(_loc6_);
_loc6_.x = 170;
_loc6_.y = 240;
super.printOnePerPage(_loc6_,20,20,_printBackground,"portrait");
_loc1_.addChild(_loc6_);
_loc6_.x = _loc5_;
_loc6_.y = _loc4_;
_loc6_.scaleX = _loc2_;
_loc6_.scaleY = _loc3_;
}
}
private function onCloseButton() : void
{
if(!_exitConfirmationActive)
{
_exitConfirmationActive = true;
if(_needsSave)
{
_exitAfterSave = true;
showDlg("ArtStudioColor_SaveExitDlg",[{
"name":"button_close",
"f":onExit_No
},{
"name":"button_save",
"f":onExit_Save
},{
"name":"button_exit",
"f":onExit_Yes
}],450,275,true,true);
}
else
{
showDlg("ArtStudioColor_ExitDlg",[{
"name":"button_yes",
"f":onExit_Yes
},{
"name":"button_no",
"f":onExit_No
}],450,275,true,true);
}
}
}
private function onSubmitButton() : void
{
var _loc1_:MovieClip = null;
if(!_exitConfirmationActive && _hasDrawn)
{
_exitConfirmationActive = true;
_loc1_ = showDlg("ArtStudioColor_SubmitDlg",[{
"name":"button_yes",
"f":onSubmit_Yes
},{
"name":"button_no",
"f":onExit_No
}],450,275,true,true);
}
}
private function onCreateMasterpieceBtn() : void
{
if(!_exitConfirmationActive && _hasDrawn)
{
if(_chooseMasterpiecePopup)
{
onChooseMasterpiecePopupLoaded(null);
}
else
{
_mediaHelper = new MediaHelper();
_mediaHelper.init(4811,onChooseMasterpiecePopupLoaded);
}
}
}
private function onClearAllButton() : void
{
var _loc1_:MovieClip = null;
if(!_exitConfirmationActive)
{
_exitConfirmationActive = true;
_loc1_ = showDlg("ArtStudioColor_ClearDlg",[{
"name":"button_yes",
"f":onClear_Yes
},{
"name":"button_no",
"f":onExit_No
}],450,275,true,true);
}
}
private function setNumMasterpieceIcons() : void
{
var _loc2_:int = 0;
var _loc1_:DenItemCollection = gMainFrame.userInfo.playerAvatarInfo.denItems;
_numMasterpieceTokens = 0;
if(_loc1_ && _loc1_.length > 0)
{
_loc1_ = Utility.discardDefaultAudioItem(_loc1_);
_loc2_ = 0;
while(_loc2_ < _loc1_.length)
{
if(_loc1_.getDenItem(_loc2_).defId == 2947)
{
++_numMasterpieceTokens;
}
_loc2_++;
}
}
}
private function onChooseMasterpiecePopupLoaded(param1:MovieClip) : void
{
if(param1)
{
_chooseMasterpiecePopup = param1.getChildAt(0) as MovieClip;
_chooseMasterpiecePopup.x = 450;
_chooseMasterpiecePopup.y = 275;
_chooseMasterpiecePopup.bx.addEventListener("mouseDown",onChooseMasterpiecePopupClose,false,0,true);
_chooseMasterpiecePopup.arrowLBtn.addEventListener("mouseDown",onLeftRightMasterpiece,false,0,true);
_chooseMasterpiecePopup.arrowRBtn.addEventListener("mouseDown",onLeftRightMasterpiece,false,0,true);
_masterpiecePreviewIconStrIds = MasterpiecePreview.masterpiecePreviewIconStrIds;
_masterpiecePreviewIconIdsOrdered = MasterpiecePreview.masterpiecePreviewIconIdsOrdered;
if(_masterpiecePreviewIconIds == null || _masterpiecePreviewIconIds.length == 0)
{
GenericListXtCommManager.requestGenericList(416,onMasterpieceIconList);
}
}
setupMasterpieceWindows();
_guiLayer.addChild(_chooseMasterpiecePopup);
DarkenManager.darken(_chooseMasterpiecePopup);
}
private function onMasterpieceIconList(param1:int, param2:Array, param3:Array) : void
{
_masterpiecePreviewIconIds = param2;
_masterpiecePreviewIconStrIds = param3;
MasterpiecePreview.masterpiecePreviewIconStrIds = param3;
if(_masterpiecePreviewIconIdsOrdered == null || _masterpiecePreviewIconIdsOrdered.length == 0)
{
GenericListXtCommManager.requestGenericList(424,onMasterpieceIconOrderListLoaded);
}
else
{
setupMasterpieceWindows();
}
}
private function onMasterpieceIconOrderListLoaded(param1:int, param2:Array, param3:Array) : void
{
_masterpiecePreviewIconIdsOrdered = param2;
MasterpiecePreview.masterpiecePreviewIconIdsOrdered = param2;
setupMasterpieceWindows();
}
private function setupMasterpieceWindows() : void
{
var _loc1_:int = 0;
setNumMasterpieceIcons();
_loc1_ = 0;
while(_loc1_ < 4)
{
clearOutItemLayer(_chooseMasterpiecePopup["iw" + _loc1_]);
_chooseMasterpiecePopup["iw" + _loc1_].tag.visible = false;
_chooseMasterpiecePopup["iw" + _loc1_].frameNameCont.visible = false;
_chooseMasterpiecePopup["iw" + _loc1_].newTag.visible = false;
if(_masterpiecePreviewIconIds)
{
if(_masterpiecePreviewIconIds[_loc1_ + _itemOffset])
{
if(_masterpiecePreviewIcons && _masterpiecePreviewIcons[_loc1_ + _itemOffset])
{
setupCurrIconAndBitmap(_loc1_);
}
else
{
new LoadingSpiral(_chooseMasterpiecePopup["iw" + _loc1_].itemLayer);
_mediaHelper = new MediaHelper();
_mediaHelper.init(_masterpiecePreviewIconIds[_loc1_ + _itemOffset],onMasterpieceIconLoaded,{
"index":_loc1_,
"offset":_itemOffset
});
_iconMediaHelpers[_loc1_ + _itemOffset] = _mediaHelper;
}
}
}
else
{
new LoadingSpiral(_chooseMasterpiecePopup["iw" + _loc1_].itemLayer);
}
_loc1_++;
}
}
private function clearOutItemLayer(param1:MovieClip) : void
{
var _loc2_:MovieClip = null;
if(param1)
{
while(param1.itemLayer.numChildren > 0)
{
_loc2_ = param1.itemLayer.getChildAt(param1.itemLayer.numChildren - 1);
if(_loc2_ is LoadingSpiral)
{
(_loc2_ as LoadingSpiral).destroy();
}
while(param1.itemLayer.numChildren > 0)
{
param1.itemLayer.removeChildAt(param1.itemLayer.numChildren - 1);
}
}
}
}
private function setupCurrIconAndBitmap(param1:int) : void
{
var _loc4_:MovieClip = null;
var _loc6_:MovieClip = null;
var _loc5_:Bitmap = null;
var _loc2_:Object = null;
var _loc3_:Boolean = false;
if(_masterpiecePreviewIcons[param1 + _itemOffset])
{
_loc4_ = _masterpiecePreviewIcons[param1 + _itemOffset];
while(_loc4_.itemWindow.numChildren > 1)
{
_loc4_.itemWindow.removeChildAt(_loc4_.itemWindow.numChildren - 1);
}
_loc6_ = _chooseMasterpiecePopup["iw" + param1];
var fullBmp:BitmapData = getCompositeBitmapData(true);
var resizedUserBmp:BitmapData = Utility.resizeImage(fullBmp,_loc4_.itemWindow.width,_loc4_.itemWindow.height,true);
fullBmp.dispose();
_loc5_ = new Bitmap(resizedUserBmp,"auto",true);
_loc5_.x = -_loc5_.width * 0.5;
_loc5_.y = -_loc5_.height * 0.5;
_loc4_.itemWindow.addChild(_loc5_);
(_loc4_.nameBar as GuiSoundButton).setTextInLayer(gMainFrame.userInfo.myUserName,"name_txt");
_loc4_.nameBar.mouseChildren = false;
_loc4_.nameBar.mouseEnabled = false;
_loc4_.report_btn.visible = false;
_loc4_.likeBtn.visible = false;
_loc6_.frameNameCont.visible = true;
_loc6_.tag.visible = true;
_loc6_.newTag.visible = _itemOffset == 0 && (param1 == 0 || param1 == 1);
LocalizationManager.translateId(_loc6_.frameNameCont.frameTxt,_masterpiecePreviewIconStrIds[param1 + _itemOffset]);
_loc2_ = DiamondXtCommManager.getDiamondDef(221);
_loc3_ = UserCurrency.hasEnoughCurrency(3,_loc2_.value) || _numMasterpieceTokens > 0;
if(!_loc3_)
{
if(_loc6_.tag.currentFrameLabel != "diamondred")
{
_loc6_.tag.gotoAndPlay("diamondred");
}
_loc6_.tag.txt.textColor = "0x800000";
}
else
{
if(_loc6_.tag.currentFrameLabel != "diamondgreen")
{
_loc6_.tag.gotoAndPlay("diamondgreen");
}
_loc6_.tag.txt.textColor = "0x386630";
}
_loc6_.tag.txt.text = Utility.convertNumberToString(_loc2_.value);
clearOutItemLayer(_loc6_);
if("frame" in _loc4_)
{
_loc4_.frame.filters = [FRAME_SELECT_FILTER_DARKER,FRAME_SELECT_FILTER_LIGHTER];
_loc6_.itemLayer.filters = null;
}
else if(_loc6_.itemLayer.filters == null || _loc6_.itemLayer.filters.length == 0)
{
_loc6_.itemLayer.filters = [FRAME_SELECT_FILTER_DARKER,FRAME_SELECT_FILTER_LIGHTER];
}
_loc6_.itemLayer.addChild(_loc4_);
_loc6_.currIcon = _loc4_;
_loc6_.index = param1;
_loc6_.addEventListener("mouseDown",onPreviewIcon,false,0,true);
_loc6_.addEventListener("mouseOver",onPreviewIconOver,false,0,true);
_loc6_.addEventListener("mouseOut",onPreviewIconOut,false,0,true);
}
}
private function onPreviewIcon(param1:MouseEvent) : void
{
var _loc2_:int = 0;
param1.stopPropagation();
_currPreviewIndex = param1.currentTarget.index;
_loc2_ = 0;
while(_loc2_ < _masterpiecePreviewIconIdsOrdered.length)
{
if(_masterpiecePreviewIconIdsOrdered[_loc2_] == _masterpiecePreviewIconIds[_currPreviewIndex + _itemOffset])
{
_currItemVersion = _loc2_;
break;
}
_loc2_++;
}
var fullBmp:BitmapData = getCompositeBitmapData(true);
_masterpiecePreviewPopup = new MasterpiecePreview(_guiLayer,_numMasterpieceTokens,"",gMainFrame.userInfo.myUserName,gMainFrame.clientInfo.dbUserId,gMainFrame.userInfo.myUUID,_currItemVersion,onPreviewClose,gMainFrame.userInfo.myUserName,null,new Bitmap(fullBmp,"auto",true),true);
onPreviewIconOut(param1);
}
private function onPreviewIconOver(param1:MouseEvent) : void
{
param1.stopPropagation();
if("frame" in param1.currentTarget.currIcon && param1.currentTarget.currIcon.frame.filters.length > 0)
{
param1.currentTarget.currIcon.frame.filters = null;
}
param1.currentTarget.itemLayer.filters = [FRAME_SELECT_FILTER_MOUSE_OVER];
if(param1.currentTarget.currentFrameLabel != "mouse")
{
param1.currentTarget.gotoAndPlay("mouse");
}
param1.currentTarget.currIcon.nameBar.visible = false;
AJAudio.playSubMenuBtnRollover();
}
private function onPreviewIconOut(param1:MouseEvent) : void
{
param1.stopPropagation();
if(param1.currentTarget.currentFrameLabel != "out")
{
param1.currentTarget.gotoAndPlay("out");
}
if("frame" in param1.currentTarget.currIcon)
{
param1.currentTarget.currIcon.frame.filters = [FRAME_SELECT_FILTER_DARKER,FRAME_SELECT_FILTER_LIGHTER];
param1.currentTarget.itemLayer.filters = null;
}
else
{
param1.currentTarget.itemLayer.filters = [FRAME_SELECT_FILTER_DARKER,FRAME_SELECT_FILTER_LIGHTER];
}
param1.currentTarget.currIcon.nameBar.visible = true;
}
private function onPreviewClose(param1:Boolean) : void
{
var _loc2_:MovieClip = null;
if(param1)
{
if(Utility.numDenItemsInList(gMainFrame.userInfo.playerUserInfo.denItemsFull,0) < ShopManager.maxDenItems)
{
askCopyCount();
}
else
{
new SBYesNoPopup(_guiLayer,LocalizationManager.translateIdOnly(14746),true,confirmRecycleHandler,4);
}
}
else
{
if(_masterpiecePreviewPopup)
{
_masterpiecePreviewPopup.destroy();
_masterpiecePreviewPopup = null;
}
clearOutItemLayer(_chooseMasterpiecePopup["iw" + _currPreviewIndex]);
_loc2_ = _masterpiecePreviewIcons[_currPreviewIndex + _itemOffset];
_chooseMasterpiecePopup["iw" + _currPreviewIndex].itemLayer.addChild(_loc2_);
if("frame" in _loc2_)
{
_loc2_.frame.filters = [FRAME_SELECT_FILTER_DARKER,FRAME_SELECT_FILTER_LIGHTER];
}
}
}
private function onSubmissionRulesClose(param1:Boolean, param2:Boolean) : void
{
_submissionRules.destroy();
_submissionRules = null;
_isUsingTokens = param2;
if(!param1)
{
stopCopies();
}
if(param1)
{
capCopiesToFunds();
DarkenManager.showLoadingSpiral(true);
DenXtCommManager.requestBuy(true,0,221,onPreviewItemBuy,onPreviewBuyInventoryResponse,0,null,_currItemVersion,1,true,_isUsingTokens,_masterpieceUuid);
}
else if(param2)
{
setupRequest(null,null,20,0,param2,1,false);
}
onPreviewClose(false);
}
private function confirmRecycleHandler(param1:Object) : void
{
var _loc2_:int = int(param1.passback);
if(param1.status)
{
_recyclePopup = new RecycleItems();
_recyclePopup.init(_loc2_,_guiLayer,true,onRecycleClose,900 * 0.5,550 * 0.5,true);
}
else if(_masterpiecePreviewPopup)
{
_masterpiecePreviewPopup.closeCallback = onPreviewClose;
}
}
private function onRecycleClose(param1:Boolean = false) : void
{
if(_recyclePopup)
{
_recyclePopup.destroy();
_recyclePopup = null;
}
if(param1)
{
setNumMasterpieceIcons();
onPreviewClose(true);
}
else if(_masterpiecePreviewPopup)
{
_masterpiecePreviewPopup.closeCallback = onPreviewClose;
}
}
private function onPreviewItemBuy(param1:int, param2:int, param3:int) : void
{
if(param1 == 1)
{
if(_copiesDone == 0)
{
onChooseMasterpiecePopupClose(null);
}
UserCurrency.setCurrency(param2,3);
_denPreviewInvId = param3;
}
else
{
DarkenManager.showLoadingSpiral(false);
new SBOkPopup(_guiLayer,LocalizationManager.translateIdOnly(14798));
ItemXtCommManager.setItemBuyIlCallback(null);
_denPreviewInvId = 0;
stopCopies();
}
}
private function onPreviewBuyInventoryResponse() : void
{
_copiesDone++;
if(_copiesDone < _copiesWanted)
{
_denPreviewInvId = 0;
DenXtCommManager.denEditorDIResponseCallback = null;
showCopyBanner("Buying copies... " + _copiesDone + " of " + _copiesWanted + " done");
setTimeout(nextCopy,COPY_GAP_MS);
return;
}
finishCopies();
var _loc3_:DenItem = null;
var _loc2_:int = 0;
DarkenManager.showLoadingSpiral(false);
var _loc1_:DenItemCollection = gMainFrame.userInfo.playerUserInfo.denItemsFull;
_loc2_ = 0;
while(_loc2_ < _loc1_.length)
{
if(_loc1_.getDenItem(_loc2_).invIdx == _denPreviewInvId)
{
_loc3_ = _loc1_.getDenItem(_loc2_);
}
_loc2_++;
}
if(_loc3_)
{
_loc3_ = _loc3_.clone() as DenItem;
_loc3_.initShopItem(_loc3_.defId,_loc3_.version);
_itemReceivedPopup = new ItemReceivedPopup(_loc3_,_guiLayer,onItemReceivedClose);
}
_denPreviewInvId = 0;
DenXtCommManager.denEditorDIResponseCallback = null;
}
private function onItemReceivedClose() : void
{
_itemReceivedPopup.destroy();
_itemReceivedPopup = null;
onPreviewClose(false);
finishFeedbackSend();
}
private function onMasterpieceIconLoaded(param1:MovieClip) : void
{
if(_masterpiecePreviewIcons == null)
{
_masterpiecePreviewIcons = [];
}
_masterpiecePreviewIcons[param1.passback.index + param1.passback.offset] = param1.getChildAt(0) as MovieClip;
setupCurrIconAndBitmap(param1.passback.index);
}
private function onChooseMasterpiecePopupClose(param1:MouseEvent) : void
{
if(param1)
{
param1.stopPropagation();
}
DarkenManager.unDarken(_chooseMasterpiecePopup);
_guiLayer.removeChild(_chooseMasterpiecePopup);
}
private function onLeftRightMasterpiece(param1:MouseEvent) : void
{
var _loc2_:int = 0;
if(!param1.currentTarget.isGray)
{
if(param1.currentTarget == _chooseMasterpiecePopup.arrowLBtn)
{
if(_itemOffset == 0)
{
_loc2_ = _masterpiecePreviewIconIds.length % 4;
if(_loc2_ != 0)
{
_itemOffset = _masterpiecePreviewIconIds.length - _loc2_;
}
else
{
_itemOffset = _masterpiecePreviewIconIds.length - 4;
}
}
else
{
_itemOffset -= 4;
}
}
else if(_itemOffset + 4 < _masterpiecePreviewIconIds.length)
{
_itemOffset += 4;
}
else
{
_itemOffset = 0;
}
setupMasterpieceWindows();
}
}
private function encodeImage() : void
{
DarkenManager.showLoadingSpiral(true,true);
_jpgEncoder = new JpegAsynchEncoder();
_jpgEncoder.addEventListener("JPEGAsyncComplete",asyncEncodingComplete,false,0,true);
_jpgEncoder.addEventListener("progress",onEncodingProgress,false,0,true);
_jpgEncoder.PixelsPerIteration = 128;
_jpgEncoder.JPEGAsyncEncoder(90);
_encodingBitmapData = getCompositeBitmapData(true);
_jpgEncoder.encode(_encodingBitmapData);
}
private function onSubmit_Yes() : void
{
_isMasterpieceSubmit = false;
encodeImage();
}
private function asyncEncodingComplete(param1:JPEGAsyncCompleteEvent) : void
{
var _loc2_:Array = null;
var _loc3_:* = false;
var _loc4_:Date = null;
var _loc5_:Number = Number(NaN);
_jpgEncoder.removeEventListener("JPEGAsyncComplete",asyncEncodingComplete);
_jpgEncoder.removeEventListener("progress",onEncodingProgress);
if(_encodingBitmapData != null)
{
_encodingBitmapData.dispose();
_encodingBitmapData = null;
}
if(_isMasterpieceSubmit)
{
_URLStatus = 0;
startSubmitWatchdog(TOKEN_TIMEOUT_MS);
_loc2_ = [];
_loc2_[0] = "gmtkn";
_loc2_[1] = "0";
_loc2_[2] = "1";
MinigameManager.msg(_loc2_);
}
else
{
_loc3_ = false;
if(_sharedObject != null)
{
if(_sharedObject.data.userSubmits.length == 5)
{
_loc4_ = new Date();
_loc5_ = Number(_loc4_.getTime());
_loc5_ -= _sharedObject.data.userSubmits[0];
_loc5_ = _loc5_ / 1000 / 60 / 60;
_loc3_ = _loc5_ >= 24;
}
else
{
_loc3_ = true;
}
}
if(_loc3_)
{
setupRequest(onSendComplete,onSendError,14,0,false,0);
}
else
{
SBTracker.trackPageview("/game/play/miniGame/#ColoringSendFiltered");
finishFeedbackSend();
}
}
}
private function onEncodingProgress(param1:ProgressEvent) : void
{
DarkenManager.updateLoadingSpiralPercentage(Math.round(param1.bytesLoaded / param1.bytesTotal * 100) + "%");
}
private function onClear_Yes() : void
{
handleClear();
hideDlg();
_exitConfirmationActive = false;
}
private function handleClear() : void
{
var k:int = 0;
if(_layerBitmapDatas == null)
{
return;
}
if(_hasDrawn)
{
pushUndo(allLayerIndices(),false);
}
k = 0;
while(k < _layerBitmapDatas.length)
{
(_layerBitmapDatas[k] as BitmapData).fillRect(_drawBitmapDataRect,0);
k++;
}
_timeSinceErase = 0;
_needsSave = false;
refreshLayerPanel(true);
syncCanvasButtons();
}
// Flattens the visible layers at their opacity and blend mode.
// opaque=true puts them on white, which is what a masterpiece is: the
// JPEG encoder ignores alpha, so transparent pixels would otherwise
// come out black.
private function getCompositeBitmapData(opaque:Boolean = false) : BitmapData
{
var composite:BitmapData = opaque ? new BitmapData(_canvasW,_canvasH,false,16777215) : new BitmapData(_canvasW,_canvasH,true,0);
var bmp:Bitmap = null;
var i:int = 0;
while(i < _layerBitmapDatas.length)
{
bmp = _layerBitmaps[i] as Bitmap;
if(bmp != null && bmp.visible && _layerOpacities[i] > 0)
{
composite.draw(_layerBitmapDatas[i],null,_layerOpacities[i] < 1 ? new ColorTransform(1,1,1,_layerOpacities[i]) : null,_layerBlends[i],null,false);
}
i++;
}
return composite;
}
private function onExit_Save() : void
{
onSaveButton();
}
private function onExit_Yes() : void
{
Mouse.show();
hideDlg();
_exitConfirmationActive = false;
end(null);
}
private function onExit_No() : void
{
hideDlg();
_exitConfirmationActive = false;
}
public function setupRequest(param1:Function, param2:Function, param3:int, param4:int, param5:Boolean, param6:int, param7:Boolean = true) : void
{
var _loc11_:Object = null;
var _loc9_:URLRequest = null;
var _loc10_:URLLoader = null;
var _loc8_:String = "---------------------------" + Math.floor(Math.random() * 100000000000000);
if(param3 == 14)
{
_loc11_ = {
"avatarName":gMainFrame.userInfo.playerAvatarInfo.unlocalizedAvName,
"type":param3,
"message":_timeSinceErase,
"languageId":LocalizationManager.currentLanguage,
"previewItemInvIndex":param4,
"secondaryType":(param5 ? "1" : "0"),
"tag":(param6 == 0 ? "" : param6),
"userName":gMainFrame.userInfo.myUserName
};
_loc9_ = new URLRequest(gMainFrame.clientInfo.mdUrl + "fb");
}
else
{
_loc11_ = {"authToken":(_masterPieceSubmissionToken == null ? "" : _masterPieceSubmissionToken)};
_loc9_ = new URLRequest(gMainFrame.clientInfo.mdUrl + "mp");
}
_loc9_.requestHeaders.push(new URLRequestHeader("Cache-Control","no-cache"));
_loc9_.requestHeaders.push(new URLRequestHeader("Content-Type","multipart/form-data; boundary=" + _loc8_));
_loc9_.method = "POST";
_loc9_.data = createPostData("ArtStudioImage",param7 && _jpgEncoder != null ? _jpgEncoder.ImageData : null,_loc8_,_loc11_);
_loc10_ = new URLLoader();
_loc10_.dataFormat = "binary";
if(param1 != null)
{
_loc10_.addEventListener("complete",param1);
_uploadLoader = _loc10_;
}
if(param2 != null)
{
_loc10_.addEventListener("ioError",param2);
_loc10_.addEventListener("securityError",param2);
_loc10_.addEventListener("httpStatus",httpStatusHandler);
}
try
{
_loc10_.load(_loc9_);
}
catch(e:Error)
{
DebugUtility.debugTrace(e.message);
if(param1 != null)
{
param2(null);
}
}
}
public function createPostData(param1:String, param2:ByteArray, param3:String, param4:Object = null) : ByteArray
{
var _loc5_:String = null;
var _loc7_:int = 0;
var _loc8_:ByteArray = new ByteArray();
_loc8_.endian = "bigEndian";
if(param4 == null)
{
param4 = {};
}
var _formFieldCount:int = 0;
for(var _loc6_ in param4)
{
_formFieldCount++;
var _fieldValue:String = param4[_loc6_];
writeBoundary(_loc8_,param3);
writeLineBreak(_loc8_);
_loc5_ = "Content-Disposition: form-data; name=\"" + _loc6_ + "\"";
_loc7_ = 0;
while(_loc7_ < _loc5_.length)
{
_loc8_.writeByte(_loc5_.charCodeAt(_loc7_));
_loc7_++;
}
writeLineBreak(_loc8_);
writeLineBreak(_loc8_);
_loc8_.writeUTFBytes(param4[_loc6_]);
writeLineBreak(_loc8_);
}
if(param2)
{
writeBoundary(_loc8_,param3);
writeLineBreak(_loc8_);
_loc5_ = "Content-Disposition: form-data; name=\"image\"; filename=\"" + param1 + "\"";
_loc7_ = 0;
while(_loc7_ < _loc5_.length)
{
_loc8_.writeByte(_loc5_.charCodeAt(_loc7_));
_loc7_++;
}
writeLineBreak(_loc8_);
_loc5_ = "Content-Type: image/jpeg";
_loc7_ = 0;
while(_loc7_ < _loc5_.length)
{
_loc8_.writeByte(_loc5_.charCodeAt(_loc7_));
_loc7_++;
}
writeLineBreak(_loc8_);
writeLineBreak(_loc8_);
_loc8_.writeBytes(param2);
writeLineBreak(_loc8_);
}
writeBoundary(_loc8_,param3);
writeDoubleDash(_loc8_);
writeLineBreak(_loc8_);
return _loc8_;
}
private function writeLineBreak(param1:ByteArray) : void
{
param1.writeShort(3338);
}
private function writeDoubleDash(param1:ByteArray) : void
{
param1.writeShort(11565);
}
private function writeBoundary(param1:ByteArray, param2:String) : void
{
var _loc3_:int = 0;
writeDoubleDash(param1);
_loc3_ = 0;
while(_loc3_ < param2.length)
{
param1.writeByte(param2.charCodeAt(_loc3_));
_loc3_++;
}
}
private function onSendComplete(param1:Event) : void
{
var _loc4_:ByteArray = null;
var _loc3_:Object = null;
var _loc2_:Date = null;
_uploadLoader = null;
if(_isMasterpieceSubmit)
{
if(!_submitPending)
{
return;
}
_submitPending = false;
stopSubmitWatchdog();
DarkenManager.showLoadingSpiral(false);
param1.currentTarget.data.position = 0;
_loc4_ = param1.currentTarget.data;
if(_loc4_ && _loc4_.length > 0)
{
try
{
_loc3_ = JSON.parse(_loc4_.readMultiByte(_loc4_.bytesAvailable,"utf-8"));
if(_loc3_ && _loc3_.success)
{
_masterpieceUuid = _loc3_.uuid;
setNumMasterpieceIcons();
if(_copiesDone > 0)
{
buyCurrentCopy();
return;
}
_submissionRules = new SubmissionRulesPopup(DiamondXtCommManager.getDiamondDef(221).value,_numMasterpieceTokens,_guiLayer,onSubmissionRulesClose);
SBTracker.trackPageview("/game/play/miniGame/#MasterpiceSubmitted");
return;
}
}
catch(e:Error)
{
}
}
displayMasterpieceFailedPopup();
SBTracker.trackPageview("/game/play/miniGame/#ColoringMasterpieceSendError");
}
else
{
if(_sharedObject != null)
{
_loc2_ = new Date();
_sharedObject.data.userSubmits.push(_loc2_.getTime());
while(_sharedObject.data.userSubmits.length > 5)
{
_sharedObject.data.userSubmits.shift();
}
try
{
_sharedObject.flush();
}
catch(e:Error)
{
}
}
SBTracker.trackPageview("/game/play/miniGame/#ColoringSubmitted");
finishFeedbackSend();
}
}
private function finishFeedbackSend() : void
{
handleClear();
DarkenManager.showLoadingSpiral(false);
hideDlg();
var _loc1_:MovieClip = showDlg("ArtStudioColor_SubmitConfirmDlg",[{
"name":"button_yes",
"f":onExit_No
}],450,275,true,true);
}
private function displayMasterpieceFailedPopup() : void
{
stopCopies();
DarkenManager.showLoadingSpiral(false);
new SBOkPopup(_guiLayer,LocalizationManager.translateIdOnly(25198));
if(_masterpiecePreviewPopup)
{
_masterpiecePreviewPopup.closeCallback = onPreviewClose;
}
}
private function httpStatusHandler(param1:HTTPStatusEvent) : void
{
_URLStatus = param1.status;
}
private function onSendError(param1:Event) : void
{
_uploadLoader = null;
if(_isMasterpieceSubmit)
{
if(!_submitPending)
{
return;
}
_submitPending = false;
stopSubmitWatchdog();
}
DarkenManager.showLoadingSpiral(false);
if(_isMasterpieceSubmit)
{
stopCopies();
if(_URLStatus == 403)
{
new SBOkPopup(GuiManager.guiLayer,LocalizationManager.translateIdOnly(28329));
SBTracker.trackPageview("/game/play/miniGame/#ColoringMasterpieceSendErrorBanned");
}
else
{
displayMasterpieceFailedPopup();
SBTracker.trackPageview("/game/play/miniGame/#ColoringMasterpieceSendError");
}
}
else
{
SBTracker.trackPageview("/game/play/miniGame/#ColoringSendError");
finishFeedbackSend();
}
}
private function handleSaveComplete(param1:Event) : void
{
_needsSave = false;
if(_exitAfterSave)
{
onExit_Yes();
}
else
{
_storageButton.guiBtn.setPressedState(false);
hideDlg();
}
}
private function onSaveButton() : void
{
var fr:FileReference = null;
var mergedBD:BitmapData = null;
var pngBytes:ByteArray = null;
try
{
mergedBD = getCompositeBitmapData(false);
pngBytes = PNGEncoder.encode(mergedBD);
pngBytes = _mediaObject["%&"](gMainFrame.userInfo.myUUID,pngBytes,true);
fr = new FileReference();
fr.addEventListener(Event.COMPLETE,handleSaveComplete);
fr.save(pngBytes,"painting.ajart");
}
catch(e:Error)
{
}
if(mergedBD != null)
{
mergedBD.dispose();
}
}
private function handleLoadError(param1:int) : void
{
hideDlg();
_storageButton.guiBtn.setPressedState(false);
new SBOkPopup(GuiManager.guiLayer,LocalizationManager.translateIdOnly(param1),true);
}
private function handleLoad(param1:Event) : void
{
var incomingBD:BitmapData = null;
var targetLayer:BitmapData = null;
try
{
incomingBD = (param1.target.content as Bitmap).bitmapData;
if(incomingBD == null)
{
throw new Error("Unable to load AJART as BitmapData");
}
pushUndo([_activeLayerIndex],false);
targetLayer = _layerBitmapDatas[_activeLayerIndex];
targetLayer.copyPixels(incomingBD,incomingBD.rect,new Point(0,0));
_needsSave = false;
refreshLayerThumb(_activeLayerIndex);
syncCanvasButtons();
hideDlg();
_storageButton.guiBtn.setPressedState(false);
}
catch(e:Error)
{
handleLoadError(25320);
}
}
private function onFileLoaded(param1:Event) : void
{
var _loc5_:FileReference = null;
var _loc2_:ByteArray = null;
var _loc3_:ByteArray = null;
var _loc4_:Loader = null;
try
{
_loc5_ = param1.target as FileReference;
_loc2_ = _loc5_["data"];
_loc3_ = new ByteArray();
_loc3_.writeObject(_loc2_);
try
{
_loc2_ = _mediaObject["%&"](gMainFrame.userInfo.myUUID,_loc2_,false);
}
catch(e:Error)
{
_loc2_ = null;
}
if(_loc2_ == null)
{
handleLoadError(25320);
}
if(_loc2_ != null)
{
_loc4_ = new Loader();
_loc4_.contentLoaderInfo.addEventListener("complete",handleLoad);
_loc4_.loadBytes(_loc2_);
}
}
catch(e:Error)
{
handleLoadError(25320);
}
}
private function selectHandler(param1:Event) : void
{
try
{
_fileRef.addEventListener("complete",onFileLoaded);
_fileRef.load();
}
catch(e:Error)
{
handleLoadError(25320);
}
}
private function onLoadButton() : void
{
var _loc2_:Array = null;
var _loc1_:FileFilter = null;
try
{
_fileRef = new FileReference();
_fileRef.addEventListener("select",selectHandler);
_loc2_ = [];
_loc1_ = new FileFilter("AJArt Files (*.ajart)","*.*");
_loc2_.push(_loc1_);
_fileRef.browse(_loc2_);
}
catch(e:Error)
{
}
}
private function onUndoClick(e:MouseEvent) : void
{
var st:Object = null;
if(_undoStack.length == 0 || _drawing)
{
return;
}
st = _undoStack.pop();
_redoStack.push(captureState(st.idx,st.props));
applyState(st);
updateUndoRedoUI();
}
private function onRedoClick(e:MouseEvent) : void
{
var st:Object = null;
if(_redoStack.length == 0 || _drawing)
{
return;
}
st = _redoStack.pop();
_undoStack.push(captureState(st.idx,st.props));
applyState(st);
updateUndoRedoUI();
}
private function updateUndoRedoUI() : void
{
ArtStudioKit.setEnabled(_undoBtn,_undoStack.length > 0);
ArtStudioKit.setEnabled(_redoBtn,_redoStack.length > 0);
}
private function updateLayerVisuals() : void
{
var i:int = 0;
var layerBmp:Bitmap = null;
while(i < _layerBitmaps.length)
{
layerBmp = _layerBitmaps[i] as Bitmap;
if(layerBmp)
{
layerBmp.alpha = _layerOpacities[i];
layerBmp.blendMode = _layerBlends[i];
}
i++;
}
}
// Submitting waits on two replies (the gmtkn token over the game socket,
// then the jammercentral upload). Neither had a timeout, so a reply that
// never came left the loading spiral up for good.
private function startSubmitWatchdog(ms:int) : void
{
stopSubmitWatchdog();
_submitPending = true;
_submitTimer = setTimeout(onSubmitTimeout,ms);
}
private function stopSubmitWatchdog() : void
{
if(_submitTimer != 0)
{
clearTimeout(_submitTimer);
_submitTimer = 0;
}
}
private function onSubmitTimeout() : void
{
_submitTimer = 0;
if(!_submitPending)
{
return;
}
_submitPending = false;
if(_uploadLoader != null)
{
try
{
_uploadLoader.close();
}
catch(e:Error)
{
}
_uploadLoader = null;
}
DarkenManager.showLoadingSpiral(false);
displayMasterpieceFailedPopup();
SBTracker.trackPageview("/game/play/miniGame/#ColoringMasterpieceSendTimeout");
}
private function onImportClick(e:MouseEvent) : void
{
_uploadFileRef = new FileReference();
_uploadFileRef.addEventListener(Event.SELECT,onUploadSelect);
_uploadFileRef.addEventListener(Event.CANCEL,onUploadCancel);
_uploadFileRef.browse([new FileFilter("Images (*.png, *.jpg, *.gif)","*.png;*.PNG;*.jpg;*.JPG;*.jpeg;*.JPEG;*.gif;*.GIF")]);
}
private function buildModUI() : void
{
ArtStudioKit.setTipLayer(_guiLayer);
_colorPanel = ArtStudioKit.colorPanel(_layerInterface,128,5,_interfaceObject.loader.content);
buildToolPanel();
buildUndoButtons();
buildBrushPanel();
buildLayerPanel();
}
// The native toolbox shows its selection with h_2 (tools) and h_3
// (brush sizes). Hide them while a mod tool or a slider size is in use,
// and give them back when a native button is clicked.
private function syncNativeControls() : void
{
var c:Object = _interfaceObject.loader.content;
var tool:int = int(c.currentTool);
var bs:int = int(c.brushSize);
if(tool >= 1 && tool <= 8)
{
if(_modTool != 0)
{
_modTool = 0;
updateToolButtons();
updateCanvasCursor();
}
c.h_2.visible = true;
}
else
{
c.h_2.visible = false;
}
if(bs >= 1 && bs <= _drawSizes.length)
{
if(_drawSizes[bs - 1] != _brushSizeVal)
{
_brushSizeVal = _drawSizes[bs - 1];
ArtStudioKit.sliderSet(_sizeSlider,_brushSizeVal);
}
if(tool != 5)
{
c.h_3.visible = true;
}
}
else
{
c.h_3.visible = false;
}
}
// Top right, between the title and the close button: the mod's tools,
// then the menu (image, adjustments, filters, layer, view).
private function buildToolPanel() : void
{
var px:int = 610;
var py:int = 5;
var x:int = px + 8;
ArtStudioKit.panel(_layerInterface,px,py,226,36);
_toolBtns = {};
x = addToolButton(TOOL_PEN,"pen","Pen: hard pixel edges (P)",x,py + 4);
x = addToolButton(TOOL_ERASER,"eraser","Eraser (E)",x,py + 4);
x = addToolButton(TOOL_BLUR,"blur","Blur",x,py + 4);
x = addToolButton(TOOL_EYEDROP,"picker","Colour picker (I, or Alt+click)",x,py + 4);
x = addToolButton(TOOL_HAND,"hand","Hand: drag to move around (H, or hold Space)",x,py + 4);
x = addToolButton(TOOL_GRADIENT,"gradient","Gradient: drag from where the colour starts (G)",x,py + 4);
ArtStudioKit.divider(_layerInterface,x + 2,py + 6,24);
_menuBtn = ArtStudioKit.button("menu","Menu: import/export, adjustments, filters, layers, view",26,28,onMenuButton);
_menuBtn.x = x + 8;
_menuBtn.y = py + 4;
_layerInterface.addChild(_menuBtn);
}
private function addToolButton(tool:int, icon:String, tip:String, x:int, y:int) : int
{
var b:MovieClip = ArtStudioKit.button(icon,tip,26,28,onModToolClick);
b.toolId = tool;
b.x = x;
b.y = y;
_layerInterface.addChild(b);
_toolBtns[tool] = b;
return x + 29;
}
private function onModToolClick(e:MouseEvent) : void
{
selectModTool(int((e.currentTarget as MovieClip).toolId));
}
private function selectModTool(tool:int) : void
{
var c:Object = _interfaceObject.loader.content;
if(tool == TOOL_EYEDROP && int(c.currentTool) != TOOL_EYEDROP)
{
_toolBeforePick = int(c.currentTool);
}
c.currentTool = tool;
_currentTool = tool;
_modTool = tool;
c.h_2.visible = false;
if(c.activeCursor)
{
c.activeCursor.gotoAndPlay("tool_2");
}
updateToolButtons();
updateCanvasCursor();
}
private function updateToolButtons() : void
{
for(var key:String in _toolBtns)
{
ArtStudioKit.setActive(_toolBtns[key],int(key) == _modTool);
}
}
private function pickColorAt(x:Number, y:Number, restoreTool:Boolean = true) : void
{
var c:Object = _interfaceObject.loader.content;
var mx:int = Math.max(0,Math.min(int(x),_canvasW - 1));
var my:int = Math.max(0,Math.min(int(y),_canvasH - 1));
var argb:uint = getCompositeColor(mx,my);
ArtStudioKit.applyColor(c,(argb >>> 24) == 0 ? 16777215 : int(argb & 0xFFFFFF));
AJAudio.playSubMenuBtnRollover();
if(!restoreTool)
{
return;
}
if(_toolBeforePick >= 1 && _toolBeforePick <= 8)
{
c.setTool(_toolBeforePick);
}
else if(_toolBeforePick == TOOL_PEN || _toolBeforePick == TOOL_ERASER || _toolBeforePick == TOOL_BLUR || _toolBeforePick == TOOL_GRADIENT)
{
selectModTool(_toolBeforePick);
}
else
{
c.setTool(1);
}
}
// Multi-step undo/redo replaces the native one-step undo button, in the
// same spot at the bottom of the toolbox.
private function buildUndoButtons() : void
{
var c:Object = _interfaceObject.loader.content;
var r:Rectangle = c.tool_9.getBounds(_layerInterface);
var w:int = 0;
if(r.width < 40 || r.width > 140 || r.height < 16 || r.height > 44)
{
r = new Rectangle(37,516,64,24);
}
c.tool_9.visible = false;
w = int((r.width - 4) / 2);
_undoBtn = ArtStudioKit.button("undo","Undo (Ctrl+Z)",w,int(r.height),onUndoClick);
_undoBtn.x = int(r.x);
_undoBtn.y = int(r.y);
_layerInterface.addChild(_undoBtn);
_redoBtn = ArtStudioKit.button("redo","Redo (Ctrl+Y)",w,int(r.height),onRedoClick);
_redoBtn.x = int(r.x) + w + 4;
_redoBtn.y = int(r.y);
_layerInterface.addChild(_redoBtn);
updateUndoRedoUI();
}
// Bottom left, in the strip the print and sketch buttons used to hold:
// brush size, opacity and softness, then zoom.
private function buildBrushPanel() : void
{
var px:int = 128;
var py:int = 496;
ArtStudioKit.panel(_layerInterface,px,py,338,50);
_sizeSlider = ArtStudioKit.slider("SIZE",58,false,MIN_SIZE,MAX_SIZE,2.2,formatPx,onSizeSlider,"Brush size ( [ and ] )");
_sizeSlider.x = px + 12;
_sizeSlider.y = py + 4;
_layerInterface.addChild(_sizeSlider);
ArtStudioKit.sliderSet(_sizeSlider,_brushSizeVal);
_opacitySlider = ArtStudioKit.slider("OPACITY",58,false,0,100,1,formatPercent,onOpacitySlider,"Brush opacity");
_opacitySlider.x = px + 88;
_opacitySlider.y = py + 4;
_layerInterface.addChild(_opacitySlider);
ArtStudioKit.sliderSet(_opacitySlider,_brushOpacity * 100);
_softSlider = ArtStudioKit.slider("SOFT",58,false,0,100,1,formatPercent,onSoftSlider,"Brush softness: blurs the edge of brush, airbrush and pen strokes");
_softSlider.x = px + 164;
_softSlider.y = py + 4;
_layerInterface.addChild(_softSlider);
ArtStudioKit.sliderSet(_softSlider,(1 - _brushHardness) * 100);
ArtStudioKit.divider(_layerInterface,px + 230,py + 8,34);
_zoomOutBtn = ArtStudioKit.button("zoomOut","Zoom out (Ctrl -)",24,26,onZoomOutClick);
_zoomOutBtn.x = px + 237;
_zoomOutBtn.y = py + 12;
_layerInterface.addChild(_zoomOutBtn);
_zoomLabelBtn = ArtStudioKit.button(null,"Reset zoom (Ctrl 0). Move around with the hand tool or Space+drag",42,26,onZoomResetClick,"100%");
_zoomLabelBtn.x = px + 264;
_zoomLabelBtn.y = py + 12;
_layerInterface.addChild(_zoomLabelBtn);
_zoomInBtn = ArtStudioKit.button("zoomIn","Zoom in (Ctrl +)",24,26,onZoomInClick);
_zoomInBtn.x = px + 309;
_zoomInBtn.y = py + 12;
_layerInterface.addChild(_zoomInBtn);
updateZoomUI();
}
private function formatPx(v:Number) : String
{
return Math.round(v) + "px";
}
private function formatPercent(v:Number) : String
{
return Math.round(v) + "%";
}
private function onSizeSlider(v:Number) : void
{
_brushSizeVal = Math.max(MIN_SIZE,Math.round(v));
_interfaceObject.loader.content.brushSize = 0;
}
private function setBrushSize(v:Number) : void
{
_brushSizeVal = Math.max(MIN_SIZE,Math.min(MAX_SIZE,Math.round(v)));
_interfaceObject.loader.content.brushSize = 0;
ArtStudioKit.sliderSet(_sizeSlider,_brushSizeVal);
}
private function onOpacitySlider(v:Number) : void
{
_brushOpacity = v / 100;
}
private function onSoftSlider(v:Number) : void
{
_brushHardness = 1 - v / 100;
}
// Right of the canvas: the seven layers (top of the column is the top
// layer) with thumbnails, then hide, move, merge and layer opacity.
private function buildLayerPanel() : void
{
var px:int = 856;
var py:int = 52;
var cap:TextField = null;
var chip:MovieClip = null;
var thumb:BitmapData = null;
var tb:Bitmap = null;
var mark:Sprite = null;
var markIcon:Shape = null;
var i:int = 0;
var y:int = 0;
ArtStudioKit.panel(_layerInterface,px,py,40,434);
cap = ArtStudioKit.text("LAYERS",10,ArtStudioKit.TEXT_LIGHT,40,"center");
cap.x = px;
cap.y = py + 3;
_layerInterface.addChild(cap);
_thumbChecker = new BitmapData(28,17,false,16777215);
y = 0;
while(y < 17)
{
i = 0;
while(i < 28)
{
if((i / 4 + y / 4) % 2 == 1)
{
_thumbChecker.fillRect(new Rectangle(i,y,4,4),14540253);
}
i += 4;
}
y += 4;
}
_layerChips = [];
_layerThumbs = [];
i = 0;
while(i < NUM_LAYERS)
{
chip = ArtStudioKit.button(null,"Layer " + (i + 1),32,26,onLayerChipClick);
chip.layerIndex = i;
chip.x = px + 4;
chip.y = py + 20 + (NUM_LAYERS - 1 - i) * 29;
thumb = new BitmapData(28,17,false,16777215);
tb = new Bitmap(thumb,"auto",true);
tb.x = 2;
tb.y = 4;
chip.addChild(tb);
mark = new Sprite();
mark.graphics.beginFill(5910032,0.6);
mark.graphics.drawRect(2,4,28,17);
markIcon = new Shape();
ArtStudioKit.drawIcon(markIcon.graphics,"eyeOff",16771522);
markIcon.scaleX = markIcon.scaleY = 0.75;
markIcon.x = 8.5;
markIcon.y = 5;
mark.addChild(markIcon);
mark.visible = false;
chip.addChild(mark);
chip.hiddenMark = mark;
_layerChips.push(chip);
_layerThumbs.push(thumb);
_layerInterface.addChild(chip);
i++;
}
y = py + 20 + NUM_LAYERS * 29 + 4;
_eyeBtn = addLayerButton("eye","Hide layer",px + 4,y,onToggleLayerClick);
_upBtn = addLayerButton("up","Move layer up",px + 4,y + 27,onMoveLayerUp);
_downBtn = addLayerButton("down","Move layer down",px + 4,y + 54,onMoveLayerDown);
_mergeBtn = addLayerButton("merge","Merge into the layer below",px + 4,y + 81,onMergeLayerDown);
_layerOpacitySlider = ArtStudioKit.slider("",56,true,0,100,1,formatPercent,onLayerOpacitySlider,"Layer opacity");
_layerOpacitySlider.x = px + 20;
_layerOpacitySlider.y = y + 112;
_layerInterface.addChild(_layerOpacitySlider);
_activeLayerIndex = 3;
refreshLayerPanel(true);
}
private function addLayerButton(icon:String, tip:String, x:int, y:int, fn:Function) : MovieClip
{
var b:MovieClip = ArtStudioKit.button(icon,tip,32,24,fn);
b.x = x;
b.y = y;
_layerInterface.addChild(b);
return b;
}
private function refreshLayerPanel(thumbs:Boolean) : void
{
var i:int = 0;
var chip:MovieClip = null;
var shown:Boolean = false;
if(_layerChips == null)
{
return;
}
while(i < _layerChips.length)
{
chip = _layerChips[i];
ArtStudioKit.setActive(chip,i == _activeLayerIndex);
chip.hiddenMark.visible = !(_layerBitmaps[i] as Bitmap).visible;
chip.tip = "Layer " + (i + 1) + (_layerBlends[i] != BlendMode.NORMAL ? " - " + _layerBlends[i] : "") + (_layerLocks[i] ? " - transparency locked" : "");
if(thumbs)
{
refreshLayerThumb(i);
}
i++;
}
shown = (_layerBitmaps[_activeLayerIndex] as Bitmap).visible;
ArtStudioKit.setIcon(_eyeBtn,shown ? "eye" : "eyeOff");
_eyeBtn.tip = shown ? "Hide layer" : "Show layer";
ArtStudioKit.setEnabled(_upBtn,_activeLayerIndex < NUM_LAYERS - 1);
ArtStudioKit.setEnabled(_downBtn,_activeLayerIndex > 0);
ArtStudioKit.setEnabled(_mergeBtn,_activeLayerIndex > 0);
ArtStudioKit.sliderSet(_layerOpacitySlider,_layerOpacities[_activeLayerIndex] * 100);
}
private function refreshLayerThumb(i:int) : void
{
var thumb:BitmapData = null;
var src:BitmapData = null;
var m:Matrix = null;
if(_layerThumbs == null || i < 0 || i >= _layerThumbs.length)
{
return;
}
thumb = _layerThumbs[i];
src = _layerBitmapDatas[i];
m = new Matrix();
m.scale(thumb.width / src.width,thumb.height / src.height);
thumb.copyPixels(_thumbChecker,_thumbChecker.rect,ORIGIN);
thumb.draw(src,m,null,null,null,true);
}
private function onLayerChipClick(e:MouseEvent) : void
{
_activeLayerIndex = int((e.currentTarget as MovieClip).layerIndex);
refreshLayerPanel(false);
}
// Swaps two layers' bitmaps, display order and opacity; the active layer
// follows the one that moved.
private function swapLayers(a:int, b:int) : void
{
var tmpBD:BitmapData = _layerBitmapDatas[a];
var tmpBmp:Bitmap = _layerBitmaps[a];
var tmpOpacity:Number = Number(_layerOpacities[a]);
var tmpBlend:String = _layerBlends[a];
var tmpLock:Boolean = Boolean(_layerLocks[a]);
pushUndo([a,b],true);
_layerBlends[a] = _layerBlends[b];
_layerBlends[b] = tmpBlend;
_layerLocks[a] = _layerLocks[b];
_layerLocks[b] = tmpLock;
_layerBitmapDatas[a] = _layerBitmapDatas[b];
_layerBitmapDatas[b] = tmpBD;
_layerBitmaps[a] = _layerBitmaps[b];
_layerBitmaps[b] = tmpBmp;
_layerOpacities[a] = _layerOpacities[b];
_layerOpacities[b] = tmpOpacity;
_layersContainer.setChildIndex(_layerBitmaps[a],a);
_layersContainer.setChildIndex(_layerBitmaps[b],b);
_activeLayerIndex = b;
updateLayerVisuals();
refreshLayerPanel(true);
}
private function onLayerOpacitySlider(v:Number) : void
{
_layerOpacities[_activeLayerIndex] = v / 100;
updateLayerVisuals();
}
private function flashTip(target:DisplayObject, msg:String) : void
{
if(target != null)
{
ArtStudioKit.showTip(target,msg);
setTimeout(ArtStudioKit.hideTip,2200);
}
}
private function allLayerIndices() : Array
{
var out:Array = [];
var i:int = 0;
while(i < NUM_LAYERS)
{
out.push(i);
i++;
}
return out;
}
// One undo step holds copies of only the layers an action changed
// (usually just the active one), not all seven: 100 full snapshots of
// seven canvas-sized layers could use most of a gigabyte. withProps also
// records opacity, visibility and the active layer, for moves and merges.
private function captureState(indices:Array, withProps:Boolean) : Object
{
var bds:Array = [];
var vis:Array = null;
var st:Object = null;
var k:int = 0;
while(k < indices.length)
{
bds.push((_layerBitmapDatas[indices[k]] as BitmapData).clone());
k++;
}
st = {
"idx":indices.concat(),
"bds":bds,
"props":withProps
};
if(withProps)
{
vis = [];
k = 0;
while(k < _layerBitmaps.length)
{
vis.push((_layerBitmaps[k] as Bitmap).visible);
k++;
}
st.opac = _layerOpacities.concat();
st.blends = _layerBlends.concat();
st.locks = _layerLocks.concat();
st.vis = vis;
st.active = _activeLayerIndex;
}
return st;
}
private function applyState(st:Object) : void
{
var bd:BitmapData = null;
var k:int = 0;
while(k < st.idx.length)
{
bd = st.bds[k];
(_layerBitmapDatas[st.idx[k]] as BitmapData).copyPixels(bd,bd.rect,ORIGIN);
bd.dispose();
k++;
}
if(st.props)
{
_layerOpacities = (st.opac as Array).concat();
_layerBlends = (st.blends as Array).concat();
_layerLocks = (st.locks as Array).concat();
k = 0;
while(k < _layerBitmaps.length)
{
(_layerBitmaps[k] as Bitmap).visible = st.vis[k];
k++;
}
_activeLayerIndex = int(st.active);
updateLayerVisuals();
}
refreshLayerPanel(true);
syncCanvasButtons();
_needsSave = true;
}
private function disposeState(st:Object) : void
{
var k:int = 0;
while(k < st.bds.length)
{
(st.bds[k] as BitmapData).dispose();
k++;
}
}
private function pushUndo(indices:Array, withProps:Boolean) : void
{
_undoStack.push(captureState(indices,withProps));
while(_undoStack.length > MAX_UNDO)
{
disposeState(_undoStack.shift());
}
clearRedo();
updateUndoRedoUI();
}
private function clearRedo() : void
{
while(_redoStack.length > 0)
{
disposeState(_redoStack.pop());
}
}
// Grays the native create / print / clear buttons when every layer is
// empty (after undo, clear or a merge), and enables them otherwise.
private function syncCanvasButtons() : void
{
var has:Boolean = false;
var i:int = 0;
while(i < _layerBitmapDatas.length && !has)
{
has = (_layerBitmapDatas[i] as BitmapData).getColorBoundsRect(4278190080,0,false).width > 0;
i++;
}
_hasDrawn = has;
_masterpieceSubmitBtn.guiBtn.setGrayState(!has);
if(_submitButton != null)
{
_submitButton.guiBtn.setGrayState(!has);
}
_printBtn.guiBtn.setGrayState(!has);
_clearAllButton.guiBtn.setGrayState(!has);
}
// Keeps at least PAN_MARGIN px of the painting inside the canvas frame,
// so it can't be dragged out of reach.
private function clampPan() : void
{
var w:Number = _canvasW * _zoomLevel;
var h:Number = _canvasH * _zoomLevel;
var left:Number = canvasLeft();
var clamped:Number = Math.max(PAN_MARGIN - w,Math.min(_canvasW - PAN_MARGIN,left));
_drawCanvas.x += clamped - left;
_drawCanvas.y = Math.max(PAN_MARGIN - h,Math.min(_canvasH - PAN_MARGIN,_drawCanvas.y));
}
private function isHandActive() : Boolean
{
return _spaceHeld || _modTool == TOOL_HAND;
}
// Over the canvas the brush cursor replaces the mouse, except with the
// hand (tool or Space held), which shows the system hand.
private function updateCanvasCursor() : void
{
var hand:Boolean = (_overCanvas || _isPanning) && isHandActive();
if(ArtStudioKit.isPlacing())
{
Mouse.cursor = MouseCursor.AUTO;
Mouse.show();
_layerMouse.visible = false;
}
else if(hand)
{
Mouse.show();
Mouse.cursor = MouseCursor.HAND;
_layerMouse.visible = false;
}
else if(_overCanvas)
{
Mouse.cursor = MouseCursor.AUTO;
Mouse.hide();
_layerMouse.visible = true;
}
else
{
Mouse.cursor = MouseCursor.AUTO;
Mouse.show();
_layerMouse.visible = false;
}
}
private function onKeyUp(e:KeyboardEvent) : void
{
if(e.keyCode == Keyboard.SPACE && _spaceHeld)
{
_spaceHeld = false;
updateCanvasCursor();
}
}
private function onMenuButton(e:MouseEvent) : void
{
if(ArtStudioKit.isMenuOpen())
{
ArtStudioKit.closeMenu();
return;
}
if(ArtStudioKit.isPlacing() || ArtStudioKit.isDialogOpen())
{
return;
}
ArtStudioKit.hideTip();
ArtStudioKit.openMenu(_guiLayer,836,44,[[{"header":"IMAGE"},{
"id":"import",
"label":"Import Image..."
},{
"id":"export",
"label":"Export PNG"
},{"header":"ADJUST LAYER"},{
"id":"bc",
"label":"Brightness / Contrast..."
},{
"id":"hsl",
"label":"Hue / Saturation..."
},{
"id":"invert",
"label":"Invert (Ctrl+I)"
},{
"id":"bw",
"label":"Black & White"
},{
"id":"fliph",
"label":"Flip Horizontal"
},{
"id":"flipv",
"label":"Flip Vertical"
},{"header":"FILTER LAYER"},{
"id":"blur",
"label":"Blur..."
},{
"id":"sharpen",
"label":"Sharpen"
},{
"id":"outline",
"label":"Outline..."
},{
"id":"shadow",
"label":"Drop Shadow"
}],[{"header":"LAYER"},{
"id":"dup",
"label":"Duplicate (Ctrl+J)"
},{
"id":"clear",
"label":"Clear Layer"
},{
"id":"mergevis",
"label":"Merge Visible"
},{
"id":"lock",
"label":"Lock Transparency"
},{"header":"BLEND MODE"},{
"id":"b:normal",
"label":"Normal"
},{
"id":"b:multiply",
"label":"Multiply"
},{
"id":"b:screen",
"label":"Screen"
},{
"id":"b:overlay",
"label":"Overlay"
},{
"id":"b:darken",
"label":"Darken"
},{
"id":"b:lighten",
"label":"Lighten"
},{
"id":"b:add",
"label":"Add"
},{
"id":"b:difference",
"label":"Difference"
},{"header":"VIEW & BRUSH"},{
"id":"flipview",
"label":"Flip View (V)"
},{
"id":"fill",
"label":"Filled Shapes"
},{
"id":"s:0",
"label":"Smoothing: Off"
},{
"id":"s:1",
"label":"Smoothing: Low"
},{
"id":"s:2",
"label":"Smoothing: High"
}]],onMenuPick,isMenuChecked,isMenuDisabled,_menuBtn);
}
private function isMenuChecked(id:String) : Boolean
{
if(id.indexOf("b:") == 0)
{
return _layerBlends[_activeLayerIndex] == id.substr(2);
}
if(id.indexOf("s:") == 0)
{
return SMOOTHING[int(id.substr(2))] == _smoothing;
}
switch(id)
{
case "lock":
return Boolean(_layerLocks[_activeLayerIndex]);
case "flipview":
return _viewFlipped;
case "fill":
return _fillShapes;
default:
return false;
}
}
private function isMenuDisabled(id:String) : Boolean
{
return id == "dup" && !canDuplicateLayer();
}
private function onMenuPick(id:String) : void
{
if(id.indexOf("b:") == 0)
{
_layerBlends[_activeLayerIndex] = id.substr(2);
updateLayerVisuals();
refreshLayerPanel(false);
_needsSave = true;
return;
}
if(id.indexOf("s:") == 0)
{
_smoothing = SMOOTHING[int(id.substr(2))];
return;
}
switch(id)
{
case "import":
onImportClick(null);
break;
case "export":
onExportClick(null);
break;
case "bc":
startAdjust("bc","BRIGHTNESS / CONTRAST",[{
"id":"brightness",
"label":"Brightness",
"min":-100,
"max":100,
"value":0,
"fmt":ArtStudioKit.formatSigned
},{
"id":"contrast",
"label":"Contrast",
"min":-100,
"max":100,
"value":0,
"fmt":ArtStudioKit.formatSigned
}]);
break;
case "hsl":
startAdjust("hsl","HUE / SATURATION",[{
"id":"hue",
"label":"Hue",
"min":-180,
"max":180,
"value":0,
"fmt":ArtStudioKit.formatSigned
},{
"id":"saturation",
"label":"Saturation",
"min":-100,
"max":100,
"value":0,
"fmt":ArtStudioKit.formatSigned
},{
"id":"lightness",
"label":"Lightness",
"min":-100,
"max":100,
"value":0,
"fmt":ArtStudioKit.formatSigned
}]);
break;
case "blur":
startAdjust("blur","BLUR LAYER",[{
"id":"radius",
"label":"Radius",
"min":0,
"max":40,
"value":4,
"fmt":formatPx
}]);
break;
case "outline":
startAdjust("outline","OUTLINE IN CURRENT COLOUR",[{
"id":"size",
"label":"Size",
"min":1,
"max":20,
"value":3,
"fmt":formatPx
}]);
break;
case "invert":
case "bw":
case "fliph":
case "flipv":
case "sharpen":
case "shadow":
applyInstant(id);
break;
case "dup":
duplicateLayer();
break;
case "clear":
pushUndo([_activeLayerIndex],false);
(_layerBitmapDatas[_activeLayerIndex] as BitmapData).fillRect(_drawBitmapDataRect,0);
refreshLayerThumb(_activeLayerIndex);
syncCanvasButtons();
_needsSave = true;
break;
case "mergevis":
mergeVisibleLayers();
break;
case "lock":
_layerLocks[_activeLayerIndex] = !_layerLocks[_activeLayerIndex];
refreshLayerPanel(false);
break;
case "flipview":
toggleFlipView();
break;
case "fill":
_fillShapes = !_fillShapes;
}
}
// Adjustments with sliders preview live on the active layer; Cancel puts
// the layer back and drops the undo step it opened with.
private function startAdjust(kind:String, title:String, sliders:Array) : void
{
var values:Object = {};
var i:int = 0;
pushUndo([_activeLayerIndex],false);
_adjustBase = (_layerBitmapDatas[_activeLayerIndex] as BitmapData).clone();
_adjustKind = kind;
ArtStudioKit.openDialog(_guiLayer,494,270,title,sliders,onAdjustChange,onAdjustClose);
while(i < sliders.length)
{
values[sliders[i].id] = sliders[i].value;
i++;
}
onAdjustChange(values);
}
private function onAdjustChange(values:Object) : void
{
var bd:BitmapData = _layerBitmapDatas[_activeLayerIndex];
var filters:Array = adjustFilters(_adjustKind,values);
var i:int = 0;
if(_adjustBase == null)
{
return;
}
bd.copyPixels(_adjustBase,_drawBitmapDataRect,ORIGIN);
while(i < filters.length)
{
bd.applyFilter(bd,_drawBitmapDataRect,ORIGIN,filters[i]);
i++;
}
applyAlphaLock();
refreshLayerThumb(_activeLayerIndex);
}
private function onAdjustClose(ok:Boolean) : void
{
if(_adjustBase == null)
{
return;
}
if(!ok)
{
(_layerBitmapDatas[_activeLayerIndex] as BitmapData).copyPixels(_adjustBase,_drawBitmapDataRect,ORIGIN);
if(_undoStack.length > 0)
{
disposeState(_undoStack.pop());
}
updateUndoRedoUI();
}
else
{
_needsSave = true;
}
_adjustBase.dispose();
_adjustBase = null;
refreshLayerThumb(_activeLayerIndex);
syncCanvasButtons();
}
private function adjustFilters(kind:String, v:Object) : Array
{
var s:Number = NaN;
var o:Number = NaN;
switch(kind)
{
case "bc":
s = v.contrast >= 0 ? 1 + v.contrast / 50 : 1 + v.contrast / 100;
o = 128 * (1 - s) + v.brightness * 1.28;
return [new ColorMatrixFilter([s,0,0,0,o,0,s,0,0,o,0,0,s,0,o,0,0,0,1,0])];
case "hsl":
return [new ColorMatrixFilter(hueMatrix(v.hue)),new ColorMatrixFilter(saturationMatrix(1 + v.saturation / 100)),new ColorMatrixFilter([1,0,0,0,v.lightness * 2.55,0,1,0,0,v.lightness * 2.55,0,0,1,0,v.lightness * 2.55,0,0,0,1,0])];
case "blur":
return v.radius > 0 ? [new BlurFilter(v.radius,v.radius,3)] : [];
case "outline":
return [new GlowFilter(ArtStudioKit.currentColor(_interfaceObject.loader.content),1,v.size * 2,v.size * 2,16,2)];
default:
return [];
}
}
private function hueMatrix(deg:Number) : Array
{
var a:Number = deg * Math.PI / 180;
var c:Number = Math.cos(a);
var s:Number = Math.sin(a);
var lr:Number = 0.213;
var lg:Number = 0.715;
var lb:Number = 0.072;
return [lr + c * (1 - lr) - s * lr,lg - c * lg - s * lg,lb - c * lb + s * (1 - lb),0,0,lr - c * lr + s * 0.143,lg + c * (1 - lg) + s * 0.14,lb - c * lb - s * 0.283,0,0,lr - c * lr - s * (1 - lr),lg - c * lg + s * lg,lb + c * (1 - lb) + s * lb,0,0,0,0,0,1,0];
}
private function saturationMatrix(s:Number) : Array
{
var sr:Number = (1 - s) * 0.213;
var sg:Number = (1 - s) * 0.715;
var sb:Number = (1 - s) * 0.072;
return [sr + s,sg,sb,0,0,sr,sg + s,sb,0,0,sr,sg,sb + s,0,0,0,0,0,1,0];
}
private function applyInstant(kind:String) : void
{
var bd:BitmapData = _layerBitmapDatas[_activeLayerIndex];
var tmp:BitmapData = null;
pushUndo([_activeLayerIndex],false);
switch(kind)
{
case "invert":
bd.applyFilter(bd,_drawBitmapDataRect,ORIGIN,new ColorMatrixFilter([-1,0,0,0,255,0,-1,0,0,255,0,0,-1,0,255,0,0,0,1,0]));
break;
case "bw":
bd.applyFilter(bd,_drawBitmapDataRect,ORIGIN,new ColorMatrixFilter(saturationMatrix(0)));
break;
case "fliph":
case "flipv":
tmp = bd.clone();
bd.fillRect(_drawBitmapDataRect,0);
bd.draw(tmp,kind == "fliph" ? new Matrix(-1,0,0,1,_canvasW,0) : new Matrix(1,0,0,-1,0,_canvasH));
tmp.dispose();
break;
case "sharpen":
bd.applyFilter(bd,_drawBitmapDataRect,ORIGIN,new ConvolutionFilter(3,3,[0,-1,0,-1,5,-1,0,-1,0],1,0,true,true));
break;
case "shadow":
bd.applyFilter(bd,_drawBitmapDataRect,ORIGIN,new DropShadowFilter(6,45,0,0.55,8,8,1,2));
}
applyAlphaLock();
refreshLayerThumb(_activeLayerIndex);
syncCanvasButtons();
_needsSave = true;
}
private function isLayerEmpty(i:int) : Boolean
{
return (_layerBitmapDatas[i] as BitmapData).getColorBoundsRect(4278190080,0,false).width == 0;
}
// Duplicate needs the top layer free: the layers above the active one
// shift up one to make room for the copy.
private function canDuplicateLayer() : Boolean
{
return _activeLayerIndex < NUM_LAYERS - 1 && isLayerEmpty(NUM_LAYERS - 1);
}
private function duplicateLayer() : void
{
var i:int = 0;
if(!canDuplicateLayer())
{
flashTip(_menuBtn,"No free layer: the top layer has to be empty.");
return;
}
pushUndo(allLayerIndices(),true);
i = NUM_LAYERS - 1;
while(i > _activeLayerIndex)
{
copyLayer(i - 1,i);
i--;
}
_activeLayerIndex++;
updateLayerVisuals();
refreshLayerPanel(true);
_needsSave = true;
}
private function copyLayer(from:int, to:int) : void
{
(_layerBitmapDatas[to] as BitmapData).copyPixels(_layerBitmapDatas[from],_drawBitmapDataRect,ORIGIN);
(_layerBitmaps[to] as Bitmap).visible = (_layerBitmaps[from] as Bitmap).visible;
_layerOpacities[to] = _layerOpacities[from];
_layerBlends[to] = _layerBlends[from];
_layerLocks[to] = _layerLocks[from];
}
// Flattens the visible layers (at their opacity and blend) into the
// lowest visible one; hidden layers are left alone.
private function mergeVisibleLayers() : void
{
var target:int = -1;
var flat:BitmapData = new BitmapData(_canvasW,_canvasH,true,0);
var i:int = 0;
pushUndo(allLayerIndices(),true);
while(i < NUM_LAYERS)
{
if((_layerBitmaps[i] as Bitmap).visible)
{
if(target < 0)
{
target = i;
}
flat.draw(_layerBitmapDatas[i],null,_layerOpacities[i] < 1 ? new ColorTransform(1,1,1,_layerOpacities[i]) : null,i == target ? null : _layerBlends[i]);
if(i != target)
{
(_layerBitmapDatas[i] as BitmapData).fillRect(_drawBitmapDataRect,0);
_layerOpacities[i] = 1;
_layerBlends[i] = BlendMode.NORMAL;
}
}
i++;
}
if(target >= 0)
{
(_layerBitmapDatas[target] as BitmapData).copyPixels(flat,_drawBitmapDataRect,ORIGIN);
_layerOpacities[target] = 1;
_layerBlends[target] = BlendMode.NORMAL;
_activeLayerIndex = target;
}
flat.dispose();
updateLayerVisuals();
refreshLayerPanel(true);
syncCanvasButtons();
_needsSave = true;
}
// Lock transparency: after a change to the active layer, put its alpha
// back to what it was before (kept in the undo step the change opened),
// so paint only lands where the layer already has pixels.
private function applyAlphaLock() : void
{
var st:Object = null;
var k:int = 0;
if(!_layerLocks[_activeLayerIndex] || _undoStack.length == 0)
{
return;
}
st = _undoStack[_undoStack.length - 1];
k = (st.idx as Array).indexOf(_activeLayerIndex);
if(k >= 0)
{
(_layerBitmapDatas[_activeLayerIndex] as BitmapData).copyChannel(st.bds[k],_drawBitmapDataRect,ORIGIN,BitmapDataChannel.ALPHA,BitmapDataChannel.ALPHA);
}
}
// Mirrors the view (not the painting) to check proportions; drawing
// still lands where the pointer is.
private function toggleFlipView() : void
{
_viewFlipped = !_viewFlipped;
_drawCanvas.scaleX = -_drawCanvas.scaleX;
_drawCanvas.x = _canvasW - _drawCanvas.x;
clampPan();
}
private function canvasLeft() : Number
{
return _viewFlipped ? _drawCanvas.x - _canvasW * _zoomLevel : _drawCanvas.x;
}
// A ring under the pointer at the brush's real size (at this zoom), for
// the tools that use the size.
private function updateSizeRing() : void
{
var tool:int = _interfaceObject != null ? int(_interfaceObject.loader.content.currentTool) : 0;
var r:Number = _brushSizeVal * 0.5 * _zoomLevel;
var show:Boolean = _layerMouse.visible && tool != 5 && tool != TOOL_EYEDROP && tool != TOOL_HAND && tool != TOOL_GRADIENT && r >= 3;
_sizeRing.visible = show;
if(!show)
{
return;
}
_sizeRing.x = mouseX;
_sizeRing.y = mouseY;
if(r != _sizeRingRadius)
{
_sizeRingRadius = r;
_sizeRing.graphics.clear();
_sizeRing.graphics.lineStyle(2.5,0,0.45);
_sizeRing.graphics.drawCircle(0,0,r);
_sizeRing.graphics.lineStyle(1,16777215,0.9);
_sizeRing.graphics.drawCircle(0,0,r);
}
}
private function drawGradientPreview() : void
{
var dx:Number = _drawCanvas.mouseX - _drawStartX;
var dy:Number = _drawCanvas.mouseY - _drawStartY;
var len:Number = Math.max(1,Math.sqrt(dx * dx + dy * dy));
var m:Matrix = new Matrix();
var color:uint = uint(ArtStudioKit.currentColor(_interfaceObject.loader.content));
m.createGradientBox(len,len,0,0,-len / 2);
m.rotate(Math.atan2(dy,dx));
m.translate(_drawStartX,_drawStartY);
_gradShape.graphics.clear();
_gradShape.graphics.beginGradientFill(GradientType.LINEAR,[color,color],[_brushOpacity,0],[0,255],m,SpreadMethod.PAD);
_gradShape.graphics.drawRect(0,0,_canvasW,_canvasH);
_gradShape.graphics.endFill();
}
private function commitGradient() : void
{
if(_gradShape.parent != null)
{
_gradShape.parent.removeChild(_gradShape);
(_layerBitmapDatas[_activeLayerIndex] as BitmapData).draw(_gradShape);
}
_gradShape.graphics.clear();
}
private function smoothStep(x:Number, y:Number) : void
{
_smX += (x - _smX) * (1 - _smoothing);
_smY += (y - _smY) * (1 - _smoothing);
}
// Mod: buy several copies of the masterpiece in one go, like the bulk
// purchase in item shops. Each copy is the vanilla flow (upload the
// painting for a new id, then buy it); copies after the first reuse the
// encoded painting and the first copy's token/diamond choice, and skip
// the rules popup. Capped by free den slots and by what you can afford;
// the first failure stops the run.
private function askCopyCount() : void
{
// Burrow: one copy, the game's own purchase (no count popup)
onCopyCountChosen({"status":true,"quantity":1});
}
private function onCopyCountChosen(result:Object) : void
{
var asked:int = int(result.quantity);
_copyPopup = null;
if(!result.status)
{
if(_masterpiecePreviewPopup)
{
_masterpiecePreviewPopup.closeCallback = onPreviewClose;
}
return;
}
_copiesWanted = Math.max(1,Math.min(asked,_copyFreeSlots));
_copiesNote = asked > _copiesWanted ? " (only " + _copiesWanted + " den slots were free)" : "";
_copiesDone = 0;
_isMasterpieceSubmit = true;
encodeImage();
}
private function capCopiesToFunds() : void
{
var price:int = int(DiamondXtCommManager.getDiamondDef(221).value);
var afford:int = _isUsingTokens ? _numMasterpieceTokens : (price > 0 ? int(UserCurrency.getCurrency(3) / price) : _copiesWanted);
if(_copiesWanted > 1 && afford < _copiesWanted)
{
_copiesWanted = Math.max(1,afford);
_copiesNote = " (you could afford " + _copiesWanted + ")";
}
}
private function buyCurrentCopy() : void
{
DarkenManager.showLoadingSpiral(true);
DenXtCommManager.requestBuy(true,0,221,onPreviewItemBuy,onPreviewBuyInventoryResponse,0,null,_currItemVersion,1,true,_isUsingTokens,_masterpieceUuid);
}
private function nextCopy() : void
{
if(_guiLayer == null)
{
return;
}
if(_copiesDone >= _copiesWanted || _jpgEncoder == null)
{
stopCopies();
DarkenManager.showLoadingSpiral(false);
return;
}
_isMasterpieceSubmit = true;
_URLStatus = 0;
startSubmitWatchdog(TOKEN_TIMEOUT_MS);
MinigameManager.msg(["gmtkn","0","1"]);
}
private function finishCopies() : void
{
if(_copiesWanted > 1)
{
showCopyBanner("Bought " + _copiesDone + " copies" + _copiesNote);
}
_copiesWanted = 1;
_copiesDone = 0;
_copiesNote = "";
}
private function stopCopies() : void
{
if(_copiesWanted > 1 && _copiesDone > 0)
{
showCopyBanner("Stopped: bought " + _copiesDone + " of " + _copiesWanted + " copies");
}
else
{
hideCopyBanner();
}
_copiesWanted = 1;
_copiesDone = 0;
_copiesNote = "";
}
private function showCopyBanner(msg:String) : void
{
var tf:TextField = ArtStudioKit.text(msg,15,ArtStudioKit.TEXT_LIGHT,520,"center");
var w:int = 0;
hideCopyBanner();
if(_guiLayer == null)
{
return;
}
tf.autoSize = "center";
w = int(tf.width) + 28;
_copyBanner = new Sprite();
_copyBanner.mouseEnabled = false;
_copyBanner.mouseChildren = false;
ArtStudioKit.panel(_copyBanner,0,0,w,32);
tf.x = int((w - tf.width) / 2);
tf.y = 5;
_copyBanner.addChild(tf);
_copyBanner.x = int(494 - w / 2);
_copyBanner.y = 60;
_guiLayer.addChild(_copyBanner);
_copyBannerStamp = getTimer();
setTimeout(autoHideCopyBanner,6000);
}
private function autoHideCopyBanner() : void
{
if(getTimer() - _copyBannerStamp >= 5900 && _copiesWanted <= 1)
{
hideCopyBanner();
}
}
private function hideCopyBanner() : void
{
if(_copyBanner != null && _copyBanner.parent != null)
{
_copyBanner.parent.removeChild(_copyBanner);
}
_copyBanner = null;
}
}
}