Merge branch 'ubitwork'

4 files changed, 194 insertions, 112 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index f835e56..051c4fa 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -11518,183 +11518,270 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 //                        }
 
                         UpdatePrimGroupRotation handlerUpdatePrimGroupRotation;
+                        UpdateVector handlerUpdatePrimGroupScale;
+
+                        Quaternion arot;
+                        Vector3 ascale;
+                        Vector3 apos;
+/*ubit from ll JIRA:
+ * 0x01 position
+ * 0x02 rotation
+ * 0x04 scale
+  
+ * 0x08 LINK_SET
+ * 0x10 UNIFORM for scale
+ */
+
 
                         switch (block.Type)
                         {
-                            case 1:
-                                Vector3 pos1 = new Vector3(block.Data, 0);
+                            case 1: //change position sp
+                                apos = new Vector3(block.Data, 0);
 
                                 UpdateVector handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;
                                 if (handlerUpdatePrimSinglePosition != null)
                                 {
+                                    part.StoreUndoState();
+                                    part.IgnoreUndoUpdate = true;
+
                                     // m_log.Debug("new movement position is " + pos.X + " , " + pos.Y + " , " + pos.Z);
-                                    handlerUpdatePrimSinglePosition(localId, pos1, this);
+                                    handlerUpdatePrimSinglePosition(localId, apos, this);
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
 
-                            case 2:
-                                Quaternion rot1 = new Quaternion(block.Data, 0, true);
+                            case 2: // rotation sp
+                                arot = new Quaternion(block.Data, 0, true);
 
                                 UpdatePrimSingleRotation handlerUpdatePrimSingleRotation = OnUpdatePrimSingleRotation;
                                 if (handlerUpdatePrimSingleRotation != null)
                                 {
-                                    // m_log.Info("new tab rotation is " + rot1.X + " , " + rot1.Y + " , " + rot1.Z + " , " + rot1.W);
-                                    handlerUpdatePrimSingleRotation(localId, rot1, this);
+                                    part.StoreUndoState();
+                                    part.IgnoreUndoUpdate = true;
+
+                                    handlerUpdatePrimSingleRotation(localId, arot, this);
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
 
-                            case 3:
-                                Vector3 rotPos = new Vector3(block.Data, 0);
-                                Quaternion rot2 = new Quaternion(block.Data, 12, true);
+                            case 3: // position plus rotation
+                                apos = new Vector3(block.Data, 0);
+                                arot = new Quaternion(block.Data, 12, true);
 
                                 UpdatePrimSingleRotationPosition handlerUpdatePrimSingleRotationPosition = OnUpdatePrimSingleRotationPosition;
                                 if (handlerUpdatePrimSingleRotationPosition != null)
                                 {
-                                    // m_log.Debug("new mouse rotation position is " + rotPos.X + " , " + rotPos.Y + " , " + rotPos.Z);
-                                    // m_log.Info("new mouse rotation is " + rot2.X + " , " + rot2.Y + " , " + rot2.Z + " , " + rot2.W);
-                                    handlerUpdatePrimSingleRotationPosition(localId, rot2, rotPos, this);
+                                    part.StoreUndoState();
+                                    part.IgnoreUndoUpdate = true;
+
+                                    handlerUpdatePrimSingleRotationPosition(localId, arot, apos, this);
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
 
-                            case 4:
-                            case 20:
-                                Vector3 scale4 = new Vector3(block.Data, 0);
+                            case 4: // scale sp
+                            case 0x14: // uniform scale sp 
+                                ascale = new Vector3(block.Data, 0);
 
                                 UpdateVector handlerUpdatePrimScale = OnUpdatePrimScale;
                                 if (handlerUpdatePrimScale != null)
                                 {
-                                    //                                     m_log.Debug("new scale is " + scale4.X + " , " + scale4.Y + " , " + scale4.Z);
-                                    handlerUpdatePrimScale(localId, scale4, this);
+                                    part.StoreUndoState();
+                                    part.IgnoreUndoUpdate = true;
+
+                                    handlerUpdatePrimScale(localId, ascale, this);
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
 
-                            case 5:
-                                Vector3 scale1 = new Vector3(block.Data, 12);
-                                Vector3 pos11 = new Vector3(block.Data, 0);
+                            case 5: // scale and position sp
+                                apos = new Vector3(block.Data, 0);
+                                ascale = new Vector3(block.Data, 12);
+                                
 
                                 handlerUpdatePrimScale = OnUpdatePrimScale;
                                 if (handlerUpdatePrimScale != null)
                                 {
-                                    // m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
-                                    handlerUpdatePrimScale(localId, scale1, this);
+                                    part.StoreUndoState();
+                                    part.IgnoreUndoUpdate = true;
+
+                                    handlerUpdatePrimScale(localId, ascale, this);
+
+                                    handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;
 
+                                    if (handlerUpdatePrimSinglePosition != null)
+                                    {
+                                        handlerUpdatePrimSinglePosition(localId, apos, this);
+                                    }
+                                    part.IgnoreUndoUpdate = false;
+                                }
+                                break;
+
+                            case 0x15: //uniform scale and position
+                                apos = new Vector3(block.Data, 0);
+                                ascale = new Vector3(block.Data, 12);
+                                
+
+                                handlerUpdatePrimScale = OnUpdatePrimScale;
+                                if (handlerUpdatePrimScale != null)
+                                {
+                                    part.StoreUndoState(false);
+                                    part.IgnoreUndoUpdate = true;
+
+                                    // m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
+                                    handlerUpdatePrimScale(localId, ascale, this);
                                     handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;
                                     if (handlerUpdatePrimSinglePosition != null)
                                     {
-                                        handlerUpdatePrimSinglePosition(localId, pos11, this);
+                                        handlerUpdatePrimSinglePosition(localId, apos, this);
                                     }
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
 
-                            case 9:
-                                Vector3 pos2 = new Vector3(block.Data, 0);
+// now group related (bit 4)
+                            case 9: //( 8 + 1 )group position
+                                apos = new Vector3(block.Data, 0);
 
                                 UpdateVector handlerUpdateVector = OnUpdatePrimGroupPosition;
 
                                 if (handlerUpdateVector != null)
                                 {
-                                    handlerUpdateVector(localId, pos2, this);
+                                    part.StoreUndoState(true);
+                                    part.IgnoreUndoUpdate = true;
+
+                                    handlerUpdateVector(localId, apos, this);
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
 
-                            case 10:
-                                Quaternion rot3 = new Quaternion(block.Data, 0, true);
+                            case 0x0A: // (8 + 2) group rotation
+                                arot = new Quaternion(block.Data, 0, true);
 
                                 UpdatePrimRotation handlerUpdatePrimRotation = OnUpdatePrimGroupRotation;
                                 if (handlerUpdatePrimRotation != null)
                                 {
                                     //  Console.WriteLine("new rotation is " + rot3.X + " , " + rot3.Y + " , " + rot3.Z + " , " + rot3.W);
-                                    handlerUpdatePrimRotation(localId, rot3, this);
+                                    part.StoreUndoState(true);
+                                    part.IgnoreUndoUpdate = true;
+
+                                    handlerUpdatePrimRotation(localId, arot, this);
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
 
-                            case 11:
-                                Vector3 pos3 = new Vector3(block.Data, 0);
-                                Quaternion rot4 = new Quaternion(block.Data, 12, true);
+                            case 0x0B: //( 8 + 2 + 1) group rotation and position
+                                apos = new Vector3(block.Data, 0);
+                                arot = new Quaternion(block.Data, 12, true);
 
                                 handlerUpdatePrimGroupRotation = OnUpdatePrimGroupMouseRotation;
                                 if (handlerUpdatePrimGroupRotation != null)
                                 {
                                     //  m_log.Debug("new rotation position is " + pos.X + " , " + pos.Y + " , " + pos.Z);
                                     // m_log.Debug("new group mouse rotation is " + rot4.X + " , " + rot4.Y + " , " + rot4.Z + " , " + rot4.W);
-                                    handlerUpdatePrimGroupRotation(localId, pos3, rot4, this);
+                                    part.StoreUndoState(true);
+                                    part.IgnoreUndoUpdate = true;
+
+                                    handlerUpdatePrimGroupRotation(localId, apos, arot, this);
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
-                            case 12:
-                            case 28:
-                                Vector3 scale7 = new Vector3(block.Data, 0);
 
-                                UpdateVector handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale;
-                                if (handlerUpdatePrimGroupScale != null)
+                            case 0x0C: // (8 + 4) group scale
+                                // only afects root prim and only sent by viewer editor object tab scaling
+                                // mouse edition only allows uniform scaling
+                                // SL MAY CHANGE THIS in viewers
+
+                                ascale = new Vector3(block.Data, 0);
+
+                                handlerUpdatePrimScale = OnUpdatePrimScale;
+                                if (handlerUpdatePrimScale != null)
                                 {
                                     //                                     m_log.Debug("new scale is " + scale7.X + " , " + scale7.Y + " , " + scale7.Z);
-                                    handlerUpdatePrimGroupScale(localId, scale7, this);
+                                    part.StoreUndoState(false); // <- SL Exception make it apply to root prim and not  group
+                                    part.IgnoreUndoUpdate = true;
+
+                                    handlerUpdatePrimScale(localId, ascale, this);
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
 
-                            case 13:
-                                Vector3 scale2 = new Vector3(block.Data, 12);
-                                Vector3 pos4 = new Vector3(block.Data, 0);
+                            case 0x0D: //(8 + 4 + 1) group scale and position
+                                // exception as above
 
+                                apos = new Vector3(block.Data, 0);
+                                ascale = new Vector3(block.Data, 12);
+                                
                                 handlerUpdatePrimScale = OnUpdatePrimScale;
                                 if (handlerUpdatePrimScale != null)
                                 {
                                     //m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
-                                    handlerUpdatePrimScale(localId, scale2, this);
+                                    part.StoreUndoState(false); // <- make it apply to root prim and not  group
+                                    part.IgnoreUndoUpdate = true;
+
+                                    handlerUpdatePrimScale(localId, ascale, this);
 
                                     // Change the position based on scale (for bug number 246)
                                     handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;
                                     // m_log.Debug("new movement position is " + pos.X + " , " + pos.Y + " , " + pos.Z);
                                     if (handlerUpdatePrimSinglePosition != null)
                                     {
-                                        handlerUpdatePrimSinglePosition(localId, pos4, this);
+                                        handlerUpdatePrimSinglePosition(localId, apos, this);
                                     }
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
 
-                            case 29:
-                                Vector3 scale5 = new Vector3(block.Data, 12);
-                                Vector3 pos5 = new Vector3(block.Data, 0);
+                            case 0x1C: // (0x10 + 8 + 4 ) group scale UNIFORM
+                                ascale = new Vector3(block.Data, 0);
 
                                 handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale;
                                 if (handlerUpdatePrimGroupScale != null)
                                 {
-                                    // m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
+                                    //                                     m_log.Debug("new scale is " + scale7.X + " , " + scale7.Y + " , " + scale7.Z);
                                     part.StoreUndoState(true);
                                     part.IgnoreUndoUpdate = true;
-                                    handlerUpdatePrimGroupScale(localId, scale5, this);
-                                    handlerUpdateVector = OnUpdatePrimGroupPosition;
 
-                                    if (handlerUpdateVector != null)
-                                    {
-                                        handlerUpdateVector(localId, pos5, this);
-                                    }
+                                    handlerUpdatePrimGroupScale(localId, ascale, this);
 
                                     part.IgnoreUndoUpdate = false;
                                 }
-
                                 break;
 
-                            case 21:
-                                Vector3 scale6 = new Vector3(block.Data, 12);
-                                Vector3 pos6 = new Vector3(block.Data, 0);
+                            case 0x1D: // (UNIFORM + GROUP + SCALE + POS)
+                                apos = new Vector3(block.Data, 0);
+                                ascale = new Vector3(block.Data, 12);
+                                
 
-                                handlerUpdatePrimScale = OnUpdatePrimScale;
-                                if (handlerUpdatePrimScale != null)
+                                handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale;
+                                if (handlerUpdatePrimGroupScale != null)
                                 {
-                                    part.StoreUndoState(false);
+                                    // m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
+                                    part.StoreUndoState(true);
                                     part.IgnoreUndoUpdate = true;
 
-                                    // m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
-                                    handlerUpdatePrimScale(localId, scale6, this);
-                                    handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;
-                                    if (handlerUpdatePrimSinglePosition != null)
+                                    handlerUpdatePrimGroupScale(localId, ascale, this);
+
+                                    handlerUpdateVector = OnUpdatePrimGroupPosition;
+
+                                    if (handlerUpdateVector != null)
                                     {
-                                        handlerUpdatePrimSinglePosition(localId, pos6, this);
+                                        handlerUpdateVector(localId, apos, this);
                                     }
 
                                     part.IgnoreUndoUpdate = false;
                                 }
+
                                 break;
 
                             default:
@@ -11704,6 +11791,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
 //                        for (int j = 0; j < parts.Length; j++)
 //                            parts[j].IgnoreUndoUpdate = false;
+
                     }
                 }
             }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 038eaa4..2d71372 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -1569,7 +1569,7 @@ namespace OpenSim.Region.Framework.Scenes
 //                "[SCENE OBJECT GROUP]: Processing OnGrabPart for {0} on {1} {2}, offsetPos {3}",
 //                remoteClient.Name, part.Name, part.LocalId, offsetPos);
 
-            part.StoreUndoState();
+//            part.StoreUndoState();
             part.OnGrab(offsetPos, remoteClient);
         }
 
@@ -3119,7 +3119,7 @@ namespace OpenSim.Region.Framework.Scenes
         {
 //            m_log.DebugFormat(
 //                "[SCENE OBJECT GROUP]: Group resizing {0} {1} from {2} to {3}", Name, LocalId, RootPart.Scale, scale);
-            RootPart.StoreUndoState(true);
+//            RootPart.StoreUndoState(true);
 
             scale.X = Math.Min(scale.X, Scene.m_maxNonphys);
             scale.Y = Math.Min(scale.Y, Scene.m_maxNonphys);
@@ -3230,7 +3230,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (obPart.UUID != m_rootPart.UUID)
                 {
-                    obPart.IgnoreUndoUpdate = true;
+//                    obPart.IgnoreUndoUpdate = true;
 
                     Vector3 currentpos = new Vector3(obPart.OffsetPosition);
                     currentpos.X *= x;
@@ -3245,7 +3245,7 @@ namespace OpenSim.Region.Framework.Scenes
                     obPart.Resize(newSize);
                     obPart.UpdateOffSet(currentpos);
 
-                    obPart.IgnoreUndoUpdate = false;                    
+//                    obPart.IgnoreUndoUpdate = false;                    
                 }
 
 //                obPart.IgnoreUndoUpdate = false;
@@ -3270,7 +3270,7 @@ namespace OpenSim.Region.Framework.Scenes
         {
 //            m_log.DebugFormat("[SCENE OBJECT GROUP]: Updating group position on {0} {1} to {2}", Name, LocalId, pos);
 
-            RootPart.StoreUndoState(true);
+//            RootPart.StoreUndoState(true);
 
 //            SceneObjectPart[] parts = m_parts.GetArray();
 //            for (int i = 0; i < parts.Length; i++)
@@ -3311,17 +3311,17 @@ namespace OpenSim.Region.Framework.Scenes
         {
             SceneObjectPart part = GetChildPart(localID);
 
-            SceneObjectPart[] parts = m_parts.GetArray();
-            for (int i = 0; i < parts.Length; i++)
-                parts[i].StoreUndoState();
+//            SceneObjectPart[] parts = m_parts.GetArray();
+//            for (int i = 0; i < parts.Length; i++)
+//                parts[i].StoreUndoState();
 
             if (part != null)
             {
 //                m_log.DebugFormat(
 //                    "[SCENE OBJECT GROUP]: Updating single position of {0} {1} to {2}", part.Name, part.LocalId, pos);
 
-                part.StoreUndoState(false);
-                part.IgnoreUndoUpdate = true;
+//                part.StoreUndoState(false);
+//                part.IgnoreUndoUpdate = true;
 
 // unlock parts position change
                 if (m_rootPart.PhysActor != null)
@@ -3340,7 +3340,7 @@ namespace OpenSim.Region.Framework.Scenes
                     m_rootPart.PhysActor.Building = false;
 
                 HasGroupChanged = true;
-                part.IgnoreUndoUpdate = false;
+//                part.IgnoreUndoUpdate = false;
             }
         }
 
@@ -3377,16 +3377,16 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             //We have to set undoing here because otherwise an undo state will be saved
-            if (!m_rootPart.Undoing)
-            {
-                m_rootPart.Undoing = true;
-                AbsolutePosition = newPos;
-                m_rootPart.Undoing = false;
-            }
-            else
-            {
+//            if (!m_rootPart.Undoing)
+//            {
+//                m_rootPart.Undoing = true;
                 AbsolutePosition = newPos;
-            }
+//                m_rootPart.Undoing = false;
+//            }
+//            else
+//            {
+//                AbsolutePosition = newPos;
+//            }
 
             HasGroupChanged = true;
             if (m_rootPart.Undoing)
@@ -3416,9 +3416,9 @@ namespace OpenSim.Region.Framework.Scenes
 //            for (int i = 0; i < parts.Length; i++)
 //                parts[i].StoreUndoState();
 
-            m_rootPart.StoreUndoState(true);
+//            m_rootPart.StoreUndoState(true);
 
-            m_rootPart.UpdateRotation(rot);
+//            m_rootPart.UpdateRotation(rot);
 
             PhysicsActor actor = m_rootPart.PhysActor;
             if (actor != null)
@@ -3445,8 +3445,8 @@ namespace OpenSim.Region.Framework.Scenes
 //            for (int i = 0; i < parts.Length; i++)
 //                parts[i].StoreUndoState();
 
-            RootPart.StoreUndoState(true);
-            RootPart.IgnoreUndoUpdate = true;
+//            RootPart.StoreUndoState(true);
+//            RootPart.IgnoreUndoUpdate = true;
 
             m_rootPart.UpdateRotation(rot);
 
@@ -3462,7 +3462,7 @@ namespace OpenSim.Region.Framework.Scenes
             HasGroupChanged = true;
             ScheduleGroupForTerseUpdate();
 
-            RootPart.IgnoreUndoUpdate = false;
+//            RootPart.IgnoreUndoUpdate = false;
         }
 
         /// <summary>
@@ -3511,8 +3511,8 @@ namespace OpenSim.Region.Framework.Scenes
 //                    "[SCENE OBJECT GROUP]: Updating single position and rotation of {0} {1} to {2}",
 //                    part.Name, part.LocalId, rot);
 
-                part.StoreUndoState();
-                part.IgnoreUndoUpdate = true;
+//                part.StoreUndoState();
+//                part.IgnoreUndoUpdate = true;
 
                 if (m_rootPart.PhysActor != null)
                     m_rootPart.PhysActor.Building = true;
@@ -3541,7 +3541,7 @@ namespace OpenSim.Region.Framework.Scenes
                 if (m_rootPart.PhysActor != null)
                     m_rootPart.PhysActor.Building = false;
 
-                part.IgnoreUndoUpdate = false;
+//                part.IgnoreUndoUpdate = false;
             }
         }
 
@@ -3557,7 +3557,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             Quaternion axRot = rot;
             Quaternion oldParentRot = m_rootPart.RotationOffset;
-            m_rootPart.StoreUndoState();
+//            m_rootPart.StoreUndoState();
             
             //Don't use UpdateRotation because it schedules an update prematurely
             m_rootPart.RotationOffset = rot;
@@ -3573,7 +3573,7 @@ namespace OpenSim.Region.Framework.Scenes
                 SceneObjectPart prim = parts[i];
                 if (prim.UUID != m_rootPart.UUID)
                 {
-                    prim.IgnoreUndoUpdate = true;
+//                    prim.IgnoreUndoUpdate = true;
 
                     Quaternion NewRot = oldParentRot * prim.RotationOffset;
                     NewRot = Quaternion.Inverse(axRot) * NewRot;
@@ -3585,7 +3585,7 @@ namespace OpenSim.Region.Framework.Scenes
                     axPos *= Quaternion.Inverse(axRot);
                     prim.OffsetPosition = axPos;
 
-                    prim.IgnoreUndoUpdate = false;
+//                    prim.IgnoreUndoUpdate = false;
                 }
             }
 
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index cce606a..6622495 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -828,7 +828,7 @@ namespace OpenSim.Region.Framework.Scenes
             
             set
             {
-                StoreUndoState();
+//                StoreUndoState();
                 m_rotationOffset = value;
 
                 PhysicsActor actor = PhysActor;
@@ -1007,7 +1007,7 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (m_shape != null)
                 {
-                    StoreUndoState();
+//                    StoreUndoState();
 
                     m_shape.Scale = value;
 
diff --git a/OpenSim/Region/Framework/Scenes/UndoState.cs b/OpenSim/Region/Framework/Scenes/UndoState.cs
index 029c828..38474de 100644
--- a/OpenSim/Region/Framework/Scenes/UndoState.cs
+++ b/OpenSim/Region/Framework/Scenes/UndoState.cs
@@ -74,14 +74,11 @@ namespace OpenSim.Region.Framework.Scenes
                 ForGroup = forGroup;
                 Position = part.ParentGroup.AbsolutePosition;
                 Rotation = part.RotationOffset;
-                if (!forGroup)
-                    Scale = part.Shape.Scale;
-                else
-                    Scale = Vector3.Zero;  // until we fix it 
+                Scale = part.Shape.Scale;
             }
             else
             {
-                ForGroup = false;  // previus code implies only root parts can undo grp
+                ForGroup = false;  // only root parts can undo grp
                 Position = part.OffsetPosition;
                 Rotation = part.RotationOffset;
                 Scale = part.Shape.Scale;
@@ -108,9 +105,7 @@ namespace OpenSim.Region.Framework.Scenes
                         return false;
                     if (Rotation != part.RotationOffset)
                         return false;
-                    if (ForGroup)
-                        return true; // for now don't do grp scale
-                    return (Scale == part.Shape.Scale);
+                    return Scale == part.Shape.Scale;
                 }
                 else
                 {
@@ -144,10 +139,9 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (Scale != Vector3.Zero)
                 {
-                    //                    if (ForGroup)
-                    //                        part.ParentGroup.GroupResize(Scale);
-                    //                    else
-                    if (!ForGroup)   // we don't have grp scale for now
+                    if (ForGroup)
+                        part.ParentGroup.GroupResize(Scale);
+                    else
                         part.Resize(Scale);
                 }
                 part.ParentGroup.ScheduleGroupForTerseUpdate();