/*

* Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package javax.microedition.m3g;

import java.util.Enumeration;

import java.util.Vector;

import com.nokia.mj.impl.rt.support.Finalizer;

/**

*/

public abstract class Object3D

{

    //------------------------------------------------------------------

    // Instance data

    //------------------------------------------------------------------

    int handle;

    private Object userObject;

    private Vector animTracks;

    private Interface iInterface;

    private Finalizer mFinalizer = new Finalizer()

    {

        public void finalizeImpl()

        {

            doFinalize();

        }

    };

    //------------------------------------------------------------------

    // Constructor(s)

    //------------------------------------------------------------------

    /**

     * <p>Only a package private constructor exists for this class.</p>

     */

    Object3D(int handle)

    {

        if (handle != 0)

        {

            this.handle = handle;

            _addRef(handle);

            // Get associated Interafece object and

            // register this instance with that

            iInterface = Interface.getInstance();

            iInterface.register(this);

            int n = _getAnimationTrackCount(handle);

            while (n-- > 0)

            {

                linkAnimTrack((AnimationTrack) getInstance(_getAnimationTrack(handle, n)));

            }

        }

        else

        {

            System.out.println("Warning: Object3D constructor called with zero handle");

        }

    }

    //------------------------------------------------------------------

    // Public API

    //------------------------------------------------------------------

    public final Object3D duplicate()

    {

        int numRef = 1;

        if (this instanceof Node)

        {

            numRef = ((Node)this)._getSubtreeSize(handle);

        }

        int[] handles = new int[numRef * 2];

        Object3D obj = getInstance(_duplicate(handle, handles));

        for (int i = 0; i < numRef; i++)

        {

            Object userObj = getInstance(handles[i * 2]).getUserObject();

            Object3D duplicateObj = getInstance(handles[i * 2 + 1]);

            if (userObj != null)

            {

                duplicateObj.setUserObject(userObj);

            }

        }

        return obj;

    }

    public int getReferences(Object3D[] references)

    {

        int[] handles = null;

        if (references != null)

        {

            handles = new int[references.length];

        }

        int num = _getReferences(handle, handles);

        if (references != null)

        {

            for (int i = 0; i < num; i++)

            {

                references[i] = getInstance(handles[i]);

            }

        }

        return num;

    }

    public void setUserID(int userID)

    {

        _setUserID(handle, userID);

    }

    public int getUserID()

    {

        return _getUserID(handle);

    }

    public Object3D find(int userID)

    {

        return getInstance(_find(handle, userID));

    }

    public void addAnimationTrack(AnimationTrack animationTrack)

    {

        _addAnimationTrack(handle, animationTrack.handle);

        linkAnimTrack(animationTrack);

    }

    public AnimationTrack getAnimationTrack(int index)

    {

        /* Don't try to match the native indexing here -- just call

         * the native getter */

        return (AnimationTrack)getInstance(_getAnimationTrack(handle, index));

    }

    public void removeAnimationTrack(AnimationTrack animationTrack)

    {

        if (animationTrack != null)

        {

            _removeAnimationTrack(handle, animationTrack.handle);

            if (animTracks != null)

            {

                animTracks.removeElement(animationTrack);

                if (animTracks.isEmpty())

                {

                    animTracks = null;

                }

            }

        }

    }

    public int getAnimationTrackCount()

    {

        return _getAnimationTrackCount(handle);

    }

    public final int animate(int time)

    {

        return _animate(handle, time);

    }

    public void setUserObject(Object obj)

    {

        userObject = obj;

    }

    public Object getUserObject()

    {

        return userObject;

    }

    //------------------------------------------------------------------

    // Private methods

    //------------------------------------------------------------------

    static final Object3D getInstance(int handle)

    {

        return Interface.getObjectInstance(handle);

    }

    /**

     * Adds a reference to an animation track.

     */

    private void linkAnimTrack(AnimationTrack track)

    {

        if (animTracks == null)

        {

            animTracks = new Vector();

        }

        animTracks.addElement(track);

    }

    /**

     * Native peer finalization

     */

    private void doFinalize()

    {

        if (mFinalizer != null)

        {

            if (handle != 0)

            {

                // finalize native peer

                Platform.finalizeObject(handle, iInterface);

                iInterface.deregister(this, iInterface);

                // reset handles

                iInterface = null;

                handle= 0;

            }

            mFinalizer = null;

        }

    }

    // Native methods

    private static native int _addAnimationTrack(int hObject, int hAnimationTrack);

    private static native void _removeAnimationTrack(int hObject, int hAnimationTrack);

    private static native int _getAnimationTrackCount(int hObject);

    private static native int _animate(int hObject, int time);

    private static native void _setUserID(int hObject, int userID);

    private static native int _getUserID(int hObject);

    private static native void _addRef(int hObject);

    private static native int _getAnimationTrack(int hObject, int index);

    private static native int _duplicate(int hObject, int[] handles);

    private static native int _getReferences(int hObject, int[] handles);

    private static native int _find(int hObject, int userID);

}