sams cinfinity audio picons
[goodguy/history.git] / cinelerra-5.1 / cinelerra / patch.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "filexml.h"
23 #include "mwindow.h"
24 #include "module.h"
25 #include "modules.h"
26 #include "mwindowgui.h"
27 #include "patch.h"
28 #include "patchbay.h"
29 #include "mainsession.h"
30 #include "theme.h"
31 #include <string.h>
32
33 Patch::Patch(MWindow *mwindow, PatchBay *patchbay, int data_type) : ListItem<Patch>()
34 {
35         this->mwindow = mwindow;
36         this->patches = patchbay;
37         this->data_type = data_type;
38         record = play = automate = draw = 1;
39         title[0] = 0;
40 }
41
42 Patch::~Patch()
43 {
44         if(mwindow->gui)
45         {
46                 delete recordpatch;
47                 delete playpatch;
48                 delete autopatch;
49                 delete drawpatch;
50                 delete title_text;
51         }
52 }
53
54 void Patch::create_objects(char *text, int pixel)
55 {
56         int x, y;
57         this->pixel = pixel;
58         strcpy(title, text);
59
60         if(mwindow->gui)
61         {
62                 if(mwindow->session->tracks_vertical)
63                 {
64                         //x = patches->gui->w - pixel - mwindow->zoom_track;
65                         x = pixel + 3;
66                         y = 0;
67                 }
68                 else
69                 {
70                         x = 3;
71                         y = pixel;
72                 }
73
74                 patches->add_subwindow(recordpatch = new RecordPatchOld(mwindow, this, x, y));
75                 patches->add_subwindow(playpatch = new PlayPatchOld(mwindow, this, x, y));
76                 patches->add_subwindow(title_text = new TitlePatchOld(mwindow, this, text, x, y));
77                 //patches->add_subwindow(autotitle = new BC_Title(x + PATCH_AUTO_TITLE, y + PATCH_ROW2, "A", SMALLFONT));
78                 //patches->add_subwindow(autopatch = new AutoPatchOld(mwindow, this, x, y));
79                 //patches->add_subwindow(drawtitle = new BC_Title(x + PATCH_DRAW_TITLE, y + PATCH_ROW2, "D", SMALLFONT));
80                 patches->add_subwindow(drawpatch = new DrawPatchOld(mwindow, this, x, y));
81         }
82 }
83
84 int Patch::save(FileXML *xml)
85 {
86         xml->tag.set_title("PATCH");
87         xml->append_tag();
88
89         if(play)
90         {
91                 xml->tag.set_title("PLAY");
92                 xml->append_tag();
93                 xml->tag.set_title("/PLAY");
94                 xml->append_tag();
95         }
96
97         if(record)
98         {
99                 xml->tag.set_title("RECORD");
100                 xml->append_tag();
101                 xml->tag.set_title("/RECORD");
102                 xml->append_tag();
103         }
104
105         if(automate)
106         {
107                 xml->tag.set_title("AUTO");
108                 xml->append_tag();
109                 xml->tag.set_title("/AUTO");
110                 xml->append_tag();
111         }
112
113         if(draw)
114         {
115                 xml->tag.set_title("DRAW");
116                 xml->append_tag();
117                 xml->tag.set_title("/DRAW");
118                 xml->append_tag();
119         }
120
121         xml->tag.set_title("TITLE");
122         xml->append_tag();
123         xml->append_text(title);
124         xml->tag.set_title("/TITLE");
125         xml->append_tag();
126
127
128         xml->tag.set_title("/PATCH");
129         xml->append_tag();
130         xml->append_newline();
131         return 0;
132 }
133
134 int Patch::load(FileXML *xml)
135 {
136         int result = 0;
137         play = record = automate = draw = 0;    // defaults
138
139         do{
140                 result = xml->read_tag();
141
142                 if(!result)
143                 {
144                         if(xml->tag.title_is("/PATCH"))
145                         {
146                                 result = 1;
147                         }
148                         else
149                         if(xml->tag.title_is("PLAY"))
150                         {
151                                 play = 1;
152                         }
153                         else
154                         if(xml->tag.title_is("RECORD"))
155                         {
156                                 record = 1;
157                         }
158                         else
159                         if(xml->tag.title_is("AUTO"))
160                         {
161                                 automate = 1;
162                         }
163                         else
164                         if(xml->tag.title_is("DRAW"))
165                         {
166                                 draw = 1;
167                         }
168                         else
169                         if(xml->tag.title_is("TITLE"))
170                         {
171                                 strcpy(title, xml->read_text());
172                         }
173                 }
174         }while(!result);
175
176         if(mwindow->gui)
177         {
178                 playpatch->update(play);
179                 recordpatch->update(record);
180                 autopatch->update(automate);
181                 drawpatch->update(draw);
182                 title_text->update(title);
183         }
184         return 0;
185 }
186
187 int Patch::set_pixel(int pixel)
188 {         // must be top of track for track zoom
189         this->pixel = pixel;
190         if(mwindow->gui)
191         {
192                 if(mwindow->session->tracks_vertical)
193                 {
194                         pixel += 3;
195                         playpatch->reposition_window(pixel + PATCH_PLAY, playpatch->get_y());
196                         recordpatch->reposition_window(pixel + PATCH_REC, recordpatch->get_y());
197                         autopatch->reposition_window(pixel + PATCH_AUTO, autopatch->get_y());
198                         title_text->reposition_window(pixel, title_text->get_y());
199                         drawpatch->reposition_window(pixel + PATCH_DRAW, drawpatch->get_y());
200                 }
201                 else
202                 {
203                         playpatch->reposition_window(playpatch->get_x(), pixel + PATCH_ROW2);
204                         recordpatch->reposition_window(recordpatch->get_x(), pixel + PATCH_ROW2);
205                         autopatch->reposition_window(autopatch->get_x(), pixel + PATCH_ROW2);
206                         drawpatch->reposition_window(drawpatch->get_x(), pixel + PATCH_ROW2);
207                         title_text->reposition_window(title_text->get_x(), pixel + 3);
208                 }
209         }
210         return 0;
211 }
212
213 int Patch::set_title(char *new_title)
214 {
215         strcpy(title, new_title);
216         title_text->update(new_title);
217         return 0;
218 }
219
220 int Patch::flip_vertical()
221 {
222         if(mwindow->gui)
223         {
224                 if(mwindow->session->tracks_vertical)
225                 {
226                         playpatch->reposition_window(playpatch->get_x(), PATCH_ROW2);
227                         recordpatch->reposition_window(recordpatch->get_x(), PATCH_ROW2);
228                         autopatch->reposition_window(autopatch->get_x(), PATCH_ROW2);
229                         drawpatch->reposition_window(drawpatch->get_x(), PATCH_ROW2);
230                         title_text->reposition_window(title_text->get_x(), 3);
231                 }
232                 else
233                 {
234                         playpatch->reposition_window(PATCH_PLAY, playpatch->get_y());
235                         recordpatch->reposition_window(PATCH_REC, recordpatch->get_y());
236                         autopatch->reposition_window(PATCH_AUTO, autopatch->get_y());
237                         drawpatch->reposition_window(PATCH_DRAW, drawpatch->get_y());
238                         title_text->reposition_window(PATCH_TITLE, title_text->get_y());
239                 }
240                 set_pixel(pixel);
241         }
242         return 0;
243 }
244
245
246 int Patch::pixelmovement(int distance)
247 {
248         if(mwindow->gui)
249         {
250                 pixel -= distance;
251                 set_pixel(pixel);
252         }
253         return 0;
254 }
255
256 Module* Patch::get_module()    // return corresponding module from console
257 {
258 //      return mwindow->console->modules->module_number(patches->number_of(this));
259 }
260
261 PlayPatchOld::PlayPatchOld(MWindow *mwindow, Patch *patch, int x, int y)
262  : BC_Toggle(x + PATCH_PLAY,
263         y + PATCH_ROW2,
264         mwindow->theme->playpatch_data,
265         1,
266         "",
267         1,
268         0,
269         0)
270 {
271         this->patch = patch;
272         patches = patch->patches;
273 }
274
275
276 int PlayPatchOld::handle_event()
277 {
278 // get the total selected before this event
279         if(shift_down())
280         {
281                 int total_selected = patches->plays_selected();
282
283                 if(total_selected == 0)
284                 {
285 // nothing previously selected
286                         patches->select_all_play();
287                 }
288                 else
289                 if(total_selected == 1)
290                 {
291                         if(patch->play)
292                         {
293 // this patch was previously the only one on
294                                 patches->select_all_play();
295                         }
296                         else
297                         {
298 // another patch was previously the only one on
299                                 patches->deselect_all_play();
300                                 patch->play = 1;
301                         }
302                 }
303                 else
304                 if(total_selected > 1)
305                 {
306                         patches->deselect_all_play();
307                         patch->play = 1;
308                 }
309
310                 update(patch->play);
311         }
312         else
313         {
314                 patch->play = get_value();
315         }
316         patches->button_down = 1;
317         patches->reconfigure_trigger = 1;
318         patches->new_status = get_value();
319         return 1;
320 }
321
322 int PlayPatchOld::button_release()
323 {
324         return 0;
325 }
326
327 int PlayPatchOld::cursor_moved_over()
328 {
329         if(patches->button_down && patches->new_status != get_value())
330         {
331                 update(patches->new_status);
332                 patch->play = get_value();
333                 return 1;
334         }
335         return 0;
336 }
337
338 RecordPatchOld::RecordPatchOld(MWindow *mwindow, Patch *patch, int x, int y)
339  : BC_Toggle(x + PATCH_REC,
340         y + PATCH_ROW2,
341         mwindow->theme->recordpatch_data,
342         1,
343         "",
344         1,
345         0,
346         0)
347 {
348         this->patch = patch;
349         patches = patch->patches;
350 }
351
352 int RecordPatchOld::handle_event()
353 {
354 // get the total selected before this event
355         if(shift_down())
356         {
357                 int total_selected = patches->records_selected();
358
359                 if(total_selected == 0)
360                 {
361 // nothing previously selected
362                         patches->select_all_record();
363                 }
364                 else
365                 if(total_selected == 1)
366                 {
367                         if(patch->record)
368                         {
369 // this patch was previously the only one on
370                                 patches->select_all_record();
371                         }
372                         else
373                         {
374 // another patch was previously the only one on
375                                 patches->deselect_all_record();
376                                 patch->record = 1;
377                         }
378                 }
379                 else
380                 if(total_selected > 1)
381                 {
382                         patches->deselect_all_record();
383                         patch->record = 1;
384                 }
385
386                 update(patch->record);
387         }
388         else
389         {
390                 patch->record = get_value();
391         }
392         patches->button_down = 1;
393         patches->new_status = get_value();
394         return 1;
395 }
396
397 int RecordPatchOld::button_release()
398 {
399         //if(patches->button_down)
400         //{
401         //      patches->button_down = 0;
402 // restart the playback
403                 //patches->mwindow->start_reconfigure(1);
404                 //patches->mwindow->stop_reconfigure(1);
405         //}
406         return 0;
407 }
408
409 int RecordPatchOld::cursor_moved_over()
410 {
411         if(patches->button_down && patches->new_status != get_value())
412         {
413                 update(patches->new_status);
414                 patch->record = get_value();
415                 return 1;
416         }
417         return 0;
418 }
419
420 TitlePatchOld::TitlePatchOld(MWindow *mwindow, Patch *patch, char *text, int x, int y)
421  : BC_TextBox(x, y + PATCH_TITLE, 124, 1, text, 0)
422 {
423         this->patch = patch;
424         patches = patch->patches;
425         module = 0;
426 }
427
428 int TitlePatchOld::handle_event()
429 {
430         if(!module) module = patch->get_module();
431         module->set_title(get_text());
432         strcpy(patch->title, get_text());
433         return 1;
434 }
435
436 DrawPatchOld::DrawPatchOld(MWindow *mwindow, Patch *patch, int x, int y)
437  : BC_Toggle(x + PATCH_DRAW,
438         y + PATCH_ROW2,
439         mwindow->theme->drawpatch_data,
440         1,
441         "",
442         1,
443         0,
444         0)
445 {
446         this->patch = patch;
447         this->patches = patch->patches;
448 }
449
450 int DrawPatchOld::handle_event()
451 {
452 // get the total selected before this event
453         if(shift_down())
454         {
455                 int total_selected = patches->draws_selected();
456
457                 if(total_selected == 0)
458                 {
459 // nothing previously selected
460                         patches->select_all_draw();
461                 }
462                 else
463                 if(total_selected == 1)
464                 {
465                         if(patch->draw)
466                         {
467 // this patch was previously the only one on
468                                 patches->select_all_draw();
469                         }
470                         else
471                         {
472 // another patch was previously the only one on
473                                 patches->deselect_all_draw();
474                                 patch->draw = 1;
475                         }
476                 }
477                 else
478                 if(total_selected > 1)
479                 {
480                         patches->deselect_all_draw();
481                         patch->draw = 1;
482                 }
483
484                 update(patch->draw);
485         }
486         else
487         {
488                 patch->draw = get_value();
489         }
490         patches->button_down = 1;
491         patches->new_status = get_value();
492         return 1;
493 }
494
495 int DrawPatchOld::cursor_moved_over()
496 {
497         if(patches->button_down && patches->new_status != get_value())
498         {
499                 update(patches->new_status);
500                 patch->draw = get_value();
501         return 1;
502         }
503         return 0;
504 }