GeoMaestro

Advanced GUI features: customizing/programming

delete RL[i]["proj"]

• LigneUNDO (when 0, lignes and RL array are removed from the UNDO capabilities)
• EvUNDO (same with the Ev scene)
• DispUNDO (same with the displayed objects)

system(NOTEPAD1+"filename"+NOTEPAD2)

ACRefresh(n) 

Drum Picker:wdrumpick

NOTE: proj_infos() is coded in the lib/lib_proj.k file. If you want to avoid changing anything there (which is recommended since it will make it easier to upgrade the system by simply replacing all files in the GeoMaestro/lib directory), you can instead use the corresponding user function in userlib/GUIuserreg.k; see the comments in this file for details.

#include lib_proj.k

#include GUIuserreg.k

#------------------------------------------------------------------------------------
function name( p1 , p2 , ... , pn ,...)	      
{
	duree = OptArgs(...)["duree"]
	t0 = OptArgs(...)["t0"]
	region = OptArgs(...)["region"]
	df = OptArgs(...)["df"]

	ligne name = NewLigne( projector id , t0)

	(...) definition of the returned ligne, based either on already existing projectors, 
or on Ecoute and/or EcouteC

	return ( ligne name )
}
#------------------------------------------------------------------------------------

#------------------------------------------------------------------------------------
function Scint(a,b,long,ouvert,nS,...)	# calls nS times AversB between points a and b
{
	duree = OptArgs(...)["duree"]  # these lines take care of the optional arguments
	t0 = OptArgs(...)["t0"]
	region = OptArgs(...)["region"]
	df = OptArgs(...)["df"]

	bars= NewLigne("Scint", t0) # the projector id should simply be the name of the function

	for (n=1; n<=nS; n++)
		bars = MergeLignes(bars, AversB(a,b,long,ouvert,duree,bars[1],region,df))
		# this adds the ligne AversB(a,b,long,ouvert,duree,0,region,df) to bars. 
		# Note the t0 = 0 in the call. 
	
	return (bars)
}
#------------------------------------------------------------------------------------

• ph this is the nodur of the event to project
  
• pan this is the side (+1 is right, -1 is left) of the event relatively to the support
  
• dist distance from the event to the support
  
• ch MIDI channel (identical to the event's channel only for the 16 first ones !)
  
• theta angle (from 0 to 2*Pi) of the projection
  
• t is the local time (in clicks): use it at your own risks, it is not documented here
  
• ... (optional) are any number of parameters specific to the function
  

NOTE: you should actually leave alone the lib/lib_dist.k file (which will make it easier to later upgrade the system, since you will only have to replace all files in the /lib directory), and instead use the corresponding user functions in userlib/GUIuserreg.k; see the comments in this file for details.

function NotGood(ph, pan, dist)	# we don't need ch, so we can skip it here
{
	return ( 127*exp(-dist) )
}

function ThisIsGood(ph, pan, dist)	
{
	return ( 127*exp(-dist) - ph.vol)
}

function Vexp1(ph, pan, distance)		
{
	if ( distance > 5 ) return(-127)	# this to shorten calculation time
	return ( ph.vol*(exp(-distance)-1) )
}		

NOTE: Again, you want to leave alone the lib/lib_gen.k file (which will make it easier to later upgrade the system, since you will only have to replace all files in the /lib directory), so you can instead use the corresponding user function in userlib/GUIuserreg.k; see the comments in this file for details.

  
	     0: nothing 
  
 	     1: segment from A to D
  
 	     2: rectangle with opposite corners A and D
  
 	     3: circle whose center is A
  
 	     4: circle containing A whose center is D
  
 	     5: circle whose center is the middle of AD
  
 	     6: reference lignes: 2 lines crossing in A + 2 lines crossing in D + the line (A,D)
  
 	     7: cake-like cut of the plane in 4 parts around A + segment AD	(p1: number of the cut)
  
 	     8:	same, with	     8 parts	(p1: number of the cut)
  
 	     9:	same, with	     16 parts	(p1: number of the cut)
  
 	     10: cut of the plane in rings centered in A and separated by 1 unit + segment AD
  
 	     11: cut of the plane in rings centered in A and separated by 0.1unit + segment AD
  
 	     12: transparent active grid 12*12	(p1, p2: coordinates of the choosen box)			
  
 	     13: transparent active grid 10*10	(p1, p2: coordinates of the choosen box)				
  
 	     14: transparent active grid 6*6	(p1, p2: coordinates of the choosen box)				
  
 	     15: transparent active grid 16*16	(p1, p2: coordinates of the choosen box)	
  
 	     16: active grid 12*12 with white background	(p1, p2: coordinates of the choosen box)		
  
 	     17: active grid 10*10 with white background	(p1, p2: coordinates of the choosen box)				
  
 	     18: active grid 6*6 with white background	(p1, p2: coordinates of the choosen box)				
  
 	     19: active grid 16*16 with white background	(p1, p2: coordinates of the choosen box)	
  
           20: pop-up menu	(p1: chosen menu item)		

function TotoDown(xA, yA, target, ch) 	{ .. }
function TotoDrag(xD, yD, target)		{ .. }
# or TotoDrag(xD, yD, target, p1, p2, p3, pchange_flag)
function TotoUp(xB, yB, target, p1, p2, p3)	{ .. }

• all fields composing the event (see here for more)
• the extra field "alias" which is 1 if you're targeting an event's alias, 0 otherwise
• the extra fields "ch" and "n" which contain the indexes of the event in the Ev array (see here for more)

#------------------------------------------------------------------------------------
function DemoDown(x, y, target)
{
	StartingPoint = xyd(x,y)
}
function DemoDrag(x, y, target)
{
	print (x,y)
	if (sizeof(target)>0) print ("this is event :", target)
	return (0)	
}
function DemoUp(x, y, target)
{
	EndingPoint = xyd(x,y)
	print("started at: ", StartingPoint)
	print("ended at: ", EndingPoint)
}
#------------------------------------------------------------------------------------

#include lib_gen.k 

#------------------------------------------------------------------------------------
function Demo2Down(x, y, target)
{
	GenPalette[0] = [0 = "Yep", 1 = "Bouh", 5 = "Hmm"]
	GenPalette[3] = [3 = "Bof"]
}
function Demo2Drag(x, y, target)
{
	return (14)	
}
function Demo2Up(x, y, target, i, j)
{
	print("clicked in ("+string(i)+","+string(j)+") :",GenPalette[i][j])
}
#------------------------------------------------------------------------------------

#------------------------------------------------------------------------------------
function Demo3(x , y, target, ch)
{
	if (sizeof(target)>0)
	{
		RemoveEv(target["ch"], target["n"])
		print ("deleted event :", target)
	}
	else
	{
		CreateNewEvent(x, y, ch, '')
		print ("created an empty event in channel "+string(ch))
	}
}
#------------------------------------------------------------------------------------

• DUMP_ALL (dumps everything... you should not use that one !)
• DUMP_UNDO (dumps everything as allowed by the UNDO parameters... better nor use it either, as it saves too many things)
• CHANGES_IN_EVENTS (use this if your generator only makes changes in the Ev scene)
• CHANGES_IN_DISPLAY (if the generator changes the displayed objects; points, circles, etc...)
• CHANGES_IN_SETTINGS (if the generator makes changes in the distortion functions settings)
• CHANGES_IN_BORNES (if the generator simply zooms in or out)
• CHANGES_IN_LIGNES (if the generator works on the RL array and associated settings, like grouping mode). This one works differently:
  • if the value returned by TotoUNDO() is CHANGES_IN_LIGNES, the RL array itself is not dumped.
  • if the returned value is 2*CHANGES_IN_LIGNES, the RL array is dumped
  • if the returned value is n+CHANGES_IN_LIGNES, only the item RL[n] is dumped

LastGMGUI.display("Or,Oi,Oj")

#define gDISP(c) LastGMGUI.display(c)

gDISP("Or,Oi,Oj")

#	.display		[display]
#	.zoom(p, d)	... zooms on the area best fitting a disk of center p and radius d
#	.op		[operation]
#	.hear		[hear]
#	.redo		[redo]
#	.snarf		[snarf]
#	.kill		[kill]
#	.newEv		[new]
#	.delsel		[!delete!]

Note: the function

GeoGUIinpage()

... returns 1 if a GeoMaestro GUI is opened in the current page (Root), 0 otherwise.

Geocontains(xyarray) 		# LastGMGUIf.contains(xyarray)
Geoellipse(xyarray,...) 		#LastGMGUIf.ellipse(xyarray, ...)
Geocercle(x,y,r,...)		#LastGMGUIf.cercle(x,y,r,...)
Geofillellipse(xyarray, ...)		#LastGMGUIf.fillellipse(xyarray, ...)
Geofillrectangle(xyarray, ...) 		#LastGMGUIf.fillrectangle(xyarray, ...)
Georectangle(xyarray, ...)	 	#LastGMGUIf.rectangle(xyarray, ...)
Geoline(xyarray, ...) 		#LastGMGUIf.line(xyarray, ...)
Geotcenter(string, xyarray, ...)		 #LastGMGUIf.textcenter(string, xyarray, ...)
Geotleft(string, xyarray, ...) 		#LastGMGUIf.textleft(string, xyarray, ...)
Geotright(string, xyarray, ...)	 	#LastGMGUIf.textright(string, xyarray, ...)
Geoth() 		#LastGMGUIf.textheight()
Geotw() 		#LastGMGUIf.textwidth()
Geoxmax() 		#LastGMGUIf.xmax()
Geoxmin() 		#LastGMGUIf.xmin()
Geoymax() 		#LastGMGUIf.ymax()
Geoymin() 		#LastGMGUIf.ymin()

xyDisp(x0, y0, x1, y1)	# returns display coordinates (which should be used for graphics)
xDisp(x)
yDisp(y) 
dDisp(d)			# (d is a distance)

xyGeo(x0, y0, x1, y1)	# returns GeoMaestro coordinates 
xGeo(x) 
yGeo(y) 
dGeo(d) 

COLOR_RED
COLOR_BLUE
COLOR_GREEN
COLOR_LIGHTGREEN
COLOR_BROWN
COLOR_LIGHTBROWN
COLOR_PALEGREY
COLOR_GREY

function GUIbackground()
{
	Geocercle(xDisp(1), yDisp(1), dDisp(1))
}

function GUIbackground()
	{PourToutEv(CircleAround)}

function CircleAround(ev)
{
	Geocercle(xDisp(ev["x"]), yDisp(ev["y"]), dDisp(0.2))
	return(ev)
}

RegGUIbackgrounds["myfunction"] = 1

#	.get_points()
#	.get_pistes()
#	.get_segments()
#	.get_circles()

DisplayedPoints({regexp})
SelectedPoints({regexp})
DisplayedCircles({regexp})
SelectedCircles({regexp})
DisplayedSegments({regexp})
SelectedSegments({regexp})
DisplayedPistes({regexp})
SelectedPistes({regexp})
PointsInXY(area)	
CirclesInXY(area)
FullCirclesInXY(area)
SegmentsInXY(area)
FullSegmentsInXY(area)
ShowObjectsNames({col})
RenameO(name, newname)