@@ -24,7 +24,7 @@

 %endif

 Name:           lightspark

-Version:        0.7.2.99+git20150403.1618

+Version:        0.7.2.99+git20150419.1419

 Release:        0

 Summary:        Modern, free, open-source flash player implementation

 License:        LGPL-3.0+

​

@@ -110,6 +110,7 @@

 //Events

 REGISTER_CLASS_NAME(AsyncErrorEvent,"flash.events")

+REGISTER_CLASS_NAME(ContextMenuEvent,"flash.events")

 REGISTER_CLASS_NAME(DRMErrorEvent,"flash.events")

 REGISTER_CLASS_NAME(DRMStatusEvent,"flash.events")

 REGISTER_CLASS_NAME(DataEvent,"flash.events")

@@ -119,6 +120,7 @@

 REGISTER_CLASS_NAME(EventPhase,"flash.events")

 REGISTER_CLASS_NAME(FocusEvent,"flash.events")

 REGISTER_CLASS_NAME(FullScreenEvent,"flash.events")

+REGISTER_CLASS_NAME(GestureEvent,"flash.events")

 REGISTER_CLASS_NAME(HTTPStatusEvent,"flash.events")

 REGISTER_CLASS_NAME(IEventDispatcher,"flash.events")

 REGISTER_CLASS_NAME(IOErrorEvent,"flash.events")

@@ -126,6 +128,7 @@

 REGISTER_CLASS_NAME(KeyboardEvent,"flash.events")

 REGISTER_CLASS_NAME(MouseEvent,"flash.events")

 REGISTER_CLASS_NAME(NetStatusEvent,"flash.events")

+REGISTER_CLASS_NAME(PressAndTapGestureEvent,"flash.events")

 REGISTER_CLASS_NAME(ProgressEvent,"flash.events")

 REGISTER_CLASS_NAME(SecurityErrorEvent,"flash.events")

 REGISTER_CLASS_NAME(StageVideoEvent,"flash.events")

@@ -133,7 +136,8 @@

 REGISTER_CLASS_NAME(StatusEvent,"flash.events")

 REGISTER_CLASS_NAME(TextEvent,"flash.events")

 REGISTER_CLASS_NAME(TimerEvent,"flash.events")

-REGISTER_CLASS_NAME(ContextMenuEvent,"flash.events")

+REGISTER_CLASS_NAME(TouchEvent,"flash.events")

+REGISTER_CLASS_NAME(TransformGestureEvent,"flash.events")

 REGISTER_CLASS_NAME(UncaughtErrorEvent,"flash.events")

 //External interface (browser interaction)

@@ -166,11 +170,13 @@

 //Net

 REGISTER_CLASS_NAME(NetConnection,"flash.net")

 REGISTER_CLASS_NAME(NetStream,"flash.net")

+REGISTER_CLASS_NAME(NetStreamAppendBytesAction,"flash.net")

 REGISTER_CLASS_NAME(NetStreamPlayTransitions,"flash.net")

 REGISTER_CLASS_NAME(NetStreamPlayOptions,"flash.net")

 REGISTER_CLASS_NAME(ObjectEncoding,"flash.net")

 REGISTER_CLASS_NAME(Responder,"flash.net")

 REGISTER_CLASS_NAME(SharedObject,"flash.net")

+REGISTER_CLASS_NAME(SharedObjectFlushStatus,"flash.net")

 REGISTER_CLASS_NAME(URLLoader,"flash.net")

 REGISTER_CLASS_NAME(URLLoaderDataFormat,"flash.net")

 REGISTER_CLASS_NAME(URLRequest,"flash.net")

@@ -223,12 +229,18 @@

 REGISTER_CLASS_NAME(EastAsianJustifier,"flash.text.engine")

 REGISTER_CLASS_NAME(ElementFormat,"flash.text.engine")

 REGISTER_CLASS_NAME(FontDescription,"flash.text.engine")

+REGISTER_CLASS_NAME(FontMetrics,"flash.text.engine")

+REGISTER_CLASS_NAME(FontLookup,"flash.text.engine")

 REGISTER_CLASS_NAME(FontWeight,"flash.text.engine")

+REGISTER_CLASS_NAME(Kerning,"flash.text.engine")

+REGISTER_CLASS_NAME(LineJustification,"flash.text.engine")

 REGISTER_CLASS_NAME(SpaceJustifier,"flash.text.engine")

+REGISTER_CLASS_NAME(TextBaseline,"flash.text.engine")

 REGISTER_CLASS_NAME(TextBlock,"flash.text.engine")

 REGISTER_CLASS_NAME(TextElement,"flash.text.engine")

 REGISTER_CLASS_NAME(TextJustifier,"flash.text.engine")

 REGISTER_CLASS_NAME(TextLine,"flash.text.engine")

+REGISTER_CLASS_NAME(TextLineValidity,"flash.text.engine")

 //Utils

 REGISTER_CLASS_NAME(ByteArray,"flash.utils")

​

@@ -421,7 +421,7 @@

 }

 bool ASObject::isConstructed() const

 {

-   return traitsInitialized && constructorCalled;

+   return traitsInitialized && constructIndicator;

 }

 variables_map::variables_map(MemoryAccount* m):

    Variables(std::less<mapType::key_type>(), reporter_allocator<mapType::value_type>(m)),slots_vars(m)

@@ -703,7 +703,8 @@

    {

        //Initializing an already existing variable

        LOG(LOG_NOT_IMPLEMENTED,"Variable " << name << "already initialized");

-       o->decRef();

+       if (o != NULL)

+           o->decRef();

        return;

    }

@@ -900,7 +901,21 @@

    {

        if (obj == NULL) // create dynamic object

        {

-           if(mainObj->is<Class_base>() &&

+           if (type == Type::anyType)

+           {

+               // type could not be found, so it's stored as an uninitialized variable

+               uninitializedVar v;

+               mainObj->incRef();

+               v.mainObj = mainObj;

+               v.mname = mname;

+               v.traitKind = traitKind;

+               v.typemname = *typemname;

+               context->uninitializedVars.push_back(v);

+               

+               obj = getSys()->getUndefinedRef();

+               obj = type->coerce(obj);

+           }

+           else if(mainObj->is<Class_base>() &&

                mainObj->as<Class_base>()->class_name.getQualifiedName() == typemname->qualifiedString())

            {

                // avoid recursive construction

@@ -915,9 +930,9 @@

            else

            {

                obj = getSys()->getUndefinedRef();

+               obj = type->coerce(obj);

            }

        }

-       obj = type->coerce(obj);

    }

    assert(traitKind==DECLARED_TRAIT || traitKind==CONSTANT_TRAIT);

@@ -1267,7 +1282,7 @@

 }

 ASObject::ASObject(MemoryAccount* m):Variables(m),classdef(NULL),proxyMultiName(NULL),

-   type(T_OBJECT),traitsInitialized(false),constructorCalled(false),implEnable(true)

+   type(T_OBJECT),traitsInitialized(false),constructIndicator(false),implEnable(true)

 {

 #ifndef NDEBUG

    //Stuff only used in debugging

@@ -1276,7 +1291,7 @@

 }

 ASObject::ASObject(Class_base* c):Variables((c)?c->memoryAccount:NULL),classdef(NULL),proxyMultiName(NULL),

-   type(T_OBJECT),traitsInitialized(false),constructorCalled(false),implEnable(true)

+   type(T_OBJECT),traitsInitialized(false),constructIndicator(false),implEnable(true)

 {

    setClass(c);

 #ifndef NDEBUG

@@ -1286,7 +1301,7 @@

 }

 ASObject::ASObject(const ASObject& o):Variables((o.classdef)?o.classdef->memoryAccount:NULL),classdef(NULL),proxyMultiName(NULL),

-   type(o.type),traitsInitialized(false),constructorCalled(false),implEnable(true)

+   type(o.type),traitsInitialized(false),constructIndicator(false),implEnable(true)

 {

    if(o.classdef)

        setClass(o.classdef);

​

@@ -283,7 +283,7 @@

    virtual ~ASObject();

    SWFOBJECT_TYPE type;

    bool traitsInitialized:1;

-   bool constructorCalled:1;

+   bool constructIndicator:1;

    void serializeDynamicProperties(ByteArray* out, std::map<tiny_string, uint32_t>& stringMap,

                std::map<const ASObject*, uint32_t>& objMap,

                std::map<const Class_base*, uint32_t> traitsMap) const;

@@ -428,7 +428,7 @@

    bool isPrimitive() const;

    bool isInitialized() const {return traitsInitialized;}

-   bool isConstructed() const;

+   virtual bool isConstructed() const;

    /* helper functions for calling the "valueOf" and

     * "toString" AS-functions which may be members of this

@@ -495,6 +495,8 @@

    void applyProxyProperty(multiname &name); 

    void dumpVariables() { Variables.dumpVariables(); }

+   

+   void setConstructIndicator() { constructIndicator = true; }

 };

 class Number;

​

@@ -125,8 +125,6 @@

    //-- DOWNLOADED DATA

    //File length (can change in certain cases, resulting in reallocation of the buffer (non-cached))

    uint32_t length;

-   //Append data to the internal buffer

-   void append(uint8_t* buffer, uint32_t length);

    //Set the length of the downloaded file, can be called multiple times to accomodate a growing file

    void setLength(uint32_t _length);

 public:

@@ -163,7 +161,8 @@

    bool isRedirected() { return redirected; }

    const tiny_string& getOriginalURL() { return originalURL; }

    uint16_t getRequestStatus() { return requestStatus; }

-

+   //Append data to the internal buffer

+   void append(uint8_t* buffer, uint32_t length);

 };

 class ThreadedDownloader : public Downloader, public IThreadJob

​

@@ -360,10 +360,16 @@

    builtin->registerBuiltin("ContentElement","flash.text.engine",Class<ContentElement>::getRef());

    builtin->registerBuiltin("ElementFormat","flash.text.engine",Class<ElementFormat>::getRef());

    builtin->registerBuiltin("FontDescription","flash.text.engine",Class<FontDescription>::getRef());

+   builtin->registerBuiltin("FontMetrics","flash.text.engine",Class<FontMetrics>::getRef());

+   builtin->registerBuiltin("FontLookup","flash.text.engine",Class<FontLookup>::getRef());

    builtin->registerBuiltin("FontWeight","flash.text.engine",Class<FontWeight>::getRef());

+   builtin->registerBuiltin("Kerning","flash.text.engine",Class<Kerning>::getRef());

+   builtin->registerBuiltin("LineJustification","flash.text.engine",Class<LineJustification>::getRef());

+   builtin->registerBuiltin("TextBaseline","flash.text.engine",Class<TextBaseline>::getRef());

    builtin->registerBuiltin("TextBlock","flash.text.engine",Class<TextBlock>::getRef());

    builtin->registerBuiltin("TextElement","flash.text.engine",Class<TextElement>::getRef());

    builtin->registerBuiltin("TextLine","flash.text.engine",Class<TextLine>::getRef());

+   builtin->registerBuiltin("TextLineValidity","flash.text.engine",Class<TextLineValidity>::getRef());

    builtin->registerBuiltin("TextJustifier","flash.text.engine",Class<TextJustifier>::getRef());

    builtin->registerBuiltin("SpaceJustifier","flash.text.engine",Class<SpaceJustifier>::getRef());

    builtin->registerBuiltin("EastAsianJustifier","flash.text.engine",Class<EastAsianJustifier>::getRef());

@@ -389,6 +395,8 @@

    builtin->registerBuiltin("clearInterval","flash.utils",_MR(Class<IFunction>::getFunction(clearInterval)));

    builtin->registerBuiltin("clearTimeout","flash.utils",_MR(Class<IFunction>::getFunction(clearTimeout)));

    builtin->registerBuiltin("describeType","flash.utils",_MR(Class<IFunction>::getFunction(describeType)));

+   builtin->registerBuiltin("escapeMultiByte","flash.utils",_MR(Class<IFunction>::getFunction(escapeMultiByte)));

+   builtin->registerBuiltin("unescapeMultiByte","flash.utils",_MR(Class<IFunction>::getFunction(unescapeMultiByte)));

    builtin->registerBuiltin("IExternalizable","flash.utils",InterfaceClass<IExternalizable>::getRef());

    builtin->registerBuiltin("IDataInput","flash.utils",InterfaceClass<IDataInput>::getRef());

    builtin->registerBuiltin("IDataOutput","flash.utils",InterfaceClass<IDataOutput>::getRef());

@@ -424,10 +432,10 @@

    builtin->registerBuiltin("DRMStatusEvent","flash.events",Class<DRMStatusEvent>::getRef());

    builtin->registerBuiltin("StageVideoEvent","flash.events",Class<StageVideoEvent>::getRef());

    builtin->registerBuiltin("StageVideoAvailabilityEvent","flash.events",Class<StageVideoAvailabilityEvent>::getRef());

-   builtin->registerBuiltin("TouchEvent","flash.events",Class<ASObject>::getStubClass(QName("TouchEvent","flash.events")));

-   builtin->registerBuiltin("GestureEvent","flash.events",Class<ASObject>::getStubClass(QName("GestureEvent","flash.events")));

-   builtin->registerBuiltin("PressAndTapGestureEvent","flash.events",Class<ASObject>::getStubClass(QName("PressAndTapGestureEvent","flash.events")));

-   builtin->registerBuiltin("TransformGestureEvent","flash.events",Class<ASObject>::getStubClass(QName("TransformGestureEvent","flash.events")));

+   builtin->registerBuiltin("TouchEvent","flash.events",Class<TouchEvent>::getRef());

+   builtin->registerBuiltin("GestureEvent","flash.events",Class<GestureEvent>::getRef());

+   builtin->registerBuiltin("PressAndTapGestureEvent","flash.events",Class<PressAndTapGestureEvent>::getRef());

+   builtin->registerBuiltin("TransformGestureEvent","flash.events",Class<TransformGestureEvent>::getRef());

    builtin->registerBuiltin("ContextMenuEvent","flash.events",Class<ContextMenuEvent>::getRef());

    builtin->registerBuiltin("UncaughtErrorEvent","flash.events",Class<UncaughtErrorEvent>::getRef());

@@ -436,6 +444,7 @@

    builtin->registerBuiltin("LocalConnection","flash.net",Class<ASObject>::getStubClass(QName("LocalConnection","flash.net")));

    builtin->registerBuiltin("NetConnection","flash.net",Class<NetConnection>::getRef());

    builtin->registerBuiltin("NetStream","flash.net",Class<NetStream>::getRef());

+   builtin->registerBuiltin("NetStreamAppendBytesAction","flash.net",Class<NetStreamAppendBytesAction>::getRef());

    builtin->registerBuiltin("NetStreamPlayOptions","flash.net",Class<NetStreamPlayOptions>::getRef());

    builtin->registerBuiltin("NetStreamPlayTransitions","flash.net",Class<NetStreamPlayTransitions>::getRef());

    builtin->registerBuiltin("URLLoader","flash.net",Class<URLLoader>::getRef());

@@ -446,6 +455,7 @@

    builtin->registerBuiltin("URLRequestMethod","flash.net",Class<URLRequestMethod>::getRef());

    builtin->registerBuiltin("URLVariables","flash.net",Class<URLVariables>::getRef());

    builtin->registerBuiltin("SharedObject","flash.net",Class<SharedObject>::getRef());

+   builtin->registerBuiltin("SharedObjectFlushStatus","flash.net",Class<SharedObjectFlushStatus>::getRef());

    builtin->registerBuiltin("ObjectEncoding","flash.net",Class<ObjectEncoding>::getRef());

    builtin->registerBuiltin("Socket","flash.net",Class<ASObject>::getStubClass(QName("Socket","flash.net")));

    builtin->registerBuiltin("Responder","flash.net",Class<Responder>::getRef());

@@ -1343,7 +1353,7 @@

    Class_inherit* derived_class_tmp=static_cast<Class_inherit*>(derived_class);

    if(derived_class_tmp->isBinded())

    {

-       LOG(LOG_ERROR, "Class already binded to a tag. Not binding");

+       LOG(LOG_ERROR, "Class already binded to a tag. Not binding:"<<s<< " class:"<<derived_class_tmp->getQualifiedClassName());

        return NULL;

    }

    return derived_class_tmp;

@@ -1539,6 +1549,17 @@

        ret->decRef();

    entry->decRef();

+   

+   // initialize vars where type was not known during script init

+   // this may happen for variables of private classes defined in this script

+   for (auto it = uninitializedVars.begin(); it != uninitializedVars.end(); it++)

+   {

+       uninitializedVar v = *it;

+       LOG(LOG_CALLS,"initialize uninitialized var:"<< v.mainObj->toDebugString()<<" "<< v.mname << " " <<v.typemname);

+       v.mainObj->initializeVariableByMultiname(v.mname,NULL,&v.typemname,this,v.traitKind);

+       v.mainObj->decRef();

+   }

+   uninitializedVars.clear();

    LOG(LOG_CALLS, "Finished script init for script " << i );

 }

@@ -2039,9 +2060,17 @@

                //do interfaces have cinit methods?

                //TODO: call them, set constructor property, do something

                if(classes[t->classi].cinit != 0)

-                   LOG(LOG_NOT_IMPLEMENTED,"Interface cinit (static):"<<className);

+               {

+                   method_info* m=&methods[classes[t->classi].cinit];

+                   if (m->body)

+                       LOG(LOG_NOT_IMPLEMENTED,"Interface cinit (static):"<<className);

+               }

                if(instances[t->classi].init != 0)

-                   LOG(LOG_NOT_IMPLEMENTED,"Interface cinit (constructor):"<<className);

+               {

+                   method_info* m=&methods[instances[t->classi].init];

+                   if (m->body)

+                       LOG(LOG_NOT_IMPLEMENTED,"Interface cinit (constructor):"<<className);

+               }

                ret = ci;

            }

            else

​

@@ -142,6 +142,15 @@

    ARGS_TYPE type;

 };

+struct uninitializedVar

+{

+   uninitializedVar():mname(NULL),mainObj(NULL),typemname(NULL),traitKind(NO_CREATE_TRAIT) {}

+   multiname mname;

+   ASObject* mainObj;

+   multiname typemname;

+   TRAIT_KIND traitKind;

+};

+

 class ABCContext

 {

 friend class ABCVm;

@@ -174,6 +183,9 @@

    uint32_t namespaceBaseId;

    std::vector<bool> hasRunScriptInit;

+   // list of vars that have to be initialized after script init is done

+   std::vector<uninitializedVar> uninitializedVars;

+

    /**

        Construct and insert in the a object a given trait

        @param obj the tarhget object

​

@@ -366,7 +366,7 @@

            }

        }

-       LOG(LOG_NOT_IMPLEMENTED,"callProperty: " << name->normalizedName() << " not found on " << obj->toDebugString());

+       LOG(LOG_NOT_IMPLEMENTED,"callProperty: " << name->qualifiedString() << " not found on " << obj->toDebugString());

        if(keepReturn)

            th->runtime_stack_push(getSys()->getUndefinedRef());

@@ -1892,7 +1892,7 @@

            namearg->setProxyProperty(*name);

            proxyArgs[1]=namearg;

            LOG(LOG_ERROR,"Proxy::getDescend:"<<namearg->toDebugString()<<*name);

-           

+

            //We now suppress special handling

            LOG(LOG_CALLS,_("Proxy::callProperty"));

            f->incRef();

@@ -2044,7 +2044,8 @@

    ret->context=th->context;

    //Null is a "valid" base class

-   if(baseClass->getObjectType()!=T_NULL)

+   // Undefined is used in private Classes that will be defined later

+   if(baseClass->getObjectType()!=T_NULL && baseClass->getObjectType()!=T_UNDEFINED)

    {

        assert_and_throw(baseClass->is<Class_base>());

        Class_base* base = baseClass->as<Class_base>();

@@ -2075,7 +2076,7 @@

    for(unsigned int i=0;i<cur->trait_count;i++)

    {

        int kind=cur->traits[i].kind&0xf;

-       if(kind==traits_info::Method || kind==traits_info::Setter || kind==traits_info::Getter)

+       if(kind==traits_info::Method || kind==traits_info::Setter || kind==traits_info::Getter || kind==traits_info::Slot)

            th->context->buildTrait(ret,&cur->traits[i],true);

    }

@@ -2165,7 +2166,7 @@

    }

    assert_and_throw(ret2->is<Undefined>());

    ret2->decRef();

-   LOG(LOG_CALLS,_("End of Class init ") << ret);

+   LOG(LOG_CALLS,_("End of Class init ") << *mname <<" " <<ret);

    th->runtime_stack_push(ret);

    cinit->decRef();

​

@@ -54,14 +54,14 @@

 LoaderInfo::LoaderInfo(Class_base* c):EventDispatcher(c),applicationDomain(NullRef),securityDomain(NullRef),

    contentType("application/x-shockwave-flash"),

    bytesLoaded(0),bytesTotal(0),sharedEvents(NullRef),

-   loader(NullRef),bytesData(NullRef),loadStatus(STARTED),actionScriptVersion(3),childAllowsParent(true)

+   loader(NullRef),bytesData(NullRef),loadStatus(STARTED),actionScriptVersion(3),swfVersion(0),childAllowsParent(true)

 {

 }

 LoaderInfo::LoaderInfo(Class_base* c, _R<Loader> l):EventDispatcher(c),applicationDomain(NullRef),securityDomain(NullRef),

    contentType("application/x-shockwave-flash"),

    bytesLoaded(0),bytesTotal(0),sharedEvents(NullRef),

-   loader(l),bytesData(NullRef),loadStatus(STARTED),actionScriptVersion(3),childAllowsParent(true)

+   loader(l),bytesData(NullRef),loadStatus(STARTED),actionScriptVersion(3),swfVersion(0),childAllowsParent(true)

 {

 }

@@ -81,6 +81,7 @@

    c->setDeclaredMethodByQName("height","",Class<IFunction>::getFunction(_getHeight),GETTER_METHOD,true);

    REGISTER_GETTER(c,parameters);

    REGISTER_GETTER(c,actionScriptVersion);

+   REGISTER_GETTER(c,swfVersion);

    REGISTER_GETTER(c,childAllowsParent);

    REGISTER_GETTER(c,contentType);

 }

@@ -89,6 +90,7 @@

 ASFUNCTIONBODY_GETTER(LoaderInfo,actionScriptVersion);

 ASFUNCTIONBODY_GETTER(LoaderInfo,childAllowsParent);

 ASFUNCTIONBODY_GETTER(LoaderInfo,contentType);

+ASFUNCTIONBODY_GETTER(LoaderInfo,swfVersion);

 void LoaderInfo::buildTraits(ASObject* o)

 {

@@ -164,9 +166,6 @@

        return;

    if(!loader.isNull() && obj==waitedObject)

        loader->setContent(obj);

-   if (bytesData.isNull())

-       bytesData = _NR<ByteArray>(Class<ByteArray>::getInstanceS());

-   bytesData->writeObject(obj.getPtr());

    sendInit();

    waitedObject.reset();

 }

@@ -253,6 +252,11 @@

 ASFUNCTIONBODY(LoaderInfo,_getBytes)

 {

    LoaderInfo* th=static_cast<LoaderInfo*>(obj);

+   if (th->bytesData.isNull())

+       th->bytesData = _NR<ByteArray>(Class<ByteArray>::getInstanceS());

+   if (!th->loader->getContent().isNull())

+       th->bytesData->writeObject(th->loader->getContent().getPtr());

+

    return th->bytesData.getPtr();

 }

@@ -317,6 +321,9 @@

        // Wait for some data, making sure our check for failure is working

        sbuf->sgetc(); // peek one byte

+       if(downloader->getRequestStatus() == 204) // empty answer

+           return;

+

        if(cache->hasFailed()) //Check to see if the download failed for some reason

        {

            LOG(LOG_ERROR, "Loader::execute(): Download of URL failed: " << url);

​

@@ -247,6 +247,7 @@

    void sendInit();

 public:

    ASPROPERTY_GETTER(uint32_t,actionScriptVersion);

+   ASPROPERTY_GETTER(uint32_t,swfVersion);

    ASPROPERTY_GETTER(bool, childAllowsParent);

    LoaderInfo(Class_base* c);

    LoaderInfo(Class_base* c, _R<Loader> l);

​

@@ -1285,3 +1285,38 @@

    c->setVariableByQName("MENU_ITEM_SELECT","",Class<ASString>::getInstanceS("menuItemSelect"),DECLARED_TRAIT);

    c->setVariableByQName("MENU_SELECT","",Class<ASString>::getInstanceS("menuSelect"),DECLARED_TRAIT);

 }

+

+

+void TouchEvent::sinit(Class_base* c)

+{

+   CLASS_SETUP(c, Event, _constructor, CLASS_SEALED);

+   c->setVariableByQName("TOUCH_BEGIN","",Class<ASString>::getInstanceS("touchBegin"),DECLARED_TRAIT);

+   c->setVariableByQName("TOUCH_END","",Class<ASString>::getInstanceS("touchEnd"),DECLARED_TRAIT);

+   c->setVariableByQName("TOUCH_MOVE","",Class<ASString>::getInstanceS("touchMove"),DECLARED_TRAIT);

+   c->setVariableByQName("TOUCH_OUT","",Class<ASString>::getInstanceS("touchOut"),DECLARED_TRAIT);

+   c->setVariableByQName("TOUCH_OVER","",Class<ASString>::getInstanceS("touchOver"),DECLARED_TRAIT);

+   c->setVariableByQName("TOUCH_ROLL_OUT","",Class<ASString>::getInstanceS("touchRollOut"),DECLARED_TRAIT);

+   c->setVariableByQName("TOUCH_ROLL_OVER","",Class<ASString>::getInstanceS("touchRollOver"),DECLARED_TRAIT);

+   c->setVariableByQName("TOUCH_TAP","",Class<ASString>::getInstanceS("touchTap"),DECLARED_TRAIT);

+}

+

+void GestureEvent::sinit(Class_base* c)

+{

+   CLASS_SETUP(c, Event, _constructor, CLASS_SEALED);

+   c->setVariableByQName("GESTURE_TWO_FINGER_TAP","",Class<ASString>::getInstanceS("gestureTwoFingerTap"),DECLARED_TRAIT);

+}

+

+void PressAndTapGestureEvent::sinit(Class_base* c)

+{

+   CLASS_SETUP(c, GestureEvent, _constructor, CLASS_SEALED);

+   c->setVariableByQName("GESTURE_PRESS_AND_TAP","",Class<ASString>::getInstanceS("gesturePressAndTap"),DECLARED_TRAIT);

+}

+

+void TransformGestureEvent::sinit(Class_base* c)

+{

+   CLASS_SETUP(c, GestureEvent, _constructor, CLASS_SEALED);

+   c->setVariableByQName("GESTURE_PAN","",Class<ASString>::getInstanceS("gesturePan"),DECLARED_TRAIT);

+   c->setVariableByQName("GESTURE_ROTATE","",Class<ASString>::getInstanceS("gestureRotate"),DECLARED_TRAIT);

+   c->setVariableByQName("GESTURE_SWIPE","",Class<ASString>::getInstanceS("gestureSwipe"),DECLARED_TRAIT);

+   c->setVariableByQName("GESTURE_ZOOM","",Class<ASString>::getInstanceS("gestureZoom"),DECLARED_TRAIT);

+}

​

@@ -536,5 +536,37 @@

    static void buildTraits(ASObject* o) {}

 };

+class TouchEvent: public Event

+{

+public:

+   TouchEvent(Class_base* c) : Event(c, "TouchEvent") {}

+   static void sinit(Class_base*);

+   static void buildTraits(ASObject* o) {}

+};

+

+class GestureEvent: public Event

+{

+public:

+   GestureEvent(Class_base* c, const tiny_string& t = "GestureEvent") : Event(c, t) {}

+   static void sinit(Class_base*);

+   static void buildTraits(ASObject* o) {}

+};

+

+class PressAndTapGestureEvent: public GestureEvent

+{

+public:

+   PressAndTapGestureEvent(Class_base* c) : GestureEvent(c, "PressAndTapGestureEvent") {}

+   static void sinit(Class_base*);

+   static void buildTraits(ASObject* o) {}

+};

+class TransformGestureEvent: public GestureEvent

+{

+public:

+   TransformGestureEvent(Class_base* c) : GestureEvent(c, "TransformGestureEvent") {}

+   static void sinit(Class_base*);

+   static void buildTraits(ASObject* o) {}

+};

+

+

 }

 #endif /* SCRIPTING_FLASH_EVENTS_FLASHEVENTS_H */

​

@@ -589,6 +589,13 @@

    c->setVariableByQName("BINARY","",Class<ASString>::getInstanceS("binary"),DECLARED_TRAIT);

 }

+void SharedObjectFlushStatus::sinit(Class_base* c)

+{

+   CLASS_SETUP_NO_CONSTRUCTOR(c, ASObject, CLASS_FINAL);

+   c->setVariableByQName("FLUSHED","",Class<ASString>::getInstanceS("flushed"),DECLARED_TRAIT);

+   c->setVariableByQName("PENDING","",Class<ASString>::getInstanceS("pending"),DECLARED_TRAIT);

+}

+

 SharedObject::SharedObject(Class_base* c):EventDispatcher(c)

 {

    data=_MR(new_asobject());

@@ -601,7 +608,7 @@

    CLASS_SETUP_NO_CONSTRUCTOR(c, EventDispatcher, CLASS_SEALED);

    c->setDeclaredMethodByQName("getLocal","",Class<IFunction>::getFunction(getLocal),NORMAL_METHOD,false);

    REGISTER_GETTER(c,data);

-};

+}

 ASFUNCTIONBODY_GETTER(SharedObject,data);

@@ -984,6 +991,14 @@

    soundTransform = _MNR(Class<SoundTransform>::getInstanceS());

 }

+void NetStreamAppendBytesAction::sinit(Class_base* c)

+{

+   CLASS_SETUP_NO_CONSTRUCTOR(c, ASObject, CLASS_FINAL);

+   c->setVariableByQName("END_SEQUENCE","",Class<ASString>::getInstanceS("endSequence"),DECLARED_TRAIT);

+   c->setVariableByQName("RESET_BEGIN","",Class<ASString>::getInstanceS("resetBegin"),DECLARED_TRAIT);

+   c->setVariableByQName("RESET_SEEK","",Class<ASString>::getInstanceS("resetSeek"),DECLARED_TRAIT);

+}

+

 void NetStream::finalize()

 {

    EventDispatcher::finalize();

@@ -1019,6 +1034,8 @@

    c->setDeclaredMethodByQName("checkPolicyFile","",Class<IFunction>::getFunction(_getCheckPolicyFile),GETTER_METHOD,true);

    c->setDeclaredMethodByQName("checkPolicyFile","",Class<IFunction>::getFunction(_setCheckPolicyFile),SETTER_METHOD,true);

    c->setDeclaredMethodByQName("attach","",Class<IFunction>::getFunction(attach),NORMAL_METHOD,true);

+   c->setDeclaredMethodByQName("appendBytes","",Class<IFunction>::getFunction(appendBytes),NORMAL_METHOD,true);

+   c->setDeclaredMethodByQName("appendBytesAction","",Class<IFunction>::getFunction(appendBytesAction),NORMAL_METHOD,true);

    REGISTER_GETTER(c, backBufferLength);

    REGISTER_GETTER_SETTER(c, backBufferTime);

    REGISTER_GETTER(c, bufferLength);

@@ -1253,6 +1270,7 @@

 ASFUNCTIONBODY(NetStream,seek)

 {

    //NetStream* th=Class<NetStream>::cast(obj);

+   LOG(LOG_NOT_IMPLEMENTED,"NetStream.seek is not implemented yet");

    assert_and_throw(argslen == 1);

    return NULL;

 }

@@ -1267,6 +1285,23 @@

    th->connection=netConnection;

    return NULL;

 }

+ASFUNCTIONBODY(NetStream,appendBytes)

+{

+   NetStream* th=Class<NetStream>::cast(obj);

+   _NR<ByteArray> bytearray;

+   ARG_UNPACK(bytearray);

+   

+   if(!bytearray.isNull())

+       th->downloader->append(bytearray->getBuffer(bytearray->getLength(),false),bytearray->getLength());

+   return NULL;

+}

+ASFUNCTIONBODY(NetStream,appendBytesAction)

+{

+   //NetStream* th=Class<NetStream>::cast(obj);

+   LOG(LOG_NOT_IMPLEMENTED,"NetStream.appendBytesAction is not implemented yet");

+   assert_and_throw(argslen == 1);

+   return NULL;

+}

 //Tick is called from the timer thread, this happens only if a decoder is available

 void NetStream::tick()

​

@@ -94,6 +94,14 @@

    static void sinit(Class_base*);

 };

+

+class SharedObjectFlushStatus: public ASObject

+{

+public:

+   SharedObjectFlushStatus(Class_base* c):ASObject(c){}

+   static void sinit(Class_base*);

+};

+

 class SharedObject: public EventDispatcher

 {

 public:

@@ -208,6 +216,14 @@

    ASPROPERTY_GETTER_SETTER(NullableRef<ASObject>,client);

 };

+class NetStreamAppendBytesAction: public ASObject

+{

+public:

+   NetStreamAppendBytesAction(Class_base* c):ASObject(c){}

+   static void sinit(Class_base*);

+};

+

+

 class SoundTransform;

 class NetStream: public EventDispatcher, public IThreadJob, public ITickJob

 {

@@ -273,6 +289,8 @@

    ASFUNCTION(_getCheckPolicyFile);

    ASFUNCTION(_setCheckPolicyFile);

    ASFUNCTION(attach);

+   ASFUNCTION(appendBytes);

+   ASFUNCTION(appendBytesAction);

    ASPROPERTY_GETTER(number_t, backBufferLength);

    ASPROPERTY_GETTER_SETTER(number_t, backBufferTime);

    ASPROPERTY_GETTER(number_t, bufferLength);

​

@@ -287,7 +287,8 @@

    LOG(LOG_CALLS,_("Looking for definition of ") << name);

    ASObject* target;

    ASObject* o=th->getVariableAndTargetByMultiname(name,target);

-   assert_and_throw(o);

+   if(o == NULL)

+       throwError<ReferenceError>(kClassNotFoundError,name.normalizedName());

    //TODO: specs says that also namespaces and function may be returned

    assert_and_throw(o->getObjectType()==T_CLASS);

​

@@ -30,23 +30,102 @@

 void ContentElement::sinit(Class_base* c)

 {

    CLASS_SETUP(c, ASObject, _constructorNotInstantiatable, CLASS_SEALED);

+   REGISTER_GETTER_SETTER(c,elementFormat);

+}

+ASFUNCTIONBODY_GETTER_SETTER(ContentElement,elementFormat)

+

+ElementFormat::ElementFormat(Class_base *c): ASObject(c),

+   alignmentBaseline("useDominantBaseline"),

+   alpha(1.0),

+   baselineShift(0.0),

+   breakOpportunity("auto"),

+   color(0x000000),

+   digitCase("default"),

+   digitWidth("default"),

+   dominantBaseline("roman"),

+   fontDescription(NULL),

+   fontSize(12.0),

+   kerning("on"),

+   ligatureLevel("common"),

+   locale("en"),

+   locked(false),

+   textRotation("auto"),

+   trackingLeft(0.0),

+   trackingRight(0.0),

+   typographicCase("default")

+{

+   

 }

 void ElementFormat::sinit(Class_base* c)

 {

    CLASS_SETUP(c, ASObject, _constructor, CLASS_FINAL | CLASS_SEALED);

    c->setVariableByQName("GRAPHIC_ELEMENT","",abstract_ui(0xFDEF),CONSTANT_TRAIT);

+   REGISTER_GETTER_SETTER(c,alignmentBaseline);

+   REGISTER_GETTER_SETTER(c,alpha);

+   REGISTER_GETTER_SETTER(c,baselineShift);

+   REGISTER_GETTER_SETTER(c,breakOpportunity);

+   REGISTER_GETTER_SETTER(c,color);

+   REGISTER_GETTER_SETTER(c,digitCase);

+   REGISTER_GETTER_SETTER(c,digitWidth);

+   REGISTER_GETTER_SETTER(c,dominantBaseline);

+   REGISTER_GETTER_SETTER(c,fontDescription);

+   REGISTER_GETTER_SETTER(c,fontSize);

+   REGISTER_GETTER_SETTER(c,kerning);

+   REGISTER_GETTER_SETTER(c,ligatureLevel);

+   REGISTER_GETTER_SETTER(c,locale);

+   REGISTER_GETTER_SETTER(c,locked);

+   REGISTER_GETTER_SETTER(c,textRotation);

+   REGISTER_GETTER_SETTER(c,trackingLeft);

+   REGISTER_GETTER_SETTER(c,trackingRight);

+   REGISTER_GETTER_SETTER(c,typographicCase);

 }

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,alignmentBaseline)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,alpha)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,baselineShift)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,breakOpportunity)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,color)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,digitCase)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,digitWidth)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,dominantBaseline)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,fontDescription)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,fontSize)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,kerning)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,ligatureLevel)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,locale)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,locked)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,textRotation)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,trackingLeft)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,trackingRight)

+ASFUNCTIONBODY_GETTER_SETTER(ElementFormat,typographicCase)

 ASFUNCTIONBODY(ElementFormat, _constructor)

 {

-   LOG(LOG_NOT_IMPLEMENTED, "ElementFormat class not implemented");

+   ElementFormat* th=static_cast<ElementFormat*>(obj);

+   ARG_UNPACK(th->fontDescription, NullRef)(th->fontSize, 12.0)(th->color, 0x000000) (th->alpha, 1.0)(th->textRotation, "auto")

+           (th->dominantBaseline, "roman") (th->alignmentBaseline, "useDominantBaseline") (th->baselineShift, 0.0)(th->kerning, "on")

+           (th->trackingRight, 0.0)(th->trackingLeft, 0.0)(th->locale, "en")(th->breakOpportunity, "auto")(th->digitCase, "default")

+           (th->digitWidth, "default")(th->ligatureLevel, "common")(th->typographicCase, "default");

    return NULL;

 }

+void FontLookup::sinit(Class_base* c)

+{

+   CLASS_SETUP_NO_CONSTRUCTOR(c, ASObject, CLASS_FINAL | CLASS_SEALED);

+   c->setVariableByQName("DEVICE","",Class<ASString>::getInstanceS("device"),CONSTANT_TRAIT);

+   c->setVariableByQName("EMBEDDED_CFF","",Class<ASString>::getInstanceS("embeddedCFF"),CONSTANT_TRAIT);

+}

+

 void FontDescription::sinit(Class_base* c)

 {

    CLASS_SETUP(c, ASObject, _constructor, CLASS_FINAL | CLASS_SEALED);

+   REGISTER_GETTER_SETTER(c,cffHinting);

+   REGISTER_GETTER_SETTER(c,fontLookup);

+   REGISTER_GETTER_SETTER(c,fontName);

+   REGISTER_GETTER_SETTER(c,fontPosture);

+   REGISTER_GETTER_SETTER(c,fontWeight);

+   REGISTER_GETTER_SETTER(c,locked);

+   REGISTER_GETTER_SETTER(c,renderingMode);

 }

 ASFUNCTIONBODY(FontDescription, _constructor)

@@ -54,6 +133,13 @@

    LOG(LOG_NOT_IMPLEMENTED, "FontDescription class not implemented");

    return NULL;

 }

+ASFUNCTIONBODY_GETTER_SETTER(FontDescription,cffHinting)

+ASFUNCTIONBODY_GETTER_SETTER(FontDescription,fontLookup)

+ASFUNCTIONBODY_GETTER_SETTER(FontDescription,fontName)

+ASFUNCTIONBODY_GETTER_SETTER(FontDescription,fontPosture)

+ASFUNCTIONBODY_GETTER_SETTER(FontDescription,fontWeight)

+ASFUNCTIONBODY_GETTER_SETTER(FontDescription,locked)

+ASFUNCTIONBODY_GETTER_SETTER(FontDescription,renderingMode)

 void FontWeight::sinit(Class_base* c)

 {

@@ -62,6 +148,44 @@

    c->setVariableByQName("NORMAL","",Class<ASString>::getInstanceS("normal"),CONSTANT_TRAIT);

 }

+void FontMetrics::sinit(Class_base* c)

+{

+   CLASS_SETUP(c, ASObject,_constructor, CLASS_FINAL);

+}

+ASFUNCTIONBODY(FontMetrics, _constructor)

+{

+   //FontMetrics* th=static_cast<FontMetrics*>(obj);

+   LOG(LOG_NOT_IMPLEMENTED, "FontMetrics is a stub");

+   return NULL;

+}

+

+void Kerning::sinit(Class_base* c)

+{

+   CLASS_SETUP_NO_CONSTRUCTOR(c, ASObject, CLASS_FINAL | CLASS_SEALED);

+   c->setVariableByQName("AUTO","",Class<ASString>::getInstanceS("auto"),CONSTANT_TRAIT);

+   c->setVariableByQName("OFF","",Class<ASString>::getInstanceS("off"),CONSTANT_TRAIT);

+   c->setVariableByQName("ON","",Class<ASString>::getInstanceS("on"),CONSTANT_TRAIT);

+}

+

+void LineJustification::sinit(Class_base* c)

+{

+   CLASS_SETUP_NO_CONSTRUCTOR(c, ASObject, CLASS_FINAL | CLASS_SEALED);

+   c->setVariableByQName("ALL_BUT_LAST","",Class<ASString>::getInstanceS("allButLast"),CONSTANT_TRAIT);

+   c->setVariableByQName("ALL_BUT_MANDATORY_BREAK","",Class<ASString>::getInstanceS("allButMandatoryBreak"),CONSTANT_TRAIT);

+   c->setVariableByQName("ALL_INCLUDING_LAST","",Class<ASString>::getInstanceS("allIncludingLast"),CONSTANT_TRAIT);

+   c->setVariableByQName("UNJUSTIFIED","",Class<ASString>::getInstanceS("unjustified"),CONSTANT_TRAIT);

+}

+void TextBaseline::sinit(Class_base* c)

+{

+   CLASS_SETUP_NO_CONSTRUCTOR(c, ASObject, CLASS_FINAL | CLASS_SEALED);

+   c->setVariableByQName("ASCENT","",Class<ASString>::getInstanceS("ascent"),CONSTANT_TRAIT);

+   c->setVariableByQName("DESCENT","",Class<ASString>::getInstanceS("descent"),CONSTANT_TRAIT);

+   c->setVariableByQName("IDEOGRAPHIC_BOTTOM","",Class<ASString>::getInstanceS("ideographicBottom"),CONSTANT_TRAIT);

+   c->setVariableByQName("IDEOGRAPHIC_CENTER","",Class<ASString>::getInstanceS("ideographicCenter"),CONSTANT_TRAIT);

+   c->setVariableByQName("IDEOGRAPHIC_TOP","",Class<ASString>::getInstanceS("ideographicTop"),CONSTANT_TRAIT);

+   c->setVariableByQName("ROMAN","",Class<ASString>::getInstanceS("roman"),CONSTANT_TRAIT);

+   c->setVariableByQName("USE_DOMINANT_BASELINE","",Class<ASString>::getInstanceS("useDominantBaseline"),CONSTANT_TRAIT);

+}

 void TextJustifier::sinit(Class_base* c)

 {

@@ -78,7 +202,7 @@

 }

 ASFUNCTIONBODY(SpaceJustifier, _constructor)

 {

-   SpaceJustifier* th=static_cast<SpaceJustifier*>(obj);

+   //SpaceJustifier* th=static_cast<SpaceJustifier*>(obj);

    LOG(LOG_NOT_IMPLEMENTED, "SpaceJustifier is a stub");

    return NULL;

 }

@@ -88,7 +212,7 @@

 }

 ASFUNCTIONBODY(EastAsianJustifier, _constructor)

 {

-   EastAsianJustifier* th=static_cast<EastAsianJustifier*>(obj);

+   //EastAsianJustifier* th=static_cast<EastAsianJustifier*>(obj);

    LOG(LOG_NOT_IMPLEMENTED, "EastAsianJustifier is a stub");

    return NULL;

 }

@@ -97,12 +221,15 @@

 {

    CLASS_SETUP(c, ASObject, _constructor, CLASS_FINAL | CLASS_SEALED);

    c->setDeclaredMethodByQName("createTextLine","",Class<IFunction>::getFunction(createTextLine),NORMAL_METHOD,true);

+   c->setDeclaredMethodByQName("recreateTextLine","",Class<IFunction>::getFunction(recreateTextLine),NORMAL_METHOD,true);

    REGISTER_GETTER_SETTER(c, content);

    REGISTER_GETTER_SETTER(c, textJustifier);

+   REGISTER_GETTER_SETTER(c, bidiLevel);

 }

 ASFUNCTIONBODY_GETTER_SETTER(TextBlock, content)

 ASFUNCTIONBODY_GETTER_SETTER(TextBlock, textJustifier)

+ASFUNCTIONBODY_GETTER_SETTER(TextBlock, bidiLevel)

 ASFUNCTIONBODY(TextBlock, _constructor)

 {

@@ -119,26 +246,87 @@

    TextBlock* th=static_cast<TextBlock*>(obj);

    _NR<TextLine> previousLine;

    int32_t width;

-   ARG_UNPACK (previousLine, NullRef) (width, MAX_LINE_WIDTH);

+   number_t lineOffset;

+   bool fitSomething;

+   ARG_UNPACK (previousLine, NullRef) (width, MAX_LINE_WIDTH) (lineOffset, 0.0) (fitSomething, false);

    if (argslen > 2)

        LOG(LOG_NOT_IMPLEMENTED, "TextBlock::createTextLine ignored some parameters");

-   if (width <= 0 || width > MAX_LINE_WIDTH)

-       throw Class<ArgumentError>::getInstanceS("Invalid width");

-

-   if (!previousLine.isNull())

+   if (!fitSomething && (width < 0 || width > MAX_LINE_WIDTH))

    {

-       LOG(LOG_NOT_IMPLEMENTED, "TextBlock::createTextLine supports a single line only");

-       return getSys()->getNullRef();

+       throwError<ArgumentError>(kOutOfRangeError,"Invalid width");

    }

+   // TODO handle non TextElement Content

+   if (th->content.isNull() || !th->content->is<TextElement>() || th->content->as<TextElement>()->text.empty())

+       return NULL;

+   tiny_string linetext = th->content->as<TextElement>()->text;

+   if (fitSomething && linetext == "")

+       linetext = " ";

+       

+   LOG(LOG_NOT_IMPLEMENTED,"splitting textblock in multiple lines not implemented");

+   th->content->as<TextElement>()->text = "";

    th->incRef();

-   TextLine *textLine = Class<TextLine>::getInstanceS(th->content, _MNR(th));

+   TextLine *textLine = Class<TextLine>::getInstanceS(linetext, _MNR(th));

    textLine->width = (uint32_t)width;

+   textLine->previousLine = previousLine;

    textLine->updateSizes();

+   if (textLine->width > textLine->textWidth)

+   {

+       delete textLine;

+       th->decRef();

+       return NULL;

+   }

+   if (!previousLine.isNull())

+       previousLine->nextLine == textLine;

    return textLine;

 }

+ASFUNCTIONBODY(TextBlock, recreateTextLine)

+{

+   TextBlock* th=static_cast<TextBlock*>(obj);

+   _NR<TextLine> previousLine;

+   _NR<TextLine> textLine;

+   int32_t width;

+   number_t lineOffset;

+   bool fitSomething;

+   ARG_UNPACK (textLine) (previousLine, NullRef) (width, MAX_LINE_WIDTH) (lineOffset, 0.0) (fitSomething, false);

+

+   if (argslen > 2)

+       LOG(LOG_NOT_IMPLEMENTED, "TextBlock::recreateTextLine ignored some parameters");

+   LOG(LOG_NOT_IMPLEMENTED, "TextBlock::recreateTextLine doesn't check all parameters for validity");

+

+   // TODO handle non TextElement Content

+   if (th->content.isNull() || !th->content->is<TextElement>() || th->content->as<TextElement>()->text.empty())

+       return NULL;

+

+   if (!fitSomething && (width < 0 || width > MAX_LINE_WIDTH))

+   {

+       throwError<ArgumentError>(kOutOfRangeError,"Invalid width");

+   }

+

+   if (textLine.isNull())

+   {

+       throwError<ArgumentError>(kInvalidArgumentError,"Invalid argument: textLine");

+   }

+

+   if (th != textLine->textBlock.getPtr())

+   {

+       throwError<ArgumentError>(kInvalidArgumentError,"Invalid argument: textLine is in different textBlock");

+   }

+   if (fitSomething && textLine->text == "")

+       textLine->text = " ";

+   textLine->width = (uint32_t)width;

+   textLine->previousLine = previousLine;

+   textLine->updateSizes();

+   if (textLine->width > textLine->textWidth)

+   {

+       return NULL;

+   }

+   if (!previousLine.isNull())

+       previousLine->nextLine == textLine;

+   return textLine.getPtr();

+}

 void TextElement::sinit(Class_base* c)

 {

@@ -158,19 +346,12 @@

    return NULL;

 }

-TextLine::TextLine(Class_base* c, _NR<ContentElement> content, _NR<TextBlock> owner)

-  : DisplayObjectContainer(c), TextData()

+TextLine::TextLine(Class_base* c, tiny_string linetext, _NR<TextBlock> owner)

+  : DisplayObjectContainer(c), TextData(),nextLine(NULL),previousLine(NULL),userData(NULL)

 {

    textBlock = owner;

-   if (content.isNull() || !content->is<TextElement>())

-   {

-       LOG(LOG_NOT_IMPLEMENTED, "TextLine supports only TextElements");

-       return;

-   }

-

-   TextElement *textElement = content->as<TextElement>();

-   text = textElement->text;

+   text = linetext;

    updateSizes();

    requestInvalidation(getSys());

 }

@@ -178,11 +359,24 @@

 void TextLine::sinit(Class_base* c)

 {

    CLASS_SETUP(c, DisplayObjectContainer, _constructor, CLASS_FINAL | CLASS_SEALED);

-   REGISTER_GETTER(c, textBlock);

    c->setVariableByQName("MAX_LINE_WIDTH","",abstract_ui(MAX_LINE_WIDTH),CONSTANT_TRAIT);

+   c->setDeclaredMethodByQName("descent","",Class<IFunction>::getFunction(getDescent),GETTER_METHOD,true);

+   c->setDeclaredMethodByQName("ascent","",Class<IFunction>::getFunction(getAscent),GETTER_METHOD,true);

+   c->setDeclaredMethodByQName("textWidth","",Class<IFunction>::getFunction(getTextWidth),GETTER_METHOD,true);

+   c->setDeclaredMethodByQName("textHeight","",Class<IFunction>::getFunction(getTextHeight),GETTER_METHOD,true);

+   REGISTER_GETTER(c, textBlock);

+   REGISTER_GETTER(c, nextLine);

+   REGISTER_GETTER(c, previousLine);

+   REGISTER_GETTER_SETTER(c, validity);

+   REGISTER_GETTER_SETTER(c, userData);

 }

+

 ASFUNCTIONBODY_GETTER(TextLine, textBlock);

+ASFUNCTIONBODY_GETTER(TextLine, nextLine);

+ASFUNCTIONBODY_GETTER(TextLine, previousLine);

+ASFUNCTIONBODY_GETTER_SETTER(TextLine, validity);

+ASFUNCTIONBODY_GETTER_SETTER(TextLine, userData);

 ASFUNCTIONBODY(TextLine, _constructor)

 {

@@ -191,6 +385,31 @@

    return NULL;

 }

+ASFUNCTIONBODY(TextLine, getDescent)

+{

+   LOG(LOG_NOT_IMPLEMENTED,"TextLine.descent");

+   return abstract_d(0);

+}

+

+ASFUNCTIONBODY(TextLine, getAscent)

+{

+   TextLine* th=static_cast<TextLine*>(obj);

+   LOG(LOG_NOT_IMPLEMENTED,"TextLine.ascent");

+   return abstract_d(th->textHeight);

+}

+

+ASFUNCTIONBODY(TextLine, getTextWidth)

+{

+   TextLine* th=static_cast<TextLine*>(obj);

+   return abstract_d(th->textWidth);

+}

+

+ASFUNCTIONBODY(TextLine, getTextHeight)

+{

+   TextLine* th=static_cast<TextLine*>(obj);

+   return abstract_d(th->textHeight);

+}

+

 void TextLine::updateSizes()

 {

@@ -199,7 +418,12 @@

    h = height;

    //Compute (text)width, (text)height

    CairoPangoRenderer::getBounds(*this, w, h, tw, th);

+   if (w == 0)

+       w = tw;

+   if (h == 0)

+       h = th;

    width = w; //TODO: check the case when w,h == 0

+   

    textWidth = w;

    height = h;

    textHeight = h;

@@ -263,3 +487,13 @@

        return DisplayObjectContainer::hitTestImpl(_MR(this), x, y, type);

    }

 }

+

+void TextLineValidity::sinit(Class_base* c)

+{

+   CLASS_SETUP_NO_CONSTRUCTOR(c, ASObject, CLASS_FINAL | CLASS_SEALED);

+   c->setVariableByQName("INVALID","",Class<ASString>::getInstanceS("invalid"),CONSTANT_TRAIT);

+   c->setVariableByQName("POSSIBLY_INVALID","",Class<ASString>::getInstanceS("possiblyInvalid"),CONSTANT_TRAIT);

+   c->setVariableByQName("STATIC","",Class<ASString>::getInstanceS("static"),CONSTANT_TRAIT);

+   c->setVariableByQName("VALID","",Class<ASString>::getInstanceS("valid"),CONSTANT_TRAIT);

+}

+

​

@@ -29,40 +29,104 @@

 namespace lightspark

 {

+class ElementFormat;

 class ContentElement: public ASObject

 {

 public:

-   ContentElement(Class_base* c): ASObject(c) {};

+   ContentElement(Class_base* c): ASObject(c),elementFormat(NULL) {}

    static void sinit(Class_base* c);

+   ASPROPERTY_GETTER_SETTER(_NR<ElementFormat>,elementFormat);

 };

+class FontDescription;

 class ElementFormat: public ASObject

 {

 public:

-   ElementFormat(Class_base* c): ASObject(c) {};

+   ElementFormat(Class_base* c);

    static void sinit(Class_base* c);

    ASFUNCTION(_constructor);

+   ASPROPERTY_GETTER_SETTER(tiny_string,alignmentBaseline);

+   ASPROPERTY_GETTER_SETTER(number_t,alpha);

+   ASPROPERTY_GETTER_SETTER(number_t,baselineShift);

+   ASPROPERTY_GETTER_SETTER(tiny_string,breakOpportunity);

+   ASPROPERTY_GETTER_SETTER(uint,color);

+   ASPROPERTY_GETTER_SETTER(tiny_string,digitCase);

+   ASPROPERTY_GETTER_SETTER(tiny_string,digitWidth);

+   ASPROPERTY_GETTER_SETTER(tiny_string,dominantBaseline);

+   ASPROPERTY_GETTER_SETTER(_NR<FontDescription>,fontDescription);

+   ASPROPERTY_GETTER_SETTER(number_t,fontSize);

+   ASPROPERTY_GETTER_SETTER(tiny_string,kerning);

+   ASPROPERTY_GETTER_SETTER(tiny_string,ligatureLevel);

+   ASPROPERTY_GETTER_SETTER(tiny_string,locale);

+   ASPROPERTY_GETTER_SETTER(bool,locked);

+   ASPROPERTY_GETTER_SETTER(tiny_string,textRotation);

+   ASPROPERTY_GETTER_SETTER(number_t,trackingLeft);

+   ASPROPERTY_GETTER_SETTER(number_t,trackingRight);

+   ASPROPERTY_GETTER_SETTER(tiny_string,typographicCase);

+};

+

+class FontLookup: public ASObject

+{

+public:

+   FontLookup(Class_base* c): ASObject(c) {}

+   static void sinit(Class_base* c);

 };

 class FontDescription: public ASObject

 {

 public:

-   FontDescription(Class_base* c): ASObject(c) {};

+   FontDescription(Class_base* c): ASObject(c), 

+       cffHinting("horizontalStem"), fontLookup("device"), fontName("_serif"), fontPosture("normal"), fontWeight("normal"),locked(false), renderingMode("cff") {}