Skip to content

Instantly share code, notes, and snippets.

@drdim

drdim/gist:4536133

Created January 15, 2013 04:41
Show Gist options
  • Save drdim/4536133 to your computer and use it in GitHub Desktop.
Save drdim/4536133 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
gistfile1.as
This file has been truncated, but you can view the full file.
//ActionScript 3.0
// package dm
// package songsterr
// package guitartuner
// class ClosestNoteFinder
package dm.songsterr.guitartuner
{
import __AS3__.vec.*;
public class ClosestNoteFinder extends Object
{
public function ClosestNoteFinder()
{
super();
return;
}
public function findClosestMidiNote(arg1:Number):dm.songsterr.guitartuner.NoteInfo
{
var loc3:*=0;
var loc4:*=null;
var loc5:*=null;
var loc6:*=null;
var loc7:*=NaN;
var loc8:*=NaN;
var loc9:*=NaN;
var loc1:*=0;
var loc2:*=127;
for (;;)
{
loc3 = (loc1 + loc2) / 2;
if (NOTES_FREQUENCIES[loc3].frequency >= arg1)
{
if ((loc3 - 1) > loc1)
{
loc2 = loc3;
}
else
{
break;
}
continue;
}
if (loc3 + 1 < loc2)
{
loc1 = loc3;
continue;
}
break;
}
loc4 = NOTES_FREQUENCIES[loc1];
loc5 = NOTES_FREQUENCIES[loc3];
loc6 = NOTES_FREQUENCIES[loc2];
loc7 = loc4.frequency - arg1;
loc8 = loc5.frequency - arg1;
loc9 = loc6.frequency - arg1;
loc7 = loc7 < 0 ? -loc7 : loc7;
loc8 = loc8 < 0 ? -loc8 : loc8;
loc9 = loc9 < 0 ? -loc9 : loc9;
if (loc7 < loc8)
{
return loc7 < loc9 ? loc4 : loc6;
}
return loc8 < loc9 ? loc5 : loc6;
}
internal static const NOTES_FREQUENCIES:__AS3__.vec.Vector.<dm.songsterr.guitartuner.NoteInfo>=Vector.<dm.songsterr.guitartuner.NoteInfo>([new dm.songsterr.guitartuner.NoteInfo(0, 8.1757989156), new dm.songsterr.guitartuner.NoteInfo(1, 8.661957218), new dm.songsterr.guitartuner.NoteInfo(2, 9.1770239974), new dm.songsterr.guitartuner.NoteInfo(3, 9.7227182413), new dm.songsterr.guitartuner.NoteInfo(4, 10.3008611535), new dm.songsterr.guitartuner.NoteInfo(5, 10.9133822323), new dm.songsterr.guitartuner.NoteInfo(6, 11.5623257097), new dm.songsterr.guitartuner.NoteInfo(7, 12.2498573744), new dm.songsterr.guitartuner.NoteInfo(8, 12.9782717994), new dm.songsterr.guitartuner.NoteInfo(9, 13.75), new dm.songsterr.guitartuner.NoteInfo(10, 14.5676175474), new dm.songsterr.guitartuner.NoteInfo(11, 15.4338531643), new dm.songsterr.guitartuner.NoteInfo(12, 16.3515978313), new dm.songsterr.guitartuner.NoteInfo(13, 17.3239144361), new dm.songsterr.guitartuner.NoteInfo(14, 18.3540479948), new dm.songsterr.guitartuner.NoteInfo(15, 19.4454364826), new dm.songsterr.guitartuner.NoteInfo(16, 20.6017223071), new dm.songsterr.guitartuner.NoteInfo(17, 21.8267644646), new dm.songsterr.guitartuner.NoteInfo(18, 23.1246514195), new dm.songsterr.guitartuner.NoteInfo(19, 24.4997147489), new dm.songsterr.guitartuner.NoteInfo(20, 25.9565435987), new dm.songsterr.guitartuner.NoteInfo(21, 27.5), new dm.songsterr.guitartuner.NoteInfo(22, 29.1352350949), new dm.songsterr.guitartuner.NoteInfo(23, 30.8677063285), new dm.songsterr.guitartuner.NoteInfo(24, 32.7031956626), new dm.songsterr.guitartuner.NoteInfo(25, 34.6478288721), new dm.songsterr.guitartuner.NoteInfo(26, 36.7080959897), new dm.songsterr.guitartuner.NoteInfo(27, 38.8908729653), new dm.songsterr.guitartuner.NoteInfo(28, 41.2034446141), new dm.songsterr.guitartuner.NoteInfo(29, 43.6535289291), new dm.songsterr.guitartuner.NoteInfo(30, 46.249302839), new dm.songsterr.guitartuner.NoteInfo(31, 48.9994294977), new dm.songsterr.guitartuner.NoteInfo(32, 51.9130871975), new dm.songsterr.guitartuner.NoteInfo(33, 55), new dm.songsterr.guitartuner.NoteInfo(34, 58.2704701898), new dm.songsterr.guitartuner.NoteInfo(35, 61.735412657), new dm.songsterr.guitartuner.NoteInfo(36, 65.4063913251), new dm.songsterr.guitartuner.NoteInfo(37, 69.2956577442), new dm.songsterr.guitartuner.NoteInfo(38, 73.4161919794), new dm.songsterr.guitartuner.NoteInfo(39, 77.7817459305), new dm.songsterr.guitartuner.NoteInfo(40, 82.4068892282), new dm.songsterr.guitartuner.NoteInfo(41, 87.3070578583), new dm.songsterr.guitartuner.NoteInfo(42, 92.4986056779), new dm.songsterr.guitartuner.NoteInfo(43, 97.9988589954), new dm.songsterr.guitartuner.NoteInfo(44, 103.826174395), new dm.songsterr.guitartuner.NoteInfo(45, 110), new dm.songsterr.guitartuner.NoteInfo(46, 116.54094038), new dm.songsterr.guitartuner.NoteInfo(47, 123.470825314), new dm.songsterr.guitartuner.NoteInfo(48, 130.81278265), new dm.songsterr.guitartuner.NoteInfo(49, 138.591315488), new dm.songsterr.guitartuner.NoteInfo(50, 146.832383959), new dm.songsterr.guitartuner.NoteInfo(51, 155.563491861), new dm.songsterr.guitartuner.NoteInfo(52, 164.813778456), new dm.songsterr.guitartuner.NoteInfo(53, 174.614115717), new dm.songsterr.guitartuner.NoteInfo(54, 184.997211356), new dm.songsterr.guitartuner.NoteInfo(55, 195.997717991), new dm.songsterr.guitartuner.NoteInfo(56, 207.65234879), new dm.songsterr.guitartuner.NoteInfo(57, 220), new dm.songsterr.guitartuner.NoteInfo(58, 233.081880759), new dm.songsterr.guitartuner.NoteInfo(59, 246.941650628), new dm.songsterr.guitartuner.NoteInfo(60, 261.625565301), new dm.songsterr.guitartuner.NoteInfo(61, 277.182630977), new dm.songsterr.guitartuner.NoteInfo(62, 293.664767917), new dm.songsterr.guitartuner.NoteInfo(63, 311.126983722), new dm.songsterr.guitartuner.NoteInfo(64, 329.627556913), new dm.songsterr.guitartuner.NoteInfo(65, 349.228231433), new dm.songsterr.guitartuner.NoteInfo(66, 369.994422712), new dm.songsterr.guitartuner.NoteInfo(67, 391.995435982), new dm.songsterr.guitartuner.NoteInfo(68, 415.30469758), new dm.songsterr.guitartuner.NoteInfo(69, 440), new dm.songsterr.guitartuner.NoteInfo(70, 466.163761518), new dm.songsterr.guitartuner.NoteInfo(71, 493.883301256), new dm.songsterr.guitartuner.NoteInfo(72, 523.251130601), new dm.songsterr.guitartuner.NoteInfo(73, 554.365261954), new dm.songsterr.guitartuner.NoteInfo(74, 587.329535835), new dm.songsterr.guitartuner.NoteInfo(75, 622.253967444), new dm.songsterr.guitartuner.NoteInfo(76, 659.255113826), new dm.songsterr.guitartuner.NoteInfo(77, 698.456462866), new dm.songsterr.guitartuner.NoteInfo(78, 739.988845423), new dm.songsterr.guitartuner.NoteInfo(79, 783.990871964), new dm.songsterr.guitartuner.NoteInfo(80, 830.60939516), new dm.songsterr.guitartuner.NoteInfo(81, 880), new dm.songsterr.guitartuner.NoteInfo(82, 932.327523036), new dm.songsterr.guitartuner.NoteInfo(83, 987.766602512), new dm.songsterr.guitartuner.NoteInfo(84, 1046.5022612), new dm.songsterr.guitartuner.NoteInfo(85, 1108.73052391), new dm.songsterr.guitartuner.NoteInfo(86, 1174.65907167), new dm.songsterr.guitartuner.NoteInfo(87, 1244.50793489), new dm.songsterr.guitartuner.NoteInfo(88, 1318.51022765), new dm.songsterr.guitartuner.NoteInfo(89, 1396.91292573), new dm.songsterr.guitartuner.NoteInfo(90, 1479.97769085), new dm.songsterr.guitartuner.NoteInfo(91, 1567.98174393), new dm.songsterr.guitartuner.NoteInfo(92, 1661.21879032), new dm.songsterr.guitartuner.NoteInfo(93, 1760), new dm.songsterr.guitartuner.NoteInfo(94, 1864.65504607), new dm.songsterr.guitartuner.NoteInfo(95, 1975.53320502), new dm.songsterr.guitartuner.NoteInfo(96, 2093.0045224), new dm.songsterr.guitartuner.NoteInfo(97, 2217.46104781), new dm.songsterr.guitartuner.NoteInfo(98, 2349.31814334), new dm.songsterr.guitartuner.NoteInfo(99, 2489.01586978), new dm.songsterr.guitartuner.NoteInfo(100, 2637.0204553), new dm.songsterr.guitartuner.NoteInfo(101, 2793.82585146), new dm.songsterr.guitartuner.NoteInfo(102, 2959.95538169), new dm.songsterr.guitartuner.NoteInfo(103, 3135.96348785), new dm.songsterr.guitartuner.NoteInfo(104, 3322.43758064), new dm.songsterr.guitartuner.NoteInfo(105, 3520), new dm.songsterr.guitartuner.NoteInfo(106, 3729.31009214), new dm.songsterr.guitartuner.NoteInfo(107, 3951.06641005), new dm.songsterr.guitartuner.NoteInfo(108, 4186.00904481), new dm.songsterr.guitartuner.NoteInfo(109, 4434.92209563), new dm.songsterr.guitartuner.NoteInfo(110, 4698.63628668), new dm.songsterr.guitartuner.NoteInfo(111, 4978.03173955), new dm.songsterr.guitartuner.NoteInfo(112, 5274.04091061), new dm.songsterr.guitartuner.NoteInfo(113, 5587.65170293), new dm.songsterr.guitartuner.NoteInfo(114, 5919.91076339), new dm.songsterr.guitartuner.NoteInfo(115, 6271.92697571), new dm.songsterr.guitartuner.NoteInfo(116, 6644.87516128), new dm.songsterr.guitartuner.NoteInfo(117, 7040), new dm.songsterr.guitartuner.NoteInfo(118, 7458.62018429), new dm.songsterr.guitartuner.NoteInfo(119, 7902.1328201), new dm.songsterr.guitartuner.NoteInfo(120, 8372.01808962), new dm.songsterr.guitartuner.NoteInfo(121, 8869.84419126), new dm.songsterr.guitartuner.NoteInfo(122, 9397.27257336), new dm.songsterr.guitartuner.NoteInfo(123, 9956.06347911), new dm.songsterr.guitartuner.NoteInfo(124, 10548.0818212), new dm.songsterr.guitartuner.NoteInfo(125, 11175.3034059), new dm.songsterr.guitartuner.NoteInfo(126, 11839.8215268), new dm.songsterr.guitartuner.NoteInfo(127, 12543.8539514)]);
}
}
// class CyclicMonoSamplesBufferHandler
package dm.songsterr.guitartuner
{
import __AS3__.vec.*;
import flash.utils.*;
public class CyclicMonoSamplesBufferHandler extends Object
{
public function CyclicMonoSamplesBufferHandler(arg1:__AS3__.vec.Vector.<Number>)
{
super();
this._vector = arg1;
this._vectorLength = arg1.length;
return;
}
public function writeMixedDownSampleDataAsComplexNumbers(arg1:flash.utils.ByteArray):void
{
this.writePointerWrapped = false;
while (arg1.bytesAvailable > 0)
{
this._vector[this._writePointer] = (arg1.readFloat() + arg1.readFloat()) / 2;
var loc1:*;
var loc2:*=((loc1 = this)._writePointer + 1);
loc1._writePointer = loc2;
this._vector[this._writePointer] = 0;
loc2 = ((loc1 = this)._writePointer + 1);
loc1._writePointer = loc2;
if (!(this._writePointer >= this._vectorLength / 2))
{
continue;
}
this._writePointer = 0;
this.writePointerWrapped = true;
}
return;
}
public function writeMonoSampleDataAsComplexNumbers(arg1:flash.utils.ByteArray):void
{
this.writePointerWrapped = false;
while (arg1.bytesAvailable > 0)
{
this._vector[this._writePointer] = arg1.readFloat();
var loc1:*;
var loc2:*=((loc1 = this)._writePointer + 1);
loc1._writePointer = loc2;
if (!(this._writePointer >= this._vectorLength))
{
continue;
}
this._writePointer = 0;
this.writePointerWrapped = true;
}
return;
}
internal var _vector:__AS3__.vec.Vector.<Number>;
internal var _vectorLength:int;
internal var _writePointer:int=0;
public var writePointerWrapped:Boolean=false;
}
}
// class FundamentalFrequencyFinder
package dm.songsterr.guitartuner
{
import __AS3__.vec.*;
public class FundamentalFrequencyFinder extends Object
{
public function FundamentalFrequencyFinder(arg1:int, arg2:int)
{
super();
this._sampleRate = arg2;
this._freqStep = this._sampleRate / Number(arg1);
this._spectrumGenerator = new dm.songsterr.guitartuner.SpectrumGenerator(arg1);
this._resampler2 = new dm.songsterr.guitartuner.Resampler(arg1);
this._resampler3 = new dm.songsterr.guitartuner.Resampler(arg1);
this._vectorMultiplier = new dm.songsterr.guitartuner.VectorsMultiplier(this._spectrumGenerator.spectrum.length);
return;
}
internal function tau(arg1:Number):Number
{
return 0.25 * Math.log(3 * arg1 * arg1 + 6 * arg1 + 1) - Math.sqrt(6) / 24 * Math.log((arg1 + 1 - Math.sqrt(2 / 3)) / (arg1 + 1 + Math.sqrt(2 / 3)));
}
public function findFundamentalFrequency(arg1:__AS3__.vec.Vector.<Number>):Number
{
var loc7:*=NaN;
this._spectrumGenerator.generate(arg1);
var loc1:*=this._spectrumGenerator.spectrum;
this._resampler2.resample(loc1, 2);
this._resampler3.resample(loc1, 3);
this._vectorMultiplier.multiply3(loc1, this._resampler2.samples, this._resampler3.samples);
var loc2:*=this._vectorMultiplier.data;
var loc3:*=(loc2.length - 1);
var loc4:*=0;
var loc5:*=0;
var loc6:*=3;
while (loc6 < loc3)
{
if ((loc7 = loc2[loc6]) > loc4)
{
loc4 = loc7;
loc5 = loc6;
}
++loc6;
}
return loc5 * this._freqStep;
}
internal var _sampleRate:Number;
internal var _freqStep:Number;
internal var _spectrumGenerator:dm.songsterr.guitartuner.SpectrumGenerator;
internal var _resampler2:dm.songsterr.guitartuner.Resampler;
internal var _resampler3:dm.songsterr.guitartuner.Resampler;
internal var _vectorMultiplier:dm.songsterr.guitartuner.VectorsMultiplier;
}
}
// class GuitarTuner
package dm.songsterr.guitartuner
{
import __AS3__.vec.*;
import dm.songsterr.math.*;
import flash.events.*;
import flash.utils.*;
public class GuitarTuner extends flash.events.EventDispatcher
{
public function GuitarTuner(arg1:Boolean=true, arg2:int=16384, arg3:int=22050)
{
super();
this._outplaceFft = new dm.songsterr.math.AsyncSorensenSplitRadixRealDitFft();
this._outplaceFft.prepare(arg2);
this._outplaceFft.addEventListener(flash.events.Event.COMPLETE, this.onFftComplete);
this._fundamentalFrequencyFinder = new dm.songsterr.guitartuner.FundamentalFrequencyFinder(arg2, arg3);
this._closestNoteFinder = new dm.songsterr.guitartuner.ClosestNoteFinder();
this._fftSource = new Vector.<Number>(arg2, true);
this._fftResult = new Vector.<Number>(arg2, true);
this._bufferHandler = new dm.songsterr.guitartuner.CyclicMonoSamplesBufferHandler(this._fftSource);
var loc1:*=arg3 / Number(arg2);
return;
}
internal function onFftComplete(arg1:flash.events.Event):void
{
this.fundamentalFrequency = this._fundamentalFrequencyFinder.findFundamentalFrequency(this._fftResult);
this.fundamentalFrequency = this.fundamentalFrequency * Math.pow(2, -1.7 / 1200);
this.closestNote = this._closestNoteFinder.findClosestMidiNote(this.fundamentalFrequency);
dispatchEvent(new flash.events.Event("update"));
return;
}
public function processSampleData(arg1:flash.utils.ByteArray):void
{
this._bufferHandler.writeMonoSampleDataAsComplexNumbers(arg1);
if (this._outplaceFft.inProgress)
{
return;
}
this._outplaceFft.fftRealToComplexOutplace(this._fftSource, this._fftResult);
return;
}
public function get lastFftSource():__AS3__.vec.Vector.<Number>
{
return this._fftSource;
}
public function get lastFftResult():__AS3__.vec.Vector.<Number>
{
return this._fftResult;
}
public var fundamentalFrequency:Number;
public var closestNote:dm.songsterr.guitartuner.NoteInfo;
internal var _outplaceFft:dm.songsterr.math.AsyncSorensenSplitRadixRealDitFft;
internal var _fundamentalFrequencyFinder:dm.songsterr.guitartuner.FundamentalFrequencyFinder;
internal var _closestNoteFinder:dm.songsterr.guitartuner.ClosestNoteFinder;
internal var _bufferHandler:dm.songsterr.guitartuner.CyclicMonoSamplesBufferHandler;
internal var _fftSource:__AS3__.vec.Vector.<Number>;
internal var _fftResult:__AS3__.vec.Vector.<Number>;
}
}
// class NoteInfo
package dm.songsterr.guitartuner
{
public class NoteInfo extends Object
{
public function NoteInfo(arg1:int, arg2:Number)
{
super();
this.midiCode = arg1;
this.frequency = arg2;
return;
}
public var midiCode:int;
public var frequency:Number;
}
}
// class Resampler
package dm.songsterr.guitartuner
{
import __AS3__.vec.*;
public class Resampler extends Object
{
public function Resampler(arg1:int)
{
super();
this.samples = new Vector.<Number>(arg1, true);
return;
}
public function resample(arg1:__AS3__.vec.Vector.<Number>, arg2:int):void
{
var loc4:*=NaN;
var loc5:*=0;
var loc6:*=0;
var loc7:*=0;
var loc1:*=arg1.length;
var loc2:*=(loc1 / arg2 - 1);
var loc3:*=0;
while (loc3 < loc1)
{
if (loc3 < loc2)
{
loc4 = 0;
loc5 = loc3 * arg2;
loc6 = (loc3 + 1) * arg2;
loc7 = loc5;
while (loc7 < loc6)
{
loc4 = loc4 + arg1[loc7];
++loc7;
}
this.samples[loc3] = loc4 / arg2;
}
else
{
this.samples[loc3] = 0;
}
++loc3;
}
return;
}
public var samples:__AS3__.vec.Vector.<Number>;
}
}
// class SpectrumGenerator
package dm.songsterr.guitartuner
{
import __AS3__.vec.*;
public class SpectrumGenerator extends Object
{
public function SpectrumGenerator(arg1:int)
{
super();
this.spectrum = new Vector.<Number>(arg1, true);
return;
}
public function generate(arg1:__AS3__.vec.Vector.<Number>):void
{
var loc4:*=0;
var loc1:*=this.spectrum.length;
if (loc1 != arg1.length)
{
throw new Error("invalid fftResults length");
}
this.spectrum[0] = arg1[0] * arg1[0];
var loc2:*;
--loc2;
var loc3:*=1;
while (loc3 < loc2)
{
loc4 = loc1 - loc3;
this.spectrum[loc3] = arg1[loc3] * arg1[loc3] + arg1[loc4] * arg1[loc4];
++loc3;
}
this.spectrum[loc2] = arg1[loc2] * arg1[loc2];
return;
}
public var spectrum:__AS3__.vec.Vector.<Number>;
}
}
// class VectorsMultiplier
package dm.songsterr.guitartuner
{
import __AS3__.vec.*;
public class VectorsMultiplier extends Object
{
public function VectorsMultiplier(arg1:int)
{
super();
this.data = new Vector.<Number>(arg1, true);
return;
}
public function multiply2(arg1:__AS3__.vec.Vector.<Number>, arg2:__AS3__.vec.Vector.<Number>):void
{
var loc1:*=arg1.length;
var loc2:*=0;
while (loc2 < loc1)
{
this.data[loc2] = arg1[loc2] * arg2[loc2];
++loc2;
}
return;
}
public function multiply3(arg1:__AS3__.vec.Vector.<Number>, arg2:__AS3__.vec.Vector.<Number>, arg3:__AS3__.vec.Vector.<Number>):void
{
var loc1:*=arg1.length;
var loc2:*=0;
while (loc2 < loc1)
{
this.data[loc2] = arg1[loc2] * arg2[loc2] * arg3[loc2];
++loc2;
}
return;
}
public function multiply4(arg1:__AS3__.vec.Vector.<Number>, arg2:__AS3__.vec.Vector.<Number>, arg3:__AS3__.vec.Vector.<Number>, arg4:__AS3__.vec.Vector.<Number>):void
{
var loc1:*=arg1.length;
var loc2:*=0;
while (loc2 < loc1)
{
this.data[loc2] = arg1[loc2] * arg2[loc2] * arg3[loc2] * arg4[loc2];
++loc2;
}
return;
}
public function multiply5(arg1:__AS3__.vec.Vector.<Number>, arg2:__AS3__.vec.Vector.<Number>, arg3:__AS3__.vec.Vector.<Number>, arg4:__AS3__.vec.Vector.<Number>, arg5:__AS3__.vec.Vector.<Number>):void
{
var loc1:*=arg1.length;
var loc2:*=0;
while (loc2 < loc1)
{
this.data[loc2] = arg1[loc2] * arg2[loc2] * arg3[loc2] * arg4[loc2] * arg5[loc2];
++loc2;
}
return;
}
public var data:__AS3__.vec.Vector.<Number>;
}
}
// package math
// class AsyncSorensenSplitRadixRealDitFft
package dm.songsterr.math
{
import __AS3__.vec.*;
import flash.events.*;
import flash.utils.*;
public class AsyncSorensenSplitRadixRealDitFft extends flash.events.EventDispatcher
{
public function AsyncSorensenSplitRadixRealDitFft()
{
this._timer = new flash.utils.Timer(1, 1);
super();
this._timer.addEventListener(flash.events.TimerEvent.TIMER_COMPLETE, this.onTimer);
return;
}
internal function fftInplaceCoreStart(arg1:__AS3__.vec.Vector.<Number>):void
{
var loc7:*=0;
var loc8:*=NaN;
var loc9:*=0;
var loc10:*=0;
var loc11:*=NaN;
var loc1:*=this._samplesNum;
var loc2:*=0;
var loc3:*=loc1 - 2;
var loc4:*=0;
while (loc4 <= loc3)
{
if (loc4 < loc2)
{
loc8 = arg1[loc2];
arg1[loc2] = arg1[loc4];
arg1[loc4] = loc8;
}
loc7 = loc1 >> 1;
while (loc7 <= loc2)
{
loc2 = loc2 - loc7;
loc7 = loc7 >> 1;
}
loc2 = loc2 + loc7;
++loc4;
}
var loc5:*=0;
var loc6:*=4;
do
{
loc9 = loc5;
while (loc9 <= (loc1 - 1))
{
loc10 = loc9 + 1;
loc11 = arg1[loc9];
arg1[loc9] = loc11 + arg1[loc10];
arg1[loc10] = loc11 - arg1[loc10];
loc9 = loc9 + loc6;
}
loc5 = (loc6 << 1) - 2;
loc6 = loc6 << 2;
}
while (loc5 < loc1);
this._step = 1;
this._k = 2;
this._loff = 0;
this._n2 = 2;
this._timer.start();
return;
}
internal function fftInplaceCoreLShaped(arg1:__AS3__.vec.Vector.<Number>):void
{
var loc4:*=0;
var loc5:*=0;
var loc6:*=0;
var loc7:*=0;
var loc8:*=0;
var loc9:*=0;
var loc10:*=0;
var loc11:*=0;
var loc12:*=0;
var loc13:*=0;
var loc14:*=NaN;
var loc15:*=NaN;
var loc16:*=NaN;
var loc17:*=NaN;
var loc18:*=NaN;
var loc19:*=NaN;
var loc20:*=0;
var loc21:*=0;
var loc22:*=0;
var loc23:*=0;
var loc24:*=NaN;
var loc25:*=NaN;
var loc26:*=NaN;
var loc27:*=NaN;
var loc1:*=flash.utils.getTimer();
var loc2:*=this._samplesNum;
var loc3:*=1 / 1.41421356237;
while (this._k <= this._m)
{
if (flash.utils.getTimer() - loc1 > 50)
{
this._timer.start();
return;
}
this._n2 = this._n2 * 2;
loc4 = this._n2 >> 2;
loc5 = this._n2 >> 3;
loc6 = 0;
loc7 = this._n2 * 2;
do
{
loc9 = loc6;
while (loc9 <= loc2 - 2)
{
loc13 = (loc12 = (loc11 = (loc10 = loc9) + loc4) + loc4) + loc4;
loc14 = arg1[loc13] + arg1[loc12];
arg1[loc13] = arg1[loc13] - arg1[loc12];
arg1[loc12] = arg1[loc10] - loc14;
arg1[loc10] = arg1[loc10] + loc14;
if (loc4 != 1)
{
loc10 = loc10 + loc5;
loc11 = loc11 + loc5;
loc12 = loc12 + loc5;
loc13 = loc13 + loc5;
loc14 = (arg1[loc12] + arg1[loc13]) * loc3;
loc15 = (arg1[loc12] - arg1[loc13]) * loc3;
arg1[loc13] = arg1[loc11] - loc14;
arg1[loc12] = -arg1[loc11] - loc14;
arg1[loc11] = arg1[loc10] - loc15;
arg1[loc10] = arg1[loc10] + loc15;
}
loc9 = loc9 + loc7;
}
loc6 = (loc7 << 1) - this._n2;
loc7 = loc7 << 2;
}
while (loc6 < loc2);
loc8 = 2;
while (loc8 <= loc5)
{
loc16 = this._cosLookupTable[this._loff];
loc17 = this._sinLookupTable[this._loff];
loc18 = this._cos3LookupTable[this._loff];
loc19 = this._sin3LookupTable[this._loff];
var loc28:*;
var loc29:*=((loc28 = this)._loff + 1);
loc28._loff = loc29;
loc6 = 0;
loc7 = this._n2 << 1;
do
{
loc9 = loc6;
while (loc9 <= loc2 - 2)
{
loc13 = (loc12 = (loc11 = (loc10 = (loc9 + loc8 - 1)) + loc4) + loc4) + loc4;
loc23 = (loc22 = (loc21 = (loc20 = loc9 + loc4 - loc8 + 1) + loc4) + loc4) + loc4;
loc14 = arg1[loc12] * loc16 + arg1[loc22] * loc17;
loc15 = arg1[loc22] * loc16 - arg1[loc12] * loc17;
loc24 = arg1[loc13] * loc18 + arg1[loc23] * loc19;
loc25 = arg1[loc23] * loc18 - arg1[loc13] * loc19;
loc26 = loc14 + loc24;
loc27 = loc15 + loc25;
loc24 = loc14 - loc24;
loc25 = loc15 - loc25;
loc15 = arg1[loc21] + loc27;
arg1[loc12] = loc27 - arg1[loc21];
arg1[loc23] = loc15;
loc15 = arg1[loc11] - loc24;
arg1[loc22] = -arg1[loc11] - loc24;
arg1[loc13] = loc15;
loc14 = arg1[loc10] + loc26;
arg1[loc21] = arg1[loc10] - loc26;
arg1[loc10] = loc14;
loc14 = arg1[loc20] + loc25;
arg1[loc20] = arg1[loc20] - loc25;
arg1[loc11] = loc14;
loc9 = loc9 + loc7;
}
loc6 = (loc7 << 1) - this._n2;
loc7 = loc7 << 2;
}
while (loc6 < loc2);
++loc8;
}
loc29 = ((loc28 = this)._k + 1);
loc28._k = loc29;
}
this._data = null;
dispatchEvent(new flash.events.Event(flash.events.Event.COMPLETE));
return;
}
internal function onTimer(arg1:flash.events.TimerEvent):void
{
if (this._step != 0)
{
this.fftInplaceCoreLShaped(this._data);
}
else
{
this.fftInplaceCoreStart(this._data);
}
return;
}
public function prepare(arg1:int):void
{
var loc6:*=0;
var loc7:*=NaN;
var loc8:*=NaN;
var loc9:*=0;
var loc10:*=NaN;
this._samplesNum = arg1;
this._m = Math.round(Math.log(this._samplesNum) * Math.LOG2E);
var loc1:*=this._m - 3;
var loc2:*=2 * (Math.pow(2, loc1) - 1) - loc1;
this._sinLookupTable = new Vector.<Number>(loc2, true);
this._sin3LookupTable = new Vector.<Number>(loc2, true);
this._cosLookupTable = new Vector.<Number>(loc2, true);
this._cos3LookupTable = new Vector.<Number>(loc2, true);
var loc3:*=0;
var loc4:*=2;
var loc5:*=2;
while (loc5 <= this._m)
{
loc6 = (loc4 = loc4 * 2) / 8;
loc8 = loc7 = 6.28318530717 / loc4;
(loc6 - 1);
loc9 = 2;
while (loc9 <= loc6)
{
loc10 = loc8 * 3;
this._sinLookupTable[loc3] = Math.sin(loc8);
this._sin3LookupTable[loc3] = Math.sin(loc10);
this._cosLookupTable[loc3] = Math.cos(loc8);
this._cos3LookupTable[loc3] = Math.cos(loc10);
loc8 = loc9 * loc7;
++loc3;
++loc9;
}
++loc5;
}
return;
}
public function get inProgress():Boolean
{
return !(this._data == null);
}
public function fftRealToComplexOutplace(arg1:__AS3__.vec.Vector.<Number>, arg2:__AS3__.vec.Vector.<Number>):void
{
var loc1:*=0;
while (loc1 < arg2.length)
{
arg2[loc1] = arg1[loc1];
++loc1;
}
this._data = arg2;
this._step = 0;
this._timer.start();
return;
}
internal var _samplesNum:int;
internal var _m:Number;
internal var _sinLookupTable:__AS3__.vec.Vector.<Number>;
internal var _sin3LookupTable:__AS3__.vec.Vector.<Number>;
internal var _cosLookupTable:__AS3__.vec.Vector.<Number>;
internal var _cos3LookupTable:__AS3__.vec.Vector.<Number>;
internal var _step:int;
internal var _timer:flash.utils.Timer;
internal var _data:__AS3__.vec.Vector.<Number>;
internal var _k:int;
internal var _loff:int;
internal var _n2:int;
}
}
// package score
// package display
// package tablature
// package assets
// class Fonts
package dm.songsterr.score.display.tablature.assets
{
public final class Fonts extends Object
{
public function Fonts()
{
super();
return;
}
public static const lucidaGrande:Class=dm.songsterr.score.display.tablature.assets.Fonts_lucidaGrande;
public static const lucidaGrandeBold:Class=dm.songsterr.score.display.tablature.assets.Fonts_lucidaGrandeBold;
public static const musicalSymbols:Class=dm.songsterr.score.display.tablature.assets.Fonts_musicalSymbols;
public static const musicalSymbolsSpecial:Class=dm.songsterr.score.display.tablature.assets.Fonts_musicalSymbolsSpecial;
public static const stringSymbolFontClass:Class=lucidaGrande;
public static const chordLabelFontClass:Class=lucidaGrande;
public static const timeSignatureFontClass:Class=musicalSymbols;
public static const longTextMarkerFontClass:Class=lucidaGrande;
public static const musicalSymbolsFontClass:Class=musicalSymbols;
public static const musicalSymbolsSpecialFontClass:Class=musicalSymbolsSpecial;
public static const measureNumberFontClass:Class=lucidaGrandeBold;
public static const alternateEndingFontClass:Class=lucidaGrande;
public static const markerFontClass:Class=lucidaGrandeBold;
public static const repetitionsNumberFontClass:Class=lucidaGrande;
public static const tupletNumberFontClass:Class=lucidaGrande;
public static const beatTextFontClass:Class=lucidaGrande;
public static const lyricsChunkFontClass:Class=lucidaGrande;
}
}
// class Fonts_lucidaGrande
package dm.songsterr.score.display.tablature.assets
{
import mx.core.*;
public class Fonts_lucidaGrande extends mx.core.FontAsset
{
public function Fonts_lucidaGrande()
{
super();
return;
}
}
}
// class Fonts_lucidaGrandeBold
package dm.songsterr.score.display.tablature.assets
{
import mx.core.*;
public class Fonts_lucidaGrandeBold extends mx.core.FontAsset
{
public function Fonts_lucidaGrandeBold()
{
super();
return;
}
}
}
// class Fonts_musicalSymbols
package dm.songsterr.score.display.tablature.assets
{
import mx.core.*;
public class Fonts_musicalSymbols extends mx.core.FontAsset
{
public function Fonts_musicalSymbols()
{
super();
return;
}
}
}
// class Fonts_musicalSymbolsSpecial
package dm.songsterr.score.display.tablature.assets
{
import mx.core.*;
public class Fonts_musicalSymbolsSpecial extends mx.core.FontAsset
{
public function Fonts_musicalSymbolsSpecial()
{
super();
return;
}
}
}
// package generators
// package display
// package layout
// class MidiNoteToStringMapper
package dm.songsterr.score.generators.display.layout
{
public class MidiNoteToStringMapper extends Object
{
public function MidiNoteToStringMapper()
{
super();
return;
}
public function map(arg1:int, arg2:Boolean=false):String
{
var loc1:*=(Math.floor(arg1 / 12) - 1);
return NAMES[arg1 % 12] + (arg2 ? "" : loc1);
}
public function mapStringToNote(arg1:String):int
{
var loc1:*=arg1.match(new RegExp("(.*)(\\d)"));
if (loc1.length != 3)
{
throw new Error("invalid note representation");
}
var loc2:*=NAMES.indexOf(loc1[1]);
if (loc2 == -1)
{
throw new Error("invalid note representation");
}
return (parseInt(loc1[2]) + 1) * 12 + loc2;
}
internal static const NAMES:Array=["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
}
}
// package flashx
// package textLayout
// package compose
// class ISWFContext
package flashx.textLayout.compose
{
public interface ISWFContext
{
function callInContext(arg1:Function, arg2:Object, arg3:Array, arg4:Boolean=true):*;
}
}
// package mx
// package accessibility
// class AccConst
package mx.accessibility
{
import mx.core.*;
use namespace mx_internal;
public final class AccConst extends Object
{
public function AccConst()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
public static const ROLE_SYSTEM_TITLEBAR:uint=1;
public static const ROLE_SYSTEM_MENUBAR:uint=2;
public static const ROLE_SYSTEM_SCROLLBAR:uint=3;
public static const ROLE_SYSTEM_GRIP:uint=4;
public static const ROLE_SYSTEM_SOUND:uint=5;
public static const ROLE_SYSTEM_CURSOR:uint=6;
public static const ROLE_SYSTEM_CARET:uint=7;
public static const ROLE_SYSTEM_ALERT:uint=8;
public static const ROLE_SYSTEM_WINDOW:uint=9;
public static const ROLE_SYSTEM_CLIENT:uint=10;
public static const ROLE_SYSTEM_MENUPOPUP:uint=11;
public static const ROLE_SYSTEM_MENUITEM:uint=12;
public static const ROLE_SYSTEM_TOOLTIP:uint=13;
public static const ROLE_SYSTEM_APPLICATION:uint=14;
public static const ROLE_SYSTEM_DOCUMENT:uint=15;
public static const ROLE_SYSTEM_PANE:uint=16;
public static const ROLE_SYSTEM_CHART:uint=17;
public static const ROLE_SYSTEM_DIALOG:uint=18;
public static const ROLE_SYSTEM_BORDER:uint=19;
public static const ROLE_SYSTEM_GROUPING:uint=20;
public static const ROLE_SYSTEM_SEPARATOR:uint=21;
public static const ROLE_SYSTEM_TOOLBAR:uint=22;
public static const ROLE_SYSTEM_STATUSBAR:uint=23;
public static const ROLE_SYSTEM_TABLE:uint=24;
public static const ROLE_SYSTEM_COLUMNHEADER:uint=25;
public static const ROLE_SYSTEM_ROWHEADER:uint=26;
public static const ROLE_SYSTEM_COLUMN:uint=27;
public static const ROLE_SYSTEM_ROW:uint=28;
public static const ROLE_SYSTEM_CELL:uint=29;
public static const ROLE_SYSTEM_LINK:uint=30;
public static const ROLE_SYSTEM_HELPBALLOON:uint=31;
public static const ROLE_SYSTEM_CHARACTER:uint=32;
public static const ROLE_SYSTEM_LIST:uint=33;
public static const ROLE_SYSTEM_LISTITEM:uint=34;
public static const ROLE_SYSTEM_OUTLINE:uint=35;
public static const ROLE_SYSTEM_OUTLINEITEM:uint=36;
public static const ROLE_SYSTEM_PAGETAB:uint=37;
public static const ROLE_SYSTEM_PROPERTYPAGE:uint=38;
public static const ROLE_SYSTEM_INDICATOR:uint=39;
public static const ROLE_SYSTEM_GRAPHIC:uint=40;
public static const ROLE_SYSTEM_STATICTEXT:uint=41;
public static const ROLE_SYSTEM_TEXT:uint=42;
public static const ROLE_SYSTEM_PUSHBUTTON:uint=43;
public static const ROLE_SYSTEM_CHECKBUTTON:uint=44;
public static const ROLE_SYSTEM_RADIOBUTTON:uint=45;
public static const ROLE_SYSTEM_COMBOBOX:uint=46;
public static const ROLE_SYSTEM_DROPLIST:uint=47;
public static const ROLE_SYSTEM_PROGRESSBAR:uint=48;
public static const ROLE_SYSTEM_DIAL:uint=49;
public static const ROLE_SYSTEM_HOTKEYFIELD:uint=50;
public static const ROLE_SYSTEM_SLIDER:uint=51;
public static const ROLE_SYSTEM_SPINBUTTON:uint=52;
public static const ROLE_SYSTEM_DIAGRAM:uint=53;
public static const ROLE_SYSTEM_ANIMATION:uint=54;
public static const ROLE_SYSTEM_EQUATION:uint=55;
public static const ROLE_SYSTEM_BUTTONDROPDOWN:uint=56;
public static const ROLE_SYSTEM_BUTTONMENU:uint=57;
public static const ROLE_SYSTEM_BUTTONDROPDOWNGRID:uint=58;
public static const ROLE_SYSTEM_WHITESPACE:uint=59;
public static const ROLE_SYSTEM_PAGETABLIST:uint=60;
public static const ROLE_SYSTEM_CLOCK:uint=61;
public static const ROLE_SYSTEM_SPLITBUTTON:uint=62;
public static const ROLE_SYSTEM_IPADDRESS:uint=63;
public static const ROLE_SYSTEM_OUTLINEBUTTON:uint=64;
public static const STATE_SYSTEM_NORMAL:uint=0;
public static const STATE_SYSTEM_UNAVAILABLE:uint=1;
public static const STATE_SYSTEM_SELECTED:uint=2;
public static const STATE_SYSTEM_FOCUSED:uint=4;
public static const STATE_SYSTEM_PRESSED:uint=8;
public static const STATE_SYSTEM_CHECKED:uint=16;
public static const STATE_SYSTEM_MIXED:uint=32;
public static const STATE_SYSTEM_READONLY:uint=64;
public static const STATE_SYSTEM_HOTTRACKED:uint=128;
public static const STATE_SYSTEM_DEFAULT:uint=256;
public static const STATE_SYSTEM_EXPANDED:uint=512;
public static const STATE_SYSTEM_COLLAPSED:uint=1024;
public static const STATE_SYSTEM_BUSY:uint=2048;
public static const STATE_SYSTEM_FLOATING:uint=4096;
public static const STATE_SYSTEM_MARQUEED:uint=8192;
public static const STATE_SYSTEM_ANIMATED:uint=16384;
public static const STATE_SYSTEM_INVISIBLE:uint=32768;
public static const STATE_SYSTEM_OFFSCREEN:uint=65536;
public static const STATE_SYSTEM_SIZEABLE:uint=131072;
public static const STATE_SYSTEM_MOVEABLE:uint=262144;
public static const STATE_SYSTEM_SELFVOICING:uint=524288;
public static const STATE_SYSTEM_FOCUSABLE:uint=1048576;
public static const STATE_SYSTEM_SELECTABLE:uint=2097152;
public static const STATE_SYSTEM_LINKED:uint=4194304;
public static const STATE_SYSTEM_TRAVERSED:uint=8388608;
public static const STATE_SYSTEM_MULTISELECTABLE:uint=16777216;
public static const STATE_SYSTEM_EXTSELECTABLE:uint=33554432;
public static const STATE_SYSTEM_ALERT_LOW:uint=67108864;
public static const STATE_SYSTEM_ALERT_MEDIUM:uint=134217728;
public static const STATE_SYSTEM_ALERT_HIGH:uint=268435456;
public static const STATE_SYSTEM_PROTECTED:uint=536870912;
public static const STATE_SYSTEM_HASPOPUP:uint=1073741824;
public static const STATE_SYSTEM_VALID:uint=2147483647;
public static const SELFLAG_NONE:uint=0;
public static const SELFLAG_TAKEFOCUS:uint=1;
public static const SELFLAG_TAKESELECTION:uint=2;
public static const SELFLAG_EXTENDSELECTION:uint=4;
public static const SELFLAG_ADDSELECTION:uint=8;
public static const SELFLAG_REMOVESELECTION:uint=16;
public static const SELFLAG_VALID:uint=31;
public static const EVENT_SYSTEM_SOUND:uint=1;
public static const EVENT_SYSTEM_ALERT:uint=2;
public static const EVENT_SYSTEM_FOREGROUND:uint=3;
public static const EVENT_SYSTEM_MENUSTART:uint=4;
public static const EVENT_SYSTEM_MENUEND:uint=5;
public static const EVENT_SYSTEM_MENUPOPUPSTART:uint=6;
public static const EVENT_SYSTEM_MENUPOPUPEND:uint=7;
mx_internal static const VERSION:String="4.1.0.16076";
public static const EVENT_SYSTEM_CAPTUREEND:uint=9;
public static const EVENT_SYSTEM_MOVESIZESTART:uint=10;
public static const EVENT_SYSTEM_MOVESIZEEND:uint=11;
public static const EVENT_SYSTEM_CONTEXTHELPSTART:uint=12;
public static const EVENT_SYSTEM_CONTEXTHELPEND:uint=13;
public static const EVENT_SYSTEM_DRAGDROPSTART:uint=14;
public static const EVENT_SYSTEM_DRAGDROPEND:uint=15;
public static const EVENT_SYSTEM_DIALOGSTART:uint=16;
public static const EVENT_SYSTEM_DIALOGEND:uint=17;
public static const EVENT_SYSTEM_SCROLLINGSTART:uint=18;
public static const EVENT_SYSTEM_SCROLLINGEND:uint=19;
public static const EVENT_SYSTEM_SWITCHSTART:uint=20;
public static const EVENT_SYSTEM_SWITCHEND:uint=21;
public static const EVENT_SYSTEM_MINIMIZESTART:uint=22;
public static const EVENT_SYSTEM_MINIMIZEEND:uint=23;
public static const EVENT_OBJECT_CREATE:uint=32768;
public static const EVENT_OBJECT_DESTROY:uint=32769;
public static const EVENT_OBJECT_SHOW:uint=32770;
public static const EVENT_SYSTEM_CAPTURESTART:uint=8;
public static const EVENT_OBJECT_REORDER:uint=32772;
public static const EVENT_OBJECT_FOCUS:uint=32773;
public static const EVENT_OBJECT_SELECTION:uint=32774;
public static const EVENT_OBJECT_SELECTIONADD:uint=32775;
public static const EVENT_OBJECT_SELECTIONREMOVE:uint=32776;
public static const EVENT_OBJECT_SELECTIONWITHIN:uint=32777;
public static const EVENT_OBJECT_STATECHANGE:uint=32778;
public static const EVENT_OBJECT_LOCATIONCHANGE:uint=32779;
public static const EVENT_OBJECT_NAMECHANGE:uint=32780;
public static const EVENT_OBJECT_DESCRIPTIONCHANGE:uint=32781;
public static const EVENT_OBJECT_VALUECHANGE:uint=32782;
public static const EVENT_OBJECT_PARENTCHANGE:uint=32783;
public static const EVENT_OBJECT_HELPCHANGE:uint=32784;
public static const EVENT_OBJECT_DEFACTIONCHANGE:uint=32785;
public static const EVENT_OBJECT_ACCELERATORCHANGE:uint=32786;
public static const EVENT_OBJECT_INVOKED:uint=32787;
public static const EVENT_OBJECT_TEXTSELECTIONCHANGED:uint=32788;
public static const EVENT_OBJECT_CONTENTSCROLLED:uint=32789;
public static const EVENT_OBJECT_HIDE:uint=32771;
}
}
// class AccImpl
package mx.accessibility
{
import flash.accessibility.*;
import flash.display.*;
import flash.events.*;
import flash.system.*;
import mx.core.*;
import mx.managers.*;
import mx.resources.*;
use namespace mx_internal;
public class AccImpl extends flash.accessibility.AccessibilityImplementation
{
public function AccImpl(arg1:mx.core.UIComponent)
{
var loc2:*=0;
var loc3:*=0;
super();
this.master = arg1;
stub = false;
if (!arg1.accessibilityProperties)
{
arg1.accessibilityProperties = new flash.accessibility.AccessibilityProperties();
}
var loc1:*=this.eventsToHandle;
if (loc1)
{
loc2 = loc1.length;
loc3 = 0;
while (loc3 < loc2)
{
arg1.addEventListener(loc1[loc3], this.eventHandler);
++loc3;
}
}
return;
}
protected function get eventsToHandle():Array
{
return ["errorStringChanged", "toolTipChanged", "show", "hide"];
}
public override function get_accRole(arg1:uint):uint
{
return this.role;
}
public override function get_accName(arg1:uint):String
{
var loc1:*=null;
if (arg1)
{
loc1 = this.getName(arg1);
return !(loc1 == null) && !(loc1 == "") ? loc1 : null;
}
loc1 = getFormName(this.master);
if (this.master.accessibilityProperties && !(this.master.accessibilityProperties.name == null) && !(this.master.accessibilityProperties.name == ""))
{
loc1 = joinWithSpace(loc1, this.master.accessibilityProperties.name);
}
else
{
loc1 = joinWithSpace(loc1, this.getName(0) || this.master.toolTip);
}
loc1 = joinWithSpace(loc1, this.getStatusName());
return !(loc1 == null) && !(loc1 == "") ? loc1 : null;
}
public override function getChildIDArray():Array
{
return [];
}
public override function accSelect(arg1:uint, arg2:uint):void
{
return;
}
protected function getName(arg1:uint):String
{
return null;
}
protected function getState(arg1:uint):uint
{
var loc1:*=mx.accessibility.AccConst.STATE_SYSTEM_NORMAL;
if (!mx.core.UIComponent(this.master).enabled || isAncestorDisabled(this.master))
{
loc1 = loc1 & ~mx.accessibility.AccConst.STATE_SYSTEM_FOCUSABLE;
loc1 = loc1 | mx.accessibility.AccConst.STATE_SYSTEM_UNAVAILABLE;
}
else
{
loc1 = loc1 | mx.accessibility.AccConst.STATE_SYSTEM_FOCUSABLE;
if (mx.core.UIComponent(this.master) == mx.core.UIComponent(this.master).getFocus())
{
loc1 = loc1 | mx.accessibility.AccConst.STATE_SYSTEM_FOCUSED;
}
}
return loc1;
}
internal function getStatusName():String
{
var loc1:*="";
if (this.master is mx.core.UIComponent && mx.core.UIComponent(this.master).errorString)
{
loc1 = mx.core.UIComponent(this.master).errorString;
}
return loc1;
}
protected function createChildIDArray(arg1:int):Array
{
var loc1:*=new Array(arg1);
var loc2:*=0;
while (loc2 < arg1)
{
loc1[loc2] = loc2 + 1;
++loc2;
}
return loc1;
}
protected function eventHandler(arg1:flash.events.Event):void
{
this.$eventHandler(arg1);
return;
}
protected final function $eventHandler(arg1:flash.events.Event):void
{
var loc1:*=arg1.type;
switch (loc1)
{
case "errorStringChanged":
case "toolTipChanged":
{
flash.accessibility.Accessibility.sendEvent(this.master, 0, mx.accessibility.AccConst.EVENT_OBJECT_NAMECHANGE);
flash.accessibility.Accessibility.updateProperties();
break;
}
case "show":
{
flash.accessibility.Accessibility.sendEvent(this.master, 0, mx.accessibility.AccConst.EVENT_OBJECT_SHOW);
flash.accessibility.Accessibility.updateProperties();
break;
}
case "hide":
{
flash.accessibility.Accessibility.sendEvent(this.master, 0, mx.accessibility.AccConst.EVENT_OBJECT_HIDE);
flash.accessibility.Accessibility.updateProperties();
break;
}
}
return;
}
mx_internal static function getDefinition(arg1:String, arg2:mx.core.IFlexModuleFactory):Object
{
var loc1:*=null;
if (arg2)
{
loc1 = arg2.info()["currentDomain"];
}
else
{
loc1 = flash.system.ApplicationDomain.currentDomain;
}
if (loc1.hasDefinition(arg1))
{
return loc1.getDefinition(arg1);
}
return null;
}
public static function isAncestorDisabled(arg1:mx.core.UIComponent):Boolean
{
var loc1:*=arg1.parent;
while (loc1 && loc1 is mx.core.UIComponent && mx.core.UIComponent(loc1).enabled && !(loc1 is mx.managers.ISystemManager) && !(loc1 == arg1.root))
{
loc1 = loc1.parent;
}
if (!(loc1 is mx.core.UIComponent))
{
return false;
}
return !mx.core.UIComponent(loc1).enabled;
}
public static function getFormName(arg1:mx.core.UIComponent):String
{
var loc1:*="";
var loc2:*=Class(mx_internal::getDefinition("mx.core.Container", arg1.moduleFactory));
if (loc2 && arg1 is loc2)
{
return loc1;
}
var loc3:*=Class(mx_internal::getDefinition("mx.containers.FormItem", arg1.moduleFactory));
var loc4:*=arg1.parent;
while (loc4 && !(loc3 && loc4 is loc3) && !(loc4 is mx.managers.ISystemManager) && !(loc4 == arg1.root))
{
loc4 = loc4.parent;
}
if (loc4 && loc3 && loc4 is loc3)
{
loc1 = updateFormItemString(loc4);
}
return loc1;
}
internal static function joinWithSpace(arg1:String, arg2:String):String
{
if (arg1 == " ")
{
arg1 = "";
}
if (arg2 == " ")
{
arg2 = "";
}
if (arg1 && arg2)
{
arg1 = arg1 + (" " + arg2);
}
else if (arg2)
{
arg1 = arg2;
}
return arg1;
}
internal static function updateFormItemString(arg1:Object):String
{
var loc6:*=null;
var loc7:*=0;
var loc8:*=0;
var loc9:*=null;
var loc1:*="";
var loc2:*=mx.resources.ResourceManager.getInstance();
var loc3:*=Class(mx_internal::getDefinition("mx.containers.Form", arg1.moduleFactory));
var loc4:*=mx.core.UIComponent(arg1.parent);
if (loc3 && loc4 is loc3)
{
loc6 = Class(mx_internal::getDefinition("mx.containers.FormHeading", arg1.moduleFactory));
loc8 = loc7 = loc4.getChildIndex(flash.display.DisplayObject(arg1));
while (loc8 >= 0)
{
loc9 = mx.core.UIComponent(loc4.getChildAt(loc8));
if (loc6 && loc9 is loc6)
{
if (loc6(loc9).accessibilityProperties)
{
loc1 = loc6(loc9).accessibilityProperties.name;
}
if (loc1 == "")
{
loc1 = loc6(loc9).label;
}
}
--loc8;
}
}
if (arg1.required)
{
loc1 = joinWithSpace(loc1, loc2.getString("controls", "requiredField"));
}
var loc5:*="";
if (arg1.accessibilityProperties)
{
loc5 = arg1.accessibilityProperties.name;
}
if (loc5 == "")
{
loc5 = arg1.label;
}
loc1 = joinWithSpace(loc1, loc5);
return loc1;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
protected var master:mx.core.UIComponent;
protected var role:uint;
}
}
// class ButtonAccImpl
package mx.accessibility
{
import flash.accessibility.*;
import flash.events.*;
import flash.ui.*;
import mx.controls.*;
import mx.core.*;
use namespace mx_internal;
public class ButtonAccImpl extends mx.accessibility.AccImpl
{
public function ButtonAccImpl(arg1:mx.core.UIComponent)
{
super(arg1);
role = mx.accessibility.AccConst.ROLE_SYSTEM_PUSHBUTTON;
return;
}
protected override function get eventsToHandle():Array
{
return super.eventsToHandle.concat(["click", "labelChanged"]);
}
public override function get_accState(arg1:uint):uint
{
var loc1:*=getState(arg1);
if (mx.controls.Button(master).selected)
{
loc1 = loc1 | mx.accessibility.AccConst.STATE_SYSTEM_PRESSED;
}
return loc1;
}
public override function get_accDefaultAction(arg1:uint):String
{
return "Press";
}
public override function accDoDefaultAction(arg1:uint):void
{
var loc1:*=null;
if (master.enabled)
{
loc1 = new flash.events.KeyboardEvent(flash.events.KeyboardEvent.KEY_DOWN);
loc1.keyCode = flash.ui.Keyboard.SPACE;
master.dispatchEvent(loc1);
loc1 = new flash.events.KeyboardEvent(flash.events.KeyboardEvent.KEY_UP);
loc1.keyCode = flash.ui.Keyboard.SPACE;
master.dispatchEvent(loc1);
}
return;
}
protected override function getName(arg1:uint):String
{
var loc1:*=mx.controls.Button(master).label;
return !(loc1 == null) && !(loc1 == "") ? loc1 : "";
}
protected override function eventHandler(arg1:flash.events.Event):void
{
$eventHandler(arg1);
var loc1:*=arg1.type;
switch (loc1)
{
case "click":
{
flash.accessibility.Accessibility.sendEvent(master, 0, mx.accessibility.AccConst.EVENT_OBJECT_STATECHANGE);
flash.accessibility.Accessibility.updateProperties();
break;
}
case "labelChanged":
{
flash.accessibility.Accessibility.sendEvent(master, 0, mx.accessibility.AccConst.EVENT_OBJECT_NAMECHANGE);
flash.accessibility.Accessibility.updateProperties();
break;
}
}
return;
}
public static function enableAccessibility():void
{
mx.controls.Button.mx_internal::createAccessibilityImplementation = mx_internal::createAccessibilityImplementation;
return;
}
mx_internal static function createAccessibilityImplementation(arg1:mx.core.UIComponent):void
{
arg1.accessibilityImplementation = new ButtonAccImpl(arg1);
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class LabelAccImpl
package mx.accessibility
{
import flash.accessibility.*;
import flash.events.*;
import mx.controls.*;
import mx.core.*;
use namespace mx_internal;
public class LabelAccImpl extends mx.accessibility.AccImpl
{
public function LabelAccImpl(arg1:mx.core.UIComponent)
{
super(arg1);
role = mx.accessibility.AccConst.ROLE_SYSTEM_STATICTEXT;
return;
}
protected override function get eventsToHandle():Array
{
return super.eventsToHandle.concat(["updateComplete"]);
}
public override function get_accState(arg1:uint):uint
{
var loc1:*=getState(arg1);
loc1 = loc1 & ~mx.accessibility.AccConst.STATE_SYSTEM_FOCUSABLE;
loc1 = loc1 | mx.accessibility.AccConst.STATE_SYSTEM_READONLY;
return loc1;
}
protected override function getName(arg1:uint):String
{
var loc1:*=mx.controls.Label(master).text;
return !(loc1 == null) && !(loc1 == "") ? loc1 : "";
}
protected override function eventHandler(arg1:flash.events.Event):void
{
$eventHandler(arg1);
var loc1:*=arg1.type;
switch (loc1)
{
case "updateComplete":
{
flash.accessibility.Accessibility.sendEvent(master, 0, mx.accessibility.AccConst.EVENT_OBJECT_NAMECHANGE);
flash.accessibility.Accessibility.updateProperties();
break;
}
}
return;
}
public static function enableAccessibility():void
{
mx.controls.Label.mx_internal::createAccessibilityImplementation = mx_internal::createAccessibilityImplementation;
return;
}
mx_internal static function createAccessibilityImplementation(arg1:mx.core.UIComponent):void
{
arg1.accessibilityImplementation = new LabelAccImpl(arg1);
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class UIComponentAccProps
package mx.accessibility
{
import flash.accessibility.*;
import flash.events.*;
import mx.core.*;
use namespace mx_internal;
public class UIComponentAccProps extends flash.accessibility.AccessibilityProperties
{
public function UIComponentAccProps(arg1:mx.core.UIComponent)
{
var loc3:*=null;
super();
this.master = arg1;
if (arg1.accessibilityProperties)
{
silent = arg1.accessibilityProperties.silent;
forceSimple = arg1.accessibilityProperties.forceSimple;
noAutoLabeling = arg1.accessibilityProperties.noAutoLabeling;
if (arg1.accessibilityProperties.name)
{
name = arg1.accessibilityProperties.name;
}
if (arg1.accessibilityProperties.description)
{
description = arg1.accessibilityProperties.description;
}
if (arg1.accessibilityProperties.shortcut)
{
shortcut = arg1.accessibilityProperties.shortcut;
}
}
var loc1:*=Class(mx.accessibility.AccImpl.mx_internal::getDefinition("mx.controls.scrollClasses.ScrollBar", this.master.moduleFactory));
if (loc1 && this.master is loc1)
{
silent = true;
return;
}
var loc2:*=Class(mx.accessibility.AccImpl.mx_internal::getDefinition("mx.controls.FormItemLabel", this.master.moduleFactory));
if (loc2 && this.master is loc2)
{
name = mx.accessibility.AccImpl.getFormName(this.master);
silent = true;
}
else
{
if ((loc3 = mx.accessibility.AccImpl.getFormName(this.master)) && !(loc3.length == 0))
{
name = loc3 + name;
}
if (this.master.toolTip && !(this.master.toolTip.length == 0))
{
if (!arg1.accessibilityProperties || arg1.accessibilityProperties && !arg1.accessibilityProperties.name)
{
this.oldToolTip = " " + this.master.toolTip;
name = name + this.oldToolTip;
}
}
if (this.master.errorString && !(this.master.errorString.length == 0))
{
this.oldErrorString = " " + this.master.errorString;
name = name + this.oldErrorString;
}
this.master.addEventListener("toolTipChanged", this.eventHandler);
this.master.addEventListener("errorStringChanged", this.eventHandler);
}
return;
}
protected function eventHandler(arg1:flash.events.Event):void
{
var loc1:*=0;
var loc2:*=arg1.type;
switch (loc2)
{
case "errorStringChanged":
{
if (name && !(name.length == 0) && this.oldErrorString)
{
loc1 = name.indexOf(this.oldErrorString);
if (loc1 != -1)
{
name = name.substring(0, loc1) + name.substring(loc1 + this.oldErrorString.length);
}
this.oldErrorString = null;
}
if (this.master.errorString && !(this.master.errorString.length == 0))
{
if (!name)
{
name = "";
}
this.oldErrorString = " " + this.master.errorString;
name = name + this.oldErrorString;
}
flash.accessibility.Accessibility.updateProperties();
break;
}
case "toolTipChanged":
{
if (name && !(name.length == 0) && this.oldToolTip)
{
loc1 = name.indexOf(this.oldToolTip);
if (loc1 != -1)
{
name = name.substring(0, loc1) + name.substring(loc1 + this.oldToolTip.length);
}
this.oldToolTip = null;
}
if (this.master.toolTip && !(this.master.toolTip.length == 0))
{
if (!this.master.accessibilityProperties || this.master.accessibilityProperties && !this.master.accessibilityProperties.name)
{
if (!name)
{
name = "";
}
this.oldToolTip = " " + this.master.toolTip;
name = name + this.oldToolTip;
}
}
flash.accessibility.Accessibility.updateProperties();
break;
}
}
return;
}
public static function enableAccessibility():void
{
mx.core.UIComponent.mx_internal::createAccessibilityImplementation = mx_internal::createAccessibilityImplementation;
return;
}
mx_internal static function createAccessibilityImplementation(arg1:mx.core.UIComponent):void
{
arg1.accessibilityProperties = new UIComponentAccProps(arg1);
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var oldToolTip:String;
internal var oldErrorString:String;
protected var master:mx.core.UIComponent;
}
}
// package automation
// class IAutomationObject
package mx.automation
{
import flash.display.*;
import flash.events.*;
public interface IAutomationObject
{
function get automationDelegate():Object;
function set automationDelegate(arg1:Object):void;
function get automationName():String;
function set automationName(arg1:String):void;
function get automationValue():Array;
function get numAutomationChildren():int;
function get showInAutomationHierarchy():Boolean;
function set showInAutomationHierarchy(arg1:Boolean):void;
function get automationTabularData():Object;
function get automationOwner():flash.display.DisplayObjectContainer;
function get automationParent():flash.display.DisplayObjectContainer;
function get automationEnabled():Boolean;
function get automationVisible():Boolean;
function createAutomationIDPart(arg1:mx.automation.IAutomationObject):Object;
function createAutomationIDPartWithRequiredProperties(arg1:mx.automation.IAutomationObject, arg2:Array):Object;
function resolveAutomationIDPart(arg1:Object):Array;
function getAutomationChildAt(arg1:int):mx.automation.IAutomationObject;
function getAutomationChildren():Array;
function replayAutomatableEvent(arg1:flash.events.Event):Boolean;
}
}
// package binding
// class BindabilityInfo
package mx.binding
{
import mx.core.*;
import mx.events.*;
use namespace mx_internal;
public class BindabilityInfo extends Object
{
public function BindabilityInfo(arg1:XML)
{
this.childChangeEvents = {};
super();
this.typeDescription = arg1;
return;
}
public function getChangeEvents(arg1:String):Object
{
var childName:String;
var changeEvents:Object;
var childDesc:XMLList;
var numChildren:int;
var loc1:*;
childDesc = null;
numChildren = 0;
childName = arg1;
changeEvents = this.childChangeEvents[childName];
if (!changeEvents)
{
changeEvents = this.copyProps(this.getClassChangeEvents(), {});
var loc3:*=0;
var loc4:*=this.typeDescription.accessor;
var loc2:*=new XMLList("");
for each (var loc5:* in loc4)
{
var loc6:*;
with (loc6 = loc5)
{
if (@name == childName)
{
loc2[loc3] = loc5;
}
}
}
loc3 = 0;
loc4 = this.typeDescription.method;
loc2 = new XMLList("");
for each (loc5 in loc4)
{
with (loc6 = loc5)
{
if (@name == childName)
{
loc2[loc3] = loc5;
}
}
}
childDesc = loc2 + loc2;
numChildren = childDesc.length();
if (numChildren != 0)
{
if (numChildren > 1)
{
trace("warning: multiple describeType entries for \'" + childName + "\' on type \'" + this.typeDescription.@name + "\':\n" + childDesc);
}
this.addBindabilityEvents(childDesc.metadata, changeEvents);
}
else if (!this.typeDescription.@dynamic)
{
trace("warning: no describeType entry for \'" + childName + "\' on non-dynamic type \'" + this.typeDescription.@name + "\'");
}
this.childChangeEvents[childName] = changeEvents;
}
return changeEvents;
}
internal function getClassChangeEvents():Object
{
var loc1:*;
if (!this.classChangeEvents)
{
this.classChangeEvents = {};
this.addBindabilityEvents(this.typeDescription.metadata, this.classChangeEvents);
var loc3:*=0;
var loc4:*=this.typeDescription.metadata;
var loc2:*=new XMLList("");
for each (var loc5:* in loc4)
{
var loc6:*;
with (loc6 = loc5)
{
if (@name == MANAGED)
{
loc2[loc3] = loc5;
}
}
}
if (loc2.length() > 0)
{
this.classChangeEvents[mx.events.PropertyChangeEvent.PROPERTY_CHANGE] = true;
}
}
return this.classChangeEvents;
}
internal function addBindabilityEvents(arg1:XMLList, arg2:Object):void
{
var metadata:XMLList;
var eventListObj:Object;
var loc1:*;
metadata = arg1;
eventListObj = arg2;
var loc3:*=0;
var loc4:*=metadata;
var loc2:*=new XMLList("");
for each (var loc5:* in loc4)
{
var loc6:*;
with (loc6 = loc5)
{
if (@name == BINDABLE)
{
loc2[loc3] = loc5;
}
}
}
this.addChangeEvents(loc2, eventListObj, true);
loc3 = 0;
loc4 = metadata;
loc2 = new XMLList("");
for each (loc5 in loc4)
{
with (loc6 = loc5)
{
if (@name == CHANGE_EVENT)
{
loc2[loc3] = loc5;
}
}
}
this.addChangeEvents(loc2, eventListObj, true);
loc3 = 0;
loc4 = metadata;
loc2 = new XMLList("");
for each (loc5 in loc4)
{
with (loc6 = loc5)
{
if (@name == NON_COMMITTING_CHANGE_EVENT)
{
loc2[loc3] = loc5;
}
}
}
this.addChangeEvents(loc2, eventListObj, false);
return;
}
internal function addChangeEvents(arg1:XMLList, arg2:Object, arg3:Boolean):void
{
var loc1:*=null;
var loc2:*=null;
var loc3:*=null;
var loc4:*=0;
var loc5:*=arg1;
for each (loc1 in loc5)
{
if ((loc2 = loc1.arg).length() > 0)
{
loc3 = loc2[0].@value;
arg2[loc3] = arg3;
continue;
}
trace("warning: unconverted Bindable metadata in class \'" + this.typeDescription.@name + "\'");
}
return;
}
internal function copyProps(arg1:Object, arg2:Object):Object
{
var loc1:*=null;
var loc2:*=0;
var loc3:*=arg1;
for (loc1 in loc3)
{
arg2[loc1] = arg1[loc1];
}
return arg2;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const BINDABLE:String="Bindable";
public static const MANAGED:String="Managed";
public static const CHANGE_EVENT:String="ChangeEvent";
public static const NON_COMMITTING_CHANGE_EVENT:String="NonCommittingChangeEvent";
public static const ACCESSOR:String="accessor";
public static const METHOD:String="method";
internal var typeDescription:XML;
internal var classChangeEvents:Object;
internal var childChangeEvents:Object;
}
}
// class Binding
package mx.binding
{
import flash.utils.*;
import mx.collections.errors.*;
import mx.core.*;
use namespace mx_internal;
public class Binding extends Object
{
public function Binding(arg1:Object, arg2:Function, arg3:Function, arg4:String, arg5:String=null)
{
super();
this.mx_internal::document = arg1;
this.mx_internal::srcFunc = arg2;
this.mx_internal::destFunc = arg3;
this.mx_internal::destString = arg4;
this.mx_internal::srcString = arg5;
if (this.mx_internal::srcFunc == null)
{
this.mx_internal::srcFunc = this.defaultSrcFunc;
}
if (this.mx_internal::destFunc == null)
{
this.mx_internal::destFunc = this.defaultDestFunc;
}
this.mx_internal::_isEnabled = true;
this.mx_internal::isExecuting = false;
this.mx_internal::isHandlingEvent = false;
this.hasHadValue = false;
this.uiComponentWatcher = -1;
mx.binding.BindingManager.addBinding(arg1, arg4, this);
return;
}
mx_internal function get isEnabled():Boolean
{
return this.mx_internal::_isEnabled;
}
mx_internal function set isEnabled(arg1:Boolean):void
{
this.mx_internal::_isEnabled = arg1;
if (arg1)
{
this.processDisabledRequests();
}
return;
}
internal function defaultDestFunc(arg1:Object):void
{
var loc1:*=this.mx_internal::destString.split(".");
var loc2:*=this.mx_internal::document;
var loc3:*=0;
if (loc1[0] == "this")
{
++loc3;
}
while (loc3 < (loc1.length - 1))
{
loc2 = loc2[loc1[loc3++]];
}
loc2[loc1[loc3]] = arg1;
return;
}
internal function defaultSrcFunc():Object
{
return this.mx_internal::document[this.mx_internal::srcString];
}
public function execute(arg1:Object=null):void
{
var o:Object=null;
var loc1:*;
o = arg1;
if (!this.mx_internal::isEnabled)
{
if (o != null)
{
this.registerDisabledExecute(o);
}
return;
}
if (this.twoWayCounterpart && !this.twoWayCounterpart.hasHadValue && this.twoWayCounterpart.isTwoWayPrimary)
{
this.twoWayCounterpart.execute();
this.hasHadValue = true;
return;
}
if (this.mx_internal::isExecuting || this.twoWayCounterpart && this.twoWayCounterpart.mx_internal::isExecuting)
{
this.hasHadValue = true;
return;
}
try
{
this.mx_internal::isExecuting = true;
this.wrapFunctionCall(this, this.innerExecute, o);
}
catch (error:Error)
{
if (error.errorID != 1507)
{
throw error;
}
}
finally
{
this.mx_internal::isExecuting = false;
}
return;
}
internal function registerDisabledExecute(arg1:Object):void
{
if (arg1 != null)
{
this.mx_internal::disabledRequests = this.mx_internal::disabledRequests == null ? new flash.utils.Dictionary(true) : this.mx_internal::disabledRequests;
this.mx_internal::disabledRequests[arg1] = true;
}
return;
}
internal function processDisabledRequests():void
{
var loc1:*=null;
if (this.mx_internal::disabledRequests != null)
{
var loc2:*=0;
var loc3:*=this.mx_internal::disabledRequests;
for (loc1 in loc3)
{
this.execute(loc1);
}
this.mx_internal::disabledRequests = null;
}
return;
}
protected function wrapFunctionCall(arg1:Object, arg2:Function, arg3:Object=null, ... rest):Object
{
var thisArg:Object;
var wrappedFunction:Function;
var object:Object=null;
var args:Array;
var result:Object;
var loc1:*;
result = null;
thisArg = arg1;
wrappedFunction = arg2;
object = arg3;
args = rest;
this.wrappedFunctionSuccessful = false;
try
{
result = wrappedFunction.apply(thisArg, args);
this.wrappedFunctionSuccessful = true;
return result;
}
catch (itemPendingError:mx.collections.errors.ItemPendingError)
{
itemPendingError.addResponder(new mx.binding.EvalBindingResponder(this, object));
if (mx.binding.BindingManager.debugDestinationStrings[mx_internal::destString])
{
trace("Binding: destString = " + mx_internal::destString + ", error = " + itemPendingError);
}
}
catch (rangeError:RangeError)
{
if (mx.binding.BindingManager.debugDestinationStrings[mx_internal::destString])
{
trace("Binding: destString = " + mx_internal::destString + ", error = " + rangeError);
}
}
catch (error:Error)
{
if (!(error.errorID == 1006) && !(error.errorID == 1009) && !(error.errorID == 1010) && !(error.errorID == 1055) && !(error.errorID == 1069))
{
throw error;
}
if (mx.binding.BindingManager.debugDestinationStrings[mx_internal::destString])
{
trace("Binding: destString = " + mx_internal::destString + ", error = " + error);
}
}
return null;
}
internal function nodeSeqEqual(arg1:XMLList, arg2:XMLList):Boolean
{
var loc2:*=0;
var loc1:*=arg1.length();
if (loc1 == arg2.length())
{
loc2 = 0;
while (loc2 < loc1 && arg1[loc2] === arg2[loc2])
{
++loc2;
}
return loc2 == loc1;
}
return false;
}
internal function innerExecute():void
{
var loc1:*=this.wrapFunctionCall(this.mx_internal::document, this.mx_internal::srcFunc);
if (mx.binding.BindingManager.debugDestinationStrings[this.mx_internal::destString])
{
trace("Binding: destString = " + this.mx_internal::destString + ", srcFunc result = " + loc1);
}
if (this.hasHadValue || this.wrappedFunctionSuccessful)
{
if (!(this.lastValue is XML && this.lastValue.hasComplexContent() && this.lastValue === loc1) && !(this.lastValue is XMLList && this.lastValue.hasComplexContent() && loc1 is XMLList && this.nodeSeqEqual(this.lastValue as XMLList, loc1 as XMLList)))
{
this.mx_internal::destFunc.call(this.mx_internal::document, loc1);
this.lastValue = loc1;
this.hasHadValue = true;
}
}
return;
}
public function watcherFired(arg1:Boolean, arg2:int):void
{
var commitEvent:Boolean;
var cloneIndex:int;
var loc1:*;
commitEvent = arg1;
cloneIndex = arg2;
if (this.mx_internal::isHandlingEvent)
{
return;
}
try
{
this.mx_internal::isHandlingEvent = true;
this.execute(cloneIndex);
}
finally
{
this.mx_internal::isHandlingEvent = false;
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
mx_internal var _isEnabled:Boolean;
mx_internal var isExecuting:Boolean;
mx_internal var isHandlingEvent:Boolean;
mx_internal var disabledRequests:flash.utils.Dictionary;
internal var hasHadValue:Boolean;
public var uiComponentWatcher:int;
public var twoWayCounterpart:mx.binding.Binding;
public var isTwoWayPrimary:Boolean;
internal var wrappedFunctionSuccessful:Boolean;
mx_internal var document:Object;
mx_internal var srcFunc:Function;
mx_internal var destFunc:Function;
mx_internal var destString:String;
mx_internal var srcString:String;
internal var lastValue:Object;
}
}
// class BindingManager
package mx.binding
{
import mx.core.*;
use namespace mx_internal;
public class BindingManager extends Object
{
public function BindingManager()
{
super();
return;
}
public static function addBinding(arg1:Object, arg2:String, arg3:mx.binding.Binding):void
{
if (!arg1._bindingsByDestination)
{
arg1._bindingsByDestination = {};
arg1._bindingsBeginWithWord = {};
}
arg1._bindingsByDestination[arg2] = arg3;
arg1._bindingsBeginWithWord[getFirstWord(arg2)] = true;
return;
}
public static function setEnabled(arg1:Object, arg2:Boolean):void
{
var loc1:*=null;
var loc2:*=0;
var loc3:*=null;
if (arg1 is mx.binding.IBindingClient && arg1._bindings)
{
loc1 = arg1._bindings as Array;
loc2 = 0;
while (loc2 < loc1.length)
{
(loc3 = loc1[loc2]).mx_internal::isEnabled = arg2;
++loc2;
}
}
return;
}
public static function executeBindings(arg1:Object, arg2:String, arg3:Object):void
{
var loc1:*=null;
if (!arg2 || arg2 == "")
{
return;
}
if (arg1 && (arg1 is mx.binding.IBindingClient || arg1.hasOwnProperty("_bindingsByDestination")) && arg1._bindingsByDestination && arg1._bindingsBeginWithWord[getFirstWord(arg2)])
{
var loc2:*=0;
var loc3:*=arg1._bindingsByDestination;
for (loc1 in loc3)
{
if (loc1.charAt(0) != arg2.charAt(0))
{
continue;
}
if (!(loc1.indexOf(arg2 + ".") == 0 || loc1.indexOf(arg2 + "[") == 0 || loc1 == arg2))
{
continue;
}
arg1._bindingsByDestination[loc1].execute(arg3);
}
}
return;
}
internal static function getFirstWord(arg1:String):String
{
var loc1:*=arg1.indexOf(".");
var loc2:*=arg1.indexOf("[");
if (loc1 == loc2)
{
return arg1;
}
var loc3:*;
if ((loc3 = Math.min(loc1, loc2)) == -1)
{
loc3 = Math.max(loc1, loc2);
}
return arg1.substr(0, loc3);
}
public static function debugBinding(arg1:String):void
{
debugDestinationStrings[arg1] = true;
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
debugDestinationStrings = {};
}
mx_internal static const VERSION:String="4.1.0.16076";
static var debugDestinationStrings:Object;
}
}
// class EvalBindingResponder
package mx.binding
{
import mx.core.*;
import mx.rpc.*;
use namespace mx_internal;
public class EvalBindingResponder extends Object implements mx.rpc.IResponder
{
public function EvalBindingResponder(arg1:mx.binding.Binding, arg2:Object)
{
super();
this.binding = arg1;
this.object = arg2;
return;
}
public function result(arg1:Object):void
{
this.binding.execute(this.object);
return;
}
public function fault(arg1:Object):void
{
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var binding:mx.binding.Binding;
internal var object:Object;
}
}
// class IBindingClient
package mx.binding
{
public interface IBindingClient
{
}
}
// class IWatcherSetupUtil2
package mx.binding
{
public interface IWatcherSetupUtil2
{
function setup(arg1:Object, arg2:Function, arg3:Function, arg4:Array, arg5:Array):void;
}
}
// class PropertyWatcher
package mx.binding
{
import flash.events.*;
import flash.utils.*;
import mx.core.*;
import mx.events.*;
import mx.utils.*;
use namespace mx_internal;
public class PropertyWatcher extends mx.binding.Watcher
{
public function PropertyWatcher(arg1:String, arg2:Object, arg3:Array, arg4:Function=null)
{
super(arg3);
this._propertyName = arg1;
this.events = arg2;
this.propertyGetter = arg4;
this.useRTTI = !arg2;
return;
}
public function get propertyName():String
{
return this._propertyName;
}
public override function updateParent(arg1:Object):void
{
var loc1:*=null;
var loc2:*=null;
if (this.parentObj && this.parentObj is flash.events.IEventDispatcher)
{
var loc3:*=0;
var loc4:*=this.events;
for (loc1 in loc4)
{
this.parentObj.removeEventListener(loc1, this.eventHandler);
}
}
if (arg1 is mx.binding.Watcher)
{
this.parentObj = arg1.value;
}
else
{
this.parentObj = arg1;
}
if (this.parentObj)
{
if (this.useRTTI)
{
this.events = {};
if (this.parentObj is flash.events.IEventDispatcher)
{
loc2 = mx.utils.DescribeTypeCache.describeType(this.parentObj).bindabilityInfo;
this.events = loc2.getChangeEvents(this._propertyName);
if (this.objectIsEmpty(this.events))
{
trace("warning: unable to bind to property \'" + this._propertyName + "\' on class \'" + flash.utils.getQualifiedClassName(this.parentObj) + "\'");
}
else
{
this.addParentEventListeners();
}
}
else
{
trace("warning: unable to bind to property \'" + this._propertyName + "\' on class \'" + flash.utils.getQualifiedClassName(this.parentObj) + "\' (class is not an IEventDispatcher)");
}
}
else if (this.parentObj is flash.events.IEventDispatcher)
{
this.addParentEventListeners();
}
}
wrapUpdate(this.updateProperty);
return;
}
protected override function shallowClone():mx.binding.Watcher
{
var loc1:*=new mx.binding.PropertyWatcher(this._propertyName, this.events, listeners, this.propertyGetter);
return loc1;
}
internal function addParentEventListeners():void
{
var loc1:*=null;
var loc2:*=0;
var loc3:*=this.events;
for (loc1 in loc3)
{
if (loc1 == "__NoChangeEvent__")
{
continue;
}
this.parentObj.addEventListener(loc1, this.eventHandler, false, mx.core.EventPriority.BINDING, true);
}
return;
}
internal function traceInfo():String
{
return "Watcher(" + flash.utils.getQualifiedClassName(this.parentObj) + "." + this._propertyName + "): events = [" + this.eventNamesToString() + (this.useRTTI ? "] (RTTI)" : "]");
}
internal function eventNamesToString():String
{
var loc2:*=null;
var loc1:*=" ";
var loc3:*=0;
var loc4:*=this.events;
for (loc2 in loc4)
{
loc1 = loc1 + (loc2 + " ");
}
return loc1;
}
internal function objectIsEmpty(arg1:Object):Boolean
{
var loc1:*=null;
var loc2:*=0;
var loc3:*=arg1;
for (loc1 in loc3)
{
return false;
}
return true;
}
internal function updateProperty():void
{
if (this.parentObj)
{
if (this._propertyName != "this")
{
if (this.propertyGetter == null)
{
value = this.parentObj[this._propertyName];
}
else
{
value = this.propertyGetter.apply(this.parentObj, [this._propertyName]);
}
}
else
{
value = this.parentObj;
}
}
else
{
value = null;
}
updateChildren();
return;
}
public function eventHandler(arg1:flash.events.Event):void
{
var loc1:*=null;
if (arg1 is mx.events.PropertyChangeEvent)
{
loc1 = mx.events.PropertyChangeEvent(arg1).property;
if (loc1 != this._propertyName)
{
return;
}
}
wrapUpdate(this.updateProperty);
notifyListeners(this.events[arg1.type]);
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var parentObj:Object;
protected var events:Object;
protected var propertyGetter:Function;
internal var _propertyName:String;
internal var useRTTI:Boolean;
}
}
// class Watcher
package mx.binding
{
import mx.collections.errors.*;
import mx.core.*;
use namespace mx_internal;
public class Watcher extends Object
{
public function Watcher(arg1:Array=null)
{
super();
this.listeners = arg1;
return;
}
public function updateParent(arg1:Object):void
{
return;
}
public function addChild(arg1:mx.binding.Watcher):void
{
if (this.children)
{
this.children.push(arg1);
}
else
{
this.children = [arg1];
}
arg1.updateParent(this);
return;
}
public function removeChildren(arg1:int):void
{
this.children.splice(arg1);
return;
}
public function updateChildren():void
{
var loc1:*=0;
var loc2:*=0;
if (this.children)
{
loc1 = this.children.length;
loc2 = 0;
while (loc2 < loc1)
{
this.children[loc2].updateParent(this);
++loc2;
}
}
return;
}
internal function valueChanged(arg1:Object):Boolean
{
if (arg1 == null && this.value == null)
{
return false;
}
var loc1:*=typeof this.value;
if (loc1 == "string")
{
if (arg1 == null && this.value == "")
{
return false;
}
return !(arg1 == this.value);
}
if (loc1 == "number")
{
if (arg1 == null && this.value == 0)
{
return false;
}
return !(arg1 == this.value);
}
if (loc1 == "boolean")
{
if (arg1 == null && this.value == false)
{
return false;
}
return !(arg1 == this.value);
}
return true;
}
protected function wrapUpdate(arg1:Function):void
{
var wrappedFunction:Function;
var loc1:*;
wrappedFunction = arg1;
try
{
wrappedFunction.apply(this);
}
catch (itemPendingError:mx.collections.errors.ItemPendingError)
{
value = null;
}
catch (rangeError:RangeError)
{
value = null;
}
catch (error:Error)
{
if (!(error.errorID == 1006) && !(error.errorID == 1009) && !(error.errorID == 1010) && !(error.errorID == 1055) && !(error.errorID == 1069) && !(error.errorID == 1507))
{
throw error;
}
}
return;
}
protected function deepClone(arg1:int):mx.binding.Watcher
{
var loc2:*=0;
var loc3:*=0;
var loc4:*=null;
var loc1:*=this.shallowClone();
loc1.cloneIndex = arg1;
if (this.listeners)
{
loc1.listeners = this.listeners.concat();
}
if (this.children)
{
loc2 = this.children.length;
loc3 = 0;
while (loc3 < loc2)
{
loc4 = this.children[loc3].deepClone(arg1);
loc1.addChild(loc4);
++loc3;
}
}
return loc1;
}
protected function shallowClone():mx.binding.Watcher
{
return new mx.binding.Watcher();
}
public function notifyListeners(arg1:Boolean):void
{
var loc1:*=0;
var loc2:*=0;
if (this.listeners)
{
loc1 = this.listeners.length;
loc2 = 0;
while (loc2 < loc1)
{
this.listeners[loc2].watcherFired(arg1, this.cloneIndex);
++loc2;
}
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
protected var listeners:Array;
protected var children:Array;
public var value:Object;
protected var cloneIndex:int;
}
}
// package collections
// package errors
// class ItemPendingError
package mx.collections.errors
{
import mx.core.*;
import mx.rpc.*;
use namespace mx_internal;
public class ItemPendingError extends Error
{
public function ItemPendingError(arg1:String)
{
super(arg1);
return;
}
public function get responders():Array
{
return this._responders;
}
public function addResponder(arg1:mx.rpc.IResponder):void
{
if (!this._responders)
{
this._responders = [];
}
this._responders.push(arg1);
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var _responders:Array;
}
}
// class IList
package mx.collections
{
import flash.events.*;
public interface IList extends flash.events.IEventDispatcher
{
function get length():int;
function addItem(arg1:Object):void;
function addItemAt(arg1:Object, arg2:int):void;
function getItemAt(arg1:int, arg2:int=0):Object;
function getItemIndex(arg1:Object):int;
function itemUpdated(arg1:Object, arg2:Object=null, arg3:Object=null, arg4:Object=null):void;
function removeAll():void;
function removeItemAt(arg1:int):Object;
function setItemAt(arg1:Object, arg2:int):Object;
function toArray():Array;
}
}
// package containers
// package errors
// class ConstraintError
package mx.containers.errors
{
import mx.core.*;
use namespace mx_internal;
public class ConstraintError extends Error
{
public function ConstraintError(arg1:String)
{
super(arg1);
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// package utilityClasses
// class ApplicationLayout
package mx.containers.utilityClasses
{
import mx.core.*;
use namespace mx_internal;
public class ApplicationLayout extends mx.containers.utilityClasses.BoxLayout
{
public function ApplicationLayout()
{
super();
return;
}
public override function updateDisplayList(arg1:Number, arg2:Number):void
{
var loc2:*=NaN;
var loc3:*=NaN;
var loc4:*=NaN;
var loc5:*=NaN;
var loc6:*=0;
var loc7:*=0;
var loc8:*=null;
super.updateDisplayList(arg1, arg2);
var loc1:*=super.target;
if (loc1.horizontalScrollBar && mx_internal::getHorizontalAlignValue() > 0 || loc1.verticalScrollBar && mx_internal::getVerticalAlignValue() > 0)
{
loc2 = loc1.getStyle("paddingLeft");
loc3 = loc1.getStyle("paddingTop");
loc4 = 0;
loc5 = 0;
loc6 = loc1.numChildren;
loc7 = 0;
while (loc7 < loc6)
{
if ((loc8 = mx.core.IFlexDisplayObject(loc1.getChildAt(loc7))).x < loc2)
{
loc4 = Math.max(loc4, loc2 - loc8.x);
}
if (loc8.y < loc3)
{
loc5 = Math.max(loc5, loc3 - loc8.y);
}
++loc7;
}
if (!(loc4 == 0) || !(loc5 == 0))
{
loc7 = 0;
while (loc7 < loc6)
{
loc8 = mx.core.IFlexDisplayObject(loc1.getChildAt(loc7));
loc8.move(loc8.x + loc4, loc8.y + loc5);
++loc7;
}
}
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class BoxLayout
package mx.containers.utilityClasses
{
import mx.containers.*;
import mx.controls.scrollClasses.*;
import mx.core.*;
use namespace mx_internal;
public class BoxLayout extends mx.containers.utilityClasses.Layout
{
public function BoxLayout()
{
super();
return;
}
public override function measure():void
{
var loc1:*=null;
var loc10:*=NaN;
var loc11:*=NaN;
var loc12:*=null;
var loc13:*=NaN;
var loc14:*=NaN;
loc1 = super.target;
var loc2:*=this.isVertical();
var loc3:*=0;
var loc4:*=0;
var loc5:*=0;
var loc6:*=0;
var loc7:*;
var loc8:*=loc7 = loc1.numChildren;
var loc9:*=0;
while (loc9 < loc7)
{
if ((loc12 = loc1.mx_internal::getLayoutChildAt(loc9)).includeInLayout)
{
loc13 = loc12.getExplicitOrMeasuredWidth();
loc14 = loc12.getExplicitOrMeasuredHeight();
if (loc2)
{
loc3 = Math.max(isNaN(loc12.percentWidth) ? loc13 : loc12.minWidth, loc3);
loc5 = Math.max(loc13, loc5);
loc4 = loc4 + (isNaN(loc12.percentHeight) ? loc14 : loc12.minHeight);
loc6 = loc6 + loc14;
}
else
{
loc3 = loc3 + (isNaN(loc12.percentWidth) ? loc13 : loc12.minWidth);
loc5 = loc5 + loc13;
loc4 = Math.max(isNaN(loc12.percentHeight) ? loc14 : loc12.minHeight, loc4);
loc6 = Math.max(loc14, loc6);
}
}
else
{
--loc8;
}
++loc9;
}
loc10 = this.mx_internal::widthPadding(loc8);
loc11 = this.mx_internal::heightPadding(loc8);
loc1.measuredMinWidth = loc3 + loc10;
loc1.measuredMinHeight = loc4 + loc11;
loc1.measuredWidth = loc5 + loc10;
loc1.measuredHeight = loc6 + loc11;
return;
}
public override function updateDisplayList(arg1:Number, arg2:Number):void
{
var loc14:*=NaN;
var loc15:*=0;
var loc16:*=NaN;
var loc17:*=NaN;
var loc18:*=NaN;
var loc19:*=0;
var loc20:*=null;
var loc21:*=null;
var loc22:*=NaN;
var loc23:*=NaN;
var loc24:*=NaN;
var loc25:*=NaN;
var loc1:*=super.target;
var loc2:*;
if ((loc2 = loc1.numChildren) == 0)
{
return;
}
var loc3:*=loc1.viewMetricsAndPadding;
var loc4:*=loc1.getStyle("paddingLeft");
var loc5:*=loc1.getStyle("paddingTop");
var loc6:*=this.mx_internal::getHorizontalAlignValue();
var loc7:*=this.mx_internal::getVerticalAlignValue();
var loc8:*=loc1.scaleX > 0 && !(loc1.scaleX == 1) ? loc1.minWidth / Math.abs(loc1.scaleX) : loc1.minWidth;
var loc9:*=loc1.scaleY > 0 && !(loc1.scaleY == 1) ? loc1.minHeight / Math.abs(loc1.scaleY) : loc1.minHeight;
var loc10:*=Math.max(arg1, loc8) - loc3.right - loc3.left;
var loc11:*=Math.max(arg2, loc9) - loc3.bottom - loc3.top;
var loc12:*=loc1.horizontalScrollBar;
var loc13:*=loc1.verticalScrollBar;
if (loc2 != 1)
{
if (this.isVertical())
{
loc14 = loc1.getStyle("verticalGap");
loc15 = loc2;
loc19 = 0;
while (loc19 < loc2)
{
if (!mx.core.IUIComponent(loc1.getChildAt(loc19)).includeInLayout)
{
--loc15;
}
++loc19;
}
loc16 = mx.containers.utilityClasses.Flex.flexChildHeightsProportionally(loc1, loc11 - (loc15 - 1) * loc14, loc10);
if (!(loc12 == null) && loc1.horizontalScrollPolicy == mx.core.ScrollPolicy.AUTO)
{
loc16 = loc16 + loc12.minHeight;
}
if (!(loc13 == null) && loc1.verticalScrollPolicy == mx.core.ScrollPolicy.AUTO)
{
loc10 = loc10 + loc13.minWidth;
}
loc17 = loc5 + loc16 * loc7;
loc19 = 0;
while (loc19 < loc2)
{
loc20 = loc1.mx_internal::getLayoutChildAt(loc19);
loc18 = (loc10 - loc20.width) * loc6 + loc4;
loc20.move(Math.floor(loc18), Math.floor(loc17));
if (loc20.includeInLayout)
{
loc17 = loc17 + (loc20.height + loc14);
}
++loc19;
}
}
else
{
loc14 = loc1.getStyle("horizontalGap");
loc15 = loc2;
loc19 = 0;
while (loc19 < loc2)
{
if (!mx.core.IUIComponent(loc1.getChildAt(loc19)).includeInLayout)
{
--loc15;
}
++loc19;
}
loc16 = mx.containers.utilityClasses.Flex.flexChildWidthsProportionally(loc1, loc10 - (loc15 - 1) * loc14, loc11);
if (!(loc12 == null) && loc1.horizontalScrollPolicy == mx.core.ScrollPolicy.AUTO)
{
loc11 = loc11 + loc12.minHeight;
}
if (!(loc13 == null) && loc1.verticalScrollPolicy == mx.core.ScrollPolicy.AUTO)
{
loc16 = loc16 + loc13.minWidth;
}
loc18 = loc4 + loc16 * loc6;
loc19 = 0;
while (loc19 < loc2)
{
loc20 = loc1.mx_internal::getLayoutChildAt(loc19);
loc17 = (loc11 - loc20.height) * loc7 + loc5;
loc20.move(Math.floor(loc18), Math.floor(loc17));
if (loc20.includeInLayout)
{
loc18 = loc18 + (loc20.width + loc14);
}
++loc19;
}
}
}
else
{
loc22 = (loc21 = loc1.mx_internal::getLayoutChildAt(0)).percentWidth;
loc23 = loc21.percentHeight;
if (loc22)
{
loc24 = Math.max(loc21.minWidth, Math.min(loc21.maxWidth, loc22 >= 100 ? loc10 : loc10 * loc22 / 100));
}
else
{
loc24 = loc21.getExplicitOrMeasuredWidth();
}
if (loc23)
{
loc25 = Math.max(loc21.minHeight, Math.min(loc21.maxHeight, loc23 >= 100 ? loc11 : loc11 * loc23 / 100));
}
else
{
loc25 = loc21.getExplicitOrMeasuredHeight();
}
if (loc21.scaleX == 1 && loc21.scaleY == 1)
{
loc21.setActualSize(Math.floor(loc24), Math.floor(loc25));
}
else
{
loc21.setActualSize(loc24, loc25);
}
if (!(loc13 == null) && loc1.verticalScrollPolicy == mx.core.ScrollPolicy.AUTO)
{
loc10 = loc10 + loc13.minWidth;
}
if (!(loc12 == null) && loc1.horizontalScrollPolicy == mx.core.ScrollPolicy.AUTO)
{
loc11 = loc11 + loc12.minHeight;
}
loc18 = (loc10 - loc21.width) * loc6 + loc4;
loc17 = (loc11 - loc21.height) * loc7 + loc5;
loc21.move(Math.floor(loc18), Math.floor(loc17));
}
return;
}
internal function isVertical():Boolean
{
return !(this.direction == mx.containers.BoxDirection.HORIZONTAL);
}
mx_internal function widthPadding(arg1:Number):Number
{
var loc1:*=target.viewMetricsAndPadding;
var loc2:*=loc1.left + loc1.right;
if (arg1 > 1 && this.isVertical() == false)
{
loc2 = loc2 + target.getStyle("horizontalGap") * (arg1 - 1);
}
return loc2;
}
mx_internal function heightPadding(arg1:Number):Number
{
var loc1:*=target.viewMetricsAndPadding;
var loc2:*=loc1.top + loc1.bottom;
if (arg1 > 1 && this.isVertical())
{
loc2 = loc2 + target.getStyle("verticalGap") * (arg1 - 1);
}
return loc2;
}
mx_internal function getHorizontalAlignValue():Number
{
var loc1:*=target.getStyle("horizontalAlign");
if (loc1 == "center")
{
return 0.5;
}
if (loc1 == "right")
{
return 1;
}
return 0;
}
mx_internal function getVerticalAlignValue():Number
{
var loc1:*=target.getStyle("verticalAlign");
if (loc1 == "middle")
{
return 0.5;
}
if (loc1 == "bottom")
{
return 1;
}
return 0;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public var direction:String="vertical";
}
}
// class CanvasLayout
package mx.containers.utilityClasses
{
import flash.display.*;
import flash.geom.*;
import flash.utils.*;
import mx.containers.errors.*;
import mx.core.*;
import mx.events.*;
use namespace mx_internal;
public class CanvasLayout extends mx.containers.utilityClasses.Layout
{
public function CanvasLayout()
{
this.colSpanChildren = [];
this.rowSpanChildren = [];
this.constraintCache = new flash.utils.Dictionary(true);
super();
return;
}
internal function bound(arg1:Number, arg2:Number, arg3:Number):Number
{
if (arg1 < arg2)
{
arg1 = arg2;
}
else if (arg1 > arg3)
{
arg1 = arg3;
}
else
{
arg1 = Math.floor(arg1);
}
return arg1;
}
public override function set target(arg1:mx.core.Container):void
{
var loc2:*=0;
var loc3:*=0;
var loc1:*=super.target;
if (arg1 != loc1)
{
if (loc1)
{
loc1.removeEventListener(mx.events.ChildExistenceChangedEvent.CHILD_ADD, this.target_childAddHandler);
loc1.removeEventListener(mx.events.ChildExistenceChangedEvent.CHILD_REMOVE, this.target_childRemoveHandler);
loc3 = loc1.numChildren;
loc2 = 0;
while (loc2 < loc3)
{
flash.display.DisplayObject(loc1.getChildAt(loc2)).removeEventListener(mx.events.MoveEvent.MOVE, this.child_moveHandler);
++loc2;
}
}
if (arg1)
{
arg1.addEventListener(mx.events.ChildExistenceChangedEvent.CHILD_ADD, this.target_childAddHandler);
arg1.addEventListener(mx.events.ChildExistenceChangedEvent.CHILD_REMOVE, this.target_childRemoveHandler);
loc3 = arg1.numChildren;
loc2 = 0;
while (loc2 < loc3)
{
flash.display.DisplayObject(arg1.getChildAt(loc2)).addEventListener(mx.events.MoveEvent.MOVE, this.child_moveHandler);
++loc2;
}
}
super.target = arg1;
}
return;
}
public override function measure():void
{
var loc1:*=null;
var loc5:*=null;
var loc7:*=null;
var loc8:*=null;
var loc9:*=null;
loc1 = super.target;
var loc2:*=0;
var loc3:*=0;
var loc4:*=0;
loc5 = loc1.viewMetrics;
loc4 = 0;
while (loc4 < loc1.numChildren)
{
loc7 = loc1.mx_internal::getLayoutChildAt(loc4);
this.parseConstraints(loc7);
++loc4;
}
loc4 = 0;
while (loc4 < mx.containers.utilityClasses.IConstraintLayout(loc1).constraintColumns.length)
{
if ((loc8 = mx.containers.utilityClasses.IConstraintLayout(loc1).constraintColumns[loc4]).mx_internal::contentSize)
{
loc8.mx_internal::_width = NaN;
}
++loc4;
}
loc4 = 0;
while (loc4 < mx.containers.utilityClasses.IConstraintLayout(loc1).constraintRows.length)
{
if ((loc9 = mx.containers.utilityClasses.IConstraintLayout(loc1).constraintRows[loc4]).mx_internal::contentSize)
{
loc9.mx_internal::_height = NaN;
}
++loc4;
}
this.measureColumnsAndRows();
this._contentArea = null;
var loc6:*=this.measureContentArea();
loc1.measuredWidth = loc6.width + loc5.left + loc5.right;
loc1.measuredHeight = loc6.height + loc5.top + loc5.bottom;
return;
}
public override function updateDisplayList(arg1:Number, arg2:Number):void
{
var loc1:*=0;
var loc2:*=null;
var loc8:*=null;
var loc9:*=null;
var loc3:*;
var loc4:*=(loc3 = super.target).numChildren;
loc3.mx_internal::doingLayout = false;
var loc5:*=loc3.viewMetrics;
loc3.mx_internal::doingLayout = true;
var loc6:*=arg1 - loc5.left - loc5.right;
var loc7:*=arg2 - loc5.top - loc5.bottom;
if (mx.containers.utilityClasses.IConstraintLayout(loc3).constraintColumns.length > 0 || mx.containers.utilityClasses.IConstraintLayout(loc3).constraintRows.length > 0)
{
this.constraintRegionsInUse = true;
}
if (this.constraintRegionsInUse)
{
loc1 = 0;
while (loc1 < loc4)
{
loc2 = loc3.mx_internal::getLayoutChildAt(loc1);
this.parseConstraints(loc2);
++loc1;
}
loc1 = 0;
while (loc1 < mx.containers.utilityClasses.IConstraintLayout(loc3).constraintColumns.length)
{
if ((loc8 = mx.containers.utilityClasses.IConstraintLayout(loc3).constraintColumns[loc1]).mx_internal::contentSize)
{
loc8.mx_internal::_width = NaN;
}
++loc1;
}
loc1 = 0;
while (loc1 < mx.containers.utilityClasses.IConstraintLayout(loc3).constraintRows.length)
{
if ((loc9 = mx.containers.utilityClasses.IConstraintLayout(loc3).constraintRows[loc1]).mx_internal::contentSize)
{
loc9.mx_internal::_height = NaN;
}
++loc1;
}
this.measureColumnsAndRows();
}
loc1 = 0;
while (loc1 < loc4)
{
loc2 = loc3.mx_internal::getLayoutChildAt(loc1);
this.applyAnchorStylesDuringUpdateDisplayList(loc6, loc7, loc2);
++loc1;
}
return;
}
internal function applyAnchorStylesDuringMeasure(arg1:mx.core.IUIComponent, arg2:flash.geom.Rectangle):void
{
var loc11:*=0;
var loc1:*=arg1 as mx.core.IConstraintClient;
if (!loc1)
{
return;
}
var loc2:*;
if (!(loc2 = this.constraintCache[loc1]))
{
loc2 = this.parseConstraints(arg1);
}
var loc3:*=loc2.left;
var loc4:*=loc2.right;
var loc5:*=loc2.hc;
var loc6:*=loc2.top;
var loc7:*=loc2.bottom;
var loc8:*=loc2.vc;
var loc9:*=mx.containers.utilityClasses.IConstraintLayout(target).constraintColumns;
var loc10:*=mx.containers.utilityClasses.IConstraintLayout(target).constraintRows;
var loc12:*=0;
if (!loc9.length > 0)
{
if (isNaN(loc5))
{
if (!isNaN(loc3) && !isNaN(loc4))
{
arg2.x = loc3;
arg2.width = arg2.width + loc4;
}
else if (isNaN(loc3))
{
if (!isNaN(loc4))
{
arg2.x = 0;
arg2.width = arg2.width + loc4;
}
}
else
{
arg2.x = loc3;
}
}
else
{
arg2.x = Math.round((target.width - arg1.width) / 2 + loc5);
}
}
else
{
arg2.x = 0;
loc11 = 0;
while (loc11 < loc9.length)
{
loc12 = loc12 + mx.containers.utilityClasses.ConstraintColumn(loc9[loc11]).width;
++loc11;
}
arg2.width = loc12;
}
if (!loc10.length > 0)
{
if (isNaN(loc8))
{
if (!isNaN(loc6) && !isNaN(loc7))
{
arg2.y = loc6;
arg2.height = arg2.height + loc7;
}
else if (isNaN(loc6))
{
if (!isNaN(loc7))
{
arg2.y = 0;
arg2.height = arg2.height + loc7;
}
}
else
{
arg2.y = loc6;
}
}
else
{
arg2.y = Math.round((target.height - arg1.height) / 2 + loc8);
}
}
else
{
loc12 = 0;
arg2.y = 0;
loc11 = 0;
while (loc11 < loc10.length)
{
loc12 = loc12 + mx.containers.utilityClasses.ConstraintRow(loc10[loc11]).height;
++loc11;
}
arg2.height = loc12;
}
return;
}
internal function applyAnchorStylesDuringUpdateDisplayList(arg1:Number, arg2:Number, arg3:mx.core.IUIComponent=null):void
{
var loc17:*=0;
var loc18:*=NaN;
var loc19:*=NaN;
var loc20:*=NaN;
var loc21:*=NaN;
var loc22:*=null;
var loc31:*=NaN;
var loc32:*=NaN;
var loc33:*=NaN;
var loc34:*=NaN;
var loc35:*=NaN;
var loc36:*=false;
var loc37:*=false;
var loc38:*=false;
var loc39:*=null;
var loc40:*=false;
var loc41:*=false;
var loc42:*=false;
var loc43:*=false;
var loc44:*=null;
var loc1:*;
if (!(loc1 = arg3 as mx.core.IConstraintClient))
{
return;
}
var loc2:*;
var loc3:*=(loc2 = this.parseConstraints(arg3)).left;
var loc4:*=loc2.right;
var loc5:*=loc2.hc;
var loc6:*=loc2.top;
var loc7:*=loc2.bottom;
var loc8:*=loc2.vc;
var loc9:*=loc2.baseline;
var loc10:*=loc2.leftBoundary;
var loc11:*=loc2.rightBoundary;
var loc12:*=loc2.hcBoundary;
var loc13:*=loc2.topBoundary;
var loc14:*=loc2.bottomBoundary;
var loc15:*=loc2.vcBoundary;
var loc16:*=loc2.baselineBoundary;
var loc23:*=false;
var loc24:*=false;
var loc25:*=!loc12 && !loc10 && !loc11;
var loc26:*=!loc15 && !loc13 && !loc14 && !loc16;
var loc27:*=0;
var loc28:*=arg1;
var loc29:*=0;
var loc30:*=arg2;
if (loc25)
{
if (!loc25)
{
loc22 = resourceManager.getString("containers", "noColumnsFound");
throw new mx.containers.errors.ConstraintError(loc22);
}
}
else
{
loc36 = loc10 ? true : false;
loc37 = loc11 ? true : false;
loc38 = loc12 ? true : false;
loc17 = 0;
while (loc17 < mx.containers.utilityClasses.IConstraintLayout(target).constraintColumns.length)
{
loc39 = mx.containers.utilityClasses.ConstraintColumn(mx.containers.utilityClasses.IConstraintLayout(target).constraintColumns[loc17]);
if (loc36)
{
if (loc10 == loc39.id)
{
loc27 = loc39.x;
loc36 = false;
}
}
if (loc37)
{
if (loc11 == loc39.id)
{
loc28 = loc39.x + loc39.width;
loc37 = false;
}
}
if (loc38)
{
if (loc12 == loc39.id)
{
loc32 = loc39.width;
loc34 = loc39.x;
loc38 = false;
}
}
++loc17;
}
if (loc36)
{
loc22 = resourceManager.getString("containers", "columnNotFound", [loc10]);
throw new mx.containers.errors.ConstraintError(loc22);
}
if (loc37)
{
loc22 = resourceManager.getString("containers", "columnNotFound", [loc11]);
throw new mx.containers.errors.ConstraintError(loc22);
}
if (loc38)
{
loc22 = resourceManager.getString("containers", "columnNotFound", [loc12]);
throw new mx.containers.errors.ConstraintError(loc22);
}
}
arg1 = Math.round(loc28 - loc27);
if (!isNaN(loc3) && !isNaN(loc4))
{
if ((loc18 = arg1 - loc3 - loc4) < arg3.minWidth)
{
loc18 = arg3.minWidth;
}
}
else if (isNaN(arg3.percentWidth))
{
loc18 = arg3.getExplicitOrMeasuredWidth();
}
else
{
loc18 = arg3.percentWidth / 100 * arg1;
loc18 = this.bound(loc18, arg3.minWidth, arg3.maxWidth);
loc23 = true;
}
if (!loc26 && mx.containers.utilityClasses.IConstraintLayout(target).constraintRows.length > 0)
{
loc40 = loc13 ? true : false;
loc41 = loc14 ? true : false;
loc42 = loc15 ? true : false;
loc43 = loc16 ? true : false;
loc17 = 0;
while (loc17 < mx.containers.utilityClasses.IConstraintLayout(target).constraintRows.length)
{
loc44 = mx.containers.utilityClasses.ConstraintRow(mx.containers.utilityClasses.IConstraintLayout(target).constraintRows[loc17]);
if (loc40)
{
if (loc13 == loc44.id)
{
loc29 = loc44.y;
loc40 = false;
}
}
if (loc41)
{
if (loc14 == loc44.id)
{
loc30 = loc44.y + loc44.height;
loc41 = false;
}
}
if (loc42)
{
if (loc15 == loc44.id)
{
loc31 = loc44.height;
loc33 = loc44.y;
loc42 = false;
}
}
if (loc43)
{
if (loc16 == loc44.id)
{
loc35 = loc44.y;
loc43 = false;
}
}
++loc17;
}
if (loc40)
{
loc22 = resourceManager.getString("containers", "rowNotFound", [loc13]);
throw new mx.containers.errors.ConstraintError(loc22);
}
if (loc41)
{
loc22 = resourceManager.getString("containers", "rowNotFound", [loc14]);
throw new mx.containers.errors.ConstraintError(loc22);
}
if (loc42)
{
loc22 = resourceManager.getString("containers", "rowNotFound", [loc15]);
throw new mx.containers.errors.ConstraintError(loc22);
}
if (loc43)
{
loc22 = resourceManager.getString("containers", "rowNotFound", [loc16]);
throw new mx.containers.errors.ConstraintError(loc22);
}
}
else if (!loc26 && !(mx.containers.utilityClasses.IConstraintLayout(target).constraintRows.length > 0))
{
loc22 = resourceManager.getString("containers", "noRowsFound");
throw new mx.containers.errors.ConstraintError(loc22);
}
arg2 = Math.round(loc30 - loc29);
if (!isNaN(loc6) && !isNaN(loc7))
{
if ((loc19 = arg2 - loc6 - loc7) < arg3.minHeight)
{
loc19 = arg3.minHeight;
}
}
else if (isNaN(arg3.percentHeight))
{
loc19 = arg3.getExplicitOrMeasuredHeight();
}
else
{
loc19 = arg3.percentHeight / 100 * arg2;
loc19 = this.bound(loc19, arg3.minHeight, arg3.maxHeight);
loc24 = true;
}
if (isNaN(loc5))
{
if (isNaN(loc3))
{
if (!isNaN(loc4))
{
if (loc11)
{
loc20 = loc28 - loc4 - loc18;
}
else
{
loc20 = arg1 - loc4 - loc18;
}
}
}
else if (loc10)
{
loc20 = loc27 + loc3;
}
else
{
loc20 = loc3;
}
}
else if (loc12)
{
loc20 = Math.round((loc32 - loc18) / 2 + loc5 + loc34);
}
else
{
loc20 = Math.round((arg1 - loc18) / 2 + loc5);
}
if (!isNaN(loc9))
{
if (loc16)
{
loc21 = loc35 - arg3.baselinePosition + loc9;
}
else
{
loc21 = loc9;
}
}
if (isNaN(loc8))
{
if (isNaN(loc6))
{
if (!isNaN(loc7))
{
if (loc14)
{
loc21 = loc30 - loc7 - loc19;
}
else
{
loc21 = arg2 - loc7 - loc19;
}
}
}
else if (loc13)
{
loc21 = loc29 + loc6;
}
else
{
loc21 = loc6;
}
}
else if (loc15)
{
loc21 = Math.round((loc31 - loc19) / 2 + loc8 + loc33);
}
else
{
loc21 = Math.round((arg2 - loc19) / 2 + loc8);
}
loc20 = isNaN(loc20) ? arg3.x : loc20;
loc21 = isNaN(loc21) ? arg3.y : loc21;
arg3.move(loc20, loc21);
if (loc23)
{
if (loc20 + loc18 > arg1)
{
loc18 = Math.max(arg1 - loc20, arg3.minWidth);
}
}
if (loc24)
{
if (loc21 + loc19 > arg2)
{
loc19 = Math.max(arg2 - loc21, arg3.minHeight);
}
}
if (!isNaN(loc18) && !isNaN(loc19))
{
arg3.setActualSize(loc18, loc19);
}
return;
}
internal function measureContentArea():flash.geom.Rectangle
{
var loc1:*=0;
var loc3:*=null;
var loc4:*=null;
var loc5:*=null;
var loc6:*=null;
var loc7:*=NaN;
var loc8:*=NaN;
var loc9:*=NaN;
var loc10:*=NaN;
var loc11:*=NaN;
var loc12:*=NaN;
if (this._contentArea)
{
return this._contentArea;
}
this._contentArea = new flash.geom.Rectangle();
var loc2:*=target.numChildren;
if (loc2 == 0 && this.constraintRegionsInUse)
{
loc3 = mx.containers.utilityClasses.IConstraintLayout(target).constraintColumns;
loc4 = mx.containers.utilityClasses.IConstraintLayout(target).constraintRows;
if (loc3.length > 0)
{
this._contentArea.right = loc3[(loc3.length - 1)].x + loc3[(loc3.length - 1)].width;
}
else
{
this._contentArea.right = 0;
}
if (loc4.length > 0)
{
this._contentArea.bottom = loc4[(loc4.length - 1)].y + loc4[(loc4.length - 1)].height;
}
else
{
this._contentArea.bottom = 0;
}
}
loc1 = 0;
while (loc1 < loc2)
{
loc5 = target.mx_internal::getLayoutChildAt(loc1);
loc6 = this.getLayoutConstraints(loc5);
if (loc5.includeInLayout)
{
loc7 = loc5.x;
loc8 = loc5.y;
loc9 = loc5.getExplicitOrMeasuredWidth();
loc10 = loc5.getExplicitOrMeasuredHeight();
if (!isNaN(loc5.percentWidth) || loc6 && !isNaN(loc6.left) && !isNaN(loc6.right) && isNaN(loc5.explicitWidth))
{
loc9 = loc5.minWidth;
}
if (!isNaN(loc5.percentHeight) || loc6 && !isNaN(loc6.top) && !isNaN(loc6.bottom) && isNaN(loc5.explicitHeight))
{
loc10 = loc5.minHeight;
}
r.x = loc7;
r.y = loc8;
r.width = loc9;
r.height = loc10;
this.applyAnchorStylesDuringMeasure(loc5, r);
loc7 = r.x;
loc8 = r.y;
loc9 = r.width;
loc10 = r.height;
if (isNaN(loc7))
{
loc7 = loc5.x;
}
if (isNaN(loc8))
{
loc8 = loc5.y;
}
loc11 = loc7;
loc12 = loc8;
if (isNaN(loc9))
{
loc9 = loc5.width;
}
if (isNaN(loc10))
{
loc10 = loc5.height;
}
loc11 = loc11 + loc9;
loc12 = loc12 + loc10;
this._contentArea.right = Math.max(this._contentArea.right, loc11);
this._contentArea.bottom = Math.max(this._contentArea.bottom, loc12);
}
++loc1;
}
return this._contentArea;
}
internal function parseConstraints(arg1:mx.core.IUIComponent=null):ChildConstraintInfo
{
var loc2:*=NaN;
var loc3:*=NaN;
var loc4:*=NaN;
var loc5:*=NaN;
var loc6:*=NaN;
var loc7:*=NaN;
var loc8:*=NaN;
var loc9:*=null;
var loc10:*=null;
var loc11:*=null;
var loc12:*=null;
var loc13:*=null;
var loc14:*=null;
var loc15:*=null;
var loc16:*=null;
var loc17:*=0;
var loc29:*=null;
var loc30:*=false;
var loc31:*=null;
var loc1:*=this.getLayoutConstraints(arg1);
if (!loc1)
{
return null;
}
for (;;)
{
if (loc16 = this.parseConstraintExp(loc1.left))
{
if (loc16.length != 1)
{
loc9 = loc16[0];
loc2 = loc16[1];
}
else
{
loc2 = Number(loc16[0]);
}
}
else
{
loc2 = NaN;
}
if (loc16 = this.parseConstraintExp(loc1.right))
{
if (loc16.length != 1)
{
loc10 = loc16[0];
loc3 = loc16[1];
}
else
{
loc3 = Number(loc16[0]);
}
}
else
{
loc3 = NaN;
}
if (loc16 = this.parseConstraintExp(loc1.horizontalCenter))
{
if (loc16.length != 1)
{
loc11 = loc16[0];
loc4 = loc16[1];
}
else
{
loc4 = Number(loc16[0]);
}
}
else
{
loc4 = NaN;
}
if (loc16 = this.parseConstraintExp(loc1.top))
{
if (loc16.length != 1)
{
loc12 = loc16[0];
loc5 = loc16[1];
}
else
{
loc5 = Number(loc16[0]);
}
}
else
{
loc5 = NaN;
}
if (loc16 = this.parseConstraintExp(loc1.bottom))
{
if (loc16.length != 1)
{
loc13 = loc16[0];
loc6 = loc16[1];
}
else
{
loc6 = Number(loc16[0]);
}
}
else
{
loc6 = NaN;
}
if (loc16 = this.parseConstraintExp(loc1.verticalCenter))
{
if (loc16.length != 1)
{
loc14 = loc16[0];
loc7 = loc16[1];
}
else
{
loc7 = Number(loc16[0]);
}
}
else
{
loc7 = NaN;
}
if (loc16 = this.parseConstraintExp(loc1.baseline))
{
if (loc16.length != 1)
{
loc15 = loc16[0];
loc8 = loc16[1];
}
else
{
loc8 = Number(loc16[0]);
}
}
else
{
loc8 = NaN;
}
break;
}
var loc18:*=new ContentColumnChild();
var loc19:*=false;
var loc20:*=0;
var loc21:*=0;
var loc22:*=0;
loc17 = 0;
while (loc17 < mx.containers.utilityClasses.IConstraintLayout(target).constraintColumns.length)
{
if ((loc29 = mx.containers.utilityClasses.IConstraintLayout(target).constraintColumns[loc17]).mx_internal::contentSize)
{
if (loc29.id == loc9)
{
loc18.leftCol = loc29;
loc18.leftOffset = loc2;
var loc32:*;
loc20 = loc32 = loc17;
loc18.left = loc32;
loc19 = true;
}
if (loc29.id == loc10)
{
loc18.rightCol = loc29;
loc18.rightOffset = loc3;
loc21 = loc32 = loc17 + 1;
loc18.right = loc32;
loc19 = true;
}
if (loc29.id == loc11)
{
loc18.hcCol = loc29;
loc18.hcOffset = loc4;
loc22 = loc32 = loc17 + 1;
loc18.hc = loc32;
loc19 = true;
}
}
++loc17;
}
if (loc19)
{
loc18.child = arg1;
if (loc18.leftCol && !loc18.rightCol || loc18.rightCol && !loc18.leftCol || loc18.hcCol)
{
loc18.span = 1;
}
else
{
loc18.span = loc21 - loc20;
}
loc30 = false;
loc17 = 0;
while (loc17 < this.colSpanChildren.length)
{
if (loc18.child == this.colSpanChildren[loc17].child)
{
loc30 = true;
break;
}
++loc17;
}
if (!loc30)
{
this.colSpanChildren.push(loc18);
}
}
loc19 = false;
var loc23:*=new ContentRowChild();
var loc24:*=0;
var loc25:*=0;
var loc26:*=0;
var loc27:*=0;
loc17 = 0;
while (loc17 < mx.containers.utilityClasses.IConstraintLayout(target).constraintRows.length)
{
if ((loc31 = mx.containers.utilityClasses.IConstraintLayout(target).constraintRows[loc17]).mx_internal::contentSize)
{
if (loc31.id == loc12)
{
loc23.topRow = loc31;
loc23.topOffset = loc5;
loc24 = loc32 = loc17;
loc23.top = loc32;
loc19 = true;
}
if (loc31.id == loc13)
{
loc23.bottomRow = loc31;
loc23.bottomOffset = loc6;
loc25 = loc32 = loc17 + 1;
loc23.bottom = loc32;
loc19 = true;
}
if (loc31.id == loc14)
{
loc23.vcRow = loc31;
loc23.vcOffset = loc7;
loc26 = loc32 = loc17 + 1;
loc23.vc = loc32;
loc19 = true;
}
if (loc31.id == loc15)
{
loc23.baselineRow = loc31;
loc23.baselineOffset = loc8;
loc27 = loc32 = loc17 + 1;
loc23.baseline = loc32;
loc19 = true;
}
}
++loc17;
}
if (loc19)
{
loc23.child = arg1;
if (loc23.topRow && !loc23.bottomRow || loc23.bottomRow && !loc23.topRow || loc23.vcRow || loc23.baselineRow)
{
loc23.span = 1;
}
else
{
loc23.span = loc25 - loc24;
}
loc30 = false;
loc17 = 0;
while (loc17 < this.rowSpanChildren.length)
{
if (loc23.child == this.rowSpanChildren[loc17].child)
{
loc30 = true;
break;
}
++loc17;
}
if (!loc30)
{
this.rowSpanChildren.push(loc23);
}
}
var loc28:*=new ChildConstraintInfo(loc2, loc3, loc4, loc5, loc6, loc7, loc8, loc9, loc10, loc11, loc12, loc13, loc14, loc15);
this.constraintCache[arg1] = loc28;
return loc28;
}
internal function measureColumnsAndRows():void
{
var loc3:*=0;
var loc4:*=0;
var loc13:*=null;
var loc14:*=null;
var loc15:*=NaN;
var loc16:*=NaN;
var loc17:*=NaN;
var loc18:*=NaN;
var loc19:*=null;
var loc20:*=null;
var loc1:*=mx.containers.utilityClasses.IConstraintLayout(target).constraintColumns;
var loc2:*=mx.containers.utilityClasses.IConstraintLayout(target).constraintRows;
if (!loc2.length > 0 && !loc1.length > 0)
{
this.constraintRegionsInUse = false;
return;
}
this.constraintRegionsInUse = true;
var loc5:*=0;
var loc6:*=0;
var loc7:*=mx.core.Container(target).viewMetrics;
var loc8:*=mx.core.Container(target).width - loc7.left - loc7.right;
var loc9:*=mx.core.Container(target).height - loc7.top - loc7.bottom;
var loc10:*=[];
var loc11:*=[];
var loc12:*=[];
if (loc1.length > 0)
{
loc3 = 0;
while (loc3 < loc1.length)
{
loc13 = loc1[loc3];
if (isNaN(loc13.percentWidth))
{
if (!isNaN(loc13.width) && !loc13.mx_internal::contentSize)
{
loc10.push(loc13);
}
else
{
loc12.push(loc13);
loc13.mx_internal::contentSize = true;
}
}
else
{
loc11.push(loc13);
}
++loc3;
}
loc3 = 0;
while (loc3 < loc10.length)
{
loc13 = mx.containers.utilityClasses.ConstraintColumn(loc10[loc3]);
loc8 = loc8 - loc13.width;
++loc3;
}
if (loc12.length > 0)
{
if (this.colSpanChildren.length > 0)
{
this.colSpanChildren.sortOn("span");
loc4 = 0;
while (loc4 < this.colSpanChildren.length)
{
if ((loc19 = this.colSpanChildren[loc4]).span != 1)
{
loc8 = this.shareColumnSpace(loc19, loc8);
}
else
{
if (loc19.hcCol)
{
loc13 = mx.containers.utilityClasses.ConstraintColumn(loc1[loc1.indexOf(loc19.hcCol)]);
}
else if (loc19.leftCol)
{
loc13 = mx.containers.utilityClasses.ConstraintColumn(loc1[loc1.indexOf(loc19.leftCol)]);
}
else if (loc19.rightCol)
{
loc13 = mx.containers.utilityClasses.ConstraintColumn(loc1[loc1.indexOf(loc19.rightCol)]);
}
loc16 = loc19.child.getExplicitOrMeasuredWidth();
if (loc19.hcOffset)
{
loc16 = loc16 + loc19.hcOffset;
}
else
{
if (loc19.leftOffset)
{
loc16 = loc16 + loc19.leftOffset;
}
if (loc19.rightOffset)
{
loc16 = loc16 + loc19.rightOffset;
}
}
if (!isNaN(loc13.width))
{
loc16 = Math.max(loc13.width, loc16);
}
loc16 = this.bound(loc16, loc13.minWidth, loc13.maxWidth);
loc13.setActualWidth(loc16);
loc8 = loc8 - loc13.width;
}
++loc4;
}
this.colSpanChildren = [];
}
loc3 = 0;
while (loc3 < loc12.length)
{
if (!(loc13 = loc12[loc3]).width)
{
loc16 = this.bound(0, loc13.minWidth, 0);
loc13.setActualWidth(loc16);
}
++loc3;
}
}
loc18 = loc8;
loc3 = 0;
while (loc3 < loc11.length)
{
loc13 = mx.containers.utilityClasses.ConstraintColumn(loc11[loc3]);
if (loc18 <= 0)
{
loc16 = 0;
}
else
{
loc16 = Math.round(loc18 * loc13.percentWidth / 100);
}
loc16 = this.bound(loc16, loc13.minWidth, loc13.maxWidth);
loc13.setActualWidth(loc16);
loc8 = loc8 - loc16;
++loc3;
}
loc3 = 0;
while (loc3 < loc1.length)
{
(loc13 = mx.containers.utilityClasses.ConstraintColumn(loc1[loc3])).x = loc5;
loc5 = loc5 + loc13.width;
++loc3;
}
}
loc10 = [];
loc11 = [];
loc12 = [];
if (loc2.length > 0)
{
loc3 = 0;
while (loc3 < loc2.length)
{
loc14 = loc2[loc3];
if (isNaN(loc14.percentHeight))
{
if (!isNaN(loc14.height) && !loc14.mx_internal::contentSize)
{
loc10.push(loc14);
}
else
{
loc12.push(loc14);
loc14.mx_internal::contentSize = true;
}
}
else
{
loc11.push(loc14);
}
++loc3;
}
loc3 = 0;
while (loc3 < loc10.length)
{
loc14 = mx.containers.utilityClasses.ConstraintRow(loc10[loc3]);
loc9 = loc9 - loc14.height;
++loc3;
}
if (loc12.length > 0)
{
if (this.rowSpanChildren.length > 0)
{
this.rowSpanChildren.sortOn("span");
loc4 = 0;
while (loc4 < this.rowSpanChildren.length)
{
if ((loc20 = this.rowSpanChildren[loc4]).span != 1)
{
loc9 = this.shareRowSpace(loc20, loc9);
}
else
{
if (loc20.vcRow)
{
loc14 = mx.containers.utilityClasses.ConstraintRow(loc2[loc2.indexOf(loc20.vcRow)]);
}
else if (loc20.baselineRow)
{
loc14 = mx.containers.utilityClasses.ConstraintRow(loc2[loc2.indexOf(loc20.baselineRow)]);
}
else if (loc20.topRow)
{
loc14 = mx.containers.utilityClasses.ConstraintRow(loc2[loc2.indexOf(loc20.topRow)]);
}
else if (loc20.bottomRow)
{
loc14 = mx.containers.utilityClasses.ConstraintRow(loc2[loc2.indexOf(loc20.bottomRow)]);
}
loc17 = loc20.child.getExplicitOrMeasuredHeight();
if (loc20.baselineOffset)
{
loc17 = loc17 + loc20.baselineOffset;
}
else if (loc20.vcOffset)
{
loc17 = loc17 + loc20.vcOffset;
}
else
{
if (loc20.topOffset)
{
loc17 = loc17 + loc20.topOffset;
}
if (loc20.bottomOffset)
{
loc17 = loc17 + loc20.bottomOffset;
}
}
if (!isNaN(loc14.height))
{
loc17 = Math.max(loc14.height, loc17);
}
loc17 = this.bound(loc17, loc14.minHeight, loc14.maxHeight);
loc14.setActualHeight(loc17);
loc9 = loc9 - loc14.height;
}
++loc4;
}
this.rowSpanChildren = [];
}
loc3 = 0;
while (loc3 < loc12.length)
{
if (!(loc14 = mx.containers.utilityClasses.ConstraintRow(loc12[loc3])).height)
{
loc17 = this.bound(0, loc14.minHeight, 0);
loc14.setActualHeight(loc17);
}
++loc3;
}
}
loc18 = loc9;
loc3 = 0;
while (loc3 < loc11.length)
{
loc14 = mx.containers.utilityClasses.ConstraintRow(loc11[loc3]);
if (loc18 <= 0)
{
loc17 = 0;
}
else
{
loc17 = Math.round(loc18 * loc14.percentHeight / 100);
}
loc17 = this.bound(loc17, loc14.minHeight, loc14.maxHeight);
loc14.setActualHeight(loc17);
loc9 = loc9 - loc17;
++loc3;
}
loc3 = 0;
while (loc3 < loc2.length)
{
(loc14 = loc2[loc3]).y = loc6;
loc6 = loc6 + loc14.height;
++loc3;
}
}
return;
}
internal function shareColumnSpace(arg1:ContentColumnChild, arg2:Number):Number
{
var loc9:*=NaN;
var loc10:*=NaN;
var loc11:*=NaN;
var loc1:*=arg1.leftCol;
var loc2:*=arg1.rightCol;
var loc3:*=arg1.child;
var loc4:*=0;
var loc5:*=0;
var loc6:*=arg1.rightOffset ? arg1.rightOffset : 0;
var loc7:*=arg1.leftOffset ? arg1.leftOffset : 0;
if (loc1 && loc1.width)
{
loc4 = loc4 + loc1.width;
}
else if (loc2 && !loc1)
{
loc1 = mx.containers.utilityClasses.IConstraintLayout(target).constraintColumns[arg1.right - 2];
if (loc1 && loc1.width)
{
loc4 = loc4 + loc1.width;
}
}
if (loc2 && loc2.width)
{
loc5 = loc5 + loc2.width;
}
else if (loc1 && !loc2)
{
if ((loc2 = mx.containers.utilityClasses.IConstraintLayout(target).constraintColumns[arg1.left + 1]) && loc2.width)
{
loc5 = loc5 + loc2.width;
}
}
if (loc1 && isNaN(loc1.width))
{
loc1.setActualWidth(Math.max(0, loc1.maxWidth));
}
if (loc2 && isNaN(loc2.width))
{
loc2.setActualWidth(Math.max(0, loc2.maxWidth));
}
var loc8:*;
if (loc8 = loc3.getExplicitOrMeasuredWidth())
{
if (!arg1.leftCol)
{
if (loc8 > loc4)
{
loc10 = loc8 - loc4 + loc6;
}
else
{
loc10 = loc8 + loc6;
}
}
if (!arg1.rightCol)
{
if (loc8 > loc5)
{
loc9 = loc8 - loc5 + loc7;
}
else
{
loc9 = loc8 + loc7;
}
}
if (arg1.leftCol && arg1.rightCol)
{
if ((loc11 = loc8 / Number(arg1.span)) + loc7 < loc4)
{
loc9 = loc4;
loc10 = loc8 - (loc4 - loc7) + loc6;
}
else
{
loc9 = loc11 + loc7;
}
if (loc11 + loc6 < loc5)
{
loc10 = loc5;
loc9 = loc8 - (loc5 - loc6) + loc7;
}
else
{
loc10 = loc11 + loc6;
}
}
loc9 = this.bound(loc9, loc1.minWidth, loc1.maxWidth);
loc1.setActualWidth(loc9);
arg2 = arg2 - loc9;
loc10 = this.bound(loc10, loc2.minWidth, loc2.maxWidth);
loc2.setActualWidth(loc10);
arg2 = arg2 - loc10;
}
return arg2;
}
internal function shareRowSpace(arg1:ContentRowChild, arg2:Number):Number
{
var loc9:*=NaN;
var loc10:*=NaN;
var loc11:*=NaN;
var loc1:*=arg1.topRow;
var loc2:*=arg1.bottomRow;
var loc3:*=arg1.child;
var loc4:*=0;
var loc5:*=0;
var loc6:*=arg1.topOffset ? arg1.topOffset : 0;
var loc7:*=arg1.bottomOffset ? arg1.bottomOffset : 0;
if (loc1 && loc1.height)
{
loc4 = loc4 + loc1.height;
}
else if (loc2 && !loc1)
{
loc1 = mx.containers.utilityClasses.IConstraintLayout(target).constraintRows[arg1.bottom - 2];
if (loc1 && loc1.height)
{
loc4 = loc4 + loc1.height;
}
}
if (loc2 && loc2.height)
{
loc5 = loc5 + loc2.height;
}
else if (loc1 && !loc2)
{
if ((loc2 = mx.containers.utilityClasses.IConstraintLayout(target).constraintRows[arg1.top + 1]) && loc2.height)
{
loc5 = loc5 + loc2.height;
}
}
if (loc1 && isNaN(loc1.height))
{
loc1.setActualHeight(Math.max(0, loc1.maxHeight));
}
if (loc2 && isNaN(loc2.height))
{
loc2.setActualHeight(Math.max(0, loc2.height));
}
var loc8:*;
if (loc8 = loc3.getExplicitOrMeasuredHeight())
{
if (!arg1.topRow)
{
if (loc8 > loc4)
{
loc10 = loc8 - loc4 + loc7;
}
else
{
loc10 = loc8 + loc7;
}
}
if (!arg1.bottomRow)
{
if (loc8 > loc5)
{
loc9 = loc8 - loc5 + loc6;
}
else
{
loc9 = loc8 + loc6;
}
}
if (arg1.topRow && arg1.bottomRow)
{
if ((loc11 = loc8 / Number(arg1.span)) + loc6 < loc4)
{
loc9 = loc4;
loc10 = loc8 - (loc4 - loc6) + loc7;
}
else
{
loc9 = loc11 + loc6;
}
if (loc11 + loc7 < loc5)
{
loc10 = loc5;
loc9 = loc8 - (loc5 - loc7) + loc6;
}
else
{
loc10 = loc11 + loc7;
}
}
loc10 = this.bound(loc10, loc2.minHeight, loc2.maxHeight);
loc2.setActualHeight(loc10);
arg2 = arg2 - loc10;
loc9 = this.bound(loc9, loc1.minHeight, loc1.maxHeight);
loc1.setActualHeight(loc9);
arg2 = arg2 - loc9;
}
return arg2;
}
internal function getLayoutConstraints(arg1:mx.core.IUIComponent):LayoutConstraints
{
var loc1:*=arg1 as mx.core.IConstraintClient;
if (!loc1)
{
return null;
}
var loc2:*=new LayoutConstraints();
loc2.baseline = loc1.getConstraintValue("baseline");
loc2.bottom = loc1.getConstraintValue("bottom");
loc2.horizontalCenter = loc1.getConstraintValue("horizontalCenter");
loc2.left = loc1.getConstraintValue("left");
loc2.right = loc1.getConstraintValue("right");
loc2.top = loc1.getConstraintValue("top");
loc2.verticalCenter = loc1.getConstraintValue("verticalCenter");
return loc2;
}
internal function parseConstraintExp(arg1:String):Array
{
if (!arg1)
{
return null;
}
var loc1:*=arg1.replace(new RegExp(":", "g"), " ");
var loc2:*=loc1.split(new RegExp("\\s+"));
return loc2;
}
internal function target_childAddHandler(arg1:mx.events.ChildExistenceChangedEvent):void
{
flash.display.DisplayObject(arg1.relatedObject).addEventListener(mx.events.MoveEvent.MOVE, this.child_moveHandler);
return;
}
internal function target_childRemoveHandler(arg1:mx.events.ChildExistenceChangedEvent):void
{
flash.display.DisplayObject(arg1.relatedObject).removeEventListener(mx.events.MoveEvent.MOVE, this.child_moveHandler);
delete this.constraintCache[arg1.relatedObject];
return;
}
internal function child_moveHandler(arg1:mx.events.MoveEvent):void
{
if (arg1.target is mx.core.IUIComponent)
{
if (!mx.core.IUIComponent(arg1.target).includeInLayout)
{
return;
}
}
var loc1:*=super.target;
if (loc1)
{
loc1.invalidateSize();
loc1.invalidateDisplayList();
this._contentArea = null;
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
r = new flash.geom.Rectangle();
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var _contentArea:flash.geom.Rectangle;
internal var colSpanChildren:Array;
internal var rowSpanChildren:Array;
internal var constraintCache:flash.utils.Dictionary;
internal var constraintRegionsInUse:Boolean=false;
internal static var r:flash.geom.Rectangle;
}
}
import mx.core.*;
class ChildConstraintInfo extends Object
{
public function ChildConstraintInfo(arg1:Number, arg2:Number, arg3:Number, arg4:Number, arg5:Number, arg6:Number, arg7:Number, arg8:String=null, arg9:String=null, arg10:String=null, arg11:String=null, arg12:String=null, arg13:String=null, arg14:String=null)
{
super();
this.left = arg1;
this.right = arg2;
this.hc = arg3;
this.top = arg4;
this.bottom = arg5;
this.vc = arg6;
this.baseline = arg7;
this.leftBoundary = arg8;
this.rightBoundary = arg9;
this.hcBoundary = arg10;
this.topBoundary = arg11;
this.bottomBoundary = arg12;
this.vcBoundary = arg13;
this.baselineBoundary = arg14;
return;
}
public var left:Number;
public var right:Number;
public var hc:Number;
public var top:Number;
public var bottom:Number;
public var vc:Number;
public var baseline:Number;
public var leftBoundary:String;
public var rightBoundary:String;
public var hcBoundary:String;
public var topBoundary:String;
public var bottomBoundary:String;
public var vcBoundary:String;
public var baselineBoundary:String;
}
class ContentColumnChild extends Object
{
public function ContentColumnChild()
{
super();
return;
}
public var leftCol:mx.containers.utilityClasses.ConstraintColumn;
public var leftOffset:Number;
public var left:Number;
public var rightCol:mx.containers.utilityClasses.ConstraintColumn;
public var rightOffset:Number;
public var right:Number;
public var hcCol:mx.containers.utilityClasses.ConstraintColumn;
public var hcOffset:Number;
public var hc:Number;
public var child:mx.core.IUIComponent;
public var span:Number;
}
class ContentRowChild extends Object
{
public function ContentRowChild()
{
super();
return;
}
public var topRow:mx.containers.utilityClasses.ConstraintRow;
public var topOffset:Number;
public var top:Number;
public var bottomRow:mx.containers.utilityClasses.ConstraintRow;
public var bottomOffset:Number;
public var bottom:Number;
public var vcRow:mx.containers.utilityClasses.ConstraintRow;
public var vcOffset:Number;
public var vc:Number;
public var baselineRow:mx.containers.utilityClasses.ConstraintRow;
public var baselineOffset:Number;
public var baseline:Number;
public var child:mx.core.IUIComponent;
public var span:Number;
}
class LayoutConstraints extends Object
{
public function LayoutConstraints()
{
super();
return;
}
public var baseline:*;
public var bottom:*;
public var horizontalCenter:*;
public var left:*;
public var right:*;
public var top:*;
public var verticalCenter:*;
}
// class ConstraintColumn
package mx.containers.utilityClasses
{
import flash.events.*;
import mx.core.*;
use namespace mx_internal;
public class ConstraintColumn extends flash.events.EventDispatcher implements mx.core.IMXMLObject
{
public function ConstraintColumn()
{
super();
return;
}
public function get container():mx.core.IInvalidating
{
return this._container;
}
public function set container(arg1:mx.core.IInvalidating):void
{
this._container = arg1;
return;
}
public function get id():String
{
return this._id;
}
public function set id(arg1:String):void
{
this._id = arg1;
return;
}
public function get maxWidth():Number
{
return this._explicitMaxWidth;
}
public function set maxWidth(arg1:Number):void
{
if (this._explicitMaxWidth != arg1)
{
this._explicitMaxWidth = arg1;
if (this.container)
{
this.container.invalidateSize();
this.container.invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("maxWidthChanged"));
}
return;
}
public function get minWidth():Number
{
return this._explicitMinWidth;
}
public function set minWidth(arg1:Number):void
{
if (this._explicitMinWidth != arg1)
{
this._explicitMinWidth = arg1;
if (this.container)
{
this.container.invalidateSize();
this.container.invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("minWidthChanged"));
}
return;
}
public function get width():Number
{
return this.mx_internal::_width;
}
public function set width(arg1:Number):void
{
if (this.explicitWidth != arg1)
{
this.explicitWidth = arg1;
if (this.mx_internal::_width != arg1)
{
this.mx_internal::_width = arg1;
if (!isNaN(this.mx_internal::_width))
{
this.mx_internal::contentSize = false;
}
if (this.container)
{
this.container.invalidateSize();
this.container.invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("widthChanged"));
}
}
return;
}
public function get explicitWidth():Number
{
return this._explicitWidth;
}
public function set explicitWidth(arg1:Number):void
{
if (this._explicitWidth == arg1)
{
return;
}
if (!isNaN(arg1))
{
this._percentWidth = NaN;
}
this._explicitWidth = arg1;
if (this.container)
{
this.container.invalidateSize();
this.container.invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("explicitWidthChanged"));
return;
}
public function get percentWidth():Number
{
return this._percentWidth;
}
public function set percentWidth(arg1:Number):void
{
if (this._percentWidth == arg1)
{
return;
}
if (!isNaN(arg1))
{
this._explicitWidth = NaN;
}
this._percentWidth = arg1;
if (!isNaN(this._percentWidth))
{
this.mx_internal::contentSize = false;
}
if (this.container)
{
this.container.invalidateSize();
this.container.invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("percentWidthChanged"));
return;
}
public function get x():Number
{
return this._x;
}
public function set x(arg1:Number):void
{
if (arg1 != this._x)
{
this._x = arg1;
dispatchEvent(new flash.events.Event("xChanged"));
}
return;
}
public function initialized(arg1:Object, arg2:String):void
{
this.id = arg2;
if (!this.width && !this.percentWidth)
{
this.mx_internal::contentSize = true;
}
return;
}
public function setActualWidth(arg1:Number):void
{
if (this.mx_internal::_width != arg1)
{
this.mx_internal::_width = arg1;
dispatchEvent(new flash.events.Event("widthChanged"));
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
mx_internal var contentSize:Boolean=false;
internal var _container:mx.core.IInvalidating;
internal var _id:String;
internal var _explicitMaxWidth:Number;
internal var _explicitMinWidth:Number;
mx_internal var _width:Number;
internal var _explicitWidth:Number;
internal var _percentWidth:Number;
internal var _x:Number;
}
}
// class ConstraintRow
package mx.containers.utilityClasses
{
import flash.events.*;
import mx.core.*;
use namespace mx_internal;
public class ConstraintRow extends flash.events.EventDispatcher implements mx.core.IMXMLObject
{
public function ConstraintRow()
{
super();
return;
}
public function get container():mx.core.IInvalidating
{
return this._container;
}
public function set container(arg1:mx.core.IInvalidating):void
{
this._container = arg1;
return;
}
public function get height():Number
{
return this.mx_internal::_height;
}
public function set height(arg1:Number):void
{
if (this.explicitHeight != arg1)
{
this.explicitHeight = arg1;
if (this.mx_internal::_height != arg1)
{
this.mx_internal::_height = arg1;
if (!isNaN(this.mx_internal::_height))
{
this.mx_internal::contentSize = false;
}
if (this.container)
{
this.container.invalidateSize();
this.container.invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("heightChanged"));
}
}
return;
}
public function get explicitHeight():Number
{
return this._explicitHeight;
}
public function set explicitHeight(arg1:Number):void
{
if (this._explicitHeight == arg1)
{
return;
}
if (!isNaN(arg1))
{
this._percentHeight = NaN;
}
this._explicitHeight = arg1;
if (this.container)
{
this.container.invalidateSize();
this.container.invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("explicitHeightChanged"));
return;
}
public function get id():String
{
return this._id;
}
public function set id(arg1:String):void
{
this._id = arg1;
return;
}
public function get maxHeight():Number
{
return this._explicitMaxHeight;
}
public function set maxHeight(arg1:Number):void
{
if (this._explicitMaxHeight != arg1)
{
this._explicitMaxHeight = arg1;
if (this.container)
{
this.container.invalidateSize();
this.container.invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("maxHeightChanged"));
}
return;
}
public function get minHeight():Number
{
return this._explicitMinHeight;
}
public function set minHeight(arg1:Number):void
{
if (this._explicitMinHeight != arg1)
{
this._explicitMinHeight = arg1;
if (this.container)
{
this.container.invalidateSize();
this.container.invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("minHeightChanged"));
}
return;
}
public function get percentHeight():Number
{
return this._percentHeight;
}
public function set percentHeight(arg1:Number):void
{
if (this._percentHeight == arg1)
{
return;
}
if (!isNaN(arg1))
{
this._explicitHeight = NaN;
}
this._percentHeight = arg1;
if (!isNaN(this._percentHeight))
{
this.mx_internal::contentSize = false;
}
if (this.container)
{
this.container.invalidateSize();
this.container.invalidateDisplayList();
}
return;
}
public function get y():Number
{
return this._y;
}
public function set y(arg1:Number):void
{
if (arg1 != this._y)
{
this._y = arg1;
dispatchEvent(new flash.events.Event("yChanged"));
}
return;
}
public function initialized(arg1:Object, arg2:String):void
{
this.id = arg2;
if (!this.height && !this.percentHeight)
{
this.mx_internal::contentSize = true;
}
return;
}
public function setActualHeight(arg1:Number):void
{
if (this.mx_internal::_height != arg1)
{
this.mx_internal::_height = arg1;
dispatchEvent(new flash.events.Event("heightChanged"));
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
mx_internal var contentSize:Boolean=false;
internal var _container:mx.core.IInvalidating;
mx_internal var _height:Number;
internal var _explicitHeight:Number;
internal var _id:String;
internal var _explicitMaxHeight:Number;
internal var _explicitMinHeight:Number;
internal var _percentHeight:Number;
internal var _y:Number;
}
}
// class Flex
package mx.containers.utilityClasses
{
import mx.core.*;
use namespace mx_internal;
public class Flex extends Object
{
public function Flex()
{
super();
return;
}
public static function flexChildWidthsProportionally(arg1:mx.core.IChildList, arg2:Number, arg3:Number):Number
{
var loc3:*=null;
var loc4:*=null;
var loc5:*=null;
var loc6:*=0;
var loc8:*=NaN;
var loc9:*=NaN;
var loc10:*=NaN;
var loc11:*=NaN;
var loc1:*=arg2;
var loc2:*=0;
loc3 = [];
var loc7:*=arg1.numChildren;
loc6 = 0;
while (loc6 < loc7)
{
loc8 = (loc5 = mx.core.IUIComponent(arg1.getChildAt(loc6))).percentWidth;
loc9 = loc5.percentHeight;
if (!isNaN(loc9) && loc5.includeInLayout)
{
loc10 = Math.max(loc5.minHeight, Math.min(loc5.maxHeight, loc9 >= 100 ? arg3 : arg3 * loc9 / 100));
}
else
{
loc10 = loc5.getExplicitOrMeasuredHeight();
}
if (!isNaN(loc8) && loc5.includeInLayout)
{
loc2 = loc2 + loc8;
(loc4 = new mx.containers.utilityClasses.FlexChildInfo()).percent = loc8;
loc4.min = loc5.minWidth;
loc4.max = loc5.maxWidth;
loc4.height = loc10;
loc4.child = loc5;
loc3.push(loc4);
}
else
{
loc11 = loc5.getExplicitOrMeasuredWidth();
if (loc5.scaleX == 1 && loc5.scaleY == 1)
{
loc5.setActualSize(Math.floor(loc11), Math.floor(loc10));
}
else
{
loc5.setActualSize(loc11, loc10);
}
if (loc5.includeInLayout)
{
loc1 = loc1 - loc5.width;
}
}
++loc6;
}
if (loc2)
{
loc1 = flexChildrenProportionally(arg2, loc1, loc2, loc3);
loc7 = loc3.length;
loc6 = 0;
while (loc6 < loc7)
{
if ((loc5 = (loc4 = loc3[loc6]).child).scaleX == 1 && loc5.scaleY == 1)
{
loc5.setActualSize(Math.floor(loc4.size), Math.floor(loc4.height));
}
else
{
loc5.setActualSize(loc4.size, loc4.height);
}
++loc6;
}
distributeExtraWidth(arg1, arg2);
}
return loc1;
}
public static function flexChildHeightsProportionally(arg1:mx.core.IChildList, arg2:Number, arg3:Number):Number
{
var loc4:*=null;
var loc5:*=null;
var loc6:*=0;
var loc8:*=NaN;
var loc9:*=NaN;
var loc10:*=NaN;
var loc11:*=NaN;
var loc1:*=arg2;
var loc2:*=0;
var loc3:*=[];
var loc7:*=arg1.numChildren;
loc6 = 0;
while (loc6 < loc7)
{
loc8 = (loc5 = mx.core.IUIComponent(arg1.getChildAt(loc6))).percentWidth;
loc9 = loc5.percentHeight;
if (!isNaN(loc8) && loc5.includeInLayout)
{
loc10 = Math.max(loc5.minWidth, Math.min(loc5.maxWidth, loc8 >= 100 ? arg3 : arg3 * loc8 / 100));
}
else
{
loc10 = loc5.getExplicitOrMeasuredWidth();
}
if (!isNaN(loc9) && loc5.includeInLayout)
{
loc2 = loc2 + loc9;
(loc4 = new mx.containers.utilityClasses.FlexChildInfo()).percent = loc9;
loc4.min = loc5.minHeight;
loc4.max = loc5.maxHeight;
loc4.width = loc10;
loc4.child = loc5;
loc3.push(loc4);
}
else
{
loc11 = loc5.getExplicitOrMeasuredHeight();
if (loc5.scaleX == 1 && loc5.scaleY == 1)
{
loc5.setActualSize(Math.floor(loc10), Math.floor(loc11));
}
else
{
loc5.setActualSize(loc10, loc11);
}
if (loc5.includeInLayout)
{
loc1 = loc1 - loc5.height;
}
}
++loc6;
}
if (loc2)
{
loc1 = flexChildrenProportionally(arg2, loc1, loc2, loc3);
loc7 = loc3.length;
loc6 = 0;
while (loc6 < loc7)
{
if ((loc5 = (loc4 = loc3[loc6]).child).scaleX == 1 && loc5.scaleY == 1)
{
loc5.setActualSize(Math.floor(loc4.width), Math.floor(loc4.size));
}
else
{
loc5.setActualSize(loc4.width, loc4.size);
}
++loc6;
}
distributeExtraHeight(arg1, arg2);
}
return loc1;
}
public static function flexChildrenProportionally(arg1:Number, arg2:Number, arg3:Number, arg4:Array):Number
{
var loc2:*=NaN;
var loc3:*=false;
var loc5:*=NaN;
var loc6:*=0;
var loc7:*=null;
var loc8:*=NaN;
var loc9:*=NaN;
var loc10:*=NaN;
var loc1:*=arg4.length;
var loc4:*;
if ((loc4 = arg2 - arg1 * arg3 / 100) > 0)
{
arg2 = arg2 - loc4;
}
do
{
loc2 = 0;
loc3 = true;
loc5 = arg2 / arg3;
loc6 = 0;
while (loc6 < loc1)
{
if ((loc8 = (loc7 = arg4[loc6]).percent * loc5) < loc7.min)
{
loc9 = loc7.min;
loc7.size = loc9;
arg4[loc6] = arg4[--loc1];
arg4[loc1] = loc7;
arg3 = arg3 - loc7.percent;
arg2 = arg2 - loc9;
loc3 = false;
break;
}
else if (loc8 > loc7.max)
{
loc10 = loc7.max;
loc7.size = loc10;
arg4[loc6] = arg4[--loc1];
arg4[loc1] = loc7;
arg3 = arg3 - loc7.percent;
arg2 = arg2 - loc10;
loc3 = false;
break;
}
else
{
loc7.size = loc8;
loc2 = loc2 + loc8;
}
++loc6;
}
}
while (!loc3);
return Math.max(0, Math.floor(arg2 - loc2));
}
public static function distributeExtraHeight(arg1:mx.core.IChildList, arg2:Number):void
{
var loc3:*=0;
var loc4:*=NaN;
var loc7:*=null;
var loc8:*=NaN;
var loc9:*=NaN;
var loc1:*=arg1.numChildren;
var loc2:*=false;
var loc5:*=arg2;
var loc6:*=0;
loc3 = 0;
while (loc3 < loc1)
{
if ((loc7 = mx.core.IUIComponent(arg1.getChildAt(loc3))).includeInLayout)
{
loc8 = loc7.height;
loc4 = loc7.percentHeight;
loc6 = loc6 + loc8;
if (!isNaN(loc4))
{
if ((loc9 = Math.ceil(loc4 / 100 * arg2)) > loc8)
{
loc2 = true;
}
}
}
++loc3;
}
if (!loc2)
{
return;
}
loc5 = loc5 - loc6;
var loc10:*=true;
while (loc10 && loc5 >= 1)
{
loc10 = false;
loc3 = 0;
while (loc3 < loc1)
{
loc8 = (loc7 = mx.core.IUIComponent(arg1.getChildAt(loc3))).height;
loc4 = loc7.percentHeight;
if (!isNaN(loc4) && loc7.includeInLayout && loc8 < loc7.maxHeight)
{
if ((loc9 = Math.ceil(loc4 / 100 * arg2)) > loc8)
{
loc7.setActualSize(loc7.width, loc8 + 1);
--loc5;
loc10 = true;
if (loc5 == 0)
{
return;
}
}
}
++loc3;
}
}
return;
}
public static function distributeExtraWidth(arg1:mx.core.IChildList, arg2:Number):void
{
var loc3:*=0;
var loc4:*=NaN;
var loc7:*=null;
var loc8:*=NaN;
var loc9:*=NaN;
var loc1:*=arg1.numChildren;
var loc2:*=false;
var loc5:*=arg2;
var loc6:*=0;
loc3 = 0;
while (loc3 < loc1)
{
if ((loc7 = mx.core.IUIComponent(arg1.getChildAt(loc3))).includeInLayout)
{
loc8 = loc7.width;
loc4 = loc7.percentWidth;
loc6 = loc6 + loc8;
if (!isNaN(loc4))
{
if ((loc9 = Math.ceil(loc4 / 100 * arg2)) > loc8)
{
loc2 = true;
}
}
}
++loc3;
}
if (!loc2)
{
return;
}
loc5 = loc5 - loc6;
var loc10:*=true;
while (loc10 && loc5 >= 1)
{
loc10 = false;
loc3 = 0;
while (loc3 < loc1)
{
loc8 = (loc7 = mx.core.IUIComponent(arg1.getChildAt(loc3))).width;
loc4 = loc7.percentWidth;
if (!isNaN(loc4) && loc7.includeInLayout && loc8 < loc7.maxWidth)
{
if ((loc9 = Math.ceil(loc4 / 100 * arg2)) > loc8)
{
loc7.setActualSize(loc8 + 1, loc7.height);
--loc5;
loc10 = true;
if (loc5 == 0)
{
return;
}
}
}
++loc3;
}
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class FlexChildInfo
package mx.containers.utilityClasses
{
import mx.core.*;
use namespace mx_internal;
public class FlexChildInfo extends Object
{
public function FlexChildInfo()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public var child:mx.core.IUIComponent;
public var size:Number=0;
public var preferred:Number=0;
public var flex:Number=0;
public var percent:Number;
public var min:Number;
public var max:Number;
public var width:Number;
public var height:Number;
}
}
// class IConstraintLayout
package mx.containers.utilityClasses
{
public interface IConstraintLayout
{
function get constraintColumns():Array;
function set constraintColumns(arg1:Array):void;
function get constraintRows():Array;
function set constraintRows(arg1:Array):void;
}
}
// class Layout
package mx.containers.utilityClasses
{
import mx.core.*;
import mx.resources.*;
use namespace mx_internal;
public class Layout extends Object
{
public function Layout()
{
this.resourceManager = mx.resources.ResourceManager.getInstance();
super();
return;
}
public function get target():mx.core.Container
{
return this._target;
}
public function set target(arg1:mx.core.Container):void
{
this._target = arg1;
return;
}
public function measure():void
{
return;
}
public function updateDisplayList(arg1:Number, arg2:Number):void
{
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
protected var resourceManager:mx.resources.IResourceManager;
internal var _target:mx.core.Container;
}
}
// class PostScaleAdapter
package mx.containers.utilityClasses
{
import flash.accessibility.*;
import flash.display.*;
import flash.events.*;
import flash.geom.*;
import mx.core.*;
import mx.managers.*;
public class PostScaleAdapter extends Object implements mx.core.IUIComponent, mx.core.IConstraintClient, mx.core.IInvalidating
{
public function PostScaleAdapter(arg1:mx.core.IUIComponent)
{
super();
this.obj = arg1;
return;
}
public static function getCompatibleIUIComponent(arg1:Object):mx.core.IUIComponent
{
var loc1:*=arg1 as mx.core.IUIComponent;
if (!loc1)
{
return null;
}
if (loc1.scaleX == 1 && loc1.scaleY == 1 || mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
return loc1;
}
if (loc1 is mx.containers.utilityClasses.PostScaleAdapter)
{
return loc1;
}
return new PostScaleAdapter(loc1);
}
public function get baselinePosition():Number
{
return this.obj.baselinePosition;
}
public function get document():Object
{
return this.obj.document;
}
public function set document(arg1:Object):void
{
this.obj.document = arg1;
return;
}
public function get enabled():Boolean
{
return this.obj.enabled;
}
public function set enabled(arg1:Boolean):void
{
this.obj.enabled = arg1;
return;
}
public function get explicitHeight():Number
{
return this.obj.explicitHeight * Math.abs(this.obj.scaleY);
}
public function set explicitHeight(arg1:Number):void
{
this.obj.explicitHeight = this.obj.scaleY != 0 ? arg1 / Math.abs(this.obj.scaleY) : 0;
return;
}
public function get explicitMaxHeight():Number
{
return this.obj.explicitMaxHeight * Math.abs(this.obj.scaleY);
}
public function get explicitMaxWidth():Number
{
return this.obj.explicitMaxWidth * Math.abs(this.obj.scaleX);
}
public function get explicitMinHeight():Number
{
return this.obj.explicitMinHeight * Math.abs(this.obj.scaleY);
}
public function get explicitMinWidth():Number
{
return this.obj.explicitMinWidth * Math.abs(this.obj.scaleX);
}
public function get explicitWidth():Number
{
return this.obj.explicitWidth * Math.abs(this.obj.scaleX);
}
public function set explicitWidth(arg1:Number):void
{
this.obj.explicitWidth = this.obj.scaleX != 0 ? arg1 / Math.abs(this.obj.scaleX) : 0;
return;
}
public function get focusPane():flash.display.Sprite
{
return this.obj.focusPane;
}
public function set focusPane(arg1:flash.display.Sprite):void
{
this.obj.focusPane = arg1;
return;
}
public function get includeInLayout():Boolean
{
return this.obj.includeInLayout;
}
public function set includeInLayout(arg1:Boolean):void
{
this.obj.includeInLayout = arg1;
return;
}
public function get isPopUp():Boolean
{
return this.obj.isPopUp;
}
public function set isPopUp(arg1:Boolean):void
{
this.obj.isPopUp = arg1;
return;
}
public function get maxHeight():Number
{
return this.obj.maxHeight * Math.abs(this.obj.scaleY);
}
public function get maxWidth():Number
{
return this.obj.maxWidth * Math.abs(this.obj.scaleX);
}
public function get measuredMinHeight():Number
{
return this.obj.measuredMinHeight * Math.abs(this.obj.scaleY);
}
public function set measuredMinHeight(arg1:Number):void
{
this.obj.measuredMinHeight = this.obj.scaleY != 0 ? arg1 / Math.abs(this.obj.scaleY) : 0;
return;
}
public function get measuredMinWidth():Number
{
return this.obj.measuredMinWidth * Math.abs(this.obj.scaleX);
}
public function set measuredMinWidth(arg1:Number):void
{
this.obj.measuredMinWidth = this.obj.scaleX != 0 ? arg1 / Math.abs(this.obj.scaleX) : 0;
return;
}
public function get minHeight():Number
{
return this.obj.minHeight * Math.abs(this.obj.scaleY);
}
public function get minWidth():Number
{
return this.obj.minWidth * Math.abs(this.obj.scaleX);
}
public function get owner():flash.display.DisplayObjectContainer
{
return this.obj.owner;
}
public function set owner(arg1:flash.display.DisplayObjectContainer):void
{
this.obj.owner = arg1;
return;
}
public function get percentHeight():Number
{
return this.obj.percentHeight;
}
public function set percentHeight(arg1:Number):void
{
this.obj.percentHeight = arg1;
return;
}
public function get percentWidth():Number
{
return this.obj.percentWidth;
}
public function set percentWidth(arg1:Number):void
{
this.obj.percentWidth = arg1;
return;
}
public function get systemManager():mx.managers.ISystemManager
{
return this.obj.systemManager;
}
public function set systemManager(arg1:mx.managers.ISystemManager):void
{
this.obj.systemManager = arg1;
return;
}
public function get tweeningProperties():Array
{
return this.obj.tweeningProperties;
}
public function set tweeningProperties(arg1:Array):void
{
this.obj.tweeningProperties = arg1;
return;
}
public function initialize():void
{
this.obj.initialize();
return;
}
public function parentChanged(arg1:flash.display.DisplayObjectContainer):void
{
this.obj.parentChanged(arg1);
return;
}
public function getExplicitOrMeasuredWidth():Number
{
return this.obj.getExplicitOrMeasuredWidth() * Math.abs(this.obj.scaleX);
}
public function getExplicitOrMeasuredHeight():Number
{
return this.obj.getExplicitOrMeasuredHeight() * Math.abs(this.obj.scaleY);
}
public function setVisible(arg1:Boolean, arg2:Boolean=false):void
{
this.obj.setVisible(arg1, arg2);
return;
}
public function owns(arg1:flash.display.DisplayObject):Boolean
{
return this.obj.owns(arg1);
}
public function get measuredHeight():Number
{
return this.obj.measuredHeight * Math.abs(this.obj.scaleY);
}
public function get measuredWidth():Number
{
return this.obj.measuredWidth * Math.abs(this.obj.scaleX);
}
public function move(arg1:Number, arg2:Number):void
{
this.obj.move(arg1, arg2);
return;
}
public function setActualSize(arg1:Number, arg2:Number):void
{
this.obj.setActualSize(this.obj.scaleX != 0 ? arg1 / Math.abs(this.obj.scaleX) : 0, this.obj.scaleY != 0 ? arg2 / Math.abs(this.obj.scaleY) : 0);
return;
}
public function get root():flash.display.DisplayObject
{
return this.obj.root;
}
public function get stage():flash.display.Stage
{
return this.obj.stage;
}
public function get name():String
{
return this.obj.name;
}
public function set name(arg1:String):void
{
this.obj.name = arg1;
return;
}
public function get parent():flash.display.DisplayObjectContainer
{
return this.obj.parent;
}
public function get mask():flash.display.DisplayObject
{
return this.obj.mask;
}
public function set mask(arg1:flash.display.DisplayObject):void
{
this.obj.mask = arg1;
return;
}
public function get visible():Boolean
{
return this.obj.visible;
}
public function set visible(arg1:Boolean):void
{
this.obj.visible = arg1;
return;
}
public function get x():Number
{
return this.obj.x;
}
public function set x(arg1:Number):void
{
this.obj.x = arg1;
return;
}
public function get y():Number
{
return this.obj.y;
}
public function set y(arg1:Number):void
{
this.obj.y = arg1;
return;
}
public function get scaleX():Number
{
return this.obj.scaleX;
}
public function set scaleX(arg1:Number):void
{
this.obj.scaleX = arg1;
return;
}
public function get scaleY():Number
{
return this.obj.scaleY;
}
public function set scaleY(arg1:Number):void
{
this.obj.scaleY = arg1;
return;
}
public function get mouseX():Number
{
return this.obj.mouseX;
}
public function get mouseY():Number
{
return this.obj.mouseY;
}
public function get rotation():Number
{
return this.obj.rotation;
}
public function set rotation(arg1:Number):void
{
this.obj.rotation = arg1;
return;
}
public function get alpha():Number
{
return this.obj.alpha;
}
public function set alpha(arg1:Number):void
{
this.obj.alpha = arg1;
return;
}
public function get width():Number
{
return this.obj.width * Math.abs(this.obj.scaleX);
}
public function set width(arg1:Number):void
{
this.obj.width = this.obj.scaleX != 0 ? arg1 / Math.abs(this.obj.scaleX) : 0;
return;
}
public function get height():Number
{
return this.obj.height * Math.abs(this.obj.scaleY);
}
public function set height(arg1:Number):void
{
this.obj.height = this.obj.scaleY != 0 ? arg1 / Math.abs(this.obj.scaleY) : 0;
return;
}
public function get cacheAsBitmap():Boolean
{
return this.obj.cacheAsBitmap;
}
public function set cacheAsBitmap(arg1:Boolean):void
{
this.obj.cacheAsBitmap = arg1;
return;
}
public function get opaqueBackground():Object
{
return this.obj.opaqueBackground;
}
public function set opaqueBackground(arg1:Object):void
{
this.obj.opaqueBackground = arg1;
return;
}
public function get scrollRect():flash.geom.Rectangle
{
return this.obj.scrollRect;
}
public function set scrollRect(arg1:flash.geom.Rectangle):void
{
this.obj.scrollRect = arg1;
return;
}
public function get filters():Array
{
return this.obj.filters;
}
public function set filters(arg1:Array):void
{
this.obj.filters = arg1;
return;
}
public function get blendMode():String
{
return this.obj.blendMode;
}
public function set blendMode(arg1:String):void
{
this.obj.blendMode = arg1;
return;
}
public function get transform():flash.geom.Transform
{
return this.obj.transform;
}
public function set transform(arg1:flash.geom.Transform):void
{
this.obj.transform = arg1;
return;
}
public function get scale9Grid():flash.geom.Rectangle
{
return this.obj.scale9Grid;
}
public function set scale9Grid(arg1:flash.geom.Rectangle):void
{
this.obj.scale9Grid = arg1;
return;
}
public function globalToLocal(arg1:flash.geom.Point):flash.geom.Point
{
return this.obj.globalToLocal(arg1);
}
public function localToGlobal(arg1:flash.geom.Point):flash.geom.Point
{
return this.obj.localToGlobal(arg1);
}
public function getBounds(arg1:flash.display.DisplayObject):flash.geom.Rectangle
{
return this.obj.getBounds(arg1);
}
public function getRect(arg1:flash.display.DisplayObject):flash.geom.Rectangle
{
return this.obj.getRect(arg1);
}
public function get loaderInfo():flash.display.LoaderInfo
{
return this.obj.loaderInfo;
}
public function hitTestObject(arg1:flash.display.DisplayObject):Boolean
{
return arg1.hitTestObject(arg1);
}
public function hitTestPoint(arg1:Number, arg2:Number, arg3:Boolean=false):Boolean
{
return this.hitTestPoint(arg1, arg2, arg3);
}
public function get accessibilityProperties():flash.accessibility.AccessibilityProperties
{
return this.obj.accessibilityProperties;
}
public function set accessibilityProperties(arg1:flash.accessibility.AccessibilityProperties):void
{
this.obj.accessibilityProperties = arg1;
return;
}
public function addEventListener(arg1:String, arg2:Function, arg3:Boolean=false, arg4:int=0, arg5:Boolean=false):void
{
this.obj.addEventListener(arg1, arg2, arg3, arg4, arg5);
return;
}
public function dispatchEvent(arg1:flash.events.Event):Boolean
{
return this.obj.dispatchEvent(arg1);
}
public function hasEventListener(arg1:String):Boolean
{
return this.obj.hasEventListener(arg1);
}
public function removeEventListener(arg1:String, arg2:Function, arg3:Boolean=false):void
{
this.obj.removeEventListener(arg1, arg2, arg3);
return;
}
public function willTrigger(arg1:String):Boolean
{
return this.obj.willTrigger(arg1);
}
public function getConstraintValue(arg1:String):*
{
if (this.obj is mx.core.IConstraintClient)
{
return mx.core.IConstraintClient(this.obj).getConstraintValue(arg1);
}
return null;
}
public function setConstraintValue(arg1:String, arg2:*):void
{
if (this.obj is mx.core.IConstraintClient)
{
mx.core.IConstraintClient(this.obj).setConstraintValue(arg1, arg2);
}
else
{
throw new Error("PostScaleAdapter can\'t set constraint value, underlying object is not an IConstraintClient");
}
return;
}
public function invalidateProperties():void
{
if (this.obj is mx.core.IInvalidating)
{
mx.core.IInvalidating(this.obj).invalidateProperties();
}
return;
}
public function invalidateSize():void
{
if (this.obj is mx.core.IInvalidating)
{
mx.core.IInvalidating(this.obj).invalidateSize();
}
return;
}
public function invalidateDisplayList():void
{
if (this.obj is mx.core.IInvalidating)
{
mx.core.IInvalidating(this.obj).invalidateDisplayList();
}
return;
}
public function validateNow():void
{
if (this.obj is mx.core.IInvalidating)
{
mx.core.IInvalidating(this.obj).validateNow();
}
return;
}
internal var obj:mx.core.IUIComponent;
}
}
// class BoxDirection
package mx.containers
{
import mx.core.*;
use namespace mx_internal;
public final class BoxDirection extends Object
{
public function BoxDirection()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const HORIZONTAL:String="horizontal";
public static const VERTICAL:String="vertical";
}
}
// package controls
// package dataGridClasses
// class DataGridListData
package mx.controls.dataGridClasses
{
import mx.controls.listClasses.*;
import mx.core.*;
use namespace mx_internal;
public class DataGridListData extends mx.controls.listClasses.BaseListData
{
public function DataGridListData(arg1:String, arg2:String, arg3:int, arg4:String, arg5:mx.core.IUIComponent, arg6:int=0)
{
super(arg1, arg4, arg5, arg6, arg3);
this.dataField = arg2;
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public var dataField:String;
}
}
// package listClasses
// class BaseListData
package mx.controls.listClasses
{
import flash.events.*;
import mx.core.*;
use namespace mx_internal;
public class BaseListData extends flash.events.EventDispatcher
{
public function BaseListData(arg1:String, arg2:String, arg3:mx.core.IUIComponent, arg4:int=0, arg5:int=0)
{
super();
this.label = arg1;
this.uid = arg2;
this.owner = arg3;
this.rowIndex = arg4;
this.columnIndex = arg5;
return;
}
public function get uid():String
{
return this._uid;
}
public function set uid(arg1:String):void
{
this._uid = arg1;
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public var columnIndex:int;
public var label:String;
public var owner:mx.core.IUIComponent;
public var rowIndex:int;
internal var _uid:String;
}
}
// class IDropInListItemRenderer
package mx.controls.listClasses
{
public interface IDropInListItemRenderer
{
function get listData():mx.controls.listClasses.BaseListData;
function set listData(arg1:mx.controls.listClasses.BaseListData):void;
}
}
// class IListItemRenderer
package mx.controls.listClasses
{
import flash.events.*;
import mx.core.*;
import mx.managers.*;
import mx.styles.*;
public interface IListItemRenderer extends mx.core.IDataRenderer, flash.events.IEventDispatcher, mx.core.IFlexDisplayObject, mx.managers.ILayoutManagerClient, mx.styles.ISimpleStyleClient, mx.core.IUIComponent
{
}
}
// package scrollClasses
// class ScrollBar
package mx.controls.scrollClasses
{
import flash.display.*;
import flash.events.*;
import flash.geom.*;
import flash.ui.*;
import flash.utils.*;
import mx.controls.*;
import mx.core.*;
import mx.events.*;
import mx.styles.*;
use namespace mx_internal;
public class ScrollBar extends mx.core.UIComponent
{
public function ScrollBar()
{
super();
return;
}
protected override function updateDisplayList(arg1:Number, arg2:Number):void
{
if (mx_internal::$height == 1)
{
return;
}
if (!this.mx_internal::upArrow)
{
return;
}
super.updateDisplayList(arg1, arg2);
if (cacheAsBitmap)
{
cacheHeuristic = false;
if (this.mx_internal::scrollThumb)
{
this.mx_internal::scrollThumb.cacheHeuristic = false;
}
}
this.mx_internal::upArrow.setActualSize(this.mx_internal::upArrow.getExplicitOrMeasuredWidth(), this.mx_internal::upArrow.getExplicitOrMeasuredHeight());
this.mx_internal::upArrow.move((this.mx_internal::virtualWidth - this.mx_internal::upArrow.width) / 2, 0);
this.mx_internal::scrollTrack.setActualSize(this.mx_internal::scrollTrack.getExplicitOrMeasuredWidth(), this.mx_internal::virtualHeight);
this.mx_internal::scrollTrack.x = (this.mx_internal::virtualWidth - this.mx_internal::scrollTrack.width) / 2;
this.mx_internal::scrollTrack.y = 0;
this.mx_internal::downArrow.setActualSize(this.mx_internal::downArrow.getExplicitOrMeasuredWidth(), this.mx_internal::downArrow.getExplicitOrMeasuredHeight());
this.mx_internal::downArrow.move((this.mx_internal::virtualWidth - this.mx_internal::downArrow.width) / 2, this.mx_internal::virtualHeight - this.mx_internal::downArrow.getExplicitOrMeasuredHeight());
this.setScrollProperties(this.pageSize, this.minScrollPosition, this.maxScrollPosition, this._pageScrollSize);
this.scrollPosition = this._scrollPosition;
return;
}
public function setScrollProperties(arg1:Number, arg2:Number, arg3:Number, arg4:Number=0):void
{
var loc1:*=NaN;
this.pageSize = arg1;
this._pageScrollSize = arg4 > 0 ? arg4 : arg1;
this.minScrollPosition = Math.max(arg2, 0);
this.maxScrollPosition = Math.max(arg3, 0);
this._scrollPosition = Math.max(this.minScrollPosition, this._scrollPosition);
this._scrollPosition = Math.min(this.maxScrollPosition, this._scrollPosition);
if (this.maxScrollPosition - this.minScrollPosition > 0 && enabled)
{
this.mx_internal::upArrow.enabled = true;
this.mx_internal::downArrow.enabled = true;
this.mx_internal::scrollTrack.enabled = true;
addEventListener(flash.events.MouseEvent.MOUSE_DOWN, this.scrollTrack_mouseDownHandler);
addEventListener(flash.events.MouseEvent.MOUSE_OVER, this.scrollTrack_mouseOverHandler);
addEventListener(flash.events.MouseEvent.MOUSE_OUT, this.scrollTrack_mouseOutHandler);
if (!this.mx_internal::scrollThumb)
{
this.mx_internal::scrollThumb = new mx.controls.scrollClasses.ScrollThumb();
this.mx_internal::scrollThumb.focusEnabled = false;
addChildAt(this.mx_internal::scrollThumb, getChildIndex(this.mx_internal::downArrow));
this.mx_internal::scrollThumb.styleName = new mx.styles.StyleProxy(this, this.thumbStyleFilters);
this.mx_internal::scrollThumb.mx_internal::upSkinName = "thumbUpSkin";
this.mx_internal::scrollThumb.mx_internal::overSkinName = "thumbOverSkin";
this.mx_internal::scrollThumb.mx_internal::downSkinName = "thumbDownSkin";
this.mx_internal::scrollThumb.mx_internal::iconName = "thumbIcon";
this.mx_internal::scrollThumb.mx_internal::skinName = "thumbSkin";
}
if ((loc1 = this.trackHeight < 0 ? 0 : Math.round(arg1 / (this.maxScrollPosition - this.minScrollPosition + arg1) * this.trackHeight)) < this.mx_internal::scrollThumb.minHeight)
{
if (this.trackHeight < this.mx_internal::scrollThumb.minHeight)
{
this.mx_internal::scrollThumb.visible = false;
}
else
{
loc1 = this.mx_internal::scrollThumb.minHeight;
this.mx_internal::scrollThumb.visible = true;
this.mx_internal::scrollThumb.setActualSize(this.mx_internal::scrollThumb.measuredWidth, this.mx_internal::scrollThumb.minHeight);
}
}
else
{
this.mx_internal::scrollThumb.visible = true;
this.mx_internal::scrollThumb.setActualSize(this.mx_internal::scrollThumb.measuredWidth, loc1);
}
this.mx_internal::scrollThumb.mx_internal::setRange(this.mx_internal::upArrow.getExplicitOrMeasuredHeight() + 0, this.mx_internal::virtualHeight - this.mx_internal::downArrow.getExplicitOrMeasuredHeight() - this.mx_internal::scrollThumb.height, this.minScrollPosition, this.maxScrollPosition);
this.scrollPosition = Math.max(Math.min(this.scrollPosition, this.maxScrollPosition), this.minScrollPosition);
}
else
{
this.mx_internal::upArrow.enabled = false;
this.mx_internal::downArrow.enabled = false;
this.mx_internal::scrollTrack.enabled = false;
if (this.mx_internal::scrollThumb)
{
this.mx_internal::scrollThumb.visible = false;
}
}
return;
}
mx_internal function lineScroll(arg1:int):void
{
var loc3:*=NaN;
var loc4:*=null;
var loc1:*=this._lineScrollSize;
var loc2:*=this._scrollPosition + arg1 * loc1;
if (loc2 > this.maxScrollPosition)
{
loc2 = this.maxScrollPosition;
}
else if (loc2 < this.minScrollPosition)
{
loc2 = this.minScrollPosition;
}
if (loc2 != this.scrollPosition)
{
loc3 = this.scrollPosition;
this.scrollPosition = loc2;
loc4 = arg1 < 0 ? this.mx_internal::lineMinusDetail : this.mx_internal::linePlusDetail;
this.mx_internal::dispatchScrollEvent(loc3, loc4);
}
return;
}
mx_internal function pageScroll(arg1:int):void
{
var loc3:*=NaN;
var loc4:*=null;
var loc1:*=this._pageScrollSize == 0 ? this.pageSize : this._pageScrollSize;
var loc2:*=this._scrollPosition + arg1 * loc1;
if (loc2 > this.maxScrollPosition)
{
loc2 = this.maxScrollPosition;
}
else if (loc2 < this.minScrollPosition)
{
loc2 = this.minScrollPosition;
}
if (loc2 != this.scrollPosition)
{
loc3 = this.scrollPosition;
this.scrollPosition = loc2;
loc4 = arg1 < 0 ? this.mx_internal::pageMinusDetail : this.mx_internal::pagePlusDetail;
this.mx_internal::dispatchScrollEvent(loc3, loc4);
}
return;
}
mx_internal function dispatchScrollEvent(arg1:Number, arg2:String):void
{
var loc1:*=new mx.events.ScrollEvent(mx.events.ScrollEvent.SCROLL);
loc1.detail = arg2;
loc1.position = this.scrollPosition;
loc1.delta = this.scrollPosition - arg1;
loc1.direction = this.direction;
dispatchEvent(loc1);
return;
}
mx_internal function isScrollBarKey(arg1:uint):Boolean
{
var loc1:*=NaN;
if (arg1 == flash.ui.Keyboard.HOME)
{
if (this.scrollPosition != 0)
{
loc1 = this.scrollPosition;
this.scrollPosition = 0;
this.mx_internal::dispatchScrollEvent(loc1, this.minDetail);
}
return true;
}
if (arg1 == flash.ui.Keyboard.END)
{
if (this.scrollPosition < this.maxScrollPosition)
{
loc1 = this.scrollPosition;
this.scrollPosition = this.maxScrollPosition;
this.mx_internal::dispatchScrollEvent(loc1, this.maxDetail);
}
return true;
}
return false;
}
internal function upArrow_buttonDownHandler(arg1:mx.events.FlexEvent):void
{
if (isNaN(this.mx_internal::oldPosition))
{
this.mx_internal::oldPosition = this.scrollPosition;
}
this.mx_internal::lineScroll(-1);
return;
}
public function get direction():String
{
return this._direction;
}
internal function downArrow_buttonDownHandler(arg1:mx.events.FlexEvent):void
{
if (isNaN(this.mx_internal::oldPosition))
{
this.mx_internal::oldPosition = this.scrollPosition;
}
this.mx_internal::lineScroll(1);
return;
}
internal function scrollTrack_mouseOverHandler(arg1:flash.events.MouseEvent):void
{
if (!(arg1.target == this || arg1.target == this.mx_internal::scrollTrack) || !enabled)
{
return;
}
if (this.trackScrolling)
{
this.trackScrollTimer.start();
}
return;
}
internal function scrollTrack_mouseOutHandler(arg1:flash.events.MouseEvent):void
{
if (this.trackScrolling && enabled)
{
this.trackScrollTimer.stop();
}
return;
}
internal function scrollTrack_mouseDownHandler(arg1:flash.events.MouseEvent):void
{
if (!(arg1.target == this || arg1.target == this.mx_internal::scrollTrack) || !enabled)
{
return;
}
this.trackScrolling = true;
var loc1:*=systemManager.getSandboxRoot();
loc1.addEventListener(flash.events.MouseEvent.MOUSE_UP, this.scrollTrack_mouseUpHandler, true);
loc1.addEventListener(flash.events.MouseEvent.MOUSE_MOVE, this.scrollTrack_mouseMoveHandler, true);
loc1.addEventListener(mx.events.SandboxMouseEvent.MOUSE_UP_SOMEWHERE, this.scrollTrack_mouseLeaveHandler);
systemManager.deployMouseShields(true);
var loc2:*=new flash.geom.Point(arg1.localX, arg1.localY);
loc2 = arg1.target.localToGlobal(loc2);
loc2 = globalToLocal(loc2);
this.trackPosition = loc2.y;
if (isNaN(this.mx_internal::oldPosition))
{
this.mx_internal::oldPosition = this.scrollPosition;
}
this.trackScrollRepeatDirection = this.mx_internal::scrollThumb.y + this.mx_internal::scrollThumb.height < loc2.y ? 1 : this.mx_internal::scrollThumb.y > loc2.y ? -1 : 0;
this.mx_internal::pageScroll(this.trackScrollRepeatDirection);
if (this.trackScrollTimer)
{
this.trackScrollTimer.delay = getStyle("repeatDelay");
this.trackScrollTimer.repeatCount = 1;
}
else
{
this.trackScrollTimer = new flash.utils.Timer(getStyle("repeatDelay"), 1);
this.trackScrollTimer.addEventListener(flash.events.TimerEvent.TIMER, this.trackScrollTimerHandler);
}
this.trackScrollTimer.start();
return;
}
public override function set doubleClickEnabled(arg1:Boolean):void
{
return;
}
public override function set enabled(arg1:Boolean):void
{
super.enabled = arg1;
invalidateDisplayList();
return;
}
internal function trackScrollTimerHandler(arg1:flash.events.Event):void
{
if (this.trackScrollRepeatDirection == 1)
{
if (this.mx_internal::scrollThumb.y + this.mx_internal::scrollThumb.height > this.trackPosition)
{
return;
}
}
if (this.trackScrollRepeatDirection == -1)
{
if (this.mx_internal::scrollThumb.y < this.trackPosition)
{
return;
}
}
this.mx_internal::pageScroll(this.trackScrollRepeatDirection);
if (this.trackScrollTimer && this.trackScrollTimer.repeatCount == 1)
{
this.trackScrollTimer.delay = getStyle("repeatInterval");
this.trackScrollTimer.repeatCount = 0;
}
return;
}
internal function scrollTrack_mouseUpHandler(arg1:flash.events.MouseEvent):void
{
this.scrollTrack_mouseLeaveHandler(arg1);
return;
}
public function set direction(arg1:String):void
{
this._direction = arg1;
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("directionChanged"));
return;
}
protected function get downArrowStyleFilters():Object
{
return null;
}
mx_internal function get lineMinusDetail():String
{
return this.direction != mx.controls.scrollClasses.ScrollBarDirection.VERTICAL ? mx.events.ScrollEventDetail.LINE_LEFT : mx.events.ScrollEventDetail.LINE_UP;
}
mx_internal function get linePlusDetail():String
{
return this.direction != mx.controls.scrollClasses.ScrollBarDirection.VERTICAL ? mx.events.ScrollEventDetail.LINE_RIGHT : mx.events.ScrollEventDetail.LINE_DOWN;
}
internal function scrollTrack_mouseLeaveHandler(arg1:flash.events.Event):void
{
this.trackScrolling = false;
var loc1:*=systemManager.getSandboxRoot();
loc1.removeEventListener(flash.events.MouseEvent.MOUSE_UP, this.scrollTrack_mouseUpHandler, true);
loc1.removeEventListener(flash.events.MouseEvent.MOUSE_MOVE, this.scrollTrack_mouseMoveHandler, true);
loc1.removeEventListener(mx.events.SandboxMouseEvent.MOUSE_UP_SOMEWHERE, this.scrollTrack_mouseLeaveHandler);
systemManager.deployMouseShields(false);
if (this.trackScrollTimer)
{
this.trackScrollTimer.reset();
}
if (arg1.target != this.mx_internal::scrollTrack)
{
return;
}
var loc2:*=this.mx_internal::oldPosition > this.scrollPosition ? this.mx_internal::pageMinusDetail : this.mx_internal::pagePlusDetail;
this.mx_internal::dispatchScrollEvent(this.mx_internal::oldPosition, loc2);
this.mx_internal::oldPosition = NaN;
return;
}
public function get lineScrollSize():Number
{
return this._lineScrollSize;
}
public function set lineScrollSize(arg1:Number):void
{
this._lineScrollSize = arg1;
return;
}
internal function get maxDetail():String
{
return this.direction != mx.controls.scrollClasses.ScrollBarDirection.VERTICAL ? mx.events.ScrollEventDetail.AT_RIGHT : mx.events.ScrollEventDetail.AT_BOTTOM;
}
internal function scrollTrack_mouseMoveHandler(arg1:flash.events.MouseEvent):void
{
var loc1:*=null;
if (this.trackScrolling)
{
loc1 = new flash.geom.Point(arg1.stageX, arg1.stageY);
loc1 = globalToLocal(loc1);
this.trackPosition = loc1.y;
}
return;
}
public function get maxScrollPosition():Number
{
return this._maxScrollPosition;
}
public function set maxScrollPosition(arg1:Number):void
{
this._maxScrollPosition = arg1;
invalidateDisplayList();
return;
}
internal function get minDetail():String
{
return this.direction != mx.controls.scrollClasses.ScrollBarDirection.VERTICAL ? mx.events.ScrollEventDetail.AT_LEFT : mx.events.ScrollEventDetail.AT_TOP;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
public function get minScrollPosition():Number
{
return this._minScrollPosition;
}
public function set minScrollPosition(arg1:Number):void
{
this._minScrollPosition = arg1;
invalidateDisplayList();
return;
}
mx_internal function get pageMinusDetail():String
{
return this.direction != mx.controls.scrollClasses.ScrollBarDirection.VERTICAL ? mx.events.ScrollEventDetail.PAGE_LEFT : mx.events.ScrollEventDetail.PAGE_UP;
}
mx_internal function get pagePlusDetail():String
{
return this.direction != mx.controls.scrollClasses.ScrollBarDirection.VERTICAL ? mx.events.ScrollEventDetail.PAGE_RIGHT : mx.events.ScrollEventDetail.PAGE_DOWN;
}
public function set scrollPosition(arg1:Number):void
{
var loc1:*=NaN;
var loc2:*=NaN;
var loc3:*=NaN;
this._scrollPosition = arg1;
if (this.mx_internal::scrollThumb)
{
if (!cacheAsBitmap)
{
var loc4:*;
this.mx_internal::scrollThumb.cacheHeuristic = loc4 = true;
cacheHeuristic = loc4;
}
if (!this.mx_internal::isScrolling)
{
arg1 = Math.min(arg1, this.maxScrollPosition);
arg1 = Math.max(arg1, this.minScrollPosition);
loc1 = this.maxScrollPosition - this.minScrollPosition;
loc2 = loc1 == 0 || isNaN(loc1) ? 0 : (arg1 - this.minScrollPosition) * (this.trackHeight - this.mx_internal::scrollThumb.height) / loc1 + this.trackY;
loc3 = (this.mx_internal::virtualWidth - this.mx_internal::scrollThumb.width) / 2 + getStyle("thumbOffset");
this.mx_internal::scrollThumb.move(Math.round(loc3), Math.round(loc2));
}
}
return;
}
public function get pageSize():Number
{
return this._pageSize;
}
public function set pageSize(arg1:Number):void
{
this._pageSize = arg1;
return;
}
public function get pageScrollSize():Number
{
return this._pageScrollSize;
}
public function set pageScrollSize(arg1:Number):void
{
this._pageScrollSize = arg1;
return;
}
public function get scrollPosition():Number
{
return this._scrollPosition;
}
protected function get thumbStyleFilters():Object
{
return null;
}
internal function get trackHeight():Number
{
return this.mx_internal::virtualHeight - (this.mx_internal::upArrow.getExplicitOrMeasuredHeight() + this.mx_internal::downArrow.getExplicitOrMeasuredHeight());
}
internal function get trackY():Number
{
return this.mx_internal::upArrow.getExplicitOrMeasuredHeight();
}
protected function get upArrowStyleFilters():Object
{
return null;
}
mx_internal function get virtualHeight():Number
{
return unscaledHeight;
}
mx_internal function get virtualWidth():Number
{
return unscaledWidth;
}
protected override function createChildren():void
{
super.createChildren();
if (!this.mx_internal::scrollTrack)
{
this.mx_internal::scrollTrack = new mx.controls.Button();
this.mx_internal::scrollTrack.focusEnabled = false;
this.mx_internal::scrollTrack.mx_internal::skinName = "trackSkin";
this.mx_internal::scrollTrack.mx_internal::upSkinName = "trackUpSkin";
this.mx_internal::scrollTrack.mx_internal::overSkinName = "trackOverSkin";
this.mx_internal::scrollTrack.mx_internal::downSkinName = "trackDownSkin";
this.mx_internal::scrollTrack.mx_internal::disabledSkinName = "trackDisabledSkin";
if (this.mx_internal::scrollTrack is mx.styles.ISimpleStyleClient)
{
mx.styles.ISimpleStyleClient(this.mx_internal::scrollTrack).styleName = this;
}
addChild(this.mx_internal::scrollTrack);
this.mx_internal::scrollTrack.validateProperties();
}
if (!this.mx_internal::upArrow)
{
this.mx_internal::upArrow = new mx.controls.Button();
this.mx_internal::upArrow.enabled = false;
this.mx_internal::upArrow.autoRepeat = true;
this.mx_internal::upArrow.focusEnabled = false;
this.mx_internal::upArrow.mx_internal::upSkinName = "upArrowUpSkin";
this.mx_internal::upArrow.mx_internal::overSkinName = "upArrowOverSkin";
this.mx_internal::upArrow.mx_internal::downSkinName = "upArrowDownSkin";
this.mx_internal::upArrow.mx_internal::disabledSkinName = "upArrowDisabledSkin";
this.mx_internal::upArrow.mx_internal::skinName = "upArrowSkin";
this.mx_internal::upArrow.mx_internal::upIconName = "";
this.mx_internal::upArrow.mx_internal::overIconName = "";
this.mx_internal::upArrow.mx_internal::downIconName = "";
this.mx_internal::upArrow.mx_internal::disabledIconName = "";
addChild(this.mx_internal::upArrow);
this.mx_internal::upArrow.styleName = new mx.styles.StyleProxy(this, this.upArrowStyleFilters);
this.mx_internal::upArrow.validateProperties();
this.mx_internal::upArrow.addEventListener(mx.events.FlexEvent.BUTTON_DOWN, this.upArrow_buttonDownHandler);
}
if (!this.mx_internal::downArrow)
{
this.mx_internal::downArrow = new mx.controls.Button();
this.mx_internal::downArrow.enabled = false;
this.mx_internal::downArrow.autoRepeat = true;
this.mx_internal::downArrow.focusEnabled = false;
this.mx_internal::downArrow.mx_internal::upSkinName = "downArrowUpSkin";
this.mx_internal::downArrow.mx_internal::overSkinName = "downArrowOverSkin";
this.mx_internal::downArrow.mx_internal::downSkinName = "downArrowDownSkin";
this.mx_internal::downArrow.mx_internal::disabledSkinName = "downArrowDisabledSkin";
this.mx_internal::downArrow.mx_internal::skinName = "downArrowSkin";
this.mx_internal::downArrow.mx_internal::upIconName = "";
this.mx_internal::downArrow.mx_internal::overIconName = "";
this.mx_internal::downArrow.mx_internal::downIconName = "";
this.mx_internal::downArrow.mx_internal::disabledIconName = "";
addChild(this.mx_internal::downArrow);
this.mx_internal::downArrow.styleName = new mx.styles.StyleProxy(this, this.downArrowStyleFilters);
this.mx_internal::downArrow.validateProperties();
this.mx_internal::downArrow.addEventListener(mx.events.FlexEvent.BUTTON_DOWN, this.downArrow_buttonDownHandler);
}
return;
}
protected override function measure():void
{
super.measure();
this.mx_internal::upArrow.validateSize();
this.mx_internal::downArrow.validateSize();
this.mx_internal::scrollTrack.validateSize();
this.mx_internal::_minWidth = this.mx_internal::scrollThumb ? this.mx_internal::scrollThumb.getExplicitOrMeasuredWidth() : 0;
this.mx_internal::_minWidth = Math.max(this.mx_internal::scrollTrack.getExplicitOrMeasuredWidth(), this.mx_internal::upArrow.getExplicitOrMeasuredWidth(), this.mx_internal::downArrow.getExplicitOrMeasuredWidth(), this.mx_internal::_minWidth);
this.mx_internal::_minHeight = this.mx_internal::upArrow.getExplicitOrMeasuredHeight() + this.mx_internal::downArrow.getExplicitOrMeasuredHeight();
return;
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const THICKNESS:Number=16;
mx_internal var upArrow:mx.controls.Button;
mx_internal var downArrow:mx.controls.Button;
mx_internal var scrollTrack:mx.controls.Button;
mx_internal var scrollThumb:mx.controls.scrollClasses.ScrollThumb;
mx_internal var _minWidth:Number=16;
mx_internal var _minHeight:Number=32;
mx_internal var isScrolling:Boolean;
internal var trackScrollRepeatDirection:int;
internal var trackScrolling:Boolean=false;
internal var trackPosition:Number;
mx_internal var oldPosition:Number;
internal var _direction:String="vertical";
internal var trackScrollTimer:flash.utils.Timer;
internal var _lineScrollSize:Number=1;
internal var _maxScrollPosition:Number=0;
internal var _minScrollPosition:Number=0;
internal var _scrollPosition:Number=0;
internal var _pageScrollSize:Number=0;
internal var _pageSize:Number=0;
}
}
// class ScrollBarDirection
package mx.controls.scrollClasses
{
import mx.core.*;
use namespace mx_internal;
public final class ScrollBarDirection extends Object
{
public function ScrollBarDirection()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const HORIZONTAL:String="horizontal";
public static const VERTICAL:String="vertical";
}
}
// class ScrollThumb
package mx.controls.scrollClasses
{
import flash.events.*;
import flash.geom.*;
import mx.controls.*;
import mx.core.*;
import mx.events.*;
use namespace mx_internal;
public class ScrollThumb extends mx.controls.Button
{
public function ScrollThumb()
{
super();
explicitMinHeight = 10;
stickyHighlighting = true;
return;
}
mx_internal override function buttonReleased():void
{
super.mx_internal::buttonReleased();
this.stopDragThumb();
return;
}
mx_internal function setRange(arg1:Number, arg2:Number, arg3:Number, arg4:Number):void
{
this.ymin = arg1;
this.ymax = arg2;
this.datamin = arg3;
this.datamax = arg4;
return;
}
internal function stopDragThumb():void
{
var loc1:*=mx.controls.scrollClasses.ScrollBar(parent);
loc1.mx_internal::isScrolling = false;
loc1.mx_internal::dispatchScrollEvent(loc1.mx_internal::oldPosition, mx.events.ScrollEventDetail.THUMB_POSITION);
loc1.mx_internal::oldPosition = NaN;
systemManager.getSandboxRoot().removeEventListener(flash.events.MouseEvent.MOUSE_MOVE, this.mouseMoveHandler, true);
return;
}
protected override function mouseDownHandler(arg1:flash.events.MouseEvent):void
{
super.mouseDownHandler(arg1);
var loc1:*=mx.controls.scrollClasses.ScrollBar(parent);
loc1.mx_internal::oldPosition = loc1.scrollPosition;
this.lastY = arg1.localY;
systemManager.getSandboxRoot().addEventListener(flash.events.MouseEvent.MOUSE_MOVE, this.mouseMoveHandler, true);
return;
}
internal function mouseMoveHandler(arg1:flash.events.MouseEvent):void
{
if (this.ymin == this.ymax)
{
return;
}
var loc1:*=new flash.geom.Point(arg1.stageX, arg1.stageY);
loc1 = globalToLocal(loc1);
var loc2:*=loc1.y - this.lastY;
loc2 = loc2 + y;
if (loc2 < this.ymin)
{
loc2 = this.ymin;
}
else if (loc2 > this.ymax)
{
loc2 = this.ymax;
}
var loc3:*;
(loc3 = mx.controls.scrollClasses.ScrollBar(parent)).mx_internal::isScrolling = true;
mx_internal::$y = loc2;
var loc4:*=loc3.scrollPosition;
var loc5:*=Math.round((this.datamax - this.datamin) * (y - this.ymin) / (this.ymax - this.ymin)) + this.datamin;
loc3.scrollPosition = loc5;
loc3.mx_internal::dispatchScrollEvent(loc4, mx.events.ScrollEventDetail.THUMB_TRACK);
arg1.updateAfterEvent();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var ymin:Number;
internal var ymax:Number;
internal var datamin:Number;
internal var datamax:Number;
internal var lastY:Number;
}
}
// class Button
package mx.controls
{
import flash.display.*;
import flash.events.*;
import flash.text.*;
import flash.ui.*;
import flash.utils.*;
import mx.controls.dataGridClasses.*;
import mx.controls.listClasses.*;
import mx.core.*;
import mx.events.*;
import mx.managers.*;
import mx.styles.*;
use namespace mx_internal;
public class Button extends mx.core.UIComponent implements mx.core.IDataRenderer, mx.controls.listClasses.IDropInListItemRenderer, mx.managers.IFocusManagerComponent, mx.controls.listClasses.IListItemRenderer, mx.core.IFontContextComponent, mx.core.IButton
{
public function Button()
{
this.skins = [];
this.icons = [];
super();
mouseChildren = false;
addEventListener(flash.events.MouseEvent.ROLL_OVER, this.rollOverHandler);
addEventListener(flash.events.MouseEvent.ROLL_OUT, this.rollOutHandler);
addEventListener(flash.events.MouseEvent.MOUSE_DOWN, this.mouseDownHandler);
addEventListener(flash.events.MouseEvent.MOUSE_UP, this.mouseUpHandler);
addEventListener(flash.events.MouseEvent.CLICK, this.clickHandler);
return;
}
protected override function focusOutHandler(arg1:flash.events.FocusEvent):void
{
super.focusOutHandler(arg1);
if (this.mx_internal::phase != mx.controls.ButtonPhase.UP)
{
this.mx_internal::phase = mx.controls.ButtonPhase.UP;
}
return;
}
public function set emphasized(arg1:Boolean):void
{
this.mx_internal::_emphasized = arg1;
this.emphasizedChanged = true;
invalidateDisplayList();
return;
}
public override function set toolTip(arg1:String):void
{
super.toolTip = arg1;
if (arg1)
{
this.toolTipSet = true;
}
else
{
this.toolTipSet = false;
invalidateDisplayList();
}
return;
}
public function get fontContext():mx.core.IFlexModuleFactory
{
return moduleFactory;
}
public function get autoRepeat():Boolean
{
return this._autoRepeat;
}
public function set autoRepeat(arg1:Boolean):void
{
this._autoRepeat = arg1;
if (arg1)
{
this.autoRepeatTimer = new flash.utils.Timer(1);
}
else
{
this.autoRepeatTimer = null;
}
return;
}
public function set fontContext(arg1:mx.core.IFlexModuleFactory):void
{
this.moduleFactory = arg1;
return;
}
public function get data():Object
{
return this._data;
}
public function set data(arg1:Object):void
{
var loc1:*=undefined;
var loc2:*=undefined;
this._data = arg1;
if (this._listData && this._listData is mx.controls.dataGridClasses.DataGridListData && !(mx.controls.dataGridClasses.DataGridListData(this._listData).dataField == null))
{
loc1 = this._data[mx.controls.dataGridClasses.DataGridListData(this._listData).dataField];
loc2 = "";
}
else if (this._listData)
{
if (this.selectedField)
{
loc1 = this._data[this.selectedField];
}
loc2 = this._listData.label;
}
else
{
loc1 = this._data;
}
if (!(loc1 === undefined) && !this.selectedSet)
{
this.selected = loc1 as Boolean;
this.selectedSet = false;
}
if (!(loc2 === undefined) && !this.labelSet)
{
this.label = loc2;
this.labelSet = false;
}
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.DATA_CHANGE));
return;
}
public function get label():String
{
return this._label;
}
public override function get baselinePosition():Number
{
if (!mx_internal::validateBaselinePosition())
{
return NaN;
}
return this.textField.y + this.textField.baselinePosition;
}
public function set label(arg1:String):void
{
this.labelSet = true;
if (this._label != arg1)
{
this._label = arg1;
this.labelChanged = true;
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("labelChanged"));
}
return;
}
public override function set enabled(arg1:Boolean):void
{
if (super.enabled == arg1)
{
return;
}
super.enabled = arg1;
this.enabledChanged = true;
invalidateProperties();
invalidateDisplayList();
return;
}
public function get emphasized():Boolean
{
return this.mx_internal::_emphasized;
}
public function get labelPlacement():String
{
return this.mx_internal::_labelPlacement;
}
public function set labelPlacement(arg1:String):void
{
this.mx_internal::_labelPlacement = arg1;
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("labelPlacementChanged"));
return;
}
public function get listData():mx.controls.listClasses.BaseListData
{
return this._listData;
}
public function set listData(arg1:mx.controls.listClasses.BaseListData):void
{
this._listData = arg1;
return;
}
mx_internal function get phase():String
{
return this._phase;
}
mx_internal function set phase(arg1:String):void
{
this._phase = arg1;
this.mx_internal::phaseChanged = true;
invalidateSize();
invalidateProperties();
invalidateDisplayList();
return;
}
public function get selected():Boolean
{
return this.mx_internal::_selected;
}
public function set selected(arg1:Boolean):void
{
this.selectedSet = true;
this.mx_internal::setSelected(arg1, true);
return;
}
mx_internal function setSelected(arg1:Boolean, arg2:Boolean=false):void
{
if (this.mx_internal::_selected != arg1)
{
this.mx_internal::_selected = arg1;
invalidateDisplayList();
if (this.toggle && !arg2)
{
dispatchEvent(new flash.events.Event(flash.events.Event.CHANGE));
}
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.VALUE_COMMIT));
}
return;
}
mx_internal function set skinLayoutDirection(arg1:String):void
{
this.skinLayoutDirectionSet = true;
this._skinLayoutDirection = arg1;
return;
}
public function get toggle():Boolean
{
return this.mx_internal::_toggle;
}
public function set toggle(arg1:Boolean):void
{
this.mx_internal::_toggle = arg1;
this.mx_internal::toggleChanged = true;
invalidateProperties();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("toggleChanged"));
return;
}
protected override function initializeAccessibility():void
{
if (mx.controls.Button.mx_internal::createAccessibilityImplementation != null)
{
mx.controls.Button.mx_internal::createAccessibilityImplementation(this);
}
return;
}
protected override function createChildren():void
{
super.createChildren();
if (!this.textField)
{
this.textField = mx.core.IUITextField(createInFontContext(mx.core.UITextField));
this.textField.styleName = this;
addChild(flash.display.DisplayObject(this.textField));
}
return;
}
protected override function commitProperties():void
{
var loc1:*=null;
super.commitProperties();
if (hasFontContextChanged() && !(this.textField == null))
{
removeChild(flash.display.DisplayObject(this.textField));
this.textField = null;
}
if (!this.textField)
{
this.textField = mx.core.IUITextField(createInFontContext(mx.core.UITextField));
this.textField.styleName = this;
addChild(flash.display.DisplayObject(this.textField));
this.enabledChanged = true;
this.mx_internal::toggleChanged = true;
}
if (!initialized)
{
this.mx_internal::viewSkin();
this.mx_internal::viewIcon();
}
if (this.enabledChanged)
{
this.textField.enabled = enabled;
if (this.mx_internal::currentIcon && this.mx_internal::currentIcon is mx.core.IUIComponent)
{
mx.core.IUIComponent(this.mx_internal::currentIcon).enabled = enabled;
}
this.enabledChanged = false;
}
if (this.mx_internal::toggleChanged)
{
if (!this.toggle)
{
this.selected = false;
}
this.mx_internal::toggleChanged = false;
}
if (this.mx_internal::phaseChanged)
{
loc1 = this._currentButtonState;
if (loc1 != this.mx_internal::getCurrentButtonState())
{
stateChanged(loc1, this._currentButtonState, false);
}
this.mx_internal::phaseChanged = false;
}
return;
}
protected override function measure():void
{
var loc9:*=null;
super.measure();
var loc1:*=0;
var loc2:*=0;
if (this.label)
{
loc1 = (loc9 = measureText(this.label)).width + mx_internal::TEXT_WIDTH_PADDING;
loc2 = loc9.height + mx.core.UITextField.mx_internal::TEXT_HEIGHT_PADDING;
}
var loc3:*=this.mx_internal::getCurrentIcon();
var loc4:*=loc3 ? loc3.width : 0;
var loc5:*=loc3 ? loc3.height : 0;
var loc6:*=0;
var loc7:*=0;
if (this.labelPlacement == mx.controls.ButtonLabelPlacement.LEFT || this.labelPlacement == mx.controls.ButtonLabelPlacement.RIGHT)
{
loc6 = loc1 + loc4;
if (loc1 && loc4)
{
loc6 = loc6 + getStyle("horizontalGap");
}
loc7 = Math.max(loc2, loc5);
}
else
{
loc6 = Math.max(loc1, loc4);
loc7 = loc2 + loc5;
if (loc2 && loc5)
{
loc7 = loc7 + getStyle("verticalGap");
}
}
if (loc1 || loc4)
{
loc6 = loc6 + (getStyle("paddingLeft") + getStyle("paddingRight"));
loc7 = loc7 + (getStyle("paddingTop") + getStyle("paddingBottom"));
}
var loc8:*;
if (loc8 = this.mx_internal::currentSkin && this.mx_internal::currentSkin is mx.core.IBorder && !(this.mx_internal::currentSkin is mx.core.IFlexAsset) ? mx.core.IBorder(this.mx_internal::currentSkin).borderMetrics : null)
{
loc6 = loc6 + (loc8.left + loc8.right);
loc7 = loc7 + (loc8.top + loc8.bottom);
}
if (this.mx_internal::currentSkin && (isNaN(this.skinMeasuredWidth) || isNaN(this.skinMeasuredHeight)))
{
this.skinMeasuredWidth = this.mx_internal::currentSkin.measuredWidth;
this.skinMeasuredHeight = this.mx_internal::currentSkin.measuredHeight;
}
if (!isNaN(this.skinMeasuredWidth))
{
loc6 = Math.max(this.skinMeasuredWidth, loc6);
}
if (!isNaN(this.skinMeasuredHeight))
{
loc7 = Math.max(this.skinMeasuredHeight, loc7);
}
var loc10:*;
measuredWidth = loc10 = loc6;
measuredMinWidth = loc10;
measuredHeight = loc10 = loc7;
measuredMinHeight = loc10;
return;
}
protected override function updateDisplayList(arg1:Number, arg2:Number):void
{
var loc3:*=null;
var loc4:*=false;
super.updateDisplayList(arg1, arg2);
if (this.emphasizedChanged)
{
this.mx_internal::changeSkins();
this.emphasizedChanged = false;
}
var loc1:*=this.skins.length;
var loc2:*=0;
while (loc2 < loc1)
{
(loc3 = mx.core.IFlexDisplayObject(this.skins[loc2])).setActualSize(arg1, arg2);
++loc2;
}
this.mx_internal::viewSkin();
this.mx_internal::viewIcon();
this.mx_internal::layoutContents(arg1, arg2, this.mx_internal::phase == mx.controls.ButtonPhase.DOWN);
if (this.oldUnscaledWidth > arg1 || !(this.textField.text == this.label) || this.labelChanged || this.styleChangedFlag)
{
this.textField.text = this.label;
loc4 = this.textField.truncateToFit();
if (!this.toolTipSet)
{
if (loc4)
{
super.toolTip = this.label;
}
else
{
super.toolTip = null;
}
}
this.styleChangedFlag = false;
this.labelChanged = false;
}
this.oldUnscaledWidth = arg1;
return;
}
public override function styleChanged(arg1:String):void
{
this.styleChangedFlag = true;
super.styleChanged(arg1);
if (!arg1 || arg1 == "styleName")
{
this.mx_internal::changeSkins();
this.mx_internal::changeIcons();
if (initialized)
{
this.mx_internal::viewSkin();
this.mx_internal::viewIcon();
}
}
else if (arg1.toLowerCase().indexOf("skin") == -1)
{
if (arg1.toLowerCase().indexOf("icon") != -1)
{
this.mx_internal::changeIcons();
invalidateSize();
}
}
else
{
this.mx_internal::changeSkins();
}
return;
}
protected override function adjustFocusRect(arg1:flash.display.DisplayObject=null):void
{
super.adjustFocusRect(this.mx_internal::currentSkin ? this : flash.display.DisplayObject(this.mx_internal::currentIcon));
return;
}
protected override function get currentCSSState():String
{
return this.mx_internal::getCurrentButtonState();
}
mx_internal function viewSkin():void
{
var loc1:*=null;
if (enabled)
{
if (this.mx_internal::phase != mx.controls.ButtonPhase.UP)
{
if (this.mx_internal::phase != mx.controls.ButtonPhase.OVER)
{
if (this.mx_internal::phase == mx.controls.ButtonPhase.DOWN)
{
loc1 = this.selected ? this.mx_internal::selectedDownSkinName : this.mx_internal::downSkinName;
}
}
else
{
loc1 = this.selected ? this.mx_internal::selectedOverSkinName : this.mx_internal::overSkinName;
}
}
else
{
loc1 = this.selected ? this.mx_internal::selectedUpSkinName : this.mx_internal::upSkinName;
}
}
else
{
loc1 = this.selected ? this.mx_internal::selectedDisabledSkinName : this.mx_internal::disabledSkinName;
}
this.mx_internal::viewSkinForPhase(loc1, this.mx_internal::getCurrentButtonState());
return;
}
mx_internal function viewSkinForPhase(arg1:String, arg2:String):void
{
var loc2:*=null;
var loc3:*=NaN;
var loc4:*=null;
var loc1:*=Class(getStyle(arg1));
if (!loc1)
{
loc1 = this.mx_internal::_emphasized ? Class(getStyle(this.mx_internal::emphasizedSkinName)) : Class(getStyle(this.mx_internal::skinName));
loc1 = !loc1 && this.mx_internal::_emphasized ? Class(getStyle(this.mx_internal::skinName)) : loc1;
if (this.mx_internal::defaultSkinUsesStates)
{
arg1 = this.mx_internal::skinName;
}
if (!this.mx_internal::checkedDefaultSkin && loc1)
{
if (!((loc2 = mx.core.IFlexDisplayObject(new loc1())) is mx.core.IProgrammaticSkin) && loc2 is mx.core.IStateClient)
{
this.mx_internal::defaultSkinUsesStates = true;
arg1 = this.mx_internal::skinName;
}
if (loc2)
{
this.mx_internal::checkedDefaultSkin = true;
if (loc2 is mx.core.ILayoutDirectionElement && this.skinLayoutDirectionSet)
{
mx.core.ILayoutDirectionElement(loc2).layoutDirection = this._skinLayoutDirection;
}
}
}
}
if (!(loc2 = mx.core.IFlexDisplayObject(getChildByName(arg1))))
{
if (loc1)
{
(loc2 = mx.core.IFlexDisplayObject(new loc1())).name = arg1;
if (loc4 = loc2 as mx.styles.ISimpleStyleClient)
{
loc4.styleName = this;
}
if (loc2 is mx.core.ILayoutDirectionElement && this.skinLayoutDirectionSet)
{
mx.core.ILayoutDirectionElement(loc2).layoutDirection = this._skinLayoutDirection;
}
addChild(flash.display.DisplayObject(loc2));
loc2.setActualSize(unscaledWidth, unscaledHeight);
if (loc2 is mx.core.IInvalidating && initialized)
{
mx.core.IInvalidating(loc2).validateNow();
}
else if (loc2 is mx.core.IProgrammaticSkin && initialized)
{
mx.core.IProgrammaticSkin(loc2).validateDisplayList();
}
this.skins.push(loc2);
}
}
if (this.mx_internal::currentSkin)
{
this.mx_internal::currentSkin.visible = false;
}
this.mx_internal::currentSkin = loc2;
if (this.mx_internal::defaultSkinUsesStates && this.mx_internal::currentSkin is mx.core.IStateClient)
{
mx.core.IStateClient(this.mx_internal::currentSkin).currentState = arg2;
if (this.mx_internal::currentSkin is mx.core.IInvalidating)
{
mx.core.IInvalidating(this.mx_internal::currentSkin).validateNow();
}
}
if (this.mx_internal::currentSkin)
{
this.mx_internal::currentSkin.visible = true;
}
if (enabled)
{
if (this.mx_internal::phase != mx.controls.ButtonPhase.OVER)
{
if (this.mx_internal::phase != mx.controls.ButtonPhase.DOWN)
{
loc3 = this.textField.getStyle("color");
}
else
{
loc3 = this.textField.getStyle("textSelectedColor");
}
}
else
{
loc3 = this.textField.getStyle("textRollOverColor");
}
this.textField.setColor(loc3);
}
return;
}
mx_internal function getCurrentIconName():String
{
var loc1:*=null;
if (enabled)
{
if (this.mx_internal::phase != mx.controls.ButtonPhase.UP)
{
if (this.mx_internal::phase != mx.controls.ButtonPhase.OVER)
{
if (this.mx_internal::phase == mx.controls.ButtonPhase.DOWN)
{
loc1 = this.selected ? this.mx_internal::selectedDownIconName : this.mx_internal::downIconName;
}
}
else
{
loc1 = this.selected ? this.mx_internal::selectedOverIconName : this.mx_internal::overIconName;
}
}
else
{
loc1 = this.selected ? this.mx_internal::selectedUpIconName : this.mx_internal::upIconName;
}
}
else
{
loc1 = this.selected ? this.mx_internal::selectedDisabledIconName : this.mx_internal::disabledIconName;
}
return loc1;
}
mx_internal function getCurrentIcon():mx.core.IFlexDisplayObject
{
var loc1:*=this.mx_internal::getCurrentIconName();
if (!loc1)
{
return null;
}
return this.mx_internal::viewIconForPhase(loc1);
}
mx_internal function viewIcon():void
{
var loc1:*=this.mx_internal::getCurrentIconName();
this.mx_internal::viewIconForPhase(loc1);
return;
}
mx_internal function viewIconForPhase(arg1:String):mx.core.IFlexDisplayObject
{
var loc2:*=null;
var loc3:*=false;
var loc1:*=Class(getStyle(arg1));
if (!loc1)
{
loc1 = Class(getStyle(this.mx_internal::iconName));
if (this.mx_internal::defaultIconUsesStates)
{
arg1 = this.mx_internal::iconName;
}
if (!this.mx_internal::checkedDefaultIcon && loc1)
{
loc2 = mx.core.IFlexDisplayObject(new loc1());
if (!(loc2 is mx.core.IProgrammaticSkin) && loc2 is mx.core.IStateClient)
{
this.mx_internal::defaultIconUsesStates = true;
arg1 = this.mx_internal::iconName;
}
if (loc2)
{
this.mx_internal::checkedDefaultIcon = true;
}
}
}
loc2 = mx.core.IFlexDisplayObject(getChildByName(arg1));
if (loc2 == null)
{
if (loc1 != null)
{
loc2 = mx.core.IFlexDisplayObject(new loc1());
loc2.name = arg1;
if (loc2 is mx.styles.ISimpleStyleClient)
{
mx.styles.ISimpleStyleClient(loc2).styleName = this;
}
addChild(flash.display.DisplayObject(loc2));
loc3 = false;
if (loc2 is mx.core.IInvalidating)
{
mx.core.IInvalidating(loc2).validateNow();
loc3 = true;
}
else if (loc2 is mx.core.IProgrammaticSkin)
{
mx.core.IProgrammaticSkin(loc2).validateDisplayList();
loc3 = true;
}
if (loc2 && loc2 is mx.core.IUIComponent)
{
mx.core.IUIComponent(loc2).enabled = enabled;
}
if (loc3)
{
loc2.setActualSize(loc2.measuredWidth, loc2.measuredHeight);
}
this.icons.push(loc2);
}
}
if (this.mx_internal::currentIcon != null)
{
this.mx_internal::currentIcon.visible = false;
}
this.mx_internal::currentIcon = loc2;
if (this.mx_internal::defaultIconUsesStates && this.mx_internal::currentIcon is mx.core.IStateClient)
{
mx.core.IStateClient(this.mx_internal::currentIcon).currentState = this.mx_internal::getCurrentButtonState();
if (this.mx_internal::currentIcon is mx.core.IInvalidating)
{
mx.core.IInvalidating(this.mx_internal::currentIcon).validateNow();
}
}
if (this.mx_internal::currentIcon != null)
{
this.mx_internal::currentIcon.visible = true;
}
return loc2;
}
mx_internal function getCurrentButtonState():String
{
this._currentButtonState = "";
if (enabled)
{
if (this.mx_internal::phase != mx.controls.ButtonPhase.UP)
{
if (this.mx_internal::phase != mx.controls.ButtonPhase.OVER)
{
if (this.mx_internal::phase == mx.controls.ButtonPhase.DOWN)
{
this._currentButtonState = this.selected ? "selectedDown" : "down";
}
}
else
{
this._currentButtonState = this.selected ? "selectedOver" : "over";
}
}
else
{
this._currentButtonState = this.selected ? "selectedUp" : "up";
}
}
else
{
this._currentButtonState = this.selected ? "selectedDisabled" : "disabled";
}
return this._currentButtonState;
}
mx_internal function layoutContents(arg1:Number, arg2:Number, arg3:Boolean):void
{
var loc17:*=null;
var loc25:*=null;
var loc1:*=0;
var loc2:*=0;
var loc3:*=0;
var loc4:*=0;
var loc5:*=0;
var loc6:*=0;
var loc7:*=0;
var loc8:*=0;
var loc9:*=0;
var loc10:*=0;
var loc11:*=getStyle("paddingLeft");
var loc12:*=getStyle("paddingRight");
var loc13:*=getStyle("paddingTop");
var loc14:*=getStyle("paddingBottom");
var loc15:*=0;
var loc16:*=0;
if (this.label)
{
loc15 = (loc17 = measureText(this.label)).width + mx_internal::TEXT_WIDTH_PADDING;
loc16 = loc17.height + mx.core.UITextField.mx_internal::TEXT_HEIGHT_PADDING;
}
else
{
loc16 = (loc17 = measureText("Wj")).height + mx.core.UITextField.mx_internal::TEXT_HEIGHT_PADDING;
}
var loc18:*=arg3 ? this.mx_internal::buttonOffset : 0;
var loc19:*;
if ((loc19 = getStyle("textAlign")) != "start")
{
if (loc19 == "end")
{
loc19 = flash.text.TextFormatAlign.RIGHT;
}
}
else
{
loc19 = flash.text.TextFormatAlign.LEFT;
}
var loc20:*=arg1;
var loc21:*=arg2;
var loc22:*;
if (loc22 = this.mx_internal::currentSkin && this.mx_internal::currentSkin is mx.core.IBorder && !(this.mx_internal::currentSkin is mx.core.IFlexAsset) ? mx.core.IBorder(this.mx_internal::currentSkin).borderMetrics : null)
{
loc20 = loc20 - (loc22.left + loc22.right);
loc21 = loc21 - (loc22.top + loc22.bottom);
}
if (this.mx_internal::currentIcon)
{
loc5 = this.mx_internal::currentIcon.width;
loc6 = this.mx_internal::currentIcon.height;
}
if (this.labelPlacement == mx.controls.ButtonLabelPlacement.LEFT || this.labelPlacement == mx.controls.ButtonLabelPlacement.RIGHT)
{
loc9 = getStyle("horizontalGap");
if (loc5 == 0 || loc15 == 0)
{
loc9 = 0;
}
if (loc15 > 0)
{
var loc26:*;
loc1 = loc26 = Math.max(Math.min(loc20 - loc5 - loc9 - loc11 - loc12, loc15), 0);
this.textField.width = loc26;
}
else
{
loc1 = loc26 = 0;
this.textField.width = loc26;
}
loc2 = loc26 = Math.min(loc21, loc16);
this.textField.height = loc26;
if (loc19 != "left")
{
if (loc19 != "right")
{
loc3 = loc3 + ((loc20 - loc1 - loc5 - loc9 - loc11 - loc12) / 2 + loc11);
}
else
{
loc3 = loc3 + (loc20 - loc1 - loc5 - loc9 - loc12);
}
}
else
{
loc3 = loc3 + loc11;
}
if (this.labelPlacement != mx.controls.ButtonLabelPlacement.RIGHT)
{
loc7 = loc3 + loc1 + loc9;
}
else
{
loc7 = (loc3 = loc3 + (loc5 + loc9)) - (loc5 + loc9);
}
loc8 = (loc21 - loc6 - loc13 - loc14) / 2 + loc13;
loc4 = (loc21 - loc2 - loc13 - loc14) / 2 + loc13;
}
else
{
loc10 = getStyle("verticalGap");
if (loc6 == 0 || this.label == "")
{
loc10 = 0;
}
if (loc15 > 0)
{
loc1 = loc26 = Math.max(loc20 - loc11 - loc12, 0);
this.textField.width = loc26;
loc2 = loc26 = Math.min(loc21 - loc6 - loc13 - loc14 - loc10, loc16);
this.textField.height = loc26;
}
else
{
loc1 = loc26 = 0;
this.textField.width = loc26;
loc2 = loc26 = 0;
this.textField.height = loc26;
}
loc3 = loc11;
if (loc19 != "left")
{
if (loc19 != "right")
{
loc7 = loc7 + ((loc20 - loc5 - loc11 - loc12) / 2 + loc11);
}
else
{
loc7 = loc7 + Math.max(loc20 - loc5 - loc12, loc11);
}
}
else
{
loc7 = loc7 + loc11;
}
if (this.labelPlacement != mx.controls.ButtonLabelPlacement.TOP)
{
loc8 = loc8 + ((loc21 - loc2 - loc6 - loc13 - loc14 - loc10) / 2 + loc13);
loc4 = loc4 + (loc8 + loc6 + loc10);
}
else
{
loc4 = loc4 + ((loc21 - loc2 - loc6 - loc13 - loc14 - loc10) / 2 + loc13);
loc8 = loc8 + (loc4 + loc2 + loc10);
}
}
var loc23:*=loc18;
var loc24:*=loc18;
if (loc22)
{
loc23 = loc23 + loc22.left;
loc24 = loc24 + loc22.top;
}
if (mx.core.FlexVersion.compatibilityVersion >= mx.core.FlexVersion.VERSION_4_0)
{
loc4 = loc4 + getStyle("labelVerticalOffset");
}
this.textField.x = Math.round(loc3 + loc23);
this.textField.y = Math.round(loc4 + loc24);
if (this.mx_internal::currentIcon)
{
loc7 = loc7 + loc23;
loc8 = loc8 + loc24;
(loc25 = new mx.events.MoveEvent(mx.events.MoveEvent.MOVE)).oldX = this.mx_internal::currentIcon.x;
loc25.oldY = this.mx_internal::currentIcon.y;
this.mx_internal::currentIcon.x = Math.round(loc7);
this.mx_internal::currentIcon.y = Math.round(loc8);
this.mx_internal::currentIcon.dispatchEvent(loc25);
}
if (this.mx_internal::currentSkin)
{
setChildIndex(flash.display.DisplayObject(this.mx_internal::currentSkin), (numChildren - 1));
}
if (this.mx_internal::currentIcon)
{
setChildIndex(flash.display.DisplayObject(this.mx_internal::currentIcon), (numChildren - 1));
}
if (this.textField)
{
setChildIndex(flash.display.DisplayObject(this.textField), (numChildren - 1));
}
return;
}
mx_internal function changeSkins():void
{
var loc1:*=this.skins.length;
var loc2:*=0;
while (loc2 < loc1)
{
removeChild(this.skins[loc2]);
++loc2;
}
this.skins = [];
this.skinMeasuredWidth = NaN;
this.skinMeasuredHeight = NaN;
this.mx_internal::checkedDefaultSkin = false;
this.mx_internal::defaultSkinUsesStates = false;
if (initialized)
{
this.mx_internal::viewSkin();
invalidateSize();
}
return;
}
mx_internal function changeIcons():void
{
var loc1:*=this.icons.length;
var loc2:*=0;
while (loc2 < loc1)
{
removeChild(this.icons[loc2]);
++loc2;
}
this.icons = [];
this.mx_internal::checkedDefaultIcon = false;
this.mx_internal::defaultIconUsesStates = false;
return;
}
mx_internal function buttonPressed():void
{
this.mx_internal::phase = mx.controls.ButtonPhase.DOWN;
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.BUTTON_DOWN));
if (this.autoRepeat)
{
this.autoRepeatTimer.delay = getStyle("repeatDelay");
this.autoRepeatTimer.addEventListener(flash.events.TimerEvent.TIMER, this.autoRepeatTimer_timerDelayHandler);
this.autoRepeatTimer.start();
}
return;
}
mx_internal function buttonReleased():void
{
systemManager.getSandboxRoot().removeEventListener(flash.events.MouseEvent.MOUSE_UP, this.systemManager_mouseUpHandler, true);
systemManager.getSandboxRoot().removeEventListener(mx.events.SandboxMouseEvent.MOUSE_UP_SOMEWHERE, this.stage_mouseLeaveHandler);
if (this.autoRepeatTimer)
{
this.autoRepeatTimer.removeEventListener(flash.events.TimerEvent.TIMER, this.autoRepeatTimer_timerDelayHandler);
this.autoRepeatTimer.removeEventListener(flash.events.TimerEvent.TIMER, this.autoRepeatTimer_timerHandler);
this.autoRepeatTimer.reset();
}
return;
}
mx_internal function getTextField():mx.core.IUITextField
{
return this.textField;
}
protected override function keyDownHandler(arg1:flash.events.KeyboardEvent):void
{
if (!enabled)
{
return;
}
if (arg1.keyCode == flash.ui.Keyboard.SPACE)
{
this.mx_internal::buttonPressed();
}
return;
}
protected override function keyUpHandler(arg1:flash.events.KeyboardEvent):void
{
if (!enabled)
{
return;
}
if (arg1.keyCode == flash.ui.Keyboard.SPACE)
{
this.mx_internal::buttonReleased();
if (this.mx_internal::phase == mx.controls.ButtonPhase.DOWN)
{
dispatchEvent(new flash.events.MouseEvent(flash.events.MouseEvent.CLICK));
}
this.mx_internal::phase = mx.controls.ButtonPhase.UP;
}
return;
}
protected function rollOverHandler(arg1:flash.events.MouseEvent):void
{
if (this.mx_internal::phase != mx.controls.ButtonPhase.UP)
{
if (this.mx_internal::phase == mx.controls.ButtonPhase.OVER)
{
this.mx_internal::phase = mx.controls.ButtonPhase.DOWN;
arg1.updateAfterEvent();
if (this.autoRepeatTimer)
{
this.autoRepeatTimer.start();
}
}
}
else
{
if (arg1.buttonDown)
{
return;
}
this.mx_internal::phase = mx.controls.ButtonPhase.OVER;
arg1.updateAfterEvent();
}
return;
}
protected function rollOutHandler(arg1:flash.events.MouseEvent):void
{
if (this.mx_internal::phase != mx.controls.ButtonPhase.OVER)
{
if (this.mx_internal::phase == mx.controls.ButtonPhase.DOWN && !this.stickyHighlighting)
{
this.mx_internal::phase = mx.controls.ButtonPhase.OVER;
arg1.updateAfterEvent();
if (this.autoRepeatTimer)
{
this.autoRepeatTimer.stop();
}
}
}
else
{
this.mx_internal::phase = mx.controls.ButtonPhase.UP;
arg1.updateAfterEvent();
}
return;
}
protected function mouseDownHandler(arg1:flash.events.MouseEvent):void
{
if (!enabled)
{
return;
}
systemManager.getSandboxRoot().addEventListener(flash.events.MouseEvent.MOUSE_UP, this.systemManager_mouseUpHandler, true);
systemManager.getSandboxRoot().addEventListener(mx.events.SandboxMouseEvent.MOUSE_UP_SOMEWHERE, this.stage_mouseLeaveHandler);
this.mx_internal::buttonPressed();
arg1.updateAfterEvent();
return;
}
protected function mouseUpHandler(arg1:flash.events.MouseEvent):void
{
if (!enabled)
{
return;
}
this.mx_internal::phase = mx.controls.ButtonPhase.OVER;
this.mx_internal::buttonReleased();
if (!this.toggle)
{
arg1.updateAfterEvent();
}
return;
}
protected function clickHandler(arg1:flash.events.MouseEvent):void
{
if (!enabled)
{
arg1.stopImmediatePropagation();
return;
}
if (this.toggle)
{
this.mx_internal::setSelected(!this.selected);
arg1.updateAfterEvent();
}
return;
}
internal function systemManager_mouseUpHandler(arg1:flash.events.MouseEvent):void
{
if (contains(flash.display.DisplayObject(arg1.target)))
{
return;
}
this.mx_internal::phase = mx.controls.ButtonPhase.UP;
this.mx_internal::buttonReleased();
arg1.updateAfterEvent();
return;
}
internal function stage_mouseLeaveHandler(arg1:flash.events.Event):void
{
this.mx_internal::phase = mx.controls.ButtonPhase.UP;
this.mx_internal::buttonReleased();
return;
}
internal function autoRepeatTimer_timerDelayHandler(arg1:flash.events.Event):void
{
if (!enabled)
{
return;
}
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.BUTTON_DOWN));
if (this.autoRepeat)
{
this.autoRepeatTimer.reset();
this.autoRepeatTimer.removeEventListener(flash.events.TimerEvent.TIMER, this.autoRepeatTimer_timerDelayHandler);
this.autoRepeatTimer.delay = getStyle("repeatInterval");
this.autoRepeatTimer.addEventListener(flash.events.TimerEvent.TIMER, this.autoRepeatTimer_timerHandler);
this.autoRepeatTimer.start();
}
return;
}
internal function autoRepeatTimer_timerHandler(arg1:flash.events.Event):void
{
if (!enabled)
{
return;
}
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.BUTTON_DOWN));
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
mx_internal::TEXT_WIDTH_PADDING = mx.core.UITextField.mx_internal::TEXT_WIDTH_PADDING + 1;
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var skins:Array;
mx_internal var currentSkin:mx.core.IFlexDisplayObject;
internal var _listData:mx.controls.listClasses.BaseListData;
protected var icons:Array;
mx_internal var currentIcon:mx.core.IFlexDisplayObject;
internal var _phase:String="up";
mx_internal var phaseChanged:Boolean=false;
internal var autoRepeatTimer:flash.utils.Timer;
mx_internal var buttonOffset:Number=0;
mx_internal var _selected:Boolean=false;
mx_internal var centerContent:Boolean=true;
mx_internal var extraSpacing:Number=20;
internal var styleChangedFlag:Boolean=true;
public var selectedField:String=null;
internal var skinLayoutDirectionSet:Boolean=false;
internal var _skinLayoutDirection:String;
internal var skinMeasuredWidth:Number;
public var stickyHighlighting:Boolean=false;
mx_internal var _toggle:Boolean=false;
mx_internal var toggleChanged:Boolean=false;
internal var skinMeasuredHeight:Number;
internal var oldUnscaledWidth:Number;
internal var selectedSet:Boolean;
internal var labelSet:Boolean;
mx_internal var defaultSkinUsesStates:Boolean=false;
mx_internal var checkedDefaultIcon:Boolean=false;
mx_internal var defaultIconUsesStates:Boolean=false;
mx_internal var skinName:String="skin";
mx_internal var emphasizedSkinName:String="emphasizedSkin";
mx_internal var upSkinName:String="upSkin";
mx_internal var overSkinName:String="overSkin";
mx_internal var downSkinName:String="downSkin";
mx_internal var disabledSkinName:String="disabledSkin";
mx_internal var selectedUpSkinName:String="selectedUpSkin";
mx_internal var selectedOverSkinName:String="selectedOverSkin";
mx_internal var selectedDownSkinName:String="selectedDownSkin";
protected var _currentButtonState:String;
mx_internal var selectedDisabledSkinName:String="selectedDisabledSkin";
mx_internal var iconName:String="icon";
mx_internal var upIconName:String="upIcon";
mx_internal var overIconName:String="overIcon";
mx_internal var downIconName:String="downIcon";
mx_internal var disabledIconName:String="disabledIcon";
mx_internal var selectedUpIconName:String="selectedUpIcon";
mx_internal var _labelPlacement:String="right";
mx_internal var selectedOverIconName:String="selectedOverIcon";
mx_internal var selectedDownIconName:String="selectedDownIcon";
mx_internal var selectedDisabledIconName:String="selectedDisabledIcon";
internal var enabledChanged:Boolean=false;
protected var textField:mx.core.IUITextField;
internal var toolTipSet:Boolean=false;
internal var _autoRepeat:Boolean=false;
internal var _data:Object;
mx_internal var _emphasized:Boolean=false;
internal var emphasizedChanged:Boolean=false;
internal var _label:String="";
internal var labelChanged:Boolean=false;
mx_internal static var createAccessibilityImplementation:Function;
mx_internal static var TEXT_WIDTH_PADDING:Number=6;
mx_internal var checkedDefaultSkin:Boolean=false;
}
}
// class ButtonLabelPlacement
package mx.controls
{
import mx.core.*;
use namespace mx_internal;
public final class ButtonLabelPlacement extends Object
{
public function ButtonLabelPlacement()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const BOTTOM:String="bottom";
public static const LEFT:String="left";
public static const RIGHT:String="right";
public static const TOP:String="top";
}
}
// class ButtonPhase
package mx.controls
{
import mx.core.*;
use namespace mx_internal;
public final class ButtonPhase extends Object
{
public function ButtonPhase()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const DOWN:String="down";
public static const OVER:String="over";
public static const UP:String="up";
}
}
// class HScrollBar
package mx.controls
{
import flash.geom.*;
import flash.ui.*;
import mx.controls.scrollClasses.*;
import mx.core.*;
use namespace mx_internal;
public class HScrollBar extends mx.controls.scrollClasses.ScrollBar
{
public function HScrollBar()
{
super();
super.direction = mx.controls.scrollClasses.ScrollBarDirection.HORIZONTAL;
scaleX = -1;
rotation = -90;
return;
}
public override function set direction(arg1:String):void
{
return;
}
public override function get minWidth():Number
{
return mx_internal::_minHeight;
}
public override function get minHeight():Number
{
return mx_internal::_minWidth;
}
mx_internal override function get virtualHeight():Number
{
return unscaledWidth;
}
mx_internal override function get virtualWidth():Number
{
return unscaledHeight;
}
protected override function measure():void
{
super.measure();
measuredWidth = mx_internal::_minHeight;
measuredHeight = mx_internal::_minWidth;
return;
}
protected override function nonDeltaLayoutMatrix():flash.geom.Matrix
{
var loc1:*=new flash.geom.Matrix(0, 1, 1, 0);
var loc2:*=super.nonDeltaLayoutMatrix();
if (loc2)
{
loc1.concat(loc2);
}
return loc1;
}
mx_internal override function isScrollBarKey(arg1:uint):Boolean
{
var loc1:*=0;
if (arg1 == flash.ui.Keyboard.LEFT)
{
loc1 = mx.core.LayoutDirection.LTR ? -1 : 1;
mx_internal::lineScroll(loc1);
return true;
}
if (arg1 == flash.ui.Keyboard.RIGHT)
{
loc1 = mx.core.LayoutDirection.LTR ? 1 : -1;
mx_internal::lineScroll(loc1);
return true;
}
return super.mx_internal::isScrollBarKey(arg1);
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class IFlexContextMenu
package mx.controls
{
import flash.display.*;
public interface IFlexContextMenu
{
function setContextMenu(arg1:flash.display.InteractiveObject):void;
function unsetContextMenu(arg1:flash.display.InteractiveObject):void;
}
}
// class Image
package mx.controls
{
import flash.display.*;
import flash.events.*;
import mx.controls.listClasses.*;
import mx.core.*;
import mx.events.*;
use namespace mx_internal;
public class Image extends mx.controls.SWFLoader implements mx.core.IDataRenderer, mx.controls.listClasses.IDropInListItemRenderer, mx.controls.listClasses.IListItemRenderer
{
public function Image()
{
super();
tabChildren = false;
tabEnabled = true;
tabFocusEnabled = true;
showInAutomationHierarchy = true;
return;
}
public override function set source(arg1:Object):void
{
this.settingBrokenImage = arg1 == getStyle("brokenImageSkin");
this.sourceSet = !this.settingBrokenImage;
super.source = arg1;
return;
}
public function get data():Object
{
return this._data;
}
public function set data(arg1:Object):void
{
this._data = arg1;
if (!this.sourceSet)
{
this.source = this.listData ? this.listData.label : this.data;
this.sourceSet = false;
}
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.DATA_CHANGE));
return;
}
public function get listData():mx.controls.listClasses.BaseListData
{
return this._listData;
}
public function set listData(arg1:mx.controls.listClasses.BaseListData):void
{
this._listData = arg1;
return;
}
public override function invalidateSize():void
{
if (this.data && this.settingBrokenImage)
{
return;
}
super.invalidateSize();
return;
}
protected override function updateDisplayList(arg1:Number, arg2:Number):void
{
super.updateDisplayList(arg1, arg2);
if (this.makeContentVisible && mx_internal::contentHolder)
{
mx_internal::contentHolder.visible = true;
this.makeContentVisible = false;
}
return;
}
mx_internal override function contentLoaderInfo_completeEventHandler(arg1:flash.events.Event):void
{
var loc1:*=flash.display.DisplayObject(arg1.target.loader);
super.mx_internal::contentLoaderInfo_completeEventHandler(arg1);
loc1.visible = false;
this.makeContentVisible = true;
invalidateDisplayList();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var makeContentVisible:Boolean=false;
internal var sourceSet:Boolean;
internal var settingBrokenImage:Boolean;
internal var _data:Object;
internal var _listData:mx.controls.listClasses.BaseListData;
}
}
// class Label
package mx.controls
{
import flash.display.*;
import flash.events.*;
import flash.geom.*;
import flash.text.*;
import mx.controls.listClasses.*;
import mx.core.*;
import mx.events.*;
use namespace mx_internal;
public class Label extends mx.core.UIComponent implements mx.core.IDataRenderer, mx.controls.listClasses.IDropInListItemRenderer, mx.controls.listClasses.IListItemRenderer, mx.core.IFontContextComponent
{
public function Label()
{
super();
return;
}
protected override function initializeAccessibility():void
{
if (mx.controls.Label.mx_internal::createAccessibilityImplementation != null)
{
mx.controls.Label.mx_internal::createAccessibilityImplementation(this);
}
return;
}
public override function get baselinePosition():Number
{
if (!mx_internal::validateBaselinePosition())
{
return NaN;
}
return this.textField.y + this.textField.baselinePosition;
}
protected override function createChildren():void
{
super.createChildren();
if (!this.textField)
{
this.mx_internal::createTextField(-1);
}
return;
}
public override function set enabled(arg1:Boolean):void
{
if (arg1 == enabled)
{
return;
}
super.enabled = arg1;
this.enabledChanged = true;
invalidateProperties();
return;
}
protected override function commitProperties():void
{
super.commitProperties();
if (hasFontContextChanged() && !(this.textField == null))
{
this.mx_internal::removeTextField();
this.condenseWhiteChanged = true;
this.enabledChanged = true;
this.selectableChanged = true;
this.mx_internal::textChanged = true;
}
if (!this.textField)
{
this.mx_internal::createTextField(-1);
}
if (this.condenseWhiteChanged)
{
this.textField.condenseWhite = this._condenseWhite;
this.condenseWhiteChanged = false;
}
this.textField.tabIndex = this.tabIndex;
if (this.enabledChanged)
{
this.textField.enabled = enabled;
this.enabledChanged = false;
}
if (this.selectableChanged)
{
this.textField.selectable = this._selectable;
this.selectableChanged = false;
}
if (this.styleSheetChanged)
{
this.textField.styleSheet = this._styleSheet;
this.styleSheetChanged = false;
}
if (this.mx_internal::textChanged || this.mx_internal::htmlTextChanged)
{
if (this.isHTML)
{
this.textField.htmlText = this.explicitHTMLText;
}
else
{
this.textField.text = this._text;
}
this.textFieldChanged(false);
this.mx_internal::textChanged = false;
this.mx_internal::htmlTextChanged = false;
}
return;
}
protected override function measure():void
{
super.measure();
var loc1:*=this.isHTML ? this.explicitHTMLText : this.text;
loc1 = this.mx_internal::getMinimumText(loc1);
var loc2:*=this.measureTextFieldBounds(loc1);
var loc3:*;
measuredWidth = loc3 = loc2.width + getStyle("paddingLeft") + getStyle("paddingRight");
measuredMinWidth = loc3;
measuredHeight = loc3 = loc2.height + getStyle("paddingTop") + getStyle("paddingBottom");
measuredMinHeight = loc3;
return;
}
public override function set toolTip(arg1:String):void
{
super.toolTip = arg1;
this.toolTipSet = !(arg1 == null);
return;
}
protected override function updateDisplayList(arg1:Number, arg2:Number):void
{
var loc7:*=false;
super.updateDisplayList(arg1, arg2);
var loc1:*=getStyle("paddingLeft");
var loc2:*=getStyle("paddingTop");
var loc3:*=getStyle("paddingRight");
var loc4:*=getStyle("paddingBottom");
this.textField.setActualSize(arg1 - loc1 - loc3, arg2 - loc2 - loc4);
this.textField.x = loc1;
this.textField.y = loc2;
var loc5:*=this.isHTML ? this.explicitHTMLText : this.text;
var loc6:*=this.measureTextFieldBounds(loc5);
if (this.truncateToFit)
{
if (this.isHTML)
{
loc7 = loc6.width > this.textField.width;
}
else
{
this.textField.text = this._text;
loc7 = this.textField.truncateToFit();
}
if (!this.toolTipSet)
{
super.toolTip = loc7 ? this.text : null;
}
}
return;
}
mx_internal function createTextField(arg1:int):void
{
if (!this.textField)
{
this.textField = mx.core.IUITextField(createInFontContext(mx.core.UITextField));
this.textField.enabled = enabled;
this.textField.ignorePadding = true;
this.textField.selectable = this.selectable;
this.textField.styleName = this;
this.textField.addEventListener("textFieldStyleChange", this.textField_textFieldStyleChangeHandler);
this.textField.addEventListener("textInsert", this.textField_textModifiedHandler);
this.textField.addEventListener("textReplace", this.textField_textModifiedHandler);
if (arg1 != -1)
{
addChildAt(flash.display.DisplayObject(this.textField), arg1);
}
else
{
addChild(flash.display.DisplayObject(this.textField));
}
}
return;
}
public function get condenseWhite():Boolean
{
return this._condenseWhite;
}
public function set condenseWhite(arg1:Boolean):void
{
if (arg1 == this._condenseWhite)
{
return;
}
this._condenseWhite = arg1;
this.condenseWhiteChanged = true;
if (this.isHTML)
{
this.mx_internal::htmlTextChanged = true;
}
invalidateProperties();
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("condenseWhiteChanged"));
return;
}
mx_internal function removeTextField():void
{
if (this.textField)
{
this.textField.removeEventListener("textFieldStyleChange", this.textField_textFieldStyleChangeHandler);
this.textField.removeEventListener("textInsert", this.textField_textModifiedHandler);
this.textField.removeEventListener("textReplace", this.textField_textModifiedHandler);
removeChild(flash.display.DisplayObject(this.textField));
this.textField = null;
}
return;
}
public function get data():Object
{
return this._data;
}
public function set data(arg1:Object):void
{
var loc1:*=undefined;
this._data = arg1;
if (this._listData)
{
loc1 = this._listData.label;
}
else if (this._data != null)
{
if (this._data is String)
{
loc1 = String(this._data);
}
else
{
loc1 = this._data.toString();
}
}
if (!(loc1 === undefined) && !this.textSet)
{
this.text = loc1;
this.textSet = false;
}
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.DATA_CHANGE));
return;
}
public function get fontContext():mx.core.IFlexModuleFactory
{
return moduleFactory;
}
public function set fontContext(arg1:mx.core.IFlexModuleFactory):void
{
this.moduleFactory = arg1;
return;
}
public function getLineMetrics(arg1:int):flash.text.TextLineMetrics
{
return this.textField ? this.textField.getLineMetrics(arg1) : null;
}
internal function textFieldChanged(arg1:Boolean):void
{
var loc1:*=false;
var loc2:*=false;
if (!arg1)
{
loc1 = !(this._text == this.textField.text);
this._text = this.textField.text;
}
loc2 = !(this._htmlText == this.textField.htmlText);
this._htmlText = this.textField.htmlText;
if (loc1)
{
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.VALUE_COMMIT));
}
if (loc2)
{
dispatchEvent(new flash.events.Event("htmlTextChanged"));
}
this._textWidth = this.textField.textWidth;
this._textHeight = this.textField.textHeight;
return;
}
mx_internal function getTextField():mx.core.IUITextField
{
return this.textField;
}
public function get htmlText():String
{
return this._htmlText;
}
public function set htmlText(arg1:String):void
{
this.textSet = true;
if (!arg1)
{
arg1 = "";
}
if (this.isHTML && arg1 == this.explicitHTMLText)
{
return;
}
this._htmlText = arg1;
this.mx_internal::htmlTextChanged = true;
this._text = null;
this.explicitHTMLText = arg1;
invalidateProperties();
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("htmlTextChanged"));
return;
}
internal function get isHTML():Boolean
{
return !(this.explicitHTMLText == null);
}
mx_internal function getMinimumText(arg1:String):String
{
if (!arg1 || arg1.length < 2)
{
arg1 = "Wj";
}
return arg1;
}
public function get listData():mx.controls.listClasses.BaseListData
{
return this._listData;
}
public function set listData(arg1:mx.controls.listClasses.BaseListData):void
{
this._listData = arg1;
return;
}
internal function textField_textFieldStyleChangeHandler(arg1:flash.events.Event):void
{
this.textFieldChanged(true);
return;
}
internal function textField_textModifiedHandler(arg1:flash.events.Event):void
{
this.textFieldChanged(false);
return;
}
public function get selectable():Boolean
{
return this._selectable;
}
public function set selectable(arg1:Boolean):void
{
if (arg1 == this.selectable)
{
return;
}
this._selectable = arg1;
this.selectableChanged = true;
invalidateProperties();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
internal function measureTextFieldBounds(arg1:String):flash.geom.Rectangle
{
var loc1:*=this.isHTML ? measureHTMLText(arg1) : measureText(arg1);
return new flash.geom.Rectangle(0, 0, loc1.width + mx.core.UITextField.mx_internal::TEXT_WIDTH_PADDING, loc1.height + mx.core.UITextField.mx_internal::TEXT_HEIGHT_PADDING);
}
public function get styleSheet():flash.text.StyleSheet
{
return this._styleSheet;
}
public function set styleSheet(arg1:flash.text.StyleSheet):void
{
this._styleSheet = arg1;
this.styleSheetChanged = true;
this.mx_internal::htmlTextChanged = true;
invalidateProperties();
return;
}
public override function get tabIndex():int
{
return this._tabIndex;
}
public override function set tabIndex(arg1:int):void
{
this._tabIndex = arg1;
invalidateProperties();
return;
}
public function get text():String
{
return this._text;
}
public function set text(arg1:String):void
{
this.textSet = true;
if (!arg1)
{
arg1 = "";
}
if (!this.isHTML && arg1 == this._text)
{
return;
}
this._text = arg1;
this.mx_internal::textChanged = true;
this._htmlText = null;
this.explicitHTMLText = null;
invalidateProperties();
invalidateSize();
invalidateDisplayList();
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.VALUE_COMMIT));
return;
}
public function get textHeight():Number
{
return this._textHeight;
}
public function get textWidth():Number
{
return this._textWidth;
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var textSet:Boolean;
internal var enabledChanged:Boolean=false;
protected var textField:mx.core.IUITextField;
internal var toolTipSet:Boolean=false;
internal var _condenseWhite:Boolean=false;
internal var condenseWhiteChanged:Boolean=false;
internal var _data:Object;
internal var _htmlText:String="";
mx_internal var htmlTextChanged:Boolean=false;
internal var explicitHTMLText:String=null;
internal var _listData:mx.controls.listClasses.BaseListData;
internal var _selectable:Boolean=false;
internal var selectableChanged:Boolean;
internal var styleSheetChanged:Boolean=false;
mx_internal var textChanged:Boolean=false;
internal var _styleSheet:flash.text.StyleSheet;
internal var _textWidth:Number;
internal var _tabIndex:int=-1;
public var truncateToFit:Boolean=true;
internal var _text:String="";
mx_internal static var createAccessibilityImplementation:Function;
internal var _textHeight:Number;
}
}
// class SWFLoader
package mx.controls
{
import flash.display.*;
import flash.events.*;
import flash.geom.*;
import flash.net.*;
import flash.system.*;
import flash.utils.*;
import mx.core.*;
import mx.events.*;
import mx.managers.*;
import mx.styles.*;
import mx.utils.*;
use namespace mx_internal;
public class SWFLoader extends mx.core.UIComponent implements mx.core.ISWFLoader
{
public function SWFLoader()
{
super();
tabEnabled = false;
tabFocusEnabled = false;
addEventListener(mx.events.FlexEvent.INITIALIZE, this.initializeHandler);
addEventListener(flash.events.Event.ADDED_TO_STAGE, this.addedToStageHandler);
addEventListener(flash.events.MouseEvent.CLICK, this.clickHandler);
showInAutomationHierarchy = false;
return;
}
internal function getHorizontalAlignValue():Number
{
var loc1:*=getStyle("horizontalAlign");
if (loc1 == "left")
{
return 0;
}
if (loc1 == "right")
{
return 1;
}
return 0.5;
}
internal function getVerticalAlignValue():Number
{
var loc1:*=getStyle("verticalAlign");
if (loc1 == "top")
{
return 0;
}
if (loc1 == "bottom")
{
return 1;
}
return 0.5;
}
internal function dispatchInvalidateRequest(arg1:Boolean, arg2:Boolean, arg3:Boolean):void
{
var loc1:*=systemManager;
var loc2:*;
if (!(loc2 = mx.managers.IMarshalSystemManager(systemManager.getImplementation("mx.managers::IMarshalSystemManager"))) || !loc2.useSWFBridge())
{
return;
}
var loc3:*=loc2.swfBridgeGroup.parentBridge;
var loc4:*=0;
if (arg1)
{
loc4 = loc4 | mx.events.InvalidateRequestData.PROPERTIES;
}
if (arg2)
{
loc4 = loc4 | mx.events.InvalidateRequestData.SIZE;
}
if (arg3)
{
loc4 = loc4 | mx.events.InvalidateRequestData.DISPLAY_LIST;
}
var loc5:*=new mx.events.SWFBridgeRequest(mx.events.SWFBridgeRequest.INVALIDATE_REQUEST, false, false, loc3, loc4);
loc3.dispatchEvent(loc5);
return;
}
internal function initializeHandler(arg1:mx.events.FlexEvent):void
{
if (this.contentChanged)
{
this.contentChanged = false;
if (this._autoLoad)
{
this.load(this._source);
}
}
return;
}
internal function addedToStageHandler(arg1:flash.events.Event):void
{
systemManager.getSandboxRoot().addEventListener(mx.events.InterManagerRequest.DRAG_MANAGER_REQUEST, this.mouseShieldHandler, false, 0, true);
return;
}
mx_internal function contentLoaderInfo_completeEventHandler(arg1:flash.events.Event):void
{
if (flash.display.LoaderInfo(arg1.target).loader != this.mx_internal::contentHolder)
{
return;
}
dispatchEvent(arg1);
this.contentLoaded();
return;
}
internal function contentLoaderInfo_httpStatusEventHandler(arg1:flash.events.HTTPStatusEvent):void
{
dispatchEvent(arg1);
return;
}
internal function contentLoaderInfo_initEventHandler(arg1:flash.events.Event):void
{
dispatchEvent(arg1);
var loc1:*=flash.display.LoaderInfo(arg1.target);
this.addInitSystemManagerCompleteListener(loc1.loader.contentLoaderInfo);
if (loc1.contentType == "application/x-shockwave-flash" && loc1.parentAllowsChild && loc1.childAllowsParent && loc1.content)
{
loc1.content.addEventListener(mx.events.Request.GET_PARENT_FLEX_MODULE_FACTORY_REQUEST, this.contentHolder_getFlexModuleFactoryRequestHandler);
}
return;
}
internal function addInitSystemManagerCompleteListener(arg1:flash.display.LoaderInfo):void
{
var loc1:*=null;
if (arg1.contentType == "application/x-shockwave-flash")
{
loc1 = arg1.sharedEvents;
loc1.addEventListener(mx.events.SWFBridgeEvent.BRIDGE_NEW_APPLICATION, this.initSystemManagerCompleteEventHandler);
}
return;
}
internal function removeInitSystemManagerCompleteListener(arg1:flash.display.LoaderInfo):void
{
var loc1:*=null;
if (arg1.contentType == "application/x-shockwave-flash")
{
loc1 = arg1.sharedEvents;
loc1.removeEventListener(mx.events.SWFBridgeEvent.BRIDGE_NEW_APPLICATION, this.initSystemManagerCompleteEventHandler);
}
return;
}
internal function contentLoaderInfo_ioErrorEventHandler(arg1:flash.events.IOErrorEvent):void
{
this.source = getStyle("brokenImageSkin");
this.load();
this.contentChanged = false;
this.brokenImage = true;
if (hasEventListener(arg1.type))
{
dispatchEvent(arg1);
}
if (this.mx_internal::contentHolder is flash.display.Loader)
{
this.removeInitSystemManagerCompleteListener(flash.display.Loader(this.mx_internal::contentHolder).contentLoaderInfo);
}
return;
}
public function get bytesLoaded():Number
{
return this._bytesLoaded;
}
internal function contentLoaderInfo_openEventHandler(arg1:flash.events.Event):void
{
dispatchEvent(arg1);
return;
}
internal function contentLoaderInfo_progressEventHandler(arg1:flash.events.ProgressEvent):void
{
this._bytesTotal = arg1.bytesTotal;
this._bytesLoaded = arg1.bytesLoaded;
dispatchEvent(arg1);
return;
}
internal function contentLoaderInfo_securityErrorEventHandler(arg1:flash.events.SecurityErrorEvent):void
{
var loc1:*=null;
if (this.attemptingChildAppDomain)
{
this.attemptingChildAppDomain = false;
loc1 = new flash.system.LoaderContext();
this._loaderContext = loc1;
callLater(this.load);
return;
}
dispatchEvent(arg1);
if (this.mx_internal::contentHolder is flash.display.Loader)
{
this.removeInitSystemManagerCompleteListener(flash.display.Loader(this.mx_internal::contentHolder).contentLoaderInfo);
}
return;
}
internal function contentLoaderInfo_unloadEventHandler(arg1:flash.events.Event):void
{
var loc1:*=null;
var loc2:*=null;
this.isContentLoaded = false;
dispatchEvent(arg1);
if (this._swfBridge)
{
this._swfBridge.removeEventListener(mx.events.SWFBridgeRequest.INVALIDATE_REQUEST, this.invalidateRequestHandler);
loc1 = systemManager;
loc2 = mx.managers.IMarshalSystemManager(systemManager.getImplementation("mx.managers::IMarshalSystemManager"));
loc2.removeChildBridge(this._swfBridge);
this._swfBridge = null;
}
return;
}
internal function contentHolder_getFlexModuleFactoryRequestHandler(arg1:flash.events.Event):void
{
if ("value" in arg1)
{
arg1["value"] = moduleFactory;
}
return;
}
public function get autoLoad():Boolean
{
return this._autoLoad;
}
public function set autoLoad(arg1:Boolean):void
{
if (this._autoLoad != arg1)
{
this._autoLoad = arg1;
this.contentChanged = true;
invalidateProperties();
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("autoLoadChanged"));
}
return;
}
internal function contentHolder_addedHandler(arg1:flash.events.Event):void
{
if (arg1.target == this.mx_internal::contentHolder)
{
return;
}
if (arg1.target is mx.core.IFlexModuleFactory)
{
arg1.target.addEventListener(mx.events.Request.GET_PARENT_FLEX_MODULE_FACTORY_REQUEST, this.contentHolder_getFlexModuleFactoryRequestHandler);
}
this.mx_internal::contentHolder.removeEventListener(flash.events.Event.ADDED, this.contentHolder_addedHandler);
return;
}
public function get loadForCompatibility():Boolean
{
return this._loadForCompatibility;
}
public function set loadForCompatibility(arg1:Boolean):void
{
if (this._loadForCompatibility != arg1)
{
this._loadForCompatibility = arg1;
this.contentChanged = true;
invalidateProperties();
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("loadForCompatibilityChanged"));
}
return;
}
internal function initSystemManagerCompleteEventHandler(arg1:flash.events.Event):void
{
var loc2:*=null;
var loc1:*=Object(arg1);
if (this.mx_internal::contentHolder is flash.display.Loader && loc1.data == flash.display.Loader(this.mx_internal::contentHolder).contentLoaderInfo.sharedEvents)
{
this._swfBridge = flash.display.Loader(this.mx_internal::contentHolder).contentLoaderInfo.sharedEvents;
this.flexContent = true;
this.unScaleContent();
loc2 = systemManager;
mx.managers.IMarshalSystemManager(loc2.getImplementation("mx.managers::IMarshalSystemManager")).addChildBridge(this._swfBridge, this);
this.removeInitSystemManagerCompleteListener(flash.display.Loader(this.mx_internal::contentHolder).contentLoaderInfo);
this._swfBridge.addEventListener(mx.events.SWFBridgeRequest.INVALIDATE_REQUEST, this.invalidateRequestHandler);
}
return;
}
internal function invalidateRequestHandler(arg1:flash.events.Event):void
{
if (arg1 is mx.events.SWFBridgeRequest)
{
return;
}
var loc1:*=mx.events.SWFBridgeRequest.marshal(arg1);
var loc2:*=uint(loc1.data);
if (loc2 & mx.events.InvalidateRequestData.PROPERTIES)
{
invalidateProperties();
}
if (loc2 & mx.events.InvalidateRequestData.SIZE)
{
invalidateSize();
}
if (loc2 & mx.events.InvalidateRequestData.DISPLAY_LIST)
{
invalidateDisplayList();
}
this.dispatchInvalidateRequest(!((loc2 & mx.events.InvalidateRequestData.PROPERTIES) == 0), !((loc2 & mx.events.InvalidateRequestData.SIZE) == 0), !((loc2 & mx.events.InvalidateRequestData.DISPLAY_LIST) == 0));
return;
}
internal function mouseShieldHandler(arg1:flash.events.Event):void
{
if (arg1["name"] != "mouseShield")
{
return;
}
if (!this.isContentLoaded || this.parentAllowsChild)
{
return;
}
if (arg1["value"])
{
if (!this.mouseShield)
{
this.mouseShield = new flash.display.Sprite();
this.mouseShield.graphics.beginFill(0, 0);
this.mouseShield.graphics.drawRect(0, 0, 100, 100);
this.mouseShield.graphics.endFill();
}
if (!this.mouseShield.parent)
{
addChild(this.mouseShield);
}
this.sizeShield();
}
else if (this.mouseShield && this.mouseShield.parent)
{
removeChild(this.mouseShield);
}
return;
}
public function get bytesTotal():Number
{
return this._bytesTotal;
}
public function get content():flash.display.DisplayObject
{
if (this.mx_internal::contentHolder is flash.display.Loader)
{
return flash.display.Loader(this.mx_internal::contentHolder).content;
}
return this.mx_internal::contentHolder;
}
public function get contentHeight():Number
{
return this.mx_internal::contentHolder ? this.mx_internal::contentHolder.height : NaN;
}
internal function get contentHolderHeight():Number
{
var loaderInfo:flash.display.LoaderInfo;
var mp:mx.managers.IMarshalSystemManager;
var content:mx.core.IFlexDisplayObject;
var bridge:flash.events.IEventDispatcher;
var request:mx.events.SWFBridgeRequest;
var testContent:flash.display.DisplayObject;
var loc1:*;
loaderInfo = null;
mp = null;
content = null;
bridge = null;
request = null;
testContent = null;
if (this.mx_internal::contentHolder is flash.display.Loader)
{
loaderInfo = flash.display.Loader(this.mx_internal::contentHolder).contentLoaderInfo;
}
if (loaderInfo)
{
if (loaderInfo.contentType != "application/x-shockwave-flash")
{
try
{
testContent = flash.display.Loader(this.mx_internal::contentHolder).content;
}
catch (error:Error)
{
return mx_internal::contentHolder.height;
}
}
else
{
try
{
mp = mx.managers.IMarshalSystemManager(systemManager.getImplementation("mx.managers::IMarshalSystemManager"));
if (mp && mp.swfBridgeGroup)
{
bridge = this.swfBridge;
if (bridge)
{
request = new mx.events.SWFBridgeRequest(mx.events.SWFBridgeRequest.GET_SIZE_REQUEST);
bridge.dispatchEvent(request);
return request.data.height;
}
}
content = flash.display.Loader(this.mx_internal::contentHolder).content as mx.core.IFlexDisplayObject;
if (content)
{
return content.measuredHeight;
}
}
catch (error:Error)
{
return mx_internal::contentHolder.height;
}
}
return loaderInfo.height;
}
if (this.mx_internal::contentHolder is mx.core.IUIComponent)
{
return mx.core.IUIComponent(this.mx_internal::contentHolder).getExplicitOrMeasuredHeight();
}
if (this.mx_internal::contentHolder is mx.core.IFlexDisplayObject)
{
return mx.core.IFlexDisplayObject(this.mx_internal::contentHolder).measuredHeight;
}
return this.mx_internal::contentHolder.height;
}
internal function get contentHolderWidth():Number
{
var loaderInfo:flash.display.LoaderInfo;
var content:mx.core.IFlexDisplayObject;
var request:mx.events.SWFBridgeRequest;
var testContent:flash.display.DisplayObject;
var loc1:*;
loaderInfo = null;
content = null;
request = null;
testContent = null;
if (this.mx_internal::contentHolder is flash.display.Loader)
{
loaderInfo = flash.display.Loader(this.mx_internal::contentHolder).contentLoaderInfo;
}
if (loaderInfo)
{
if (loaderInfo.contentType != "application/x-shockwave-flash")
{
try
{
testContent = flash.display.Loader(this.mx_internal::contentHolder).content;
}
catch (error:Error)
{
return mx_internal::contentHolder.width;
}
}
else
{
try
{
if (this.swfBridge)
{
request = new mx.events.SWFBridgeRequest(mx.events.SWFBridgeRequest.GET_SIZE_REQUEST);
this.swfBridge.dispatchEvent(request);
return request.data.width;
}
content = flash.display.Loader(this.mx_internal::contentHolder).content as mx.core.IFlexDisplayObject;
if (content)
{
return content.measuredWidth;
}
}
catch (error:Error)
{
return mx_internal::contentHolder.width;
}
}
return loaderInfo.width;
}
if (this.mx_internal::contentHolder is mx.core.IUIComponent)
{
return mx.core.IUIComponent(this.mx_internal::contentHolder).getExplicitOrMeasuredWidth();
}
if (this.mx_internal::contentHolder is mx.core.IFlexDisplayObject)
{
return mx.core.IFlexDisplayObject(this.mx_internal::contentHolder).measuredWidth;
}
return this.mx_internal::contentHolder.width;
}
public function get contentWidth():Number
{
return this.mx_internal::contentHolder ? this.mx_internal::contentHolder.width : NaN;
}
internal function sizeShield():void
{
if (this.mouseShield && this.mouseShield.parent)
{
this.mouseShield.width = unscaledWidth;
this.mouseShield.height = unscaledHeight;
}
return;
}
public function get loaderContext():flash.system.LoaderContext
{
return this._loaderContext;
}
public function set loaderContext(arg1:flash.system.LoaderContext):void
{
this._loaderContext = arg1;
this.explicitLoaderContext = true;
dispatchEvent(new flash.events.Event("loaderContextChanged"));
return;
}
public override function regenerateStyleCache(arg1:Boolean):void
{
var recursive:Boolean;
var sm:mx.managers.ISystemManager;
var cm:Object;
var loc1:*;
sm = null;
cm = null;
recursive = arg1;
super.regenerateStyleCache(recursive);
try
{
sm = this.content as mx.managers.ISystemManager;
if (sm != null)
{
cm = sm.getImplementation("mx.managers::ISystemManagerChildManager");
Object(cm).regenerateStyleCache(recursive);
}
}
catch (error:Error)
{
};
return;
}
public function get maintainAspectRatio():Boolean
{
return this._maintainAspectRatio;
}
public function set maintainAspectRatio(arg1:Boolean):void
{
this._maintainAspectRatio = arg1;
dispatchEvent(new flash.events.Event("maintainAspectRatioChanged"));
return;
}
public function get source():Object
{
return this._source;
}
public function get percentLoaded():Number
{
var loc1:*=isNaN(this._bytesTotal) || this._bytesTotal == 0 ? 0 : 100 * this._bytesLoaded / this._bytesTotal;
if (isNaN(loc1))
{
loc1 = 0;
}
return loc1;
}
public override function notifyStyleChangeInChildren(arg1:String, arg2:Boolean):void
{
var styleProp:String;
var recursive:Boolean;
var sm:mx.managers.ISystemManager;
var cm:Object;
var loc1:*;
sm = null;
cm = null;
styleProp = arg1;
recursive = arg2;
super.notifyStyleChangeInChildren(styleProp, recursive);
try
{
sm = this.content as mx.managers.ISystemManager;
if (sm != null)
{
cm = sm.getImplementation("mx.managers::ISystemManagerChildManager");
Object(cm).notifyStyleChangeInChildren(styleProp, recursive);
}
}
catch (error:Error)
{
};
return;
}
public function get scaleContent():Boolean
{
return this._scaleContent;
}
public function set scaleContent(arg1:Boolean):void
{
if (this._scaleContent != arg1)
{
this._scaleContent = arg1;
this.scaleContentChanged = true;
invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("scaleContentChanged"));
return;
}
internal function getContentSize():flash.geom.Point
{
var loc3:*=null;
var loc4:*=null;
var loc1:*=new flash.geom.Point();
if (!this.mx_internal::contentHolder is flash.display.Loader)
{
return loc1;
}
var loc2:*=flash.display.Loader(this.mx_internal::contentHolder);
if (loc2.contentLoaderInfo.childAllowsParent)
{
loc1.x = loc2.content.width;
loc1.y = loc2.content.height;
}
else
{
loc3 = this.swfBridge;
if (loc3)
{
loc4 = new mx.events.SWFBridgeRequest(mx.events.SWFBridgeRequest.GET_SIZE_REQUEST);
loc3.dispatchEvent(loc4);
loc1.x = loc4.data.width;
loc1.y = loc4.data.height;
}
}
if (loc1.x == 0)
{
loc1.x = loc2.contentLoaderInfo.width;
}
if (loc1.y == 0)
{
loc1.y = loc2.contentLoaderInfo.height;
}
return loc1;
}
public function get showBusyCursor():Boolean
{
return this._showBusyCursor;
}
public function set showBusyCursor(arg1:Boolean):void
{
if (this._showBusyCursor != arg1)
{
this._showBusyCursor = arg1;
if (this._showBusyCursor)
{
mx.managers.CursorManager.mx_internal::registerToUseBusyCursor(this);
}
else
{
mx.managers.CursorManager.mx_internal::unRegisterToUseBusyCursor(this);
}
}
return;
}
protected function clickHandler(arg1:flash.events.MouseEvent):void
{
if (!enabled)
{
arg1.stopImmediatePropagation();
return;
}
return;
}
public function get smoothBitmapContent():Boolean
{
return this._smoothBitmapContent;
}
public function set smoothBitmapContent(arg1:Boolean):void
{
if (this._smoothBitmapContent != arg1)
{
this._smoothBitmapContent = arg1;
this.smoothBitmapContentChanged = true;
invalidateDisplayList();
}
dispatchEvent(new flash.events.Event("smoothBitmapContentChanged"));
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
public function unloadAndStop(arg1:Boolean=true):void
{
this.useUnloadAndStop = true;
this.unloadAndStopGC = arg1;
this.source = null;
if (!this.autoLoad)
{
this.load(null);
}
return;
}
public function set source(arg1:Object):void
{
if (this._source != arg1)
{
this._source = arg1;
this.contentChanged = true;
invalidateProperties();
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("sourceChanged"));
}
return;
}
public function get trustContent():Boolean
{
return this._trustContent;
}
public function set trustContent(arg1:Boolean):void
{
if (this._trustContent != arg1)
{
this._trustContent = arg1;
invalidateProperties();
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("trustContentChanged"));
}
return;
}
public function get swfBridge():flash.events.IEventDispatcher
{
return this._swfBridge;
}
public function get childAllowsParent():Boolean
{
var loc1:*;
if (!this.isContentLoaded)
{
return false;
}
try
{
if (this.mx_internal::contentHolder is flash.display.Loader)
{
return flash.display.Loader(this.mx_internal::contentHolder).contentLoaderInfo.childAllowsParent;
}
}
catch (error:Error)
{
return false;
}
return true;
}
public function get parentAllowsChild():Boolean
{
var loc1:*;
if (!this.isContentLoaded)
{
return false;
}
try
{
if (this.mx_internal::contentHolder is flash.display.Loader)
{
return flash.display.Loader(this.mx_internal::contentHolder).contentLoaderInfo.parentAllowsChild;
}
}
catch (error:Error)
{
return false;
}
return true;
}
protected override function commitProperties():void
{
super.commitProperties();
if (this.contentChanged)
{
this.contentChanged = false;
if (this._autoLoad)
{
this.load(this._source);
}
}
return;
}
protected override function measure():void
{
var loc1:*=NaN;
var loc2:*=NaN;
super.measure();
if (this.isContentLoaded)
{
loc1 = this.mx_internal::contentHolder.scaleX;
loc2 = this.mx_internal::contentHolder.scaleY;
this.mx_internal::contentHolder.scaleX = 1;
this.mx_internal::contentHolder.scaleY = 1;
measuredWidth = this.contentHolderWidth;
measuredHeight = this.contentHolderHeight;
this.mx_internal::contentHolder.scaleX = loc1;
this.mx_internal::contentHolder.scaleY = loc2;
}
else if (!this._source || this._source == "")
{
measuredWidth = 0;
measuredHeight = 0;
}
return;
}
protected override function updateDisplayList(arg1:Number, arg2:Number):void
{
var loc1:*=null;
super.updateDisplayList(arg1, arg2);
if (this.contentChanged)
{
this.contentChanged = false;
if (this._autoLoad)
{
this.load(this._source);
}
}
if (this.isContentLoaded)
{
if (this._scaleContent && !this.brokenImage)
{
this.doScaleContent();
}
else
{
this.doScaleLoader();
}
this.scaleContentChanged = false;
if (this.smoothBitmapContentChanged)
{
this.doSmoothBitmapContent();
this.smoothBitmapContentChanged = false;
}
}
if (this.brokenImage && !this.brokenImageBorder)
{
loc1 = getStyle("brokenImageBorderSkin");
if (loc1)
{
this.brokenImageBorder = mx.core.IFlexDisplayObject(new loc1());
if (this.brokenImageBorder is mx.styles.ISimpleStyleClient)
{
mx.styles.ISimpleStyleClient(this.brokenImageBorder).styleName = this;
}
addChild(flash.display.DisplayObject(this.brokenImageBorder));
}
}
else if (!this.brokenImage && this.brokenImageBorder)
{
removeChild(flash.display.DisplayObject(this.brokenImageBorder));
this.brokenImageBorder = null;
}
if (this.brokenImageBorder)
{
this.brokenImageBorder.setActualSize(arg1, arg2);
}
this.sizeShield();
return;
}
public function load(arg1:Object=null):void
{
if (arg1)
{
this._source = arg1;
}
this.unloadContent();
this.isContentLoaded = false;
this.brokenImage = false;
this.useUnloadAndStop = false;
this.contentChanged = false;
if (!this._source || this._source == "")
{
return;
}
this.loadContent(this._source);
return;
}
public function getVisibleApplicationRect(arg1:Boolean=false):flash.geom.Rectangle
{
var loc1:*=getVisibleRect();
if (arg1)
{
loc1 = systemManager.getVisibleApplicationRect(loc1);
}
return loc1;
}
internal function unloadContent():void
{
var imageData:flash.display.Bitmap;
var contentLoader:flash.display.Loader;
var request:mx.events.SWFBridgeEvent;
var loc1:*;
imageData = null;
contentLoader = null;
request = null;
if (this.mx_internal::contentHolder)
{
if (this.isContentLoaded)
{
if (this.mx_internal::contentHolder is flash.display.Loader)
{
contentLoader = flash.display.Loader(this.mx_internal::contentHolder);
try
{
if (contentLoader.content is flash.display.Bitmap)
{
imageData = flash.display.Bitmap(contentLoader.content);
if (imageData.bitmapData)
{
imageData.bitmapData = null;
}
}
}
catch (error:Error)
{
};
if (this._swfBridge)
{
request = new mx.events.SWFBridgeEvent(mx.events.SWFBridgeEvent.BRIDGE_APPLICATION_UNLOADING, false, false, this._swfBridge);
this._swfBridge.dispatchEvent(request);
}
if (contentLoader.contentLoaderInfo.contentType == "application/x-shockwave-flash" && contentLoader.contentLoaderInfo.parentAllowsChild && contentLoader.contentLoaderInfo.childAllowsParent && contentLoader.content)
{
contentLoader.content.removeEventListener(mx.events.Request.GET_PARENT_FLEX_MODULE_FACTORY_REQUEST, this.contentHolder_getFlexModuleFactoryRequestHandler);
}
this.mx_internal::contentHolder.removeEventListener(flash.events.Event.ADDED, this.contentHolder_addedHandler);
this.removeInitSystemManagerCompleteListener(contentLoader.contentLoaderInfo);
if (this.useUnloadAndStop)
{
contentLoader.unloadAndStop(this.unloadAndStopGC);
}
else
{
contentLoader.unload();
}
if (!this.explicitLoaderContext)
{
this._loaderContext = null;
}
}
else if (this.mx_internal::contentHolder is flash.display.Bitmap)
{
imageData = flash.display.Bitmap(this.mx_internal::contentHolder);
if (imageData.bitmapData)
{
imageData.bitmapData = null;
}
}
}
else if (this.mx_internal::contentHolder is flash.display.Loader)
{
try
{
flash.display.Loader(this.mx_internal::contentHolder).close();
}
catch (error:Error)
{
};
}
try
{
if (this.mx_internal::contentHolder.parent == this)
{
removeChild(this.mx_internal::contentHolder);
}
}
catch (error:Error)
{
try
{
removeChild(mx_internal::contentHolder);
}
catch (error1:Error)
{
};
}
this.mx_internal::contentHolder = null;
}
return;
}
internal function loadContent(arg1:Object):void
{
var classOrString:Object;
var child:flash.display.DisplayObject;
var cls:Class;
var url:String;
var byteArray:flash.utils.ByteArray;
var loader:flash.display.Loader;
var lc:flash.system.LoaderContext;
var rootURL:String;
var currentDomain:flash.system.ApplicationDomain;
var appDomain:flash.system.ApplicationDomain;
var topmostDomain:flash.system.ApplicationDomain;
var message:String;
var loc1:*;
child = null;
cls = null;
url = null;
byteArray = null;
loader = null;
lc = null;
rootURL = null;
currentDomain = null;
appDomain = null;
topmostDomain = null;
message = null;
classOrString = arg1;
if (classOrString is Class)
{
cls = Class(classOrString);
}
else if (classOrString is String)
{
try
{
cls = Class(systemManager.getDefinitionByName(String(classOrString)));
}
catch (e:Error)
{
};
url = String(classOrString);
}
else if (classOrString is flash.utils.ByteArray)
{
byteArray = flash.utils.ByteArray(classOrString);
}
else
{
url = classOrString.toString();
}
if (cls)
{
child = loc2 = new cls();
this.mx_internal::contentHolder = loc2;
this.mx_internal::contentHolder.addEventListener(flash.events.Event.ADDED, this.contentHolder_addedHandler, false, 0, true);
addChild(child);
this.contentLoaded();
}
else if (classOrString is flash.display.DisplayObject)
{
child = loc2 = flash.display.DisplayObject(classOrString);
this.mx_internal::contentHolder = loc2;
addChild(child);
this.contentLoaded();
this.mx_internal::contentHolder.addEventListener(mx.events.Request.GET_PARENT_FLEX_MODULE_FACTORY_REQUEST, this.contentHolder_getFlexModuleFactoryRequestHandler);
}
else if (byteArray)
{
loader = new mx.core.FlexLoader();
child = loc2 = loader;
this.mx_internal::contentHolder = loc2;
addChild(child);
loader.contentLoaderInfo.addEventListener(flash.events.Event.COMPLETE, this.mx_internal::contentLoaderInfo_completeEventHandler);
loader.contentLoaderInfo.addEventListener(flash.events.Event.INIT, this.contentLoaderInfo_initEventHandler);
loader.contentLoaderInfo.addEventListener(flash.events.IOErrorEvent.IO_ERROR, this.contentLoaderInfo_ioErrorEventHandler);
loader.contentLoaderInfo.addEventListener(flash.events.Event.UNLOAD, this.contentLoaderInfo_unloadEventHandler);
loader.loadBytes(byteArray, this.loaderContext);
}
else if (url)
{
loader = new mx.core.FlexLoader();
child = loc2 = loader;
this.mx_internal::contentHolder = loc2;
addChild(loader);
loader.contentLoaderInfo.addEventListener(flash.events.Event.COMPLETE, this.mx_internal::contentLoaderInfo_completeEventHandler);
loader.contentLoaderInfo.addEventListener(flash.events.HTTPStatusEvent.HTTP_STATUS, this.contentLoaderInfo_httpStatusEventHandler);
loader.contentLoaderInfo.addEventListener(flash.events.Event.INIT, this.contentLoaderInfo_initEventHandler);
loader.contentLoaderInfo.addEventListener(flash.events.IOErrorEvent.IO_ERROR, this.contentLoaderInfo_ioErrorEventHandler);
loader.contentLoaderInfo.addEventListener(flash.events.Event.OPEN, this.contentLoaderInfo_openEventHandler);
loader.contentLoaderInfo.addEventListener(flash.events.ProgressEvent.PROGRESS, this.contentLoaderInfo_progressEventHandler);
loader.contentLoaderInfo.addEventListener(flash.events.SecurityErrorEvent.SECURITY_ERROR, this.contentLoaderInfo_securityErrorEventHandler);
loader.contentLoaderInfo.addEventListener(flash.events.Event.UNLOAD, this.contentLoaderInfo_unloadEventHandler);
if (flash.system.Capabilities.isDebugger == true && url.indexOf(".jpg") == -1 && mx.utils.LoaderUtil.normalizeURL(mx.core.FlexGlobals.topLevelApplication.systemManager.loaderInfo).indexOf("debug=true") > -1)
{
url = url + (url.indexOf("?") > -1 ? "&debug=true" : "?debug=true");
}
if (url.indexOf(":") > -1 || url.indexOf("/") == 0 || url.indexOf("\\") == 0)
{
url = this.OSToPlayerURI(url, this.isLocal(url));
}
else
{
if (!(mx.managers.SystemManagerGlobals.bootstrapLoaderInfoURL == null) && !(mx.managers.SystemManagerGlobals.bootstrapLoaderInfoURL == ""))
{
rootURL = mx.managers.SystemManagerGlobals.bootstrapLoaderInfoURL;
}
else if (root)
{
rootURL = mx.utils.LoaderUtil.normalizeURL(root.loaderInfo);
}
else if (systemManager)
{
rootURL = mx.utils.LoaderUtil.normalizeURL(flash.display.DisplayObject(systemManager).loaderInfo);
}
url = this.OSToPlayerURI(url, this.isLocal(rootURL ? rootURL : url));
if (rootURL)
{
url = mx.utils.LoaderUtil.createAbsoluteURL(rootURL, url);
}
}
this.requestedURL = new flash.net.URLRequest(url);
lc = this.loaderContext;
if (!lc)
{
lc = new flash.system.LoaderContext();
this._loaderContext = lc;
if (moduleFactory && mx.core.FlexVersion.compatibilityVersion >= mx.core.FlexVersion.VERSION_4_0)
{
currentDomain = moduleFactory.info()["currentDomain"];
}
else
{
currentDomain = flash.system.ApplicationDomain.currentDomain;
}
if (this.loadForCompatibility)
{
appDomain = currentDomain.parentDomain;
topmostDomain = null;
while (appDomain)
{
topmostDomain = appDomain;
appDomain = appDomain.parentDomain;
}
lc.applicationDomain = new flash.system.ApplicationDomain(topmostDomain);
}
if (this.trustContent)
{
lc.securityDomain = flash.system.SecurityDomain.currentDomain;
}
else if (!this.loadForCompatibility)
{
this.attemptingChildAppDomain = true;
lc.applicationDomain = new flash.system.ApplicationDomain(currentDomain);
}
}
loader.load(this.requestedURL, lc);
}
else
{
message = resourceManager.getString("controls", "notLoadable", [this.source]);
throw new Error(message);
}
if (this.mx_internal::contentHolder && this.mx_internal::contentHolder is mx.core.ILayoutDirectionElement)
{
mx.core.ILayoutDirectionElement(this.mx_internal::contentHolder).layoutDirection = null;
}
invalidateDisplayList();
return;
}
internal function isLocal(arg1:String):Boolean
{
return arg1.indexOf("file:") == 0 || arg1.indexOf(":") == 1;
}
internal function OSToPlayerURI(arg1:String, arg2:Boolean):String
{
arg1 = decodeURI(arg1);
if (arg2 && flash.system.Capabilities.playerType == "ActiveX")
{
return arg1;
}
return encodeURI(arg1);
}
internal function contentLoaded():void
{
var loaderInfo:flash.display.LoaderInfo;
var loc1:*;
loaderInfo = null;
this.isContentLoaded = true;
if (this.mx_internal::contentHolder is flash.display.Loader)
{
loaderInfo = flash.display.Loader(this.mx_internal::contentHolder).contentLoaderInfo;
}
this.resizableContent = false;
if (loaderInfo)
{
if (loaderInfo.contentType == "application/x-shockwave-flash")
{
this.resizableContent = true;
}
if (this.resizableContent)
{
try
{
if (flash.display.Loader(this.mx_internal::contentHolder).content is mx.core.IFlexDisplayObject)
{
this.flexContent = true;
}
else
{
this.flexContent = !(this.swfBridge == null);
}
}
catch (e:Error)
{
flexContent = !(swfBridge == null);
}
}
}
try
{
if (tabChildren && this.mx_internal::contentHolder is flash.display.Loader && (loaderInfo.contentType == "application/x-shockwave-flash" || flash.display.Loader(this.mx_internal::contentHolder).content is flash.display.DisplayObjectContainer))
{
flash.display.Loader(this.mx_internal::contentHolder).tabChildren = true;
flash.display.DisplayObjectContainer(flash.display.Loader(this.mx_internal::contentHolder).content).tabChildren = true;
}
}
catch (e:Error)
{
};
invalidateSize();
invalidateDisplayList();
return;
}
internal function doScaleContent():void
{
var interiorWidth:Number;
var interiorHeight:Number;
var contentWidth:Number;
var contentHeight:Number;
var x:Number;
var y:Number;
var newXScale:Number;
var newYScale:Number;
var scale:Number;
var w:Number;
var h:Number;
var holder:flash.display.Loader;
var sizeSet:Boolean;
var lInfo:flash.display.LoaderInfo;
var loc1:*;
interiorWidth = NaN;
interiorHeight = NaN;
contentWidth = NaN;
contentHeight = NaN;
x = NaN;
y = NaN;
newXScale = NaN;
newYScale = NaN;
scale = NaN;
w = NaN;
h = NaN;
holder = null;
sizeSet = false;
lInfo = null;
if (!this.isContentLoaded)
{
return;
}
if (!this.resizableContent || this.maintainAspectRatio && !this.flexContent)
{
this.unScaleContent();
interiorWidth = unscaledWidth;
interiorHeight = unscaledHeight;
contentWidth = this.contentHolderWidth;
contentHeight = this.contentHolderHeight;
x = 0;
y = 0;
newXScale = contentWidth != 0 ? interiorWidth / contentWidth : 1;
newYScale = contentHeight != 0 ? interiorHeight / contentHeight : 1;
if (this._maintainAspectRatio)
{
if (newXScale > newYScale)
{
x = Math.floor((interiorWidth - contentWidth * newYScale) * this.getHorizontalAlignValue());
scale = newYScale;
}
else
{
y = Math.floor((interiorHeight - contentHeight * newXScale) * this.getVerticalAlignValue());
scale = newXScale;
}
this.mx_internal::contentHolder.scaleX = scale;
this.mx_internal::contentHolder.scaleY = scale;
}
else
{
this.mx_internal::contentHolder.scaleX = newXScale;
this.mx_internal::contentHolder.scaleY = newYScale;
}
this.mx_internal::contentHolder.x = x;
this.mx_internal::contentHolder.y = y;
}
else
{
this.mx_internal::contentHolder.x = 0;
this.mx_internal::contentHolder.y = 0;
w = unscaledWidth;
h = unscaledHeight;
if (this.mx_internal::contentHolder is flash.display.Loader)
{
holder = flash.display.Loader(this.mx_internal::contentHolder);
try
{
if (this.getContentSize().x > 0)
{
sizeSet = false;
if (holder.contentLoaderInfo.contentType == "application/x-shockwave-flash")
{
if (this.childAllowsParent)
{
if (holder.content is mx.core.IFlexDisplayObject)
{
mx.core.IFlexDisplayObject(holder.content).setActualSize(w, h);
sizeSet = true;
}
}
if (!sizeSet && this.swfBridge)
{
this.swfBridge.dispatchEvent(new mx.events.SWFBridgeRequest(mx.events.SWFBridgeRequest.SET_ACTUAL_SIZE_REQUEST, false, false, null, {"width":w, "height":h}));
sizeSet = true;
}
}
if (!sizeSet)
{
lInfo = holder.contentLoaderInfo;
if (lInfo)
{
this.mx_internal::contentHolder.scaleX = w / lInfo.width;
this.mx_internal::contentHolder.scaleY = h / lInfo.height;
}
else
{
this.mx_internal::contentHolder.width = w;
this.mx_internal::contentHolder.height = h;
}
}
}
else if (this.childAllowsParent && !(holder.content is mx.core.IFlexDisplayObject))
{
this.mx_internal::contentHolder.width = w;
this.mx_internal::contentHolder.height = h;
}
}
catch (error:Error)
{
mx_internal::contentHolder.width = w;
mx_internal::contentHolder.height = h;
}
if (!this.parentAllowsChild)
{
this.mx_internal::contentHolder.scrollRect = new flash.geom.Rectangle(0, 0, w / this.mx_internal::contentHolder.scaleX, h / this.mx_internal::contentHolder.scaleY);
}
}
else
{
this.mx_internal::contentHolder.width = w;
this.mx_internal::contentHolder.height = h;
}
}
return;
}
internal function doScaleLoader():void
{
if (!this.isContentLoaded)
{
return;
}
this.unScaleContent();
var loc1:*=unscaledWidth;
var loc2:*=unscaledHeight;
if (this.contentHolderWidth > loc1 || this.contentHolderHeight > loc2 || !this.parentAllowsChild)
{
this.mx_internal::contentHolder.scrollRect = new flash.geom.Rectangle(0, 0, loc1, loc2);
}
else
{
this.mx_internal::contentHolder.scrollRect = null;
}
this.mx_internal::contentHolder.x = (loc1 - this.contentHolderWidth) * this.getHorizontalAlignValue();
this.mx_internal::contentHolder.y = (loc2 - this.contentHolderHeight) * this.getVerticalAlignValue();
return;
}
internal function doSmoothBitmapContent():void
{
if (this.content is flash.display.Bitmap)
{
(this.content as flash.display.Bitmap).smoothing = this._smoothBitmapContent;
}
return;
}
internal function unScaleContent():void
{
this.mx_internal::contentHolder.scaleX = 1;
this.mx_internal::contentHolder.scaleY = 1;
this.mx_internal::contentHolder.x = 0;
this.mx_internal::contentHolder.y = 0;
return;
}
mx_internal static const VERSION:String="4.1.0.16076";
mx_internal var contentHolder:flash.display.DisplayObject;
internal var contentChanged:Boolean=false;
internal var scaleContentChanged:Boolean=false;
internal var smoothBitmapContentChanged:Boolean=false;
internal var isContentLoaded:Boolean=false;
internal var brokenImage:Boolean=false;
internal var resizableContent:Boolean=false;
internal var flexContent:Boolean=false;
internal var contentRequestID:String=null;
internal var attemptingChildAppDomain:Boolean=false;
internal var requestedURL:flash.net.URLRequest;
internal var explicitLoaderContext:Boolean=false;
internal var mouseShield:flash.display.Sprite;
internal var useUnloadAndStop:Boolean;
internal var unloadAndStopGC:Boolean;
internal var _autoLoad:Boolean=true;
internal var _loadForCompatibility:Boolean=false;
internal var _bytesLoaded:Number=NaN;
internal var brokenImageBorder:mx.core.IFlexDisplayObject;
internal var _bytesTotal:Number=NaN;
internal var _loaderContext:flash.system.LoaderContext;
internal var _maintainAspectRatio:Boolean=true;
internal var _scaleContent:Boolean=true;
internal var _showBusyCursor:Boolean=false;
internal var _smoothBitmapContent:Boolean=false;
internal var _source:Object;
internal var _trustContent:Boolean=false;
internal var _swfBridge:flash.events.IEventDispatcher;
}
}
// class ToolTip
package mx.controls
{
import flash.display.*;
import flash.text.*;
import mx.core.*;
import mx.styles.*;
use namespace mx_internal;
public class ToolTip extends mx.core.UIComponent implements mx.core.IToolTip, mx.core.IFontContextComponent
{
public function ToolTip()
{
super();
mouseEnabled = false;
return;
}
internal function get borderMetrics():mx.core.EdgeMetrics
{
if (this.mx_internal::border is mx.core.IRectangularBorder)
{
return mx.core.IRectangularBorder(this.mx_internal::border).borderMetrics;
}
return mx.core.EdgeMetrics.EMPTY;
}
public function get fontContext():mx.core.IFlexModuleFactory
{
return moduleFactory;
}
public function set fontContext(arg1:mx.core.IFlexModuleFactory):void
{
this.moduleFactory = arg1;
return;
}
public function get text():String
{
return this._text;
}
public function set text(arg1:String):void
{
this._text = arg1;
this.textChanged = true;
invalidateProperties();
invalidateSize();
invalidateDisplayList();
return;
}
protected override function createChildren():void
{
var loc1:*=null;
super.createChildren();
if (!this.mx_internal::border)
{
loc1 = getStyle("borderSkin");
this.mx_internal::border = new loc1();
if (this.mx_internal::border is mx.styles.ISimpleStyleClient)
{
mx.styles.ISimpleStyleClient(this.mx_internal::border).styleName = this;
}
addChild(flash.display.DisplayObject(this.mx_internal::border));
}
this.mx_internal::createTextField(-1);
return;
}
protected override function commitProperties():void
{
var loc1:*=0;
var loc2:*=null;
super.commitProperties();
if (hasFontContextChanged() && !(this.textField == null))
{
loc1 = getChildIndex(flash.display.DisplayObject(this.textField));
this.mx_internal::removeTextField();
this.mx_internal::createTextField(loc1);
invalidateSize();
this.textChanged = true;
}
if (this.textChanged)
{
loc2 = this.textField.getTextFormat();
loc2.leftMargin = 0;
loc2.rightMargin = 0;
this.textField.defaultTextFormat = loc2;
this.textField.text = this._text;
this.textChanged = false;
}
return;
}
protected override function measure():void
{
var loc7:*=NaN;
super.measure();
var loc1:*=this.borderMetrics;
var loc2:*=loc1.left + getStyle("paddingLeft");
var loc3:*=loc1.top + getStyle("paddingTop");
var loc4:*=loc1.right + getStyle("paddingRight");
var loc5:*=loc1.bottom + getStyle("paddingBottom");
var loc6:*=loc2 + loc4;
loc7 = loc3 + loc5;
this.textField.wordWrap = false;
if (this.textField.textWidth + loc6 > mx.controls.ToolTip.maxWidth)
{
this.textField.width = mx.controls.ToolTip.maxWidth - loc6;
this.textField.wordWrap = true;
}
measuredWidth = this.textField.width + loc6;
measuredHeight = this.textField.height + loc7;
return;
}
protected override function updateDisplayList(arg1:Number, arg2:Number):void
{
super.updateDisplayList(arg1, arg2);
var loc1:*=this.borderMetrics;
var loc2:*=loc1.left + getStyle("paddingLeft");
var loc3:*=loc1.top + getStyle("paddingTop");
var loc4:*=loc1.right + getStyle("paddingRight");
var loc5:*=loc1.bottom + getStyle("paddingBottom");
var loc6:*=loc2 + loc4;
var loc7:*=loc3 + loc5;
this.mx_internal::border.setActualSize(arg1, arg2);
this.textField.move(loc2, loc3);
this.textField.setActualSize(arg1 - loc6, arg2 - loc7);
return;
}
public override function styleChanged(arg1:String):void
{
super.styleChanged(arg1);
if (arg1 == "borderStyle" || arg1 == "styleName" || arg1 == null)
{
invalidateDisplayList();
}
return;
}
mx_internal function createTextField(arg1:int):void
{
if (!this.textField)
{
this.textField = mx.core.IUITextField(createInFontContext(mx.core.UITextField));
this.textField.autoSize = flash.text.TextFieldAutoSize.LEFT;
this.textField.mouseEnabled = false;
this.textField.multiline = true;
this.textField.selectable = false;
this.textField.wordWrap = false;
this.textField.styleName = this;
if (arg1 != -1)
{
addChildAt(flash.display.DisplayObject(this.textField), arg1);
}
else
{
addChild(flash.display.DisplayObject(this.textField));
}
}
return;
}
mx_internal function removeTextField():void
{
if (this.textField)
{
removeChild(flash.display.DisplayObject(this.textField));
this.textField = null;
}
return;
}
mx_internal function getTextField():mx.core.IUITextField
{
return this.textField;
}
{
mx_internal::VERSION = "4.1.0.16076";
maxWidth = 300;
}
mx_internal static const VERSION:String="4.1.0.16076";
mx_internal var border:mx.core.IFlexDisplayObject;
internal var _text:String;
internal var textChanged:Boolean;
protected var textField:mx.core.IUITextField;
public static var maxWidth:Number=300;
}
}
// class VScrollBar
package mx.controls
{
import flash.ui.*;
import mx.controls.scrollClasses.*;
import mx.core.*;
use namespace mx_internal;
public class VScrollBar extends mx.controls.scrollClasses.ScrollBar
{
public function VScrollBar()
{
super();
super.direction = mx.controls.scrollClasses.ScrollBarDirection.VERTICAL;
return;
}
public override function set direction(arg1:String):void
{
return;
}
public override function get minWidth():Number
{
return mx_internal::_minWidth;
}
public override function get minHeight():Number
{
return mx_internal::_minHeight;
}
protected override function measure():void
{
super.measure();
measuredWidth = mx_internal::_minWidth;
measuredHeight = mx_internal::_minHeight;
return;
}
mx_internal override function isScrollBarKey(arg1:uint):Boolean
{
if (arg1 == flash.ui.Keyboard.UP)
{
mx_internal::lineScroll(-1);
return true;
}
if (arg1 == flash.ui.Keyboard.DOWN)
{
mx_internal::lineScroll(1);
return true;
}
if (arg1 == flash.ui.Keyboard.PAGE_UP)
{
mx_internal::pageScroll(-1);
return true;
}
if (arg1 == flash.ui.Keyboard.PAGE_DOWN)
{
mx_internal::pageScroll(1);
return true;
}
return super.mx_internal::isScrollBarKey(arg1);
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// package core
// class AdvancedLayoutFeatures
package mx.core
{
import __AS3__.vec.*;
import flash.events.*;
import flash.geom.*;
import flash.system.*;
import mx.geom.*;
use namespace mx_internal;
public class AdvancedLayoutFeatures extends Object implements mx.core.IAssetLayoutFeatures
{
public function AdvancedLayoutFeatures()
{
super();
this.layout = new mx.geom.CompoundTransform();
return;
}
internal function completeTransformCenterAdjustment(arg1:Boolean, arg2:flash.geom.Vector3D, arg3:flash.geom.Vector3D, arg4:flash.geom.Vector3D):void
{
var loc1:*=null;
var loc2:*=null;
var loc3:*=null;
var loc4:*=null;
var loc5:*=null;
var loc6:*=null;
if (this.is3D || arg1)
{
if (arg3 != null)
{
if ((loc1 = transformVector(this.layoutMatrix3D, arg2)).equals(arg3) == false)
{
this.layout.translateBy(arg3.x - loc1.x, arg3.y - loc1.y, arg3.z - loc1.z);
this.invalidate();
}
}
if (!(arg4 == null) && !(this._postLayoutTransformOffsets == null))
{
loc2 = new flash.geom.Vector3D(arg2.x, arg2.y, arg2.z);
loc2.x = loc2.x / this.stretchX;
loc2.y = loc2.y / this.stretchY;
if ((loc3 = transformVector(this.computedMatrix3D, loc2)).equals(arg4) == false)
{
this.postLayoutTransformOffsets.x = this.postLayoutTransformOffsets.x + (arg4.x - loc3.x);
this.postLayoutTransformOffsets.y = this.postLayoutTransformOffsets.y + (arg4.y - loc3.y);
this.postLayoutTransformOffsets.z = this.postLayoutTransformOffsets.z + (arg4.z - loc3.z);
this.invalidate();
}
}
}
else
{
loc4 = new flash.geom.Point(arg2.x, arg2.y);
if (arg3 != null)
{
if (!((loc5 = this.layoutMatrix.transformPoint(loc4)).x == arg3.x) || !(loc5.y == arg3.y))
{
this.layout.translateBy(arg3.x - loc5.x, arg3.y - loc5.y, 0);
this.invalidate();
}
}
if (!(arg4 == null) && !(this._postLayoutTransformOffsets == null))
{
loc4.x = loc4.x / this.stretchX;
loc4.y = loc4.y / this.stretchY;
if (!((loc6 = this.computedMatrix.transformPoint(loc4)).x == arg4.x) || !(loc6.y == arg4.y))
{
this._postLayoutTransformOffsets.x = this._postLayoutTransformOffsets.x + (arg4.x - loc6.x);
this._postLayoutTransformOffsets.y = this._postLayoutTransformOffsets.y + (arg4.y - loc6.y);
this.invalidate();
}
}
}
return;
}
public function transformAround(arg1:flash.geom.Vector3D, arg2:flash.geom.Vector3D, arg3:flash.geom.Vector3D, arg4:flash.geom.Vector3D, arg5:flash.geom.Vector3D=null, arg6:flash.geom.Vector3D=null, arg7:flash.geom.Vector3D=null):void
{
var loc1:*=!(arg2 == null) && !(arg2.z == 1) || !(arg3 == null) && (!(arg3.x == 0) || !(arg3.y == 0)) || !(arg4 == null) && !(arg4.z == 0) || !(arg5 == null) && !(arg5.z == 1) || !(arg6 == null) && (!(arg6.x == 0) || !(arg6.y == 0)) || !(arg7 == null) && !(arg7.z == 0);
var loc2:*;
if (loc2 = this._postLayoutTransformOffsets == null && (!(arg5 == null) || !(arg6 == null) || !(arg7 == null)))
{
this._postLayoutTransformOffsets = new mx.geom.TransformOffsets();
}
if (!(arg1 == null) && (arg4 == null || arg7 == null))
{
this.transformPointToParent(loc1, arg1, staticTranslation, staticOffsetTranslation);
if (arg7 == null && !(arg4 == null))
{
staticOffsetTranslation.x = arg4.x + staticOffsetTranslation.x - staticTranslation.x;
staticOffsetTranslation.y = arg4.y + staticOffsetTranslation.y - staticTranslation.y;
staticOffsetTranslation.z = arg4.z + staticOffsetTranslation.z - staticTranslation.z;
}
}
var loc3:*=arg4 != null ? arg4 : staticTranslation;
var loc4:*=arg7 != null ? arg7 : staticOffsetTranslation;
if (arg3 != null)
{
if (!isNaN(arg3.x))
{
this.layout.rotationX = arg3.x;
}
if (!isNaN(arg3.y))
{
this.layout.rotationY = arg3.y;
}
if (!isNaN(arg3.z))
{
this.layout.rotationZ = arg3.z;
}
}
if (arg2 != null)
{
if (!isNaN(arg2.x))
{
this.layout.scaleX = arg2.x;
}
if (!isNaN(arg2.y))
{
this.layout.scaleY = arg2.y;
}
if (!isNaN(arg2.z))
{
this.layout.scaleZ = arg2.z;
}
}
if (arg6 != null)
{
this._postLayoutTransformOffsets.rotationX = arg6.x;
this._postLayoutTransformOffsets.rotationY = arg6.y;
this._postLayoutTransformOffsets.rotationZ = arg6.z;
}
if (arg5 != null)
{
this._postLayoutTransformOffsets.scaleX = arg5.x;
this._postLayoutTransformOffsets.scaleY = arg5.y;
this._postLayoutTransformOffsets.scaleZ = arg5.z;
}
if (arg1 == null)
{
if (arg4 != null)
{
this.layout.x = arg4.x;
this.layout.y = arg4.y;
this.layout.z = arg4.z;
}
if (arg7 != null)
{
this._postLayoutTransformOffsets.x = arg7.x - this.layout.x;
this._postLayoutTransformOffsets.y = arg7.y - this.layout.y;
this._postLayoutTransformOffsets.z = arg7.z - this.layout.z;
}
}
this.invalidate();
if (arg1 != null)
{
this.completeTransformCenterAdjustment(loc1, arg1, loc3, loc4);
}
return;
}
{
reVT = new flash.geom.Vector3D(0, 0, 0);
reVR = new flash.geom.Vector3D(0, 0, 0);
reVS = new flash.geom.Vector3D(1, 1, 1);
reV = new Vector.<flash.geom.Vector3D>();
transformVector = initTransformVectorFunction;
staticTranslation = new flash.geom.Vector3D();
staticOffsetTranslation = new flash.geom.Vector3D();
reV.push(reVT);
reV.push(reVR);
reV.push(reVS);
}
internal static function pre10_0_22_87_transformVector(arg1:flash.geom.Matrix3D, arg2:flash.geom.Vector3D):flash.geom.Vector3D
{
var loc1:*=arg1.rawData;
return new flash.geom.Vector3D(loc1[0] * arg2.x + loc1[4] * arg2.y + loc1[8] * arg2.z + loc1[12], loc1[1] * arg2.x + loc1[5] * arg2.y + loc1[9] * arg2.z + loc1[13], loc1[2] * arg2.x + loc1[6] * arg2.y + loc1[10] * arg2.z + loc1[14], 1);
}
internal static function nativeTransformVector(arg1:flash.geom.Matrix3D, arg2:flash.geom.Vector3D):flash.geom.Vector3D
{
return arg1.transformVector(arg2);
}
internal static function initTransformVectorFunction(arg1:flash.geom.Matrix3D, arg2:flash.geom.Vector3D):flash.geom.Vector3D
{
var loc1:*=false;
var loc2:*=flash.system.Capabilities.version.split(" ")[1].split(",");
if (parseFloat(loc2[0]) > 10)
{
loc1 = true;
}
else if (parseFloat(loc2[1]) > 0)
{
loc1 = true;
}
else if (parseFloat(loc2[2]) > 22)
{
loc1 = true;
}
else if (parseFloat(loc2[3]) >= 87)
{
loc1 = true;
}
if (loc1)
{
transformVector = nativeTransformVector;
}
else
{
transformVector = pre10_0_22_87_transformVector;
}
return transformVector(arg1, arg2);
}
public static function build2DMatrix(arg1:flash.geom.Matrix, arg2:Number, arg3:Number, arg4:Number, arg5:Number, arg6:Number, arg7:Number, arg8:Number):void
{
arg1.translate(-arg2, -arg3);
arg1.scale(arg4, arg5);
arg1.rotate(arg6 * RADIANS_PER_DEGREES);
arg1.translate(arg7 + arg2, arg8 + arg3);
return;
}
public function set layoutX(arg1:Number):void
{
this.layout.x = arg1;
this.invalidate();
return;
}
public function get layoutX():Number
{
return this.layout.x;
}
public function set layoutY(arg1:Number):void
{
this.layout.y = arg1;
this.invalidate();
return;
}
public function get layoutY():Number
{
return this.layout.y;
}
public function set layoutZ(arg1:Number):void
{
this.layout.z = arg1;
this.invalidate();
return;
}
public function get layoutZ():Number
{
return this.layout.z;
}
public static function build3DMatrix(arg1:flash.geom.Matrix3D, arg2:Number, arg3:Number, arg4:Number, arg5:Number, arg6:Number, arg7:Number, arg8:Number, arg9:Number, arg10:Number, arg11:Number, arg12:Number, arg13:Number):void
{
reVR.x = arg8 * RADIANS_PER_DEGREES;
reVR.y = arg9 * RADIANS_PER_DEGREES;
reVR.z = arg10 * RADIANS_PER_DEGREES;
arg1.recompose(reV);
if (arg5 == 0)
{
arg5 = ZERO_REPLACEMENT_IN_3D;
}
if (arg6 == 0)
{
arg6 = ZERO_REPLACEMENT_IN_3D;
}
if (arg7 == 0)
{
arg7 = ZERO_REPLACEMENT_IN_3D;
}
arg1.prependScale(arg5, arg6, arg7);
arg1.prependTranslation(-arg2, -arg3, -arg4);
arg1.appendTranslation(arg2 + arg11, arg3 + arg12, arg4 + arg13);
return;
}
public function get layoutWidth():Number
{
return this._layoutWidth;
}
public function set layoutWidth(arg1:Number):void
{
if (arg1 == this._layoutWidth)
{
return;
}
this._layoutWidth = arg1;
this.invalidate();
return;
}
public function set transformX(arg1:Number):void
{
this.layout.transformX = arg1;
this.invalidate();
return;
}
public function get transformX():Number
{
return this.layout.transformX;
}
public function set transformY(arg1:Number):void
{
this.layout.transformY = arg1;
this.invalidate();
return;
}
public function get transformY():Number
{
return this.layout.transformY;
}
public function set transformZ(arg1:Number):void
{
this.layout.transformZ = arg1;
this.invalidate();
return;
}
public function get transformZ():Number
{
return this.layout.transformZ;
}
public function set layoutRotationX(arg1:Number):void
{
this.layout.rotationX = arg1;
this.invalidate();
return;
}
public function get layoutRotationX():Number
{
return this.layout.rotationX;
}
public function set layoutRotationY(arg1:Number):void
{
this.layout.rotationY = arg1;
this.invalidate();
return;
}
public function get layoutRotationY():Number
{
return this.layout.rotationY;
}
public function set layoutRotationZ(arg1:Number):void
{
this.layout.rotationZ = arg1;
this.invalidate();
return;
}
public function get layoutRotationZ():Number
{
return this.layout.rotationZ;
}
public function set layoutScaleX(arg1:Number):void
{
this.layout.scaleX = arg1;
this.invalidate();
return;
}
public function get layoutScaleX():Number
{
return this.layout.scaleX;
}
public function set layoutScaleY(arg1:Number):void
{
this.layout.scaleY = arg1;
this.invalidate();
return;
}
public function get layoutScaleY():Number
{
return this.layout.scaleY;
}
public function set layoutScaleZ(arg1:Number):void
{
this.layout.scaleZ = arg1;
this.invalidate();
return;
}
public function get layoutScaleZ():Number
{
return this.layout.scaleZ;
}
public function set layoutMatrix(arg1:flash.geom.Matrix):void
{
this.layout.matrix = arg1;
this.invalidate();
return;
}
public function get layoutMatrix():flash.geom.Matrix
{
return this.layout.matrix;
}
public function set layoutMatrix3D(arg1:flash.geom.Matrix3D):void
{
this.layout.matrix3D = arg1;
this.invalidate();
return;
}
public function get layoutMatrix3D():flash.geom.Matrix3D
{
return this.layout.matrix3D;
}
public function get is3D():Boolean
{
return this.layout.is3D || !(this.postLayoutTransformOffsets == null) && this.postLayoutTransformOffsets.mx_internal::is3D;
}
public function get layoutIs3D():Boolean
{
return this.layout.is3D;
}
public function set postLayoutTransformOffsets(arg1:mx.geom.TransformOffsets):void
{
if (this._postLayoutTransformOffsets != null)
{
this._postLayoutTransformOffsets.removeEventListener(flash.events.Event.CHANGE, this.postLayoutTransformOffsetsChangedHandler);
this._postLayoutTransformOffsets.mx_internal::owner = null;
}
this._postLayoutTransformOffsets = arg1;
if (this._postLayoutTransformOffsets != null)
{
this._postLayoutTransformOffsets.addEventListener(flash.events.Event.CHANGE, this.postLayoutTransformOffsetsChangedHandler);
this._postLayoutTransformOffsets.mx_internal::owner = this;
}
this.invalidate();
return;
}
public function get postLayoutTransformOffsets():mx.geom.TransformOffsets
{
return this._postLayoutTransformOffsets;
}
internal function postLayoutTransformOffsetsChangedHandler(arg1:flash.events.Event):void
{
this.invalidate();
return;
}
public function get mirror():Boolean
{
return this._mirror;
}
public function set mirror(arg1:Boolean):void
{
this._mirror = arg1;
this.invalidate();
return;
}
public function get stretchX():Number
{
return this._stretchX;
}
public function set stretchX(arg1:Number):void
{
if (arg1 == this._stretchX)
{
return;
}
this._stretchX = arg1;
this.invalidate();
return;
}
public function get stretchY():Number
{
return this._stretchY;
}
public function set stretchY(arg1:Number):void
{
if (arg1 == this._stretchY)
{
return;
}
this._stretchY = arg1;
this.invalidate();
return;
}
internal function invalidate():void
{
this._flags = this._flags & ~COMPUTED_MATRIX_VALID;
this._flags = this._flags & ~COMPUTED_MATRIX3D_VALID;
return;
}
public function get computedMatrix():flash.geom.Matrix
{
if (this._flags & COMPUTED_MATRIX_VALID)
{
return this._computedMatrix;
}
if (!this.postLayoutTransformOffsets && !this.mirror && this.stretchX == 1 && this.stretchY == 1)
{
return this.layout.matrix;
}
var loc1:*=this._computedMatrix;
if (loc1 != null)
{
loc1.identity();
}
else
{
var loc9:*;
this._computedMatrix = loc9 = new flash.geom.Matrix();
loc1 = loc9;
}
var loc2:*=this.layout.transformX;
var loc3:*=this.layout.transformY;
var loc4:*=this.layout.scaleX;
var loc5:*=this.layout.scaleY;
var loc6:*=this.layout.rotationZ;
var loc7:*=this.layout.x;
var loc8:*=this.layout.y;
if (this.mirror)
{
loc4 = loc4 * -1;
loc7 = loc7 + this.layoutWidth;
}
if (this.postLayoutTransformOffsets)
{
loc4 = loc4 * this.postLayoutTransformOffsets.scaleX;
loc5 = loc5 * this.postLayoutTransformOffsets.scaleY;
loc6 = loc6 + this.postLayoutTransformOffsets.rotationZ;
loc7 = loc7 + this.postLayoutTransformOffsets.x;
loc8 = loc8 + this.postLayoutTransformOffsets.y;
}
if (!(this.stretchX == 1) || !(this.stretchY == 1))
{
loc1.scale(this.stretchX, this.stretchY);
}
build2DMatrix(loc1, loc2, loc3, loc4, loc5, loc6, loc7, loc8);
this._flags = this._flags | COMPUTED_MATRIX_VALID;
return loc1;
}
public function get computedMatrix3D():flash.geom.Matrix3D
{
if (this._flags & COMPUTED_MATRIX3D_VALID)
{
return this._computedMatrix3D;
}
if (!this.postLayoutTransformOffsets && !this.mirror && this.stretchX == 1 && this.stretchY == 1)
{
return this.layout.matrix3D;
}
var loc1:*=this._computedMatrix3D;
if (loc1 != null)
{
loc1.identity();
}
else
{
var loc14:*;
this._computedMatrix3D = loc14 = new flash.geom.Matrix3D();
loc1 = loc14;
}
var loc2:*=this.layout.transformX;
var loc3:*=this.layout.transformY;
var loc4:*=this.layout.transformZ;
var loc5:*=this.layout.scaleX;
var loc6:*=this.layout.scaleY;
var loc7:*=this.layout.scaleZ;
var loc8:*=this.layout.rotationX;
var loc9:*=this.layout.rotationY;
var loc10:*=this.layout.rotationZ;
var loc11:*=this.layout.x;
var loc12:*=this.layout.y;
var loc13:*=this.layout.z;
if (this.mirror)
{
loc5 = loc5 * -1;
loc11 = loc11 + this.layoutWidth;
}
if (this.postLayoutTransformOffsets)
{
loc5 = loc5 * this.postLayoutTransformOffsets.scaleX;
loc6 = loc6 * this.postLayoutTransformOffsets.scaleY;
loc7 = loc7 * this.postLayoutTransformOffsets.scaleZ;
loc8 = loc8 + this.postLayoutTransformOffsets.rotationX;
loc9 = loc9 + this.postLayoutTransformOffsets.rotationY;
loc10 = loc10 + this.postLayoutTransformOffsets.rotationZ;
loc11 = loc11 + this.postLayoutTransformOffsets.x;
loc12 = loc12 + this.postLayoutTransformOffsets.y;
loc13 = loc13 + this.postLayoutTransformOffsets.z;
}
build3DMatrix(loc1, loc2, loc3, loc4, loc5, loc6, loc7, loc8, loc9, loc10, loc11, loc12, loc13);
if (!(this.stretchX == 1) || !(this.stretchY == 1))
{
loc1.prependScale(this.stretchX, this.stretchY, 1);
}
this._flags = this._flags | COMPUTED_MATRIX3D_VALID;
return loc1;
}
public function transformPointToParent(arg1:Boolean, arg2:flash.geom.Vector3D, arg3:flash.geom.Vector3D, arg4:flash.geom.Vector3D):void
{
var loc1:*=null;
var loc2:*=null;
var loc3:*=null;
tempLocalPosition = arg2 ? arg2.clone() : new flash.geom.Vector3D();
if (this.is3D || arg1)
{
if (arg3 != null)
{
loc1 = transformVector(this.layoutMatrix3D, tempLocalPosition);
arg3.x = loc1.x;
arg3.y = loc1.y;
arg3.z = loc1.z;
}
if (arg4 != null)
{
tempLocalPosition.x = tempLocalPosition.x / this.stretchX;
tempLocalPosition.y = tempLocalPosition.y / this.stretchY;
loc1 = transformVector(this.computedMatrix3D, tempLocalPosition);
arg4.x = loc1.x;
arg4.y = loc1.y;
arg4.z = loc1.z;
}
}
else
{
loc3 = new flash.geom.Point(tempLocalPosition.x, tempLocalPosition.y);
if (arg3 != null)
{
loc2 = this.layoutMatrix.transformPoint(loc3);
arg3.x = loc2.x;
arg3.y = loc2.y;
arg3.z = 0;
}
if (arg4 != null)
{
loc3.x = loc3.x / this.stretchX;
loc3.y = loc3.y / this.stretchY;
loc2 = this.computedMatrix.transformPoint(loc3);
arg4.x = loc2.x;
arg4.y = loc2.y;
arg4.z = 0;
}
}
return;
}
internal static const RADIANS_PER_DEGREES:Number=Math.PI / 180;
internal static const ZERO_REPLACEMENT_IN_3D:Number=1e-014;
internal static const COMPUTED_MATRIX_VALID:uint=1;
internal static const COMPUTED_MATRIX3D_VALID:uint=2;
public var updatePending:Boolean=false;
public var depth:Number=0;
protected var _computedMatrix:flash.geom.Matrix;
protected var _computedMatrix3D:flash.geom.Matrix3D;
protected var layout:mx.geom.CompoundTransform;
internal var _postLayoutTransformOffsets:mx.geom.TransformOffsets;
internal var _flags:uint=0;
internal var _layoutWidth:Number=0;
internal static var reVR:flash.geom.Vector3D;
internal static var reVS:flash.geom.Vector3D;
internal static var reV:__AS3__.vec.Vector.<flash.geom.Vector3D>;
internal var _stretchY:Number=1;
internal static var transformVector:Function;
internal var _mirror:Boolean=false;
internal var _stretchX:Number=1;
internal static var reVT:flash.geom.Vector3D;
internal static var staticTranslation:flash.geom.Vector3D;
internal static var staticOffsetTranslation:flash.geom.Vector3D;
internal static var tempLocalPosition:flash.geom.Vector3D;
}
}
// class Application
package mx.core
{
import flash.display.*;
import flash.events.*;
import flash.external.*;
import flash.net.*;
import flash.system.*;
import flash.ui.*;
import flash.utils.*;
import mx.containers.utilityClasses.*;
import mx.effects.*;
import mx.events.*;
import mx.managers.*;
import mx.styles.*;
import mx.utils.*;
use namespace mx_internal;
public class Application extends mx.core.LayoutContainer
{
public function Application()
{
this.creationQueue = [];
mx.core.UIComponentGlobals.mx_internal::layoutManager = mx.managers.ILayoutManager(mx.core.Singleton.getInstance("mx.managers::ILayoutManager"));
mx.core.UIComponentGlobals.mx_internal::layoutManager.usePhasedInstantiation = true;
if (!mx.core.FlexGlobals.topLevelApplication)
{
mx.core.FlexGlobals.topLevelApplication = this;
}
super();
layoutObject = new mx.containers.utilityClasses.ApplicationLayout();
layoutObject.target = this;
boxLayoutClass = mx.containers.utilityClasses.ApplicationLayout;
showInAutomationHierarchy = true;
this.initResizeBehavior();
return;
}
public override function prepareToPrint(arg1:mx.core.IFlexDisplayObject):Object
{
var loc1:*={};
if (arg1 == this)
{
loc1.width = width;
loc1.height = height;
loc1.verticalScrollPosition = verticalScrollPosition;
loc1.horizontalScrollPosition = horizontalScrollPosition;
loc1.horizontalScrollBarVisible = !(horizontalScrollBar == null);
loc1.verticalScrollBarVisible = !(verticalScrollBar == null);
loc1.whiteBoxVisible = !(whiteBox == null);
setActualSize(measuredWidth, measuredHeight);
horizontalScrollPosition = 0;
verticalScrollPosition = 0;
if (horizontalScrollBar)
{
horizontalScrollBar.visible = false;
}
if (verticalScrollBar)
{
verticalScrollBar.visible = false;
}
if (whiteBox)
{
whiteBox.visible = false;
}
this.updateDisplayList(unscaledWidth, unscaledHeight);
}
loc1.scrollRect = super.prepareToPrint(arg1);
return loc1;
}
public override function finishPrint(arg1:Object, arg2:mx.core.IFlexDisplayObject):void
{
if (arg2 == this)
{
setActualSize(arg1.width, arg1.height);
if (horizontalScrollBar)
{
horizontalScrollBar.visible = arg1.horizontalScrollBarVisible;
}
if (verticalScrollBar)
{
verticalScrollBar.visible = arg1.verticalScrollBarVisible;
}
if (whiteBox)
{
whiteBox.visible = arg1.whiteBoxVisible;
}
horizontalScrollPosition = arg1.horizontalScrollPosition;
verticalScrollPosition = arg1.verticalScrollPosition;
this.updateDisplayList(unscaledWidth, unscaledHeight);
}
super.finishPrint(arg1.scrollRect, arg2);
return;
}
mx_internal override function initThemeColor():Boolean
{
var loc2:*=null;
var loc3:*=NaN;
var loc4:*=NaN;
var loc5:*=null;
if (mx.core.FlexVersion.compatibilityVersion >= mx.core.FlexVersion.VERSION_4_0)
{
return true;
}
var loc1:*=super.mx_internal::initThemeColor();
if (!loc1)
{
if (loc5 = styleManager.getMergedStyleDeclaration("global"))
{
loc2 = loc5.getStyle("themeColor");
loc3 = loc5.getStyle("rollOverColor");
loc4 = loc5.getStyle("selectionColor");
}
if (loc2 && isNaN(loc3) && isNaN(loc4))
{
mx_internal::setThemeColor(loc2);
}
loc1 = true;
}
return loc1;
}
protected override function resourcesChanged():void
{
super.resourcesChanged();
if (this.viewSourceCMI)
{
this.viewSourceCMI.caption = resourceManager.getString("core", "viewSource");
}
return;
}
protected override function layoutChrome(arg1:Number, arg2:Number):void
{
super.layoutChrome(arg1, arg2);
if (!mx_internal::doingLayout)
{
createBorder();
}
var loc1:*=borderMetrics;
var loc2:*=getStyle("borderThickness");
var loc3:*;
(loc3 = new mx.core.EdgeMetrics()).left = loc1.left - loc2;
loc3.top = loc1.top - loc2;
loc3.right = loc1.right - loc2;
loc3.bottom = loc1.bottom - loc2;
if (this.controlBar && this.controlBar.includeInLayout)
{
if (this.controlBar is mx.core.IInvalidating)
{
mx.core.IInvalidating(this.controlBar).invalidateDisplayList();
}
this.controlBar.setActualSize(width - (loc3.left + loc3.right), this.controlBar.getExplicitOrMeasuredHeight());
this.controlBar.move(loc3.left, loc3.top);
}
return;
}
internal function debugTickler():void
{
var loc1:*=0;
return;
}
internal function initManagers(arg1:mx.managers.ISystemManager):void
{
var loc1:*=null;
if (arg1.isTopLevel())
{
focusManager = new mx.managers.FocusManager(this);
loc1 = mx.managers.IActiveWindowManager(arg1.getImplementation("mx.managers::IActiveWindowManager"));
if (loc1)
{
loc1.activate(this);
}
else
{
focusManager.activate();
}
}
return;
}
protected override function commitProperties():void
{
super.commitProperties();
this.resizeWidth = isNaN(explicitWidth);
this.resizeHeight = isNaN(explicitHeight);
if (this.resizeWidth || this.resizeHeight)
{
this.resizeHandler(new flash.events.Event(flash.events.Event.RESIZE));
if (!this.resizeHandlerAdded)
{
systemManager.addEventListener(flash.events.Event.RESIZE, this.resizeHandler, false, 0, true);
this.resizeHandlerAdded = true;
}
}
else if (this.resizeHandlerAdded)
{
systemManager.removeEventListener(flash.events.Event.RESIZE, this.resizeHandler);
this.resizeHandlerAdded = false;
}
if (this.percentBoundsChanged)
{
this.updateBounds();
this.percentBoundsChanged = false;
}
return;
}
internal function initContextMenu():void
{
var loc2:*=null;
if (flexContextMenu != null)
{
if (systemManager is flash.display.InteractiveObject)
{
flash.display.InteractiveObject(systemManager).contextMenu = contextMenu;
}
return;
}
var loc1:*=new flash.ui.ContextMenu();
loc1.hideBuiltInItems();
loc1.builtInItems.print = true;
if (this._viewSourceURL)
{
loc2 = resourceManager.getString("core", "viewSource");
this.viewSourceCMI = new flash.ui.ContextMenuItem(loc2, true);
this.viewSourceCMI.addEventListener(flash.events.ContextMenuEvent.MENU_ITEM_SELECT, this.menuItemSelectHandler);
loc1.customItems.push(this.viewSourceCMI);
}
contextMenu = loc1;
if (systemManager is flash.display.InteractiveObject)
{
flash.display.InteractiveObject(systemManager).contextMenu = loc1;
}
return;
}
public function addToCreationQueue(arg1:Object, arg2:int=-1, arg3:Function=null, arg4:mx.core.IFlexDisplayObject=null):void
{
var loc4:*=0;
var loc5:*=0;
var loc6:*=0;
var loc8:*=0;
var loc1:*=this.creationQueue.length;
var loc2:*={};
var loc3:*=false;
loc2.id = arg1;
loc2.parent = arg4;
loc2.callbackFunc = arg3;
loc2.index = arg2;
var loc7:*=0;
while (loc7 < loc1)
{
loc5 = this.creationQueue[loc7].index;
loc6 = this.creationQueue[loc7].parent ? this.creationQueue[loc7].parent.nestLevel : 0;
if (loc2.index == -1)
{
loc8 = loc2.parent ? loc2.parent.nestLevel : 0;
if (loc5 == -1 && loc6 < loc8)
{
loc4 = loc7;
loc3 = true;
break;
}
}
else if (loc5 == -1 || loc2.index < loc5)
{
loc4 = loc7;
loc3 = true;
break;
}
++loc7;
}
if (loc3)
{
this.creationQueue.splice(loc4, 0, loc2);
}
else
{
this.creationQueue.push(loc2);
loc3 = true;
}
if (initialized && !this.processingCreationQueue)
{
this.doNextQueueItem();
}
return;
}
internal function doNextQueueItem(arg1:mx.events.FlexEvent=null):void
{
this.processingCreationQueue = true;
mx.core.Application.mx_internal::useProgressiveLayout = true;
callLater(this.processNextQueueItem);
return;
}
internal function processNextQueueItem():void
{
var queueItem:Object;
var nextChild:mx.core.IUIComponent;
var loc1:*;
queueItem = null;
nextChild = null;
if (mx.effects.EffectManager.mx_internal::effectsPlaying.length > 0)
{
callLater(this.processNextQueueItem);
}
else if (this.creationQueue.length > 0)
{
queueItem = this.creationQueue.shift();
try
{
nextChild = queueItem.id is String ? document[queueItem.id] : queueItem.id;
if (nextChild is mx.core.Container)
{
mx.core.Container(nextChild).createComponentsFromDescriptors(true);
}
if (nextChild is mx.core.Container && mx.core.Container(nextChild).creationPolicy == mx.core.ContainerCreationPolicy.QUEUED)
{
this.doNextQueueItem();
}
else
{
nextChild.addEventListener("childrenCreationComplete", this.doNextQueueItem);
}
}
catch (e:Error)
{
processNextQueueItem();
}
}
else
{
this.processingCreationQueue = false;
mx.core.Application.mx_internal::useProgressiveLayout = false;
}
return;
}
internal function printCreationQueue():void
{
var loc4:*=null;
var loc1:*="";
var loc2:*=this.creationQueue.length;
var loc3:*=0;
while (loc3 < loc2)
{
loc4 = this.creationQueue[loc3];
loc1 = loc1 + (" [" + loc3 + "] " + loc4.id + " " + loc4.index);
++loc3;
}
return;
}
internal function setControlBar(arg1:mx.core.IUIComponent):void
{
if (arg1 == this.controlBar)
{
return;
}
if (this.controlBar && this.controlBar is mx.styles.IStyleClient)
{
mx.styles.IStyleClient(this.controlBar).clearStyle("cornerRadius");
mx.styles.IStyleClient(this.controlBar).clearStyle("docked");
}
this.controlBar = arg1;
if (this.controlBar && this.controlBar is mx.styles.IStyleClient)
{
mx.styles.IStyleClient(this.controlBar).setStyle("cornerRadius", 0);
mx.styles.IStyleClient(this.controlBar).setStyle("docked", true);
}
invalidateSize();
invalidateDisplayList();
mx_internal::invalidateViewMetricsAndPadding();
return;
}
mx_internal function dockControlBar(arg1:mx.core.IUIComponent, arg2:Boolean):void
{
var controlBar:mx.core.IUIComponent;
var dock:Boolean;
var loc1:*;
controlBar = arg1;
dock = arg2;
if (dock)
{
try
{
removeChild(flash.display.DisplayObject(controlBar));
}
catch (e:Error)
{
return;
}
rawChildren.addChildAt(flash.display.DisplayObject(controlBar), mx_internal::firstChildIndex);
this.setControlBar(controlBar);
}
else
{
try
{
rawChildren.removeChild(flash.display.DisplayObject(controlBar));
}
catch (e:Error)
{
return;
}
this.setControlBar(null);
addChildAt(flash.display.DisplayObject(controlBar), 0);
}
return;
}
internal function addedHandler(arg1:flash.events.Event):void
{
if (arg1.target == this && this.creationQueue.length > 0)
{
this.doNextQueueItem();
}
return;
}
internal function resizeHandler(arg1:flash.events.Event):void
{
if (!this.percentBoundsChanged)
{
this.updateBounds();
if (this.synchronousResize)
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.validateNow();
}
}
return;
}
public override function set enabled(arg1:Boolean):void
{
super.enabled = arg1;
if (this.controlBar)
{
this.controlBar.enabled = arg1;
}
return;
}
public override function set icon(arg1:Class):void
{
return;
}
public override function get id():String
{
if (!super.id && this == mx.core.FlexGlobals.topLevelApplication && flash.external.ExternalInterface.available)
{
return flash.external.ExternalInterface.objectID;
}
return super.id;
}
public override function set label(arg1:String):void
{
return;
}
public override function set percentHeight(arg1:Number):void
{
if (arg1 != super.percentHeight)
{
super.percentHeight = arg1;
this.percentBoundsChanged = true;
invalidateProperties();
}
return;
}
public override function set percentWidth(arg1:Number):void
{
if (arg1 != super.percentWidth)
{
super.percentWidth = arg1;
this.percentBoundsChanged = true;
invalidateProperties();
}
return;
}
public override function set tabIndex(arg1:int):void
{
return;
}
public override function set toolTip(arg1:String):void
{
return;
}
public override function get viewMetrics():mx.core.EdgeMetrics
{
if (!this._applicationViewMetrics)
{
this._applicationViewMetrics = new mx.core.EdgeMetrics();
}
var loc1:*=this._applicationViewMetrics;
var loc2:*=super.viewMetrics;
var loc3:*=getStyle("borderThickness");
loc1.left = loc2.left;
loc1.top = loc2.top;
loc1.right = loc2.right;
loc1.bottom = loc2.bottom;
if (this.controlBar && this.controlBar.includeInLayout)
{
loc1.top = loc1.top - loc3;
loc1.top = loc1.top + Math.max(this.controlBar.getExplicitOrMeasuredHeight(), loc3);
}
return loc1;
}
public function get url():String
{
return this.mx_internal::_url;
}
protected function menuItemSelectHandler(arg1:flash.events.Event):void
{
flash.net.navigateToURL(new flash.net.URLRequest(this._viewSourceURL), "_blank");
return;
}
internal function updateBounds():void
{
var loc1:*=NaN;
var loc2:*=NaN;
if (this.resizeWidth)
{
if (isNaN(percentWidth))
{
loc1 = flash.display.DisplayObject(systemManager).width;
}
else
{
super.percentWidth = Math.max(percentWidth, 0);
super.percentWidth = Math.min(percentWidth, 100);
if (mx.core.FlexVersion.compatibilityVersion >= mx.core.FlexVersion.VERSION_4_0)
{
loc1 = percentWidth * flash.display.DisplayObject(systemManager).width / 100;
}
else
{
loc1 = percentWidth * screen.width / 100;
}
}
if (!isNaN(explicitMaxWidth))
{
loc1 = Math.min(loc1, explicitMaxWidth);
}
if (!isNaN(explicitMinWidth))
{
loc1 = Math.max(loc1, explicitMinWidth);
}
}
else
{
loc1 = width;
}
if (this.resizeHeight)
{
if (isNaN(percentHeight))
{
loc2 = flash.display.DisplayObject(systemManager).height;
}
else
{
super.percentHeight = Math.max(percentHeight, 0);
super.percentHeight = Math.min(percentHeight, 100);
if (mx.core.FlexVersion.compatibilityVersion >= mx.core.FlexVersion.VERSION_4_0)
{
loc2 = percentHeight * flash.display.DisplayObject(systemManager).height / 100;
}
else
{
loc2 = percentHeight * screen.height / 100;
}
}
if (!isNaN(explicitMaxHeight))
{
loc2 = Math.min(loc2, explicitMaxHeight);
}
if (!isNaN(explicitMinHeight))
{
loc2 = Math.max(loc2, explicitMinHeight);
}
}
else
{
loc2 = height;
}
if (!(loc1 == width) || !(loc2 == height))
{
invalidateProperties();
invalidateSize();
}
setActualSize(loc1, loc2);
invalidateDisplayList();
return;
}
public function get parameters():Object
{
return this.mx_internal::_parameters;
}
public static function get application():Object
{
return mx.core.FlexGlobals.topLevelApplication;
}
mx_internal override function setUnscaledHeight(arg1:Number):void
{
invalidateProperties();
super.mx_internal::setUnscaledHeight(arg1);
return;
}
mx_internal override function setUnscaledWidth(arg1:Number):void
{
invalidateProperties();
super.mx_internal::setUnscaledWidth(arg1);
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
mx_internal::useProgressiveLayout = false;
}
internal function initResizeBehavior():void
{
var loc1:*=flash.system.Capabilities.version.split(" ")[1].split(",");
this.synchronousResize = (parseFloat(loc1[0]) > 10 || parseFloat(loc1[0]) == 10 && parseFloat(loc1[1]) >= 1) && !(flash.system.Capabilities.playerType == "Desktop");
return;
}
mx_internal override function get usePadding():Boolean
{
return !(layout == mx.core.ContainerLayout.ABSOLUTE);
}
public function get viewSourceURL():String
{
return this._viewSourceURL;
}
public function set viewSourceURL(arg1:String):void
{
this._viewSourceURL = arg1;
return;
}
public override function getChildIndex(arg1:flash.display.DisplayObject):int
{
if (this.controlBar && arg1 == this.controlBar)
{
return -1;
}
return super.getChildIndex(arg1);
}
protected override function invalidateParentSizeAndDisplayList():void
{
if (!includeInLayout)
{
return;
}
var loc1:*=parent as mx.core.IInvalidating;
if (!loc1)
{
if (parent is mx.managers.ISystemManager)
{
mx.managers.ISystemManager(parent).invalidateParentSizeAndDisplayList();
}
return;
}
super.invalidateParentSizeAndDisplayList();
return;
}
public override function initialize():void
{
var loc2:*=null;
var loc1:*=systemManager;
this.mx_internal::_url = mx.utils.LoaderUtil.normalizeURL(loc1.loaderInfo);
this.mx_internal::_parameters = loc1.loaderInfo.parameters;
this.initManagers(loc1);
mx_internal::_descriptor = null;
if (mx_internal::documentDescriptor)
{
creationPolicy = mx_internal::documentDescriptor.properties.creationPolicy;
if (creationPolicy == null || creationPolicy.length == 0)
{
creationPolicy = mx.core.ContainerCreationPolicy.AUTO;
}
loc2 = mx_internal::documentDescriptor.properties;
if (loc2.width != null)
{
width = loc2.width;
delete loc2.width;
}
if (loc2.height != null)
{
height = loc2.height;
delete loc2.height;
}
mx_internal::documentDescriptor.events = null;
}
this.initContextMenu();
super.initialize();
addEventListener(flash.events.Event.ADDED, this.addedHandler);
if (loc1.isTopLevelRoot() && flash.system.Capabilities.isDebugger == true)
{
flash.utils.setInterval(this.debugTickler, 1500);
}
return;
}
protected override function measure():void
{
var loc2:*=NaN;
super.measure();
var loc1:*=borderMetrics;
if (this.controlBar && this.controlBar.includeInLayout)
{
loc2 = this.controlBar.getExplicitOrMeasuredWidth() + loc1.left + loc1.right;
measuredWidth = Math.max(measuredWidth, loc2);
measuredMinWidth = Math.max(measuredMinWidth, loc2);
}
return;
}
protected override function updateDisplayList(arg1:Number, arg2:Number):void
{
super.updateDisplayList(arg1, arg2);
createBorder();
return;
}
public override function styleChanged(arg1:String):void
{
super.styleChanged(arg1);
if (arg1 == "backgroundColor" && getStyle("backgroundImage") == getStyle("defaultBackgroundImage"))
{
clearStyle("backgroundImage");
}
return;
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var resizeHandlerAdded:Boolean=false;
internal var percentBoundsChanged:Boolean;
internal var preloadObj:Object;
internal var creationQueue:Array;
internal var processingCreationQueue:Boolean=false;
internal var _applicationViewMetrics:mx.core.EdgeMetrics;
internal var resizeWidth:Boolean=true;
internal var synchronousResize:Boolean=false;
internal var viewSourceCMI:flash.ui.ContextMenuItem;
public var frameRate:Number;
public var pageTitle:String;
public var preloader:Object;
public var preloaderChromeColor:uint;
public var scriptRecursionLimit:int;
public var scriptTimeLimit:Number;
public var usePreloader:Boolean;
public var historyManagementEnabled:Boolean=true;
mx_internal var _parameters:Object;
public var resetHistory:Boolean=true;
mx_internal var _url:String;
public var controlBar:mx.core.IUIComponent;
mx_internal static var useProgressiveLayout:Boolean=false;
internal var _viewSourceURL:String;
internal var resizeHeight:Boolean=true;
}
}
// class BitmapAsset
package mx.core
{
import flash.display.*;
import flash.events.*;
import flash.geom.*;
import flash.system.*;
use namespace mx_internal;
public class BitmapAsset extends mx.core.FlexBitmap implements mx.core.IFlexAsset, mx.core.IFlexDisplayObject, mx.core.ILayoutDirectionElement
{
public function BitmapAsset(arg1:flash.display.BitmapData=null, arg2:String="auto", arg3:Boolean=false)
{
var loc1:*=null;
super(arg1, arg2, arg3);
if (FlexVersionClass == null)
{
if ((loc1 = flash.system.ApplicationDomain.currentDomain).hasDefinition("mx.core::FlexVersion"))
{
FlexVersionClass = Class(loc1.getDefinition("mx.core::FlexVersion"));
}
}
if (FlexVersionClass && FlexVersionClass["compatibilityVersion"] >= FlexVersionClass["VERSION_4_0"])
{
this.addEventListener(flash.events.Event.ADDED, this.addedHandler);
}
return;
}
internal function initAdvancedLayoutFeatures():void
{
var loc1:*=null;
var loc2:*=null;
if (this.layoutFeaturesClass == null)
{
loc1 = flash.system.ApplicationDomain.currentDomain;
if (loc1.hasDefinition("mx.core::AdvancedLayoutFeatures"))
{
this.layoutFeaturesClass = Class(loc1.getDefinition("mx.core::AdvancedLayoutFeatures"));
}
if (MatrixUtilClass == null)
{
if (loc1.hasDefinition("mx.utils::MatrixUtil"))
{
MatrixUtilClass = Class(loc1.getDefinition("mx.utils::MatrixUtil"));
}
}
}
if (this.layoutFeaturesClass != null)
{
loc2 = new this.layoutFeaturesClass();
loc2.layoutScaleX = this.scaleX;
loc2.layoutScaleY = this.scaleY;
loc2.layoutScaleZ = this.scaleZ;
loc2.layoutRotationX = this.rotationX;
loc2.layoutRotationY = this.rotationY;
loc2.layoutRotationZ = this.rotation;
loc2.layoutX = this.x;
loc2.layoutY = this.y;
loc2.layoutZ = this.z;
loc2.layoutWidth = this.width;
this._height = this.height;
this.layoutFeatures = loc2;
}
return;
}
internal function validateTransformMatrix():void
{
if (this.layoutFeatures != null)
{
if (this.layoutFeatures.is3D)
{
super.transform.matrix3D = this.layoutFeatures.computedMatrix3D;
}
else
{
super.transform.matrix = this.layoutFeatures.computedMatrix;
}
}
return;
}
public override function get x():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutX : super.x;
}
public override function set x(arg1:Number):void
{
if (this.x == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutX = arg1;
this.validateTransformMatrix();
}
else
{
super.x = arg1;
}
return;
}
public override function get y():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutY : super.y;
}
public override function set y(arg1:Number):void
{
if (this.y == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutY = arg1;
this.validateTransformMatrix();
}
else
{
super.y = arg1;
}
return;
}
public override function get z():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutZ : super.z;
}
public override function set z(arg1:Number):void
{
if (this.z == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutZ = arg1;
this.validateTransformMatrix();
}
else
{
super.z = arg1;
}
return;
}
public override function get width():Number
{
var loc1:*=null;
if (this.layoutFeatures == null)
{
return super.width;
}
if (MatrixUtilClass != null)
{
var loc2:*;
loc1 = (loc2 = MatrixUtilClass)["transformSize"](this.layoutFeatures.layoutWidth, this._height, transform.matrix);
}
return loc1 ? loc1.x : super.width;
}
public override function set width(arg1:Number):void
{
if (this.width == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutWidth = arg1;
this.layoutFeatures.layoutScaleX = this.measuredWidth == 0 ? 0 : arg1 / this.measuredWidth;
this.validateTransformMatrix();
}
else
{
super.width = arg1;
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
public override function get height():Number
{
var loc1:*=null;
if (this.layoutFeatures == null)
{
return super.height;
}
if (MatrixUtilClass != null)
{
var loc2:*;
loc1 = (loc2 = MatrixUtilClass)["transformSize"](this.layoutFeatures.layoutWidth, this._height, transform.matrix);
}
return loc1 ? loc1.y : super.height;
}
public override function set height(arg1:Number):void
{
if (this.height == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this._height = arg1;
this.layoutFeatures.layoutScaleY = this.measuredHeight == 0 ? 0 : arg1 / this.measuredHeight;
this.validateTransformMatrix();
}
else
{
super.height = arg1;
}
return;
}
public override function get rotationX():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutRotationX : super.rotationX;
}
public override function set rotationX(arg1:Number):void
{
if (this.rotationX == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutRotationX = arg1;
this.validateTransformMatrix();
}
else
{
super.rotationX = arg1;
}
return;
}
public override function get rotationY():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutRotationY : super.rotationY;
}
public override function set rotationY(arg1:Number):void
{
if (this.rotationY == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutRotationY = arg1;
this.validateTransformMatrix();
}
else
{
super.rotationY = arg1;
}
return;
}
public override function get rotationZ():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutRotationZ : super.rotationZ;
}
public override function set rotationZ(arg1:Number):void
{
if (this.rotationZ == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutRotationZ = arg1;
this.validateTransformMatrix();
}
else
{
super.rotationZ = arg1;
}
return;
}
public override function get rotation():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutRotationZ : super.rotation;
}
public override function set rotation(arg1:Number):void
{
if (this.rotation == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutRotationZ = arg1;
this.validateTransformMatrix();
}
else
{
super.rotation = arg1;
}
return;
}
public override function get scaleX():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutScaleX : super.scaleX;
}
public override function set scaleX(arg1:Number):void
{
if (this.scaleX == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutScaleX = arg1;
this.layoutFeatures.layoutWidth = Math.abs(arg1) * this.measuredWidth;
this.validateTransformMatrix();
}
else
{
super.scaleX = arg1;
}
return;
}
public override function get scaleY():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutScaleY : super.scaleY;
}
public override function set scaleY(arg1:Number):void
{
if (this.scaleY == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutScaleY = arg1;
this._height = Math.abs(arg1) * this.measuredHeight;
this.validateTransformMatrix();
}
else
{
super.scaleY = arg1;
}
return;
}
public override function get scaleZ():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutScaleZ : super.scaleZ;
}
public override function set scaleZ(arg1:Number):void
{
if (this.scaleZ == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutScaleZ = arg1;
this.validateTransformMatrix();
}
else
{
super.scaleZ = arg1;
}
return;
}
public function get layoutDirection():String
{
return this._layoutDirection;
}
public function set layoutDirection(arg1:String):void
{
if (arg1 == this._layoutDirection)
{
return;
}
this._layoutDirection = arg1;
this.invalidateLayoutDirection();
return;
}
public function get measuredHeight():Number
{
if (bitmapData)
{
return bitmapData.height;
}
return 0;
}
public function get measuredWidth():Number
{
if (bitmapData)
{
return bitmapData.width;
}
return 0;
}
public function invalidateLayoutDirection():void
{
var loc2:*=false;
var loc1:*=parent;
while (loc1)
{
if (loc1 is mx.core.ILayoutDirectionElement)
{
loc2 = !(this._layoutDirection == null) && !(this._layoutDirection == mx.core.ILayoutDirectionElement(loc1).layoutDirection);
if (loc2 && this.layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
if (this.layoutFeatures != null)
{
this.layoutFeatures.mirror = loc2;
this.validateTransformMatrix();
}
}
else if (!loc2 && this.layoutFeatures)
{
this.layoutFeatures.mirror = loc2;
this.validateTransformMatrix();
this.layoutFeatures = null;
}
break;
}
loc1 = loc1.parent;
}
return;
}
public function move(arg1:Number, arg2:Number):void
{
this.x = arg1;
this.y = arg2;
return;
}
public function setActualSize(arg1:Number, arg2:Number):void
{
this.width = arg1;
this.height = arg2;
return;
}
internal function addedHandler(arg1:flash.events.Event):void
{
this.invalidateLayoutDirection();
return;
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var layoutFeaturesClass:Class;
internal var layoutFeatures:mx.core.IAssetLayoutFeatures;
internal var _height:Number;
internal static var FlexVersionClass:Class;
internal static var MatrixUtilClass:Class;
internal var _layoutDirection:String="ltr";
}
}
// class ByteArrayAsset
package mx.core
{
import flash.utils.*;
use namespace mx_internal;
public class ByteArrayAsset extends flash.utils.ByteArray implements mx.core.IFlexAsset
{
public function ByteArrayAsset()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class ComponentDescriptor
package mx.core
{
use namespace mx_internal;
public class ComponentDescriptor extends Object
{
public function ComponentDescriptor(arg1:Object)
{
var loc1:*=null;
super();
var loc2:*=0;
var loc3:*=arg1;
for (loc1 in loc3)
{
this[loc1] = arg1[loc1];
}
return;
}
public function get properties():Object
{
var loc1:*=null;
var loc2:*=0;
var loc3:*=0;
if (this._properties)
{
return this._properties;
}
if (this.propertiesFactory != null)
{
this._properties = this.propertiesFactory.call(this.document);
}
if (this._properties)
{
loc1 = this._properties.childDescriptors;
if (loc1)
{
loc2 = loc1.length;
loc3 = 0;
while (loc3 < loc2)
{
loc1[loc3].document = this.document;
++loc3;
}
}
}
else
{
this._properties = {};
}
return this._properties;
}
public function invalidateProperties():void
{
this._properties = null;
return;
}
public function toString():String
{
return "ComponentDescriptor_" + this.id;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public var document:Object;
public var events:Object;
public var id:String;
internal var _properties:Object;
public var propertiesFactory:Function;
public var type:Class;
}
}
// class Container
package mx.core
{
import flash.display.*;
import flash.events.*;
import flash.geom.*;
import flash.system.*;
import flash.text.*;
import flash.ui.*;
import flash.utils.*;
import mx.binding.*;
import mx.containers.utilityClasses.*;
import mx.controls.*;
import mx.controls.listClasses.*;
import mx.controls.scrollClasses.*;
import mx.events.*;
import mx.geom.*;
import mx.managers.*;
import mx.styles.*;
use namespace mx_internal;
public class Container extends mx.core.UIComponent implements mx.core.IContainer, mx.core.IDataRenderer, mx.managers.IFocusManagerContainer, mx.controls.listClasses.IListItemRenderer, mx.core.IRawChildrenContainer, mx.core.IChildList, mx.core.IVisualElementContainer, mx.core.INavigatorContent
{
public function Container()
{
super();
tabEnabled = false;
tabFocusEnabled = false;
showInAutomationHierarchy = false;
if (flash.system.ApplicationDomain.currentDomain.hasDefinition("spark.components.RichEditableText"))
{
this.richEditableTextClass = Class(flash.system.ApplicationDomain.currentDomain.getDefinition("spark.components.RichEditableText"));
}
return;
}
mx_internal function getLayoutChildAt(arg1:int):mx.core.IUIComponent
{
return mx.containers.utilityClasses.PostScaleAdapter.getCompatibleIUIComponent(this.getChildAt(arg1));
}
mx_internal override function childAdded(arg1:flash.display.DisplayObject):void
{
var loc1:*=null;
if (hasEventListener("childrenChanged"))
{
dispatchEvent(new flash.events.Event("childrenChanged"));
}
if (hasEventListener(mx.events.ChildExistenceChangedEvent.CHILD_ADD))
{
loc1 = new mx.events.ChildExistenceChangedEvent(mx.events.ChildExistenceChangedEvent.CHILD_ADD);
loc1.relatedObject = arg1;
dispatchEvent(loc1);
}
if (hasEventListener(mx.events.FlexEvent.ADD))
{
arg1.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.ADD));
}
super.mx_internal::childAdded(arg1);
return;
}
mx_internal override function removingChild(arg1:flash.display.DisplayObject):void
{
var loc1:*=null;
super.mx_internal::removingChild(arg1);
if (hasEventListener(mx.events.FlexEvent.REMOVE))
{
arg1.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.REMOVE));
}
if (hasEventListener(mx.events.ChildExistenceChangedEvent.CHILD_REMOVE))
{
loc1 = new mx.events.ChildExistenceChangedEvent(mx.events.ChildExistenceChangedEvent.CHILD_REMOVE);
loc1.relatedObject = arg1;
dispatchEvent(loc1);
}
return;
}
mx_internal override function childRemoved(arg1:flash.display.DisplayObject):void
{
super.mx_internal::childRemoved(arg1);
invalidateSize();
invalidateDisplayList();
if (!this.mx_internal::contentPane)
{
var loc1:*;
var loc2:*=((loc1 = this).mx_internal::_numChildren - 1);
loc1.mx_internal::_numChildren = loc2;
if (this.mx_internal::_numChildren == 0)
{
this._firstChildIndex = super.numChildren;
}
}
if (this.mx_internal::contentPane && !this.autoLayout)
{
this.forceLayout = true;
mx.core.UIComponentGlobals.mx_internal::layoutManager.addEventListener(mx.events.FlexEvent.UPDATE_COMPLETE, this.layoutCompleteHandler, false, 0, true);
}
if (hasEventListener("childrenChanged"))
{
dispatchEvent(new flash.events.Event("childrenChanged"));
}
return;
}
public function getChildren():Array
{
var loc1:*=[];
var loc2:*=this.numChildren;
var loc3:*=0;
while (loc3 < loc2)
{
loc1.push(this.getChildAt(loc3));
++loc3;
}
return loc1;
}
public function removeAllChildren():void
{
while (this.numChildren > 0)
{
this.removeChildAt(0);
}
return;
}
mx_internal function setDocumentDescriptor(arg1:mx.core.UIComponentDescriptor):void
{
var loc1:*=null;
if (processedDescriptors)
{
return;
}
if (mx_internal::_documentDescriptor && mx_internal::_documentDescriptor.properties.childDescriptors)
{
if (arg1.properties.childDescriptors)
{
loc1 = resourceManager.getString("core", "multipleChildSets_ClassAndSubclass");
throw new Error(loc1);
}
}
else
{
mx_internal::_documentDescriptor = arg1;
mx_internal::_documentDescriptor.document = this;
}
return;
}
mx_internal function setActualCreationPolicies(arg1:String):void
{
var loc4:*=null;
var loc5:*=null;
this.actualCreationPolicy = arg1;
var loc1:*=arg1;
if (arg1 == mx.core.ContainerCreationPolicy.QUEUED)
{
loc1 = mx.core.ContainerCreationPolicy.AUTO;
}
var loc2:*=this.numChildren;
var loc3:*=0;
while (loc3 < loc2)
{
if ((loc4 = mx.core.IFlexDisplayObject(this.getChildAt(loc3))) is mx.core.Container)
{
if ((loc5 = mx.core.Container(loc4)).creationPolicy == null)
{
loc5.mx_internal::setActualCreationPolicies(loc1);
}
}
++loc3;
}
return;
}
public function get creatingContentPane():Boolean
{
return this._creatingContentPane;
}
public function set creatingContentPane(arg1:Boolean):void
{
this._creatingContentPane = arg1;
return;
}
public function createComponentsFromDescriptors(arg1:Boolean=true):void
{
var loc3:*=null;
this.numChildrenBefore = this.numChildren;
this.mx_internal::createdComponents = [];
var loc1:*=this.childDescriptors ? this.childDescriptors.length : 0;
var loc2:*=0;
while (loc2 < loc1)
{
loc3 = this.createComponentFromDescriptor(this.childDescriptors[loc2], arg1);
this.mx_internal::createdComponents.push(loc3);
++loc2;
}
if (this.creationPolicy == mx.core.ContainerCreationPolicy.QUEUED || this.creationPolicy == mx.core.ContainerCreationPolicy.NONE)
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.usePhasedInstantiation = false;
}
this.mx_internal::numChildrenCreated = this.numChildren - this.numChildrenBefore;
processedDescriptors = true;
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.CONTENT_CREATION_COMPLETE));
return;
}
public function createDeferredContent():void
{
this.createComponentsFromDescriptors(true);
return;
}
public function createComponentFromDescriptor(arg1:mx.core.ComponentDescriptor, arg2:Boolean):mx.core.IFlexDisplayObject
{
var loc5:*=null;
var loc8:*=null;
var loc9:*=null;
var loc10:*=null;
var loc11:*=null;
var loc1:*=mx.core.UIComponentDescriptor(arg1);
var loc2:*=loc1.properties;
if ((!(this.numChildrenBefore == 0) || !(this.mx_internal::numChildrenCreated == -1)) && loc1.mx_internal::instanceIndices == null && this.hasChildMatchingDescriptor(loc1))
{
return null;
}
mx.core.UIComponentGlobals.mx_internal::layoutManager.usePhasedInstantiation = true;
var loc3:*;
var loc4:*;
(loc4 = new (loc3 = loc1.type)()).id = loc1.id;
if (loc4.id && !(loc4.id == ""))
{
loc4.name = loc4.id;
}
loc4.descriptor = loc1;
if (loc2.childDescriptors && loc4 is mx.core.Container)
{
mx.core.Container(loc4)._childDescriptors = loc2.childDescriptors;
delete loc2.childDescriptors;
}
var loc12:*=0;
var loc13:*=loc2;
for (loc5 in loc13)
{
loc4[loc5] = loc2[loc5];
}
if (loc4 is mx.core.Container)
{
mx.core.Container(loc4).recursionFlag = arg2;
}
if (loc1.mx_internal::instanceIndices)
{
if (loc4 is mx.core.IRepeaterClient)
{
(loc8 = mx.core.IRepeaterClient(loc4)).instanceIndices = loc1.mx_internal::instanceIndices;
loc8.repeaters = loc1.mx_internal::repeaters;
loc8.repeaterIndices = loc1.mx_internal::repeaterIndices;
}
}
if (loc4 is mx.styles.IStyleClient)
{
loc9 = mx.styles.IStyleClient(loc4);
if (loc1.stylesFactory != null)
{
if (!loc9.styleDeclaration)
{
loc9.styleDeclaration = new mx.styles.CSSStyleDeclaration(null, styleManager);
}
loc9.styleDeclaration.factory = loc1.stylesFactory;
}
}
var loc6:*;
if (loc6 = loc1.events)
{
loc12 = 0;
loc13 = loc6;
for (loc10 in loc13)
{
loc11 = loc6[loc10];
loc4.addEventListener(loc10, loc1.document[loc11]);
}
}
var loc7:*;
if (loc7 = loc1.effects)
{
loc4.registerEffects(loc7);
}
if (loc4 is mx.core.IRepeaterClient)
{
mx.core.IRepeaterClient(loc4).initializeRepeaterArrays(this);
}
loc4.createReferenceOnParentDocument(mx.core.IFlexDisplayObject(loc1.document));
if (!loc4.document)
{
loc4.document = loc1.document;
}
if (loc4 is mx.core.IRepeater)
{
if (!this.mx_internal::childRepeaters)
{
this.mx_internal::childRepeaters = [];
}
this.mx_internal::childRepeaters.push(loc4);
loc4.executeBindings();
mx.core.IRepeater(loc4).initializeRepeater(this, arg2);
}
else
{
this.addChild(flash.display.DisplayObject(loc4));
loc4.executeBindings();
if (this.creationPolicy == mx.core.ContainerCreationPolicy.QUEUED || this.creationPolicy == mx.core.ContainerCreationPolicy.NONE)
{
loc4.addEventListener(mx.events.FlexEvent.CREATION_COMPLETE, this.creationCompleteHandler);
}
}
return loc4;
}
internal function hasChildMatchingDescriptor(arg1:mx.core.UIComponentDescriptor):Boolean
{
var loc3:*=0;
var loc4:*=null;
var loc1:*=arg1.id;
if (!(loc1 == null) && loc1 in document && document[loc1] == null)
{
return false;
}
var loc2:*=this.numChildren;
loc3 = 0;
while (loc3 < loc2)
{
if ((loc4 = mx.core.IUIComponent(this.getChildAt(loc3))) is mx.core.IDeferredInstantiationUIComponent && mx.core.IDeferredInstantiationUIComponent(loc4).descriptor == arg1)
{
return true;
}
++loc3;
}
if (this.mx_internal::childRepeaters)
{
loc2 = this.mx_internal::childRepeaters.length;
loc3 = 0;
while (loc3 < loc2)
{
if (mx.core.IDeferredInstantiationUIComponent(this.mx_internal::childRepeaters[loc3]).descriptor == arg1)
{
return true;
}
++loc3;
}
}
return false;
}
mx_internal function rawChildren_addChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject
{
if (this.mx_internal::_numChildren == 0)
{
var loc1:*;
var loc2:*=((loc1 = this)._firstChildIndex + 1);
loc1._firstChildIndex = loc2;
}
super.mx_internal::addingChild(arg1);
mx_internal::$addChild(arg1);
super.mx_internal::childAdded(arg1);
dispatchEvent(new flash.events.Event("childrenChanged"));
return arg1;
}
mx_internal function rawChildren_addChildAt(arg1:flash.display.DisplayObject, arg2:int):flash.display.DisplayObject
{
if (this._firstChildIndex < arg2 && arg2 < this._firstChildIndex + this.mx_internal::_numChildren + 1)
{
var loc1:*;
var loc2:*=((loc1 = this).mx_internal::_numChildren + 1);
loc1.mx_internal::_numChildren = loc2;
}
else if (arg2 <= this._firstChildIndex)
{
loc2 = ((loc1 = this)._firstChildIndex + 1);
loc1._firstChildIndex = loc2;
}
super.mx_internal::addingChild(arg1);
mx_internal::$addChildAt(arg1, arg2);
super.mx_internal::childAdded(arg1);
dispatchEvent(new flash.events.Event("childrenChanged"));
return arg1;
}
mx_internal function rawChildren_removeChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject
{
var loc1:*=this.mx_internal::rawChildren_getChildIndex(arg1);
return this.mx_internal::rawChildren_removeChildAt(loc1);
}
mx_internal function rawChildren_removeChildAt(arg1:int):flash.display.DisplayObject
{
var loc1:*=super.getChildAt(arg1);
super.mx_internal::removingChild(loc1);
mx_internal::$removeChildAt(arg1);
super.mx_internal::childRemoved(loc1);
if (this._firstChildIndex < arg1 && arg1 < this._firstChildIndex + this.mx_internal::_numChildren)
{
var loc2:*;
var loc3:*=((loc2 = this).mx_internal::_numChildren - 1);
loc2.mx_internal::_numChildren = loc3;
}
else if (this.mx_internal::_numChildren == 0 || arg1 < this._firstChildIndex)
{
loc3 = ((loc2 = this)._firstChildIndex - 1);
loc2._firstChildIndex = loc3;
}
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("childrenChanged"));
return loc1;
}
mx_internal function rawChildren_getChildAt(arg1:int):flash.display.DisplayObject
{
return super.getChildAt(arg1);
}
mx_internal function rawChildren_getChildByName(arg1:String):flash.display.DisplayObject
{
return super.getChildByName(arg1);
}
mx_internal function rawChildren_getChildIndex(arg1:flash.display.DisplayObject):int
{
return super.getChildIndex(arg1);
}
mx_internal function rawChildren_setChildIndex(arg1:flash.display.DisplayObject, arg2:int):void
{
var loc1:*=super.getChildIndex(arg1);
super.setChildIndex(arg1, arg2);
if (loc1 < this._firstChildIndex && arg2 >= this._firstChildIndex)
{
var loc2:*;
var loc3:*=((loc2 = this)._firstChildIndex - 1);
loc2._firstChildIndex = loc3;
}
else if (loc1 >= this._firstChildIndex && arg2 <= this._firstChildIndex)
{
loc3 = ((loc2 = this)._firstChildIndex + 1);
loc2._firstChildIndex = loc3;
}
dispatchEvent(new flash.events.Event("childrenChanged"));
return;
}
mx_internal function rawChildren_getObjectsUnderPoint(arg1:flash.geom.Point):Array
{
return super.getObjectsUnderPoint(arg1);
}
mx_internal function rawChildren_contains(arg1:flash.display.DisplayObject):Boolean
{
return super.contains(arg1);
}
public override function get baselinePosition():Number
{
if (!mx_internal::validateBaselinePosition())
{
return NaN;
}
var loc1:*=measureText("Wj");
if (height < 2 * this.viewMetrics.top + 4 + loc1.ascent)
{
return int(height + (loc1.ascent - height) / 2);
}
return this.viewMetrics.top + 2 + loc1.ascent;
}
public override function get contentMouseX():Number
{
if (this.mx_internal::contentPane)
{
return this.mx_internal::contentPane.mouseX;
}
return super.contentMouseX;
}
public override function get contentMouseY():Number
{
if (this.mx_internal::contentPane)
{
return this.mx_internal::contentPane.mouseY;
}
return super.contentMouseY;
}
public override function set doubleClickEnabled(arg1:Boolean):void
{
var loc1:*=0;
var loc2:*=0;
var loc3:*=null;
super.doubleClickEnabled = arg1;
if (this.mx_internal::contentPane)
{
loc1 = this.mx_internal::contentPane.numChildren;
loc2 = 0;
while (loc2 < loc1)
{
if (loc3 = this.mx_internal::contentPane.getChildAt(loc2) as flash.display.InteractiveObject)
{
loc3.doubleClickEnabled = arg1;
}
++loc2;
}
}
return;
}
public override function set enabled(arg1:Boolean):void
{
super.enabled = arg1;
if (this.horizontalScrollBar)
{
this.horizontalScrollBar.enabled = arg1;
}
if (this.verticalScrollBar)
{
this.verticalScrollBar.enabled = arg1;
}
invalidateProperties();
if (this.mx_internal::border && this.mx_internal::border is mx.core.IInvalidating)
{
mx.core.IInvalidating(this.mx_internal::border).invalidateDisplayList();
}
return;
}
protected function layoutChrome(arg1:Number, arg2:Number):void
{
if (this.mx_internal::border)
{
this.updateBackgroundImageRect();
this.mx_internal::border.move(0, 0);
this.mx_internal::border.setActualSize(arg1, arg2);
}
return;
}
public override function get focusPane():flash.display.Sprite
{
return this._focusPane;
}
public override function set focusPane(arg1:flash.display.Sprite):void
{
var loc1:*=mx_internal::invalidateSizeFlag;
var loc2:*=mx_internal::invalidateDisplayListFlag;
mx_internal::invalidateSizeFlag = true;
mx_internal::invalidateDisplayListFlag = true;
if (arg1)
{
this.rawChildren.addChild(arg1);
arg1.x = 0;
arg1.y = 0;
arg1.scrollRect = null;
this._focusPane = arg1;
}
else
{
this.rawChildren.removeChild(this._focusPane);
this._focusPane = null;
}
if (arg1 && this.mx_internal::contentPane)
{
arg1.x = this.mx_internal::contentPane.x;
arg1.y = this.mx_internal::contentPane.y;
arg1.scrollRect = this.mx_internal::contentPane.scrollRect;
}
mx_internal::invalidateSizeFlag = loc1;
mx_internal::invalidateDisplayListFlag = loc2;
return;
}
public override function set moduleFactory(arg1:mx.core.IFlexModuleFactory):void
{
super.moduleFactory = arg1;
styleManager.registerInheritingStyle("_creationPolicy");
return;
}
mx_internal final function get $numChildren():int
{
return super.numChildren;
}
protected function createBorder():void
{
var loc1:*=null;
if (!this.mx_internal::border && this.isBorderNeeded())
{
loc1 = getStyle("borderSkin");
if (loc1 != null)
{
this.mx_internal::border = new loc1();
this.mx_internal::border.name = "border";
if (this.mx_internal::border is mx.core.IUIComponent)
{
mx.core.IUIComponent(this.mx_internal::border).enabled = enabled;
}
if (this.mx_internal::border is mx.styles.ISimpleStyleClient)
{
mx.styles.ISimpleStyleClient(this.mx_internal::border).styleName = this;
}
this.rawChildren.addChildAt(flash.display.DisplayObject(this.mx_internal::border), 0);
invalidateDisplayList();
}
}
return;
}
public override function get numChildren():int
{
return this.mx_internal::contentPane ? this.mx_internal::contentPane.numChildren : this.mx_internal::_numChildren;
}
internal function isBorderNeeded():Boolean
{
var loc1:*=getStyle("borderSkin");
if (!didLookup)
{
haloBorder = getDefinition("mx.skins.halo::HaloBorder");
sparkBorder = getDefinition("mx.skins.spark::BorderSkin");
sparkContainerBorder = getDefinition("mx.skins.spark::ContainerBorderSkin");
didLookup = true;
}
if (!(loc1 == haloBorder || loc1 == sparkBorder || loc1 == sparkContainerBorder))
{
return true;
}
var loc2:*=getStyle("borderStyle");
if (loc2)
{
if (!(loc2 == "none") || loc2 == "none" && getStyle("mouseShield"))
{
return true;
}
}
loc2 = getStyle("contentBackgroundColor");
if (loc1 == sparkBorder && !(loc2 === null))
{
return true;
}
loc2 = getStyle("backgroundColor");
if (!(loc2 === null) && !(loc2 === ""))
{
return true;
}
loc2 = getStyle("backgroundImage");
return !(loc2 == null) && !(loc2 == "");
}
public function get autoLayout():Boolean
{
return this._autoLayout;
}
public function set autoLayout(arg1:Boolean):void
{
var loc1:*=null;
this._autoLayout = arg1;
if (arg1)
{
invalidateSize();
invalidateDisplayList();
loc1 = parent as mx.core.IInvalidating;
if (loc1)
{
loc1.invalidateSize();
loc1.invalidateDisplayList();
}
}
return;
}
public function get borderMetrics():mx.core.EdgeMetrics
{
return this.mx_internal::border && this.mx_internal::border is mx.core.IRectangularBorder ? mx.core.IRectangularBorder(this.mx_internal::border).borderMetrics : mx.core.EdgeMetrics.EMPTY;
}
mx_internal function invalidateViewMetricsAndPadding():void
{
this._viewMetricsAndPadding = null;
return;
}
public function get childDescriptors():Array
{
return this._childDescriptors;
}
internal function createOrDestroyBlocker():void
{
var loc1:*=null;
var loc2:*=null;
if (enabled)
{
if (this.mx_internal::blocker)
{
this.rawChildren.removeChild(this.mx_internal::blocker);
this.mx_internal::blocker = null;
}
}
else if (!this.mx_internal::blocker)
{
this.mx_internal::blocker = new mx.core.FlexSprite();
this.mx_internal::blocker.name = "blocker";
this.mx_internal::blocker.mouseEnabled = true;
this.rawChildren.addChild(this.mx_internal::blocker);
this.mx_internal::blocker.addEventListener(flash.events.MouseEvent.CLICK, this.blocker_clickHandler);
loc1 = focusManager ? flash.display.DisplayObject(focusManager.getFocus()) : null;
while (loc1)
{
if (loc1 == this)
{
loc2 = systemManager;
if (loc2 && loc2.stage)
{
loc2.stage.focus = null;
}
}
loc1 = loc1.parent;
}
}
return;
}
mx_internal function get childRepeaters():Array
{
return this._childRepeaters;
}
mx_internal function set childRepeaters(arg1:Array):void
{
this._childRepeaters = arg1;
return;
}
internal function updateBackgroundImageRect():void
{
var loc1:*=this.mx_internal::border as mx.core.IRectangularBorder;
if (!loc1)
{
return;
}
if (this.viewableWidth == 0 && this.viewableHeight == 0)
{
loc1.backgroundImageBounds = null;
return;
}
var loc2:*=this.viewMetrics;
var loc3:*=this.viewableWidth ? this.viewableWidth : unscaledWidth - loc2.left - loc2.right;
var loc4:*=this.viewableHeight ? this.viewableHeight : unscaledHeight - loc2.top - loc2.bottom;
if (getStyle("backgroundAttachment") != "fixed")
{
loc1.backgroundImageBounds = new flash.geom.Rectangle(loc2.left, loc2.top, Math.max(this.scrollableWidth, loc3), Math.max(this.scrollableHeight, loc4));
}
else
{
loc1.backgroundImageBounds = new flash.geom.Rectangle(loc2.left, loc2.top, loc3, loc4);
}
return;
}
public function get clipContent():Boolean
{
return this._clipContent;
}
public function set clipContent(arg1:Boolean):void
{
if (this._clipContent != arg1)
{
this._clipContent = arg1;
invalidateDisplayList();
}
return;
}
internal function createContentPaneAndScrollbarsIfNeeded():Boolean
{
var loc1:*=null;
var loc2:*=false;
if (this._clipContent)
{
loc1 = this.mx_internal::getScrollableRect();
loc2 = this.createScrollbarsIfNeeded(loc1);
if (this.mx_internal::border)
{
this.updateBackgroundImageRect();
}
return loc2;
}
loc2 = this.createOrDestroyScrollbars(false, false, false);
loc1 = this.mx_internal::getScrollableRect();
this.scrollableWidth = loc1.right;
this.scrollableHeight = loc1.bottom;
if (loc2 && this.mx_internal::border)
{
this.updateBackgroundImageRect();
}
return loc2;
}
mx_internal function get createdComponents():Array
{
return this._createdComponents;
}
mx_internal function set createdComponents(arg1:Array):void
{
this._createdComponents = arg1;
return;
}
mx_internal function getScrollableRect():flash.geom.Rectangle
{
var loc9:*=NaN;
var loc10:*=NaN;
var loc11:*=NaN;
var loc12:*=NaN;
var loc13:*=null;
var loc14:*=null;
var loc1:*=0;
var loc2:*=0;
var loc3:*=0;
var loc4:*=0;
var loc5:*=this.numChildren;
var loc6:*=0;
while (loc6 < loc5)
{
if ((loc13 = this.getChildAt(loc6)) is mx.core.IUIComponent)
{
if (mx.core.IUIComponent(loc13).includeInLayout)
{
loc11 = (loc14 = mx.containers.utilityClasses.PostScaleAdapter.getCompatibleIUIComponent(loc13)).width;
loc12 = loc14.height;
loc9 = loc14.x;
loc10 = loc14.y;
loc1 = Math.min(loc1, loc9);
loc2 = Math.min(loc2, loc10);
if (!isNaN(loc11))
{
loc3 = Math.max(loc3, loc9 + loc11);
}
if (!isNaN(loc12))
{
loc4 = Math.max(loc4, loc10 + loc12);
}
}
}
else
{
loc11 = loc13.width;
loc12 = loc13.height;
loc9 = loc13.x;
loc10 = loc13.y;
loc1 = Math.min(loc1, loc9);
loc2 = Math.min(loc2, loc10);
if (!isNaN(loc11))
{
loc3 = Math.max(loc3, loc9 + loc11);
}
if (!isNaN(loc12))
{
loc4 = Math.max(loc4, loc10 + loc12);
}
}
++loc6;
}
var loc7:*=this.viewMetrics;
var loc8:*;
(loc8 = new flash.geom.Rectangle()).left = loc1;
loc8.top = loc2;
loc8.right = loc3;
loc8.bottom = loc4;
if (this.mx_internal::usePadding)
{
loc8.right = loc8.right + getStyle("paddingRight");
loc8.bottom = loc8.bottom + getStyle("paddingBottom");
}
return loc8;
}
public function get creationIndex():int
{
return this._creationIndex;
}
public function set creationIndex(arg1:int):void
{
this._creationIndex = arg1;
return;
}
internal function createScrollbarsIfNeeded(arg1:flash.geom.Rectangle):Boolean
{
var loc1:*=arg1.right;
var loc2:*=arg1.bottom;
var loc3:*=unscaledWidth;
var loc4:*=unscaledHeight;
var loc5:*=arg1.left < 0 || arg1.top < 0;
var loc6:*=this.viewMetrics;
if (scaleX != 1)
{
loc3 = loc3 + 1 / Math.abs(scaleX);
}
if (scaleY != 1)
{
loc4 = loc4 + 1 / Math.abs(scaleY);
}
loc3 = Math.floor(loc3);
loc4 = Math.floor(loc4);
loc1 = Math.floor(loc1);
loc2 = Math.floor(loc2);
if (this.horizontalScrollBar && !(this.horizontalScrollPolicy == mx.core.ScrollPolicy.ON))
{
loc4 = loc4 - this.horizontalScrollBar.minHeight;
}
if (this.verticalScrollBar && !(this.verticalScrollPolicy == mx.core.ScrollPolicy.ON))
{
loc3 = loc3 - this.verticalScrollBar.minWidth;
}
loc3 = loc3 - (loc6.left + loc6.right);
loc4 = loc4 - (loc6.top + loc6.bottom);
var loc7:*=this.horizontalScrollPolicy == mx.core.ScrollPolicy.ON;
var loc8:*=this.verticalScrollPolicy == mx.core.ScrollPolicy.ON;
var loc9:*=loc7 || loc8 || loc5 || !(mx_internal::effectOverlay == null) || loc6.left > 0 || loc6.top > 0;
if (loc3 < loc1)
{
loc9 = true;
if (this.horizontalScrollPolicy == mx.core.ScrollPolicy.AUTO && unscaledHeight - loc6.top - loc6.bottom >= 18 && unscaledWidth - loc6.left - loc6.right >= 32)
{
loc7 = true;
}
}
if (loc4 < loc2)
{
loc9 = true;
if (this.verticalScrollPolicy == mx.core.ScrollPolicy.AUTO && unscaledWidth - loc6.left - loc6.right >= 18 && unscaledHeight - loc6.top - loc6.bottom >= 32)
{
loc8 = true;
}
}
if (loc7 && loc8 && this.horizontalScrollPolicy == mx.core.ScrollPolicy.AUTO && this.verticalScrollPolicy == mx.core.ScrollPolicy.AUTO && this.horizontalScrollBar && this.verticalScrollBar && loc3 + this.verticalScrollBar.minWidth >= loc1 && loc4 + this.horizontalScrollBar.minHeight >= loc2)
{
var loc11:*;
loc8 = loc11 = false;
loc7 = loc11;
}
else if (loc7 && !loc8 && this.verticalScrollBar && this.horizontalScrollPolicy == mx.core.ScrollPolicy.AUTO && loc3 + this.verticalScrollBar.minWidth >= loc1)
{
loc7 = false;
}
var loc10:*=this.createOrDestroyScrollbars(loc7, loc8, loc9);
if (!(this.scrollableWidth == loc1) || !(this.viewableWidth == loc3) || loc10)
{
if (this.horizontalScrollBar)
{
this.horizontalScrollBar.setScrollProperties(loc3, 0, loc1 - loc3, this.horizontalPageScrollSize);
this.scrollPositionChanged = true;
}
this.viewableWidth = loc3;
this.scrollableWidth = loc1;
}
if (!(this.scrollableHeight == loc2) || !(this.viewableHeight == loc4) || loc10)
{
if (this.verticalScrollBar)
{
this.verticalScrollBar.setScrollProperties(loc4, 0, loc2 - loc4, this.verticalPageScrollSize);
this.scrollPositionChanged = true;
}
this.viewableHeight = loc4;
this.scrollableHeight = loc2;
}
return loc10;
}
public function get creationPolicy():String
{
if (this.creationPolicyNone)
{
return mx.core.ContainerCreationPolicy.NONE;
}
return getStyle("_creationPolicy");
}
public function set creationPolicy(arg1:String):void
{
var loc1:*=arg1;
if (arg1 != mx.core.ContainerCreationPolicy.NONE)
{
this.creationPolicyNone = false;
}
else
{
this.creationPolicyNone = true;
loc1 = mx.core.ContainerCreationPolicy.AUTO;
}
setStyle("_creationPolicy", loc1);
this.mx_internal::setActualCreationPolicies(arg1);
return;
}
internal function createOrDestroyScrollbars(arg1:Boolean, arg2:Boolean, arg3:Boolean):Boolean
{
var loc2:*=null;
var loc3:*=null;
var loc4:*=null;
var loc5:*=null;
var loc1:*=false;
if (arg1 || arg2 || arg3)
{
this.mx_internal::createContentPane();
}
if (arg1)
{
if (!this.horizontalScrollBar)
{
this.horizontalScrollBar = new mx.controls.HScrollBar();
this.horizontalScrollBar.name = "horizontalScrollBar";
if ((loc3 = getStyle("horizontalScrollBarStyleName")) && this.horizontalScrollBar is mx.styles.ISimpleStyleClient)
{
mx.styles.ISimpleStyleClient(this.horizontalScrollBar).styleName = loc3;
}
this.rawChildren.addChild(flash.display.DisplayObject(this.horizontalScrollBar));
this.horizontalScrollBar.lineScrollSize = this.horizontalLineScrollSize;
this.horizontalScrollBar.pageScrollSize = this.horizontalPageScrollSize;
this.horizontalScrollBar.addEventListener(mx.events.ScrollEvent.SCROLL, this.horizontalScrollBar_scrollHandler);
this.horizontalScrollBar.enabled = enabled;
if (this.horizontalScrollBar is mx.core.IInvalidating)
{
mx.core.IInvalidating(this.horizontalScrollBar).validateNow();
}
invalidateDisplayList();
this.mx_internal::invalidateViewMetricsAndPadding();
loc1 = true;
if (!this.verticalScrollBar)
{
this.addEventListener(flash.events.KeyboardEvent.KEY_DOWN, this.keyDownHandler);
}
}
}
else if (this.horizontalScrollBar)
{
this.horizontalScrollBar.removeEventListener(mx.events.ScrollEvent.SCROLL, this.horizontalScrollBar_scrollHandler);
this.rawChildren.removeChild(flash.display.DisplayObject(this.horizontalScrollBar));
this.horizontalScrollBar = null;
var loc6:*;
this.scrollableWidth = loc6 = 0;
this.viewableWidth = loc6;
if (this._horizontalScrollPosition != 0)
{
this._horizontalScrollPosition = 0;
this.scrollPositionChanged = true;
}
invalidateDisplayList();
this.mx_internal::invalidateViewMetricsAndPadding();
loc1 = true;
loc2 = focusManager;
if (!this.verticalScrollBar && (!loc2 || !(loc2.getFocus() == this)))
{
this.removeEventListener(flash.events.KeyboardEvent.KEY_DOWN, this.keyDownHandler);
}
}
if (arg2)
{
if (!this.verticalScrollBar)
{
this.verticalScrollBar = new mx.controls.VScrollBar();
this.verticalScrollBar.name = "verticalScrollBar";
if ((loc4 = getStyle("verticalScrollBarStyleName")) && this.verticalScrollBar is mx.styles.ISimpleStyleClient)
{
mx.styles.ISimpleStyleClient(this.verticalScrollBar).styleName = loc4;
}
this.rawChildren.addChild(flash.display.DisplayObject(this.verticalScrollBar));
this.verticalScrollBar.lineScrollSize = this.verticalLineScrollSize;
this.verticalScrollBar.pageScrollSize = this.verticalPageScrollSize;
this.verticalScrollBar.addEventListener(mx.events.ScrollEvent.SCROLL, this.verticalScrollBar_scrollHandler);
this.verticalScrollBar.enabled = enabled;
if (this.verticalScrollBar is mx.core.IInvalidating)
{
mx.core.IInvalidating(this.verticalScrollBar).validateNow();
}
invalidateDisplayList();
this.mx_internal::invalidateViewMetricsAndPadding();
loc1 = true;
if (!this.horizontalScrollBar)
{
this.addEventListener(flash.events.KeyboardEvent.KEY_DOWN, this.keyDownHandler);
}
this.addEventListener(flash.events.MouseEvent.MOUSE_WHEEL, this.mouseWheelHandler);
}
}
else if (this.verticalScrollBar)
{
this.verticalScrollBar.removeEventListener(mx.events.ScrollEvent.SCROLL, this.verticalScrollBar_scrollHandler);
this.rawChildren.removeChild(flash.display.DisplayObject(this.verticalScrollBar));
this.verticalScrollBar = null;
this.scrollableHeight = loc6 = 0;
this.viewableHeight = loc6;
if (this._verticalScrollPosition != 0)
{
this._verticalScrollPosition = 0;
this.scrollPositionChanged = true;
}
invalidateDisplayList();
this.mx_internal::invalidateViewMetricsAndPadding();
loc1 = true;
loc2 = focusManager;
if (!this.horizontalScrollBar && (!loc2 || !(loc2.getFocus() == this)))
{
this.removeEventListener(flash.events.KeyboardEvent.KEY_DOWN, this.keyDownHandler);
}
this.removeEventListener(flash.events.MouseEvent.MOUSE_WHEEL, this.mouseWheelHandler);
}
if (this.horizontalScrollBar && this.verticalScrollBar)
{
if (!this.whiteBox)
{
this.whiteBox = new mx.core.FlexShape();
this.whiteBox.name = "whiteBox";
(loc5 = this.whiteBox.graphics).beginFill(16777215);
loc5.drawRect(0, 0, this.verticalScrollBar.minWidth, this.horizontalScrollBar.minHeight);
loc5.endFill();
this.rawChildren.addChild(this.whiteBox);
}
}
else if (this.whiteBox)
{
this.rawChildren.removeChild(this.whiteBox);
this.whiteBox = null;
}
return loc1;
}
public function get defaultButton():mx.core.IFlexDisplayObject
{
return this._defaultButton;
}
public function set defaultButton(arg1:mx.core.IFlexDisplayObject):void
{
this._defaultButton = arg1;
mx.core.ContainerGlobals.focusedContainer = null;
return;
}
public function get deferredContentCreated():Boolean
{
return processedDescriptors;
}
internal function clampScrollPositions():Boolean
{
var loc1:*=false;
if (this._horizontalScrollPosition < 0)
{
this._horizontalScrollPosition = 0;
loc1 = true;
}
else if (this._horizontalScrollPosition > this.maxHorizontalScrollPosition)
{
this._horizontalScrollPosition = this.maxHorizontalScrollPosition;
loc1 = true;
}
if (this.horizontalScrollBar && !(this.horizontalScrollBar.scrollPosition == this._horizontalScrollPosition))
{
this.horizontalScrollBar.scrollPosition = this._horizontalScrollPosition;
}
if (this._verticalScrollPosition < 0)
{
this._verticalScrollPosition = 0;
loc1 = true;
}
else if (this._verticalScrollPosition > this.maxVerticalScrollPosition)
{
this._verticalScrollPosition = this.maxVerticalScrollPosition;
loc1 = true;
}
if (this.verticalScrollBar && !(this.verticalScrollBar.scrollPosition == this._verticalScrollPosition))
{
this.verticalScrollBar.scrollPosition = this._verticalScrollPosition;
}
return loc1;
}
public function get data():Object
{
return this._data;
}
public function set data(arg1:Object):void
{
this._data = arg1;
dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.DATA_CHANGE));
invalidateDisplayList();
return;
}
mx_internal function createContentPane():void
{
var loc3:*=0;
var loc5:*=null;
if (this.mx_internal::contentPane)
{
return;
}
this.creatingContentPane = true;
var loc1:*=this.numChildren;
var loc2:*=new mx.core.FlexSprite();
loc2.name = "contentPane";
if (this.mx_internal::border)
{
loc3 = this.rawChildren.getChildIndex(flash.display.DisplayObject(this.mx_internal::border)) + 1;
if (this.mx_internal::border is mx.core.IRectangularBorder && mx.core.IRectangularBorder(this.mx_internal::border).hasBackgroundImage)
{
++loc3;
}
}
else
{
loc3 = 0;
}
this.rawChildren.addChildAt(loc2, loc3);
var loc4:*=0;
while (loc4 < loc1)
{
loc5 = mx.core.IUIComponent(super.getChildAt(this._firstChildIndex));
loc2.addChild(flash.display.DisplayObject(loc5));
loc5.parentChanged(loc2);
var loc6:*;
var loc7:*=((loc6 = this).mx_internal::_numChildren - 1);
loc6.mx_internal::_numChildren = loc7;
++loc4;
}
this.mx_internal::contentPane = loc2;
this.creatingContentPane = false;
this.mx_internal::contentPane.visible = true;
return;
}
mx_internal function get firstChildIndex():int
{
return this._firstChildIndex;
}
protected function scrollChildren():void
{
if (!this.mx_internal::contentPane)
{
return;
}
var loc1:*=this.viewMetrics;
var loc2:*=0;
var loc3:*=0;
var loc4:*=unscaledWidth - loc1.left - loc1.right;
var loc5:*=unscaledHeight - loc1.top - loc1.bottom;
if (this._clipContent)
{
loc2 = loc2 + this._horizontalScrollPosition;
if (this.horizontalScrollBar)
{
loc4 = this.viewableWidth;
}
loc3 = loc3 + this._verticalScrollPosition;
if (this.verticalScrollBar)
{
loc5 = this.viewableHeight;
}
}
else
{
loc4 = this.scrollableWidth;
loc5 = this.scrollableHeight;
}
var loc6:*=this.mx_internal::getScrollableRect();
if (loc2 == 0 && loc3 == 0 && loc4 >= loc6.right && loc5 >= loc6.bottom && loc6.left >= 0 && loc6.top >= 0 && this._forceClippingCount <= 0)
{
this.mx_internal::contentPane.scrollRect = null;
this.mx_internal::contentPane.opaqueBackground = null;
this.mx_internal::contentPane.cacheAsBitmap = false;
}
else
{
this.mx_internal::contentPane.scrollRect = new flash.geom.Rectangle(loc2, loc3, loc4, loc5);
}
if (this.focusPane)
{
this.focusPane.scrollRect = this.mx_internal::contentPane.scrollRect;
}
if (this.mx_internal::border && this.mx_internal::border is mx.core.IRectangularBorder && mx.core.IRectangularBorder(this.mx_internal::border).hasBackgroundImage)
{
mx.core.IRectangularBorder(this.mx_internal::border).layoutBackgroundImage();
}
return;
}
public function get horizontalLineScrollSize():Number
{
return this._horizontalLineScrollSize;
}
public function set horizontalLineScrollSize(arg1:Number):void
{
this.scrollPropertiesChanged = true;
this._horizontalLineScrollSize = arg1;
invalidateDisplayList();
dispatchEvent(new flash.events.Event("horizontalLineScrollSizeChanged"));
return;
}
internal function dispatchScrollEvent(arg1:String, arg2:Number, arg3:Number, arg4:String):void
{
var loc1:*;
(loc1 = new mx.events.ScrollEvent(mx.events.ScrollEvent.SCROLL)).direction = arg1;
loc1.position = arg3;
loc1.delta = arg3 - arg2;
loc1.detail = arg4;
dispatchEvent(loc1);
return;
}
public function get horizontalPageScrollSize():Number
{
return this._horizontalPageScrollSize;
}
public function set horizontalPageScrollSize(arg1:Number):void
{
this.scrollPropertiesChanged = true;
this._horizontalPageScrollSize = arg1;
invalidateDisplayList();
dispatchEvent(new flash.events.Event("horizontalPageScrollSizeChanged"));
return;
}
mx_internal function set forceClipping(arg1:Boolean):void
{
if (this._clipContent)
{
if (arg1)
{
var loc1:*;
var loc2:*=((loc1 = this)._forceClippingCount + 1);
loc1._forceClippingCount = loc2;
}
else
{
loc2 = ((loc1 = this)._forceClippingCount - 1);
loc1._forceClippingCount = loc2;
}
this.mx_internal::createContentPane();
this.scrollChildren();
}
return;
}
public function get horizontalScrollBar():mx.controls.scrollClasses.ScrollBar
{
return this._horizontalScrollBar;
}
public function set horizontalScrollBar(arg1:mx.controls.scrollClasses.ScrollBar):void
{
this._horizontalScrollBar = arg1;
return;
}
public function executeChildBindings(arg1:Boolean):void
{
var loc3:*=null;
var loc1:*=this.numChildren;
var loc2:*=0;
while (loc2 < loc1)
{
if ((loc3 = mx.core.IUIComponent(this.getChildAt(loc2))) is mx.core.IDeferredInstantiationUIComponent)
{
mx.core.IDeferredInstantiationUIComponent(loc3).executeBindings(arg1);
}
++loc2;
}
return;
}
public function get horizontalScrollPosition():Number
{
if (!isNaN(this.horizontalScrollPositionPending))
{
return this.horizontalScrollPositionPending;
}
return this._horizontalScrollPosition;
}
public function set horizontalScrollPosition(arg1:Number):void
{
if (this._horizontalScrollPosition == arg1)
{
return;
}
this._horizontalScrollPosition = arg1;
this.scrollPositionChanged = true;
if (!initialized)
{
this.horizontalScrollPositionPending = arg1;
}
invalidateDisplayList();
dispatchEvent(new flash.events.Event("viewChanged"));
return;
}
protected override function keyDownHandler(arg1:flash.events.KeyboardEvent):void
{
var loc2:*=null;
var loc3:*=NaN;
var loc4:*=0;
var loc1:*=getFocus();
if (loc1 is flash.text.TextField || this.richEditableTextClass && loc1 is this.richEditableTextClass)
{
return;
}
if (arg1.isDefaultPrevented())
{
return;
}
if (this.verticalScrollBar)
{
loc2 = mx.events.ScrollEventDirection.VERTICAL;
loc3 = this.verticalScrollPosition;
var loc5:*=arg1.keyCode;
switch (loc5)
{
case flash.ui.Keyboard.DOWN:
{
this.verticalScrollPosition = this.verticalScrollPosition + this.verticalLineScrollSize;
this.dispatchScrollEvent(loc2, loc3, this.verticalScrollPosition, mx.events.ScrollEventDetail.LINE_DOWN);
arg1.stopPropagation();
break;
}
case flash.ui.Keyboard.UP:
{
this.verticalScrollPosition = this.verticalScrollPosition - this.verticalLineScrollSize;
this.dispatchScrollEvent(loc2, loc3, this.verticalScrollPosition, mx.events.ScrollEventDetail.LINE_UP);
arg1.stopPropagation();
break;
}
case flash.ui.Keyboard.PAGE_UP:
{
this.verticalScrollPosition = this.verticalScrollPosition - this.verticalPageScrollSize;
this.dispatchScrollEvent(loc2, loc3, this.verticalScrollPosition, mx.events.ScrollEventDetail.PAGE_UP);
arg1.stopPropagation();
break;
}
case flash.ui.Keyboard.PAGE_DOWN:
{
this.verticalScrollPosition = this.verticalScrollPosition + this.verticalPageScrollSize;
this.dispatchScrollEvent(loc2, loc3, this.verticalScrollPosition, mx.events.ScrollEventDetail.PAGE_DOWN);
arg1.stopPropagation();
break;
}
case flash.ui.Keyboard.HOME:
{
this.verticalScrollPosition = this.verticalScrollBar.minScrollPosition;
this.dispatchScrollEvent(loc2, loc3, this.verticalScrollPosition, mx.events.ScrollEventDetail.AT_TOP);
arg1.stopPropagation();
break;
}
case flash.ui.Keyboard.END:
{
this.verticalScrollPosition = this.verticalScrollBar.maxScrollPosition;
this.dispatchScrollEvent(loc2, loc3, this.verticalScrollPosition, mx.events.ScrollEventDetail.AT_BOTTOM);
arg1.stopPropagation();
break;
}
}
}
if (this.horizontalScrollBar)
{
loc2 = mx.events.ScrollEventDirection.HORIZONTAL;
loc3 = this.horizontalScrollPosition;
loc4 = mx_internal::mapKeycodeForLayoutDirection(arg1);
loc5 = loc4;
switch (loc5)
{
case flash.ui.Keyboard.LEFT:
{
this.horizontalScrollPosition = this.horizontalScrollPosition - this.horizontalLineScrollSize;
this.dispatchScrollEvent(loc2, loc3, this.horizontalScrollPosition, mx.events.ScrollEventDetail.LINE_LEFT);
arg1.stopPropagation();
break;
}
case flash.ui.Keyboard.RIGHT:
{
this.horizontalScrollPosition = this.horizontalScrollPosition + this.horizontalLineScrollSize;
this.dispatchScrollEvent(loc2, loc3, this.horizontalScrollPosition, mx.events.ScrollEventDetail.LINE_RIGHT);
arg1.stopPropagation();
break;
}
}
}
return;
}
public function get horizontalScrollPolicy():String
{
return this.mx_internal::_horizontalScrollPolicy;
}
public function set horizontalScrollPolicy(arg1:String):void
{
if (this.mx_internal::_horizontalScrollPolicy != arg1)
{
this.mx_internal::_horizontalScrollPolicy = arg1;
invalidateDisplayList();
dispatchEvent(new flash.events.Event("horizontalScrollPolicyChanged"));
}
return;
}
internal function mouseWheelHandler(arg1:flash.events.MouseEvent):void
{
var loc1:*=0;
var loc2:*=0;
var loc3:*=NaN;
var loc4:*=NaN;
if (this.verticalScrollBar && !arg1.isDefaultPrevented())
{
loc1 = arg1.delta <= 0 ? 1 : -1;
loc2 = this.verticalScrollBar ? this.verticalScrollBar.lineScrollSize : 1;
loc3 = Math.max(Math.abs(arg1.delta), loc2);
loc4 = this.verticalScrollPosition;
this.verticalScrollPosition = this.verticalScrollPosition + 3 * loc3 * loc1;
this.dispatchScrollEvent(mx.events.ScrollEventDirection.VERTICAL, loc4, this.verticalScrollPosition, arg1.delta <= 0 ? mx.events.ScrollEventDetail.LINE_UP : mx.events.ScrollEventDetail.LINE_DOWN);
arg1.preventDefault();
}
return;
}
public function get icon():Class
{
return this._icon;
}
public function set icon(arg1:Class):void
{
this._icon = arg1;
dispatchEvent(new flash.events.Event("iconChanged"));
return;
}
internal function layoutCompleteHandler(arg1:mx.events.FlexEvent):void
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.removeEventListener(mx.events.FlexEvent.UPDATE_COMPLETE, this.layoutCompleteHandler);
this.forceLayout = false;
var loc1:*=false;
if (!isNaN(this.horizontalScrollPositionPending))
{
if (this.horizontalScrollPositionPending < 0)
{
this.horizontalScrollPositionPending = 0;
}
else if (this.horizontalScrollPositionPending > this.maxHorizontalScrollPosition)
{
this.horizontalScrollPositionPending = this.maxHorizontalScrollPosition;
}
if (this.horizontalScrollBar && !(this.horizontalScrollBar.scrollPosition == this.horizontalScrollPositionPending))
{
this._horizontalScrollPosition = this.horizontalScrollPositionPending;
this.horizontalScrollBar.scrollPosition = this.horizontalScrollPositionPending;
loc1 = true;
}
this.horizontalScrollPositionPending = NaN;
}
if (!isNaN(this.verticalScrollPositionPending))
{
if (this.verticalScrollPositionPending < 0)
{
this.verticalScrollPositionPending = 0;
}
else if (this.verticalScrollPositionPending > this.maxVerticalScrollPosition)
{
this.verticalScrollPositionPending = this.maxVerticalScrollPosition;
}
if (this.verticalScrollBar && !(this.verticalScrollBar.scrollPosition == this.verticalScrollPositionPending))
{
this._verticalScrollPosition = this.verticalScrollPositionPending;
this.verticalScrollBar.scrollPosition = this.verticalScrollPositionPending;
loc1 = true;
}
this.verticalScrollPositionPending = NaN;
}
if (loc1)
{
this.scrollChildren();
}
return;
}
public function get label():String
{
return this._label;
}
public function set label(arg1:String):void
{
this._label = arg1;
dispatchEvent(new flash.events.Event("labelChanged"));
return;
}
public function get maxHorizontalScrollPosition():Number
{
return this.horizontalScrollBar ? this.horizontalScrollBar.maxScrollPosition : Math.max(this.scrollableWidth - this.viewableWidth, 0);
}
public function get maxVerticalScrollPosition():Number
{
return this.verticalScrollBar ? this.verticalScrollBar.maxScrollPosition : Math.max(this.scrollableHeight - this.viewableHeight, 0);
}
internal function creationCompleteHandler(arg1:mx.events.FlexEvent):void
{
var loc1:*;
var loc2:*=((loc1 = this).mx_internal::numChildrenCreated - 1);
loc1.mx_internal::numChildrenCreated = loc2;
if (this.mx_internal::numChildrenCreated <= 0)
{
dispatchEvent(new mx.events.FlexEvent("childrenCreationComplete"));
}
return;
}
mx_internal function get numChildrenCreated():int
{
return this._numChildrenCreated;
}
mx_internal function set numChildrenCreated(arg1:int):void
{
this._numChildrenCreated = arg1;
return;
}
mx_internal function get numRepeaters():int
{
return this.mx_internal::childRepeaters ? this.mx_internal::childRepeaters.length : 0;
}
internal function horizontalScrollBar_scrollHandler(arg1:flash.events.Event):void
{
var loc1:*=NaN;
if (arg1 is mx.events.ScrollEvent)
{
loc1 = this.horizontalScrollPosition;
this.horizontalScrollPosition = this.horizontalScrollBar.scrollPosition;
this.dispatchScrollEvent(mx.events.ScrollEventDirection.HORIZONTAL, loc1, this.horizontalScrollPosition, mx.events.ScrollEvent(arg1).detail);
}
return;
}
public function get rawChildren():mx.core.IChildList
{
if (!this._rawChildren)
{
this._rawChildren = new mx.core.ContainerRawChildrenList(this);
}
return this._rawChildren;
}
mx_internal function get usePadding():Boolean
{
return true;
}
internal function verticalScrollBar_scrollHandler(arg1:flash.events.Event):void
{
var loc1:*=NaN;
if (arg1 is mx.events.ScrollEvent)
{
loc1 = this.verticalScrollPosition;
this.verticalScrollPosition = this.verticalScrollBar.scrollPosition;
this.dispatchScrollEvent(mx.events.ScrollEventDirection.VERTICAL, loc1, this.verticalScrollPosition, mx.events.ScrollEvent(arg1).detail);
}
return;
}
public function get verticalLineScrollSize():Number
{
return this._verticalLineScrollSize;
}
public function set verticalLineScrollSize(arg1:Number):void
{
this.scrollPropertiesChanged = true;
this._verticalLineScrollSize = arg1;
invalidateDisplayList();
dispatchEvent(new flash.events.Event("verticalLineScrollSizeChanged"));
return;
}
internal function blocker_clickHandler(arg1:flash.events.Event):void
{
arg1.stopPropagation();
return;
}
public function get verticalPageScrollSize():Number
{
return this._verticalPageScrollSize;
}
public function set verticalPageScrollSize(arg1:Number):void
{
this.scrollPropertiesChanged = true;
this._verticalPageScrollSize = arg1;
invalidateDisplayList();
dispatchEvent(new flash.events.Event("verticalPageScrollSizeChanged"));
return;
}
internal static function getDefinition(arg1:String):Class
{
var name:String;
var result:Object;
var loc1:*;
name = arg1;
result = null;
try
{
result = flash.utils.getDefinitionByName(name);
}
catch (e:Error)
{
};
return result as Class;
}
public function get verticalScrollBar():mx.controls.scrollClasses.ScrollBar
{
return this._verticalScrollBar;
}
public function set verticalScrollBar(arg1:mx.controls.scrollClasses.ScrollBar):void
{
this._verticalScrollBar = arg1;
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
didLookup = false;
}
public function get verticalScrollPosition():Number
{
if (!isNaN(this.verticalScrollPositionPending))
{
return this.verticalScrollPositionPending;
}
return this._verticalScrollPosition;
}
public function set verticalScrollPosition(arg1:Number):void
{
if (this._verticalScrollPosition == arg1)
{
return;
}
this._verticalScrollPosition = arg1;
this.scrollPositionChanged = true;
if (!initialized)
{
this.verticalScrollPositionPending = arg1;
}
invalidateDisplayList();
dispatchEvent(new flash.events.Event("viewChanged"));
return;
}
public function get verticalScrollPolicy():String
{
return this.mx_internal::_verticalScrollPolicy;
}
public function set verticalScrollPolicy(arg1:String):void
{
if (this.mx_internal::_verticalScrollPolicy != arg1)
{
this.mx_internal::_verticalScrollPolicy = arg1;
invalidateDisplayList();
dispatchEvent(new flash.events.Event("verticalScrollPolicyChanged"));
}
return;
}
public function get viewMetrics():mx.core.EdgeMetrics
{
var loc1:*=this.borderMetrics;
var loc2:*=!(this.verticalScrollBar == null) && (this.mx_internal::doingLayout || this.verticalScrollPolicy == mx.core.ScrollPolicy.ON);
var loc3:*=!(this.horizontalScrollBar == null) && (this.mx_internal::doingLayout || this.horizontalScrollPolicy == mx.core.ScrollPolicy.ON);
if (!loc2 && !loc3)
{
return loc1;
}
if (this._viewMetrics)
{
this._viewMetrics.left = loc1.left;
this._viewMetrics.right = loc1.right;
this._viewMetrics.top = loc1.top;
this._viewMetrics.bottom = loc1.bottom;
}
else
{
this._viewMetrics = loc1.clone();
}
if (loc2)
{
this._viewMetrics.right = this._viewMetrics.right + this.verticalScrollBar.minWidth;
}
if (loc3)
{
this._viewMetrics.bottom = this._viewMetrics.bottom + this.horizontalScrollBar.minHeight;
}
return this._viewMetrics;
}
public function get viewMetricsAndPadding():mx.core.EdgeMetrics
{
if (this._viewMetricsAndPadding && (!this.horizontalScrollBar || this.horizontalScrollPolicy == mx.core.ScrollPolicy.ON) && (!this.verticalScrollBar || this.verticalScrollPolicy == mx.core.ScrollPolicy.ON))
{
return this._viewMetricsAndPadding;
}
if (!this._viewMetricsAndPadding)
{
this._viewMetricsAndPadding = new mx.core.EdgeMetrics();
}
var loc1:*=this._viewMetricsAndPadding;
var loc2:*=this.viewMetrics;
loc1.left = loc2.left + getStyle("paddingLeft");
loc1.right = loc2.right + getStyle("paddingRight");
loc1.top = loc2.top + getStyle("paddingTop");
loc1.bottom = loc2.bottom + getStyle("paddingBottom");
return loc1;
}
public override function addEventListener(arg1:String, arg2:Function, arg3:Boolean=false, arg4:int=0, arg5:Boolean=false):void
{
super.addEventListener(arg1, arg2, arg3, arg4, arg5);
if (arg1 == flash.events.MouseEvent.CLICK || arg1 == flash.events.MouseEvent.DOUBLE_CLICK || arg1 == flash.events.MouseEvent.MOUSE_DOWN || arg1 == flash.events.MouseEvent.MOUSE_MOVE || arg1 == flash.events.MouseEvent.MOUSE_OVER || arg1 == flash.events.MouseEvent.MOUSE_OUT || arg1 == flash.events.MouseEvent.MOUSE_UP || arg1 == flash.events.MouseEvent.MOUSE_WHEEL)
{
if (this.mouseEventReferenceCount < 2147483647)
{
this.mouseEventReferenceCount < 2147483647;
var loc1:*;
var loc2:*=((loc1 = this).mouseEventReferenceCount + 1);
loc1.mouseEventReferenceCount = loc2;
}
if (this.mouseEventReferenceCount < 2147483647)
{
setStyle("mouseShield", true);
setStyle("mouseShieldChildren", true);
}
}
return;
}
mx_internal function $addEventListener(arg1:String, arg2:Function, arg3:Boolean=false, arg4:int=0, arg5:Boolean=false):void
{
super.addEventListener(arg1, arg2, arg3, arg4, arg5);
return;
}
public override function removeEventListener(arg1:String, arg2:Function, arg3:Boolean=false):void
{
super.removeEventListener(arg1, arg2, arg3);
if (arg1 == flash.events.MouseEvent.CLICK || arg1 == flash.events.MouseEvent.DOUBLE_CLICK || arg1 == flash.events.MouseEvent.MOUSE_DOWN || arg1 == flash.events.MouseEvent.MOUSE_MOVE || arg1 == flash.events.MouseEvent.MOUSE_OVER || arg1 == flash.events.MouseEvent.MOUSE_OUT || arg1 == flash.events.MouseEvent.MOUSE_UP || arg1 == flash.events.MouseEvent.MOUSE_WHEEL)
{
if (this.mouseEventReferenceCount > 0)
{
this.mouseEventReferenceCount > 0;
var loc1:*;
var loc2:*;
}
if (this.mouseEventReferenceCount > 0)
{
setStyle("mouseShield", false);
setStyle("mouseShieldChildren", false);
}
}
return;
}
mx_internal function $removeEventListener(arg1:String, arg2:Function, arg3:Boolean=false):void
{
super.removeEventListener(arg1, arg2, arg3);
return;
}
public override function addChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject
{
return this.addChildAt(arg1, this.numChildren);
}
public override function addChildAt(arg1:flash.display.DisplayObject, arg2:int):flash.display.DisplayObject
{
var loc1:*=arg1.parent;
if (loc1 && !(loc1 is flash.display.Loader))
{
if (loc1 == this)
{
arg2 = arg2 != this.numChildren ? arg2 : (arg2 - 1);
}
loc1.removeChild(arg1);
}
this.mx_internal::addingChild(arg1);
if (this.mx_internal::contentPane)
{
this.mx_internal::contentPane.addChildAt(arg1, arg2);
}
else
{
mx_internal::$addChildAt(arg1, this._firstChildIndex + arg2);
}
this.mx_internal::childAdded(arg1);
if (arg1 is mx.core.UIComponent && mx.core.UIComponent(arg1).isDocument)
{
mx.binding.BindingManager.setEnabled(arg1, true);
}
return arg1;
}
public override function removeChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject
{
var loc1:*=0;
var loc2:*=0;
if (arg1 is mx.core.IDeferredInstantiationUIComponent && mx.core.IDeferredInstantiationUIComponent(arg1).descriptor)
{
if (this.mx_internal::createdComponents)
{
loc1 = this.mx_internal::createdComponents.length;
loc2 = 0;
while (loc2 < loc1)
{
if (this.mx_internal::createdComponents[loc2] === arg1)
{
this.mx_internal::createdComponents.splice(loc2, 1);
}
++loc2;
}
}
}
this.mx_internal::removingChild(arg1);
if (arg1 is mx.core.UIComponent && mx.core.UIComponent(arg1).isDocument)
{
mx.binding.BindingManager.setEnabled(arg1, false);
}
if (this.mx_internal::contentPane)
{
this.mx_internal::contentPane.removeChild(arg1);
}
else
{
mx_internal::$removeChild(arg1);
}
this.mx_internal::childRemoved(arg1);
return arg1;
}
public override function removeChildAt(arg1:int):flash.display.DisplayObject
{
return this.removeChild(this.getChildAt(arg1));
}
public override function getChildAt(arg1:int):flash.display.DisplayObject
{
if (this.mx_internal::contentPane)
{
return this.mx_internal::contentPane.getChildAt(arg1);
}
return super.getChildAt(this._firstChildIndex + arg1);
}
public override function getChildByName(arg1:String):flash.display.DisplayObject
{
var loc1:*=null;
var loc2:*=0;
if (this.mx_internal::contentPane)
{
return this.mx_internal::contentPane.getChildByName(arg1);
}
loc1 = super.getChildByName(arg1);
if (!loc1)
{
return null;
}
loc2 = super.getChildIndex(loc1) - this._firstChildIndex;
if (loc2 < 0 || loc2 >= this.mx_internal::_numChildren)
{
return null;
}
return loc1;
}
public override function getChildIndex(arg1:flash.display.DisplayObject):int
{
var loc1:*=0;
if (this.mx_internal::contentPane)
{
return this.mx_internal::contentPane.getChildIndex(arg1);
}
loc1 = super.getChildIndex(arg1) - this._firstChildIndex;
return loc1;
}
public override function setChildIndex(arg1:flash.display.DisplayObject, arg2:int):void
{
var loc1:*=0;
var loc2:*=loc1;
var loc3:*=arg2;
if (this.mx_internal::contentPane)
{
this.mx_internal::contentPane.setChildIndex(arg1, arg2);
if (this._autoLayout || this.forceLayout)
{
invalidateDisplayList();
}
}
else
{
loc1 = super.getChildIndex(arg1);
arg2 = arg2 + this._firstChildIndex;
if (arg2 == loc1)
{
return;
}
super.setChildIndex(arg1, arg2);
invalidateDisplayList();
loc2 = loc1 - this._firstChildIndex;
loc3 = arg2 - this._firstChildIndex;
}
var loc4:*;
(loc4 = new mx.events.IndexChangedEvent(mx.events.IndexChangedEvent.CHILD_INDEX_CHANGE)).relatedObject = arg1;
loc4.oldIndex = loc2;
loc4.newIndex = loc3;
dispatchEvent(loc4);
dispatchEvent(new flash.events.Event("childrenChanged"));
return;
}
public override function contains(arg1:flash.display.DisplayObject):Boolean
{
if (this.mx_internal::contentPane)
{
return this.mx_internal::contentPane.contains(arg1);
}
return super.contains(arg1);
}
public function get numElements():int
{
return this.numChildren;
}
public function getElementAt(arg1:int):mx.core.IVisualElement
{
return this.getChildAt(arg1) as mx.core.IVisualElement;
}
public function getElementIndex(arg1:mx.core.IVisualElement):int
{
if (!(arg1 is flash.display.DisplayObject))
{
throw ArgumentError(arg1 + " is not found in this Container");
}
return this.getChildIndex(arg1 as flash.display.DisplayObject);
}
public function addElement(arg1:mx.core.IVisualElement):mx.core.IVisualElement
{
if (!(arg1 is flash.display.DisplayObject))
{
throw ArgumentError(arg1 + " is not supported in this Container");
}
return this.addChild(arg1 as flash.display.DisplayObject) as mx.core.IVisualElement;
}
public function addElementAt(arg1:mx.core.IVisualElement, arg2:int):mx.core.IVisualElement
{
if (!(arg1 is flash.display.DisplayObject))
{
throw ArgumentError(arg1 + " is not supported in this Container");
}
return this.addChildAt(arg1 as flash.display.DisplayObject, arg2) as mx.core.IVisualElement;
}
public function removeElement(arg1:mx.core.IVisualElement):mx.core.IVisualElement
{
if (!(arg1 is flash.display.DisplayObject))
{
throw ArgumentError(arg1 + " is not found in this Container");
}
return this.removeChild(arg1 as flash.display.DisplayObject) as mx.core.IVisualElement;
}
public function removeElementAt(arg1:int):mx.core.IVisualElement
{
return this.removeChildAt(arg1) as mx.core.IVisualElement;
}
public function removeAllElements():void
{
var loc1:*=(this.numElements - 1);
while (loc1 >= 0)
{
this.removeElementAt(loc1);
--loc1;
}
return;
}
public function setElementIndex(arg1:mx.core.IVisualElement, arg2:int):void
{
if (!(arg1 is flash.display.DisplayObject))
{
throw ArgumentError(arg1 + " is not found in this Container");
}
return this.setChildIndex(arg1 as flash.display.DisplayObject, arg2);
}
public function swapElements(arg1:mx.core.IVisualElement, arg2:mx.core.IVisualElement):void
{
if (!(arg1 is flash.display.DisplayObject))
{
throw ArgumentError(arg1 + " is not found in this Container");
}
if (!(arg2 is flash.display.DisplayObject))
{
throw ArgumentError(arg2 + " is not found in this Container");
}
swapChildren(arg1 as flash.display.DisplayObject, arg2 as flash.display.DisplayObject);
return;
}
public function swapElementsAt(arg1:int, arg2:int):void
{
swapChildrenAt(arg1, arg2);
return;
}
public override function initialize():void
{
var loc1:*=undefined;
var loc2:*=null;
if (mx_internal::documentDescriptor && !processedDescriptors)
{
loc1 = mx_internal::documentDescriptor.properties;
if (loc1 && loc1.childDescriptors)
{
if (this._childDescriptors)
{
loc2 = resourceManager.getString("core", "multipleChildSets_ClassAndInstance");
throw new Error(loc2);
}
this._childDescriptors = loc1.childDescriptors;
}
}
super.initialize();
return;
}
protected override function createChildren():void
{
var loc1:*=undefined;
super.createChildren();
this.createBorder();
this.createOrDestroyScrollbars(this.horizontalScrollPolicy == mx.core.ScrollPolicy.ON, this.verticalScrollPolicy == mx.core.ScrollPolicy.ON, this.horizontalScrollPolicy == mx.core.ScrollPolicy.ON || this.verticalScrollPolicy == mx.core.ScrollPolicy.ON);
if (this.actualCreationPolicy == null)
{
if (this.creationPolicy != null)
{
this.actualCreationPolicy = this.creationPolicy;
}
if (this.actualCreationPolicy == mx.core.ContainerCreationPolicy.QUEUED)
{
this.actualCreationPolicy = mx.core.ContainerCreationPolicy.AUTO;
}
}
if (this.actualCreationPolicy != mx.core.ContainerCreationPolicy.NONE)
{
if (this.actualCreationPolicy != mx.core.ContainerCreationPolicy.QUEUED)
{
if (this.recursionFlag)
{
this.createComponentsFromDescriptors();
}
}
else
{
loc1 = parentApplication ? parentApplication : mx.core.FlexGlobals.topLevelApplication;
if ("addToCreationQueue" in loc1)
{
loc1.addToCreationQueue(this, this._creationIndex, null, this);
}
else
{
this.createComponentsFromDescriptors();
}
}
}
else
{
this.actualCreationPolicy = mx.core.ContainerCreationPolicy.AUTO;
}
if (this.autoLayout == false)
{
this.forceLayout = true;
}
mx.core.UIComponentGlobals.mx_internal::layoutManager.addEventListener(mx.events.FlexEvent.UPDATE_COMPLETE, this.layoutCompleteHandler, false, 0, true);
return;
}
protected override function initializationComplete():void
{
return;
}
public override function invalidateLayoutDirection():void
{
var loc1:*=0;
var loc2:*=0;
var loc3:*=null;
super.invalidateLayoutDirection();
if (this._rawChildren)
{
loc1 = this._rawChildren.numChildren;
loc2 = 0;
while (loc2 < loc1)
{
loc3 = this._rawChildren.getChildAt(loc2);
if (!(loc3 is mx.styles.IStyleClient) && loc3 is mx.core.ILayoutDirectionElement)
{
mx.core.ILayoutDirectionElement(loc3).invalidateLayoutDirection();
}
++loc2;
}
}
return;
}
protected override function commitProperties():void
{
var loc1:*=null;
super.commitProperties();
if (this.changedStyles)
{
loc1 = this.changedStyles != MULTIPLE_PROPERTIES ? this.changedStyles : null;
super.notifyStyleChangeInChildren(loc1, true);
this.changedStyles = null;
}
this.createOrDestroyBlocker();
return;
}
public override function validateSize(arg1:Boolean=false):void
{
var loc1:*=0;
var loc2:*=0;
var loc3:*=null;
if (this.autoLayout == false && this.forceLayout == false)
{
if (arg1)
{
loc1 = super.numChildren;
loc2 = 0;
while (loc2 < loc1)
{
if ((loc3 = super.getChildAt(loc2)) is mx.managers.ILayoutManagerClient)
{
mx.managers.ILayoutManagerClient(loc3).validateSize(true);
}
++loc2;
}
}
mx_internal::adjustSizesForScaleChanges();
}
else
{
super.validateSize(arg1);
}
return;
}
public override function validateDisplayList():void
{
var loc1:*=null;
var loc2:*=NaN;
var loc3:*=NaN;
var loc4:*=null;
var loc5:*=NaN;
var loc6:*=NaN;
var loc7:*=NaN;
if (this._autoLayout || this.forceLayout)
{
this.mx_internal::doingLayout = true;
super.validateDisplayList();
this.mx_internal::doingLayout = false;
}
else
{
this.layoutChrome(unscaledWidth, unscaledHeight);
}
mx_internal::invalidateDisplayListFlag = true;
if (this.createContentPaneAndScrollbarsIfNeeded())
{
if (this._autoLayout || this.forceLayout)
{
this.mx_internal::doingLayout = true;
super.validateDisplayList();
this.mx_internal::doingLayout = false;
}
this.createContentPaneAndScrollbarsIfNeeded();
}
if (this.clampScrollPositions())
{
this.scrollChildren();
}
if (this.mx_internal::contentPane)
{
loc1 = this.viewMetrics;
if (mx_internal::effectOverlay)
{
mx_internal::effectOverlay.x = 0;
mx_internal::effectOverlay.y = 0;
mx_internal::effectOverlay.width = unscaledWidth;
mx_internal::effectOverlay.height = unscaledHeight;
}
if (this.horizontalScrollBar || this.verticalScrollBar)
{
if (this.verticalScrollBar && this.verticalScrollPolicy == mx.core.ScrollPolicy.ON)
{
loc1.right = loc1.right - this.verticalScrollBar.minWidth;
}
if (this.horizontalScrollBar && this.horizontalScrollPolicy == mx.core.ScrollPolicy.ON)
{
loc1.bottom = loc1.bottom - this.horizontalScrollBar.minHeight;
}
if (this.horizontalScrollBar)
{
loc2 = unscaledWidth - loc1.left - loc1.right;
if (this.verticalScrollBar)
{
loc2 = loc2 - this.verticalScrollBar.minWidth;
}
this.horizontalScrollBar.setActualSize(loc2, this.horizontalScrollBar.minHeight);
this.horizontalScrollBar.move(loc1.left, unscaledHeight - loc1.bottom - this.horizontalScrollBar.minHeight);
}
if (this.verticalScrollBar)
{
loc3 = unscaledHeight - loc1.top - loc1.bottom;
if (this.horizontalScrollBar)
{
loc3 = loc3 - this.horizontalScrollBar.minHeight;
}
this.verticalScrollBar.setActualSize(this.verticalScrollBar.minWidth, loc3);
this.verticalScrollBar.move(unscaledWidth - loc1.right - this.verticalScrollBar.minWidth, loc1.top);
}
if (this.whiteBox)
{
this.whiteBox.x = this.verticalScrollBar.x;
this.whiteBox.y = this.horizontalScrollBar.y;
}
}
this.mx_internal::contentPane.x = loc1.left;
this.mx_internal::contentPane.y = loc1.top;
if (this.focusPane)
{
this.focusPane.x = loc1.left;
this.focusPane.y = loc1.top;
}
this.scrollChildren();
}
mx_internal::invalidateDisplayListFlag = false;
if (this.mx_internal::blocker)
{
loc1 = this.viewMetrics;
if (mx.core.FlexVersion.compatibilityVersion >= mx.core.FlexVersion.VERSION_4_0)
{
loc1 = mx.core.EdgeMetrics.EMPTY;
}
if ((loc4 = enabled ? null : getStyle("backgroundDisabledColor")) === null || isNaN(Number(loc4)))
{
loc4 = getStyle("backgroundColor");
}
if (loc4 === null || isNaN(Number(loc4)))
{
loc4 = 16777215;
}
loc5 = getStyle("disabledOverlayAlpha");
if (isNaN(loc5))
{
loc5 = 0.6;
}
this.mx_internal::blocker.x = loc1.left;
this.mx_internal::blocker.y = loc1.top;
loc6 = unscaledWidth - (loc1.left + loc1.right);
loc7 = unscaledHeight - (loc1.top + loc1.bottom);
this.mx_internal::blocker.graphics.clear();
this.mx_internal::blocker.graphics.beginFill(uint(loc4), loc5);
this.mx_internal::blocker.graphics.drawRect(0, 0, loc6, loc7);
this.mx_internal::blocker.graphics.endFill();
this.rawChildren.setChildIndex(this.mx_internal::blocker, (this.rawChildren.numChildren - 1));
}
return;
}
protected override function updateDisplayList(arg1:Number, arg2:Number):void
{
var loc1:*=null;
var loc2:*=NaN;
super.updateDisplayList(arg1, arg2);
this.layoutChrome(arg1, arg2);
if (this.scrollPositionChanged)
{
this.clampScrollPositions();
this.scrollChildren();
this.scrollPositionChanged = false;
}
if (this.scrollPropertiesChanged)
{
if (this.horizontalScrollBar)
{
this.horizontalScrollBar.lineScrollSize = this.horizontalLineScrollSize;
this.horizontalScrollBar.pageScrollSize = this.horizontalPageScrollSize;
}
if (this.verticalScrollBar)
{
this.verticalScrollBar.lineScrollSize = this.verticalLineScrollSize;
this.verticalScrollBar.pageScrollSize = this.verticalPageScrollSize;
}
this.scrollPropertiesChanged = false;
}
if (this.mx_internal::contentPane && this.mx_internal::contentPane.scrollRect)
{
loc1 = enabled ? null : getStyle("backgroundDisabledColor");
if (loc1 === null || isNaN(Number(loc1)))
{
loc1 = getStyle("backgroundColor");
}
loc2 = getStyle("backgroundAlpha");
if (!this._clipContent || isNaN(Number(loc1)) || loc1 === "" || !(this.horizontalScrollBar || this.verticalScrollBar) && !cacheAsBitmap)
{
loc1 = null;
}
else if (getStyle("backgroundImage") || getStyle("background"))
{
loc1 = null;
}
else if (loc2 != 1)
{
loc1 = null;
}
this.mx_internal::contentPane.opaqueBackground = loc1;
this.mx_internal::contentPane.cacheAsBitmap = !(loc1 == null);
}
return;
}
public override function contentToGlobal(arg1:flash.geom.Point):flash.geom.Point
{
if (this.mx_internal::contentPane)
{
return this.mx_internal::contentPane.localToGlobal(arg1);
}
return localToGlobal(arg1);
}
public override function globalToContent(arg1:flash.geom.Point):flash.geom.Point
{
if (this.mx_internal::contentPane)
{
return this.mx_internal::contentPane.globalToLocal(arg1);
}
return globalToLocal(arg1);
}
public override function contentToLocal(arg1:flash.geom.Point):flash.geom.Point
{
if (!this.mx_internal::contentPane)
{
return arg1;
}
arg1 = this.contentToGlobal(arg1);
return globalToLocal(arg1);
}
public override function localToContent(arg1:flash.geom.Point):flash.geom.Point
{
if (!this.mx_internal::contentPane)
{
return arg1;
}
arg1 = localToGlobal(arg1);
return this.globalToContent(arg1);
}
public override function styleChanged(arg1:String):void
{
var loc2:*=null;
var loc3:*=null;
var loc1:*=arg1 == null || arg1 == "styleName";
if (loc1 || styleManager.isSizeInvalidatingStyle(arg1))
{
invalidateDisplayList();
}
if (loc1 || arg1 == "borderSkin")
{
if (this.mx_internal::border)
{
this.rawChildren.removeChild(flash.display.DisplayObject(this.mx_internal::border));
this.mx_internal::border = null;
this.createBorder();
}
}
if (loc1 || arg1 == "borderStyle" || arg1 == "backgroundColor" || arg1 == "backgroundImage" || arg1 == "mouseShield" || arg1 == "mouseShieldChildren")
{
this.createBorder();
}
super.styleChanged(arg1);
if (loc1 || styleManager.isSizeInvalidatingStyle(arg1))
{
this.mx_internal::invalidateViewMetricsAndPadding();
}
if (loc1 || arg1 == "horizontalScrollBarStyleName")
{
if (this.horizontalScrollBar && this.horizontalScrollBar is mx.styles.ISimpleStyleClient)
{
loc2 = getStyle("horizontalScrollBarStyleName");
mx.styles.ISimpleStyleClient(this.horizontalScrollBar).styleName = loc2;
}
}
if (loc1 || arg1 == "verticalScrollBarStyleName")
{
if (this.verticalScrollBar && this.verticalScrollBar is mx.styles.ISimpleStyleClient)
{
loc3 = getStyle("verticalScrollBarStyleName");
mx.styles.ISimpleStyleClient(this.verticalScrollBar).styleName = loc3;
}
}
return;
}
public override function notifyStyleChangeInChildren(arg1:String, arg2:Boolean):void
{
var loc3:*=null;
var loc1:*=super.numChildren;
var loc2:*=0;
while (loc2 < loc1)
{
if (this.mx_internal::contentPane || loc2 < this._firstChildIndex || loc2 >= this._firstChildIndex + this.mx_internal::_numChildren)
{
if (loc3 = super.getChildAt(loc2) as mx.styles.ISimpleStyleClient)
{
loc3.styleChanged(arg1);
if (loc3 is mx.styles.IStyleClient)
{
mx.styles.IStyleClient(loc3).notifyStyleChangeInChildren(arg1, arg2);
}
}
}
++loc2;
}
if (arg2)
{
this.changedStyles = !(this.changedStyles == null) || arg1 == null ? MULTIPLE_PROPERTIES : arg1;
invalidateProperties();
}
return;
}
public override function regenerateStyleCache(arg1:Boolean):void
{
var loc1:*=0;
var loc2:*=0;
var loc3:*=null;
super.regenerateStyleCache(arg1);
if (this.mx_internal::contentPane)
{
loc1 = this.mx_internal::contentPane.numChildren;
loc2 = 0;
while (loc2 < loc1)
{
if ((loc3 = this.getChildAt(loc2)) is mx.core.UIComponent)
{
if (mx.core.UIComponent(loc3).inheritingStyles != mx.styles.StyleProtoChain.STYLE_UNINITIALIZED)
{
mx.core.UIComponent(loc3).regenerateStyleCache(arg1);
}
}
else if (loc3 is mx.core.IUITextField && mx.core.IUITextField(loc3).inheritingStyles)
{
mx.styles.StyleProtoChain.initTextField(mx.core.IUITextField(loc3));
}
++loc2;
}
}
return;
}
protected override function attachOverlay():void
{
this.mx_internal::rawChildren_addChild(mx_internal::effectOverlay);
return;
}
mx_internal override function fillOverlay(arg1:mx.core.UIComponent, arg2:uint, arg3:mx.geom.RoundedRectangle=null):void
{
var loc1:*=this.viewMetrics;
var loc2:*=0;
if (!arg3)
{
arg3 = new mx.geom.RoundedRectangle(loc1.left, loc1.top, unscaledWidth - loc1.right - loc1.left, unscaledHeight - loc1.bottom - loc1.top, loc2);
}
if (isNaN(arg3.x) || isNaN(arg3.y) || isNaN(arg3.width) || isNaN(arg3.height) || isNaN(arg3.cornerRadius))
{
return;
}
var loc3:*;
(loc3 = arg1.graphics).clear();
loc3.beginFill(arg2);
loc3.drawRoundRect(arg3.x, arg3.y, arg3.width, arg3.height, arg3.cornerRadius * 2, arg3.cornerRadius * 2);
loc3.endFill();
return;
}
public override function executeBindings(arg1:Boolean=false):void
{
var loc1:*=descriptor && descriptor.document ? descriptor.document : parentDocument;
mx.binding.BindingManager.executeBindings(loc1, id, this);
if (arg1)
{
this.executeChildBindings(arg1);
}
return;
}
public override function prepareToPrint(arg1:mx.core.IFlexDisplayObject):Object
{
var loc1:*=this.mx_internal::contentPane && this.mx_internal::contentPane.scrollRect ? this.mx_internal::contentPane.scrollRect : null;
if (loc1)
{
this.mx_internal::contentPane.scrollRect = null;
}
super.prepareToPrint(arg1);
return loc1;
}
public override function finishPrint(arg1:Object, arg2:mx.core.IFlexDisplayObject):void
{
if (arg1)
{
this.mx_internal::contentPane.scrollRect = flash.geom.Rectangle(arg1);
}
super.finishPrint(arg1, arg2);
return;
}
mx_internal override function addingChild(arg1:flash.display.DisplayObject):void
{
var loc1:*=mx.core.IUIComponent(arg1);
super.mx_internal::addingChild(arg1);
invalidateSize();
invalidateDisplayList();
if (!this.mx_internal::contentPane)
{
if (this.mx_internal::_numChildren == 0)
{
this._firstChildIndex = super.numChildren;
}
var loc2:*;
var loc3:*=((loc2 = this).mx_internal::_numChildren + 1);
loc2.mx_internal::_numChildren = loc3;
}
if (this.mx_internal::contentPane && !this.autoLayout)
{
this.forceLayout = true;
mx.core.UIComponentGlobals.mx_internal::layoutManager.addEventListener(mx.events.FlexEvent.UPDATE_COMPLETE, this.layoutCompleteHandler, false, 0, true);
}
return;
}
mx_internal static const VERSION:String="4.1.0.16076";
internal static const MULTIPLE_PROPERTIES:String="<MULTIPLE>";
internal var recursionFlag:Boolean=true;
internal var forceLayout:Boolean=false;
mx_internal var doingLayout:Boolean=false;
internal var changedStyles:String=null;
internal var _creatingContentPane:Boolean=false;
protected var whiteBox:flash.display.Shape;
mx_internal var contentPane:flash.display.Sprite=null;
internal var scrollPropertiesChanged:Boolean=false;
internal var scrollPositionChanged:Boolean=true;
internal var horizontalScrollPositionPending:Number;
internal var verticalScrollPositionPending:Number;
internal var scrollableWidth:Number=0;
internal var scrollableHeight:Number=0;
internal var viewableWidth:Number=0;
internal var viewableHeight:Number=0;
mx_internal var border:mx.core.IFlexDisplayObject;
mx_internal var blocker:flash.display.Sprite;
internal var mouseEventReferenceCount:int=0;
internal var richEditableTextClass:Class;
internal var _focusPane:flash.display.Sprite;
mx_internal var _numChildren:int=0;
internal var _autoLayout:Boolean=true;
internal var _childDescriptors:Array;
internal var _childRepeaters:Array;
internal var _clipContent:Boolean=true;
internal var _createdComponents:Array;
internal var _creationIndex:int=-1;
internal var creationPolicyNone:Boolean=false;
internal var _defaultButton:mx.core.IFlexDisplayObject;
internal var _data:Object;
internal var _firstChildIndex:int=0;
internal var _horizontalLineScrollSize:Number=5;
internal var _horizontalPageScrollSize:Number=0;
internal var _horizontalScrollBar:mx.controls.scrollClasses.ScrollBar;
internal var _horizontalScrollPosition:Number=0;
mx_internal var _horizontalScrollPolicy:String="auto";
internal var _icon:Class=null;
internal var _label:String="";
internal var _numChildrenCreated:int=-1;
protected var actualCreationPolicy:String;
internal var _verticalLineScrollSize:Number=5;
internal var _verticalPageScrollSize:Number=0;
internal var _verticalScrollBar:mx.controls.scrollClasses.ScrollBar;
internal var _verticalScrollPosition:Number=0;
internal var _forceClippingCount:int;
internal var _viewMetrics:mx.core.EdgeMetrics;
internal var _rawChildren:mx.core.ContainerRawChildrenList;
internal var numChildrenBefore:int;
internal static var haloBorder:Class;
internal static var sparkBorder:Class;
internal static var sparkContainerBorder:Class;
internal static var didLookup:Boolean=false;
mx_internal var _verticalScrollPolicy:String="auto";
internal var _viewMetricsAndPadding:mx.core.EdgeMetrics;
}
}
// class ContainerCreationPolicy
package mx.core
{
use namespace mx_internal;
public final class ContainerCreationPolicy extends Object
{
public function ContainerCreationPolicy()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const AUTO:String="auto";
public static const ALL:String="all";
public static const QUEUED:String="queued";
public static const NONE:String="none";
}
}
// class ContainerGlobals
package mx.core
{
import flash.display.*;
import mx.managers.*;
public class ContainerGlobals extends Object
{
public function ContainerGlobals()
{
super();
return;
}
public static function checkFocus(arg1:flash.display.InteractiveObject, arg2:flash.display.InteractiveObject):void
{
var loc4:*=null;
var loc5:*=null;
var loc1:*=arg2;
var loc2:*=arg2;
var loc3:*=null;
if (!(arg2 == null) && arg1 == arg2)
{
return;
}
while (loc2)
{
if (loc2.parent)
{
loc1 = loc2.parent;
}
else
{
loc1 = null;
}
if (loc2 is mx.core.IUIComponent)
{
loc3 = mx.core.IUIComponent(loc2);
}
if (!((loc2 = loc1) && loc2 is mx.managers.IFocusManagerContainer && mx.managers.IFocusManagerContainer(loc2).defaultButton))
{
continue;
}
break;
}
if (!(mx.core.ContainerGlobals.focusedContainer == loc2) || mx.core.ContainerGlobals.focusedContainer == null && loc2 == null)
{
if (!loc2)
{
loc2 = flash.display.InteractiveObject(loc3);
}
if (loc2 && loc2 is mx.managers.IFocusManagerContainer)
{
if (!(loc4 = mx.managers.IFocusManagerContainer(loc2).focusManager))
{
return;
}
if (loc5 = mx.managers.IFocusManagerContainer(loc2).defaultButton as mx.core.IButton)
{
mx.core.ContainerGlobals.focusedContainer = flash.display.InteractiveObject(loc2);
loc4.defaultButton = loc5 as mx.core.IButton;
}
else
{
mx.core.ContainerGlobals.focusedContainer = flash.display.InteractiveObject(loc2);
loc4.defaultButton = null;
}
}
}
return;
}
public static var focusedContainer:flash.display.InteractiveObject;
}
}
// class ContainerLayout
package mx.core
{
use namespace mx_internal;
public final class ContainerLayout extends Object
{
public function ContainerLayout()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const ABSOLUTE:String="absolute";
public static const VERTICAL:String="vertical";
public static const HORIZONTAL:String="horizontal";
}
}
// class ContainerRawChildrenList
package mx.core
{
import flash.display.*;
import flash.geom.*;
use namespace mx_internal;
public class ContainerRawChildrenList extends Object implements mx.core.IChildList
{
public function ContainerRawChildrenList(arg1:mx.core.Container)
{
super();
this.owner = arg1;
return;
}
public function get numChildren():int
{
return this.owner.mx_internal::$numChildren;
}
public function addChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject
{
return this.owner.mx_internal::rawChildren_addChild(arg1);
}
public function addChildAt(arg1:flash.display.DisplayObject, arg2:int):flash.display.DisplayObject
{
return this.owner.mx_internal::rawChildren_addChildAt(arg1, arg2);
}
public function removeChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject
{
return this.owner.mx_internal::rawChildren_removeChild(arg1);
}
public function removeChildAt(arg1:int):flash.display.DisplayObject
{
return this.owner.mx_internal::rawChildren_removeChildAt(arg1);
}
public function getChildAt(arg1:int):flash.display.DisplayObject
{
return this.owner.mx_internal::rawChildren_getChildAt(arg1);
}
public function getChildByName(arg1:String):flash.display.DisplayObject
{
return this.owner.mx_internal::rawChildren_getChildByName(arg1);
}
public function getChildIndex(arg1:flash.display.DisplayObject):int
{
return this.owner.mx_internal::rawChildren_getChildIndex(arg1);
}
public function setChildIndex(arg1:flash.display.DisplayObject, arg2:int):void
{
this.owner.mx_internal::rawChildren_setChildIndex(arg1, arg2);
return;
}
public function getObjectsUnderPoint(arg1:flash.geom.Point):Array
{
return this.owner.mx_internal::rawChildren_getObjectsUnderPoint(arg1);
}
public function contains(arg1:flash.display.DisplayObject):Boolean
{
return this.owner.mx_internal::rawChildren_contains(arg1);
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var owner:mx.core.Container;
}
}
// class DesignLayer
package mx.core
{
import flash.events.*;
import mx.events.*;
public class DesignLayer extends flash.events.EventDispatcher implements mx.core.IMXMLObject
{
public function DesignLayer()
{
this.layerChildren = new Array();
super();
return;
}
public function get id():String
{
return this._id;
}
public function set id(arg1:String):void
{
this._id = arg1;
return;
}
public function get parent():mx.core.DesignLayer
{
return this._parent;
}
protected function parentChanged(arg1:mx.core.DesignLayer):void
{
if (this._parent && arg1)
{
this._parent.removeLayer(this);
}
this._parent = arg1;
this.effectiveVisibilityChanged(this._visible);
this.effectiveAlphaChanged(this._alpha);
return;
}
public function get visible():Boolean
{
return this._visible;
}
public function set visible(arg1:Boolean):void
{
if (this._visible != arg1)
{
this._visible = arg1;
this.effectiveVisibilityChanged(this.effectiveVisibility);
}
return;
}
public function get effectiveVisibility():Boolean
{
var loc1:*=this._visible;
var loc2:*=this;
while (loc1 && loc2.parent)
{
loc2 = loc2.parent;
loc1 = loc2.visible;
}
return loc1;
}
protected function effectiveVisibilityChanged(arg1:Boolean):void
{
var loc2:*=null;
dispatchEvent(new mx.events.PropertyChangeEvent("layerPropertyChange", false, false, mx.events.PropertyChangeEventKind.UPDATE, "effectiveVisibility", !this.effectiveVisibility, this.effectiveVisibility));
var loc1:*=0;
while (loc1 < this.layerChildren.length)
{
loc2 = this.layerChildren[loc1];
if (loc2.visible)
{
loc2.effectiveVisibilityChanged(arg1);
}
++loc1;
}
return;
}
public function get alpha():Number
{
return this._alpha;
}
public function set alpha(arg1:Number):void
{
var loc1:*=NaN;
if (this._alpha != arg1)
{
loc1 = this._alpha;
this._alpha = arg1;
this.effectiveAlphaChanged(loc1);
}
return;
}
public function get effectiveAlpha():Number
{
var loc1:*=this._alpha;
var loc2:*=this;
while (loc2.parent)
{
loc2 = loc2.parent;
loc1 = loc1 * loc2.alpha;
}
return loc1;
}
protected function effectiveAlphaChanged(arg1:Number):void
{
var loc2:*=null;
dispatchEvent(new mx.events.PropertyChangeEvent("layerPropertyChange", false, false, mx.events.PropertyChangeEventKind.UPDATE, "effectiveAlpha", arg1, this.effectiveAlpha));
var loc1:*=0;
while (loc1 < this.layerChildren.length)
{
loc2 = this.layerChildren[loc1];
loc2.effectiveAlphaChanged(loc2.alpha);
++loc1;
}
return;
}
public function get numLayers():int
{
return this.layerChildren.length;
}
public function addLayer(arg1:mx.core.DesignLayer):void
{
arg1.parentChanged(this);
this.layerChildren.push(arg1);
return;
}
public function getLayerAt(arg1:int):mx.core.DesignLayer
{
return arg1 < this.layerChildren.length && arg1 >= 0 ? this.layerChildren[arg1] : null;
}
public function initialized(arg1:Object, arg2:String):void
{
this.id = arg2;
return;
}
public function removeLayer(arg1:mx.core.DesignLayer):void
{
var loc1:*=0;
while (loc1 < this.layerChildren.length)
{
if (this.layerChildren[loc1] == arg1)
{
arg1.parentChanged(null);
this.layerChildren.splice(loc1, 1);
return;
}
++loc1;
}
return;
}
internal var _id:String;
internal var _parent:mx.core.DesignLayer;
internal var layerChildren:Array;
internal var _visible:Boolean=true;
internal var _alpha:Number=1;
}
}
// class DragSource
package mx.core
{
use namespace mx_internal;
public class DragSource extends Object
{
public function DragSource()
{
this.dataHolder = {};
this.formatHandlers = {};
this._formats = [];
super();
return;
}
public function get formats():Array
{
return this._formats;
}
public function addData(arg1:Object, arg2:String):void
{
this._formats.push(arg2);
this.dataHolder[arg2] = arg1;
return;
}
public function addHandler(arg1:Function, arg2:String):void
{
this._formats.push(arg2);
this.formatHandlers[arg2] = arg1;
return;
}
public function dataForFormat(arg1:String):Object
{
var loc1:*=this.dataHolder[arg1];
if (loc1)
{
return loc1;
}
if (this.formatHandlers[arg1])
{
var loc2:*;
return (loc2 = this.formatHandlers)[arg1]();
}
return null;
}
public function hasFormat(arg1:String):Boolean
{
var loc1:*=this._formats.length;
var loc2:*=0;
while (loc2 < loc1)
{
if (this._formats[loc2] == arg1)
{
return true;
}
++loc2;
}
return false;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var dataHolder:Object;
internal var formatHandlers:Object;
internal var _formats:Array;
}
}
// class EdgeMetrics
package mx.core
{
use namespace mx_internal;
public class EdgeMetrics extends Object
{
public function EdgeMetrics(arg1:Number=0, arg2:Number=0, arg3:Number=0, arg4:Number=0)
{
super();
this.left = arg1;
this.top = arg2;
this.right = arg3;
this.bottom = arg4;
return;
}
public function clone():mx.core.EdgeMetrics
{
return new mx.core.EdgeMetrics(this.left, this.top, this.right, this.bottom);
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const EMPTY:mx.core.EdgeMetrics=new EdgeMetrics(0, 0, 0, 0);
public var bottom:Number;
public var left:Number;
public var right:Number;
public var top:Number;
}
}
// class EmbeddedFont
package mx.core
{
use namespace mx_internal;
public class EmbeddedFont extends Object
{
public function EmbeddedFont(arg1:String, arg2:Boolean, arg3:Boolean)
{
super();
this.initialize(arg1, arg2, arg3);
return;
}
public function get bold():Boolean
{
return this._bold;
}
public function get fontName():String
{
return this._fontName;
}
public function get fontStyle():String
{
return this._fontStyle;
}
public function get italic():Boolean
{
return this._italic;
}
public function initialize(arg1:String, arg2:Boolean, arg3:Boolean):void
{
this._bold = arg2;
this._italic = arg3;
this._fontName = arg1;
this._fontStyle = mx.core.EmbeddedFontRegistry.getInstance().getFontStyle(arg2, arg3);
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var _bold:Boolean;
internal var _fontName:String;
internal var _fontStyle:String;
internal var _italic:Boolean;
}
}
// class EmbeddedFontRegistry
package mx.core
{
import flash.system.*;
import flash.text.*;
import flash.text.engine.*;
import flash.utils.*;
import mx.managers.*;
import mx.resources.*;
use namespace mx_internal;
public class EmbeddedFontRegistry extends Object implements mx.core.IEmbeddedFontRegistry
{
public function EmbeddedFontRegistry()
{
super();
return;
}
internal function get resourceManager():mx.resources.IResourceManager
{
if (!this._resourceManager)
{
this._resourceManager = mx.resources.ResourceManager.getInstance();
}
return this._resourceManager;
}
public function getFontStyle(arg1:Boolean, arg2:Boolean):String
{
var loc1:*=flash.text.FontStyle.REGULAR;
if (arg1 && arg2)
{
loc1 = flash.text.FontStyle.BOLD_ITALIC;
}
else if (arg1)
{
loc1 = flash.text.FontStyle.BOLD;
}
else if (arg2)
{
loc1 = flash.text.FontStyle.ITALIC;
}
return loc1;
}
public function registerFont(arg1:mx.core.EmbeddedFont, arg2:mx.core.IFlexModuleFactory):void
{
var loc1:*=createFontKey(arg1);
var loc2:*;
if (!(loc2 = fonts[loc1]))
{
loc2 = new flash.utils.Dictionary(true);
fonts[loc1] = loc2;
}
loc2[arg2] = 1;
return;
}
public function deregisterFont(arg1:mx.core.EmbeddedFont, arg2:mx.core.IFlexModuleFactory):void
{
var loc3:*=0;
var loc4:*=null;
var loc1:*=createFontKey(arg1);
var loc2:*;
if ((loc2 = fonts[loc1]) != null)
{
delete loc2[arg2];
loc3 = 0;
var loc5:*=0;
var loc6:*=loc2;
for (loc4 in loc6)
{
++loc3;
}
if (loc3 == 0)
{
delete fonts[loc1];
}
}
return;
}
public function isFontRegistered(arg1:mx.core.EmbeddedFont, arg2:mx.core.IFlexModuleFactory):Boolean
{
var loc1:*=createFontKey(arg1);
var loc2:*;
return (loc2 = fonts[loc1]) && loc2[arg2] == 1;
}
public function getFonts():Array
{
var loc2:*=null;
var loc1:*=[];
var loc3:*=0;
var loc4:*=fonts;
for (loc2 in loc4)
{
loc1.push(createEmbeddedFont(loc2));
}
return loc1;
}
public function getAssociatedModuleFactory(arg1:String, arg2:Boolean, arg3:Boolean, arg4:Object, arg5:mx.core.IFlexModuleFactory, arg6:mx.managers.ISystemManager, arg7:*=undefined):mx.core.IFlexModuleFactory
{
var loc1:*=null;
var loc2:*=null;
var loc4:*=0;
var loc5:*=null;
var loc6:*=false;
var loc7:*=null;
if (loc1 = cachedFontsForObjects[arg4])
{
if (!(loc1.fontName == arg1) || !(loc1.bold == arg2) || !(loc1.italic == arg3))
{
loc1 = new mx.core.EmbeddedFont(arg1, arg2, arg3);
cachedFontsForObjects[arg4] = loc1;
}
}
else
{
loc1 = new mx.core.EmbeddedFont(arg1, arg2, arg3);
cachedFontsForObjects[arg4] = loc1;
}
var loc3:*;
if (loc3 = fonts[createFontKey(loc1)])
{
if (loc4 = loc3[arg5])
{
loc2 = arg5;
}
else
{
var loc8:*=0;
var loc9:*=loc3;
for (loc5 in loc9)
{
loc2 = loc5 as mx.core.IFlexModuleFactory;
break;
}
}
}
if (!loc2 && arg6)
{
staticTextFormat.font = arg1;
staticTextFormat.bold = arg2;
staticTextFormat.italic = arg3;
if (arg6.isFontFaceEmbedded(staticTextFormat))
{
loc2 = arg6;
}
}
if (loc2 && !(arg7 == undefined) && flash.system.Capabilities.isDebugger)
{
if (!(loc6 = arg7 ? loc2.callInContext(flash.text.engine.FontDescription.isFontCompatible, null, [arg1, arg2 ? "bold" : "normal", arg3 ? "italic" : "normal"]) : loc2.callInContext(flash.text.TextField.isFontCompatible, null, [arg1, this.getFontStyle(arg2, arg3)])))
{
if (!flaggedObjects[arg4])
{
loc7 = (loc7 = flash.utils.getQualifiedClassName(arg4)) + ("name" in arg4 && !(arg4.name == null) ? " (" + arg4.name + ") " : "");
trace(this.resourceManager.getString("core", "fontIncompatible", [arg1, loc7, arg7]));
flaggedObjects[arg4] = true;
}
}
}
return loc2;
}
public static function getInstance():mx.core.IEmbeddedFontRegistry
{
if (!instance)
{
instance = new EmbeddedFontRegistry();
}
return instance;
}
internal static function createFontKey(arg1:mx.core.EmbeddedFont):String
{
return arg1.fontName + arg1.fontStyle;
}
internal static function createEmbeddedFont(arg1:String):mx.core.EmbeddedFont
{
var loc1:*=null;
var loc2:*=false;
var loc3:*=false;
var loc4:*;
if ((loc4 = endsWith(arg1, flash.text.FontStyle.REGULAR)) > 0)
{
loc1 = arg1.substring(0, loc4);
return new mx.core.EmbeddedFont(loc1, false, false);
}
if ((loc4 = endsWith(arg1, flash.text.FontStyle.BOLD)) > 0)
{
loc1 = arg1.substring(0, loc4);
return new mx.core.EmbeddedFont(loc1, true, false);
}
if ((loc4 = endsWith(arg1, flash.text.FontStyle.BOLD_ITALIC)) > 0)
{
loc1 = arg1.substring(0, loc4);
return new mx.core.EmbeddedFont(loc1, true, true);
}
if ((loc4 = endsWith(arg1, flash.text.FontStyle.ITALIC)) > 0)
{
loc1 = arg1.substring(0, loc4);
return new mx.core.EmbeddedFont(loc1, false, true);
}
return new mx.core.EmbeddedFont("", false, false);
}
internal static function endsWith(arg1:String, arg2:String):int
{
var loc1:*=arg1.lastIndexOf(arg2);
if (loc1 > 0 && loc1 + arg2.length == arg1.length)
{
return loc1;
}
return -1;
}
public static function registerFonts(arg1:Object, arg2:mx.core.IFlexModuleFactory):void
{
var fonts:Object;
var moduleFactory:mx.core.IFlexModuleFactory;
var fontRegistry:mx.core.IEmbeddedFontRegistry;
var f:Object;
var fontObj:Object;
var fieldIter:String;
var bold:Boolean;
var italic:Boolean;
var loc1:*;
fontRegistry = null;
f = null;
fontObj = null;
fieldIter = null;
bold = false;
italic = false;
fonts = arg1;
moduleFactory = arg2;
try
{
fontRegistry = mx.core.IEmbeddedFontRegistry(mx.core.Singleton.getInstance("mx.core::IEmbeddedFontRegistry"));
}
catch (e:Error)
{
mx.core.Singleton.registerClass("mx.core::IEmbeddedFontRegistry", mx.core.EmbeddedFontRegistry);
fontRegistry = mx.core.IEmbeddedFontRegistry(mx.core.Singleton.getInstance("mx.core::IEmbeddedFontRegistry"));
}
loc2 = 0;
var loc3:*=fonts;
for (f in loc3)
{
fontObj = fonts[f];
var loc4:*=0;
var loc5:*=fontObj;
for (fieldIter in loc5)
{
if (fontObj[fieldIter] == false)
{
continue;
}
if (fieldIter != "regular")
{
if (fieldIter != "boldItalic")
{
if (fieldIter != "bold")
{
if (fieldIter == "italic")
{
bold = false;
italic = true;
}
}
else
{
bold = true;
italic = false;
}
}
else
{
bold = true;
italic = true;
}
}
else
{
bold = false;
italic = false;
}
fontRegistry.registerFont(new mx.core.EmbeddedFont(String(f), bold, italic), moduleFactory);
}
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
fonts = {};
cachedFontsForObjects = new flash.utils.Dictionary(true);
staticTextFormat = new flash.text.TextFormat();
flaggedObjects = new flash.utils.Dictionary(true);
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var _resourceManager:mx.resources.IResourceManager;
internal static var fonts:Object;
internal static var cachedFontsForObjects:flash.utils.Dictionary;
internal static var instance:mx.core.IEmbeddedFontRegistry;
internal static var staticTextFormat:flash.text.TextFormat;
internal static var flaggedObjects:flash.utils.Dictionary;
}
}
// class EventPriority
package mx.core
{
use namespace mx_internal;
public final class EventPriority extends Object
{
public function EventPriority()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const CURSOR_MANAGEMENT:int=200;
public static const BINDING:int=100;
public static const DEFAULT:int=0;
public static const DEFAULT_HANDLER:int=-50;
public static const EFFECT:int=-100;
}
}
// class FlexBitmap
package mx.core
{
import flash.display.*;
import mx.utils.*;
use namespace mx_internal;
public class FlexBitmap extends flash.display.Bitmap
{
public function FlexBitmap(arg1:flash.display.BitmapData=null, arg2:String="auto", arg3:Boolean=false)
{
var bitmapData:flash.display.BitmapData=null;
var pixelSnapping:String="auto";
var smoothing:Boolean=false;
var loc1:*;
bitmapData = arg1;
pixelSnapping = arg2;
smoothing = arg3;
super(bitmapData, pixelSnapping, smoothing);
try
{
name = mx.utils.NameUtil.createUniqueName(this);
}
catch (e:Error)
{
};
return;
}
public override function toString():String
{
return mx.utils.NameUtil.displayObjectToString(this);
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class FlexGlobals
package mx.core
{
public class FlexGlobals extends Object
{
public function FlexGlobals()
{
super();
return;
}
public static var topLevelApplication:Object;
}
}
// class FlexLoader
package mx.core
{
import flash.display.*;
import mx.utils.*;
use namespace mx_internal;
public class FlexLoader extends flash.display.Loader
{
public function FlexLoader()
{
var loc1:*;
super();
try
{
name = mx.utils.NameUtil.createUniqueName(this);
}
catch (e:Error)
{
};
return;
}
public override function toString():String
{
return mx.utils.NameUtil.displayObjectToString(this);
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class FlexShape
package mx.core
{
import flash.display.*;
import mx.utils.*;
use namespace mx_internal;
public class FlexShape extends flash.display.Shape
{
public function FlexShape()
{
var loc1:*;
super();
try
{
name = mx.utils.NameUtil.createUniqueName(this);
}
catch (e:Error)
{
};
return;
}
public override function toString():String
{
return mx.utils.NameUtil.displayObjectToString(this);
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class FlexSprite
package mx.core
{
import flash.display.*;
import mx.utils.*;
use namespace mx_internal;
public class FlexSprite extends flash.display.Sprite
{
public function FlexSprite()
{
var loc1:*;
super();
try
{
name = mx.utils.NameUtil.createUniqueName(this);
}
catch (e:Error)
{
};
return;
}
public override function toString():String
{
return mx.utils.NameUtil.displayObjectToString(this);
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class FlexTextField
package mx.core
{
import flash.text.*;
import mx.utils.*;
use namespace mx_internal;
public class FlexTextField extends flash.text.TextField
{
public function FlexTextField()
{
var loc1:*;
super();
try
{
name = mx.utils.NameUtil.createUniqueName(this);
}
catch (e:Error)
{
};
return;
}
public override function toString():String
{
return mx.utils.NameUtil.displayObjectToString(this);
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class FlexVersion
package mx.core
{
import mx.resources.*;
use namespace mx_internal;
public class FlexVersion extends Object
{
public function FlexVersion()
{
super();
return;
}
public static function get compatibilityErrorFunction():Function
{
return _compatibilityErrorFunction;
}
public static function set compatibilityErrorFunction(arg1:Function):void
{
_compatibilityErrorFunction = arg1;
return;
}
public static function get compatibilityVersion():uint
{
compatibilityVersionRead = true;
return _compatibilityVersion;
}
public static function set compatibilityVersion(arg1:uint):void
{
var loc1:*=null;
if (arg1 == _compatibilityVersion)
{
return;
}
if (compatibilityVersionChanged)
{
if (compatibilityErrorFunction == null)
{
loc1 = mx.resources.ResourceManager.getInstance().getString("core", VERSION_ALREADY_SET);
throw new Error(loc1);
}
compatibilityErrorFunction(arg1, VERSION_ALREADY_SET);
}
if (compatibilityVersionRead)
{
if (compatibilityErrorFunction == null)
{
loc1 = mx.resources.ResourceManager.getInstance().getString("core", VERSION_ALREADY_READ);
throw new Error(loc1);
}
compatibilityErrorFunction(arg1, VERSION_ALREADY_READ);
}
_compatibilityVersion = arg1;
compatibilityVersionChanged = true;
return;
}
public static function get compatibilityVersionString():String
{
var loc1:*=compatibilityVersion >> 24 & 255;
var loc2:*=compatibilityVersion >> 16 & 255;
var loc3:*=compatibilityVersion & 65535;
return loc1.toString() + "." + loc2.toString() + "." + loc3.toString();
}
public static function set compatibilityVersionString(arg1:String):void
{
var loc1:*=arg1.split(".");
var loc2:*=parseInt(loc1[0]);
var loc3:*=parseInt(loc1[1]);
var loc4:*=parseInt(loc1[2]);
compatibilityVersion = (loc2 << 24) + (loc3 << 16) + loc4;
return;
}
mx_internal static function changeCompatibilityVersionString(arg1:String):void
{
var loc1:*=arg1.split(".");
var loc2:*=parseInt(loc1[0]);
var loc3:*=parseInt(loc1[1]);
var loc4:*=parseInt(loc1[2]);
_compatibilityVersion = (loc2 << 24) + (loc3 << 16) + loc4;
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
_compatibilityVersion = CURRENT_VERSION;
compatibilityVersionChanged = false;
compatibilityVersionRead = false;
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const CURRENT_VERSION:uint=67108864;
public static const VERSION_4_0:uint=67108864;
public static const VERSION_3_0:uint=50331648;
public static const VERSION_2_0_1:uint=33554433;
public static const VERSION_2_0:uint=33554432;
public static const VERSION_ALREADY_SET:String="versionAlreadySet";
public static const VERSION_ALREADY_READ:String="versionAlreadyRead";
internal static var _compatibilityErrorFunction:Function;
internal static var _compatibilityVersion:uint=67108864;
internal static var compatibilityVersionChanged:Boolean=false;
internal static var compatibilityVersionRead:Boolean=false;
}
}
// class FontAsset
package mx.core
{
import flash.text.*;
use namespace mx_internal;
public class FontAsset extends flash.text.Font implements mx.core.IFlexAsset
{
public function FontAsset()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
}
}
// class IAssetLayoutFeatures
package mx.core
{
import flash.geom.*;
public interface IAssetLayoutFeatures
{
function set layoutX(arg1:Number):void;
function get layoutX():Number;
function set layoutY(arg1:Number):void;
function get layoutY():Number;
function set layoutZ(arg1:Number):void;
function get layoutZ():Number;
function get layoutWidth():Number;
function set layoutWidth(arg1:Number):void;
function set transformX(arg1:Number):void;
function get transformX():Number;
function set transformY(arg1:Number):void;
function get transformY():Number;
function set transformZ(arg1:Number):void;
function get transformZ():Number;
function set layoutRotationX(arg1:Number):void;
function get layoutRotationX():Number;
function set layoutRotationY(arg1:Number):void;
function get layoutRotationY():Number;
function set layoutRotationZ(arg1:Number):void;
function get layoutRotationZ():Number;
function set layoutScaleX(arg1:Number):void;
function get layoutScaleX():Number;
function set layoutScaleY(arg1:Number):void;
function get layoutScaleY():Number;
function set layoutScaleZ(arg1:Number):void;
function get layoutScaleZ():Number;
function set layoutMatrix(arg1:flash.geom.Matrix):void;
function get layoutMatrix():flash.geom.Matrix;
function set layoutMatrix3D(arg1:flash.geom.Matrix3D):void;
function get layoutMatrix3D():flash.geom.Matrix3D;
function get is3D():Boolean;
function get layoutIs3D():Boolean;
function get mirror():Boolean;
function set mirror(arg1:Boolean):void;
function get stretchX():Number;
function set stretchX(arg1:Number):void;
function get stretchY():Number;
function set stretchY(arg1:Number):void;
function get computedMatrix():flash.geom.Matrix;
function get computedMatrix3D():flash.geom.Matrix3D;
}
}
// class IBorder
package mx.core
{
public interface IBorder
{
function get borderMetrics():mx.core.EdgeMetrics;
}
}
// class IButton
package mx.core
{
public interface IButton extends mx.core.IUIComponent
{
function get emphasized():Boolean;
function set emphasized(arg1:Boolean):void;
function callLater(arg1:Function, arg2:Array=null):void;
}
}
// class IChildList
package mx.core
{
import flash.display.*;
import flash.geom.*;
public interface IChildList
{
function get numChildren():int;
function addChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject;
function addChildAt(arg1:flash.display.DisplayObject, arg2:int):flash.display.DisplayObject;
function removeChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject;
function removeChildAt(arg1:int):flash.display.DisplayObject;
function getChildAt(arg1:int):flash.display.DisplayObject;
function getChildByName(arg1:String):flash.display.DisplayObject;
function getChildIndex(arg1:flash.display.DisplayObject):int;
function setChildIndex(arg1:flash.display.DisplayObject, arg2:int):void;
function getObjectsUnderPoint(arg1:flash.geom.Point):Array;
function contains(arg1:flash.display.DisplayObject):Boolean;
}
}
// class IConstraintClient
package mx.core
{
public interface IConstraintClient
{
function getConstraintValue(arg1:String):*;
function setConstraintValue(arg1:String, arg2:*):void;
}
}
// class IContainer
package mx.core
{
import flash.display.*;
import flash.geom.*;
import flash.media.*;
import flash.text.*;
import mx.managers.*;
public interface IContainer extends mx.core.IUIComponent
{
function get graphics():flash.display.Graphics;
function get buttonMode():Boolean;
function set buttonMode(arg1:Boolean):void;
function startDrag(arg1:Boolean=false, arg2:flash.geom.Rectangle=null):void;
function stopDrag():void;
function get dropTarget():flash.display.DisplayObject;
function get hitArea():flash.display.Sprite;
function set hitArea(arg1:flash.display.Sprite):void;
function get useHandCursor():Boolean;
function set useHandCursor(arg1:Boolean):void;
function get soundTransform():flash.media.SoundTransform;
function set soundTransform(arg1:flash.media.SoundTransform):void;
function addChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject;
function addChildAt(arg1:flash.display.DisplayObject, arg2:int):flash.display.DisplayObject;
function removeChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject;
function removeChildAt(arg1:int):flash.display.DisplayObject;
function getChildIndex(arg1:flash.display.DisplayObject):int;
function setChildIndex(arg1:flash.display.DisplayObject, arg2:int):void;
function getChildAt(arg1:int):flash.display.DisplayObject;
function getChildByName(arg1:String):flash.display.DisplayObject;
function get numChildren():int;
function get textSnapshot():flash.text.TextSnapshot;
function getObjectsUnderPoint(arg1:flash.geom.Point):Array;
function areInaccessibleObjectsUnderPoint(arg1:flash.geom.Point):Boolean;
function get tabChildren():Boolean;
function set tabChildren(arg1:Boolean):void;
function get mouseChildren():Boolean;
function set mouseChildren(arg1:Boolean):void;
function contains(arg1:flash.display.DisplayObject):Boolean;
function swapChildrenAt(arg1:int, arg2:int):void;
function swapChildren(arg1:flash.display.DisplayObject, arg2:flash.display.DisplayObject):void;
function get tabEnabled():Boolean;
function set tabEnabled(arg1:Boolean):void;
function get tabIndex():int;
function set tabIndex(arg1:int):void;
function get focusRect():Object;
function set focusRect(arg1:Object):void;
function get mouseEnabled():Boolean;
function set mouseEnabled(arg1:Boolean):void;
function get doubleClickEnabled():Boolean;
function set doubleClickEnabled(arg1:Boolean):void;
function get defaultButton():mx.core.IFlexDisplayObject;
function set defaultButton(arg1:mx.core.IFlexDisplayObject):void;
function get creatingContentPane():Boolean;
function set creatingContentPane(arg1:Boolean):void;
function get viewMetrics():mx.core.EdgeMetrics;
function get horizontalScrollPosition():Number;
function set horizontalScrollPosition(arg1:Number):void;
function get verticalScrollPosition():Number;
function set verticalScrollPosition(arg1:Number):void;
function get focusManager():mx.managers.IFocusManager;
}
}
// class IDataRenderer
package mx.core
{
public interface IDataRenderer
{
function get data():Object;
function set data(arg1:Object):void;
}
}
// class IDeferredContentOwner
package mx.core
{
public interface IDeferredContentOwner extends mx.core.IUIComponent
{
function get creationPolicy():String;
function set creationPolicy(arg1:String):void;
function createDeferredContent():void;
function get deferredContentCreated():Boolean;
}
}
// class IDeferredInstantiationUIComponent
package mx.core
{
public interface IDeferredInstantiationUIComponent extends mx.core.IUIComponent
{
function set cacheHeuristic(arg1:Boolean):void;
function get cachePolicy():String;
function get descriptor():mx.core.UIComponentDescriptor;
function set descriptor(arg1:mx.core.UIComponentDescriptor):void;
function get id():String;
function set id(arg1:String):void;
function createReferenceOnParentDocument(arg1:mx.core.IFlexDisplayObject):void;
function deleteReferenceOnParentDocument(arg1:mx.core.IFlexDisplayObject):void;
function executeBindings(arg1:Boolean=false):void;
function registerEffects(arg1:Array):void;
}
}
// class IEmbeddedFontRegistry
package mx.core
{
import mx.managers.*;
public interface IEmbeddedFontRegistry
{
function registerFont(arg1:mx.core.EmbeddedFont, arg2:mx.core.IFlexModuleFactory):void;
function deregisterFont(arg1:mx.core.EmbeddedFont, arg2:mx.core.IFlexModuleFactory):void;
function isFontRegistered(arg1:mx.core.EmbeddedFont, arg2:mx.core.IFlexModuleFactory):Boolean;
function getAssociatedModuleFactory(arg1:String, arg2:Boolean, arg3:Boolean, arg4:Object, arg5:mx.core.IFlexModuleFactory, arg6:mx.managers.ISystemManager, arg7:*=undefined):mx.core.IFlexModuleFactory;
function getFonts():Array;
function getFontStyle(arg1:Boolean, arg2:Boolean):String;
}
}
// class IFlexAsset
package mx.core
{
public interface IFlexAsset
{
}
}
// class IFlexDisplayObject
package mx.core
{
import flash.accessibility.*;
import flash.display.*;
import flash.events.*;
import flash.geom.*;
public interface IFlexDisplayObject extends flash.display.IBitmapDrawable, flash.events.IEventDispatcher
{
function get root():flash.display.DisplayObject;
function get stage():flash.display.Stage;
function get name():String;
function set name(arg1:String):void;
function get parent():flash.display.DisplayObjectContainer;
function get mask():flash.display.DisplayObject;
function set mask(arg1:flash.display.DisplayObject):void;
function get visible():Boolean;
function set visible(arg1:Boolean):void;
function get x():Number;
function set x(arg1:Number):void;
function get y():Number;
function set y(arg1:Number):void;
function get scaleX():Number;
function set scaleX(arg1:Number):void;
function get scaleY():Number;
function set scaleY(arg1:Number):void;
function get mouseX():Number;
function get mouseY():Number;
function get rotation():Number;
function set rotation(arg1:Number):void;
function get alpha():Number;
function set alpha(arg1:Number):void;
function get width():Number;
function set width(arg1:Number):void;
function get height():Number;
function set height(arg1:Number):void;
function get cacheAsBitmap():Boolean;
function set cacheAsBitmap(arg1:Boolean):void;
function get opaqueBackground():Object;
function set opaqueBackground(arg1:Object):void;
function get scrollRect():flash.geom.Rectangle;
function set scrollRect(arg1:flash.geom.Rectangle):void;
function get filters():Array;
function set filters(arg1:Array):void;
function get blendMode():String;
function set blendMode(arg1:String):void;
function get transform():flash.geom.Transform;
function set transform(arg1:flash.geom.Transform):void;
function get scale9Grid():flash.geom.Rectangle;
function set scale9Grid(arg1:flash.geom.Rectangle):void;
function globalToLocal(arg1:flash.geom.Point):flash.geom.Point;
function localToGlobal(arg1:flash.geom.Point):flash.geom.Point;
function getBounds(arg1:flash.display.DisplayObject):flash.geom.Rectangle;
function getRect(arg1:flash.display.DisplayObject):flash.geom.Rectangle;
function get loaderInfo():flash.display.LoaderInfo;
function hitTestObject(arg1:flash.display.DisplayObject):Boolean;
function hitTestPoint(arg1:Number, arg2:Number, arg3:Boolean=false):Boolean;
function get accessibilityProperties():flash.accessibility.AccessibilityProperties;
function set accessibilityProperties(arg1:flash.accessibility.AccessibilityProperties):void;
function get measuredHeight():Number;
function get measuredWidth():Number;
function move(arg1:Number, arg2:Number):void;
function setActualSize(arg1:Number, arg2:Number):void;
}
}
// class IFlexModule
package mx.core
{
public interface IFlexModule
{
function set moduleFactory(arg1:mx.core.IFlexModuleFactory):void;
function get moduleFactory():mx.core.IFlexModuleFactory;
}
}
// class IFlexModuleFactory
package mx.core
{
import flash.utils.*;
public interface IFlexModuleFactory
{
function get preloadedRSLs():flash.utils.Dictionary;
function allowDomain(... rest):void;
function allowInsecureDomain(... rest):void;
function callInContext(arg1:Function, arg2:Object, arg3:Array, arg4:Boolean=true):*;
function create(... rest):Object;
function getImplementation(arg1:String):Object;
function info():Object;
function registerImplementation(arg1:String, arg2:Object):void;
}
}
// class IFontContextComponent
package mx.core
{
public interface IFontContextComponent
{
function get fontContext():mx.core.IFlexModuleFactory;
function set fontContext(arg1:mx.core.IFlexModuleFactory):void;
}
}
// class IIMESupport
package mx.core
{
public interface IIMESupport
{
function get enableIME():Boolean;
function get imeMode():String;
function set imeMode(arg1:String):void;
}
}
// class IInvalidating
package mx.core
{
public interface IInvalidating
{
function invalidateProperties():void;
function invalidateSize():void;
function invalidateDisplayList():void;
function validateNow():void;
}
}
// class ILayoutDirectionElement
package mx.core
{
public interface ILayoutDirectionElement
{
function get layoutDirection():String;
function set layoutDirection(arg1:String):void;
function invalidateLayoutDirection():void;
}
}
// class ILayoutElement
package mx.core
{
import flash.events.*;
import flash.geom.*;
public interface ILayoutElement extends flash.events.IEventDispatcher
{
function get left():Object;
function set left(arg1:Object):void;
function get right():Object;
function set right(arg1:Object):void;
function get top():Object;
function set top(arg1:Object):void;
function get bottom():Object;
function set bottom(arg1:Object):void;
function get horizontalCenter():Object;
function set horizontalCenter(arg1:Object):void;
function get verticalCenter():Object;
function set verticalCenter(arg1:Object):void;
function get baseline():Object;
function set baseline(arg1:Object):void;
function get baselinePosition():Number;
function get percentWidth():Number;
function set percentWidth(arg1:Number):void;
function get percentHeight():Number;
function set percentHeight(arg1:Number):void;
function get includeInLayout():Boolean;
function set includeInLayout(arg1:Boolean):void;
function getPreferredBoundsWidth(arg1:Boolean=true):Number;
function getPreferredBoundsHeight(arg1:Boolean=true):Number;
function getMinBoundsWidth(arg1:Boolean=true):Number;
function getMinBoundsHeight(arg1:Boolean=true):Number;
function getMaxBoundsWidth(arg1:Boolean=true):Number;
function getMaxBoundsHeight(arg1:Boolean=true):Number;
function getBoundsXAtSize(arg1:Number, arg2:Number, arg3:Boolean=true):Number;
function getBoundsYAtSize(arg1:Number, arg2:Number, arg3:Boolean=true):Number;
function getLayoutBoundsWidth(arg1:Boolean=true):Number;
function getLayoutBoundsHeight(arg1:Boolean=true):Number;
function getLayoutBoundsX(arg1:Boolean=true):Number;
function getLayoutBoundsY(arg1:Boolean=true):Number;
function setLayoutBoundsPosition(arg1:Number, arg2:Number, arg3:Boolean=true):void;
function setLayoutBoundsSize(arg1:Number, arg2:Number, arg3:Boolean=true):void;
function getLayoutMatrix():flash.geom.Matrix;
function setLayoutMatrix(arg1:flash.geom.Matrix, arg2:Boolean):void;
function get hasLayoutMatrix3D():Boolean;
function getLayoutMatrix3D():flash.geom.Matrix3D;
function setLayoutMatrix3D(arg1:flash.geom.Matrix3D, arg2:Boolean):void;
function transformAround(arg1:flash.geom.Vector3D, arg2:flash.geom.Vector3D=null, arg3:flash.geom.Vector3D=null, arg4:flash.geom.Vector3D=null, arg5:flash.geom.Vector3D=null, arg6:flash.geom.Vector3D=null, arg7:flash.geom.Vector3D=null, arg8:Boolean=true):void;
}
}
// class IMXMLObject
package mx.core
{
public interface IMXMLObject
{
function initialized(arg1:Object, arg2:String):void;
}
}
// class INavigatorContent
package mx.core
{
import mx.managers.*;
public interface INavigatorContent extends mx.core.IDeferredContentOwner, mx.managers.IToolTipManagerClient
{
function get label():String;
function get icon():Class;
}
}
// class IProgrammaticSkin
package mx.core
{
public interface IProgrammaticSkin
{
function validateNow():void;
function validateDisplayList():void;
}
}
// class IPropertyChangeNotifier
package mx.core
{
import flash.events.*;
public interface IPropertyChangeNotifier extends flash.events.IEventDispatcher, mx.core.IUID
{
}
}
// class IRawChildrenContainer
package mx.core
{
public interface IRawChildrenContainer
{
function get rawChildren():mx.core.IChildList;
}
}
// class IRectangularBorder
package mx.core
{
import flash.geom.*;
public interface IRectangularBorder extends mx.core.IBorder
{
function get backgroundImageBounds():flash.geom.Rectangle;
function set backgroundImageBounds(arg1:flash.geom.Rectangle):void;
function get hasBackgroundImage():Boolean;
function layoutBackgroundImage():void;
}
}
// class IRepeater
package mx.core
{
public interface IRepeater
{
function get container():mx.core.IContainer;
function get count():int;
function set count(arg1:int):void;
function get currentIndex():int;
function get currentItem():Object;
function get dataProvider():Object;
function set dataProvider(arg1:Object):void;
function get recycleChildren():Boolean;
function set recycleChildren(arg1:Boolean):void;
function get startingIndex():int;
function set startingIndex(arg1:int):void;
function initializeRepeater(arg1:mx.core.IContainer, arg2:Boolean):void;
function executeChildBindings():void;
}
}
// class IRepeaterClient
package mx.core
{
public interface IRepeaterClient
{
function get instanceIndices():Array;
function set instanceIndices(arg1:Array):void;
function get isDocument():Boolean;
function get repeaterIndices():Array;
function set repeaterIndices(arg1:Array):void;
function get repeaters():Array;
function set repeaters(arg1:Array):void;
function initializeRepeaterArrays(arg1:mx.core.IRepeaterClient):void;
}
}
// class ISWFBridgeGroup
package mx.core
{
import flash.events.*;
public interface ISWFBridgeGroup extends flash.events.IEventDispatcher
{
function get parentBridge():flash.events.IEventDispatcher;
function set parentBridge(arg1:flash.events.IEventDispatcher):void;
function addChildBridge(arg1:flash.events.IEventDispatcher, arg2:mx.core.ISWFBridgeProvider):void;
function removeChildBridge(arg1:flash.events.IEventDispatcher):void;
function getChildBridgeProvider(arg1:flash.events.IEventDispatcher):mx.core.ISWFBridgeProvider;
function getChildBridges():Array;
function containsBridge(arg1:flash.events.IEventDispatcher):Boolean;
}
}
// class ISWFBridgeProvider
package mx.core
{
import flash.events.*;
public interface ISWFBridgeProvider
{
function get swfBridge():flash.events.IEventDispatcher;
function get childAllowsParent():Boolean;
function get parentAllowsChild():Boolean;
}
}
// class ISWFLoader
package mx.core
{
import flash.geom.*;
public interface ISWFLoader extends mx.core.ISWFBridgeProvider
{
function get loadForCompatibility():Boolean;
function set loadForCompatibility(arg1:Boolean):void;
function getVisibleApplicationRect(arg1:Boolean=false):flash.geom.Rectangle;
}
}
// class IStateClient
package mx.core
{
public interface IStateClient
{
function get currentState():String;
function set currentState(arg1:String):void;
}
}
// class IStateClient2
package mx.core
{
import flash.events.*;
public interface IStateClient2 extends flash.events.IEventDispatcher, mx.core.IStateClient
{
function get states():Array;
function set states(arg1:Array):void;
function get transitions():Array;
function set transitions(arg1:Array):void;
function hasState(arg1:String):Boolean;
}
}
// class ISystemCursorClient
package mx.core
{
public interface ISystemCursorClient
{
function get showSystemCursor():Boolean;
}
}
// class ITextFieldFactory
package mx.core
{
import flash.text.*;
public interface ITextFieldFactory
{
function createTextField(arg1:mx.core.IFlexModuleFactory):flash.text.TextField;
function createFTETextField(arg1:mx.core.IFlexModuleFactory):Object;
}
}
// class IToggleButton
package mx.core
{
public interface IToggleButton
{
}
}
// class IToolTip
package mx.core
{
import flash.geom.*;
public interface IToolTip extends mx.core.IUIComponent
{
function get screen():flash.geom.Rectangle;
function get text():String;
function set text(arg1:String):void;
}
}
// class IUIComponent
package mx.core
{
import flash.display.*;
import mx.managers.*;
public interface IUIComponent extends mx.core.IFlexDisplayObject
{
function get baselinePosition():Number;
function get document():Object;
function set document(arg1:Object):void;
function get enabled():Boolean;
function set enabled(arg1:Boolean):void;
function get explicitHeight():Number;
function set explicitHeight(arg1:Number):void;
function get explicitMaxHeight():Number;
function get explicitMaxWidth():Number;
function get explicitMinHeight():Number;
function get explicitMinWidth():Number;
function get explicitWidth():Number;
function set explicitWidth(arg1:Number):void;
function get focusPane():flash.display.Sprite;
function set focusPane(arg1:flash.display.Sprite):void;
function get includeInLayout():Boolean;
function set includeInLayout(arg1:Boolean):void;
function get isPopUp():Boolean;
function set isPopUp(arg1:Boolean):void;
function get maxHeight():Number;
function get maxWidth():Number;
function get measuredMinHeight():Number;
function set measuredMinHeight(arg1:Number):void;
function get measuredMinWidth():Number;
function set measuredMinWidth(arg1:Number):void;
function get minHeight():Number;
function get minWidth():Number;
function get owner():flash.display.DisplayObjectContainer;
function set owner(arg1:flash.display.DisplayObjectContainer):void;
function get percentHeight():Number;
function set percentHeight(arg1:Number):void;
function get percentWidth():Number;
function set percentWidth(arg1:Number):void;
function get systemManager():mx.managers.ISystemManager;
function set systemManager(arg1:mx.managers.ISystemManager):void;
function get tweeningProperties():Array;
function set tweeningProperties(arg1:Array):void;
function initialize():void;
function parentChanged(arg1:flash.display.DisplayObjectContainer):void;
function getExplicitOrMeasuredWidth():Number;
function getExplicitOrMeasuredHeight():Number;
function setVisible(arg1:Boolean, arg2:Boolean=false):void;
function owns(arg1:flash.display.DisplayObject):Boolean;
}
}
// class IUID
package mx.core
{
public interface IUID
{
function get uid():String;
function set uid(arg1:String):void;
}
}
// class IUITextField
package mx.core
{
import flash.display.*;
import flash.geom.*;
import flash.text.*;
import mx.managers.*;
import mx.styles.*;
public interface IUITextField extends mx.core.IIMESupport, mx.core.IFlexModule, mx.core.IInvalidating, mx.styles.ISimpleStyleClient, mx.managers.IToolTipManagerClient, mx.core.IUIComponent
{
function get alwaysShowSelection():Boolean;
function set alwaysShowSelection(arg1:Boolean):void;
function get antiAliasType():String;
function set antiAliasType(arg1:String):void;
function get autoSize():String;
function set autoSize(arg1:String):void;
function get background():Boolean;
function set background(arg1:Boolean):void;
function get backgroundColor():uint;
function set backgroundColor(arg1:uint):void;
function get border():Boolean;
function set border(arg1:Boolean):void;
function get borderColor():uint;
function set borderColor(arg1:uint):void;
function get bottomScrollV():int;
function get caretIndex():int;
function get condenseWhite():Boolean;
function set condenseWhite(arg1:Boolean):void;
function get defaultTextFormat():flash.text.TextFormat;
function set defaultTextFormat(arg1:flash.text.TextFormat):void;
function get embedFonts():Boolean;
function set embedFonts(arg1:Boolean):void;
function get gridFitType():String;
function set gridFitType(arg1:String):void;
function get htmlText():String;
function set htmlText(arg1:String):void;
function get length():int;
function get maxChars():int;
function set maxChars(arg1:int):void;
function get maxScrollH():int;
function get maxScrollV():int;
function get mouseWheelEnabled():Boolean;
function set mouseWheelEnabled(arg1:Boolean):void;
function get multiline():Boolean;
function set multiline(arg1:Boolean):void;
function get numLines():int;
function get displayAsPassword():Boolean;
function set displayAsPassword(arg1:Boolean):void;
function get restrict():String;
function set restrict(arg1:String):void;
function get scrollH():int;
function set scrollH(arg1:int):void;
function get scrollV():int;
function set scrollV(arg1:int):void;
function get selectable():Boolean;
function set selectable(arg1:Boolean):void;
function get selectionBeginIndex():int;
function get selectionEndIndex():int;
function get sharpness():Number;
function set sharpness(arg1:Number):void;
function get styleSheet():flash.text.StyleSheet;
function set styleSheet(arg1:flash.text.StyleSheet):void;
function get text():String;
function set text(arg1:String):void;
function get textColor():uint;
function set textColor(arg1:uint):void;
function get textHeight():Number;
function get textWidth():Number;
function get thickness():Number;
function set thickness(arg1:Number):void;
function get type():String;
function set type(arg1:String):void;
function get wordWrap():Boolean;
function set wordWrap(arg1:Boolean):void;
function appendText(arg1:String):void;
function getCharBoundaries(arg1:int):flash.geom.Rectangle;
function getCharIndexAtPoint(arg1:Number, arg2:Number):int;
function getFirstCharInParagraph(arg1:int):int;
function getLineIndexAtPoint(arg1:Number, arg2:Number):int;
function getLineIndexOfChar(arg1:int):int;
function getLineLength(arg1:int):int;
function getLineMetrics(arg1:int):flash.text.TextLineMetrics;
function getLineOffset(arg1:int):int;
function getLineText(arg1:int):String;
function getParagraphLength(arg1:int):int;
function getTextFormat(arg1:int=-1, arg2:int=-1):flash.text.TextFormat;
function replaceSelectedText(arg1:String):void;
function replaceText(arg1:int, arg2:int, arg3:String):void;
function setSelection(arg1:int, arg2:int):void;
function setTextFormat(arg1:flash.text.TextFormat, arg2:int=-1, arg3:int=-1):void;
function getImageReference(arg1:String):flash.display.DisplayObject;
function set useRichTextClipboard(arg1:Boolean):void;
function get useRichTextClipboard():Boolean;
function get tabEnabled():Boolean;
function set tabEnabled(arg1:Boolean):void;
function get tabIndex():int;
function set tabIndex(arg1:int):void;
function get focusRect():Object;
function set focusRect(arg1:Object):void;
function get mouseEnabled():Boolean;
function set mouseEnabled(arg1:Boolean):void;
function get doubleClickEnabled():Boolean;
function set doubleClickEnabled(arg1:Boolean):void;
function get ignorePadding():Boolean;
function set ignorePadding(arg1:Boolean):void;
function get inheritingStyles():Object;
function set inheritingStyles(arg1:Object):void;
function get nestLevel():int;
function set nestLevel(arg1:int):void;
function get nonInheritingStyles():Object;
function set nonInheritingStyles(arg1:Object):void;
function get nonZeroTextHeight():Number;
function getStyle(arg1:String):*;
function getUITextFormat():mx.core.UITextFormat;
function setColor(arg1:uint):void;
function setFocus():void;
function truncateToFit(arg1:String=null):Boolean;
}
}
// class IVisualElement
package mx.core
{
import flash.display.*;
import mx.geom.*;
public interface IVisualElement extends mx.core.ILayoutElement, mx.core.ILayoutDirectionElement
{
function get owner():flash.display.DisplayObjectContainer;
function set owner(arg1:flash.display.DisplayObjectContainer):void;
function get parent():flash.display.DisplayObjectContainer;
function get depth():Number;
function set depth(arg1:Number):void;
function get visible():Boolean;
function set visible(arg1:Boolean):void;
function get alpha():Number;
function set alpha(arg1:Number):void;
function get width():Number;
function set width(arg1:Number):void;
function get height():Number;
function set height(arg1:Number):void;
function get x():Number;
function set x(arg1:Number):void;
function get y():Number;
function set y(arg1:Number):void;
function get designLayer():mx.core.DesignLayer;
function set designLayer(arg1:mx.core.DesignLayer):void;
function get postLayoutTransformOffsets():mx.geom.TransformOffsets;
function set postLayoutTransformOffsets(arg1:mx.geom.TransformOffsets):void;
function get is3D():Boolean;
}
}
// class IVisualElementContainer
package mx.core
{
public interface IVisualElementContainer
{
function get numElements():int;
function getElementAt(arg1:int):mx.core.IVisualElement;
function addElement(arg1:mx.core.IVisualElement):mx.core.IVisualElement;
function addElementAt(arg1:mx.core.IVisualElement, arg2:int):mx.core.IVisualElement;
function removeElement(arg1:mx.core.IVisualElement):mx.core.IVisualElement;
function removeElementAt(arg1:int):mx.core.IVisualElement;
function removeAllElements():void;
function getElementIndex(arg1:mx.core.IVisualElement):int;
function setElementIndex(arg1:mx.core.IVisualElement, arg2:int):void;
function swapElements(arg1:mx.core.IVisualElement, arg2:mx.core.IVisualElement):void;
function swapElementsAt(arg1:int, arg2:int):void;
}
}
// class LayoutContainer
package mx.core
{
import flash.events.*;
import mx.containers.*;
import mx.containers.utilityClasses.*;
use namespace mx_internal;
public class LayoutContainer extends mx.core.Container implements mx.containers.utilityClasses.IConstraintLayout
{
public function LayoutContainer()
{
this.layoutObject = new mx.containers.utilityClasses.BoxLayout();
this.canvasLayoutClass = mx.containers.utilityClasses.CanvasLayout;
this.boxLayoutClass = mx.containers.utilityClasses.BoxLayout;
this.creationQueue = [];
this._constraintColumns = [];
this._constraintRows = [];
super();
this.layoutObject.target = this;
return;
}
public function get constraintColumns():Array
{
return this._constraintColumns;
}
public function set constraintColumns(arg1:Array):void
{
var loc1:*=0;
var loc2:*=0;
if (arg1 != this._constraintColumns)
{
loc1 = arg1.length;
loc2 = 0;
while (loc2 < loc1)
{
mx.containers.utilityClasses.ConstraintColumn(arg1[loc2]).container = this;
++loc2;
}
this._constraintColumns = arg1;
invalidateSize();
invalidateDisplayList();
}
return;
}
public function get constraintRows():Array
{
return this._constraintRows;
}
public function set constraintRows(arg1:Array):void
{
var loc1:*=0;
var loc2:*=0;
if (arg1 != this._constraintRows)
{
loc1 = arg1.length;
loc2 = 0;
while (loc2 < loc1)
{
mx.containers.utilityClasses.ConstraintRow(arg1[loc2]).container = this;
++loc2;
}
this._constraintRows = arg1;
invalidateSize();
invalidateDisplayList();
}
return;
}
public function get layout():String
{
return this._layout;
}
public function set layout(arg1:String):void
{
if (this._layout != arg1)
{
this._layout = arg1;
if (this.layoutObject)
{
this.layoutObject.target = null;
}
if (this._layout != mx.core.ContainerLayout.ABSOLUTE)
{
this.layoutObject = new this.boxLayoutClass();
if (this._layout != mx.core.ContainerLayout.VERTICAL)
{
mx.containers.utilityClasses.BoxLayout(this.layoutObject).direction = mx.containers.BoxDirection.HORIZONTAL;
}
else
{
mx.containers.utilityClasses.BoxLayout(this.layoutObject).direction = mx.containers.BoxDirection.VERTICAL;
}
}
else
{
this.layoutObject = new this.canvasLayoutClass();
}
if (this.layoutObject)
{
this.layoutObject.target = this;
}
invalidateSize();
invalidateDisplayList();
dispatchEvent(new flash.events.Event("layoutChanged"));
}
return;
}
mx_internal override function get usePadding():Boolean
{
return !(this.layout == mx.core.ContainerLayout.ABSOLUTE);
}
protected override function measure():void
{
super.measure();
this.layoutObject.measure();
return;
}
protected override function updateDisplayList(arg1:Number, arg2:Number):void
{
super.updateDisplayList(arg1, arg2);
this.layoutObject.updateDisplayList(arg1, arg2);
createBorder();
return;
}
protected override function layoutChrome(arg1:Number, arg2:Number):void
{
super.layoutChrome(arg1, arg2);
if (!mx_internal::doingLayout)
{
createBorder();
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
mx_internal::useProgressiveLayout = false;
}
mx_internal static const VERSION:String="4.1.0.16076";
protected var layoutObject:mx.containers.utilityClasses.Layout;
protected var canvasLayoutClass:Class;
protected var boxLayoutClass:Class;
internal var resizeHandlerAdded:Boolean=false;
internal var preloadObj:Object;
internal var creationQueue:Array;
internal var processingCreationQueue:Boolean=false;
internal var _constraintColumns:Array;
internal var _constraintRows:Array;
internal var _layout:String="vertical";
mx_internal static var useProgressiveLayout:Boolean=false;
}
}
// class LayoutDirection
package mx.core
{
use namespace mx_internal;
public final class LayoutDirection extends Object
{
public function LayoutDirection()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const LTR:String="ltr";
public static const RTL:String="rtl";
}
}
// class LayoutElementUIComponentUtils
package mx.core
{
import flash.geom.*;
import mx.utils.*;
use namespace mx_internal;
public class LayoutElementUIComponentUtils extends Object
{
public function LayoutElementUIComponentUtils()
{
super();
return;
}
internal static function getPreferredUBoundsWidth(arg1:mx.core.IUIComponent):Number
{
var loc1:*=arg1.getExplicitOrMeasuredWidth();
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = arg1.scaleX != 0 ? loc1 / arg1.scaleX : 0;
}
return loc1;
}
internal static function getPreferredUBoundsHeight(arg1:mx.core.IUIComponent):Number
{
var loc1:*=arg1.getExplicitOrMeasuredHeight();
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = arg1.scaleY != 0 ? loc1 / arg1.scaleY : 0;
}
return loc1;
}
internal static function getMinUBoundsWidth(arg1:mx.core.IUIComponent):Number
{
var loc1:*=NaN;
if (isNaN(arg1.explicitMinWidth))
{
loc1 = isNaN(arg1.measuredMinWidth) ? 0 : arg1.measuredMinWidth;
if (!isNaN(arg1.explicitMaxWidth))
{
loc1 = Math.min(loc1, arg1.explicitMaxWidth);
}
}
else
{
loc1 = arg1.explicitMinWidth;
}
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = arg1.scaleX != 0 ? loc1 / arg1.scaleX : 0;
}
return loc1;
}
internal static function getMinUBoundsHeight(arg1:mx.core.IUIComponent):Number
{
var loc1:*=NaN;
if (isNaN(arg1.explicitMinHeight))
{
loc1 = isNaN(arg1.measuredMinHeight) ? 0 : arg1.measuredMinHeight;
if (!isNaN(arg1.explicitMaxHeight))
{
loc1 = Math.min(loc1, arg1.explicitMaxHeight);
}
}
else
{
loc1 = arg1.explicitMinHeight;
}
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = arg1.scaleY != 0 ? loc1 / arg1.scaleY : 0;
}
return loc1;
}
internal static function getMaxUBoundsWidth(arg1:mx.core.IUIComponent):Number
{
var loc1:*=NaN;
if (isNaN(arg1.explicitMaxWidth))
{
loc1 = DEFAULT_MAX_WIDTH;
}
else
{
loc1 = arg1.explicitMaxWidth;
}
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = arg1.scaleX != 0 ? loc1 / arg1.scaleX : 0;
}
return loc1;
}
internal static function getMaxUBoundsHeight(arg1:mx.core.IUIComponent):Number
{
var loc1:*=NaN;
if (isNaN(arg1.explicitMaxHeight))
{
loc1 = DEFAULT_MAX_HEIGHT;
}
else
{
loc1 = arg1.explicitMaxHeight;
}
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = arg1.scaleY != 0 ? loc1 / arg1.scaleY : 0;
}
return loc1;
}
public static function getPreferredBoundsWidth(arg1:mx.core.IUIComponent, arg2:flash.geom.Matrix):Number
{
var loc1:*=getPreferredUBoundsWidth(arg1);
if (arg2)
{
loc1 = mx.utils.MatrixUtil.transformSize(loc1, getPreferredUBoundsHeight(arg1), arg2).x;
}
return loc1;
}
public static function getPreferredBoundsHeight(arg1:mx.core.IUIComponent, arg2:flash.geom.Matrix):Number
{
var loc1:*=getPreferredUBoundsHeight(arg1);
if (arg2)
{
loc1 = mx.utils.MatrixUtil.transformSize(getPreferredUBoundsWidth(arg1), loc1, arg2).y;
}
return loc1;
}
public static function getMinBoundsWidth(arg1:mx.core.IUIComponent, arg2:flash.geom.Matrix):Number
{
var loc1:*=getMinUBoundsWidth(arg1);
if (arg2)
{
loc1 = mx.utils.MatrixUtil.transformSize(loc1, getMinUBoundsHeight(arg1), arg2).x;
}
return loc1;
}
public static function getMinBoundsHeight(arg1:mx.core.IUIComponent, arg2:flash.geom.Matrix):Number
{
var loc1:*=getMinUBoundsHeight(arg1);
if (arg2)
{
loc1 = mx.utils.MatrixUtil.transformSize(getMinUBoundsWidth(arg1), loc1, arg2).y;
}
return loc1;
}
public static function getMaxBoundsWidth(arg1:mx.core.IUIComponent, arg2:flash.geom.Matrix):Number
{
var loc1:*=getMaxUBoundsWidth(arg1);
if (arg2)
{
loc1 = mx.utils.MatrixUtil.transformSize(loc1, getMaxUBoundsHeight(arg1), arg2).x;
}
return loc1;
}
public static function getMaxBoundsHeight(arg1:mx.core.IUIComponent, arg2:flash.geom.Matrix):Number
{
var loc1:*=getMaxUBoundsHeight(arg1);
if (arg2)
{
loc1 = mx.utils.MatrixUtil.transformSize(getMaxUBoundsWidth(arg1), loc1, arg2).y;
}
return loc1;
}
public static function getBoundsXAtSize(arg1:mx.core.IUIComponent, arg2:Number, arg3:Number, arg4:flash.geom.Matrix):Number
{
if (!arg4)
{
return arg1.x;
}
var loc1:*;
if (!(loc1 = mx.utils.MatrixUtil.fitBounds(arg2, arg3, arg4, getPreferredUBoundsWidth(arg1), getPreferredUBoundsHeight(arg1), getMinUBoundsWidth(arg1), getMinUBoundsHeight(arg1), getMaxUBoundsWidth(arg1), getMaxUBoundsHeight(arg1))))
{
loc1 = new flash.geom.Point(getMinUBoundsWidth(arg1), getMinUBoundsHeight(arg1));
}
var loc2:*=new flash.geom.Point();
mx.utils.MatrixUtil.transformBounds(loc1.x, loc1.y, arg4, loc2);
return loc2.x;
}
public static function getBoundsYAtSize(arg1:mx.core.IUIComponent, arg2:Number, arg3:Number, arg4:flash.geom.Matrix):Number
{
if (!arg4)
{
return arg1.y;
}
var loc1:*;
if (!(loc1 = mx.utils.MatrixUtil.fitBounds(arg2, arg3, arg4, getPreferredUBoundsWidth(arg1), getPreferredUBoundsHeight(arg1), getMinUBoundsWidth(arg1), getMinUBoundsHeight(arg1), getMaxUBoundsWidth(arg1), getMaxUBoundsHeight(arg1))))
{
loc1 = new flash.geom.Point(getMinUBoundsWidth(arg1), getMinUBoundsHeight(arg1));
}
var loc2:*=new flash.geom.Point();
mx.utils.MatrixUtil.transformBounds(loc1.x, loc1.y, arg4, loc2);
return loc2.y;
}
public static function getLayoutBoundsWidth(arg1:mx.core.IUIComponent, arg2:flash.geom.Matrix):Number
{
var loc2:*=NaN;
var loc1:*=arg1.width;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = arg1.scaleX != 0 ? loc1 / arg1.scaleX : 0;
}
if (arg2)
{
loc2 = arg1.height;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc2 = arg1.scaleY != 0 ? loc2 / arg1.scaleY : 0;
}
loc1 = mx.utils.MatrixUtil.transformBounds(loc1, loc2, arg2, new flash.geom.Point()).x;
}
return loc1;
}
public static function getLayoutBoundsHeight(arg1:mx.core.IUIComponent, arg2:flash.geom.Matrix):Number
{
var loc2:*=NaN;
var loc1:*=arg1.height;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = arg1.scaleY != 0 ? loc1 / arg1.scaleY : 0;
}
if (arg2)
{
loc2 = arg1.width;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc2 = arg1.scaleX != 0 ? loc2 / arg1.scaleX : 0;
}
loc1 = mx.utils.MatrixUtil.transformBounds(loc2, loc1, arg2, new flash.geom.Point()).y;
}
return loc1;
}
public static function getLayoutBoundsX(arg1:mx.core.IUIComponent, arg2:flash.geom.Matrix):Number
{
if (arg2 == null)
{
return arg1.x;
}
var loc1:*=arg1.width;
var loc2:*=arg1.height;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = arg1.scaleX != 0 ? loc1 / arg1.scaleX : 0;
loc2 = arg1.scaleY != 0 ? loc2 / arg1.scaleY : 0;
}
var loc3:*=new flash.geom.Point();
mx.utils.MatrixUtil.transformBounds(loc1, loc2, arg2, loc3);
return loc3.x;
}
public static function getLayoutBoundsY(arg1:mx.core.IUIComponent, arg2:flash.geom.Matrix):Number
{
if (arg2 == null)
{
return arg1.y;
}
var loc1:*=arg1.width;
var loc2:*=arg1.height;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = arg1.scaleX != 0 ? loc1 / arg1.scaleX : 0;
loc2 = arg1.scaleY != 0 ? loc2 / arg1.scaleY : 0;
}
var loc3:*=new flash.geom.Point();
mx.utils.MatrixUtil.transformBounds(loc1, loc2, arg2, loc3);
return loc3.y;
}
public static function setLayoutBoundsPosition(arg1:mx.core.IUIComponent, arg2:Number, arg3:Number, arg4:flash.geom.Matrix):void
{
if (arg4)
{
arg2 = arg2 - getLayoutBoundsX(arg1, arg4) + arg1.x;
arg3 = arg3 - getLayoutBoundsY(arg1, arg4) + arg1.y;
}
arg1.move(arg2, arg3);
return;
}
public static function setLayoutBoundsSize(arg1:mx.core.IUIComponent, arg2:Number, arg3:Number, arg4:flash.geom.Matrix):void
{
if (!arg4)
{
if (isNaN(arg2))
{
arg2 = getPreferredUBoundsWidth(arg1);
}
if (isNaN(arg3))
{
arg3 = getPreferredUBoundsHeight(arg1);
}
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
arg2 = arg2 * arg1.scaleX;
arg3 = arg3 * arg1.scaleY;
}
arg1.setActualSize(arg2, arg3);
return;
}
var loc1:*;
if (!(loc1 = mx.utils.MatrixUtil.fitBounds(arg2, arg3, arg4, getPreferredUBoundsWidth(arg1), getPreferredUBoundsHeight(arg1), getMinUBoundsWidth(arg1), getMinUBoundsHeight(arg1), getMaxUBoundsWidth(arg1), getMaxUBoundsHeight(arg1))))
{
loc1 = new flash.geom.Point(getMinUBoundsWidth(arg1), getMinUBoundsHeight(arg1));
}
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
arg1.setActualSize(loc1.x * arg1.scaleX, loc1.y * arg1.scaleY);
}
else
{
arg1.setActualSize(loc1.x, loc1.y);
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal static const DEFAULT_MAX_WIDTH:Number=10000;
internal static const DEFAULT_MAX_HEIGHT:Number=10000;
}
}
// class RSLItem
package mx.core
{
import flash.display.*;
import flash.events.*;
import flash.net.*;
import flash.system.*;
import mx.events.*;
import mx.utils.*;
use namespace mx_internal;
public class RSLItem extends Object
{
public function RSLItem(arg1:String, arg2:String=null, arg3:mx.core.IFlexModuleFactory=null)
{
super();
this.url = arg1;
this.rootURL = arg2;
this.moduleFactory = arg3;
return;
}
public function load(arg1:Function, arg2:Function, arg3:Function, arg4:Function, arg5:Function):void
{
this.chainedProgressHandler = arg1;
this.chainedCompleteHandler = arg2;
this.chainedIOErrorHandler = arg3;
this.chainedSecurityErrorHandler = arg4;
this.chainedRSLErrorHandler = arg5;
var loc1:*=new flash.display.Loader();
var loc2:*=new flash.system.LoaderContext();
this.urlRequest = new flash.net.URLRequest(mx.utils.LoaderUtil.createAbsoluteURL(this.rootURL, this.url));
loc1.contentLoaderInfo.addEventListener(flash.events.ProgressEvent.PROGRESS, this.itemProgressHandler);
loc1.contentLoaderInfo.addEventListener(flash.events.Event.COMPLETE, this.itemCompleteHandler);
loc1.contentLoaderInfo.addEventListener(flash.events.IOErrorEvent.IO_ERROR, this.itemErrorHandler);
loc1.contentLoaderInfo.addEventListener(flash.events.SecurityErrorEvent.SECURITY_ERROR, this.itemErrorHandler);
if (this.moduleFactory == null)
{
loc2.applicationDomain = flash.system.ApplicationDomain.currentDomain;
}
else
{
loc2.applicationDomain = this.moduleFactory.info()["currentDomain"];
}
loc1.load(this.urlRequest, loc2);
return;
}
public function itemProgressHandler(arg1:flash.events.ProgressEvent):void
{
this.loaded = arg1.bytesLoaded;
this.total = arg1.bytesTotal;
if (this.chainedProgressHandler != null)
{
this.chainedProgressHandler(arg1);
}
return;
}
public function itemCompleteHandler(arg1:flash.events.Event):void
{
this.completed = true;
if (this.chainedCompleteHandler != null)
{
this.chainedCompleteHandler(arg1);
}
return;
}
public function itemErrorHandler(arg1:flash.events.ErrorEvent):void
{
this.errorText = decodeURI(arg1.text);
this.completed = true;
this.loaded = 0;
this.total = 0;
trace(this.errorText);
if (arg1.type == flash.events.IOErrorEvent.IO_ERROR && !(this.chainedIOErrorHandler == null))
{
this.chainedIOErrorHandler(arg1);
}
else if (arg1.type == flash.events.SecurityErrorEvent.SECURITY_ERROR && !(this.chainedSecurityErrorHandler == null))
{
this.chainedSecurityErrorHandler(arg1);
}
else if (arg1.type == mx.events.RSLEvent.RSL_ERROR && !(this.chainedRSLErrorHandler == null))
{
this.chainedRSLErrorHandler(arg1);
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public var urlRequest:flash.net.URLRequest;
public var total:uint=0;
public var loaded:uint=0;
public var rootURL:String;
protected var chainedProgressHandler:Function;
protected var chainedCompleteHandler:Function;
protected var chainedIOErrorHandler:Function;
protected var chainedSecurityErrorHandler:Function;
protected var chainedRSLErrorHandler:Function;
internal var completed:Boolean=false;
internal var errorText:String;
protected var moduleFactory:mx.core.IFlexModuleFactory;
protected var url:String;
}
}
// class RSLListLoader
package mx.core
{
import flash.events.*;
use namespace mx_internal;
public class RSLListLoader extends Object
{
public function RSLListLoader(arg1:Array)
{
this.rslList = [];
super();
this.rslList = arg1;
return;
}
public function load(arg1:Function, arg2:Function, arg3:Function, arg4:Function, arg5:Function):void
{
this.chainedProgressHandler = arg1;
this.chainedCompleteHandler = arg2;
this.chainedIOErrorHandler = arg3;
this.chainedSecurityErrorHandler = arg4;
this.chainedRSLErrorHandler = arg5;
this.currentIndex = -1;
this.loadNext();
return;
}
internal function loadNext():void
{
if (!this.isDone())
{
var loc1:*;
var loc2:*=((loc1 = this).currentIndex + 1);
loc1.currentIndex = loc2;
if (this.currentIndex < this.rslList.length)
{
this.rslList[this.currentIndex].load(this.chainedProgressHandler, this.listCompleteHandler, this.listIOErrorHandler, this.listSecurityErrorHandler, this.chainedRSLErrorHandler);
}
}
return;
}
public function getItem(arg1:int):mx.core.RSLItem
{
if (arg1 < 0 || arg1 >= this.rslList.length)
{
return null;
}
return this.rslList[arg1];
}
public function getIndex():int
{
return this.currentIndex;
}
public function getItemCount():int
{
return this.rslList.length;
}
public function isDone():Boolean
{
return this.currentIndex >= this.rslList.length;
}
internal function listCompleteHandler(arg1:flash.events.Event):void
{
if (this.chainedCompleteHandler != null)
{
this.chainedCompleteHandler(arg1);
}
this.loadNext();
return;
}
internal function listIOErrorHandler(arg1:flash.events.Event):void
{
if (this.chainedIOErrorHandler != null)
{
this.chainedIOErrorHandler(arg1);
}
return;
}
internal function listSecurityErrorHandler(arg1:flash.events.Event):void
{
if (this.chainedSecurityErrorHandler != null)
{
this.chainedSecurityErrorHandler(arg1);
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var currentIndex:int=0;
internal var rslList:Array;
internal var chainedProgressHandler:Function;
internal var chainedCompleteHandler:Function;
internal var chainedIOErrorHandler:Function;
internal var chainedSecurityErrorHandler:Function;
internal var chainedRSLErrorHandler:Function;
}
}
// class ResourceModuleRSLItem
package mx.core
{
import flash.events.*;
import flash.system.*;
import mx.events.*;
import mx.resources.*;
use namespace mx_internal;
public class ResourceModuleRSLItem extends mx.core.RSLItem
{
public function ResourceModuleRSLItem(arg1:String, arg2:flash.system.ApplicationDomain)
{
super(arg1);
this.appDomain = arg2;
return;
}
public override function load(arg1:Function, arg2:Function, arg3:Function, arg4:Function, arg5:Function):void
{
var loc2:*=null;
chainedProgressHandler = arg1;
chainedCompleteHandler = arg2;
chainedIOErrorHandler = arg3;
chainedSecurityErrorHandler = arg4;
chainedRSLErrorHandler = arg5;
if (!resourceManager)
{
if (this.appDomain.hasDefinition("mx.resources::ResourceManager"))
{
loc2 = Class(this.appDomain.getDefinition("mx.resources::ResourceManager"));
var loc3:*;
resourceManager = mx.resources.IResourceManager((loc3 = loc2)["getInstance"]());
}
else
{
return;
}
}
var loc1:*;
(loc1 = resourceManager.loadResourceModule(url)).addEventListener(mx.events.ResourceEvent.PROGRESS, itemProgressHandler);
loc1.addEventListener(mx.events.ResourceEvent.COMPLETE, itemCompleteHandler);
loc1.addEventListener(mx.events.ResourceEvent.ERROR, this.resourceErrorHandler);
return;
}
internal function resourceErrorHandler(arg1:mx.events.ResourceEvent):void
{
var loc1:*=new flash.events.IOErrorEvent(flash.events.IOErrorEvent.IO_ERROR);
loc1.text = arg1.errorText;
super.itemErrorHandler(loc1);
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var appDomain:flash.system.ApplicationDomain;
public static var resourceManager:mx.resources.IResourceManager;
}
}
// class ScrollPolicy
package mx.core
{
use namespace mx_internal;
public final class ScrollPolicy extends Object
{
public function ScrollPolicy()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const AUTO:String="auto";
public static const OFF:String="off";
public static const ON:String="on";
}
}
// class Singleton
package mx.core
{
use namespace mx_internal;
public class Singleton extends Object
{
public function Singleton()
{
super();
return;
}
public static function registerClass(arg1:String, arg2:Class):void
{
var loc1:*=classMap[arg1];
if (!loc1)
{
classMap[arg1] = arg2;
}
return;
}
public static function getClass(arg1:String):Class
{
return classMap[arg1];
}
public static function getInstance(arg1:String):Object
{
var loc1:*=classMap[arg1];
if (!loc1)
{
throw new Error("No class registered for interface \'" + arg1 + "\'.");
}
var loc2:*;
return (loc2 = loc1)["getInstance"]();
}
{
mx_internal::VERSION = "4.1.0.16076";
classMap = {};
}
mx_internal static const VERSION:String="4.1.0.16076";
internal static var classMap:Object;
}
}
// class SpriteAsset
package mx.core
{
import flash.display.*;
import flash.events.*;
import flash.geom.*;
import flash.system.*;
use namespace mx_internal;
public class SpriteAsset extends mx.core.FlexSprite implements mx.core.IFlexAsset, mx.core.IFlexDisplayObject, mx.core.IBorder, mx.core.ILayoutDirectionElement
{
public function SpriteAsset()
{
var loc1:*=null;
super();
this._measuredWidth = this.width;
this._measuredHeight = this.height;
if (FlexVersionClass == null)
{
loc1 = flash.system.ApplicationDomain.currentDomain;
if (loc1.hasDefinition("mx.core::FlexVersion"))
{
FlexVersionClass = Class(loc1.getDefinition("mx.core::FlexVersion"));
}
}
if (FlexVersionClass && FlexVersionClass["compatibilityVersion"] >= FlexVersionClass["VERSION_4_0"])
{
this.addEventListener(flash.events.Event.ADDED, this.addedHandler);
}
return;
}
internal function initAdvancedLayoutFeatures():void
{
var loc1:*=null;
var loc2:*=null;
if (this.layoutFeaturesClass == null)
{
loc1 = flash.system.ApplicationDomain.currentDomain;
if (loc1.hasDefinition("mx.core::AdvancedLayoutFeatures"))
{
this.layoutFeaturesClass = Class(loc1.getDefinition("mx.core::AdvancedLayoutFeatures"));
}
if (MatrixUtilClass == null)
{
if (loc1.hasDefinition("mx.utils::MatrixUtil"))
{
MatrixUtilClass = Class(loc1.getDefinition("mx.utils::MatrixUtil"));
}
}
}
if (this.layoutFeaturesClass != null)
{
loc2 = new this.layoutFeaturesClass();
loc2.layoutScaleX = this.scaleX;
loc2.layoutScaleY = this.scaleY;
loc2.layoutScaleZ = this.scaleZ;
loc2.layoutRotationX = this.rotationX;
loc2.layoutRotationY = this.rotationY;
loc2.layoutRotationZ = this.rotation;
loc2.layoutX = this.x;
loc2.layoutY = this.y;
loc2.layoutZ = this.z;
loc2.layoutWidth = this.width;
this._height = this.height;
this.layoutFeatures = loc2;
}
return;
}
internal function validateTransformMatrix():void
{
if (this.layoutFeatures != null)
{
if (this.layoutFeatures.is3D)
{
super.transform.matrix3D = this.layoutFeatures.computedMatrix3D;
}
else
{
super.transform.matrix = this.layoutFeatures.computedMatrix;
}
}
return;
}
public override function get x():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutX : super.x;
}
public override function set x(arg1:Number):void
{
if (this.x == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutX = arg1;
this.validateTransformMatrix();
}
else
{
super.x = arg1;
}
return;
}
public override function get y():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutY : super.y;
}
public override function set y(arg1:Number):void
{
if (this.y == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutY = arg1;
this.validateTransformMatrix();
}
else
{
super.y = arg1;
}
return;
}
public override function get z():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutZ : super.z;
}
public override function set z(arg1:Number):void
{
if (this.z == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutZ = arg1;
this.validateTransformMatrix();
}
else
{
super.z = arg1;
}
return;
}
public override function get width():Number
{
var loc1:*=null;
if (this.layoutFeatures == null)
{
return super.width;
}
if (MatrixUtilClass != null)
{
var loc2:*;
loc1 = (loc2 = MatrixUtilClass)["transformSize"](this.layoutFeatures.layoutWidth, this._height, transform.matrix);
}
return loc1 ? loc1.x : super.width;
}
public override function set width(arg1:Number):void
{
if (this.width == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutWidth = arg1;
this.layoutFeatures.layoutScaleX = this.measuredWidth == 0 ? 0 : arg1 / this.measuredWidth;
this.validateTransformMatrix();
}
else
{
super.width = arg1;
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
public override function get height():Number
{
var loc1:*=null;
if (this.layoutFeatures == null)
{
return super.height;
}
if (MatrixUtilClass != null)
{
var loc2:*;
loc1 = (loc2 = MatrixUtilClass)["transformSize"](this.layoutFeatures.layoutWidth, this._height, transform.matrix);
}
return loc1 ? loc1.y : super.height;
}
public override function set height(arg1:Number):void
{
if (this.height == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this._height = arg1;
this.layoutFeatures.layoutScaleY = this.measuredHeight == 0 ? 0 : arg1 / this.measuredHeight;
this.validateTransformMatrix();
}
else
{
super.height = arg1;
}
return;
}
public override function get rotationX():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutRotationX : super.rotationX;
}
public override function set rotationX(arg1:Number):void
{
if (this.rotationX == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutRotationX = arg1;
this.validateTransformMatrix();
}
else
{
super.rotationX = arg1;
}
return;
}
public override function get rotationY():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutRotationY : super.rotationY;
}
public override function set rotationY(arg1:Number):void
{
if (this.rotationY == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutRotationY = arg1;
this.validateTransformMatrix();
}
else
{
super.rotationY = arg1;
}
return;
}
public override function get rotationZ():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutRotationZ : super.rotationZ;
}
public override function set rotationZ(arg1:Number):void
{
if (this.rotationZ == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutRotationZ = arg1;
this.validateTransformMatrix();
}
else
{
super.rotationZ = arg1;
}
return;
}
public override function get rotation():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutRotationZ : super.rotation;
}
public override function set rotation(arg1:Number):void
{
if (this.rotation == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutRotationZ = arg1;
this.validateTransformMatrix();
}
else
{
super.rotation = arg1;
}
return;
}
public override function get scaleX():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutScaleX : super.scaleX;
}
public override function set scaleX(arg1:Number):void
{
if (this.scaleX == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutScaleX = arg1;
this.layoutFeatures.layoutWidth = Math.abs(arg1) * this.measuredWidth;
this.validateTransformMatrix();
}
else
{
super.scaleX = arg1;
}
return;
}
public override function get scaleY():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutScaleY : super.scaleY;
}
public override function set scaleY(arg1:Number):void
{
if (this.scaleY == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutScaleY = arg1;
this._height = Math.abs(arg1) * this.measuredHeight;
this.validateTransformMatrix();
}
else
{
super.scaleY = arg1;
}
return;
}
public override function get scaleZ():Number
{
return this.layoutFeatures != null ? this.layoutFeatures.layoutScaleZ : super.scaleZ;
}
public override function set scaleZ(arg1:Number):void
{
if (this.scaleZ == arg1)
{
return;
}
if (this.layoutFeatures != null)
{
this.layoutFeatures.layoutScaleZ = arg1;
this.validateTransformMatrix();
}
else
{
super.scaleZ = arg1;
}
return;
}
public function get layoutDirection():String
{
return this._layoutDirection;
}
public function set layoutDirection(arg1:String):void
{
if (arg1 == this._layoutDirection)
{
return;
}
this._layoutDirection = arg1;
this.invalidateLayoutDirection();
return;
}
public function get measuredHeight():Number
{
return this._measuredHeight;
}
public function get measuredWidth():Number
{
return this._measuredWidth;
}
public function get borderMetrics():mx.core.EdgeMetrics
{
if (scale9Grid == null)
{
return mx.core.EdgeMetrics.EMPTY;
}
return new mx.core.EdgeMetrics(scale9Grid.left, scale9Grid.top, Math.ceil(this.measuredWidth - scale9Grid.right), Math.ceil(this.measuredHeight - scale9Grid.bottom));
}
public function invalidateLayoutDirection():void
{
var loc2:*=false;
var loc1:*=parent;
while (loc1)
{
if (loc1 is mx.core.ILayoutDirectionElement)
{
loc2 = !(this._layoutDirection == null) && !(this._layoutDirection == mx.core.ILayoutDirectionElement(loc1).layoutDirection);
if (loc2 && this.layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
if (this.layoutFeatures != null)
{
this.layoutFeatures.mirror = loc2;
this.validateTransformMatrix();
}
}
else if (!loc2 && this.layoutFeatures)
{
this.layoutFeatures.mirror = loc2;
this.validateTransformMatrix();
this.layoutFeatures = null;
}
break;
}
loc1 = loc1.parent;
}
return;
}
public function move(arg1:Number, arg2:Number):void
{
this.x = arg1;
this.y = arg2;
return;
}
public function setActualSize(arg1:Number, arg2:Number):void
{
this.width = arg1;
this.height = arg2;
return;
}
internal function addedHandler(arg1:flash.events.Event):void
{
this.invalidateLayoutDirection();
return;
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var layoutFeaturesClass:Class;
internal var layoutFeatures:mx.core.IAssetLayoutFeatures;
internal var _height:Number;
internal var _measuredHeight:Number;
internal var _layoutDirection:String="ltr";
internal static var FlexVersionClass:Class;
internal static var MatrixUtilClass:Class;
internal var _measuredWidth:Number;
}
}
// class TextFieldFactory
package mx.core
{
import flash.text.*;
import flash.utils.*;
use namespace mx_internal;
public class TextFieldFactory extends Object implements mx.core.ITextFieldFactory
{
public function TextFieldFactory()
{
this.textFields = new flash.utils.Dictionary(true);
this.fteTextFields = new flash.utils.Dictionary(true);
super();
return;
}
public function createTextField(arg1:mx.core.IFlexModuleFactory):flash.text.TextField
{
var loc3:*=null;
var loc1:*=null;
var loc2:*=this.textFields[arg1];
if (loc2)
{
var loc4:*=0;
var loc5:*=loc2;
for (loc3 in loc5)
{
loc1 = flash.text.TextField(loc3);
break;
}
}
if (!loc1)
{
if (arg1)
{
loc1 = flash.text.TextField(arg1.create("flash.text.TextField"));
}
else
{
loc1 = new flash.text.TextField();
}
if (!loc2)
{
loc2 = new flash.utils.Dictionary(true);
}
loc2[loc1] = 1;
this.textFields[arg1] = loc2;
}
return loc1;
}
public function createFTETextField(arg1:mx.core.IFlexModuleFactory):Object
{
var loc3:*=null;
var loc1:*=null;
var loc2:*=this.fteTextFields[arg1];
if (loc2)
{
var loc4:*=0;
var loc5:*=loc2;
for (loc3 in loc5)
{
loc1 = loc3;
break;
}
}
if (!loc1)
{
if (arg1)
{
loc1 = arg1.create("mx.core.FTETextField");
loc1.fontContext = arg1;
}
if (!loc2)
{
loc2 = new flash.utils.Dictionary(true);
}
loc2[loc1] = 1;
this.fteTextFields[arg1] = loc2;
}
return loc1;
}
public static function getInstance():mx.core.ITextFieldFactory
{
if (!instance)
{
instance = new TextFieldFactory();
}
return instance;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
internal var textFields:flash.utils.Dictionary;
internal var fteTextFields:flash.utils.Dictionary;
internal static var instance:mx.core.ITextFieldFactory;
}
}
// class UIComponent
package mx.core
{
import flash.accessibility.*;
import flash.display.*;
import flash.events.*;
import flash.geom.*;
import flash.system.*;
import flash.text.*;
import flash.ui.*;
import flash.utils.*;
import mx.automation.*;
import mx.binding.*;
import mx.controls.*;
import mx.effects.*;
import mx.events.*;
import mx.filters.*;
import mx.geom.*;
import mx.graphics.shaderClasses.*;
import mx.managers.*;
import mx.resources.*;
import mx.states.*;
import mx.styles.*;
import mx.utils.*;
import mx.validators.*;
use namespace mx_internal;
public class UIComponent extends mx.core.FlexSprite implements mx.automation.IAutomationObject, mx.core.IChildList, mx.core.IConstraintClient, mx.core.IDeferredInstantiationUIComponent, mx.core.IFlexDisplayObject, mx.core.IFlexModule, mx.core.IInvalidating, mx.managers.ILayoutManagerClient, mx.core.IPropertyChangeNotifier, mx.core.IRepeaterClient, mx.core.IStateClient, mx.styles.IAdvancedStyleClient, mx.managers.IToolTipManagerClient, mx.core.IUIComponent, mx.validators.IValidatorListener, mx.core.IVisualElement
{
public function UIComponent()
{
this.methodQueue = [];
this._resourceManager = mx.resources.ResourceManager.getInstance();
this._inheritingStyles = mx.styles.StyleProtoChain.STYLE_UNINITIALIZED;
this._nonInheritingStyles = mx.styles.StyleProtoChain.STYLE_UNINITIALIZED;
this._states = [];
this._transitions = [];
this.mx_internal::_effectsStarted = [];
this.mx_internal::_affectedProperties = {};
this._endingEffectInstances = [];
super();
focusRect = false;
tabEnabled = this is mx.managers.IFocusManagerComponent;
this.tabFocusEnabled = this is mx.managers.IFocusManagerComponent;
this.enabled = true;
this.mx_internal::$visible = false;
addEventListener(flash.events.Event.ADDED, this.addedHandler);
addEventListener(flash.events.Event.REMOVED, this.removedHandler);
if (this is mx.managers.IFocusManagerComponent)
{
addEventListener(flash.events.FocusEvent.FOCUS_IN, this.focusInHandler);
addEventListener(flash.events.FocusEvent.FOCUS_OUT, this.focusOutHandler);
addEventListener(flash.events.KeyboardEvent.KEY_DOWN, this.keyDownHandler);
addEventListener(flash.events.KeyboardEvent.KEY_UP, this.keyUpHandler);
}
this.resourcesChanged();
this.resourceManager.addEventListener(flash.events.Event.CHANGE, this.resourceManager_changeHandler, false, 0, true);
this.mx_internal::_width = super.width;
this.mx_internal::_height = super.height;
return;
}
mx_internal function set isEffectStarted(arg1:Boolean):void
{
this._isEffectStarted = arg1;
return;
}
public function effectStarted(arg1:mx.effects.IEffectInstance):void
{
var loc3:*=null;
this.mx_internal::_effectsStarted.push(arg1);
var loc1:*=arg1.effect.getAffectedProperties();
var loc2:*=0;
while (loc2 < loc1.length)
{
loc3 = loc1[loc2];
if (this.mx_internal::_affectedProperties[loc3] == undefined)
{
this.mx_internal::_affectedProperties[loc3] = [];
}
this.mx_internal::_affectedProperties[loc3].push(arg1);
++loc2;
}
this.mx_internal::isEffectStarted = true;
if (arg1.hideFocusRing)
{
this.preventDrawFocus = true;
this.drawFocus(false);
}
return;
}
public function effectFinished(arg1:mx.effects.IEffectInstance):void
{
this._endingEffectInstances.push(arg1);
this.invalidateProperties();
mx.core.UIComponentGlobals.mx_internal::layoutManager.addEventListener(mx.events.FlexEvent.UPDATE_COMPLETE, this.updateCompleteHandler, false, 0, true);
return;
}
public function endEffectsStarted():void
{
var loc1:*=this.mx_internal::_effectsStarted.length;
var loc2:*=0;
while (loc2 < loc1)
{
this.mx_internal::_effectsStarted[loc2].end();
++loc2;
}
return;
}
internal function updateCompleteHandler(arg1:mx.events.FlexEvent):void
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.removeEventListener(mx.events.FlexEvent.UPDATE_COMPLETE, this.updateCompleteHandler);
this.processEffectFinished(this._endingEffectInstances);
this._endingEffectInstances = [];
return;
}
internal function processEffectFinished(arg1:Array):void
{
var loc2:*=0;
var loc3:*=null;
var loc4:*=null;
var loc5:*=null;
var loc6:*=0;
var loc7:*=null;
var loc8:*=0;
var loc1:*=(this.mx_internal::_effectsStarted.length - 1);
while (loc1 >= 0)
{
loc2 = 0;
while (loc2 < arg1.length)
{
if ((loc3 = arg1[loc2]) == this.mx_internal::_effectsStarted[loc1])
{
loc4 = this.mx_internal::_effectsStarted[loc1];
this.mx_internal::_effectsStarted.splice(loc1, 1);
loc5 = loc4.effect.getAffectedProperties();
loc6 = 0;
while (loc6 < loc5.length)
{
loc7 = loc5[loc6];
if (this.mx_internal::_affectedProperties[loc7] != undefined)
{
loc8 = 0;
while (loc8 < this.mx_internal::_affectedProperties[loc7].length)
{
if (this.mx_internal::_affectedProperties[loc7][loc8] == loc3)
{
this.mx_internal::_affectedProperties[loc7].splice(loc8, 1);
break;
}
++loc8;
}
if (this.mx_internal::_affectedProperties[loc7].length == 0)
{
delete this.mx_internal::_affectedProperties[loc7];
}
}
++loc6;
}
break;
}
++loc2;
}
--loc1;
}
this.mx_internal::isEffectStarted = this.mx_internal::_effectsStarted.length > 0 ? true : false;
if (loc3 && loc3.hideFocusRing)
{
this.preventDrawFocus = false;
}
return;
}
mx_internal function getEffectsForProperty(arg1:String):Array
{
return this.mx_internal::_affectedProperties[arg1] == undefined ? [] : this.mx_internal::_affectedProperties[arg1];
}
public function createReferenceOnParentDocument(arg1:mx.core.IFlexDisplayObject):void
{
var loc1:*=null;
var loc2:*=null;
var loc3:*=0;
var loc4:*=0;
var loc5:*=null;
var loc6:*=null;
if (this.id && !(this.id == ""))
{
loc1 = this._instanceIndices;
if (loc1)
{
loc2 = arg1[this.id];
if (!(loc2 is Array))
{
var loc7:*;
arg1[this.id] = loc7 = [];
loc2 = loc7;
}
loc3 = loc1.length;
loc4 = 0;
while (loc4 < (loc3 - 1))
{
if (!((loc5 = loc2[loc1[loc4]]) is Array))
{
loc2[loc1[loc4]] = loc7 = [];
loc5 = loc7;
}
loc2 = loc5;
++loc4;
}
loc2[loc1[(loc3 - 1)]] = this;
if (arg1.hasEventListener("propertyChange"))
{
loc6 = mx.events.PropertyChangeEvent.createUpdateEvent(arg1, this.id, arg1[this.id], arg1[this.id]);
arg1.dispatchEvent(loc6);
}
}
else
{
arg1[this.id] = this;
}
}
return;
}
public function get initialized():Boolean
{
return this._initialized;
}
public function set initialized(arg1:Boolean):void
{
this._initialized = arg1;
if (arg1)
{
this.setVisible(this._visible, true);
this.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.CREATION_COMPLETE));
}
return;
}
public function deleteReferenceOnParentDocument(arg1:mx.core.IFlexDisplayObject):void
{
var loc1:*=null;
var loc2:*=null;
var loc3:*=null;
var loc4:*=0;
var loc5:*=0;
var loc6:*=0;
var loc7:*=null;
var loc8:*=null;
if (this.id && !(this.id == ""))
{
loc1 = this._instanceIndices;
if (loc1)
{
loc2 = arg1[this.id];
if (!loc2)
{
return;
}
(loc3 = []).push(loc2);
loc4 = loc1.length;
loc5 = 0;
while (loc5 < (loc4 - 1))
{
if (!(loc7 = loc2[loc1[loc5]]))
{
return;
}
loc2 = loc7;
loc3.push(loc2);
++loc5;
}
loc2.splice(loc1[(loc4 - 1)], 1);
loc6 = (loc3.length - 1);
while (loc6 > 0)
{
if (loc3[loc6].length == 0)
{
loc3[(loc6 - 1)].splice(loc1[loc6], 1);
}
--loc6;
}
if (loc3.length > 0 && loc3[0].length == 0)
{
arg1[this.id] = null;
}
else if (arg1.hasEventListener("propertyChange"))
{
loc8 = mx.events.PropertyChangeEvent.createUpdateEvent(arg1, this.id, arg1[this.id], arg1[this.id]);
arg1.dispatchEvent(loc8);
}
}
else
{
arg1[this.id] = null;
}
}
return;
}
public function get processedDescriptors():Boolean
{
return this._processedDescriptors;
}
public function set processedDescriptors(arg1:Boolean):void
{
this._processedDescriptors = arg1;
if (arg1)
{
this.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.INITIALIZE));
}
return;
}
public function getRepeaterItem(arg1:int=-1):Object
{
var loc1:*=this.repeaters;
if (loc1.length == 0)
{
return null;
}
if (arg1 == -1)
{
arg1 = (loc1.length - 1);
}
return loc1[arg1].getItemAt(this.repeaterIndices[arg1]);
}
public function get updateCompletePendingFlag():Boolean
{
return this._updateCompletePendingFlag;
}
public function set updateCompletePendingFlag(arg1:Boolean):void
{
this._updateCompletePendingFlag = arg1;
return;
}
public function get accessibilityEnabled():Boolean
{
return accessibilityProperties ? !accessibilityProperties.silent : true;
}
public function set accessibilityEnabled(arg1:Boolean):void
{
if (!flash.system.Capabilities.hasAccessibility)
{
return;
}
if (!accessibilityProperties)
{
accessibilityProperties = new flash.accessibility.AccessibilityProperties();
}
accessibilityProperties.silent = !arg1;
flash.accessibility.Accessibility.updateProperties();
return;
}
public function get accessibilityName():String
{
return accessibilityProperties ? accessibilityProperties.name : "";
}
public function set accessibilityName(arg1:String):void
{
if (!flash.system.Capabilities.hasAccessibility)
{
return;
}
if (!accessibilityProperties)
{
accessibilityProperties = new flash.accessibility.AccessibilityProperties();
}
accessibilityProperties.name = arg1;
flash.accessibility.Accessibility.updateProperties();
return;
}
public function get accessibilityDescription():String
{
return accessibilityProperties ? accessibilityProperties.description : "";
}
public function set accessibilityDescription(arg1:String):void
{
if (!flash.system.Capabilities.hasAccessibility)
{
return;
}
if (!accessibilityProperties)
{
accessibilityProperties = new flash.accessibility.AccessibilityProperties();
}
accessibilityProperties.description = arg1;
flash.accessibility.Accessibility.updateProperties();
return;
}
public function get accessibilityShortcut():String
{
return accessibilityProperties ? accessibilityProperties.shortcut : "";
}
public function set accessibilityShortcut(arg1:String):void
{
if (!flash.system.Capabilities.hasAccessibility)
{
return;
}
if (!accessibilityProperties)
{
accessibilityProperties = new flash.accessibility.AccessibilityProperties();
}
accessibilityProperties.shortcut = arg1;
flash.accessibility.Accessibility.updateProperties();
return;
}
protected function resourcesChanged():void
{
return;
}
public function prepareToPrint(arg1:mx.core.IFlexDisplayObject):Object
{
return null;
}
public function finishPrint(arg1:Object, arg2:mx.core.IFlexDisplayObject):void
{
return;
}
internal function callLaterDispatcher(arg1:flash.events.Event):void
{
var event:flash.events.Event;
var callLaterErrorEvent:mx.events.DynamicEvent;
var loc1:*;
callLaterErrorEvent = null;
event = arg1;
var loc2:*;
var loc3:*=((loc2 = mx.core.UIComponentGlobals).mx_internal::callLaterDispatcherCount + 1);
loc2.mx_internal::callLaterDispatcherCount = loc3;
if (mx.core.UIComponentGlobals.catchCallLaterExceptions)
{
try
{
this.callLaterDispatcher2(event);
}
catch (e:Error)
{
callLaterErrorEvent = new mx.events.DynamicEvent("callLaterError");
callLaterErrorEvent.error = e;
callLaterErrorEvent.source = this;
systemManager.dispatchEvent(callLaterErrorEvent);
}
}
else
{
this.callLaterDispatcher2(event);
}
loc3 = ((loc2 = mx.core.UIComponentGlobals).mx_internal::callLaterDispatcherCount - 1);
loc2.mx_internal::callLaterDispatcherCount = loc3;
return;
}
internal function callLaterDispatcher2(arg1:flash.events.Event):void
{
var loc5:*=null;
if (mx.core.UIComponentGlobals.mx_internal::callLaterSuspendCount > 0)
{
return;
}
var loc1:*=this.systemManager;
if (loc1 && (loc1.stage || this.usingBridge) && this.listeningForRender)
{
loc1.removeEventListener(mx.events.FlexEvent.RENDER, this.callLaterDispatcher);
loc1.removeEventListener(mx.events.FlexEvent.ENTER_FRAME, this.callLaterDispatcher);
this.listeningForRender = false;
}
var loc2:*=this.methodQueue;
this.methodQueue = [];
var loc3:*=loc2.length;
var loc4:*=0;
while (loc4 < loc3)
{
(loc5 = MethodQueueElement(loc2[loc4])).method.apply(null, loc5.args);
++loc4;
}
return;
}
protected function keyDownHandler(arg1:flash.events.KeyboardEvent):void
{
return;
}
protected function keyUpHandler(arg1:flash.events.KeyboardEvent):void
{
return;
}
protected function isOurFocus(arg1:flash.display.DisplayObject):Boolean
{
return arg1 == this;
}
protected function focusInHandler(arg1:flash.events.FocusEvent):void
{
var loc1:*=null;
if (this.isOurFocus(flash.display.DisplayObject(arg1.target)))
{
loc1 = this.focusManager;
if (loc1 && loc1.showFocusIndicator)
{
this.drawFocus(true);
}
mx.core.ContainerGlobals.checkFocus(arg1.relatedObject, this);
}
return;
}
protected function focusOutHandler(arg1:flash.events.FocusEvent):void
{
if (this.isOurFocus(flash.display.DisplayObject(arg1.target)))
{
this.drawFocus(false);
}
return;
}
internal function addedHandler(arg1:flash.events.Event):void
{
var event:flash.events.Event;
var loc1:*;
event = arg1;
if (event.eventPhase != flash.events.EventPhase.AT_TARGET)
{
return;
}
try
{
if (this.parent is mx.core.IContainer && mx.core.IContainer(this.parent).creatingContentPane)
{
event.stopImmediatePropagation();
return;
}
}
catch (error:SecurityError)
{
};
return;
}
internal function removedHandler(arg1:flash.events.Event):void
{
var event:flash.events.Event;
var loc1:*;
event = arg1;
if (event.eventPhase != flash.events.EventPhase.AT_TARGET)
{
return;
}
try
{
if (this.parent is mx.core.IContainer && mx.core.IContainer(this.parent).creatingContentPane)
{
event.stopImmediatePropagation();
return;
}
}
catch (error:SecurityError)
{
};
this.invalidateSystemManager();
return;
}
internal function setFocusLater(arg1:flash.events.Event=null):void
{
var loc1:*=this.systemManager;
if (loc1 && loc1.stage)
{
loc1.stage.removeEventListener(flash.events.Event.ENTER_FRAME, this.setFocusLater);
if (mx.core.UIComponentGlobals.mx_internal::nextFocusObject)
{
loc1.stage.focus = mx.core.UIComponentGlobals.mx_internal::nextFocusObject;
}
mx.core.UIComponentGlobals.mx_internal::nextFocusObject = null;
}
return;
}
internal function focusObj_scrollHandler(arg1:flash.events.Event):void
{
this.adjustFocusRect();
return;
}
internal function focusObj_moveHandler(arg1:mx.events.MoveEvent):void
{
this.adjustFocusRect();
return;
}
internal function focusObj_resizeHandler(arg1:flash.events.Event):void
{
if (arg1 is mx.events.ResizeEvent)
{
this.adjustFocusRect();
}
return;
}
internal function focusObj_removedHandler(arg1:flash.events.Event):void
{
if (arg1.target != this)
{
return;
}
var loc1:*=this.mx_internal::getFocusObject();
if (loc1)
{
loc1.visible = false;
}
return;
}
protected function layer_PropertyChange(arg1:mx.events.PropertyChangeEvent):void
{
var loc1:*=false;
var loc2:*=NaN;
var loc3:*=arg1.property;
switch (loc3)
{
case "effectiveVisibility":
{
loc1 = arg1.newValue && this._visible;
if (loc1 != this.mx_internal::$visible)
{
this.mx_internal::$visible = loc1;
}
break;
}
case "effectiveAlpha":
{
loc2 = Number(arg1.newValue) * this._alpha;
if (loc2 != this.mx_internal::$alpha)
{
this.mx_internal::$alpha = loc2;
}
break;
}
}
return;
}
public function validationResultHandler(arg1:mx.events.ValidationResultEvent):void
{
var loc2:*=null;
var loc3:*=null;
var loc4:*=0;
if (this.errorObjectArray === null)
{
this.errorObjectArray = new Array();
this.errorArray = new Array();
}
var loc1:*=this.errorObjectArray.indexOf(arg1.target);
if (arg1.type != mx.events.ValidationResultEvent.VALID)
{
if (!(this.validationSubField == null) && !(this.validationSubField == "") && arg1.results)
{
loc4 = 0;
while (loc4 < arg1.results.length)
{
if ((loc3 = arg1.results[loc4]).subField == this.validationSubField)
{
if (loc3.isError)
{
loc2 = loc3.errorMessage;
}
else if (loc1 != -1)
{
this.errorObjectArray.splice(loc1, 1);
this.errorArray.splice(loc1, 1);
this.errorString = this.errorArray.join("\n");
if (this.errorArray.length == 0)
{
this.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.VALID));
}
}
break;
}
++loc4;
}
}
else if (arg1.results && arg1.results.length > 0)
{
loc2 = arg1.results[0].errorMessage;
}
if (loc2 && !(loc1 == -1))
{
this.errorArray[loc1] = loc2;
this.errorString = this.errorArray.join("\n");
this.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.INVALID));
}
else if (loc2 && loc1 == -1)
{
this.errorObjectArray.push(arg1.target);
this.errorArray.push(loc2);
this.errorString = this.errorArray.join("\n");
this.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.INVALID));
}
}
else if (loc1 != -1)
{
this.errorObjectArray.splice(loc1, 1);
this.errorArray.splice(loc1, 1);
this.errorString = this.errorArray.join("\n");
if (this.errorArray.length == 0)
{
this.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.VALID));
}
}
return;
}
internal function resourceManager_changeHandler(arg1:flash.events.Event):void
{
this.resourcesChanged();
return;
}
internal function filterChangeHandler(arg1:flash.events.Event):void
{
this.filters = this._filters;
return;
}
public function owns(arg1:flash.display.DisplayObject):Boolean
{
var child:flash.display.DisplayObject;
var childList:mx.core.IChildList;
var loc1:*;
child = arg1;
childList = this is mx.core.IRawChildrenContainer ? mx.core.IRawChildrenContainer(this).rawChildren : mx.core.IChildList(this);
if (childList.contains(child))
{
return true;
}
try
{
while (child && !(child == this))
{
if (child is mx.core.IUIComponent)
{
child = mx.core.IUIComponent(child).owner;
continue;
}
child = child.parent;
}
}
catch (e:SecurityError)
{
return false;
}
return child == this;
}
mx_internal function getFontContext(arg1:String, arg2:Boolean, arg3:Boolean, arg4:*=undefined):mx.core.IFlexModuleFactory
{
if (noEmbeddedFonts)
{
return null;
}
var loc1:*;
return (loc1 = mx_internal::embeddedFontRegistry) ? loc1.getAssociatedModuleFactory(arg1, arg2, arg3, this, this.moduleFactory, this.systemManager, arg4) : null;
}
protected function createInFontContext(arg1:Class):Object
{
this.hasFontContextBeenSaved = true;
var loc1:*=mx.utils.StringUtil.trimArrayElements(this.getStyle("fontFamily"), ",");
var loc2:*=this.getStyle("fontWeight");
var loc3:*=this.getStyle("fontStyle");
var loc4:*=loc2 == "bold";
var loc5:*=loc3 == "italic";
var loc6:*;
if ((loc6 = flash.utils.getQualifiedClassName(arg1)) == "mx.core::UITextField")
{
if ((loc6 = this.getTextFieldClassName()) == "mx.core::UIFTETextField")
{
arg1 = Class(flash.system.ApplicationDomain.currentDomain.getDefinition(loc6));
}
}
this.oldEmbeddedFontContext = this.mx_internal::getFontContext(loc1, loc4, loc5, loc6 == "mx.core::UIFTETextField");
var loc7:*=this.oldEmbeddedFontContext ? this.oldEmbeddedFontContext : this.moduleFactory;
var loc8:*;
if ((loc8 = this.createInModuleContext(loc7, loc6)) == null)
{
loc8 = new arg1();
}
if (loc6 == "mx.core::UIFTETextField")
{
loc8.fontContext = loc7;
}
return loc8;
}
internal function getTextFieldClassName():String
{
var loc1:*=this.getStyle("textFieldClass");
if (!loc1 || mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
return "mx.core::UITextField";
}
return flash.utils.getQualifiedClassName(loc1);
}
internal function getTextInputClassName():String
{
var loc1:*=this.getStyle("textInputClass");
if (!loc1 || mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
return "mx.core::TextInput";
}
return flash.utils.getQualifiedClassName(loc1);
}
internal function get usingBridge():Boolean
{
if (this._usingBridge == 0)
{
return false;
}
if (this._usingBridge == 1)
{
return true;
}
if (!this._systemManager)
{
return false;
}
var loc1:*=this._systemManager.getImplementation("mx.managers.IMarshallPlanSystemManager");
if (!loc1)
{
this._usingBridge = 0;
return false;
}
if (loc1.useSWFBridge())
{
this._usingBridge = 1;
return true;
}
this._usingBridge = 0;
return false;
}
protected function createInModuleContext(arg1:mx.core.IFlexModuleFactory, arg2:String):Object
{
var loc1:*=null;
if (arg1)
{
loc1 = arg1.create(arg2);
}
return loc1;
}
public function get owner():flash.display.DisplayObjectContainer
{
return this.mx_internal::_owner ? this.mx_internal::_owner : this.parent;
}
public function set owner(arg1:flash.display.DisplayObjectContainer):void
{
this.mx_internal::_owner = arg1;
return;
}
public function hasFontContextChanged():Boolean
{
if (!this.hasFontContextBeenSaved)
{
return false;
}
var loc1:*=mx.utils.StringUtil.trimArrayElements(this.getStyle("fontFamily"), ",");
var loc2:*=this.getStyle("fontWeight");
var loc3:*=this.getStyle("fontStyle");
var loc4:*=loc2 == "bold";
var loc5:*=loc3 == "italic";
var loc6:*;
return !((loc6 = noEmbeddedFonts ? null : mx_internal::embeddedFontRegistry.getAssociatedModuleFactory(loc1, loc4, loc5, this, this.moduleFactory, this.systemManager)) == this.oldEmbeddedFontContext);
}
public override function get parent():flash.display.DisplayObjectContainer
{
var loc1:*;
try
{
return this.mx_internal::_parent ? this.mx_internal::_parent : super.parent;
}
catch (e:SecurityError)
{
};
return null;
}
public override function get x():Number
{
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutX : super.x;
}
public override function set x(arg1:Number):void
{
if (this.x == arg1)
{
return;
}
if (this.mx_internal::_layoutFeatures != null)
{
this.mx_internal::_layoutFeatures.layoutX = arg1;
this.invalidateTransform();
}
else
{
super.x = arg1;
}
this.invalidateProperties();
if (this.parent && this.parent is mx.core.UIComponent)
{
mx.core.UIComponent(this.parent).mx_internal::childXYChanged();
}
if (hasEventListener("xChanged"))
{
this.dispatchEvent(new flash.events.Event("xChanged"));
}
return;
}
public override function get z():Number
{
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutZ : super.z;
}
public override function set z(arg1:Number):void
{
if (this.z == arg1)
{
return;
}
var loc1:*=this.is3D;
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
this.mx_internal::_layoutFeatures.layoutZ = arg1;
this.invalidateTransform();
this.invalidateProperties();
if (loc1 != this.is3D)
{
this.validateMatrix();
}
if (hasEventListener("zChanged"))
{
this.dispatchEvent(new flash.events.Event("zChanged"));
}
return;
}
public function get transformX():Number
{
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.transformX : 0;
}
public function set transformX(arg1:Number):void
{
if (this.transformX == arg1)
{
return;
}
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
this.mx_internal::_layoutFeatures.transformX = arg1;
this.invalidateTransform();
this.invalidateProperties();
this.invalidateParentSizeAndDisplayList();
return;
}
public function get transformY():Number
{
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.transformY : 0;
}
public function set transformY(arg1:Number):void
{
if (this.transformY == arg1)
{
return;
}
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
this.mx_internal::_layoutFeatures.transformY = arg1;
this.invalidateTransform();
this.invalidateProperties();
this.invalidateParentSizeAndDisplayList();
return;
}
public function get transformZ():Number
{
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.transformZ : 0;
}
public function set transformZ(arg1:Number):void
{
if (this.transformZ == arg1)
{
return;
}
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
this.mx_internal::_layoutFeatures.transformZ = arg1;
this.invalidateTransform();
this.invalidateProperties();
this.invalidateParentSizeAndDisplayList();
return;
}
public override function get rotation():Number
{
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
return super.rotation;
}
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutRotationZ : super.rotation;
}
public override function set rotation(arg1:Number):void
{
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
super.rotation = arg1;
return;
}
if (this.rotation == arg1)
{
return;
}
this._hasComplexLayoutMatrix = true;
if (this.mx_internal::_layoutFeatures != null)
{
this.mx_internal::_layoutFeatures.layoutRotationZ = arg1;
}
else
{
super.rotation = mx.utils.MatrixUtil.clampRotation(arg1);
}
this.invalidateTransform();
this.invalidateProperties();
this.invalidateParentSizeAndDisplayList();
return;
}
public override function get rotationZ():Number
{
return this.rotation;
}
public override function set rotationZ(arg1:Number):void
{
this.rotation = arg1;
return;
}
public override function get rotationX():Number
{
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutRotationX : super.rotationX;
}
public override function set rotationX(arg1:Number):void
{
if (this.rotationX == arg1)
{
return;
}
var loc1:*=this.is3D;
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
this.mx_internal::_layoutFeatures.layoutRotationX = arg1;
this.invalidateTransform();
this.invalidateProperties();
this.invalidateParentSizeAndDisplayList();
if (loc1 != this.is3D)
{
this.validateMatrix();
}
return;
}
public override function get rotationY():Number
{
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutRotationY : super.rotationY;
}
public override function set rotationY(arg1:Number):void
{
if (this.rotationY == arg1)
{
return;
}
var loc1:*=this.is3D;
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
this.mx_internal::_layoutFeatures.layoutRotationY = arg1;
this.invalidateTransform();
this.invalidateProperties();
this.invalidateParentSizeAndDisplayList();
if (loc1 != this.is3D)
{
this.validateMatrix();
}
return;
}
public override function get y():Number
{
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutY : super.y;
}
public override function set y(arg1:Number):void
{
if (this.y == arg1)
{
return;
}
if (this.mx_internal::_layoutFeatures != null)
{
this.mx_internal::_layoutFeatures.layoutY = arg1;
this.invalidateTransform();
}
else
{
super.y = arg1;
}
this.invalidateProperties();
if (this.parent && this.parent is mx.core.UIComponent)
{
mx.core.UIComponent(this.parent).mx_internal::childXYChanged();
}
if (hasEventListener("yChanged"))
{
this.dispatchEvent(new flash.events.Event("yChanged"));
}
return;
}
public function createAutomationIDPart(arg1:mx.automation.IAutomationObject):Object
{
if (this.automationDelegate)
{
return this.automationDelegate.createAutomationIDPart(arg1);
}
return null;
}
public override function get width():Number
{
return this.mx_internal::_width;
}
public override function set width(arg1:Number):void
{
if (this.explicitWidth != arg1)
{
this.explicitWidth = arg1;
this.invalidateSize();
}
if (this.mx_internal::_width != arg1)
{
this.invalidateProperties();
this.invalidateDisplayList();
this.invalidateParentSizeAndDisplayList();
this.mx_internal::_width = arg1;
if (this.mx_internal::_layoutFeatures)
{
this.mx_internal::_layoutFeatures.layoutWidth = this.mx_internal::_width;
this.invalidateTransform();
}
if (hasEventListener("widthChanged"))
{
this.dispatchEvent(new flash.events.Event("widthChanged"));
}
}
return;
}
public function createAutomationIDPartWithRequiredProperties(arg1:mx.automation.IAutomationObject, arg2:Array):Object
{
if (this.automationDelegate)
{
return this.automationDelegate.createAutomationIDPartWithRequiredProperties(arg1, arg2);
}
return null;
}
public override function get height():Number
{
return this.mx_internal::_height;
}
public override function set height(arg1:Number):void
{
if (this.explicitHeight != arg1)
{
this.explicitHeight = arg1;
this.invalidateSize();
}
if (this.mx_internal::_height != arg1)
{
this.invalidateProperties();
this.invalidateDisplayList();
this.invalidateParentSizeAndDisplayList();
this.mx_internal::_height = arg1;
if (hasEventListener("heightChanged"))
{
this.dispatchEvent(new flash.events.Event("heightChanged"));
}
}
return;
}
public override function get scaleX():Number
{
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
return this._scaleX;
}
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutScaleX : super.scaleX;
}
public function resolveAutomationIDPart(arg1:Object):Array
{
if (this.automationDelegate)
{
return this.automationDelegate.resolveAutomationIDPart(arg1);
}
return [];
}
public override function set scaleX(arg1:Number):void
{
var loc1:*=NaN;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
if (this._scaleX == arg1)
{
return;
}
this._scaleX = arg1;
this.invalidateProperties();
this.invalidateSize();
}
else
{
loc1 = this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutScaleX : this.scaleX;
if (loc1 == arg1)
{
return;
}
this._hasComplexLayoutMatrix = true;
if (this.mx_internal::_layoutFeatures != null)
{
this.mx_internal::_layoutFeatures.layoutScaleX = arg1;
}
else
{
super.scaleX = arg1;
}
this.invalidateTransform();
this.invalidateProperties();
this.invalidateParentSizeAndDisplayList();
}
this.dispatchEvent(new flash.events.Event("scaleXChanged"));
return;
}
public override function get scaleY():Number
{
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
return this._scaleY;
}
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutScaleY : super.scaleY;
}
public function getAutomationChildAt(arg1:int):mx.automation.IAutomationObject
{
if (this.automationDelegate)
{
return this.automationDelegate.getAutomationChildAt(arg1);
}
return null;
}
public override function set scaleY(arg1:Number):void
{
var loc1:*=NaN;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
if (this._scaleY == arg1)
{
return;
}
this._scaleY = arg1;
this.invalidateProperties();
this.invalidateSize();
}
else
{
loc1 = this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutScaleY : this.scaleY;
if (loc1 == arg1)
{
return;
}
this._hasComplexLayoutMatrix = true;
if (this.mx_internal::_layoutFeatures != null)
{
this.mx_internal::_layoutFeatures.layoutScaleY = arg1;
}
else
{
super.scaleY = arg1;
}
this.invalidateTransform();
this.invalidateProperties();
this.invalidateParentSizeAndDisplayList();
}
this.dispatchEvent(new flash.events.Event("scaleYChanged"));
return;
}
public override function get scaleZ():Number
{
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.layoutScaleZ : super.scaleZ;
}
public override function set scaleZ(arg1:Number):void
{
if (this.scaleZ == arg1)
{
return;
}
var loc1:*=this.is3D;
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
this._hasComplexLayoutMatrix = true;
this.mx_internal::_layoutFeatures.layoutScaleZ = arg1;
this.invalidateTransform();
this.invalidateProperties();
this.invalidateParentSizeAndDisplayList();
if (loc1 != this.is3D)
{
this.validateMatrix();
}
this.dispatchEvent(new flash.events.Event("scaleZChanged"));
return;
}
mx_internal final function get $scaleX():Number
{
return super.scaleX;
}
mx_internal final function set $scaleX(arg1:Number):void
{
super.scaleX = arg1;
return;
}
mx_internal final function get $scaleY():Number
{
return super.scaleY;
}
mx_internal final function set $scaleY(arg1:Number):void
{
super.scaleY = arg1;
return;
}
public function get numAutomationChildren():int
{
if (this.automationDelegate)
{
return this.automationDelegate.numAutomationChildren;
}
return 0;
}
public override function get visible():Boolean
{
return this._visible;
}
public override function set visible(arg1:Boolean):void
{
this.setVisible(arg1);
return;
}
public function setVisible(arg1:Boolean, arg2:Boolean=false):void
{
this._visible = arg1;
if (!this.initialized)
{
return;
}
if (this.designLayer && !this.designLayer.effectiveVisibility)
{
arg1 = false;
}
if (this.mx_internal::$visible == arg1)
{
return;
}
this.mx_internal::$visible = arg1;
if (!arg2)
{
this.dispatchEvent(new mx.events.FlexEvent(arg1 ? mx.events.FlexEvent.SHOW : mx.events.FlexEvent.HIDE));
}
return;
}
public function get automationTabularData():Object
{
if (this.automationDelegate)
{
return this.automationDelegate.automationTabularData;
}
return null;
}
public override function get alpha():Number
{
return int(this._alpha * 256) / 256;
}
public override function set alpha(arg1:Number):void
{
if (this._alpha != arg1)
{
this._alpha = arg1;
if (this.designLayer)
{
arg1 = arg1 * this.designLayer.effectiveAlpha;
}
this.mx_internal::$alpha = arg1;
this.dispatchEvent(new flash.events.Event("alphaChanged"));
}
return;
}
public function get automationOwner():flash.display.DisplayObjectContainer
{
return this.owner;
}
public function get automationParent():flash.display.DisplayObjectContainer
{
return this.parent;
}
public function get automationEnabled():Boolean
{
return this.enabled;
}
public override function get blendMode():String
{
return this._blendMode;
}
public override function set blendMode(arg1:String):void
{
if (this._blendMode != arg1)
{
this._blendMode = arg1;
this.blendModeChanged = true;
if (arg1 == "colordodge" || arg1 == "colorburn" || arg1 == "exclusion" || arg1 == "softlight" || arg1 == "hue" || arg1 == "saturation" || arg1 == "color" || arg1 == "luminosity")
{
this.blendShaderChanged = true;
}
this.invalidateProperties();
}
return;
}
public override function get doubleClickEnabled():Boolean
{
return super.doubleClickEnabled;
}
public override function set doubleClickEnabled(arg1:Boolean):void
{
var loc1:*=null;
var loc3:*=null;
super.doubleClickEnabled = arg1;
if (this is mx.core.IRawChildrenContainer)
{
loc1 = mx.core.IRawChildrenContainer(this).rawChildren;
}
else
{
loc1 = mx.core.IChildList(this);
}
var loc2:*=0;
while (loc2 < loc1.numChildren)
{
if (loc3 = loc1.getChildAt(loc2) as flash.display.InteractiveObject)
{
loc3.doubleClickEnabled = arg1;
}
++loc2;
}
return;
}
public function get automationVisible():Boolean
{
return this.visible;
}
public function get enabled():Boolean
{
return this._enabled;
}
public function set enabled(arg1:Boolean):void
{
this._enabled = arg1;
this.cachedTextFormat = null;
this.invalidateDisplayList();
this.dispatchEvent(new flash.events.Event("enabledChanged"));
return;
}
public override function set cacheAsBitmap(arg1:Boolean):void
{
super.cacheAsBitmap = arg1;
this.cacheAsBitmapCount = arg1 ? 1 : 0;
return;
}
public function replayAutomatableEvent(arg1:flash.events.Event):Boolean
{
if (this.automationDelegate)
{
return this.automationDelegate.replayAutomatableEvent(arg1);
}
return false;
}
public override function get filters():Array
{
return this._filters ? this._filters : super.filters;
}
public override function set filters(arg1:Array):void
{
var loc1:*=0;
var loc2:*=0;
var loc3:*=null;
if (this._filters)
{
loc1 = this._filters.length;
loc2 = 0;
while (loc2 < loc1)
{
if (loc3 = this._filters[loc2] as flash.events.IEventDispatcher)
{
loc3.removeEventListener(mx.filters.BaseFilter.CHANGE, this.filterChangeHandler);
}
++loc2;
}
}
this._filters = arg1;
var loc4:*=[];
if (this._filters)
{
loc1 = this._filters.length;
loc2 = 0;
while (loc2 < loc1)
{
if (this._filters[loc2] is mx.filters.IBitmapFilter)
{
if (loc3 = this._filters[loc2] as flash.events.IEventDispatcher)
{
loc3.addEventListener(mx.filters.BaseFilter.CHANGE, this.filterChangeHandler);
}
loc4.push(mx.filters.IBitmapFilter(this._filters[loc2]).clone());
}
else
{
loc4.push(this._filters[loc2]);
}
++loc2;
}
}
super.filters = loc4;
return;
}
public function getVisibleRect(arg1:flash.display.DisplayObject=null):flash.geom.Rectangle
{
if (!arg1)
{
arg1 = flash.display.DisplayObject(this.systemManager);
}
var loc1:*=this.mx_internal::$parent ? this.mx_internal::$parent : this.parent;
if (!loc1)
{
return new flash.geom.Rectangle();
}
var loc2:*=new flash.geom.Point(this.x, this.y);
loc2 = loc1.localToGlobal(loc2);
var loc3:*=new flash.geom.Rectangle(loc2.x, loc2.y, this.width, this.height);
var loc4:*=this;
var loc5:*=new flash.geom.Rectangle();
do
{
if (loc4 is mx.core.UIComponent)
{
if (mx.core.UIComponent(loc4).mx_internal::$parent)
{
loc4 = mx.core.UIComponent(loc4).mx_internal::$parent;
}
else
{
loc4 = mx.core.UIComponent(loc4).parent;
}
}
else
{
loc4 = loc4.parent;
}
if (loc4 && loc4.scrollRect)
{
loc5 = loc4.scrollRect.clone();
loc2 = loc4.localToGlobal(loc5.topLeft);
loc5.x = loc2.x;
loc5.y = loc2.y;
loc3 = loc3.intersection(loc5);
}
}
while (loc4 && !(loc4 == arg1));
return loc3;
}
public function get designLayer():mx.core.DesignLayer
{
return this._designLayer;
}
public function set designLayer(arg1:mx.core.DesignLayer):void
{
if (this._designLayer)
{
this._designLayer.removeEventListener("layerPropertyChange", this.layer_PropertyChange, false);
}
this._designLayer = arg1;
if (this._designLayer)
{
this._designLayer.addEventListener("layerPropertyChange", this.layer_PropertyChange, false, 0, true);
}
this.mx_internal::$alpha = this._designLayer ? this._alpha * this._designLayer.effectiveAlpha : this._alpha;
this.mx_internal::$visible = this.designLayer ? this._visible && this._designLayer.effectiveVisibility : this._visible;
return;
}
mx_internal final function get $alpha():Number
{
return super.alpha;
}
mx_internal final function set $alpha(arg1:Number):void
{
super.alpha = arg1;
return;
}
mx_internal final function get $blendMode():String
{
return super.blendMode;
}
mx_internal final function set $blendMode(arg1:String):void
{
super.blendMode = arg1;
return;
}
mx_internal final function set $blendShader(arg1:flash.display.Shader):void
{
super.blendShader = arg1;
return;
}
mx_internal final function get $parent():flash.display.DisplayObjectContainer
{
return super.parent;
}
mx_internal final function get $x():Number
{
return super.x;
}
mx_internal final function set $x(arg1:Number):void
{
super.x = arg1;
return;
}
mx_internal final function get $y():Number
{
return super.y;
}
mx_internal final function set $y(arg1:Number):void
{
super.y = arg1;
return;
}
mx_internal final function get $width():Number
{
return super.width;
}
mx_internal final function set $width(arg1:Number):void
{
super.width = arg1;
return;
}
mx_internal final function get $height():Number
{
return super.height;
}
mx_internal final function set $height(arg1:Number):void
{
super.height = arg1;
return;
}
mx_internal final function get $visible():Boolean
{
return super.visible;
}
mx_internal final function set $visible(arg1:Boolean):void
{
super.visible = arg1;
return;
}
public function get contentMouseX():Number
{
return this.mouseX;
}
public function get contentMouseY():Number
{
return this.mouseY;
}
public override function dispatchEvent(arg1:flash.events.Event):Boolean
{
if (mx_internal::dispatchEventHook != null)
{
mx_internal::dispatchEventHook(arg1, this);
}
return super.dispatchEvent(arg1);
}
public function get tweeningProperties():Array
{
return this._tweeningProperties;
}
public function set tweeningProperties(arg1:Array):void
{
this._tweeningProperties = arg1;
return;
}
public function get cursorManager():mx.managers.ICursorManager
{
var loc2:*=null;
var loc1:*=this.parent;
while (loc1)
{
if (loc1 is mx.core.IUIComponent && "cursorManager" in loc1)
{
loc2 = loc1["cursorManager"];
return loc2;
}
loc1 = loc1.parent;
}
return mx.managers.CursorManager.getInstance();
}
public override function get mouseX():Number
{
if (!root || root is flash.display.Stage || root[fakeMouseX] === undefined)
{
return super.mouseX;
}
return globalToLocal(new flash.geom.Point(root[fakeMouseX], 0)).x;
}
public function get focusManager():mx.managers.IFocusManager
{
if (this._focusManager)
{
return this._focusManager;
}
var loc1:*=this.parent;
while (loc1)
{
if (loc1 is mx.managers.IFocusManagerContainer)
{
return mx.managers.IFocusManagerContainer(loc1).focusManager;
}
loc1 = loc1.parent;
}
return null;
}
public function set focusManager(arg1:mx.managers.IFocusManager):void
{
this._focusManager = arg1;
this.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.ADD_FOCUS_MANAGER));
return;
}
public override function get mouseY():Number
{
if (!root || root is flash.display.Stage || root[fakeMouseY] === undefined)
{
return super.mouseY;
}
return globalToLocal(new flash.geom.Point(0, root[fakeMouseY])).y;
}
protected function get resourceManager():mx.resources.IResourceManager
{
return this._resourceManager;
}
public function get styleManager():mx.styles.IStyleManager2
{
return mx.styles.StyleManager.getStyleManager(this.moduleFactory);
}
protected function initAdvancedLayoutFeatures():void
{
var loc1:*=new mx.core.AdvancedLayoutFeatures();
this._hasComplexLayoutMatrix = true;
loc1.layoutScaleX = this.scaleX;
loc1.layoutScaleY = this.scaleY;
loc1.layoutScaleZ = this.scaleZ;
loc1.layoutRotationX = this.rotationX;
loc1.layoutRotationY = this.rotationY;
loc1.layoutRotationZ = this.rotation;
loc1.layoutX = this.x;
loc1.layoutY = this.y;
loc1.layoutZ = this.z;
loc1.layoutWidth = this.width;
this.mx_internal::_layoutFeatures = loc1;
this.invalidateTransform();
return;
}
internal function setTransform(arg1:flash.geom.Transform):void
{
var loc1:*=this._transform as mx.geom.Transform;
if (loc1)
{
loc1.target = null;
}
var loc2:*=arg1 as mx.geom.Transform;
if (loc2)
{
loc2.target = this;
}
this._transform = arg1;
return;
}
public function get systemManager():mx.managers.ISystemManager
{
var loc1:*=null;
var loc2:*=null;
var loc3:*=null;
if (!this._systemManager || this._systemManagerDirty)
{
loc1 = root;
if (!(this._systemManager && this._systemManager.isProxy))
{
if (loc1 && !(loc1 is flash.display.Stage))
{
this._systemManager = loc1 as mx.managers.ISystemManager;
}
else if (loc1)
{
this._systemManager = flash.display.Stage(loc1).getChildAt(0) as mx.managers.ISystemManager;
}
else
{
loc2 = this.parent;
while (loc2)
{
loc3 = loc2 as mx.core.IUIComponent;
if (loc3)
{
this._systemManager = loc3.systemManager;
}
if (loc2 is mx.managers.ISystemManager)
{
this._systemManager = loc2 as mx.managers.ISystemManager;
}
loc2 = loc2.parent;
}
}
}
this._systemManagerDirty = false;
}
return this._systemManager;
}
public function set systemManager(arg1:mx.managers.ISystemManager):void
{
this._systemManager = arg1;
this._systemManagerDirty = false;
return;
}
mx_internal function getNonNullSystemManager():mx.managers.ISystemManager
{
var loc1:*=this.systemManager;
if (!loc1)
{
loc1 = mx.managers.ISystemManager(mx.managers.SystemManager.getSWFRoot(this));
}
if (!loc1)
{
return mx.managers.SystemManagerGlobals.topLevelSystemManagers[0];
}
return loc1;
}
protected function invalidateSystemManager():void
{
var loc4:*=null;
var loc1:*=this is mx.core.IRawChildrenContainer ? mx.core.IRawChildrenContainer(this).rawChildren : mx.core.IChildList(this);
var loc2:*=loc1.numChildren;
var loc3:*=0;
while (loc3 < loc2)
{
if (loc4 = loc1.getChildAt(loc3) as mx.core.UIComponent)
{
loc4.invalidateSystemManager();
}
++loc3;
}
this._systemManagerDirty = true;
return;
}
mx_internal function get $transform():flash.geom.Transform
{
return super.transform;
}
public function get nestLevel():int
{
return this._nestLevel;
}
public function set nestLevel(arg1:int):void
{
var loc1:*=null;
var loc2:*=0;
var loc3:*=0;
var loc4:*=null;
var loc5:*=null;
if (arg1 > 1 && !(this._nestLevel == arg1))
{
this._nestLevel = arg1;
this.mx_internal::updateCallbacks();
loc1 = this is mx.core.IRawChildrenContainer ? mx.core.IRawChildrenContainer(this).rawChildren : mx.core.IChildList(this);
loc2 = loc1.numChildren;
loc3 = 0;
while (loc3 < loc2)
{
if (loc4 = loc1.getChildAt(loc3) as mx.managers.ILayoutManagerClient)
{
loc4.nestLevel = arg1 + 1;
}
else if (loc5 = loc1.getChildAt(loc3) as mx.core.IUITextField)
{
loc5.nestLevel = arg1 + 1;
}
++loc3;
}
}
return;
}
public override function get transform():flash.geom.Transform
{
if (this._transform == null)
{
this.setTransform(new mx.geom.Transform(this));
}
return this._transform;
}
public function get descriptor():mx.core.UIComponentDescriptor
{
return this.mx_internal::_descriptor;
}
public function set descriptor(arg1:mx.core.UIComponentDescriptor):void
{
this.mx_internal::_descriptor = arg1;
return;
}
public override function set transform(arg1:flash.geom.Transform):void
{
var loc1:*=arg1.matrix;
var loc2:*=arg1.matrix3D;
var loc3:*=arg1.colorTransform;
var loc4:*=arg1.perspectiveProjection;
var loc5:*=this.is3D;
var loc6:*;
if (loc6 = arg1 as mx.geom.Transform)
{
if (!loc6.mx_internal::applyMatrix)
{
loc1 = null;
}
if (!loc6.mx_internal::applyMatrix3D)
{
loc2 = null;
}
}
this.setTransform(arg1);
if (loc1 == null)
{
if (loc2 != null)
{
this.setLayoutMatrix3D(loc2.clone(), true);
}
}
else
{
this.setLayoutMatrix(loc1.clone(), true);
}
super.transform.colorTransform = loc3;
super.transform.perspectiveProjection = loc4;
if (this.maintainProjectionCenter)
{
this.invalidateDisplayList();
}
if (loc5 != this.is3D)
{
this.validateMatrix();
}
return;
}
public function get document():Object
{
return this.mx_internal::_document;
}
public function set document(arg1:Object):void
{
var loc3:*=null;
var loc1:*=numChildren;
var loc2:*=0;
while (loc2 < loc1)
{
if (loc3 = getChildAt(loc2) as mx.core.IUIComponent)
{
if (loc3.document == this.mx_internal::_document || loc3.document == mx.core.FlexGlobals.topLevelApplication)
{
loc3.document = arg1;
}
}
++loc2;
}
this.mx_internal::_document = arg1;
return;
}
public function get postLayoutTransformOffsets():mx.geom.TransformOffsets
{
return this.mx_internal::_layoutFeatures == null ? null : this.mx_internal::_layoutFeatures.postLayoutTransformOffsets;
}
mx_internal function get documentDescriptor():mx.core.UIComponentDescriptor
{
return this.mx_internal::_documentDescriptor;
}
public function set postLayoutTransformOffsets(arg1:mx.geom.TransformOffsets):void
{
var loc1:*=this.is3D;
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
if (this.mx_internal::_layoutFeatures.postLayoutTransformOffsets != null)
{
this.mx_internal::_layoutFeatures.postLayoutTransformOffsets.removeEventListener(flash.events.Event.CHANGE, this.transformOffsetsChangedHandler);
}
this.mx_internal::_layoutFeatures.postLayoutTransformOffsets = arg1;
if (this.mx_internal::_layoutFeatures.postLayoutTransformOffsets != null)
{
this.mx_internal::_layoutFeatures.postLayoutTransformOffsets.addEventListener(flash.events.Event.CHANGE, this.transformOffsetsChangedHandler);
}
if (loc1 != this.is3D)
{
this.validateMatrix();
}
return;
}
public function get id():String
{
return this._id;
}
public function set id(arg1:String):void
{
this._id = arg1;
return;
}
public function get isDocument():Boolean
{
return this.document == this;
}
public function get parentApplication():Object
{
var loc2:*=null;
var loc1:*=this.systemManager.document;
if (loc1 == this)
{
loc2 = loc1.systemManager.parent as mx.core.UIComponent;
loc1 = loc2 ? loc2.systemManager.document : null;
}
return loc1;
}
public function get parentDocument():Object
{
var loc1:*=null;
var loc2:*=null;
if (this.document == this)
{
loc1 = this.parent as mx.core.IUIComponent;
if (loc1)
{
return loc1.document;
}
loc2 = this.parent as mx.managers.ISystemManager;
if (loc2)
{
return loc2.document;
}
return null;
}
return this.document;
}
public function get screen():flash.geom.Rectangle
{
var loc1:*=this.systemManager;
return loc1 ? loc1.screen : null;
}
public function set maintainProjectionCenter(arg1:Boolean):void
{
this._maintainProjectionCenter = arg1;
if (arg1 && super.transform.perspectiveProjection == null)
{
super.transform.perspectiveProjection = new flash.geom.PerspectiveProjection();
}
this.invalidateDisplayList();
return;
}
public function get moduleFactory():mx.core.IFlexModuleFactory
{
return this._moduleFactory;
}
public function set moduleFactory(arg1:mx.core.IFlexModuleFactory):void
{
var loc3:*=null;
var loc1:*=numChildren;
var loc2:*=0;
while (loc2 < loc1)
{
if (loc3 = getChildAt(loc2) as mx.core.IFlexModule)
{
if (loc3.moduleFactory == null || loc3.moduleFactory == this._moduleFactory)
{
loc3.moduleFactory = arg1;
}
}
++loc2;
}
this._moduleFactory = arg1;
this.setDeferredStyles();
return;
}
public function get maintainProjectionCenter():Boolean
{
return this._maintainProjectionCenter;
}
public function get inheritingStyles():Object
{
return this._inheritingStyles;
}
public function set inheritingStyles(arg1:Object):void
{
this._inheritingStyles = arg1;
return;
}
public function setLayoutMatrix(arg1:flash.geom.Matrix, arg2:Boolean):void
{
var loc1:*=this.mx_internal::_layoutFeatures ? this.mx_internal::_layoutFeatures.layoutMatrix : super.transform.matrix;
var loc2:*=this.is3D;
this._hasComplexLayoutMatrix = true;
if (this.mx_internal::_layoutFeatures != null)
{
this.mx_internal::_layoutFeatures.layoutMatrix = arg1;
this.invalidateTransform();
}
else
{
super.transform.matrix = arg1;
}
if (mx.utils.MatrixUtil.isEqual(loc1, this.mx_internal::_layoutFeatures ? this.mx_internal::_layoutFeatures.layoutMatrix : super.transform.matrix))
{
return;
}
this.invalidateProperties();
if (arg2)
{
this.invalidateParentSizeAndDisplayList();
}
if (loc2 != this.is3D)
{
this.validateMatrix();
}
return;
}
public function get nonInheritingStyles():Object
{
return this._nonInheritingStyles;
}
public function set nonInheritingStyles(arg1:Object):void
{
this._nonInheritingStyles = arg1;
return;
}
public function setLayoutMatrix3D(arg1:flash.geom.Matrix3D, arg2:Boolean):void
{
if (this.mx_internal::_layoutFeatures && mx.utils.MatrixUtil.isEqual3D(this.mx_internal::_layoutFeatures.layoutMatrix3D, arg1))
{
return;
}
var loc1:*=this.is3D;
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
this.mx_internal::_layoutFeatures.layoutMatrix3D = arg1;
this.invalidateTransform();
this.invalidateProperties();
if (arg2)
{
this.invalidateParentSizeAndDisplayList();
}
if (loc1 != this.is3D)
{
this.validateMatrix();
}
return;
}
public function get styleDeclaration():mx.styles.CSSStyleDeclaration
{
return this._styleDeclaration;
}
public function set styleDeclaration(arg1:mx.styles.CSSStyleDeclaration):void
{
this._styleDeclaration = arg1;
return;
}
public function transformAround(arg1:flash.geom.Vector3D, arg2:flash.geom.Vector3D=null, arg3:flash.geom.Vector3D=null, arg4:flash.geom.Vector3D=null, arg5:flash.geom.Vector3D=null, arg6:flash.geom.Vector3D=null, arg7:flash.geom.Vector3D=null, arg8:Boolean=true):void
{
var loc1:*=false;
var loc2:*=false;
var loc3:*=NaN;
var loc4:*=NaN;
var loc5:*=NaN;
var loc6:*=null;
var loc7:*=null;
if (!arg8)
{
loc1 = this._includeInLayout;
this._includeInLayout = false;
}
if (this.mx_internal::_layoutFeatures == null)
{
if (loc2 = !(arg2 == null) && (!isNaN(arg2.x) && !(arg2.x == 1) || !isNaN(arg2.y) && !(arg2.y == 1) || !isNaN(arg2.z) && !(arg2.z == 1)) || !(arg3 == null) && (!isNaN(arg3.x) && !(arg3.x == 0) || !isNaN(arg3.y) && !(arg3.y == 0) || !isNaN(arg3.z) && !(arg3.z == 0)) || !(arg4 == null) && !(arg4.z == 0) && !isNaN(arg4.z) || !(arg5 == null) || !(arg6 == null) || !(arg7 == null) && (arg4 == null || !(arg7.x == arg4.x) || !(arg7.y == arg4.y) || !(arg7.z == arg4.z)))
{
this.initAdvancedLayoutFeatures();
}
}
if (this.mx_internal::_layoutFeatures == null)
{
if (arg4 == null && !(arg1 == null))
{
if (xformPt == null)
{
xformPt = new flash.geom.Point();
}
xformPt.x = arg1.x;
xformPt.y = arg1.y;
loc6 = this.transform.matrix.transformPoint(xformPt);
}
if (!(arg3 == null) && !isNaN(arg3.z))
{
this.rotation = arg3.z;
}
if (arg2 != null)
{
this.scaleX = arg2.x;
this.scaleY = arg2.y;
}
if (arg1 != null)
{
if (xformPt == null)
{
xformPt = new flash.geom.Point();
}
xformPt.x = arg1.x;
xformPt.y = arg1.y;
loc7 = this.transform.matrix.transformPoint(xformPt);
if (arg4 == null)
{
this.x = this.x + (loc6.x - loc7.x);
this.y = this.y + (loc6.y - loc7.y);
}
else
{
this.x = this.x + (arg4.x - loc7.x);
this.y = this.y + (arg4.y - loc7.y);
}
}
else if (arg4 != null)
{
this.x = arg4.x;
this.y = arg4.y;
}
}
else
{
loc3 = this.mx_internal::_layoutFeatures.layoutX;
loc4 = this.mx_internal::_layoutFeatures.layoutY;
loc5 = this.mx_internal::_layoutFeatures.layoutZ;
this.mx_internal::_layoutFeatures.transformAround(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
this.invalidateTransform();
this.invalidateParentSizeAndDisplayList();
if (loc3 != this.mx_internal::_layoutFeatures.layoutX)
{
this.dispatchEvent(new flash.events.Event("xChanged"));
}
if (loc4 != this.mx_internal::_layoutFeatures.layoutY)
{
this.dispatchEvent(new flash.events.Event("yChanged"));
}
if (loc5 != this.mx_internal::_layoutFeatures.layoutZ)
{
this.dispatchEvent(new flash.events.Event("zChanged"));
}
}
if (!arg8)
{
this._includeInLayout = loc1;
}
return;
}
public function get cachePolicy():String
{
return this._cachePolicy;
}
public function set cachePolicy(arg1:String):void
{
if (this._cachePolicy != arg1)
{
this._cachePolicy = arg1;
if (arg1 != mx.core.UIComponentCachePolicy.OFF)
{
if (arg1 != mx.core.UIComponentCachePolicy.ON)
{
this.cacheAsBitmap = this.cacheAsBitmapCount > 0;
}
else
{
this.cacheAsBitmap = true;
}
}
else
{
this.cacheAsBitmap = false;
}
}
return;
}
public function transformPointToParent(arg1:flash.geom.Vector3D, arg2:flash.geom.Vector3D, arg3:flash.geom.Vector3D):void
{
var loc1:*=null;
if (this.mx_internal::_layoutFeatures == null)
{
if (xformPt == null)
{
xformPt = new flash.geom.Point();
}
if (arg1)
{
xformPt.x = arg1.x;
xformPt.y = arg1.y;
}
else
{
xformPt.x = 0;
xformPt.y = 0;
}
loc1 = this.transform.matrix == null ? xformPt : this.transform.matrix.transformPoint(xformPt);
if (arg2 != null)
{
arg2.x = loc1.x;
arg2.y = loc1.y;
arg2.z = 0;
}
if (arg3 != null)
{
arg3.x = loc1.x;
arg3.y = loc1.y;
arg3.z = 0;
}
}
else
{
this.mx_internal::_layoutFeatures.transformPointToParent(true, arg1, arg2, arg3);
}
return;
}
public function set cacheHeuristic(arg1:Boolean):void
{
if (this._cachePolicy == mx.core.UIComponentCachePolicy.AUTO)
{
if (arg1)
{
var loc1:*;
var loc2:*=((loc1 = this).cacheAsBitmapCount + 1);
loc1.cacheAsBitmapCount = loc2;
}
else if (this.cacheAsBitmapCount != 0)
{
loc2 = ((loc1 = this).cacheAsBitmapCount - 1);
loc1.cacheAsBitmapCount = loc2;
}
super.cacheAsBitmap = !(this.cacheAsBitmapCount == 0);
}
return;
}
public function set layoutMatrix3D(arg1:flash.geom.Matrix3D):void
{
this.setLayoutMatrix3D(arg1, true);
return;
}
public function get focusPane():flash.display.Sprite
{
return this._focusPane;
}
public function set focusPane(arg1:flash.display.Sprite):void
{
if (arg1)
{
this.addChild(arg1);
arg1.x = 0;
arg1.y = 0;
arg1.scrollRect = null;
this._focusPane = arg1;
}
else
{
this.removeChild(this._focusPane);
this._focusPane.mask = null;
this._focusPane = null;
}
return;
}
public function get depth():Number
{
return this.mx_internal::_layoutFeatures != null ? this.mx_internal::_layoutFeatures.depth : 0;
}
public function get focusEnabled():Boolean
{
return this._focusEnabled;
}
public function set focusEnabled(arg1:Boolean):void
{
this._focusEnabled = arg1;
return;
}
public function set depth(arg1:Number):void
{
if (arg1 == this.depth)
{
return;
}
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
this.mx_internal::_layoutFeatures.depth = arg1;
if (this.parent is mx.core.UIComponent)
{
mx.core.UIComponent(this.parent).invalidateLayering();
}
return;
}
public function get hasFocusableChildren():Boolean
{
return this._hasFocusableChildren;
}
public function set hasFocusableChildren(arg1:Boolean):void
{
if (arg1 != this._hasFocusableChildren)
{
this._hasFocusableChildren = arg1;
this.dispatchEvent(new flash.events.Event("hasFocusableChildrenChange"));
}
return;
}
public function invalidateLayering():void
{
return;
}
public function get mouseFocusEnabled():Boolean
{
return this._mouseFocusEnabled;
}
public function set mouseFocusEnabled(arg1:Boolean):void
{
this._mouseFocusEnabled = arg1;
return;
}
protected function applyComputedMatrix():void
{
this.mx_internal::_layoutFeatures.updatePending = false;
if (this.mx_internal::_layoutFeatures.is3D)
{
super.transform.matrix3D = this.mx_internal::_layoutFeatures.computedMatrix3D;
}
else
{
super.transform.matrix = this.mx_internal::_layoutFeatures.computedMatrix;
}
return;
}
public function get tabFocusEnabled():Boolean
{
return this._tabFocusEnabled;
}
public function set tabFocusEnabled(arg1:Boolean):void
{
if (arg1 != this._tabFocusEnabled)
{
this._tabFocusEnabled = arg1;
this.dispatchEvent(new flash.events.Event("tabFocusEnabledChange"));
}
return;
}
mx_internal function get computedMatrix():flash.geom.Matrix
{
return this.mx_internal::_layoutFeatures ? this.mx_internal::_layoutFeatures.computedMatrix : this.transform.matrix;
}
public function get measuredMinWidth():Number
{
return this._measuredMinWidth;
}
public function set measuredMinWidth(arg1:Number):void
{
this._measuredMinWidth = arg1;
return;
}
protected function setStretchXY(arg1:Number, arg2:Number):void
{
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
if (!(arg1 == this.mx_internal::_layoutFeatures.stretchX) || !(arg2 == this.mx_internal::_layoutFeatures.stretchY))
{
this.mx_internal::_layoutFeatures.stretchX = arg1;
this.mx_internal::_layoutFeatures.stretchY = arg2;
this.invalidateTransform();
}
return;
}
public function get measuredMinHeight():Number
{
return this._measuredMinHeight;
}
public function set measuredMinHeight(arg1:Number):void
{
this._measuredMinHeight = arg1;
return;
}
public function getPreferredBoundsWidth(arg1:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getPreferredBoundsWidth(this, arg1 ? this.nonDeltaLayoutMatrix() : null);
}
public function get measuredWidth():Number
{
return this._measuredWidth;
}
public function set measuredWidth(arg1:Number):void
{
this._measuredWidth = arg1;
return;
}
public function getPreferredBoundsHeight(arg1:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getPreferredBoundsHeight(this, arg1 ? this.nonDeltaLayoutMatrix() : null);
}
public function get measuredHeight():Number
{
return this._measuredHeight;
}
public function set measuredHeight(arg1:Number):void
{
this._measuredHeight = arg1;
return;
}
public function callLater(arg1:Function, arg2:Array=null):void
{
this.methodQueue.push(new MethodQueueElement(arg1, arg2));
var loc1:*=this.systemManager;
if (loc1 && (loc1.stage || this.usingBridge))
{
if (!this.listeningForRender)
{
loc1.addEventListener(mx.events.FlexEvent.RENDER, this.callLaterDispatcher);
loc1.addEventListener(mx.events.FlexEvent.ENTER_FRAME, this.callLaterDispatcher);
this.listeningForRender = true;
}
if (loc1.stage)
{
loc1.stage.invalidate();
}
}
return;
}
public function get percentWidth():Number
{
return this._percentWidth;
}
public function set percentWidth(arg1:Number):void
{
if (this._percentWidth == arg1)
{
return;
}
if (!isNaN(arg1))
{
this._explicitWidth = NaN;
}
this._percentWidth = arg1;
this.invalidateParentSizeAndDisplayList();
return;
}
public function getMinBoundsWidth(arg1:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getMinBoundsWidth(this, arg1 ? this.nonDeltaLayoutMatrix() : null);
}
public function get percentHeight():Number
{
return this._percentHeight;
}
public function set percentHeight(arg1:Number):void
{
if (this._percentHeight == arg1)
{
return;
}
if (!isNaN(arg1))
{
this._explicitHeight = NaN;
}
this._percentHeight = arg1;
this.invalidateParentSizeAndDisplayList();
return;
}
public function get minWidth():Number
{
if (!isNaN(this.explicitMinWidth))
{
return this.explicitMinWidth;
}
return this.measuredMinWidth;
}
public function set minWidth(arg1:Number):void
{
if (this.explicitMinWidth == arg1)
{
return;
}
this.explicitMinWidth = arg1;
return;
}
public function get minHeight():Number
{
if (!isNaN(this.explicitMinHeight))
{
return this.explicitMinHeight;
}
return this.measuredMinHeight;
}
public function set minHeight(arg1:Number):void
{
if (this.explicitMinHeight == arg1)
{
return;
}
this.explicitMinHeight = arg1;
return;
}
public function get maxWidth():Number
{
return isNaN(this.explicitMaxWidth) ? DEFAULT_MAX_WIDTH : this.explicitMaxWidth;
}
public function set maxWidth(arg1:Number):void
{
if (this.explicitMaxWidth == arg1)
{
return;
}
this.explicitMaxWidth = arg1;
return;
}
public function get maxHeight():Number
{
return isNaN(this.explicitMaxHeight) ? DEFAULT_MAX_HEIGHT : this.explicitMaxHeight;
}
public function set maxHeight(arg1:Number):void
{
if (this.explicitMaxHeight == arg1)
{
return;
}
this.explicitMaxHeight = arg1;
return;
}
public function getMinBoundsHeight(arg1:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getMinBoundsHeight(this, arg1 ? this.nonDeltaLayoutMatrix() : null);
}
public function get explicitMinWidth():Number
{
return this.mx_internal::_explicitMinWidth;
}
public function set explicitMinWidth(arg1:Number):void
{
if (this.mx_internal::_explicitMinWidth == arg1)
{
return;
}
this.mx_internal::_explicitMinWidth = arg1;
this.invalidateSize();
this.invalidateParentSizeAndDisplayList();
this.dispatchEvent(new flash.events.Event("explicitMinWidthChanged"));
return;
}
public function getMaxBoundsWidth(arg1:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getMaxBoundsWidth(this, arg1 ? this.nonDeltaLayoutMatrix() : null);
}
public function get explicitMinHeight():Number
{
return this.mx_internal::_explicitMinHeight;
}
public function set explicitMinHeight(arg1:Number):void
{
if (this.mx_internal::_explicitMinHeight == arg1)
{
return;
}
this.mx_internal::_explicitMinHeight = arg1;
this.invalidateSize();
this.invalidateParentSizeAndDisplayList();
this.dispatchEvent(new flash.events.Event("explicitMinHeightChanged"));
return;
}
public function getMaxBoundsHeight(arg1:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getMaxBoundsHeight(this, arg1 ? this.nonDeltaLayoutMatrix() : null);
}
public function get explicitMaxWidth():Number
{
return this.mx_internal::_explicitMaxWidth;
}
public function set explicitMaxWidth(arg1:Number):void
{
if (this.mx_internal::_explicitMaxWidth == arg1)
{
return;
}
this.mx_internal::_explicitMaxWidth = arg1;
this.invalidateSize();
this.invalidateParentSizeAndDisplayList();
this.dispatchEvent(new flash.events.Event("explicitMaxWidthChanged"));
return;
}
public function getBoundsXAtSize(arg1:Number, arg2:Number, arg3:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getBoundsXAtSize(this, arg1, arg2, arg3 ? this.nonDeltaLayoutMatrix() : null);
}
public function get explicitMaxHeight():Number
{
return this.mx_internal::_explicitMaxHeight;
}
public function set explicitMaxHeight(arg1:Number):void
{
if (this.mx_internal::_explicitMaxHeight == arg1)
{
return;
}
this.mx_internal::_explicitMaxHeight = arg1;
this.invalidateSize();
this.invalidateParentSizeAndDisplayList();
this.dispatchEvent(new flash.events.Event("explicitMaxHeightChanged"));
return;
}
public function getBoundsYAtSize(arg1:Number, arg2:Number, arg3:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getBoundsYAtSize(this, arg1, arg2, arg3 ? this.nonDeltaLayoutMatrix() : null);
}
public function get explicitWidth():Number
{
return this._explicitWidth;
}
public function set explicitWidth(arg1:Number):void
{
if (this._explicitWidth == arg1)
{
return;
}
if (!isNaN(arg1))
{
this._percentWidth = NaN;
}
this._explicitWidth = arg1;
this.invalidateSize();
this.invalidateParentSizeAndDisplayList();
this.dispatchEvent(new flash.events.Event("explicitWidthChanged"));
return;
}
public function getLayoutBoundsWidth(arg1:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getLayoutBoundsWidth(this, arg1 ? this.nonDeltaLayoutMatrix() : null);
}
public function get explicitHeight():Number
{
return this._explicitHeight;
}
public function set explicitHeight(arg1:Number):void
{
if (this._explicitHeight == arg1)
{
return;
}
if (!isNaN(arg1))
{
this._percentHeight = NaN;
}
this._explicitHeight = arg1;
this.invalidateSize();
this.invalidateParentSizeAndDisplayList();
this.dispatchEvent(new flash.events.Event("explicitHeightChanged"));
return;
}
public function getLayoutBoundsHeight(arg1:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getLayoutBoundsHeight(this, arg1 ? this.nonDeltaLayoutMatrix() : null);
}
protected function get hasComplexLayoutMatrix():Boolean
{
if (!this._hasComplexLayoutMatrix)
{
return false;
}
if (this.mx_internal::_layoutFeatures == null)
{
this._hasComplexLayoutMatrix = !mx.utils.MatrixUtil.isDeltaIdentity(super.transform.matrix);
return this._hasComplexLayoutMatrix;
}
return !mx.utils.MatrixUtil.isDeltaIdentity(this.mx_internal::_layoutFeatures.layoutMatrix);
}
public function getLayoutBoundsX(arg1:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getLayoutBoundsX(this, arg1 ? this.nonDeltaLayoutMatrix() : null);
}
public function get includeInLayout():Boolean
{
return this._includeInLayout;
}
public function set includeInLayout(arg1:Boolean):void
{
var loc1:*=null;
if (this._includeInLayout != arg1)
{
this._includeInLayout = arg1;
loc1 = this.parent as mx.core.IInvalidating;
if (loc1)
{
loc1.invalidateSize();
loc1.invalidateDisplayList();
}
this.dispatchEvent(new flash.events.Event("includeInLayoutChanged"));
}
return;
}
public function getLayoutBoundsY(arg1:Boolean=true):Number
{
return mx.core.LayoutElementUIComponentUtils.getLayoutBoundsY(this, arg1 ? this.nonDeltaLayoutMatrix() : null);
}
public function get layoutDirection():String
{
return this.getStyle("layoutDirection");
}
public function set layoutDirection(arg1:String):void
{
if (arg1 != null)
{
this.setStyle("layoutDirection", arg1);
}
else
{
this.setStyle("layoutDirection", undefined);
}
return;
}
public function get instanceIndex():int
{
return this._instanceIndices ? this._instanceIndices[(this._instanceIndices.length - 1)] : -1;
}
public function setLayoutBoundsPosition(arg1:Number, arg2:Number, arg3:Boolean=true):void
{
mx.core.LayoutElementUIComponentUtils.setLayoutBoundsPosition(this, arg1, arg2, arg3 ? this.nonDeltaLayoutMatrix() : null);
return;
}
public function get instanceIndices():Array
{
return this._instanceIndices ? this._instanceIndices.slice(0) : null;
}
public function set instanceIndices(arg1:Array):void
{
this._instanceIndices = arg1;
return;
}
public function get repeater():mx.core.IRepeater
{
return this._repeaters ? this._repeaters[(this._repeaters.length - 1)] : null;
}
public function setLayoutBoundsSize(arg1:Number, arg2:Number, arg3:Boolean=true):void
{
mx.core.LayoutElementUIComponentUtils.setLayoutBoundsSize(this, arg1, arg2, arg3 ? this.nonDeltaLayoutMatrix() : null);
return;
}
public function get repeaters():Array
{
return this._repeaters ? this._repeaters.slice(0) : [];
}
public function set repeaters(arg1:Array):void
{
this._repeaters = arg1;
return;
}
public function get repeaterIndex():int
{
return this._repeaterIndices ? this._repeaterIndices[(this._repeaterIndices.length - 1)] : -1;
}
public function getLayoutMatrix():flash.geom.Matrix
{
if (!(this.mx_internal::_layoutFeatures == null) || super.transform.matrix == null)
{
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
return this.mx_internal::_layoutFeatures.layoutMatrix.clone();
}
return super.transform.matrix;
}
public function get repeaterIndices():Array
{
return this._repeaterIndices ? this._repeaterIndices.slice() : [];
}
public function set repeaterIndices(arg1:Array):void
{
this._repeaterIndices = arg1;
return;
}
public function get hasLayoutMatrix3D():Boolean
{
return this.mx_internal::_layoutFeatures ? this.mx_internal::_layoutFeatures.layoutIs3D : false;
}
public function get is3D():Boolean
{
return this.mx_internal::_layoutFeatures ? this.mx_internal::_layoutFeatures.is3D : false;
}
public function getLayoutMatrix3D():flash.geom.Matrix3D
{
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
return this.mx_internal::_layoutFeatures.layoutMatrix3D.clone();
}
protected function nonDeltaLayoutMatrix():flash.geom.Matrix
{
if (!this.hasComplexLayoutMatrix)
{
return null;
}
if (this.mx_internal::_layoutFeatures != null)
{
return this.mx_internal::_layoutFeatures.layoutMatrix;
}
return super.transform.matrix;
}
public function get currentState():String
{
return this._currentStateChanged ? this.requestedCurrentState : this._currentState;
}
public function set currentState(arg1:String):void
{
this.setCurrentState(arg1, true);
return;
}
mx_internal static function get embeddedFontRegistry():mx.core.IEmbeddedFontRegistry
{
var loc1:*;
if (!_embeddedFontRegistry && !noEmbeddedFonts)
{
try
{
_embeddedFontRegistry = mx.core.IEmbeddedFontRegistry(mx.core.Singleton.getInstance("mx.core::IEmbeddedFontRegistry"));
}
catch (e:Error)
{
noEmbeddedFonts = true;
}
}
return _embeddedFontRegistry;
}
mx_internal function get currentStateDeferred():String
{
return this._currentStateDeferred == null ? this.currentState : this._currentStateDeferred;
}
mx_internal function set currentStateDeferred(arg1:String):void
{
this._currentStateDeferred = arg1;
if (arg1 != null)
{
this.invalidateProperties();
}
return;
}
public static function suspendBackgroundProcessing():void
{
var loc1:*;
var loc2:*=((loc1 = mx.core.UIComponentGlobals).mx_internal::callLaterSuspendCount + 1);
loc1.mx_internal::callLaterSuspendCount = loc2;
return;
}
public function get states():Array
{
return this._states;
}
public function set states(arg1:Array):void
{
this._states = arg1;
return;
}
public static function resumeBackgroundProcessing():void
{
var loc1:*=null;
if (mx.core.UIComponentGlobals.mx_internal::callLaterSuspendCount > 0)
{
var loc2:*;
var loc3:*=((loc2 = mx.core.UIComponentGlobals).mx_internal::callLaterSuspendCount - 1);
loc2.mx_internal::callLaterSuspendCount = loc3;
if (mx.core.UIComponentGlobals.mx_internal::callLaterSuspendCount == 0)
{
loc1 = mx.managers.SystemManagerGlobals.topLevelSystemManagers[0];
if (loc1 && loc1.stage)
{
loc1.stage.invalidate();
}
}
}
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
compositeEffectLoaded = false;
fakeMouseX = new QName(mx.core.mx_internal, "_mouseX");
fakeMouseY = new QName(mx.core.mx_internal, "_mouseY");
}
public function get transitions():Array
{
return this._transitions;
}
public function set transitions(arg1:Array):void
{
this._transitions = arg1;
return;
}
public function get baselinePosition():Number
{
if (!this.mx_internal::validateBaselinePosition())
{
return NaN;
}
var loc1:*=this.measureText("Wj");
if (this.height < 2 + loc1.ascent + 2)
{
return int(this.height + (loc1.ascent - this.height) / 2);
}
return 2 + loc1.ascent;
}
public function get className():String
{
return mx.utils.NameUtil.getUnqualifiedClassName(this);
}
public function get activeEffects():Array
{
return this.mx_internal::_effectsStarted;
}
public function getAutomationChildren():Array
{
if (this.automationDelegate)
{
return this.automationDelegate.getAutomationChildren();
}
return null;
}
public function get flexContextMenu():mx.controls.IFlexContextMenu
{
return this._flexContextMenu;
}
public function set flexContextMenu(arg1:mx.controls.IFlexContextMenu):void
{
if (this._flexContextMenu)
{
this._flexContextMenu.unsetContextMenu(this);
}
this._flexContextMenu = arg1;
if (arg1 != null)
{
this._flexContextMenu.setContextMenu(this);
}
return;
}
public function get styleName():Object
{
return this._styleName;
}
public function set styleName(arg1:Object):void
{
if (this._styleName === arg1)
{
return;
}
this._styleName = arg1;
if (this.inheritingStyles == mx.styles.StyleProtoChain.STYLE_UNINITIALIZED)
{
return;
}
this.regenerateStyleCache(true);
this.mx_internal::initThemeColor();
this.styleChanged("styleName");
this.notifyStyleChangeInChildren("styleName", true);
return;
}
public function get toolTip():String
{
return this.mx_internal::_toolTip;
}
public function set toolTip(arg1:String):void
{
var loc1:*=this.mx_internal::_toolTip;
this.mx_internal::_toolTip = arg1;
mx.managers.ToolTipManager.mx_internal::registerToolTip(this, loc1, arg1);
this.dispatchEvent(new flash.events.Event("toolTipChanged"));
return;
}
public function get uid():String
{
if (!this._uid)
{
this._uid = toString();
}
return this._uid;
}
public function set uid(arg1:String):void
{
this._uid = arg1;
return;
}
internal function get indexedID():String
{
var loc1:*=this.id;
var loc2:*=this.instanceIndices;
if (loc2)
{
loc1 = loc1 + ("[" + loc2.join("][") + "]");
}
return loc1;
}
public function get isPopUp():Boolean
{
return this._isPopUp;
}
public function set isPopUp(arg1:Boolean):void
{
this._isPopUp = arg1;
return;
}
public function get automationDelegate():Object
{
return this._automationDelegate;
}
public function set automationDelegate(arg1:Object):void
{
this._automationDelegate = arg1 as mx.automation.IAutomationObject;
return;
}
public function get automationName():String
{
if (this._automationName)
{
return this._automationName;
}
if (this.automationDelegate)
{
return this.automationDelegate.automationName;
}
return "";
}
public function set automationName(arg1:String):void
{
this._automationName = arg1;
return;
}
public function get automationValue():Array
{
if (this.automationDelegate)
{
return this.automationDelegate.automationValue;
}
return [];
}
public function get showInAutomationHierarchy():Boolean
{
return this._showInAutomationHierarchy;
}
public function set showInAutomationHierarchy(arg1:Boolean):void
{
this._showInAutomationHierarchy = arg1;
return;
}
public function get errorString():String
{
return this.mx_internal::_errorString;
}
public function set errorString(arg1:String):void
{
var loc1:*=this.mx_internal::_errorString;
this.mx_internal::_errorString = arg1;
mx.managers.ToolTipManager.mx_internal::registerErrorString(this, loc1, arg1);
this.errorStringChanged = true;
this.invalidateProperties();
this.dispatchEvent(new flash.events.Event("errorStringChanged"));
return;
}
internal function setBorderColorForErrorString():void
{
if (!this.mx_internal::_errorString || this.mx_internal::_errorString.length == 0)
{
if (!isNaN(this.mx_internal::origBorderColor))
{
this.setStyle("borderColor", this.mx_internal::origBorderColor);
this.mx_internal::saveBorderColor = true;
}
}
else
{
if (this.mx_internal::saveBorderColor)
{
this.mx_internal::saveBorderColor = false;
this.mx_internal::origBorderColor = this.getStyle("borderColor");
}
this.setStyle("borderColor", this.getStyle("errorColor"));
}
this.styleChanged("themeColor");
var loc1:*=this.focusManager;
var loc2:*=loc1 ? flash.display.DisplayObject(loc1.getFocus()) : null;
if (loc1 && loc1.showFocusIndicator && loc2 == this)
{
this.drawFocus(true);
}
return;
}
public function get validationSubField():String
{
return this._validationSubField;
}
public function set validationSubField(arg1:String):void
{
this._validationSubField = arg1;
return;
}
public override function addChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject
{
var loc1:*=arg1.parent;
if (loc1 && !(loc1 is flash.display.Loader))
{
loc1.removeChild(arg1);
}
var loc2:*=this.mx_internal::effectOverlayReferenceCount && !(arg1 == this.mx_internal::effectOverlay) ? Math.max(0, (super.numChildren - 1)) : super.numChildren;
this.mx_internal::addingChild(arg1);
this.mx_internal::$addChildAt(arg1, loc2);
this.mx_internal::childAdded(arg1);
return arg1;
}
public override function addChildAt(arg1:flash.display.DisplayObject, arg2:int):flash.display.DisplayObject
{
var loc1:*=arg1.parent;
if (loc1 && !(loc1 is flash.display.Loader))
{
loc1.removeChild(arg1);
}
if (this.mx_internal::effectOverlayReferenceCount && !(arg1 == this.mx_internal::effectOverlay))
{
arg2 = Math.min(arg2, Math.max(0, (super.numChildren - 1)));
}
this.mx_internal::addingChild(arg1);
this.mx_internal::$addChildAt(arg1, arg2);
this.mx_internal::childAdded(arg1);
return arg1;
}
public override function removeChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject
{
this.mx_internal::removingChild(arg1);
this.mx_internal::$removeChild(arg1);
this.mx_internal::childRemoved(arg1);
return arg1;
}
public override function removeChildAt(arg1:int):flash.display.DisplayObject
{
var loc1:*=getChildAt(arg1);
this.mx_internal::removingChild(loc1);
this.mx_internal::$removeChild(loc1);
this.mx_internal::childRemoved(loc1);
return loc1;
}
public override function setChildIndex(arg1:flash.display.DisplayObject, arg2:int):void
{
if (this.mx_internal::effectOverlayReferenceCount && !(arg1 == this.mx_internal::effectOverlay))
{
arg2 = Math.min(arg2, Math.max(0, super.numChildren - 2));
}
super.setChildIndex(arg1, arg2);
return;
}
public override function stopDrag():void
{
super.stopDrag();
this.invalidateProperties();
this.dispatchEvent(new flash.events.Event("xChanged"));
this.dispatchEvent(new flash.events.Event("yChanged"));
return;
}
mx_internal final function $addChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject
{
return super.addChild(arg1);
}
mx_internal final function $addChildAt(arg1:flash.display.DisplayObject, arg2:int):flash.display.DisplayObject
{
return super.addChildAt(arg1, arg2);
}
mx_internal final function $removeChild(arg1:flash.display.DisplayObject):flash.display.DisplayObject
{
return super.removeChild(arg1);
}
mx_internal final function $removeChildAt(arg1:int):flash.display.DisplayObject
{
return super.removeChildAt(arg1);
}
mx_internal final function $setChildIndex(arg1:flash.display.DisplayObject, arg2:int):void
{
super.setChildIndex(arg1, arg2);
return;
}
mx_internal function updateCallbacks():void
{
if (this.mx_internal::invalidateDisplayListFlag)
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.invalidateDisplayList(this);
}
if (this.mx_internal::invalidateSizeFlag)
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.invalidateSize(this);
}
if (this.mx_internal::invalidatePropertiesFlag)
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.invalidateProperties(this);
}
if (this.systemManager && (this._systemManager.stage || this.usingBridge))
{
if (this.methodQueue.length > 0 && !this.listeningForRender)
{
this._systemManager.addEventListener(mx.events.FlexEvent.RENDER, this.callLaterDispatcher);
this._systemManager.addEventListener(mx.events.FlexEvent.ENTER_FRAME, this.callLaterDispatcher);
this.listeningForRender = true;
}
if (this._systemManager.stage)
{
this._systemManager.stage.invalidate();
}
}
return;
}
public function parentChanged(arg1:flash.display.DisplayObjectContainer):void
{
if (arg1)
{
if (arg1 is mx.styles.IStyleClient)
{
this.mx_internal::_parent = arg1;
}
else if (arg1 is mx.managers.ISystemManager)
{
this.mx_internal::_parent = arg1;
}
else
{
this.mx_internal::_parent = arg1.parent;
}
}
else
{
this.mx_internal::_parent = null;
this._nestLevel = 0;
}
this.parentChangedFlag = true;
return;
}
mx_internal function addingChild(arg1:flash.display.DisplayObject):void
{
if (arg1 is mx.core.IUIComponent && !mx.core.IUIComponent(arg1).document)
{
mx.core.IUIComponent(arg1).document = this.document ? this.document : mx.core.FlexGlobals.topLevelApplication;
}
if (arg1 is mx.core.IFlexModule && mx.core.IFlexModule(arg1).moduleFactory == null)
{
if (this.moduleFactory == null)
{
if (this.document is mx.core.IFlexModule && !(this.document.moduleFactory == null))
{
mx.core.IFlexModule(arg1).moduleFactory = this.document.moduleFactory;
}
else if (this.parent is mx.core.IFlexModule && !(mx.core.IFlexModule(this.parent).moduleFactory == null))
{
mx.core.IFlexModule(arg1).moduleFactory = mx.core.IFlexModule(this.parent).moduleFactory;
}
}
else
{
mx.core.IFlexModule(arg1).moduleFactory = this.moduleFactory;
}
}
if (arg1 is mx.core.IFontContextComponent && !arg1 is mx.core.UIComponent && mx.core.IFontContextComponent(arg1).fontContext == null)
{
mx.core.IFontContextComponent(arg1).fontContext = this.moduleFactory;
}
if (arg1 is mx.core.IUIComponent)
{
mx.core.IUIComponent(arg1).parentChanged(this);
}
if (arg1 is mx.managers.ILayoutManagerClient)
{
mx.managers.ILayoutManagerClient(arg1).nestLevel = this.nestLevel + 1;
}
else if (arg1 is mx.core.IUITextField)
{
mx.core.IUITextField(arg1).nestLevel = this.nestLevel + 1;
}
if (arg1 is flash.display.InteractiveObject)
{
if (this.doubleClickEnabled)
{
flash.display.InteractiveObject(arg1).doubleClickEnabled = true;
}
}
if (arg1 is mx.styles.IStyleClient)
{
mx.styles.IStyleClient(arg1).regenerateStyleCache(true);
}
else if (arg1 is mx.core.IUITextField && mx.core.IUITextField(arg1).inheritingStyles)
{
mx.styles.StyleProtoChain.initTextField(mx.core.IUITextField(arg1));
}
if (arg1 is mx.styles.ISimpleStyleClient)
{
mx.styles.ISimpleStyleClient(arg1).styleChanged(null);
}
if (arg1 is mx.styles.IStyleClient)
{
mx.styles.IStyleClient(arg1).notifyStyleChangeInChildren(null, true);
}
if (arg1 is mx.core.UIComponent)
{
mx.core.UIComponent(arg1).mx_internal::initThemeColor();
}
if (arg1 is mx.core.UIComponent)
{
mx.core.UIComponent(arg1).stylesInitialized();
}
return;
}
mx_internal function childAdded(arg1:flash.display.DisplayObject):void
{
if (arg1 is mx.core.UIComponent)
{
if (!mx.core.UIComponent(arg1).initialized)
{
mx.core.UIComponent(arg1).initialize();
}
}
else if (arg1 is mx.core.IUIComponent)
{
mx.core.IUIComponent(arg1).initialize();
}
return;
}
mx_internal function removingChild(arg1:flash.display.DisplayObject):void
{
return;
}
mx_internal function childRemoved(arg1:flash.display.DisplayObject):void
{
if (arg1 is mx.core.IUIComponent)
{
if (mx.core.IUIComponent(arg1).document != arg1)
{
mx.core.IUIComponent(arg1).document = null;
}
mx.core.IUIComponent(arg1).parentChanged(null);
}
return;
}
public function initialize():void
{
if (this.initialized)
{
return;
}
this.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.PREINITIALIZE));
this.createChildren();
this.childrenCreated();
this.initializeAccessibility();
this.initializationComplete();
return;
}
protected function initializationComplete():void
{
this.processedDescriptors = true;
return;
}
protected function initializeAccessibility():void
{
if (mx.core.UIComponent.mx_internal::createAccessibilityImplementation != null)
{
mx.core.UIComponent.mx_internal::createAccessibilityImplementation(this);
}
return;
}
public function initializeRepeaterArrays(arg1:mx.core.IRepeaterClient):void
{
if (arg1 && arg1.instanceIndices && (!arg1.isDocument || !(arg1 == this.descriptor.document)) && !this._instanceIndices)
{
this._instanceIndices = arg1.instanceIndices;
this._repeaters = arg1.repeaters;
this._repeaterIndices = arg1.repeaterIndices;
}
return;
}
protected function createChildren():void
{
return;
}
protected function childrenCreated():void
{
this.invalidateProperties();
this.invalidateSize();
this.invalidateDisplayList();
return;
}
public function invalidateProperties():void
{
if (!this.mx_internal::invalidatePropertiesFlag)
{
this.mx_internal::invalidatePropertiesFlag = true;
if (this.parent && mx.core.UIComponentGlobals.mx_internal::layoutManager)
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.invalidateProperties(this);
}
}
return;
}
public function invalidateSize():void
{
if (!this.mx_internal::invalidateSizeFlag)
{
this.mx_internal::invalidateSizeFlag = true;
if (this.parent && mx.core.UIComponentGlobals.mx_internal::layoutManager)
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.invalidateSize(this);
}
}
return;
}
protected function invalidateParentSizeAndDisplayList():void
{
if (!this.includeInLayout)
{
return;
}
var loc1:*=this.parent as mx.core.IInvalidating;
if (!loc1)
{
return;
}
loc1.invalidateSize();
loc1.invalidateDisplayList();
return;
}
public function invalidateDisplayList():void
{
if (!this.mx_internal::invalidateDisplayListFlag)
{
this.mx_internal::invalidateDisplayListFlag = true;
if (this.isOnDisplayList() && mx.core.UIComponentGlobals.mx_internal::layoutManager)
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.invalidateDisplayList(this);
}
}
return;
}
internal function invalidateTransform():void
{
if (this.mx_internal::_layoutFeatures && this.mx_internal::_layoutFeatures.updatePending == false)
{
this.mx_internal::_layoutFeatures.updatePending = true;
if (this.isOnDisplayList() && mx.core.UIComponentGlobals.mx_internal::layoutManager && this.mx_internal::invalidateDisplayListFlag == false)
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.invalidateDisplayList(this);
}
}
return;
}
public function invalidateLayoutDirection():void
{
var loc1:*=null;
var loc4:*=0;
var loc5:*=null;
var loc6:*=0;
var loc7:*=null;
var loc8:*=0;
var loc9:*=null;
loc1 = this.parent as mx.core.ILayoutDirectionElement;
var loc2:*=this.layoutDirection;
var loc3:*=loc1 ? !(loc1.layoutDirection == loc2) : !(mx.core.LayoutDirection.LTR == loc2);
if (this.mx_internal::_layoutFeatures ? !(loc3 == this.mx_internal::_layoutFeatures.mirror) : loc3)
{
if (this.mx_internal::_layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
}
this.mx_internal::_layoutFeatures.mirror = loc3;
this.mx_internal::_layoutFeatures.layoutWidth = this.mx_internal::_width;
this.invalidateTransform();
}
if (this.mx_internal::oldLayoutDirection != this.layoutDirection)
{
if (this is mx.core.IVisualElementContainer)
{
loc6 = (loc5 = mx.core.IVisualElementContainer(this)).numElements;
loc4 = 0;
while (loc4 < loc6)
{
if ((loc7 = loc5.getElementAt(loc4)) && !(loc7 is mx.styles.IStyleClient))
{
loc7.invalidateLayoutDirection();
}
++loc4;
}
}
else
{
loc8 = numChildren;
loc4 = 0;
while (loc4 < loc8)
{
if (!((loc9 = getChildAt(loc4)) is mx.styles.IStyleClient) && loc9 is mx.core.ILayoutDirectionElement)
{
mx.core.ILayoutDirectionElement(loc9).invalidateLayoutDirection();
}
++loc4;
}
}
}
return;
}
internal function transformOffsetsChangedHandler(arg1:flash.events.Event):void
{
this.invalidateTransform();
return;
}
internal function isOnDisplayList():Boolean
{
var p:flash.display.DisplayObjectContainer;
var loc1:*;
p = null;
try
{
p = this.mx_internal::_parent ? this.mx_internal::_parent : super.parent;
}
catch (e:SecurityError)
{
return true;
}
return p ? true : false;
}
public function stylesInitialized():void
{
return;
}
public function styleChanged(arg1:String):void
{
mx.styles.StyleProtoChain.styleChanged(this, arg1);
if (arg1 && !(arg1 == "styleName"))
{
if (hasEventListener(arg1 + "Changed"))
{
this.dispatchEvent(new flash.events.Event(arg1 + "Changed"));
}
}
else if (hasEventListener("allStylesChanged"))
{
this.dispatchEvent(new flash.events.Event("allStylesChanged"));
}
return;
}
public function validateNow():void
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.validateClient(this);
return;
}
mx_internal function validateBaselinePosition():Boolean
{
var loc1:*=NaN;
var loc2:*=NaN;
if (!this.parent)
{
return false;
}
if (!this.mx_internal::setActualSizeCalled && (this.width == 0 || this.height == 0))
{
this.validateNow();
loc1 = this.getExplicitOrMeasuredWidth();
loc2 = this.getExplicitOrMeasuredHeight();
this.setActualSize(loc1, loc2);
}
this.validateNow();
return true;
}
mx_internal function cancelAllCallLaters():void
{
var loc1:*=this.systemManager;
if (loc1 && (loc1.stage || this.usingBridge))
{
if (this.listeningForRender)
{
loc1.removeEventListener(mx.events.FlexEvent.RENDER, this.callLaterDispatcher);
loc1.removeEventListener(mx.events.FlexEvent.ENTER_FRAME, this.callLaterDispatcher);
this.listeningForRender = false;
}
}
this.methodQueue.splice(0);
return;
}
public function validateProperties():void
{
if (this.mx_internal::invalidatePropertiesFlag)
{
this.commitProperties();
this.mx_internal::invalidatePropertiesFlag = false;
}
return;
}
protected function commitProperties():void
{
var loc1:*=NaN;
var loc2:*=NaN;
var loc3:*=null;
var loc4:*=null;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
if (this._scaleX != this.oldScaleX)
{
loc1 = Math.abs(this._scaleX / this.oldScaleX);
if (!isNaN(this.explicitMinWidth))
{
this.explicitMinWidth = this.explicitMinWidth * loc1;
}
if (!isNaN(this.explicitWidth))
{
this.explicitWidth = this.explicitWidth * loc1;
}
if (!isNaN(this.explicitMaxWidth))
{
this.explicitMaxWidth = this.explicitMaxWidth * loc1;
}
this.mx_internal::_width = this.mx_internal::_width * loc1;
var loc5:*;
this.oldScaleX = loc5 = this._scaleX;
super.scaleX = loc5;
}
if (this._scaleY != this.oldScaleY)
{
loc2 = Math.abs(this._scaleY / this.oldScaleY);
if (!isNaN(this.explicitMinHeight))
{
this.explicitMinHeight = this.explicitMinHeight * loc2;
}
if (!isNaN(this.explicitHeight))
{
this.explicitHeight = this.explicitHeight * loc2;
}
if (!isNaN(this.explicitMaxHeight))
{
this.explicitMaxHeight = this.explicitMaxHeight * loc2;
}
this.mx_internal::_height = this.mx_internal::_height * loc2;
this.oldScaleY = loc5 = this._scaleY;
super.scaleY = loc5;
}
}
else
{
if (this._currentStateDeferred != null)
{
loc3 = this._currentStateDeferred;
this._currentStateDeferred = null;
this.currentState = loc3;
}
this.oldScaleX = this.scaleX;
this.oldScaleY = this.scaleY;
}
if (this._currentStateChanged && !this.initialized)
{
this._currentStateChanged = false;
this.commitCurrentState();
}
if (mx.core.FlexVersion.compatibilityVersion >= mx.core.FlexVersion.VERSION_4_0)
{
loc4 = this.parent as mx.core.UIComponent;
if (!(this.mx_internal::oldLayoutDirection == this.layoutDirection) || this.parentChangedFlag || loc4 && !(loc4.layoutDirection == loc4.mx_internal::oldLayoutDirection))
{
this.invalidateLayoutDirection();
}
}
if (!(this.x == this.oldX) || !(this.y == this.oldY))
{
this.dispatchMoveEvent();
}
if (!(this.width == this.oldWidth) || !(this.height == this.oldHeight))
{
this.dispatchResizeEvent();
}
if (this.errorStringChanged)
{
this.errorStringChanged = false;
this.setBorderColorForErrorString();
}
if (this.blendModeChanged)
{
this.blendModeChanged = false;
if (this.blendShaderChanged)
{
this.blendShaderChanged = false;
this.mx_internal::$blendMode = flash.display.BlendMode.NORMAL;
loc5 = this._blendMode;
switch (loc5)
{
case "color":
{
this.mx_internal::$blendShader = new mx.graphics.shaderClasses.ColorShader();
break;
}
case "colordodge":
{
this.mx_internal::$blendShader = new mx.graphics.shaderClasses.ColorDodgeShader();
break;
}
case "colorburn":
{
this.mx_internal::$blendShader = new mx.graphics.shaderClasses.ColorBurnShader();
break;
}
case "exclusion":
{
this.mx_internal::$blendShader = new mx.graphics.shaderClasses.ExclusionShader();
break;
}
case "hue":
{
this.mx_internal::$blendShader = new mx.graphics.shaderClasses.HueShader();
break;
}
case "luminosity":
{
this.mx_internal::$blendShader = new mx.graphics.shaderClasses.LuminosityShader();
break;
}
case "saturation":
{
this.mx_internal::$blendShader = new mx.graphics.shaderClasses.SaturationShader();
break;
}
case "softlight":
{
this.mx_internal::$blendShader = new mx.graphics.shaderClasses.SoftLightShader();
break;
}
}
}
else
{
this.mx_internal::$blendMode = this._blendMode;
}
}
this.parentChangedFlag = false;
return;
}
public function validateSize(arg1:Boolean=false):void
{
var loc1:*=0;
var loc2:*=null;
var loc3:*=false;
if (arg1)
{
loc1 = 0;
while (loc1 < numChildren)
{
loc2 = getChildAt(loc1);
if (loc2 is mx.managers.ILayoutManagerClient)
{
(loc2 as mx.managers.ILayoutManagerClient).validateSize(true);
}
++loc1;
}
}
if (this.mx_internal::invalidateSizeFlag)
{
if ((loc3 = this.measureSizes()) && this.includeInLayout)
{
this.invalidateDisplayList();
this.invalidateParentSizeAndDisplayList();
}
}
return;
}
protected function canSkipMeasurement():Boolean
{
return !isNaN(this.explicitWidth) && !isNaN(this.explicitHeight);
}
internal function measureSizes():Boolean
{
var loc2:*=NaN;
var loc3:*=NaN;
var loc4:*=NaN;
var loc5:*=NaN;
var loc1:*=false;
if (!this.mx_internal::invalidateSizeFlag)
{
return loc1;
}
if (this.canSkipMeasurement())
{
this.mx_internal::invalidateSizeFlag = false;
this._measuredMinWidth = 0;
this._measuredMinHeight = 0;
}
else
{
loc4 = Math.abs(this.scaleX);
loc5 = Math.abs(this.scaleY);
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
if (loc4 != 1)
{
this._measuredMinWidth = this._measuredMinWidth / loc4;
this._measuredWidth = this._measuredWidth / loc4;
}
if (loc5 != 1)
{
this._measuredMinHeight = this._measuredMinHeight / loc5;
this._measuredHeight = this._measuredHeight / loc5;
}
}
this.measure();
this.mx_internal::invalidateSizeFlag = false;
if (!isNaN(this.explicitMinWidth) && this.measuredWidth < this.explicitMinWidth)
{
this.measuredWidth = this.explicitMinWidth;
}
if (!isNaN(this.explicitMaxWidth) && this.measuredWidth > this.explicitMaxWidth)
{
this.measuredWidth = this.explicitMaxWidth;
}
if (!isNaN(this.explicitMinHeight) && this.measuredHeight < this.explicitMinHeight)
{
this.measuredHeight = this.explicitMinHeight;
}
if (!isNaN(this.explicitMaxHeight) && this.measuredHeight > this.explicitMaxHeight)
{
this.measuredHeight = this.explicitMaxHeight;
}
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
if (loc4 != 1)
{
this._measuredMinWidth = this._measuredMinWidth * loc4;
this._measuredWidth = this._measuredWidth * loc4;
}
if (loc5 != 1)
{
this._measuredMinHeight = this._measuredMinHeight * loc5;
this._measuredHeight = this._measuredHeight * loc5;
}
}
}
this.mx_internal::adjustSizesForScaleChanges();
if (isNaN(this.oldMinWidth))
{
this.oldMinWidth = isNaN(this.explicitMinWidth) ? this.measuredMinWidth : this.explicitMinWidth;
this.oldMinHeight = isNaN(this.explicitMinHeight) ? this.measuredMinHeight : this.explicitMinHeight;
this.oldExplicitWidth = isNaN(this.explicitWidth) ? this.measuredWidth : this.explicitWidth;
this.oldExplicitHeight = isNaN(this.explicitHeight) ? this.measuredHeight : this.explicitHeight;
loc1 = true;
}
else
{
loc3 = isNaN(this.explicitMinWidth) ? this.measuredMinWidth : this.explicitMinWidth;
if (loc3 != this.oldMinWidth)
{
this.oldMinWidth = loc3;
loc1 = true;
}
loc3 = isNaN(this.explicitMinHeight) ? this.measuredMinHeight : this.explicitMinHeight;
if (loc3 != this.oldMinHeight)
{
this.oldMinHeight = loc3;
loc1 = true;
}
loc3 = isNaN(this.explicitWidth) ? this.measuredWidth : this.explicitWidth;
if (loc3 != this.oldExplicitWidth)
{
this.oldExplicitWidth = loc3;
loc1 = true;
}
loc3 = isNaN(this.explicitHeight) ? this.measuredHeight : this.explicitHeight;
if (loc3 != this.oldExplicitHeight)
{
this.oldExplicitHeight = loc3;
loc1 = true;
}
}
return loc1;
}
protected function measure():void
{
this.measuredMinWidth = 0;
this.measuredMinHeight = 0;
this.measuredWidth = 0;
this.measuredHeight = 0;
return;
}
mx_internal function adjustSizesForScaleChanges():void
{
var loc3:*=NaN;
var loc1:*=this.scaleX;
var loc2:*=this.scaleY;
if (loc1 != this.oldScaleX)
{
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc3 = Math.abs(loc1 / this.oldScaleX);
if (this.explicitMinWidth)
{
this.explicitMinWidth = this.explicitMinWidth * loc3;
}
if (!isNaN(this.explicitWidth))
{
this.explicitWidth = this.explicitWidth * loc3;
}
if (this.explicitMaxWidth)
{
this.explicitMaxWidth = this.explicitMaxWidth * loc3;
}
}
this.oldScaleX = loc1;
}
if (loc2 != this.oldScaleY)
{
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc3 = Math.abs(loc2 / this.oldScaleY);
if (this.explicitMinHeight)
{
this.explicitMinHeight = this.explicitMinHeight * loc3;
}
if (this.explicitHeight)
{
this.explicitHeight = this.explicitHeight * loc3;
}
if (this.explicitMaxHeight)
{
this.explicitMaxHeight = this.explicitMaxHeight * loc3;
}
}
this.oldScaleY = loc2;
}
return;
}
public function getExplicitOrMeasuredWidth():Number
{
return isNaN(this.explicitWidth) ? this.measuredWidth : this.explicitWidth;
}
public function getExplicitOrMeasuredHeight():Number
{
return isNaN(this.explicitHeight) ? this.measuredHeight : this.explicitHeight;
}
protected function get unscaledWidth():Number
{
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
return this.width / Math.abs(this.scaleX);
}
return this.width;
}
mx_internal function getUnscaledWidth():Number
{
return this.unscaledWidth;
}
mx_internal function setUnscaledWidth(arg1:Number):void
{
var loc1:*=arg1;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = loc1 * Math.abs(this.oldScaleX);
}
if (this._explicitWidth == loc1)
{
return;
}
if (!isNaN(loc1))
{
this._percentWidth = NaN;
}
this._explicitWidth = loc1;
this.invalidateSize();
this.invalidateParentSizeAndDisplayList();
return;
}
protected function get unscaledHeight():Number
{
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
return this.height / Math.abs(this.scaleY);
}
return this.height;
}
mx_internal function getUnscaledHeight():Number
{
return this.unscaledHeight;
}
mx_internal function setUnscaledHeight(arg1:Number):void
{
var loc1:*=arg1;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc1 = loc1 * Math.abs(this.oldScaleY);
}
if (this._explicitHeight == loc1)
{
return;
}
if (!isNaN(loc1))
{
this._percentHeight = NaN;
}
this._explicitHeight = loc1;
this.invalidateSize();
this.invalidateParentSizeAndDisplayList();
return;
}
public function measureText(arg1:String):flash.text.TextLineMetrics
{
return this.determineTextFormatFromStyles().measureText(arg1);
}
public function measureHTMLText(arg1:String):flash.text.TextLineMetrics
{
return this.determineTextFormatFromStyles().measureHTMLText(arg1);
}
protected function validateMatrix():void
{
var loc1:*=null;
if (!(this.mx_internal::_layoutFeatures == null) && this.mx_internal::_layoutFeatures.updatePending == true)
{
this.applyComputedMatrix();
}
if (this._maintainProjectionCenter)
{
loc1 = super.transform.perspectiveProjection;
if (loc1 != null)
{
loc1.projectionCenter = new flash.geom.Point(this.unscaledWidth / 2, this.unscaledHeight / 2);
}
}
return;
}
public function validateDisplayList():void
{
var loc1:*=null;
var loc2:*=NaN;
var loc3:*=NaN;
this.mx_internal::oldLayoutDirection = this.layoutDirection;
if (this.mx_internal::invalidateDisplayListFlag)
{
loc1 = this.parent as mx.managers.ISystemManager;
if (loc1)
{
if (loc1.isProxy || loc1 == this.systemManager.topLevelSystemManager && !(loc1.document == this))
{
this.setActualSize(this.getExplicitOrMeasuredWidth(), this.getExplicitOrMeasuredHeight());
}
}
this.validateMatrix();
loc2 = this.width;
loc3 = this.height;
if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc2 = this.scaleX != 0 ? this.width / this.scaleX : 0;
loc3 = this.scaleY != 0 ? this.height / this.scaleY : 0;
if (Math.abs(loc2 - this.lastUnscaledWidth) < 1e-005)
{
loc2 = this.lastUnscaledWidth;
}
if (Math.abs(loc3 - this.lastUnscaledHeight) < 1e-005)
{
loc3 = this.lastUnscaledHeight;
}
}
this.updateDisplayList(loc2, loc3);
this.lastUnscaledWidth = loc2;
this.lastUnscaledHeight = loc3;
this.mx_internal::invalidateDisplayListFlag = false;
}
else
{
this.validateMatrix();
}
return;
}
protected function updateDisplayList(arg1:Number, arg2:Number):void
{
return;
}
public function getConstraintValue(arg1:String):*
{
return this.getStyle(arg1);
}
public function setConstraintValue(arg1:String, arg2:*):void
{
this.setStyle(arg1, arg2);
return;
}
public function get left():Object
{
return this.getConstraintValue("left");
}
public function set left(arg1:Object):void
{
this.setConstraintValue("left", arg1 == null ? undefined : arg1);
return;
}
public function get right():Object
{
return this.getConstraintValue("right");
}
public function set right(arg1:Object):void
{
this.setConstraintValue("right", arg1 == null ? undefined : arg1);
return;
}
public function get top():Object
{
return this.getConstraintValue("top");
}
public function set top(arg1:Object):void
{
this.setConstraintValue("top", arg1 == null ? undefined : arg1);
return;
}
public function get bottom():Object
{
return this.getConstraintValue("bottom");
}
public function set bottom(arg1:Object):void
{
this.setConstraintValue("bottom", arg1 == null ? undefined : arg1);
return;
}
public function get horizontalCenter():Object
{
return this.getConstraintValue("horizontalCenter");
}
public function set horizontalCenter(arg1:Object):void
{
this.setConstraintValue("horizontalCenter", arg1 == null ? undefined : arg1);
return;
}
public function get verticalCenter():Object
{
return this.getConstraintValue("verticalCenter");
}
public function set verticalCenter(arg1:Object):void
{
this.setConstraintValue("verticalCenter", arg1 == null ? undefined : arg1);
return;
}
public function get baseline():Object
{
return this.getConstraintValue("baseline");
}
public function set baseline(arg1:Object):void
{
this.setConstraintValue("baseline", arg1 == null ? undefined : arg1);
return;
}
public function horizontalGradientMatrix(arg1:Number, arg2:Number, arg3:Number, arg4:Number):flash.geom.Matrix
{
mx.core.UIComponentGlobals.mx_internal::tempMatrix.createGradientBox(arg3, arg4, 0, arg1, arg2);
return mx.core.UIComponentGlobals.mx_internal::tempMatrix;
}
public function verticalGradientMatrix(arg1:Number, arg2:Number, arg3:Number, arg4:Number):flash.geom.Matrix
{
mx.core.UIComponentGlobals.mx_internal::tempMatrix.createGradientBox(arg3, arg4, Math.PI / 2, arg1, arg2);
return mx.core.UIComponentGlobals.mx_internal::tempMatrix;
}
public function drawRoundRect(arg1:Number, arg2:Number, arg3:Number, arg4:Number, arg5:Object=null, arg6:Object=null, arg7:Object=null, arg8:Object=null, arg9:String=null, arg10:Array=null, arg11:Object=null):void
{
var loc2:*=NaN;
var loc3:*=null;
var loc4:*=null;
var loc5:*=null;
var loc1:*=graphics;
if (!arg3 || !arg4)
{
return;
}
if (arg6 !== null)
{
if (arg6 is Array)
{
if (arg7 is Array)
{
loc3 = arg7 as Array;
}
else
{
loc3 = [arg7, arg7];
}
if (!arg10)
{
arg10 = [0, 255];
}
loc4 = null;
if (arg8)
{
if (arg8 is flash.geom.Matrix)
{
loc4 = flash.geom.Matrix(arg8);
}
else
{
loc4 = new flash.geom.Matrix();
if (arg8 is Number)
{
loc4.createGradientBox(arg3, arg4, Number(arg8) * Math.PI / 180, arg1, arg2);
}
else
{
loc4.createGradientBox(arg8.w, arg8.h, arg8.r, arg8.x, arg8.y);
}
}
}
if (arg9 != flash.display.GradientType.RADIAL)
{
loc1.beginGradientFill(flash.display.GradientType.LINEAR, arg6 as Array, loc3, arg10, loc4);
}
else
{
loc1.beginGradientFill(flash.display.GradientType.RADIAL, arg6 as Array, loc3, arg10, loc4);
}
}
else
{
loc1.beginFill(Number(arg6), Number(arg7));
}
}
if (arg5)
{
if (arg5 is Number)
{
loc2 = Number(arg5) * 2;
loc1.drawRoundRect(arg1, arg2, arg3, arg4, loc2, loc2);
}
else
{
mx.utils.GraphicsUtil.drawRoundRectComplex(loc1, arg1, arg2, arg3, arg4, arg5.tl, arg5.tr, arg5.bl, arg5.br);
}
}
else
{
loc1.drawRect(arg1, arg2, arg3, arg4);
}
if (arg11)
{
if ((loc5 = arg11.r) is Number)
{
loc2 = Number(loc5) * 2;
loc1.drawRoundRect(arg11.x, arg11.y, arg11.w, arg11.h, loc2, loc2);
}
else
{
mx.utils.GraphicsUtil.drawRoundRectComplex(loc1, arg11.x, arg11.y, arg11.w, arg11.h, loc5.tl, loc5.tr, loc5.bl, loc5.br);
}
}
if (arg6 !== null)
{
loc1.endFill();
}
return;
}
public function move(arg1:Number, arg2:Number):void
{
var loc1:*=false;
if (arg1 != this.x)
{
if (this.mx_internal::_layoutFeatures != null)
{
this.mx_internal::_layoutFeatures.layoutX = arg1;
}
else
{
super.x = arg1;
}
if (hasEventListener("xChanged"))
{
this.dispatchEvent(new flash.events.Event("xChanged"));
}
loc1 = true;
}
if (arg2 != this.y)
{
if (this.mx_internal::_layoutFeatures != null)
{
this.mx_internal::_layoutFeatures.layoutY = arg2;
}
else
{
super.y = arg2;
}
if (hasEventListener("yChanged"))
{
this.dispatchEvent(new flash.events.Event("yChanged"));
}
loc1 = true;
}
if (loc1)
{
this.invalidateTransform();
this.dispatchMoveEvent();
}
return;
}
public function setActualSize(arg1:Number, arg2:Number):void
{
var loc1:*=false;
if (this.mx_internal::_width != arg1)
{
this.mx_internal::_width = arg1;
if (this.mx_internal::_layoutFeatures)
{
this.mx_internal::_layoutFeatures.layoutWidth = arg1;
this.invalidateTransform();
}
if (hasEventListener("widthChanged"))
{
this.dispatchEvent(new flash.events.Event("widthChanged"));
}
loc1 = true;
}
if (this.mx_internal::_height != arg2)
{
this.mx_internal::_height = arg2;
if (hasEventListener("heightChanged"))
{
this.dispatchEvent(new flash.events.Event("heightChanged"));
}
loc1 = true;
}
if (loc1)
{
this.invalidateDisplayList();
this.dispatchResizeEvent();
}
this.mx_internal::setActualSizeCalled = true;
return;
}
public function contentToGlobal(arg1:flash.geom.Point):flash.geom.Point
{
return localToGlobal(arg1);
}
public function globalToContent(arg1:flash.geom.Point):flash.geom.Point
{
return globalToLocal(arg1);
}
public function contentToLocal(arg1:flash.geom.Point):flash.geom.Point
{
return arg1;
}
public function localToContent(arg1:flash.geom.Point):flash.geom.Point
{
return arg1;
}
public function getFocus():flash.display.InteractiveObject
{
var loc1:*=this.systemManager;
if (!loc1)
{
return null;
}
if (mx.core.UIComponentGlobals.mx_internal::nextFocusObject)
{
return mx.core.UIComponentGlobals.mx_internal::nextFocusObject;
}
if (loc1.stage)
{
return loc1.stage.focus;
}
return null;
}
public function setFocus():void
{
var loc1:*=this.systemManager;
if (loc1 && (loc1.stage || this.usingBridge))
{
if (mx.core.UIComponentGlobals.mx_internal::callLaterDispatcherCount != 0)
{
mx.core.UIComponentGlobals.mx_internal::nextFocusObject = this;
loc1.addEventListener(mx.events.FlexEvent.ENTER_FRAME, this.setFocusLater);
}
else
{
loc1.stage.focus = this;
mx.core.UIComponentGlobals.mx_internal::nextFocusObject = null;
}
}
else
{
mx.core.UIComponentGlobals.mx_internal::nextFocusObject = this;
this.callLater(this.setFocusLater);
}
return;
}
mx_internal function getFocusObject():flash.display.DisplayObject
{
var loc1:*=this.focusManager;
if (!loc1 || !loc1.focusPane)
{
return null;
}
return loc1.focusPane.numChildren != 0 ? loc1.focusPane.getChildAt(0) : null;
}
public function drawFocus(arg1:Boolean):void
{
var loc3:*=null;
var loc4:*=null;
if (!this.parent)
{
return;
}
var loc1:*=this.mx_internal::getFocusObject();
var loc2:*=this.focusManager ? this.focusManager.focusPane : null;
if (arg1 && !this.preventDrawFocus)
{
if ((loc3 = loc2.parent) != this.parent)
{
if (loc3)
{
if (loc3 is mx.managers.ISystemManager)
{
mx.managers.ISystemManager(loc3).focusPane = null;
}
else
{
mx.core.IUIComponent(loc3).focusPane = null;
}
}
if (this.parent is mx.managers.ISystemManager)
{
mx.managers.ISystemManager(this.parent).focusPane = loc2;
}
else
{
mx.core.IUIComponent(this.parent).focusPane = loc2;
}
}
if (!(loc4 = this.getStyle("focusSkin")))
{
return;
}
if (loc1 && !(loc1 is loc4))
{
loc2.removeChild(loc1);
loc1 = null;
}
if (!loc1)
{
loc1 = new loc4();
loc1.name = "focus";
loc2.addChild(loc1);
}
if (loc1 is mx.managers.ILayoutManagerClient)
{
mx.managers.ILayoutManagerClient(loc1).nestLevel = this.nestLevel;
}
if (loc1 is mx.styles.ISimpleStyleClient)
{
mx.styles.ISimpleStyleClient(loc1).styleName = this;
}
addEventListener(mx.events.MoveEvent.MOVE, this.focusObj_moveHandler, true);
addEventListener(mx.events.MoveEvent.MOVE, this.focusObj_moveHandler);
addEventListener(mx.events.ResizeEvent.RESIZE, this.focusObj_resizeHandler, true);
addEventListener(mx.events.ResizeEvent.RESIZE, this.focusObj_resizeHandler);
addEventListener(flash.events.Event.REMOVED, this.focusObj_removedHandler, true);
loc1.visible = true;
this.hasFocusRect = true;
this.adjustFocusRect();
}
else if (this.hasFocusRect)
{
this.hasFocusRect = false;
if (loc1)
{
loc1.visible = false;
if (loc1 is mx.styles.ISimpleStyleClient)
{
mx.styles.ISimpleStyleClient(loc1).styleName = null;
}
}
removeEventListener(mx.events.MoveEvent.MOVE, this.focusObj_moveHandler);
removeEventListener(mx.events.MoveEvent.MOVE, this.focusObj_moveHandler, true);
removeEventListener(mx.events.ResizeEvent.RESIZE, this.focusObj_resizeHandler, true);
removeEventListener(mx.events.ResizeEvent.RESIZE, this.focusObj_resizeHandler);
removeEventListener(flash.events.Event.REMOVED, this.focusObj_removedHandler, true);
}
return;
}
protected function adjustFocusRect(arg1:flash.display.DisplayObject=null):void
{
var loc1:*=NaN;
var loc2:*=NaN;
var loc5:*=NaN;
var loc6:*=NaN;
var loc7:*=null;
var loc8:*=NaN;
if (!arg1)
{
arg1 = this;
}
if (arg1 is mx.core.UIComponent)
{
loc1 = mx.core.UIComponent(arg1).unscaledWidth * Math.abs(arg1.scaleX);
loc2 = mx.core.UIComponent(arg1).unscaledHeight * Math.abs(arg1.scaleY);
}
else
{
loc1 = arg1.width;
loc2 = arg1.height;
}
if (isNaN(loc1) || isNaN(loc2))
{
return;
}
var loc3:*;
if (!(loc3 = this.focusManager))
{
return;
}
var loc4:*;
if (loc4 = mx.core.IFlexDisplayObject(this.mx_internal::getFocusObject()))
{
if (this.errorString && !(this.errorString == ""))
{
loc5 = this.getStyle("errorColor");
}
else if (mx.core.FlexVersion.compatibilityVersion < mx.core.FlexVersion.VERSION_4_0)
{
loc5 = this.getStyle("themeColor");
}
else
{
loc5 = this.getStyle("focusColor");
}
loc6 = this.getStyle("focusThickness");
if (loc4 is mx.styles.IStyleClient)
{
mx.styles.IStyleClient(loc4).setStyle("focusColor", loc5);
}
loc4.setActualSize(loc1 + 2 * loc6, loc2 + 2 * loc6);
if (this.rotation)
{
loc8 = this.rotation * Math.PI / 180;
loc7 = new flash.geom.Point(arg1.x - loc6 * (Math.cos(loc8) - Math.sin(loc8)), arg1.y - loc6 * (Math.cos(loc8) + Math.sin(loc8)));
flash.display.DisplayObject(loc4).rotation = this.rotation;
}
else
{
loc7 = new flash.geom.Point(arg1.x - loc6, arg1.y - loc6);
flash.display.DisplayObject(loc4).rotation = 0;
}
if (arg1.parent == this)
{
loc7.x = loc7.x + this.x;
loc7.y = loc7.y + this.y;
}
if (arg1 != this)
{
if (this.mx_internal::_layoutFeatures && this.mx_internal::_layoutFeatures.mirror)
{
loc7.x = loc7.x + (this.width - arg1.width);
}
}
loc7 = this.parent.localToGlobal(loc7);
loc7 = this.parent.globalToLocal(loc7);
loc4.move(loc7.x, loc7.y);
if (loc4 is mx.core.IInvalidating)
{
mx.core.IInvalidating(loc4).validateNow();
}
else if (loc4 is mx.core.IProgrammaticSkin)
{
mx.core.IProgrammaticSkin(loc4).validateNow();
}
}
return;
}
protected function dispatchPropertyChangeEvent(arg1:String, arg2:*, arg3:*):void
{
if (hasEventListener("propertyChange"))
{
this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, arg1, arg2, arg3));
}
return;
}
internal function dispatchMoveEvent():void
{
var loc1:*=null;
if (hasEventListener(mx.events.MoveEvent.MOVE))
{
loc1 = new mx.events.MoveEvent(mx.events.MoveEvent.MOVE);
loc1.oldX = this.oldX;
loc1.oldY = this.oldY;
this.dispatchEvent(loc1);
}
this.oldX = this.x;
this.oldY = this.y;
return;
}
internal function dispatchResizeEvent():void
{
var loc1:*=null;
if (hasEventListener(mx.events.ResizeEvent.RESIZE))
{
loc1 = new mx.events.ResizeEvent(mx.events.ResizeEvent.RESIZE);
loc1.oldWidth = this.oldWidth;
loc1.oldHeight = this.oldHeight;
this.dispatchEvent(loc1);
}
this.oldWidth = this.width;
this.oldHeight = this.height;
return;
}
mx_internal function childXYChanged():void
{
return;
}
mx_internal function mapKeycodeForLayoutDirection(arg1:flash.events.KeyboardEvent, arg2:Boolean=false):uint
{
var loc1:*=arg1.keyCode;
var loc2:*=loc1;
switch (loc2)
{
case flash.ui.Keyboard.DOWN:
{
if (arg2 && this.layoutDirection == mx.core.LayoutDirection.RTL)
{
loc1 = flash.ui.Keyboard.LEFT;
}
break;
}
case flash.ui.Keyboard.RIGHT:
{
if (this.layoutDirection == mx.core.LayoutDirection.RTL)
{
loc1 = flash.ui.Keyboard.LEFT;
}
break;
}
case flash.ui.Keyboard.UP:
{
if (arg2 && this.layoutDirection == mx.core.LayoutDirection.RTL)
{
loc1 = flash.ui.Keyboard.RIGHT;
}
break;
}
case flash.ui.Keyboard.LEFT:
{
if (this.layoutDirection == mx.core.LayoutDirection.RTL)
{
loc1 = flash.ui.Keyboard.RIGHT;
}
break;
}
}
return loc1;
}
public function setCurrentState(arg1:String, arg2:Boolean=true):void
{
arg1 = this.isBaseState(arg1) ? this.getDefaultState() : arg1;
if (!(arg1 == this.currentState) && !(this.isBaseState(arg1) && this.isBaseState(this.currentState)))
{
this.requestedCurrentState = arg1;
this.playStateTransition = this is mx.core.IStateClient2 && this.isBaseState(this.currentState) ? false : arg2;
if (this.initialized)
{
this.commitCurrentState();
}
else
{
this._currentStateChanged = true;
this.invalidateProperties();
}
}
return;
}
public function hasState(arg1:String):Boolean
{
return !(this.getState(arg1, false) == null);
}
internal function isBaseState(arg1:String):Boolean
{
return !arg1 || arg1 == "";
}
internal function getDefaultState():String
{
return this is mx.core.IStateClient2 && this.states.length > 0 ? this.states[0].name : null;
}
internal function commitCurrentState():void
{
var loc3:*=null;
var loc6:*=NaN;
var loc1:*=this.playStateTransition ? this.getTransition(this._currentState, this.requestedCurrentState) : null;
var loc2:*=this.findCommonBaseState(this._currentState, this.requestedCurrentState);
var loc4:*=this._currentState ? this._currentState : "";
var loc5:*=this.getState(this.requestedCurrentState);
if (this._currentTransition)
{
if (this._currentTransition.autoReverse && this.transitionFromState == this.requestedCurrentState && this.transitionToState == this._currentState)
{
if (this._currentTransition.effect.duration != 0)
{
loc6 = this._currentTransition.effect.playheadTime / this.getTotalDuration(this._currentTransition.effect);
}
else
{
loc6 = 0;
}
}
this._currentTransition.effect.end();
}
this.initializeState(this.requestedCurrentState);
if (loc1)
{
loc1.effect.captureStartValues();
}
if (hasEventListener(mx.events.StateChangeEvent.CURRENT_STATE_CHANGING))
{
loc3 = new mx.events.StateChangeEvent(mx.events.StateChangeEvent.CURRENT_STATE_CHANGING);
loc3.oldState = loc4;
loc3.newState = this.requestedCurrentState ? this.requestedCurrentState : "";
this.dispatchEvent(loc3);
}
if (this.isBaseState(this._currentState) && hasEventListener(mx.events.FlexEvent.EXIT_STATE))
{
this.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.EXIT_STATE));
}
this.removeState(this._currentState, loc2);
this._currentState = this.requestedCurrentState;
this.stateChanged(loc4, this._currentState, true);
if (this.isBaseState(this.currentState))
{
if (hasEventListener(mx.events.FlexEvent.ENTER_STATE))
{
this.dispatchEvent(new mx.events.FlexEvent(mx.events.FlexEvent.ENTER_STATE));
}
}
else
{
this.applyState(this._currentState, loc2);
}
if (hasEventListener(mx.events.StateChangeEvent.CURRENT_STATE_CHANGE))
{
loc3 = new mx.events.StateChangeEvent(mx.events.StateChangeEvent.CURRENT_STATE_CHANGE);
loc3.oldState = loc4;
loc3.newState = this._currentState ? this._currentState : "";
this.dispatchEvent(loc3);
}
if (loc1)
{
mx.core.UIComponentGlobals.mx_internal::layoutManager.validateNow();
this._currentTransition = loc1;
this.transitionFromState = loc4;
this.transitionToState = this._currentState;
loc1.effect.addEventListener(mx.events.EffectEvent.EFFECT_END, this.transition_effectEndHandler);
loc1.effect.play();
if (!isNaN(loc6) && !(loc1.effect.duration == 0))
{
loc1.effect.playheadTime = (1 - loc6) * this.getTotalDuration(loc1.effect);
}
}
return;
}
internal function getTotalDuration(arg1:mx.effects.IEffect):Number
{
var loc1:*=0;
var loc2:*=Object(arg1);
if (!compositeEffectLoaded)
{
compositeEffectLoaded = true;
if (flash.system.ApplicationDomain.currentDomain.hasDefinition("mx.effects.CompositeEffect"))
{
compositeEffectType = Class(flash.system.ApplicationDomain.currentDomain.getDefinition("mx.effects.CompositeEffect"));
}
}
if (compositeEffectType && arg1 is compositeEffectType)
{
loc1 = loc2.compositeDuration;
}
else
{
loc1 = arg1.duration;
}
var loc3:*="repeatDelay" in arg1 ? loc2.repeatDelay : 0;
var loc4:*="repeatCount" in arg1 ? loc2.repeatCount : 0;
var loc5:*="startDelay" in arg1 ? loc2.startDelay : 0;
loc1 = loc1 * loc4 + loc3 * (loc4 - 1) + loc5;
return loc1;
}
internal function transition_effectEndHandler(arg1:mx.events.EffectEvent):void
{
this._currentTransition = null;
return;
}
internal function getState(arg1:String, arg2:Boolean=true):mx.states.State
{
var loc2:*=null;
if (!this.states || this.isBaseState(arg1))
{
return null;
}
var loc1:*=0;
while (loc1 < this.states.length)
{
if (this.states[loc1].name == arg1)
{
return this.states[loc1];
}
++loc1;
}
if (arg2)
{
loc2 = this.resourceManager.getString("core", "stateUndefined", [arg1]);
throw new ArgumentError(loc2);
}
return null;
}
internal function findCommonBaseState(arg1:String, arg2:String):String
{
var loc1:*=this.getState(arg1);
var loc2:*=this.getState(arg2);
if (!loc1 || !loc2)
{
return "";
}
if (this.isBaseState(loc1.basedOn) && this.isBaseState(loc2.basedOn))
{
return "";
}
var loc3:*=this.getBaseStates(loc1);
var loc4:*=this.getBaseStates(loc2);
var loc5:*="";
while (loc3[(loc3.length - 1)] == loc4[(loc4.length - 1)])
{
loc5 = loc3.pop();
loc4.pop();
if (!(!loc3.length || !loc4.length))
{
continue;
}
break;
}
if (loc3.length && loc3[(loc3.length - 1)] == loc2.name)
{
loc5 = loc2.name;
}
else if (loc4.length && loc4[(loc4.length - 1)] == loc1.name)
{
loc5 = loc1.name;
}
return loc5;
}
internal function getBaseStates(arg1:mx.states.State):Array
{
var loc1:*=[];
while (arg1 && arg1.basedOn)
{
loc1.push(arg1.basedOn);
arg1 = this.getState(arg1.basedOn);
}
return loc1;
}
internal function removeState(arg1:String, arg2:String):void
{
var loc2:*=null;
var loc3:*=0;
var loc1:*=this.getState(arg1);
if (arg1 == arg2)
{
return;
}
if (loc1)
{
loc1.mx_internal::dispatchExitState();
loc3 = (loc2 = loc1.overrides).length;
while (loc3)
{
loc2[(loc3 - 1)].remove(this);
--loc3;
}
if (loc1.basedOn != arg2)
{
this.removeState(loc1.basedOn, arg2);
}
}
return;
}
internal function applyState(arg1:String, arg2:String):void
{
var loc2:*=null;
var loc3:*=0;
var loc1:*=this.getState(arg1);
if (arg1 == arg2)
{
return;
}
if (loc1)
{
if (loc1.basedOn != arg2)
{
this.applyState(loc1.basedOn, arg2);
}
loc2 = loc1.overrides;
loc3 = 0;
while (loc3 < loc2.length)
{
loc2[loc3].apply(this);
++loc3;
}
loc1.mx_internal::dispatchEnterState();
}
return;
}
internal function initializeState(arg1:String):void
{
var loc1:*=this.getState(arg1);
while (loc1)
{
loc1.mx_internal::initialize();
loc1 = this.getState(loc1.basedOn);
}
return;
}
internal function getTransition(arg1:String, arg2:String):mx.states.Transition
{
var loc4:*=null;
var loc1:*=null;
var loc2:*=0;
if (!this.transitions)
{
return null;
}
if (!arg1)
{
arg1 = "";
}
if (!arg2)
{
arg2 = "";
}
var loc3:*=0;
while (loc3 < this.transitions.length)
{
if ((loc4 = this.transitions[loc3]).fromState == "*" && loc4.toState == "*" && loc2 < 1)
{
loc1 = loc4;
loc2 = 1;
}
else if (loc4.fromState == arg1 && loc4.toState == "*" && loc2 < 2)
{
loc1 = loc4;
loc2 = 2;
}
else if (loc4.fromState == "*" && loc4.toState == arg2 && loc2 < 3)
{
loc1 = loc4;
loc2 = 3;
}
else if (loc4.fromState == arg1 && loc4.toState == arg2 && loc2 < 4)
{
loc1 = loc4;
loc2 = 4;
break;
}
++loc3;
}
if (loc1 && !loc1.effect)
{
loc1 = null;
}
return loc1;
}
protected function get currentCSSState():String
{
return this.currentState;
}
public function get styleParent():mx.styles.IAdvancedStyleClient
{
return this.parent as mx.styles.IAdvancedStyleClient;
}
public function matchesCSSState(arg1:String):Boolean
{
return this.currentCSSState == arg1;
}
public function matchesCSSType(arg1:String):Boolean
{
return mx.styles.StyleProtoChain.matchesCSSType(this, arg1);
}
mx_internal function initProtoChain():void
{
mx.styles.StyleProtoChain.initProtoChain(this);
return;
}
public function getClassStyleDeclarations():Array
{
return mx.styles.StyleProtoChain.getClassStyleDeclarations(this);
}
public function regenerateStyleCache(arg1:Boolean):void
{
var loc4:*=null;
this.mx_internal::initProtoChain();
var loc1:*=this is mx.core.IRawChildrenContainer ? mx.core.IRawChildrenContainer(this).rawChildren : mx.core.IChildList(this);
var loc2:*=loc1.numChildren;
var loc3:*=0;
while (loc3 < loc2)
{
if ((loc4 = loc1.getChildAt(loc3)) is mx.styles.IStyleClient)
{
if (mx.styles.IStyleClient(loc4).inheritingStyles != mx.styles.StyleProtoChain.STYLE_UNINITIALIZED)
{
mx.styles.IStyleClient(loc4).regenerateStyleCache(arg1);
}
}
else if (loc4 is mx.core.IUITextField)
{
if (mx.core.IUITextField(loc4).inheritingStyles)
{
mx.styles.StyleProtoChain.initTextField(mx.core.IUITextField(loc4));
}
}
++loc3;
}
return;
}
protected function stateChanged(arg1:String, arg2:String, arg3:Boolean):void
{
if (this.currentCSSState && !(arg1 == arg2) && (this.styleManager.hasPseudoCondition(arg1) || this.styleManager.hasPseudoCondition(arg2)))
{
this.regenerateStyleCache(arg3);
this.mx_internal::initThemeColor();
this.styleChanged(null);
this.notifyStyleChangeInChildren(null, arg3);
}
return;
}
public function getStyle(arg1:String):*
{
if (!this.moduleFactory)
{
if (this.deferredSetStyles && !(this.deferredSetStyles[arg1] === undefined))
{
return this.deferredSetStyles[arg1];
}
}
return this.styleManager.inheritingStyles[arg1] ? this._inheritingStyles[arg1] : this._nonInheritingStyles[arg1];
}
public function setStyle(arg1:String, arg2:*):void
{
if (this.moduleFactory)
{
mx.styles.StyleProtoChain.setStyle(this, arg1, arg2);
}
else
{
if (!this.deferredSetStyles)
{
this.deferredSetStyles = new Object();
}
this.deferredSetStyles[arg1] = arg2;
}
return;
}
internal function setDeferredStyles():void
{
var loc1:*=null;
if (!this.deferredSetStyles)
{
return;
}
var loc2:*=0;
var loc3:*=this.deferredSetStyles;
for (loc1 in loc3)
{
mx.styles.StyleProtoChain.setStyle(this, loc1, this.deferredSetStyles[loc1]);
}
this.deferredSetStyles = null;
return;
}
public function clearStyle(arg1:String):void
{
this.setStyle(arg1, undefined);
return;
}
public function notifyStyleChangeInChildren(arg1:String, arg2:Boolean):void
{
var loc3:*=null;
this.cachedTextFormat = null;
var loc1:*=numChildren;
var loc2:*=0;
while (loc2 < loc1)
{
if (loc3 = getChildAt(loc2) as mx.styles.ISimpleStyleClient)
{
loc3.styleChanged(arg1);
if (loc3 is mx.styles.IStyleClient)
{
mx.styles.IStyleClient(loc3).notifyStyleChangeInChildren(arg1, arg2);
}
}
++loc2;
}
return;
}
mx_internal function initThemeColor():Boolean
{
var loc2:*=null;
var loc3:*=NaN;
var loc4:*=NaN;
var loc5:*=0;
var loc6:*=null;
var loc7:*=null;
var loc8:*=null;
var loc9:*=null;
var loc10:*=null;
if (mx.core.FlexVersion.compatibilityVersion >= mx.core.FlexVersion.VERSION_4_0)
{
return true;
}
var loc1:*=this._styleName;
if (this._styleDeclaration)
{
loc2 = this._styleDeclaration.getStyle("themeColor");
loc3 = this._styleDeclaration.getStyle("rollOverColor");
loc4 = this._styleDeclaration.getStyle("selectionColor");
}
if (this.styleManager.hasAdvancedSelectors())
{
if (loc2 === null || !this.styleManager.isValidStyleValue(loc2))
{
loc5 = ((loc6 = mx.styles.StyleProtoChain.getMatchingStyleDeclarations(this)).length - 1);
while (loc5 >= 0)
{
if (loc7 = loc6[loc5])
{
loc2 = loc7.getStyle("themeColor");
loc3 = loc7.getStyle("rollOverColor");
loc4 = loc7.getStyle("selectionColor");
}
if (!(!(loc2 === null) && this.styleManager.isValidStyleValue(loc2)))
{
};
--loc5;
}
}
}
else
{
if ((loc2 === null || !this.styleManager.isValidStyleValue(loc2)) && loc1 && !(loc1 is mx.styles.ISimpleStyleClient))
{
if (loc8 = loc1 is String ? this.styleManager.getMergedStyleDeclaration("." + loc1) : loc1)
{
loc2 = loc8.getStyle("themeColor");
loc3 = loc8.getStyle("rollOverColor");
loc4 = loc8.getStyle("selectionColor");
}
}
if (loc2 === null || !this.styleManager.isValidStyleValue(loc2))
{
loc9 = this.getClassStyleDeclarations();
loc5 = 0;
while (loc5 < loc9.length)
{
if (loc10 = loc9[loc5])
{
loc2 = loc10.getStyle("themeColor");
loc3 = loc10.getStyle("rollOverColor");
loc4 = loc10.getStyle("selectionColor");
}
if (!(!(loc2 === null) && this.styleManager.isValidStyleValue(loc2)))
{
};
++loc5;
}
}
}
if (!(loc2 === null) && this.styleManager.isValidStyleValue(loc2) && isNaN(loc3) && isNaN(loc4))
{
this.mx_internal::setThemeColor(loc2);
return true;
}
return !(loc2 === null) && this.styleManager.isValidStyleValue(loc2) && !isNaN(loc3) && !isNaN(loc4);
}
mx_internal function setThemeColor(arg1:Object):void
{
var loc1:*=NaN;
if (loc1 is String)
{
loc1 = parseInt(String(arg1));
}
else
{
loc1 = Number(arg1);
}
if (isNaN(loc1))
{
loc1 = this.styleManager.getColorName(arg1);
}
var loc2:*=mx.utils.ColorUtil.adjustBrightness2(loc1, 50);
var loc3:*=mx.utils.ColorUtil.adjustBrightness2(loc1, 70);
this.setStyle("selectionColor", loc2);
this.setStyle("rollOverColor", loc3);
return;
}
public function determineTextFormatFromStyles():mx.core.UITextFormat
{
var loc2:*=null;
var loc3:*=null;
var loc1:*=this.cachedTextFormat;
if (!loc1)
{
loc2 = mx.utils.StringUtil.trimArrayElements(this._inheritingStyles.fontFamily, ",");
loc1 = new mx.core.UITextFormat(this.mx_internal::getNonNullSystemManager(), loc2);
loc1.moduleFactory = this.moduleFactory;
loc3 = this._inheritingStyles.textAlign;
if (loc3 != "start")
{
if (loc3 == "end")
{
loc3 = flash.text.TextFormatAlign.RIGHT;
}
}
else
{
loc3 = flash.text.TextFormatAlign.LEFT;
}
loc1.align = loc3;
loc1.bold = this._inheritingStyles.fontWeight == "bold";
loc1.color = this.enabled ? this._inheritingStyles.color : this._inheritingStyles.disabledColor;
loc1.font = loc2;
loc1.indent = this._inheritingStyles.textIndent;
loc1.italic = this._inheritingStyles.fontStyle == "italic";
loc1.kerning = this._inheritingStyles.kerning;
loc1.leading = this._nonInheritingStyles.leading;
loc1.leftMargin = this._nonInheritingStyles.paddingLeft;
loc1.letterSpacing = this._inheritingStyles.letterSpacing;
loc1.rightMargin = this._nonInheritingStyles.paddingRight;
loc1.size = this._inheritingStyles.fontSize;
loc1.underline = this._nonInheritingStyles.textDecoration == "underline";
loc1.antiAliasType = this._inheritingStyles.fontAntiAliasType;
loc1.gridFitType = this._inheritingStyles.fontGridFitType;
loc1.sharpness = this._inheritingStyles.fontSharpness;
loc1.thickness = this._inheritingStyles.fontThickness;
loc1.useFTE = this.getTextFieldClassName() == "mx.core::UIFTETextField" || this.getTextInputClassName() == "mx.controls::MXFTETextInput";
if (loc1.useFTE)
{
loc1.direction = this._inheritingStyles.direction;
loc1.locale = this._inheritingStyles.locale;
}
this.cachedTextFormat = loc1;
}
return loc1;
}
public function executeBindings(arg1:Boolean=false):void
{
var loc1:*=this.descriptor && this.descriptor.document ? this.descriptor.document : this.parentDocument;
mx.binding.BindingManager.executeBindings(loc1, this.id, this);
return;
}
public function registerEffects(arg1:Array):void
{
var loc3:*=null;
var loc1:*=arg1.length;
var loc2:*=0;
while (loc2 < loc1)
{
if (!((loc3 = mx.effects.EffectManager.mx_internal::getEventForEffectTrigger(arg1[loc2])) == null) && !(loc3 == ""))
{
addEventListener(loc3, mx.effects.EffectManager.mx_internal::eventHandler, false, mx.core.EventPriority.EFFECT);
}
++loc2;
}
return;
}
mx_internal function addOverlay(arg1:uint, arg2:mx.geom.RoundedRectangle=null):void
{
if (this.mx_internal::effectOverlay)
{
var loc1:*;
var loc2:*=((loc1 = this).mx_internal::effectOverlayReferenceCount + 1);
loc1.mx_internal::effectOverlayReferenceCount = loc2;
}
else
{
this.mx_internal::effectOverlayColor = arg1;
this.mx_internal::effectOverlay = new mx.core.UIComponent();
this.mx_internal::effectOverlay.name = "overlay";
this.mx_internal::effectOverlay.mx_internal::$visible = true;
this.mx_internal::fillOverlay(this.mx_internal::effectOverlay, arg1, arg2);
this.attachOverlay();
if (!arg2)
{
addEventListener(mx.events.ResizeEvent.RESIZE, this.overlay_resizeHandler);
}
this.mx_internal::effectOverlay.x = 0;
this.mx_internal::effectOverlay.y = 0;
this.invalidateDisplayList();
this.mx_internal::effectOverlayReferenceCount = 1;
}
this.dispatchEvent(new mx.events.ChildExistenceChangedEvent(mx.events.ChildExistenceChangedEvent.OVERLAY_CREATED, true, false, this.mx_internal::effectOverlay));
return;
}
protected function attachOverlay():void
{
this.addChild(this.mx_internal::effectOverlay);
return;
}
mx_internal function fillOverlay(arg1:mx.core.UIComponent, arg2:uint, arg3:mx.geom.RoundedRectangle=null):void
{
if (!arg3)
{
arg3 = new mx.geom.RoundedRectangle(0, 0, this.unscaledWidth, this.unscaledHeight, 0);
}
var loc1:*;
(loc1 = arg1.graphics).clear();
loc1.beginFill(arg2);
loc1.drawRoundRect(arg3.x, arg3.y, arg3.width, arg3.height, arg3.cornerRadius * 2, arg3.cornerRadius * 2);
loc1.endFill();
return;
}
mx_internal function removeOverlay():void
{
if (this.mx_internal::effectOverlayReferenceCount > 0)
{
this.mx_internal::effectOverlayReferenceCount > 0;
var loc1:*;
var loc2:*;
}
if (this.mx_internal::effectOverlayReferenceCount > 0 && this.mx_internal::effectOverlay)
{
removeEventListener(mx.events.ResizeEvent.RESIZE, this.overlay_resizeHandler);
if (super.getChildByName("overlay"))
{
this.mx_internal::$removeChild(this.mx_internal::effectOverlay);
}
this.mx_internal::effectOverlay = null;
}
return;
}
internal function overlay_resizeHandler(arg1:flash.events.Event):void
{
this.mx_internal::fillOverlay(this.mx_internal::effectOverlay, this.mx_internal::effectOverlayColor, null);
return;
}
mx_internal function get isEffectStarted():Boolean
{
return this._isEffectStarted;
}
public static const DEFAULT_MEASURED_HEIGHT:Number=22;
mx_internal static const VERSION:String="4.1.0.16076";
public static const DEFAULT_MEASURED_WIDTH:Number=160;
public static const DEFAULT_MEASURED_MIN_WIDTH:Number=40;
public static const DEFAULT_MEASURED_MIN_HEIGHT:Number=22;
public static const DEFAULT_MAX_WIDTH:Number=10000;
public static const DEFAULT_MAX_HEIGHT:Number=10000;
internal var _initialized:Boolean=false;
internal var _processedDescriptors:Boolean=false;
internal var _updateCompletePendingFlag:Boolean=false;
mx_internal var invalidatePropertiesFlag:Boolean=false;
mx_internal var invalidateSizeFlag:Boolean=false;
mx_internal var invalidateDisplayListFlag:Boolean=false;
mx_internal var setActualSizeCalled:Boolean=false;
internal var oldX:Number=0;
internal var oldY:Number=0;
internal var oldWidth:Number=0;
internal var oldHeight:Number=0;
internal var oldMinWidth:Number;
internal var oldMinHeight:Number;
internal var oldExplicitWidth:Number;
internal var oldExplicitHeight:Number;
internal var oldScaleX:Number=1;
internal var oldScaleY:Number=1;
internal var hasFontContextBeenSaved:Boolean=false;
internal var oldEmbeddedFontContext:mx.core.IFlexModuleFactory=null;
mx_internal var _layoutFeatures:mx.core.AdvancedLayoutFeatures;
internal var _transform:flash.geom.Transform;
internal var cachedTextFormat:mx.core.UITextFormat;
mx_internal var effectOverlay:mx.core.UIComponent;
mx_internal var effectOverlayColor:uint;
mx_internal var effectOverlayReferenceCount:int=0;
mx_internal var saveBorderColor:Boolean=true;
mx_internal var origBorderColor:Number;
mx_internal var automaticRadioButtonGroups:Object;
internal var _usingBridge:int=-1;
mx_internal var _owner:flash.display.DisplayObjectContainer;
mx_internal var _parent:flash.display.DisplayObjectContainer;
mx_internal var _width:Number;
mx_internal var _height:Number;
internal var _scaleX:Number=1;
internal var _scaleY:Number=1;
internal var _visible:Boolean=true;
internal var _alpha:Number=1;
internal var _blendMode:String="normal";
internal var blendShaderChanged:Boolean;
internal var blendModeChanged:Boolean;
internal var _enabled:Boolean=false;
internal var _filters:Array;
internal var _designLayer:mx.core.DesignLayer;
internal var _tweeningProperties:Array;
internal var _focusManager:mx.managers.IFocusManager;
internal var _resourceManager:mx.resources.IResourceManager;
internal var _systemManager:mx.managers.ISystemManager;
internal var _systemManagerDirty:Boolean=false;
internal var _nestLevel:int=0;
mx_internal var _descriptor:mx.core.UIComponentDescriptor;
mx_internal var _document:Object;
mx_internal var _documentDescriptor:mx.core.UIComponentDescriptor;
internal var _id:String;
internal var _moduleFactory:mx.core.IFlexModuleFactory;
internal var _inheritingStyles:Object;
internal var _nonInheritingStyles:Object;
internal var _styleDeclaration:mx.styles.CSSStyleDeclaration;
internal var _cachePolicy:String="auto";
internal var cacheAsBitmapCount:int=0;
internal var _focusPane:flash.display.Sprite;
internal var _focusEnabled:Boolean=true;
internal var _hasFocusableChildren:Boolean=false;
internal var _mouseFocusEnabled:Boolean=true;
internal var _tabFocusEnabled:Boolean=true;
internal var _measuredMinWidth:Number=0;
internal var _measuredMinHeight:Number=0;
internal var _measuredWidth:Number=0;
internal var _measuredHeight:Number=0;
internal var _percentHeight:Number;
mx_internal var _explicitMinWidth:Number;
mx_internal var _explicitMinHeight:Number;
mx_internal var _explicitMaxWidth:Number;
mx_internal var _explicitMaxHeight:Number;
internal var _explicitWidth:Number;
internal var _explicitHeight:Number;
internal var _hasComplexLayoutMatrix:Boolean=false;
internal var _includeInLayout:Boolean=true;
mx_internal var oldLayoutDirection:String="ltr";
internal var _instanceIndices:Array;
internal var _repeaters:Array;
internal var _repeaterIndices:Array;
internal var _currentState:String;
internal var requestedCurrentState:String;
internal var playStateTransition:Boolean=true;
internal var _currentStateChanged:Boolean;
internal var _currentStateDeferred:String;
internal var _states:Array;
internal var _currentTransition:mx.states.Transition;
internal var _transitions:Array;
internal var lastUnscaledHeight:Number;
mx_internal var _effectsStarted:Array;
mx_internal var _affectedProperties:Object;
internal var _isEffectStarted:Boolean=false;
internal var errorObjectArray:Array;
internal var deferredSetStyles:Object;
internal var preventDrawFocus:Boolean=false;
internal var _maintainProjectionCenter:Boolean=false;
internal var _automationName:String=null;
internal var _endingEffectInstances:Array;
internal var _percentWidth:Number;
internal var _styleName:Object;
mx_internal var _toolTip:String;
internal var _validationSubField:String;
internal var _automationDelegate:mx.automation.IAutomationObject;
internal var _flexContextMenu:mx.controls.IFlexContextMenu;
internal var _showInAutomationHierarchy:Boolean=true;
internal var _uid:String;
internal var listeningForRender:Boolean=false;
internal var methodQueue:Array;
internal var hasFocusRect:Boolean=false;
internal var errorStringChanged:Boolean=false;
internal var transitionFromState:String;
internal var transitionToState:String;
internal var parentChangedFlag:Boolean=false;
mx_internal static var createAccessibilityImplementation:Function;
internal static var noEmbeddedFonts:Boolean;
internal static var _embeddedFontRegistry:mx.core.IEmbeddedFontRegistry;
internal var _isPopUp:Boolean;
mx_internal var _errorString:String="";
internal var errorArray:Array;
internal static var compositeEffectType:Class;
internal static var compositeEffectLoaded:Boolean=false;
mx_internal static var dispatchEventHook:Function;
internal static var fakeMouseX:QName;
internal static var fakeMouseY:QName;
internal static var xformPt:flash.geom.Point;
internal var lastUnscaledWidth:Number;
}
}
class MethodQueueElement extends Object
{
public function MethodQueueElement(arg1:Function, arg2:Array=null)
{
super();
this.method = arg1;
this.args = arg2;
return;
}
public var method:Function;
public var args:Array;
}
// class UIComponentCachePolicy
package mx.core
{
use namespace mx_internal;
public final class UIComponentCachePolicy extends Object
{
public function UIComponentCachePolicy()
{
super();
return;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public static const AUTO:String="auto";
public static const OFF:String="off";
public static const ON:String="on";
}
}
// class UIComponentDescriptor
package mx.core
{
use namespace mx_internal;
public class UIComponentDescriptor extends mx.core.ComponentDescriptor
{
public function UIComponentDescriptor(arg1:Object)
{
super(arg1);
return;
}
public override function toString():String
{
return "UIComponentDescriptor_" + id;
}
{
mx_internal::VERSION = "4.1.0.16076";
}
mx_internal static const VERSION:String="4.1.0.16076";
public var effects:Array;
mx_internal var instanceIndices:Array;
mx_internal var repeaterIndices:Array;
mx_internal var repeaters:Array;
public var stylesFactory:Function;
}
}
// class UIComponentGlobals
package mx.core
{
import flash.display.*;
import flash.geom.*;
import mx.managers.*;
use namespace mx_internal;
public class UIComponentGlobals extends Object
{
public function UIComponentGlobals()
{
super();
return;
}
public static function get designMode():Boolean
{
return mx_internal::designTime;
}
public static function set designMode(arg1:Boolean):void
{
mx_internal::designTime = arg1;
return;
}
public static function get catchCallLaterExceptions():Boolean
{
return _catchCallLaterExceptions;
}
public static function set catchCallLaterExceptions(arg1:Boolean):void
{
_catchCallLaterExceptions = arg1;
return;
}
{
mx_internal::callLaterSuspendCount = 0;
mx_internal::callLaterDispatcherCount = 0;
mx_internal::tempMatrix = new flash.geom.Matrix();
mx_internal::designTime = false;
_catchCallLaterExceptions = false;
}
mx_internal static var layoutManager:mx.managers.ILayoutManager;
mx_internal static var callLaterSuspendCount:int=0;
mx_internal static var callLaterDispatcherCount:int=0;
mx_internal static var nextFocusObject:flash.display.InteractiveObject;
mx_internal static var tempMatrix:flash.geom.Matrix;
mx_internal static var designTime:Boolean=false;
internal static var _catchCallLaterExceptions:Boolean=false;
}
}
// class UITextField
package mx.core
{
import flash.display.*;
import flash.events.*;
import flash.geom.*;
import flash.text.*;
import mx.automation.*;
import mx.managers.*;
import mx.resources.*;
import mx.styles.*;
import mx.utils.*;
use namespace mx_internal;
public class UITextField extends mx.core.FlexTextField implements mx.automation.IAutomationObject, mx.core.IIMESupport, mx.core.IFlexModule, mx.core.IInvalidating, mx.styles.ISimpleStyleClient, mx.managers.IToolTipManagerClient, mx.core.IUITextField
{
public function UITextField()
{
this.resourceManager = mx.resources.ResourceManager.getInstance();
this._inheritingStyles = mx.styles.StyleProtoChain.STYLE_UNINITIALIZED;
this._nonInheritingStyles = mx.styles.StyleProtoChain.STYLE_UNINITIALIZED;
super();
super.text = "";
focusRect = false;
selectable = false;
tabEnabled = false;
if (mx_internal::debuggingBorders)
{
border = true;
}
if (!truncationIndicatorResource)
{
truncationIndicatorResource = this.resourceManager.getString("core", "truncationIndicator");
}
addEventListener(flash.events.Event.CHANGE, this.changeHandler);
addEventListener("textFieldStyleChange", this.textFieldStyleChangeHandler);
this.resourceManager.addEventListener(flash.events.Event.CHANGE, this.resourceManager_changeHandler, false, 0, true);
return;
}
public function invalidateDisplayList():void
{
this.invalidateDisplayListFlag = true;
return;
}
public function invalidateProperties():void
{
return;
}
public function truncateToFit(arg1:String=null):Boolean
{
var loc3:*=null;
if (!arg1)
{
arg1 = truncationIndicatorResource;
}
this.validateNow();
var loc1:*=super.text;
this.untruncatedText = loc1;
var loc2:*=width;
if (!(loc1 == "") && textWidth + mx_internal::TEXT_WIDTH_PADDING > loc2 + 1e-014)
{
var loc4:*;
super.text = loc4 = loc1;
loc3 = loc4;
loc1.slice(0, Math.floor(loc2 / (textWidth + mx_internal::TEXT_WIDTH_PADDING) * loc1.length));
while (loc3.length > 1 && textWidth + mx_internal::TEXT_WIDTH_PADDING > loc2)
{
loc3 = loc3.slice(0, -1);
super.text = loc3 + arg1;
}
return true;
}
return false;
}
internal function changeHandler(arg1:flash.events.Event):void
{
this.explicitHTMLText = null;
return;
}
internal function textFieldStyleChangeHandler(arg1:flash.events.Event):void
{
if (this.explicitHTMLText != null)
{
super.htmlText = this.explicitHTMLText;
}
return;
}
internal function resourceManager_changeHandler(arg1:flash.events.Event):void
{
truncationIndicatorResource = this.resourceManager.getString("core", "truncationIndicator");
if (this.untruncatedText != null)
{
super.text = this.untruncatedText;
this.truncateToFit();
}
return;
}
public function owns(arg1:flash.display.DisplayObject):Boolean
{
return arg1 == this;
}
public function get owner():flash.display.DisplayObjectContainer
{
return this._owner ? this._owner : this.parent;
}
public function set owner(arg1:flash.display.DisplayObjectContainer):void
{
this._owner = arg1;
return;
}
public override function set x(arg1:Number):void
{
this._x = arg1;
super.x = arg1;
if (this.mirror)
{
this.validateTransformMatrix();
}
return;
}
public override function get x():Number
{
return this.mirror ? this._x : super.x;
}
public override function set width(arg1:Number):void
{
super.width = arg1;
if (this.mirror)
{
this.validateTransformMatrix();
}
return;
}
public override function set htmlText(arg1:String):void
{
if (!arg1)
{
arg1 = "";
}
if (this.isHTML && super.htmlText == arg1)
{
return;
}
if (this.cachedTextFormat && styleSheet == null)
{
defaultTextFormat = this.cachedTextFormat;
}
super.htmlText = arg1;
this.explicitHTMLText = arg1;
if (this.invalidateDisplayListFlag)
{
this.validateNow();
}
return;
}
internal function creatingSystemManager():mx.managers.ISystemManager
{
return !(this.moduleFactory == null) && this.moduleFactory is mx.managers.ISystemManager ? mx.managers.ISystemManager(this.moduleFactory) : this.systemManager;
}
public override function get parent():flash.display.DisplayObjectContainer
{
return this.mx_internal::_parent ? this.mx_internal::_parent : super.parent;
}
public override function set text(arg1:String):void
{
if (!arg1)
{
arg1 = "";
}
if (!this.isHTML && super.text == arg1)
{
return;
}
super.text = arg1;
this.explicitHTMLText = null;
if (this.invalidateDisplayListFlag)
{
this.validateNow();
}
return;
}
public override function set textColor(arg1:uint):void
{
this.setColor(arg1);
return;
}
public function replayAutomatableEvent(arg1:flash.events.Event):Boolean
{
if (this.automationDelegate)
{
return this.automationDelegate.replayAutomatableEvent(arg1);
}
return false;
}
public function get automationDelegate():Object
{
return this._automationDelegate;
}
public function set automationDelegate(arg1:Object):void
{
this._automationDelegate = arg1 as mx.automation.IAutomationObject;
return;
}
public function createAutomationIDPart(arg1:mx.automation.IAutomationObject):Object
{
return null;
}
public function get automationName():String
{
if (this._automationName)
{
return this._automationName;
}
if (this.automationDelegate)
{
return this.automationDelegate.automationName;
}
return "";
}
public function set automationName(arg1:String):void
{
this._automationName = arg1;
return;
}
public function get automationValue():Array
{
if (this.automationDelegate)
{
return this.automationDelegate.automationValue;
}
return [""];
}
public function get automationOwner():flash.display.DisplayObjectContainer
{
return this.owner;
}
public function get automationParent():flash.display.DisplayObjectContainer
{
return this.parent;
}
public function get automationEnabled():Boolean
{
return this.enabled;
}
public function get automationVisible():Boolean
{
return visible;
}
public function get baselinePosition():Number
{
var loc1:*=null;
if (!this.parent)
{
return NaN;
}
var loc2:*=text == "";
if (loc2)
{
super.text = "Wj";
}
loc1 = getLineMetrics(0);
if (loc2)
{
super.text = "";
}
return 2 + loc1.ascent;
}
public function get className():String
{
return mx.utils.NameUtil.getUnqualifiedClassName(this);
}
public function createAutomationIDPartWithRequiredProperties(arg1:mx.automation.IAutomationObject, arg2:Array):Object
{
return null;
}
public function get document():Object
{
return this._document;
}
public function set document(arg1:Object):void
{
this._document = arg1;
return;
}
public function get enableIME():Boolean
{
return type == flash.text.TextFieldType.INPUT;
}
public function resolveAutomationIDPart(arg1:Object):Array
{
return [];
}
public function get enabled():Boolean
{
return this._enabled;
}
public function set enabled(arg1:Boolean):void
{
mouseEnabled = arg1;
this._enabled = arg1;
this.styleChanged("color");
return;
}
public function getAutomationChildAt(arg1:int):mx.automation.IAutomationObject
{
return null;
}
public function get explicitHeight():Number
{
return this._explicitHeight;
}
public function set explicitHeight(arg1:Number):void
{
this._explicitHeight = arg1;
return;
}
public function get explicitMaxHeight():Number
{
return NaN;
}
public function get explicitMaxWidth():Number
{
return NaN;
}
public function get explicitMinHeight():Number
{
return NaN;
}
public function get explicitMinWidth():Number
{
return NaN;
}
public function getAutomationChildren():Array
{
return null;
}
public function get explicitWidth():Number
{
return this._explicitWidth;
}
public function set explicitWidth(arg1:Number):void
{
this._explicitWidth = arg1;
return;
}
public function get focusPane():flash.display.Sprite
{
return null;
}
public function set focusPane(arg1:flash.display.Sprite):void
{
return;
}
public function get numAutomationChildren():int
{
return 0;
}
public function get ignorePadding():Boolean
{
return this._ignorePadding;
}
public function set ignorePadding(arg1:Boolean):void
{
this._ignorePadding = arg1;
this.styleChanged(null);
return;
}
public function get showInAutomationHierarchy():Boolean
{
return true;
}
public function get imeMode():String
{
return this._imeMode;
}
public function set imeMode(arg1:String):void
{
this._imeMode = arg1;
return;
}
public function set showInAutomationHierarchy(arg1:Boolean):void
{
return;
}
public function get includeInLayout():Boolean
{
return this._includeInLayout;
}
public function set includeInLayout(arg1:Boolean):void
{
var loc1:*=null;
if (this._includeInLayout != arg1)
{
this._includeInLayout = arg1;
loc1 = this.parent as mx.core.IInvalidating;
if (loc1)
{
loc1.invalidateSize();
loc1.invalidateDisplayList();
}
}
return;
}
public function get automationTabularData():Object
{
return null;
}
public function get inheritingStyles():Object
{
return this._inheritingStyles;
}
public function set inheritingStyles(arg1:Object):void
{
this._inheritingStyles = arg1;
return;
}
internal static function get embeddedFontRegistry():mx.core.IEmbeddedFontRegistry
{
var loc1:*;
if (!_embeddedFontRegistry && !noEmbeddedFonts)
{
try
{
_embeddedFontRegistry = mx.core.IEmbeddedFontRegistry(mx.core.Singleton.getInstance("mx.core::IEmbeddedFontRegistry"));
}
catch (e:Error)
{
noEmbeddedFonts = true;
}
}
return _embeddedFontRegistry;
}
public function get initialized():Boolean
{
return this._initialized;
}
public function set initialized(arg1:Boolean):void
{
this._initialized = arg1;
return;
}
internal function get isHTML():Boolean
{
return !(this.explicitHTMLText == null);
}
public function get isPopUp():Boolean
{
return false;
}
public function set isPopUp(arg1:Boolean):void
{
return;
}
public function get maxHeight():Number
{
return mx.core.UIComponent.DEFAULT_MAX_HEIGHT;
}
public function get maxWidth():Number
{
return mx.core.UIComponent.DEFAULT_MAX_WIDTH;
}
public function get measuredHeight():Number
{
this.validateNow();
if (!stage || embedFonts)
{
return this.textHeight + mx_internal::TEXT_HEIGHT_PADDING;
}
var loc1:*=transform.concatenatedMatrix;
return Math.abs(this.textHeight * loc1.a / loc1.d) + mx_internal::TEXT_HEIGHT_PADDING;
}
public function get measuredMinHeight():Number
{
return 0;
}
public function set measuredMinHeight(arg1:Number):void
{
return;
}
public function get measuredMinWidth():Number
{
return 0;
}
public function set measuredMinWidth(arg1:Number):void
{
return;
}
public function get measuredWidth():Number
{
this.validateNow();
if (!stage || embedFonts)
{
return textWidth + mx_internal::TEXT_WIDTH_PADDING;
}
var loc1:*=transform.concatenatedMatrix;
return Math.abs(textWidth * loc1.a / loc1.d) + mx_internal::TEXT_WIDTH_PADDING;
}
public function get minHeight():Number
{
return 0;
}
public function get minWidth():Number
{
return 0;
}
{
mx_internal::VERSION = "4.1.0.16076";
mx_internal::TEXT_WIDTH_PADDING = 5;
mx_internal::TEXT_HEIGHT_PADDING = 4;
mx_internal::debuggingBorders = false;
}
public function get moduleFactory():mx.core.IFlexModuleFactory
{
return this._moduleFactory;
}
public function set moduleFactory(arg1:mx.core.IFlexModuleFactory):void
{
this._moduleFactory = arg1;
return;
}
public function get nestLevel():int
{
return this._nestLevel;
}
public function set nestLevel(arg1:int):void
{
if (arg1 > 1 && !(this._nestLevel == arg1))
{
this._nestLevel = arg1;
mx.styles.StyleProtoChain.initTextField(this);
this.mx_internal::styleChangedFlag = true;
this.validateNow();
}
return;
}
public function get nonInheritingStyles():Object
{
return this._nonInheritingStyles;
}
public function set nonInheritingStyles(arg1:Object):void
{
this._nonInheritingStyles = arg1;
return;
}
public function get percentHeight():Number
{
return NaN;
}
public function set percentHeight(arg1:Number):void
{
return;
}
public function get percentWidth():Number
{
return NaN;
}
public function set percentWidth(arg1:Number):void
{
return;
}
public function get processedDescriptors():Boolean
{
return this._processedDescriptors;
}
public function set processedDescriptors(arg1:Boolean):void
{
this._processedDescriptors = arg1;
return;
}
public function get styleManager():mx.styles.IStyleManager2
{
return mx.styles.StyleManager.getStyleManager(this.moduleFactory);
}
public function get styleName():Object
{
return this._styleName;
}
public function set styleName(arg1:Object):void
{
if (this._styleName === arg1)
{
return;
}
this._styleName = arg1;
if (this.parent)
{
mx.styles.StyleProtoChain.initTextField(this);
this.styleChanged("styleName");
}
return;
}
public function get systemManager():mx.managers.ISystemManager
{
var loc2:*=null;
var loc1:*=this.parent;
while (loc1)
{
loc2 = loc1 as mx.core.IUIComponent;
if (loc2)
{
return loc2.systemManager;
}
loc1 = loc1.parent;
}
return null;
}
public function set systemManager(arg1:mx.managers.ISystemManager):void
{
return;
}
public function get nonZeroTextHeight():Number
{
var loc1:*=NaN;
if (super.text == "")
{
super.text = "Wj";
loc1 = this.textHeight;
super.text = "";
return loc1;
}
return this.textHeight;
}
public override function get textHeight():Number
{
var loc1:*=super.textHeight;
if (numLines > 1)
{
loc1 = loc1 + getLineMetrics(1).leading;
}
return loc1;
}
public function get toolTip():String
{
return this.mx_internal::_toolTip;
}
public function set toolTip(arg1:String):void
{
var loc1:*=this.mx_internal::_toolTip;
this.mx_internal::_toolTip = arg1;
mx.managers.ToolTipManager.mx_internal::registerToolTip(this, loc1, arg1);
return;
}
public function get tweeningProperties():Array
{
return null;
}
public function set tweeningProperties(arg1:Array):void
{
return;
}
public function get updateCompletePendingFlag():Boolean
{
return this._updateCompletePendingFlag;
}
public function set updateCompletePendingFlag(arg1:Boolean):void
{
this._updateCompletePendingFlag = arg1;
return;
}
public override function setTextFormat(arg1:flash.text.TextFormat, arg2:int=-1, arg3:int=-1):void
{
if (styleSheet)
{
return;
}
super.setTextFormat(arg1, arg2, arg3);
dispatchEvent(new flash.events.Event("textFormatChange"));
return;
}
public override function insertXMLText(arg1:int, arg2:int, arg3:String, arg4:Boolean=false):void
{
super.insertXMLText(arg1, arg2, arg3, arg4);
dispatchEvent(new flash.events.Event("textInsert"));
return;
}
public override function replaceText(arg1:int, arg2:int, arg3:String):void
{
super.replaceText(arg1, arg2, arg3);
dispatchEvent(new flash.events.Event("textReplace"));
return;
}
public function initialize():void
{
return;
}
public function getExplicitOrMeasuredWidth():Number
{
return isNaN(this.explicitWidth) ? this.measuredWidth : this.explicitWidth;
}
public function getExplicitOrMeasuredHeight():Number
{
return isNaN(this.explicitHeight) ? this.measuredHeight : this.explicitHeight;
}
public function setVisible(arg1:Boolean, arg2:Boolean=false):void
{
this.visible = arg1;
return;
}
public function setFocus():void
{
this.systemManager.stage.focus = this;
return;
}
public function getUITextFormat():mx.core.UITextFormat
{
this.validateNow();
var loc1:*=new mx.core.UITextFormat(this.creatingSystemManager());
loc1.moduleFactory = this.moduleFactory;
loc1.mx_internal::copyFrom(getTextFormat());
loc1.antiAliasType = antiAliasType;
loc1.gridFitType = gridFitType;
loc1.sharpness = sharpness;
loc1.thickness = thickness;
return loc1;
}
public function move(arg1:Number, arg2:Number):void
{
if (this.x != arg1)
{
this.x = arg1;
}
if (this.y != arg2)
{
this.y = arg2;
}
return;
}
public function setActualSize(arg1:Number, arg2:Number):void
{
if (width != arg1)
{
this.width = arg1;
}
if (height != arg2)
{
height = arg2;
}
return;
}
public function getStyle(arg1:String):*
{
if (this.styleManager.inheritingStyles[arg1])
{
return this.inheritingStyles ? this.inheritingStyles[arg1] : mx.styles.IStyleClient(this.parent).getStyle(arg1);
}
return this.nonInheritingStyles ? this.nonInheritingStyles[arg1] : mx.styles.IStyleClient(this.parent).getStyle(arg1);
}
public function setStyle(arg1:String, arg2:*):void
{
return;
}
public function parentChanged(arg1:flash.display.DisplayObjectContainer):void
{
if (arg1)
{
if (arg1 is mx.styles.IStyleClient)
{
this.mx_internal::_parent = arg1;
}
else if (arg1 is mx.managers.SystemManager)
{
this.mx_internal::_parent = arg1;
}
else
{
this.mx_internal::_parent = arg1.parent;
}
}
else
{
this.mx_internal::_parent = null;
this._nestLevel = 0;
}
return;
}
public function styleChanged(arg1:String):void
{
this.mx_internal::styleChangedFlag = true;
if (!this.invalidateDisplayListFlag)
{
this.invalidateDisplayListFlag = true;
if ("callLater" in this.parent)
{
Object(this.parent).callLater(this.validateNow);
}
}
return;
}
public function validateNow():void
{
var loc1:*=false;
var loc2:*=null;
var loc3:*=null;
if (!this.parent)
{
return;
}
if (!isNaN(this.explicitWidth) && !(super.width == this.explicitWidth))
{
this.width = this.explicitWidth > 4 ? this.explicitWidth : 4;
}
if (!isNaN(this.explicitHeight) && !(super.height == this.explicitHeight))
{
super.height = this.explicitHeight;
}
if (this.mx_internal::styleChangedFlag)
{
loc1 = this.mirror;
this.mirror = this.getStyle("layoutDirection") == mx.core.LayoutDirection.RTL;
if (this.mirror || loc1)
{
this.validateTransformMatrix();
}
}
if (this.mx_internal::styleChangedFlag)
{
loc2 = this.getTextStyles();
if (loc2.font)
{
loc3 = noEmbeddedFonts || !embeddedFontRegistry ? null : embeddedFontRegistry.getAssociatedModuleFactory(loc2.font, loc2.bold, loc2.italic, this, this.moduleFactory, this.creatingSystemManager(), false);
embedFonts = !(loc3 == null);
}
else
{
embedFonts = this.getStyle("embedFonts");
}
if (this.getStyle("fontAntiAliasType") != undefined)
{
antiAliasType = this.getStyle("fontAntiAliasType");
gridFitType = this.getStyle("fontGridFitType");
sharpness = this.getStyle("fontSharpness");
thickness = this.getStyle("fontThickness");
}
if (!styleSheet)
{
super.setTextFormat(loc2);
defaultTextFormat = loc2;
}
dispatchEvent(new flash.events.Event("textFieldStyleChange"));
}
this.mx_internal::styleChangedFlag = false;
this.invalidateDisplayListFlag = false;
return;
}
internal function validateTransformMatrix():void
{
var loc1:*=null;
var loc2:*=null;
if (this.mirror)
{
loc1 = this.transform.matrix;
loc1.a = -1;
loc1.tx = this._x + width;
transform.matrix = loc1;
}
else
{
loc2 = new flash.geom.Matrix();
loc2.tx = this._x;
loc2.ty = y;
transform.matrix = loc2;
}
return;
}
public function getTextStyles():flash.text.TextFormat
{
var loc1:*=new flash.text.TextFormat();
var loc2:*=this.getStyle("textAlign");
var loc3:*=this.getStyle("direction");
if (loc2 != "start")
{
if (loc2 != "end")
{
if (loc2 == "justify" && loc3 == "rtl")
{
loc2 = flash.text.TextFormatAlign.RIGHT;
}
}
else
{
loc2 = loc3 != "ltr" ? flash.text.TextFormatAlign.LEFT : flash.text.TextFormatAlign.RIGHT;
}
}
else
{
loc2 = loc3 != "ltr" ? flash.text.TextFormatAlign.RIGHT : flash.text.TextFormatAlign.LEFT;
}
loc1.align = loc2;
loc1.bold = this.getStyle("fontWeight") == "bold";
if (this.enabled)
{
if (this.mx_internal::explicitColor != mx.styles.StyleManager.NOT_A_COLOR)
{
loc1.color = this.mx_internal::explicitColor;
}
else
{
loc1.color = this.getStyle("color");
}
}
else
{
loc1.color = this.getStyle("disabledColor");
}
loc1.font = mx.utils.StringUtil.trimArrayElements(this.getStyle("fontFamily"), ",");
loc1.indent = this.getStyle("textIndent");
loc1.italic = this.getStyle("fontStyle") == "italic";
var loc4:*;
if ((loc4 = this.getStyle("kerning")) == "auto" || loc4 == "on")
{
loc4 = true;
}
else if (loc4 == "default" || loc4 == "off")
{
loc4 = false;
}
loc1.kerning = loc4;
loc1.leading = this.getStyle("leading");
loc1.leftMargin = this.ignorePadding ? 0 : this.getStyle("paddingLeft");
loc1.letterSpacing = this.getStyle("letterSpacing");
loc1.rightMargin = this.ignorePadding ? 0 : this.getStyle("paddingRight");
loc1.size = this.getStyle("fontSize");
loc1.underline = this.getStyle("textDecoration") == "underline";
this.cachedTextFormat = loc1;
return loc1;
}
public function setColor(arg1:uint):void
{
this.mx_internal::explicitColor = arg1;
this.mx_internal::styleChangedFlag = true;
this.invalidateDisplayListFlag = true;
this.validateNow();
return;
}
public function invalidateSize():void
{
this.invalidateDisplayListFlag = true;
return;
}
mx_internal static const VERSION:String="4.1.0.16076";
mx_internal static const TEXT_WIDTH_PADDING:int=5;
mx_internal static const TEXT_HEIGHT_PADDING:int=4;
internal var explicitHTMLText:String=null;
mx_internal var explicitColor:uint=4294967295;
internal var resourceManager:mx.resources.IResourceManager;
internal var untruncatedText:String;
internal var mirror:Boolean=false;
internal var _x:Number=0;
mx_internal var _parent:flash.display.DisplayObjectContainer;
internal var _automationDelegate:mx.automation.IAutomationObject;
internal var _automationName:String;
internal var _document:Object;
internal var _enabled:Boolean=true;
internal var _explicitHeight:Number;
internal var _explicitWidth:Number;
internal var _ignorePadding:Boolean=tru
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment