// llSetTransformLimits.mel
//
//////////////////////////////
//
// Maya script file
//
//////////////////////////////
//
// Author : Lluís Llobera
//	    (lluisllobera@hotmail.com)
//
// Creation date : 25/II/2005
//    Update 1.5 : 28/II/2005
//
// Main procedure : type "llSetTransformLimits" in the Command Line or Script Editor
//
//////////////////////////


////////////////////////////////////////////////////////////////////////////////////////
//
//
// VERSION 1
// This is a UI to quickly manage the transform limits of any number of selected
// objects. Ideal for rigging tasks ..
//
// UPDATE 1.5
// Changed the window to un-sizable, and modified the frameLayoutrs for "Translate",
// "Rotate" and "Scale" so that they automatically resize the window when expanded
// or collapsed, in addition to dynamically changing their height
//
//
//		Enjoy!!
//
//
////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////
//  global matrix $LLSTLMFLIMITSARRAY  //
/////////////////////////////////////////
// 
// Will store float values with the limits information when
// the "copy limits" button is pressed. The 1st column of the
// 10th line will either have a "0" or a "1", depending on whether
// there actually are stored limits in the matrix.
//
////////////////////////////////////

global matrix $LLSTLMFLIMITSARRAY[10][4] ;



/////////////////////////////////////
//  llSTLMFCopyLimits              //
/////////////////////////////////////
// 
// Copies the limits from the UI to the global matrix
//
// <-- llSetTransformLimits
//
////////////////////////////////////

global proc llSTLMFCopyLimits ()
  {

  global matrix $LLSTLMFLIMITSARRAY[10][4] ;
  string $FIELDATTRIBUTENAME[] = {"Trans"  , "Trans"  , "Trans"  ,
                                  "Rotate" , "Rotate" , "Rotate" , 
                                  "Scale"  , "Scale"  , "Scale"  } ;
  string $AXIS[] = {"X" , "Y" , "Z" ,
                    "X" , "Y" , "Z" ,
                    "X" , "Y" , "Z" } ;
  float $VALUE ;

  for ($I = 0 ; $I <= 8 ; $I++)
    {
    $VALUE = eval ("checkBox -q -v \"llSTLCheckBoxMin" + $FIELDATTRIBUTENAME[$I] + $AXIS[$I] + "\"") ;
    $LLSTLMFLIMITSARRAY[$I][0] = $VALUE ;

    $VALUE = eval ("floatField -q -v \"llSTLFloatFieldMin" + $FIELDATTRIBUTENAME[$I] + $AXIS[$I] + "\"") ;
    $LLSTLMFLIMITSARRAY[$I][1] = $VALUE ;

    $VALUE = eval ("floatField -q -v \"llSTLFloatFieldMax" + $FIELDATTRIBUTENAME[$I] + $AXIS[$I] + "\"") ;
    $LLSTLMFLIMITSARRAY[$I][2] = $VALUE ;

    $VALUE = eval ("checkBox -q -v \"llSTLCheckBoxMax" + $FIELDATTRIBUTENAME[$I] + $AXIS[$I] + "\"") ;
    $LLSTLMFLIMITSARRAY[$I][3] = $VALUE ;
    } ; // for $I

  $LLSTLMFLIMITSARRAY[9][0] = 1 ;

  button -e -en 1 llSTLMFPasteLimitsButton ;

  } ; // global proc llSTLMFCopyLimits
  
  
  
/////////////////////////////////////
//  llSTLMFPasteimits              //
/////////////////////////////////////
// 
// Sets limits for all selected objects, using 
// the values in the matrix
//
// <-- llSetTransformLimits
//
////////////////////////////////////

global proc llSTLMFPasteLimits ()
  {

  global matrix $LLSTLMFLIMITSARRAY[10][4] ;
  string $LIMITATTRIBUTENAME[] = {"Trans"  , "Trans"  , "Trans"  ,
                                  "Rot" ,    "Rot"    , "Rot"    , 
                                  "Scale"  , "Scale"  , "Scale"  } ;
  string $AXIS[] = {"X" , "Y" , "Z" ,
                    "X" , "Y" , "Z" ,
                    "X" , "Y" , "Z" } ;
  float $VALUE ;

  for ($ELEMENT in `ls -sl -type transform -type joint`)
    {
    for ($I = 0 ; $I <= 8 ; $I++)
      {
      setAttr ($ELEMENT + ".min" + $LIMITATTRIBUTENAME[$I] + $AXIS[$I] + "LimitEnable") $LLSTLMFLIMITSARRAY[$I][0] ;

      setAttr ($ELEMENT + ".min" + $LIMITATTRIBUTENAME[$I] + $AXIS[$I] + "Limit") $LLSTLMFLIMITSARRAY[$I][1] ;

      setAttr ($ELEMENT + ".max" + $LIMITATTRIBUTENAME[$I] + $AXIS[$I] + "Limit") $LLSTLMFLIMITSARRAY[$I][2] ;

      setAttr ($ELEMENT + ".max" + $LIMITATTRIBUTENAME[$I] + $AXIS[$I] + "LimitEnable") $LLSTLMFLIMITSARRAY[$I][3] ;
      } ; // for $I
    } ; // for $ELEMENT

  llSTLUpdateOnSelection ;

  } ; // global proc llSTLMFPasteLimits

  

/////////////////////////////////////
//  llSTLChangeCurrent             //
/////////////////////////////////////
// 
// Triggered when the "current" fields are changed,
// merely changes the values of the selected objects
//
// <-- llSetTransformLimits
//
////////////////////////////////////

global proc llSTLChangeCurrent (string $ATTRIBUTE , string $AXIS)
  {

  string $ATTRIBUTENAME ;
  switch ($ATTRIBUTE)
    {
    case "Trans" : $ATTRIBUTENAME = "t" ; break ;
    case "Rotate" : $ATTRIBUTENAME = "r" ; break ;
    case "Scale" : $ATTRIBUTENAME = "s" ; break ;
    } ; // switch ($ATTRIBUTE) 

  for ($ELEMENT in `ls -sl -type transform -type joint`)
    {
    setAttr ($ELEMENT + "." + $ATTRIBUTENAME + `tolower $AXIS`)
      `floatField -q -v ("llSTLFloatFieldCurrent" + $ATTRIBUTE + $AXIS)` ;
    } ; // for

  } ; // global proc llSTLChangeCurrent

  
  
/////////////////////////////////////
//  llSTLLimitChange               //
/////////////////////////////////////
// 
// Changes the values of the Limits in the UI and 
// the attributes of all the selected objects.
//
// <-- llSetTransformLimits
//
////////////////////////////////////

global proc llSTLLimitChange (string $MINMAX , string $ATTRIBUTE , string $AXIS , int $SPECIFIED)
  {

  string $ATTRIBUTES[] = {"t" , "r" , "s"} ;
  string $FIELDATTRIBUTENAME ;
  string $LIMITATTRIBUTENAME ;
  switch ($ATTRIBUTE)
    {
    case "Trans" : $LIMITATTRIBUTENAME = "Trans" ; $FIELDATTRIBUTENAME = "t" ; break ;
    case "Rotate" : $LIMITATTRIBUTENAME = "Rot" ; $FIELDATTRIBUTENAME = "r" ; break ;
    case "Scale" : $LIMITATTRIBUTENAME = "Scale" ; $FIELDATTRIBUTENAME = "s" ; break ;
    } ; // switch ($ATTRIBUTE) 
  float $VALUE ;
  string $TRANSFORMS[] = `ls -sl -type transform -type joint` ;
  string $LASTTRANSFORM = $TRANSFORMS[`size $TRANSFORMS` - 1] ;

  for ($ELEMENT in $TRANSFORMS)
    {
    if ($SPECIFIED == 1)
      $VALUE = `floatField -q -v ("llSTLFloatField" + $MINMAX + $ATTRIBUTE + $AXIS)` ;
    else
      $VALUE = `floatField -q -v ("llSTLFloatFieldCurrent" + $ATTRIBUTE + $AXIS)` ;

    setAttr ($ELEMENT + "." + `tolower $MINMAX` + $LIMITATTRIBUTENAME + $AXIS + "LimitEnable") 1 ;
    setAttr ($ELEMENT + "." + `tolower $MINMAX` + $LIMITATTRIBUTENAME + $AXIS + "Limit") $VALUE ;
    } ; // for
  
  } ; // global proc llSTLLimitChange

  
  
/////////////////////////////////////
//  llSTLGreyOutFloatFieldValues   //
/////////////////////////////////////
// 
// When no objects are selected, the whole
// UI's controls are greyed-out
//
// <-- llSetTransformLimits
//
////////////////////////////////////

global proc llSTLGreyOutFloatFieldValues ()
  {
  string $AXIS[] = {"X" , "Y" , "Z"} ;
  string $ATTRIBUTES[] = {"t" , "r" , "s"} ;
  string $FIELDATTRIBUTENAMES[] = {"Trans" , "Rotate" , "Scale"} ;
  string $MINMAX[] = {"Min" , "Max"} ;

  for ($I = 0 ; $I <= 2 ; $I++)
    {
    for ($J = 0 ; $J <= 2 ; $J++)
      {
      string $CURRENTAXIS = `tolower ($AXIS[$J])` ;

      floatField -e -en 0
        ("llSTLFloatFieldCurrent" + $FIELDATTRIBUTENAMES[$I] + $AXIS[$J]) ;

      for ($Q = 0 ; $Q <= 1 ; $Q++)
        {
        button -e -en 0 ("llSTLButtonArrow" + $MINMAX[$Q] + $FIELDATTRIBUTENAMES[$I] + $AXIS[$J]) ;

        floatField -e -en 0
          ("llSTLFloatField" + $MINMAX[$Q] + $FIELDATTRIBUTENAMES[$I] + $AXIS[$J]) ;

        checkBox -e -en 0
          ("llSTLCheckBox" + $MINMAX[$Q] + $FIELDATTRIBUTENAMES[$I] + $AXIS[$J]) ;
        } ; // for $Q

      } ; // for $J
    } ; // for $I
  } ; // global proc llSTLGreyOutFloatFieldValues


  

/////////////////////////////////////
//  llSTLUpdateFloatFieldValues    //
/////////////////////////////////////
// 
// Some object(s) are selected. The UI controls
// are connected to the last object's attributes
//
// <-- llSetTransformLimits
// --> llSTLCheckBoxChanged
//
////////////////////////////////////

global proc llSTLUpdateFloatFieldValues (string $TRANSFORMS[])
  {

  string $LASTTRANSFORM = $TRANSFORMS[(`size $TRANSFORMS` - 1)] ;

  string $AXIS[] = {"X" , "Y" , "Z"} ;
  string $ATTRIBUTES[] = {"t" , "r" , "s"} ;
  string $FIELDATTRIBUTENAMES[] = {"Trans" , "Rotate" , "Scale"} ;
  string $LIMITATTRIBUTENAMES[] = {"Trans" , "Rot" , "Scale"} ;
  string $MINMAX[] = {"Min" , "Max"} ;

  for ($I = 0 ; $I <= 2 ; $I++)
    {
    for ($J = 0 ; $J <= 2 ; $J++)
      {
      string $CURRENTAXIS = `tolower ($AXIS[$J])` ;

      floatField -e -en 1
        ("llSTLFloatFieldCurrent" + $FIELDATTRIBUTENAMES[$I] + $AXIS[$J]) ;

      connectControl ("llSTLFloatFieldCurrent" + $FIELDATTRIBUTENAMES[$I] + $AXIS[$J])
        (($LASTTRANSFORM + "." + $ATTRIBUTES[$I] + $CURRENTAXIS))  ;

      int $CURRENTLIMITSENABLED[] = eval ("transformLimits -q -e" + $ATTRIBUTES[$I] + $CURRENTAXIS + " " + $LASTTRANSFORM) ;

      for ($Q = 0 ; $Q <= 1 ; $Q++)
        {
        button -e -en 1 ("llSTLButtonArrow" + $MINMAX[$Q] + $FIELDATTRIBUTENAMES[$I] + $AXIS[$J]) ;

        connectControl ("llSTLFloatField" + $MINMAX[$Q] + $FIELDATTRIBUTENAMES[$I] + $AXIS[$J]) 
          (($LASTTRANSFORM + "." + `tolower $MINMAX[$Q]` + $LIMITATTRIBUTENAMES[$I] + $AXIS[$J]) + "Limit")  ;

        connectControl ("llSTLCheckBox" + $MINMAX[$Q] + $FIELDATTRIBUTENAMES[$I] + $AXIS[$J])
          ($LASTTRANSFORM + "." + `tolower $MINMAX[$Q]` + $LIMITATTRIBUTENAMES[$I] + $AXIS[$J] + "LimitEnable") ;

        llSTLCheckBoxChanged ($CURRENTLIMITSENABLED[$Q] , $MINMAX[$Q] , $FIELDATTRIBUTENAMES[$I] , $AXIS[$J]) ;
        } ; // for $Q

      } ; // for $J
    } ; // for $I

  } ; // global proc llSTLUpdateFloatFieldValues

  
  
/////////////////////////////////////
//  llSTLUpdateOnSelection         //
/////////////////////////////////////
// 
// The selection has changed, and this proc
// checks if the objects are limit-able
//
// <-- llSetTransformLimits
// --> llSTLUpdateFloatFieldValues
//
////////////////////////////////////

global proc llSTLUpdateOnSelection ()
  {

  global matrix $LLSTLMFLIMITSARRAY[10][4] ;    

  string $SELECTED[] = `ls -sl` ;
  int $SIZESELECTED = `size $SELECTED` ;
  string $TRANSFORMS[] = `ls -sl -type transform -type joint` ;
  int $SIZETRANSFORMS = `size $TRANSFORMS` ;

  if ($SIZESELECTED == 0)
    warning "no objects selected" ;
  else
  if ($SIZESELECTED > $SIZETRANSFORMS)
    if ($SIZETRANSFORMS == 0)
      warning "current selection has no adequate nodes to set limits to" ;
    else
      warning "some of the selected nodes are not transforms or joints" ;

  if ($SIZETRANSFORMS > 0)
    {
    button -e -en 1 llSTLMFCopyLimitsButton ;
    if ($LLSTLMFLIMITSARRAY[9][0] == 1)
      button -e -en 1 llSTLMFPasteLimitsButton ;
    else
      button -e -en 0 llSTLMFPasteLimitsButton ;
    llSTLUpdateFloatFieldValues ($TRANSFORMS) ;
    } // if
  else
    {
    button -e -en 0 llSTLMFCopyLimitsButton ;
    button -e -en 0 llSTLMFPasteLimitsButton ;
    llSTLGreyOutFloatFieldValues ;
    } ; // else

  } ; // global proc llSTLUpdateOnSelection

  
  
/////////////////////////////////////
//  llSTLArrowPressed              //
/////////////////////////////////////
// 
// Enables the checkbox to enable the floatField,
// then calls on to the next proc.
//
// <-- llSetTransformLimits
// --> llSTLCheckBoxChanged
// --> llSTLLimitChange
//
////////////////////////////////////

global proc llSTLArrowPressed (string $MINMAX , string $ATTRIBUTE , string $AXIS)
  {

  llSTLCheckBoxChanged (1 , $MINMAX , $ATTRIBUTE , $AXIS) ;

  llSTLLimitChange $MINMAX $ATTRIBUTE $AXIS 0 ;

  } ; // global proc llSTLArrowPressed



/////////////////////////////////////
//  llSTLCheckBoxChanged           //
/////////////////////////////////////
// 
// Enables or disables the checkboxes and floatFields.
//
// <-- llSetTransformLimits
// <-- llSTLArrowPressed
//
////////////////////////////////////  

global proc llSTLCheckBoxChanged (int $VALUE , string $MINMAX , string $ATTRIBUTE , string $AXIS)
  {

  string $TRANSFORMS[] = `ls -sl -type transform -type joint` ;
  string $LIMITATTRIBUTENAME ;
  string $ATTRIBUTEINITIAL ;
  switch ($ATTRIBUTE)
    {
    case "Trans" : $ATTRIBUTEINITIAL = "t" ; $LIMITATTRIBUTENAME = "Trans" ; break ;
    case "Rotate" : $ATTRIBUTEINITIAL = "r" ; $LIMITATTRIBUTENAME = "Rot" ; break ;
    case "Scale" : $ATTRIBUTEINITIAL = "s" ; $LIMITATTRIBUTENAME = "Scale" ; break ;
    } ; // switch $ATTRIBUTE

  floatField -e -en $VALUE ("llSTLFloatField" + $MINMAX + $ATTRIBUTE + $AXIS) ;

  for ($ELEMENT in `ls -sl -type transform -type joint`)
    setAttr ($ELEMENT + "." + `tolower $MINMAX` + $LIMITATTRIBUTENAME + $AXIS + "LimitEnable") $VALUE ;
 
  } ; // global proc llSTLCheckBoxChanged



/////////////////////////////////////
//  llSTLCreateLimitsUI            //
/////////////////////////////////////
// 
// Creates the min/current/max XYZ controls for each limit.
//
// <-- llSetTransformLimits
//
////////////////////////////////////  

global proc llSTLCreateLimitsUI (string $ATTRIBUTE , int $CHILD)
  {

  string $AXIS[] = { "X" , "Y" , "Z" } ;

  columnLayout ;

  rowColumnLayout 
    -numberOfColumns 8 
    -cat 1 "both" 10
    -cw 1 90
    -cat 2 "both" 2
    -cw 2 15
    -cat 3 "both" 2
    -cal 3 "center"
    -cw 3 70
    -cat 4 "both" 2
    -cw 4 20
    -cat 5 "both" 2
    -cal 5 "center" 
    -cw 5 70
    -cat 6 "both" 2
    -cw 6 20
    -cat 7 "both" 2
    -cal 7 "center" 
    -cw 7 70
    -cat 8 "both" 2
    -cw 8 15 ;

  // ROW 1 : labels for columns
  text " " ; 
  text " " ; 
  text -al "center" "Min" ; 
  text " " ; 
  text -al "center" "Current" ; 
  text " " ; 
  text -al "center" "Max" ; 
  text " " ; 

  // ROWS 2 to 4
  for ($I = 0 ; $I <= 2 ; $I++)
    {
    text ($ATTRIBUTE + " Limit " + $AXIS[$I]) ;

    checkBox 
      -v 0 
      -onc ("llSTLCheckBoxChanged 1 \"Min\" \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\"")
      -ofc ("llSTLCheckBoxChanged 0 \"Min\" \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\"")
      -l "" 
    ("llSTLCheckBoxMin" + $ATTRIBUTE + $AXIS[$I]) ;

    floatField 
      -en 0 
      -pre 3 
      -v 0
      -cc ("llSTLLimitChange \"Min\" \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\" 1")
      -ec ("llSTLLimitChange \"Min\" \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\" 1")
   ("llSTLFloatFieldMin" + $ATTRIBUTE + $AXIS[$I]) ;

    button 
      -l "<" 
      -c ("llSTLArrowPressed \"Min\" \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\"") 
      ("llSTLButtonArrowMin" + $ATTRIBUTE + $AXIS[$I]) ;

    floatField 
      -pre 3 
      -v 0 
      -cc ("llSTLChangeCurrent \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\"")
      -ec ("llSTLChangeCurrent \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\"")
    ("llSTLFloatFieldCurrent" + $ATTRIBUTE + $AXIS[$I]) ;

    button 
      -l ">" 
      -c ("llSTLArrowPressed \"Max\" \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\"")
    ("llSTLButtonArrowMax" + $ATTRIBUTE + $AXIS[$I]) ;

    floatField 
      -en 0 
      -pre 3 
      -v 0 
      -cc ("llSTLLimitChange \"Max\" \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\" 1")
      -ec ("llSTLLimitChange \"Max\" \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\" 1")
    ("llSTLFloatFieldMax" + $ATTRIBUTE + $AXIS[$I]) ;

    checkBox
      -v 0 
      -onc ("llSTLCheckBoxChanged 1 \"Max\" \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\"")
      -ofc ("llSTLCheckBoxChanged 0 \"Max\" \"" + $ATTRIBUTE + "\" \"" + $AXIS[$I] + "\"")
      -l "" 
    ("llSTLCheckBoxMax" + $ATTRIBUTE + $AXIS[$I]) ;

    } ;
  setParent .. ;

  separator -style "none" -h 5 ;

  setParent .. ;

  } ; // global proc llSTLCreateLimitsUI

  

    
/////////////////////////////////////
//  llSetTransformLimits           //
/////////////////////////////////////
// 
// MAIN PROC
// Creates the main UI, plus a scriptJob 
// triggered on SelectionChanged
//
// --> llSTLCreateLimitsUI
// --> llSTLMFCopyLimits
// --> llSTLMFPasteLimits
// --> llSTLUpdateOnSelection
//
//////////////////////////////////// 

global proc llSetTransformLimits ()
  {

  int $WIDTH = 400 ;
  int $HEIGHT = 230 ;
  string $VERSION = "1.05" ;

  if (`window -ex llSTLWindow`) deleteUI llSTLWindow ;

  window
    -tb 1
    -title ("llSetTransformLimits v" + $VERSION)
    -menuBar 1
  llSTLWindow ;

  // llSTLMainFormLayout definition
  formLayout llSTLMainFormLayout ;

  // llSTLMainFormLayout child 1 : llSTLMFL1 ("text")
  columnLayout -rs 5 llSTLMF1 ;
  text "llSetTransformLimits Settings" ;
  setParent .. ;

  // llSTLMainFormLayout child 2 : llSTLMF2 ("translate")
  frameLayout 
    -bs "etchedIn" 
    -cll 1
    -cl 0
    -ec ("window -e -h (`window -q -h llSTLWindow` + 84) llSTLWindow ; frameLayout -e -h 104 llSTLMF2")
    -cc ("window -e -h (`window -q -h llSTLWindow` - 84) llSTLWindow ; frameLayout -e -h 20 llSTLMF2")
    -h 104
    -l "Translate" 
  llSTLMF2 ;
  llSTLCreateLimitsUI ("Trans" , 2) ;
  setParent .. ;

  // llSTLMainFormLayout child 3 : llSTLMF3 ("rotate")
  frameLayout 
    -bs "etchedIn" 
    -cll 1 
    -cl 1 
    -ec ("window -e -h (`window -q -h llSTLWindow` + 84) llSTLWindow ; frameLayout -e -h 104 llSTLMF3")
    -cc ("window -e -h (`window -q -h llSTLWindow` - 84) llSTLWindow ; frameLayout -e -h 20 llSTLMF3")
    -h 20 
    -l "Rotate" 
  llSTLMF3 ;
  llSTLCreateLimitsUI ("Rotate" , 3) ;
  setParent .. ;

  // llSTLMainFormLayout child 4 : llSTLMF4 ("scale")
  frameLayout 
    -bs "etchedIn" 
    -cll 1 
    -cl 1 
    -ec ("window -e -h (`window -q -h llSTLWindow` + 84) llSTLWindow ; frameLayout -e -h 104 llSTLMF4")
    -cc ("window -e -h (`window -q -h llSTLWindow` - 84) llSTLWindow ; frameLayout -e -h 20 llSTLMF4")
    -h 20 
    -l "Scale" 
  llSTLMF4 ;
  llSTLCreateLimitsUI ("Scale" , 4) ;
  setParent .. ;

  // llSTLMainFormLayout child 5 :llSTLMF5 ("buttons") 
  rowColumnLayout 
    -nc 2
    -h 30
    -rat 1 "both" 5
    -cat 1 "both" 5
    -cw 1 75
    -cat 2 "both" 10
    -rat 2 "both" 5
    -cw 2 90
  llSTLMF5 ;

  button 
    -l "copy limits" 
    -c llSTLMFCopyLimits
  llSTLMFCopyLimitsButton ;

  button 
    -en 0
    -l "paste limits" 
    -c llSTLMFPasteLimits
  llSTLMFPasteLimitsButton ;

  setParent .. ;

  // llSTLMainFormLayout edit

  formLayout -e
    -attachForm      llSTLMF1   "top"      1
    -attachNone      llSTLMF1   "bottom"
    -attachForm      llSTLMF1   "left"     15
    -attachForm      llSTLMF1   "right"    1

    -attachControl   llSTLMF2   "top"      1   llSTLMF1
    -attachNone      llSTLMF2   "bottom"
    -attachForm      llSTLMF2   "left"     1
    -attachForm      llSTLMF2   "right"    1

    -attachControl   llSTLMF3   "top"      1   llSTLMF2
    -attachNone      llSTLMF3   "bottom"
    -attachForm      llSTLMF3   "left"     1
    -attachForm      llSTLMF3   "right"    1

    -attachControl   llSTLMF4   "top"      1   llSTLMF3
    -attachNone      llSTLMF4   "bottom"
    -attachForm      llSTLMF4   "left"     1
    -attachForm      llSTLMF4   "right"    1

    -attachControl   llSTLMF5   "top"      1   llSTLMF4
    -attachForm      llSTLMF5   "bottom"   1
    -attachForm      llSTLMF5   "left"     1
    -attachForm      llSTLMF5   "right"    1
  llSTLMainFormLayout ;

  window -e -s 0 -wh $WIDTH $HEIGHT llSTLWindow ;

  showWindow llSTLWindow ;

  llSTLUpdateOnSelection ;

  scriptJob
    -p llSTLWindow
    -event SelectionChanged
    llSTLUpdateOnSelection ;

  } ; // global proc llSetTransformLimits
  
  

////////////////////////////////////////////////////////////////////////////////////////
//
// EoS llSetTransformLimits.mel
//
////////////////////////////////////////////////////////////////////////////////////////