1 files changed, 379 insertions, 36 deletions

diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 1bb5854..a703377 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -77,6 +77,7 @@ namespace OpenSim.Region.Framework.Scenes
         touch = 8,
         touch_end = 536870912,
         touch_start = 2097152,
+        transaction_result = 33554432,
         object_rez = 4194304
     }
 
@@ -121,12 +122,17 @@ namespace OpenSim.Region.Framework.Scenes
         /// since the group's last persistent backup
         /// </summary>
         private bool m_hasGroupChanged = false;
+<<<<<<< HEAD
+        private long timeFirstChanged;
+        private long timeLastChanged;
+=======
         private long timeFirstChanged = 0;
         private long timeLastChanged = 0;
         private long m_maxPersistTime = 0;
         private long m_minPersistTime = 0;
 //        private Random m_rand;
         private List<ScenePresence> m_linkedAvatars = new List<ScenePresence>();
+>>>>>>> avn/ubitvar
 
         /// <summary>
         /// This indicates whether the object has changed such that it needs to be repersisted to permenant storage
@@ -190,12 +196,31 @@ namespace OpenSim.Region.Framework.Scenes
 
             get { return m_hasGroupChanged; }
         }
+
+        private bool m_groupContainsForeignPrims = false;
         
         /// <summary>
-        /// Has the group changed due to an unlink operation?  We record this in order to optimize deletion, since
-        /// an unlinked group currently has to be persisted to the database before we can perform an unlink operation.
+        /// Whether the group contains prims that came from a different group. This happens when
+        /// linking or delinking groups. The implication is that until the group is persisted,
+        /// the prims in the database still use the old SceneGroupID. That's a problem if the group
+        /// is deleted, because we delete groups by searching for prims by their SceneGroupID.
         /// </summary>
+<<<<<<< HEAD
+        public bool GroupContainsForeignPrims
+        {
+            private set
+            {
+                m_groupContainsForeignPrims = value;
+                if (m_groupContainsForeignPrims)
+                    HasGroupChanged = true;
+            }
+
+            get { return m_groupContainsForeignPrims; }
+        }
+
+=======
         public bool HasGroupChangedDueToDelink { get; set; }
+>>>>>>> avn/ubitvar
 
         private bool isTimeToPersist()
         {
@@ -325,7 +350,17 @@ namespace OpenSim.Region.Framework.Scenes
             get { return RootPart.VolumeDetectActive; }
         }
 
+<<<<<<< HEAD
+        private Vector3 lastPhysGroupPos;
+        private Quaternion lastPhysGroupRot;
+
+        /// <summary>
+        /// Is this entity set to be saved in persistent storage?
+        /// </summary>
+        public bool Backup { get; private set; }
+=======
         private bool m_isBackedUp;
+>>>>>>> avn/ubitvar
 
         public bool IsBackedUp
         {
@@ -507,7 +542,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         public bool IsAttachmentCheckFull()
         {
-            return (IsAttachment || (m_rootPart.Shape.PCode == 9 && m_rootPart.Shape.State != 0));
+            return (IsAttachment || (m_rootPart.Shape.PCode == (byte)PCodeEnum.Primitive && m_rootPart.Shape.State != 0));
         }
         
         private struct avtocrossInfo
@@ -535,11 +570,146 @@ namespace OpenSim.Region.Framework.Scenes
                         && !Scene.LoadingPrims
                     )
                 {
+<<<<<<< HEAD
+                    if (
+                        !Scene.PositionIsInCurrentRegion(val)
+                                && !IsAttachmentCheckFull()
+                                && (!Scene.LoadingPrims)
+                        )
+                    {
+                        IEntityTransferModule entityTransfer = m_scene.RequestModuleInterface<IEntityTransferModule>();
+                        string version = String.Empty;
+                        Vector3 newpos = Vector3.Zero;
+                        string failureReason = String.Empty;
+                        OpenSim.Services.Interfaces.GridRegion destination = null;
+
+                        if (m_rootPart.KeyframeMotion != null)
+                            m_rootPart.KeyframeMotion.StartCrossingCheck();
+
+                        bool canCross = true;
+                        foreach (ScenePresence av in GetSittingAvatars())
+                        {
+                            // We need to cross these agents. First, let's find
+                            // out if any of them can't cross for some reason.
+                            // We have to deny the crossing entirely if any
+                            // of them are banned. Alternatively, we could
+                            // unsit banned agents....
+
+
+                            // We set the avatar position as being the object
+                            // position to get the region to send to
+                            if ((destination = entityTransfer.GetDestination(m_scene, av.UUID, val, out version, out newpos, out failureReason)) == null)
+                            {
+                                canCross = false;
+                                break;
+                            }
+
+                            m_log.DebugFormat("[SCENE OBJECT]: Avatar {0} needs to be crossed to {1}", av.Name, destination.RegionName);
+                        }
+
+                        if (canCross)
+                        {
+                            // We unparent the SP quietly so that it won't
+                            // be made to stand up
+
+                            List<avtocrossInfo> avsToCross = new List<avtocrossInfo>();
+
+                            foreach (ScenePresence av in GetSittingAvatars())
+                            {
+                                avtocrossInfo avinfo = new avtocrossInfo();
+                                SceneObjectPart parentPart = m_scene.GetSceneObjectPart(av.ParentID);
+                                if (parentPart != null)
+                                    av.ParentUUID = parentPart.UUID;
+
+                                avinfo.av = av;
+                                avinfo.ParentID = av.ParentID;
+                                avsToCross.Add(avinfo);
+
+                                av.PrevSitOffset = av.OffsetPosition;
+                                av.ParentID = 0;
+                            }
+
+                            m_scene.CrossPrimGroupIntoNewRegion(val, this, true);
+
+                            // Normalize
+                            if (val.X >= m_scene.RegionInfo.RegionSizeX)
+                                val.X -= m_scene.RegionInfo.RegionSizeX;
+                            if (val.Y >= m_scene.RegionInfo.RegionSizeY)
+                                val.Y -= m_scene.RegionInfo.RegionSizeY;
+                            if (val.X < 0)
+                                val.X += m_scene.RegionInfo.RegionSizeX;
+                            if (val.Y < 0)
+                                val.Y += m_scene.RegionInfo.RegionSizeY;
+
+                            // If it's deleted, crossing was successful
+                            if (IsDeleted)
+                            {
+                                foreach (avtocrossInfo avinfo in avsToCross)
+                                {
+                                    ScenePresence av = avinfo.av;
+                                    if (!av.IsInTransit) // just in case...
+                                    {
+                                        m_log.DebugFormat("[SCENE OBJECT]: Crossing avatar {0} to {1}", av.Name, val);
+
+                                        av.IsInTransit = true;
+
+                                        // A temporary measure to allow regression tests to work.
+                                        // Quite possibly, all BeginInvoke() calls should be replaced by Util.FireAndForget
+                                        // or similar since BeginInvoke() always uses the system threadpool to launch
+                                        // threads rather than any replace threadpool that we might be using.
+                                        if (Util.FireAndForgetMethod == FireAndForgetMethod.RegressionTest)
+                                        { 
+                                            entityTransfer.CrossAgentToNewRegionAsync(av, val, destination, av.Flying, version);
+                                            CrossAgentToNewRegionCompleted(av);
+                                        }
+                                        else
+                                        {
+                                            CrossAgentToNewRegionDelegate d = entityTransfer.CrossAgentToNewRegionAsync;
+                                            d.BeginInvoke(
+                                                av, val, destination, av.Flying, version, 
+                                                ar => CrossAgentToNewRegionCompleted(d.EndInvoke(ar)), null);
+                                        }
+                                    }
+                                    else
+                                    {
+                                        m_log.DebugFormat("[SCENE OBJECT]: Not crossing avatar {0} to {1} because it's already in transit", av.Name, val);
+                                    }
+                                }
+
+                                return;
+                            }
+                            else // cross failed, put avas back ??
+                            {
+                                foreach (avtocrossInfo avinfo in avsToCross)
+                                {
+                                    ScenePresence av = avinfo.av;
+                                    av.ParentUUID = UUID.Zero;
+                                    av.ParentID = avinfo.ParentID;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            if (m_rootPart.KeyframeMotion != null)
+                                m_rootPart.KeyframeMotion.CrossingFailure();
+
+                            if (RootPart.PhysActor != null)
+                            {
+                                RootPart.PhysActor.CrossingFailure();
+                            }
+                        }
+
+                        Vector3 oldp = AbsolutePosition;
+                        val.X = Util.Clamp<float>(oldp.X, 0.5f, (float)m_scene.RegionInfo.RegionSizeX - 0.5f);
+                        val.Y = Util.Clamp<float>(oldp.Y, 0.5f, (float)m_scene.RegionInfo.RegionSizeY - 0.5f);
+                        val.Z = Util.Clamp<float>(oldp.Z, 0.5f, Constants.RegionHeight);
+=======
                     if (!inTransit)
                     {
                         inTransit = true;
                         SOGCrossDelegate d = CrossAsync;
                         d.BeginInvoke(this, val, CrossAsyncCompleted, d);
+>>>>>>> avn/ubitvar
                     }
                     return;
                 }
@@ -780,11 +950,8 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        private void CrossAgentToNewRegionCompleted(IAsyncResult iar)
+        private void CrossAgentToNewRegionCompleted(ScenePresence agent)
         {
-            CrossAgentToNewRegionDelegate icon = (CrossAgentToNewRegionDelegate)iar.AsyncState;
-            ScenePresence agent = icon.EndInvoke(iar);
-
             //// If the cross was successful, this agent is a child agent
             if (agent.IsChildAgent)
             {
@@ -871,7 +1038,11 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_rootPart.Text = value; }
         }
 
-        protected virtual bool InSceneBackup
+        /// <summary>
+        /// If set to true then the scene object can be backed up in principle, though this will only actually occur
+        /// if Backup is set.  If false then the scene object will never be backed up, Backup will always be false.
+        /// </summary>
+        protected virtual bool CanBeBackedUp
         {
             get { return true; }
         }
@@ -1014,6 +1185,12 @@ namespace OpenSim.Region.Framework.Scenes
         public UUID FromFolderID { get; set; }
 
         /// <summary>
+        /// If true then grabs are blocked no matter what the individual part BlockGrab setting.
+        /// </summary>
+        /// <value><c>true</c> if block grab override; otherwise, <c>false</c>.</value>
+        public bool BlockGrabOverride { get; set; }
+
+        /// <summary>
         /// IDs of all avatars sat on this scene object.
         /// </summary>
         /// <remarks>
@@ -1023,7 +1200,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// No avatar should appear more than once in this list.
         /// Do not manipulate this list directly - use the Add/Remove sitting avatar methods on SceneObjectPart.
         /// </remarks>
-        protected internal List<UUID> m_sittingAvatars = new List<UUID>();
+        protected internal List<ScenePresence> m_sittingAvatars = new List<ScenePresence>();
 
         #endregion
 
@@ -1089,23 +1266,67 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public void LoadScriptState(XmlReader reader)
+        {
+//            m_log.DebugFormat("[SCENE OBJECT GROUP]: Looking for script state for {0}", Name);
+
+            while (true)
+            {
+                if (reader.Name == "SavedScriptState" && reader.NodeType == XmlNodeType.Element)
+                {
+//                    m_log.DebugFormat("[SCENE OBJECT GROUP]: Loading script state for {0}", Name);
+
+                    if (m_savedScriptState == null)
+                        m_savedScriptState = new Dictionary<UUID, string>();
+
+                    string uuid = reader.GetAttribute("UUID");
+
+                    // Even if there is no UUID attribute for some strange reason, we must always read the inner XML
+                    // so we don't continually keep checking the same SavedScriptedState element.
+                    string innerXml = reader.ReadInnerXml();
+
+                    if (uuid != null)
+                    {
+//                        m_log.DebugFormat("[SCENE OBJECT GROUP]: Found state for item ID {0} in object {1}", uuid, Name);
+
+                        UUID itemid = new UUID(uuid);
+                        if (itemid != UUID.Zero)
+                            m_savedScriptState[itemid] = innerXml;
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("[SCENE OBJECT GROUP]: SavedScriptState element had no UUID in object {0}", Name);
+                    }
+                }
+                else
+                {
+                    if (!reader.Read())
+                        break;
+                }
+            }
+        }
+
         /// <summary>
         /// Hooks this object up to the backup event so that it is persisted to the database when the update thread executes.
         /// </summary>
         public virtual void AttachToBackup()
         {
+<<<<<<< HEAD
+            if (CanBeBackedUp)
+=======
             if (IsAttachment) return;
             m_scene.SceneGraph.FireAttachToBackup(this);
 
             if (InSceneBackup)
+>>>>>>> avn/ubitvar
             {
-                //m_log.DebugFormat(
-                //    "[SCENE OBJECT GROUP]: Attaching object {0} {1} to scene presistence sweep", Name, UUID);
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT GROUP]: Attaching object {0} {1} to scene presistence sweep", Name, UUID);
 
-                if (!m_isBackedUp)
+                if (!Backup)
                     m_scene.EventManager.OnBackup += ProcessBackup;
                 
-                m_isBackedUp = true;
+                Backup = true;
             }
         }
         
@@ -1210,12 +1431,21 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         public void GetAxisAlignedBoundingBoxRaw(out float minX, out float maxX, out float minY, out float maxY, out float minZ, out float maxZ)
         {
+<<<<<<< HEAD
+            maxX = -256f;
+            maxY = -256f;
+            maxZ = -256f;
+            minX = 10000f;
+            minY = 10000f;
+            minZ = 10000f;
+=======
             maxX = float.MinValue;
             maxY = float.MinValue;
             maxZ = float.MinValue;
             minX = float.MaxValue;
             minY = float.MaxValue;
             minZ = float.MaxValue;
+>>>>>>> avn/ubitvar
 
             SceneObjectPart[] parts = m_parts.GetArray();
             foreach (SceneObjectPart part in parts)
@@ -1613,6 +1843,17 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+<<<<<<< HEAD
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="part"></param>
+        private void SetPartAsNonRoot(SceneObjectPart part)
+        {
+            part.ParentID = m_rootPart.LocalId;
+            part.ClearUndoState();
+=======
         /// <summary>
         /// Add the avatar to this linkset (avatar is sat).
         /// </summary>
@@ -1652,6 +1893,7 @@ namespace OpenSim.Region.Framework.Scenes
         public List<ScenePresence> GetLinkedAvatars()
         {
             return m_linkedAvatars;
+>>>>>>> avn/ubitvar
         }
 
         /// <summary>
@@ -1955,7 +2197,14 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (Scene != null)
                 {
+<<<<<<< HEAD
+                    if (!sp.IsChildAgent && sp.ParentID == part.LocalId)
+                        sp.StandUp();
+
+                    if (!silent)
+=======
                     Scene.ForEachRootScenePresence(delegate(ScenePresence avatar)
+>>>>>>> avn/ubitvar
                     {
                         if (avatar.ParentID == LocalId)
                             avatar.StandUp();
@@ -2097,7 +2346,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="datastore"></param>
         public virtual void ProcessBackup(ISimulationDataService datastore, bool forcedBackup)
         {
-            if (!m_isBackedUp)
+            if (!Backup)
             {
 //                m_log.DebugFormat(
 //                    "[WATER WARS]: Ignoring backup of {0} {1} since object is not marked to be backed up", Name, UUID);
@@ -2187,7 +2436,7 @@ namespace OpenSim.Region.Framework.Scenes
                         backup_group.RootPart.AngularVelocity = RootPart.AngularVelocity;
                         backup_group.RootPart.ParticleSystem = RootPart.ParticleSystem;
                         HasGroupChanged = false;
-                        HasGroupChangedDueToDelink = false;
+                        GroupContainsForeignPrims = false;
 
                         m_scene.EventManager.TriggerOnSceneObjectPreSave(backup_group, this);
 
@@ -2255,6 +2504,16 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         public SceneObjectGroup Copy(bool userExposed)
         {
+<<<<<<< HEAD
+            // FIXME: This is dangerous since it's easy to forget to reset some references when necessary and end up 
+            // with bugs that only occur in some circumstances (e.g. crossing between regions on the same simulator
+            // but not between regions on different simulators).  Really, all copying should be done explicitly.
+            SceneObjectGroup dupe = (SceneObjectGroup)MemberwiseClone();
+
+            dupe.Backup = false;
+            dupe.m_parts = new MapAndArray<OpenMetaverse.UUID, SceneObjectPart>();
+            dupe.m_sittingAvatars = new List<ScenePresence>();
+=======
             m_dupeInProgress = true;
             SceneObjectGroup dupe = (SceneObjectGroup)MemberwiseClone();
             dupe.m_isBackedUp = false;
@@ -2266,6 +2525,7 @@ namespace OpenSim.Region.Framework.Scenes
             dupe.m_linkedAvatars = new List<ScenePresence>();
             dupe.m_sittingAvatars = new List<UUID>();
 
+>>>>>>> avn/ubitvar
             dupe.CopyRootPart(m_rootPart, OwnerID, GroupID, userExposed);
             dupe.m_rootPart.LinkNum = m_rootPart.LinkNum;
             
@@ -2440,16 +2700,19 @@ namespace OpenSim.Region.Framework.Scenes
             return RootPart.Torque;
         }
 
+<<<<<<< HEAD
+        public void MoveToTarget(Vector3 target, float tau)
+=======
          // This is used by both Double-Click Auto-Pilot and llMoveToTarget() in an attached object
         public void moveToTarget(Vector3 target, float tau)
+>>>>>>> avn/ubitvar
         {
             if (IsAttachment)
             {
                 ScenePresence avatar = m_scene.GetScenePresence(AttachedAvatar);
+
                 if (avatar != null)
-                {
                     avatar.MoveToTarget(target, false, false);
-                }
             }
             else
             {
@@ -2464,11 +2727,26 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void stopMoveToTarget()
+        public void StopMoveToTarget()
         {
             if (IsAttachment)
             {
                 ScenePresence avatar = m_scene.GetScenePresence(AttachedAvatar);
+<<<<<<< HEAD
+
+                if (avatar != null)
+                    avatar.ResetMoveToTarget();
+            }
+            else
+            {
+                PhysicsActor pa = RootPart.PhysActor;
+
+                if (pa != null && pa.PIDActive)
+                {
+                    pa.PIDActive = false;
+                    
+                    ScheduleGroupForTerseUpdate();
+=======
                 if (avatar != null)
                 {
                     avatar.ResetMoveToTarget();
@@ -2508,6 +2786,7 @@ namespace OpenSim.Region.Framework.Scenes
                         rootpart.PhysActor.APIDDamping = damping;
                         rootpart.PhysActor.APIDActive = true;
                     }
+>>>>>>> avn/ubitvar
                 }
             }
         }
@@ -3055,7 +3334,9 @@ namespace OpenSim.Region.Framework.Scenes
 //            objectGroup.m_rootPart = null;
 
             // If linking prims with different permissions, fix them
-            AdjustChildPrimPermissions();
+            AdjustChildPrimPermissions(false);
+
+            GroupContainsForeignPrims = true;
 
             AttachToBackup();
 
@@ -3203,6 +3484,18 @@ namespace OpenSim.Region.Framework.Scenes
 
             linkPart.Rezzed = RootPart.Rezzed;
 
+<<<<<<< HEAD
+            // We must persist the delinked group to the database immediately, for safety. The problem
+            // is that although in memory the new group has a new SceneGroupID, in the database it
+            // still has the parent group's SceneGroupID (until the next backup). This means that if the
+            // parent group is deleted then the delinked group will also be deleted from the database.
+            // This problem will disappear if the region remains alive long enough for another backup,
+            // since at that time the delinked group's new SceneGroupID will be written to the database.
+            // But if the region crashes before that then the prims will be permanently gone, and this must
+            // not happen. (We can't use a just-in-time trick like GroupContainsForeignPrims in this case
+            // because the delinked group doesn't know when the source group is deleted.)
+            m_scene.ForceSceneObjectBackup(objectGroup);
+=======
             // When we delete a group, we currently have to force persist to the database if the object id has changed
             // (since delete works by deleting all rows which have a given object id)
 
@@ -3214,6 +3507,7 @@ namespace OpenSim.Region.Framework.Scenes
                 m_rootPart.PhysActor.Building = false;
 
             objectGroup.HasGroupChangedDueToDelink = true;
+>>>>>>> avn/ubitvar
 
             if (sendEvents)
                 linkPart.TriggerScriptChangedEvent(Changed.LINK);
@@ -3227,12 +3521,16 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="objectGroup"></param>
         public virtual void DetachFromBackup()
         {
+<<<<<<< HEAD
+            if (Backup && Scene != null)
+=======
             if (m_scene != null)
                 m_scene.SceneGraph.FireDetachFromBackup(this);
             if (m_isBackedUp && Scene != null)
+>>>>>>> avn/ubitvar
                 m_scene.EventManager.OnBackup -= ProcessBackup;
             
-            m_isBackedUp = false;
+            Backup = false;
         }
 
         // This links an SOP from a previous linkset into my linkset.
@@ -3295,20 +3593,26 @@ namespace OpenSim.Region.Framework.Scenes
         /// If object is physical, apply force to move it around
         /// If object is not physical, just put it at the resulting location
         /// </summary>
+        /// <param name="partID">Part ID to check for grab</param>
         /// <param name="offset">Always seems to be 0,0,0, so ignoring</param>
         /// <param name="pos">New position.  We do the math here to turn it into a force</param>
         /// <param name="remoteClient"></param>
-        public void GrabMovement(Vector3 offset, Vector3 pos, IClientAPI remoteClient)
+        public void GrabMovement(UUID partID, Vector3 offset, Vector3 pos, IClientAPI remoteClient)
         {
             if (m_scene.EventManager.TriggerGroupMove(UUID, pos))
             {
+                SceneObjectPart part = GetPart(partID);
+
+                if (part == null)
+                    return;
+
                 PhysicsActor pa = m_rootPart.PhysActor;
 
                 if (pa != null)
                 {
                     if (pa.IsPhysical)
                     {
-                        if (!m_rootPart.BlockGrab)
+                        if (!BlockGrabOverride && !part.BlockGrab)
                         {
 /*                            Vector3 llmoveforce = pos - AbsolutePosition;
                             Vector3 grabforce = llmoveforce;
@@ -3323,20 +3627,27 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     else
                     {
-                        //NonPhysicalGrabMovement(pos);
+                        NonPhysicalGrabMovement(pos);
                     }
                 }
                 else
                 {
-                    //NonPhysicalGrabMovement(pos);
+                    NonPhysicalGrabMovement(pos);
                 }
             }
         }
 
+        /// <summary>
+        /// Apply possition for grabbing non-physical linksets (Ctrl+Drag)
+        /// This MUST be blocked for linksets that contain touch scripts because the viewer triggers grab on the touch
+        /// event (Viewer Bug?) This would allow anyone to drag a linkset with a touch script. SL behaviour is also to
+        /// block grab on prims with touch events.
+        /// </summary>
+        /// <param name="pos">New Position</param>
         public void NonPhysicalGrabMovement(Vector3 pos)
         {
-            AbsolutePosition = pos;
-            m_rootPart.SendTerseUpdateToAllClients();
+            if(!IsAttachment && ScriptCount() == 0)
+                UpdateGroupPosition(pos);
         }
 
         /// <summary>
@@ -3432,17 +3743,28 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     else
                     {
-                        //NonPhysicalSpinMovement(pos);
+                        NonPhysicalSpinMovement(newOrientation);
                     }
                 }
                 else
                 {
-                    //NonPhysicalSpinMovement(pos);
+                    NonPhysicalSpinMovement(newOrientation);
                 }
             }
         }
 
         /// <summary>
+        /// Apply rotation for spinning non-physical linksets (Ctrl+Shift+Drag)
+        /// As with dragging, scripted objects must be blocked from spinning
+        /// </summary>
+        /// <param name="newOrientation">New Rotation</param>
+        private void NonPhysicalSpinMovement(Quaternion newOrientation)
+        {
+            if(!IsAttachment && ScriptCount() == 0)
+                UpdateGroupRotationR(newOrientation);
+        }
+
+        /// <summary>
         /// Set the name of a prim
         /// </summary>
         /// <param name="name"></param>
@@ -3517,12 +3839,22 @@ namespace OpenSim.Region.Framework.Scenes
 
             SceneObjectPart selectionPart = GetPart(localID);
 
-            if (SetTemporary && Scene != null)
+            if (Scene != null)
             {
-                DetachFromBackup();
-                // Remove from database and parcel prim count
-                //
-                m_scene.DeleteFromStorage(UUID);
+                if (SetTemporary)
+                {
+                    DetachFromBackup();
+                    // Remove from database and parcel prim count
+                    //
+                    m_scene.DeleteFromStorage(UUID);
+                }
+                else if (!Backup)
+                {
+                    // Previously been temporary now switching back so make it
+                    // available for persisting again
+                    AttachToBackup();
+                }
+
                 m_scene.EventManager.TriggerParcelPrimCountTainted();
             }
 
@@ -3611,7 +3943,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void AdjustChildPrimPermissions()
+        public void AdjustChildPrimPermissions(bool forceTaskInventoryPermissive)
         {
             uint newOwnerMask = (uint)(PermissionMask.All | PermissionMask.Export) & 0xfffffff8; // Mask folded bits
             uint foldedPerms = RootPart.OwnerMask & 3;
@@ -3621,11 +3953,18 @@ namespace OpenSim.Region.Framework.Scenes
                 newOwnerMask &= part.BaseMask;
                 if (part != RootPart)
                     part.ClonePermissions(RootPart);
+                if (forceTaskInventoryPermissive)
+                    part.Inventory.ApplyGodPermissions(part.BaseMask);
             });
 
             uint lockMask = ~(uint)(PermissionMask.Move | PermissionMask.Modify);
             uint lockBit = RootPart.OwnerMask & (uint)(PermissionMask.Move | PermissionMask.Modify);
             RootPart.OwnerMask = (RootPart.OwnerMask & lockBit) | ((newOwnerMask | foldedPerms) & lockMask);
+
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: RootPart.OwnerMask now {0} for {1} in {2}", 
+//                (OpenMetaverse.PermissionMask)RootPart.OwnerMask, Name, Scene.Name);
+
             RootPart.ScheduleFullUpdate();
         }
 
@@ -3634,6 +3973,9 @@ namespace OpenSim.Region.Framework.Scenes
         {
             RootPart.UpdatePermissions(AgentID, field, localID, mask, addRemTF);
 
+<<<<<<< HEAD
+            AdjustChildPrimPermissions(Scene.Permissions.IsGod(AgentID));
+=======
             bool god = Scene.Permissions.IsGod(AgentID);
 
             if (field == 1 && god)
@@ -3645,6 +3987,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             AdjustChildPrimPermissions();
+>>>>>>> avn/ubitvar
 
             if (field == 1 && god) // Base mask was set. Update all child part inventories
             {
@@ -4694,10 +5037,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// down after it move one place down the list.
         /// </remarks>
         /// <returns>A list of the sitting avatars.  Returns an empty list if there are no sitting avatars.</returns>
-        public List<UUID> GetSittingAvatars()
+        public List<ScenePresence> GetSittingAvatars()
         {
             lock (m_sittingAvatars)
-                return new List<UUID>(m_sittingAvatars);
+                return new List<ScenePresence>(m_sittingAvatars);
         }
 
         /// <summary>