[Closed] Assign event to edittext through addhandler

ugh… I hate the rolloutCreator. It was intended to make dynamic rollout creation easier, but I seriously doubt it did(!)

Anyway – your code should be:

rci = rolloutCreator "myRollout" "My Rollout"
  rci.begin()
  rci.addControl #edittext mytext "MyText" 
  rci.addHandler  mytext #changed paramStr:"str" codeStr:"box()"
  rci.end()
  createDialog rci.def

The only difference is that I added the part ‘paramStr:“str”’. This is needed because an edittext control’s ‘changed’ event takes a single parameter, namely the string within the edittext control after the change.

Thanks a lot. That helped!!!

But I am still unable to recover that edittext value inside a function using that variable. Returns undefined. Can you please help…

rci = rolloutCreator "myRollout" "My Rollout"
    rci.begin()
    rci.addControl #edittext mytext "MyText" 
    rci.addHandler  mytext #entered paramStr:"str" codeStr:"xyz()"
    rci.end()
    createDialog rci.def
    
    
    fn xyz=(
  	  print "entered"
  	  print str			   --returns undefined here :-(
    )

First of all, SCOPING!
The function has to be defined before it is first called. You have to either pre-declare xyz as a variable in the beginning and define the function later, or just move the function definition before the rollout definition.

Second, if you want to print the content of the “str” parameter, you have to pass it to the xyz function!

fn xyz str=(
 		print "entered"
 		print str 
 	)
 rci = rolloutCreator "myRollout" "My Rollout"
 	rci.begin()
 	rci.addControl #edittext mytext "MyText" 
 	rci.addHandler  mytext #entered paramStr:"str" codeStr:"xyz str"
 	rci.end()
 	createDialog rci.def

OMG bobo himself

Thanks for the reply bobo. Is there no other way…Basically I am dynamically creating UI elements and I cant be passing the variables to functions… Cant global variables be used anywhere like in mel… Is there absolutely no other way… actually my variable names are based on the element names that are created dynamically and it would help if I could just have them as global variables and use them anywhere.

Of course you can use global variables, we are just trying to discourage people from using them extensively as they might collide with globals from other scripts.
All you need is pre-declaring all variables you will be using in the beginning of the script and then reading/writing at will. But please make sure the names of these variables are nothing like ‘str’ or ‘a’ because chances are somebody might come to the idea to use these as LOCAL variables in their script and would suddenly access your variables instead, potentially affecting your results. Always use long descriptive and unique names, possibly prefixed with the name or at least the initials of your code. So if you are writing a script called “MasterOfPuppetsPullingTheStrings”, you could abbreviate this to MOPPTS and add this as a prefix to each global variable to make it clear it is part of that code. Like MOPPTS_TotalNumberOfPuppets etc.

A very good practice is creating a struct with all variables your script will need and using the event handlers to set them in the struct as an intermediate storage, then reading the values from the struct.

This could look like

struct MOPPTS_Stuct_Def 
 (
 TotalNumberOfPuppets = 10,
 NumberOfStringsPerPuppet = 4
 )
 
 global MOPPTS_Props= MOPPTS_Stuct_Def()
 

At this point, you can access variables like MOPPTS_Props.TotalNumberOfPuppets and you would get 10, or set a value like (MOPPTS_Props.TotalNumberOfPuppets = 42).

Structs can contain functions, too. (they can even contain ONLY functions, in which case it is not even necessary to create an instance first).

So in your case, you could say

struct MOPPTS_Stuct_Def --define a struct with vars and functions
 (
 TotalNumberOfPuppets = 10,
 NumberOfStringsPerPuppet = 4,
 StringEntered = "",
 fn xyz=(
   format "entered %
" StringEntered
 )
 )
 
 global MOPPTS_Props= MOPPTS_Stuct_Def() --create a global instance of the struct
 
 rci = rolloutCreator "myRollout" "My Rollout"
 	rci.begin()
 	rci.addControl #edittext mytext "MyText" 
 	rci.addHandler  mytext #entered paramStr:"str" codeStr:"MOPPTS_Props.StringEntered=str;MOPPTS_Props.xyz()"
 	rci.end()
 	createDialog rci.def

Note that the struct defines some variables and a function. The event handler simply writes the current value into the struct and then calls a function in the struct which accesses that value via the variable inside the struct.
Of course, xyz() could be a function outside of the struct, in which case it would have to be like

fn xyz=(
   format "entered %
" MOPPTS_Props.StringEntered
 )