aboutsummaryrefslogtreecommitdiff
path: root/src/param.h
blob: 46daca6c818443fb66c1824489207450de1c8667 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
#include "tof.h"
#include <stdio.h>
#include <fcntl.h>



typedef void (*t_paramGetMethod)(void*,t_symbol**,int*,t_atom**);
typedef void (*t_paramSaveMethod)(void*,t_binbuf*,int);
typedef void (*t_paramGUIMethod)(void*,int*,t_atom**,t_symbol**,t_symbol**);
//typedef void (*t_paramGUIUpdateMethod)(void*);

static char param_buf_temp_a[MAXPDSTRING];
static  char param_buf_temp_b[MAXPDSTRING];
static  char* param_separator = "/";


//char PARAMECHO = 0;

//struct _paramroot;

typedef struct _param {
   t_symbol*			root;
   t_symbol* 			path; //Path(name) of the param
   void*				x;
   struct _param* 		next; //Next param
   struct _param* 		previous; //Previous param
   t_paramGetMethod		get; //Function to get current value
   t_paramSaveMethod	save; //Function to save
   t_paramGUIMethod		GUI;
  // t_paramGUIUpdateMethod GUIUpdate;
   //t_symbol*			send;
   //t_symbol*			receive;
} t_param;

typedef struct _paramroot {
	t_symbol*			root;
	t_param* 			params; //param list
	struct _paramroot* 	next; //Next paramroot
    struct _paramroot* 	previous; //Previous paramroot
} t_paramroot;

static t_paramroot* PARAMROOTS;


static t_paramroot* param_get_root(t_symbol* root) {
	
	if (PARAMROOTS == NULL) {
		#ifdef PARAMDEBUG
		post("Could not get...not even one root created");
		#endif
		return NULL;
	 }
	
	
	// Pointer to the start of paramroots
	t_paramroot* branch = PARAMROOTS;
		
		while( branch ) {
			if ( branch->root == root) {
				#ifdef PARAMDEBUG
				  post("Found root:%s",root->s_name);
				#endif
				
				return branch;
			}
			branch = branch->next; 
		}
	#ifdef PARAMDEBUG
		post("Could not find root");
	#endif
	return branch;
	
}


static t_paramroot* param_root_attach(t_symbol* root){
		
		// Pointer to the start of paramroots
		t_paramroot* branch = PARAMROOTS;
		
		while( branch ) {
			if ( branch->root == root) {
				#ifdef PARAMDEBUG
				  post("Found root:%s",root->s_name);
				#endif
				
				return branch;
			}
			if ( branch->next == NULL ) break;
			branch = branch->next; 
		}
		
		// we did not find a paramroot linked to this root canvas
		// so we create it
		#ifdef PARAMDEBUG
			 post("Creating root:%s",root->s_name);
		#endif
		
		// Create and add paramroot to the end
		t_paramroot* newbranch = getbytes(sizeof(*newbranch));
		newbranch->root = root;
		newbranch->next = NULL;
		newbranch->params = NULL;
		
		if (branch) {
			#ifdef PARAMDEBUG
			  post("Appending it to previous roots");
			#endif
			newbranch->previous = branch;
			branch->next = newbranch;
		} else {
			#ifdef PARAMDEBUG
				post("Creating first root");
			#endif
			newbranch->previous = NULL;
			PARAMROOTS = newbranch;
		}
		
		
		return newbranch;
	
}



static t_param* get_param_list(t_symbol* root) {
	
	
	t_paramroot* branch = param_get_root(root);
	if (branch) {
		
	#ifdef PARAMDEBUG
		post("Getting params from %s",branch->root->s_name);
		if (!branch->params) post("Root contains no params");
	#endif
		return branch->params;
	} 
	
	return NULL;
    
}


static t_symbol* param_get_name ( int ac, t_atom* av  ) {
	
	if (ac  && IS_A_SYMBOL(av, 0)) {
		char* name =  atom_getsymbol(av)->s_name;
		if (*name == *param_separator ) {
			int length = strlen(name);
			if (name[length-1] != '_' || name[length-1] != '/') return atom_getsymbol(av);
		 }
	} 
	post("Param names must start with a \"/\" and can not end with either a \"_\" or a \"/\"!");
	return NULL;
}


static t_symbol* param_get_path( t_canvas* i_canvas,  t_symbol* name) {
	
	char* sbuf_name = param_buf_temp_a;
	char* sbuf_temp = param_buf_temp_b;
	sbuf_name[0] = '\0';
	sbuf_temp[0] = '\0';
	//char* separator = "/";
	
	
	t_symbol* id_s = gensym("/id"); // symbol that points to "/id" symbol
	   
    // arguments of the current canvas being analyzed
    int i_ac;
    t_atom * i_av;
	
	// temp pointer to the current id being added to the path
	t_symbol* id_temp;
	
	/* FIND ID AND BASEPATH  */
   while( i_canvas->gl_owner) {
	   // Ignore all supatches
	   if ( tof_canvas_is_not_subpatch(i_canvas) ) {
		tof_get_canvas_arguments(i_canvas,&i_ac, &i_av);
		id_temp=NULL;
		//id_temp= canvas_realizedollar(i_canvas, gensym("$0"));
		int ac_a = 0;
		t_atom* av_a = NULL;
		int iter = 0;
		//found_id_flag = 0;
		
		while( tof_next_tagged_argument(*param_separator,i_ac,i_av,&ac_a,&av_a,&iter) ) {
			
			if ( IS_A_SYMBOL(av_a,0)
			   && (id_s == av_a->a_w.w_symbol) 
			   && (ac_a > 1) ) {  
	           	id_temp = atom_getsymbol(av_a+1);
	           	//id_canvas = i_canvas;
				//found_id_flag = 1;
	           	break;
			}
		}
		
		if (id_temp == NULL) {
			
			id_temp = tof_remove_extension(tof_get_canvas_name(i_canvas));	    
		}    
        // if ever an /id is missing, this param is not saveable
        //if (found_id_flag == 0)  saveable = 0;
        
	   // Prepend newly found ID
		   strcpy(sbuf_temp,sbuf_name);
		   strcpy(sbuf_name, param_separator);
		   strcat(sbuf_name, id_temp->s_name);
		   strcat(sbuf_name,sbuf_temp);  
		}
        i_canvas = i_canvas->gl_owner;
    } 
  
  // If no name, the path will always end with a /
  
  if ( name != NULL) {
	  strcat(sbuf_name,name->s_name);
  } else {
      //if (strlen(sbuf_name)==0) 
      strcat(sbuf_name,param_separator); 
  }
  
  return gensym(sbuf_name);
	
}



// root, path, ac, av, ac_g, av_g
// From there, deduct id, path_, etc...

//static struct param* register_param( t_canvas* canvas, int o_ac, t_atom* o_av) {

static t_param* param_register(void* x,t_symbol* root, t_symbol* path,\
 t_paramGetMethod get, t_paramSaveMethod save, t_paramGUIMethod GUI) {
	
			
     //char *separator = "/";
		
		/* GET POINTER TO PARAMLIST FOR THAT ROOT  */
		t_paramroot* branch = param_root_attach(root);
        t_param* last = branch->params;
		
		// Search for param with same path
		while( last ) {
			if ( last->path == path) {
				
				  pd_error(x,"Found param with same name: %s", path->s_name);
				
				return NULL;
			}
			if ( last->next == NULL ) break;
			last = last->next; 
		}
		
		// Create and add param to the end
		
		t_param* p = getbytes(sizeof(*p));
		p->root = root;
		//p->alloc = 0;
		p->path = path;
		
		// Create receive and send symbols: $0/path
		//strcpy(param_buf_temp_a,p->root->s_name);  
		//strcat(param_buf_temp_a,separator);
		//strcat(param_buf_temp_a,p->path->s_name);
		//p->receive = gensym(param_buf_temp_a);
		//strcat(param_buf_temp_a,"_");  
		//p->send = gensym(param_buf_temp_a);
		
		p->next = NULL;
		p->x = x;
		p->get = get;
		p->save = save;
		p->GUI = GUI;
		//p->GUIUpdate = GUIUpdate;
		//p->id = id;
		//set_param( p, ac, av);
		//p->ac_g = ac_g;
		//p->av_g = getbytes(ac_g*sizeof(*(p->av_g)));
		//tof_copy_atoms(av_g,p->av_g,ac_g);
		if (last) {
			#ifdef PARAMDEBUG
			  post("Appending param");
			#endif
			p->previous = last;
			last->next = p;
		} else {
			#ifdef PARAMDEBUG
				post("Creating first param");
			#endif
			p->previous = NULL;
			branch->params = p;
		}
		
		
		return p;
   
}

static void param_unregister(t_param* p) {
	
	//post("unregistering %s", p->path->s_name);
	t_paramroot* branch = param_get_root(p->root);
	t_param* paramlist = branch->params;
	
	if ( paramlist) {

		
			if (p->previous) {
				p->previous->next = p->next;
				if (p->next) p->next->previous = p->previous;
				
			} else {
				paramlist = p->next;
				if ( p->next != NULL) p->next->previous = NULL;
			}
			
			freebytes(p, sizeof *p);
		
		// Update the params for that root
		if (paramlist == NULL) {
			if (branch->previous) {
				branch->previous->next = branch->next;
					if (branch->next) branch->next->previous = branch->previous;
			} else {
				PARAMROOTS = branch->next;
				if ( branch->next != NULL) branch->next->previous = NULL;
			}
			#ifdef PARAMDEBUG
			  post("Removing root:%s",branch->root->s_name);
			#endif
			freebytes(branch, sizeof *branch);
		} else {
			branch->params = paramlist;
		}
		
	} else {
		post("Euh... no params found!");
	}
	
	
}