cinelerra-5.1/cinelerra/patchgui.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 "automation.h"
  23 #include "bcsignals.h"
  24 #include "cplayback.h"
  25 #include "cwindow.h"
  26 #include "edl.h"
  27 #include "edlsession.h"
  28 #include "intauto.h"
  29 #include "intautos.h"
  30 #include "language.h"
  31 #include "localsession.h"
  32 #include "mainsession.h"
  33 #include "mainundo.h"
  34 #include "mwindow.h"
  35 #include "mwindowgui.h"
  36 #include "patchbay.h"
  37 #include "patchgui.h"
  38 #include "playbackengine.h"
  39 #include "theme.h"
  40 #include "track.h"
  41 #include "trackcanvas.h"
  42 #include "tracks.h"
  43 #include "transportque.h"
  44 #include "vframe.h"
  45 #include "zwindow.h"
  46
  47
  48 PatchGUI::PatchGUI(MWindow *mwindow,
  49                 PatchBay *patchbay,
  50                 Track *track,
  51                 int x,
  52                 int y)
  53 {
  54         this->mwindow = mwindow;
  55         this->patchbay = patchbay;
  56         this->track = track;
  57         this->x = x;
  58         this->y = y;
  59         title = 0;
  60         record = 0;
  61         play = 0;
  62 //      automate = 0;
  63         gang = 0;
  64         draw = 0;
  65         mute = 0;
  66         expand = 0;
  67         nudge = 0;
  68         mix = 0;
  69         change_source = 0;
  70         track_id = track ? track->get_id() : -1;
  71         mixer = 0;
  72 }
  73
  74 PatchGUI::~PatchGUI()
  75 {
  76         delete title;
  77         delete record;
  78         delete play;
  79 //      delete automate;
  80         delete gang;
  81         delete draw;
  82         delete mute;
  83         delete expand;
  84         delete nudge;
  85         delete mix;
  86 }
  87
  88 void PatchGUI::create_objects()
  89 {
  90         update(x, y);
  91 }
  92
  93 int PatchGUI::reposition(int x, int y)
  94 {
  95         int x1 = 0;
  96         int y1 = 0;
  97
  98
  99         if( x != this->x || y != this->y ) {
 100                 this->x = x;  this->y = y;
 101
 102                 if( title )
 103                         title->reposition_window(title->get_x(), y1 + y, 0);
 104                 if( expand )
 105                         expand->reposition_window(expand->get_x(), y1 + y);
 106                 y1 += mwindow->theme->title_h;
 107
 108                 if( play ) {
 109                         play->reposition_window(play->get_x(), y1 + y);
 110                         x1 += play->get_w();
 111                         record->reposition_window(record->get_x(), y1 + y);
 112                         x1 += record->get_w();
 113 //                      automate->reposition_window(x1, y1 + y);
 114 //                      x1 += automate->get_w();
 115                         gang->reposition_window(gang->get_x(), y1 + y);
 116                         x1 += gang->get_w();
 117                         draw->reposition_window(draw->get_x(), y1 + y);
 118                         x1 += draw->get_w();
 119                         mute->reposition_window(mute->get_x(), y1 + y);
 120                         x1 += mute->get_w();
 121                 }
 122                 y1 += mwindow->theme->play_h;
 123         }
 124         else {
 125                 if( title )
 126                         y1 += mwindow->theme->title_h;
 127                 if( play )
 128                         y1 += mwindow->theme->play_h;
 129         }
 130
 131         return y1;
 132 }
 133
 134 int PatchGUI::update(int x, int y)
 135 {
 136 //TRACE("PatchGUI::update 1");
 137         reposition(x, y);
 138 //TRACE("PatchGUI::update 10");
 139
 140         int h = track->vertical_span(mwindow->theme);
 141         int y1 = 0;
 142         int x1 = 0;
 143 //printf("PatchGUI::update 10\n");
 144
 145         int y2 = y1 + mwindow->theme->title_h;
 146         if( title ) {
 147                 if( h < y2 ) {
 148                         delete title;   title = 0;
 149                         delete expand;  expand = 0;
 150                 }
 151                 else {
 152                         title->update(track->title);
 153                         expand->update(track->expand_view);
 154                 }
 155         }
 156         else if( h >= y2 ) {
 157                 VFrame **expandpatch_data = mwindow->theme->get_image_set("expandpatch_data");
 158                 int x2 = patchbay->get_w() - expandpatch_data[0]->get_w() - 5;
 159                 patchbay->add_subwindow(title = new TitlePatch(mwindow, this, x1 + x, y1 + y, x2-x1-5));
 160                 patchbay->add_subwindow(expand = new ExpandPatch(mwindow, this, x2, y1 + y));
 161         }
 162
 163         if( title )
 164                 y1 = y2;
 165
 166         y2 = y1 + mwindow->theme->play_h;
 167         if( play ) {
 168                 if( h < y2 ) {
 169                         delete play;    play = 0;
 170                         delete record;  record = 0;
 171                         delete gang;    gang = 0;
 172                         delete draw;    draw = 0;
 173                         delete mute;    mute = 0;
 174                 }
 175                 else {
 176                         play->update(track->play);
 177                         record->update(track->record);
 178                         gang->update(track->gang);
 179                         draw->update(track->draw);
 180                         mute->update(mwindow->get_int_auto(this, AUTOMATION_MUTE)->value);
 181                 }
 182         }
 183         else if( h >= y2 ) {
 184                 patchbay->add_subwindow(play = new PlayPatch(mwindow, this, x1 + x, y1 + y));
 185 //printf("PatchGUI::update %d %d\n", __LINE__, play->get_h());
 186                 x1 += play->get_w();
 187                 patchbay->add_subwindow(record = new RecordPatch(mwindow, this, x1 + x, y1 + y));
 188                 x1 += record->get_w();
 189                 patchbay->add_subwindow(gang = new GangPatch(mwindow, this, x1 + x, y1 + y));
 190                 x1 += gang->get_w();
 191                 patchbay->add_subwindow(draw = new DrawPatch(mwindow, this, x1 + x, y1 + y));
 192                 x1 += draw->get_w();
 193                 patchbay->add_subwindow(mute = new MutePatch(mwindow, this, x1 + x, y1 + y));
 194                 x1 += mute->get_w();
 195         }
 196         if( play )
 197                 y1 = y2;
 198
 199 //UNTRACE
 200         return y1;
 201 }
 202
 203
 204 void PatchGUI::toggle_behavior(int type,
 205                 int value,
 206                 BC_Toggle *toggle,
 207                 int *output)
 208 {
 209         if(toggle->shift_down()) {
 210                 int sense = type != Tracks::MUTE ? 1 : 0;
 211                 // all selected if nothing previously selected or
 212                 // if this patch was previously the only one selected
 213                 int total_type = mwindow->edl->tracks->total_of(type);
 214                 int total_selected = sense ? total_type :
 215                         mwindow->edl->tracks->total() - total_type;
 216                 int selected = !total_selected || (total_selected == 1 &&
 217                          *output == sense ) ? sense : 1-sense;
 218                 mwindow->edl->tracks->select_all(type, selected);
 219                 if( selected != sense ) *output = sense;
 220
 221                 patchbay->drag_operation = type;
 222                 patchbay->new_status = 1;
 223         }
 224         else
 225         {
 226                 *output = value;
 227 // Select + drag behavior
 228                 patchbay->drag_operation = type;
 229                 patchbay->new_status = value;
 230         }
 231
 232         switch(type)
 233         {
 234                 case Tracks::PLAY:
 235                         mwindow->gui->unlock_window();
 236                         mwindow->restart_brender();
 237                         mwindow->sync_parameters(CHANGE_EDL);
 238                         mwindow->gui->lock_window("PatchGUI::toggle_behavior 1");
 239                         break;
 240
 241                 case Tracks::MUTE:
 242                         mwindow->gui->unlock_window();
 243                         mwindow->restart_brender();
 244                         mwindow->sync_parameters(CHANGE_PARAMS);
 245                         mwindow->gui->lock_window("PatchGUI::toggle_behavior 2");
 246                         break;
 247
 248 // Update affected tracks in cwindow
 249                 case Tracks::RECORD:
 250                         mwindow->cwindow->update(0, 1, 1);
 251                         break;
 252
 253                 case Tracks::GANG:
 254                         break;
 255
 256                 case Tracks::DRAW:
 257                         mwindow->gui->update(0, NORMAL_DRAW, 0, 0, 0, 0, 0);
 258                         break;
 259
 260                 case Tracks::EXPAND:
 261                         break;
 262         }
 263
 264 // update all panes
 265         mwindow->gui->update_patchbay();
 266 }
 267
 268
 269 char* PatchGUI::calculate_nudge_text(int *changed)
 270 {
 271         if(changed) *changed = 0;
 272         if(track->edl->session->nudge_format)
 273         {
 274                 sprintf(string_return, "%.4f", track->from_units(track->nudge));
 275                 if(changed && nudge && atof(nudge->get_text()) - atof(string_return) != 0)
 276                         *changed = 1;
 277         }
 278         else
 279         {
 280                 sprintf(string_return, "%jd", track->nudge);
 281                 if(changed && nudge && atoi(nudge->get_text()) - atoi(string_return) != 0)
 282                         *changed = 1;
 283         }
 284         return string_return;
 285 }
 286
 287
 288 int64_t PatchGUI::calculate_nudge(const char *string)
 289 {
 290         if(mwindow->edl->session->nudge_format)
 291         {
 292                 float result;
 293                 sscanf(string, "%f", &result);
 294                 return track->to_units(result, 0);
 295         }
 296         else
 297         {
 298                 int64_t temp;
 299                 sscanf(string, "%jd", &temp);
 300                 return temp;
 301         }
 302 }
 303
 304
 305 PlayPatch::PlayPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 306  : BC_Toggle(x,
 307                 y,
 308                 mwindow->theme->get_image_set("playpatch_data"),
 309                 patch->track->play,
 310                 "",
 311                 0,
 312                 0,
 313                 0)
 314 {
 315         this->mwindow = mwindow;
 316         this->patch = patch;
 317         set_tooltip(_("Play track"));
 318         set_select_drag(1);
 319 }
 320
 321 int PlayPatch::button_press_event()
 322 {
 323         if(is_event_win() && get_buttonpress() == 1)
 324         {
 325                 mwindow->undo->update_undo_before();
 326                 set_status(BC_Toggle::TOGGLE_DOWN);
 327                 update(!get_value());
 328                 patch->toggle_behavior(Tracks::PLAY,
 329                         get_value(),
 330                         this,
 331                         &patch->track->play);
 332                 return 1;
 333         }
 334         return 0;
 335 }
 336
 337 int PlayPatch::button_release_event()
 338 {
 339         int result = BC_Toggle::button_release_event();
 340         if(patch->patchbay->drag_operation == Tracks::PLAY)
 341         {
 342                 mwindow->undo->update_undo_after(_("play patch"), LOAD_PATCHES);
 343                 patch->patchbay->drag_operation = Tracks::NONE;
 344         }
 345         return result;
 346 }
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358 RecordPatch::RecordPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 359  : BC_Toggle(x,
 360                 y,
 361                 mwindow->theme->get_image_set("recordpatch_data"),
 362                 patch->track->record,
 363                 "",
 364                 0,
 365                 0,
 366                 0)
 367 {
 368         this->mwindow = mwindow;
 369         this->patch = patch;
 370         set_tooltip(_("Arm track"));
 371         set_select_drag(1);
 372 }
 373
 374 int RecordPatch::button_press_event()
 375 {
 376         if(is_event_win() && get_buttonpress() == 1)
 377         {
 378                 mwindow->undo->update_undo_before();
 379                 set_status(BC_Toggle::TOGGLE_DOWN);
 380                 update(!get_value());
 381                 patch->toggle_behavior(Tracks::RECORD,
 382                         get_value(),
 383                         this,
 384                         &patch->track->record);
 385                 patch->title->set_back_color(patch->track->record ?
 386                         get_resources()->text_background :
 387                         get_resources()->text_background_disarmed);
 388                 patch->title->set_text_row(0);
 389                 return 1;
 390         }
 391         return 0;
 392 }
 393
 394 int RecordPatch::button_release_event()
 395 {
 396         int result = BC_Toggle::button_release_event();
 397         if(patch->patchbay->drag_operation == Tracks::RECORD)
 398         {
 399                 mwindow->undo->update_undo_after(_("record patch"), LOAD_PATCHES);
 400                 patch->patchbay->drag_operation = Tracks::NONE;
 401         }
 402         return result;
 403 }
 404
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415 GangPatch::GangPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 416  : BC_Toggle(x, y,
 417                 mwindow->theme->get_image_set("gangpatch_data"),
 418                 patch->track->gang,
 419                 "",
 420                 0,
 421                 0,
 422                 0)
 423 {
 424         this->mwindow = mwindow;
 425         this->patch = patch;
 426         set_tooltip(_("Gang faders"));
 427         set_select_drag(1);
 428 }
 429
 430 int GangPatch::button_press_event()
 431 {
 432         if(is_event_win() && get_buttonpress() == 1)
 433         {
 434                 mwindow->undo->update_undo_before();
 435                 set_status(BC_Toggle::TOGGLE_DOWN);
 436                 update(!get_value());
 437                 patch->toggle_behavior(Tracks::GANG,
 438                         get_value(),
 439                         this,
 440                         &patch->track->gang);
 441                 return 1;
 442         }
 443         return 0;
 444 }
 445
 446 int GangPatch::button_release_event()
 447 {
 448         int result = BC_Toggle::button_release_event();
 449         if(patch->patchbay->drag_operation == Tracks::GANG)
 450         {
 451                 mwindow->undo->update_undo_after(_("gang patch"), LOAD_PATCHES);
 452                 patch->patchbay->drag_operation = Tracks::NONE;
 453         }
 454         return result;
 455 }
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467 DrawPatch::DrawPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 468  : BC_Toggle(x, y,
 469                 mwindow->theme->get_image_set("drawpatch_data"),
 470                 patch->track->draw,
 471                 "",
 472                 0,
 473                 0,
 474                 0)
 475 {
 476         this->mwindow = mwindow;
 477         this->patch = patch;
 478         set_tooltip(_("Draw media"));
 479         set_select_drag(1);
 480 }
 481
 482 int DrawPatch::button_press_event()
 483 {
 484         if(is_event_win() && get_buttonpress() == 1)
 485         {
 486                 mwindow->undo->update_undo_before();
 487                 set_status(BC_Toggle::TOGGLE_DOWN);
 488                 update(!get_value());
 489                 patch->toggle_behavior(Tracks::DRAW,
 490                         get_value(),
 491                         this,
 492                         &patch->track->draw);
 493                 return 1;
 494         }
 495         return 0;
 496 }
 497
 498 int DrawPatch::button_release_event()
 499 {
 500         int result = BC_Toggle::button_release_event();
 501         if(patch->patchbay->drag_operation == Tracks::DRAW)
 502         {
 503                 mwindow->undo->update_undo_after(_("draw patch"), LOAD_PATCHES);
 504                 patch->patchbay->drag_operation = Tracks::NONE;
 505         }
 506         return result;
 507 }
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518 MutePatch::MutePatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 519  : BC_Toggle(x, y,
 520                 mwindow->theme->get_image_set("mutepatch_data"),
 521                 mwindow->get_int_auto(patch, AUTOMATION_MUTE)->value,
 522                 "",
 523                 0,
 524                 0,
 525                 0)
 526 {
 527         this->mwindow = mwindow;
 528         this->patch = patch;
 529         set_tooltip(_("Don't send to output"));
 530         set_select_drag(1);
 531 }
 532
 533 int MutePatch::button_press_event()
 534 {
 535         if(is_event_win() && get_buttonpress() == 1)
 536         {
 537                 mwindow->undo->update_undo_before();
 538                 set_status(BC_Toggle::TOGGLE_DOWN);
 539                 update(!get_value());
 540                 IntAuto *current;
 541                 double position = mwindow->edl->local_session->get_selectionstart(1);
 542                 Autos *mute_autos = patch->track->automation->autos[AUTOMATION_MUTE];
 543
 544
 545                 current = (IntAuto*)mute_autos->get_auto_for_editing(position);
 546                 current->value = get_value();
 547
 548                 patch->toggle_behavior(Tracks::MUTE,
 549                         get_value(),
 550                         this,
 551                         &current->value);
 552
 553
 554
 555                 if(mwindow->edl->session->auto_conf->autos[AUTOMATION_MUTE])
 556                 {
 557                         mwindow->gui->draw_overlays(1);
 558                 }
 559                 return 1;
 560         }
 561         return 0;
 562 }
 563
 564 int MutePatch::button_release_event()
 565 {
 566         int result = BC_Toggle::button_release_event();
 567         if(patch->patchbay->drag_operation == Tracks::MUTE)
 568         {
 569                 mwindow->undo->update_undo_after(_("mute patch"), LOAD_PATCHES);
 570                 patch->patchbay->drag_operation = Tracks::NONE;
 571         }
 572         return result;
 573 }
 574
 575
 576
 577 ExpandPatch::ExpandPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 578  : BC_Toggle(x,
 579                 y,
 580                 mwindow->theme->get_image_set("expandpatch_data"),
 581                 patch->track->expand_view,
 582                 "",
 583                 0,
 584                 0,
 585                 0)
 586 {
 587         this->mwindow = mwindow;
 588         this->patch = patch;
 589         set_select_drag(1);
 590 }
 591
 592 int ExpandPatch::button_press_event()
 593 {
 594         if(is_event_win() && get_buttonpress() == 1)
 595         {
 596                 mwindow->undo->update_undo_before();
 597                 set_status(BC_Toggle::TOGGLE_DOWN);
 598                 update(!get_value());
 599                 patch->toggle_behavior(Tracks::EXPAND,
 600                         get_value(),
 601                         this,
 602                         &patch->track->expand_view);
 603                 mwindow->edl->tracks->update_y_pixels(mwindow->theme);
 604                 mwindow->gui->draw_trackmovement();
 605                 return 1;
 606         }
 607         return 0;
 608 }
 609
 610 int ExpandPatch::button_release_event()
 611 {
 612         int result = BC_Toggle::button_release_event();
 613         if(patch->patchbay->drag_operation == Tracks::EXPAND)
 614         {
 615                 mwindow->undo->update_undo_after(_("expand patch"), LOAD_PATCHES);
 616                 patch->patchbay->drag_operation = Tracks::NONE;
 617         }
 618         return result;
 619 }
 620
 621
 622 TitlePatch::TitlePatch(MWindow *mwindow, PatchGUI *patch, int x, int y, int w)
 623  : BC_TextBox(x, y, w, 1, patch->track->title, 1, MEDIUMFONT, 1)
 624 {
 625         this->mwindow = mwindow;
 626         this->patch = patch;
 627         set_back_color(patch->track->record ?
 628                         get_resources()->text_background :
 629                         get_resources()->text_background_disarmed);
 630 }
 631
 632 void TitlePatch::update(const char *text)
 633 {
 634         set_back_color(patch->track->record ?
 635                         get_resources()->text_background :
 636                         get_resources()->text_background_disarmed);
 637         BC_TextBox::update(text);
 638 }
 639
 640 int TitlePatch::handle_event()
 641 {
 642         mwindow->undo->update_undo_before(_("track title"), this);
 643         strcpy(patch->track->title, get_text());
 644         mwindow->update_plugin_titles();
 645         mwindow->gui->draw_overlays(1);
 646         mwindow->undo->update_undo_after(_("track title"), LOAD_PATCHES);
 647         return 1;
 648 }
 649
 650
 651 NudgePatch::NudgePatch(MWindow *mwindow,
 652         PatchGUI *patch,
 653         int x,
 654         int y,
 655         int w)
 656  : BC_TextBox(x,
 657         y,
 658         w,
 659         1,
 660         patch->calculate_nudge_text(0))
 661 {
 662         this->mwindow = mwindow;
 663         this->patch = patch;
 664         set_tooltip(_("Nudge"));
 665 }
 666
 667 int NudgePatch::handle_event()
 668 {
 669         set_value(patch->calculate_nudge(get_text()));
 670         return 1;
 671 }
 672
 673 void NudgePatch::set_value(int64_t value)
 674 {
 675         mwindow->undo->update_undo_before(_("nudge."), this);
 676         patch->track->nudge = value;
 677
 678         if(patch->track->gang && patch->track->record)
 679                 patch->patchbay->synchronize_nudge(patch->track->nudge, patch->track);
 680
 681         mwindow->undo->update_undo_after(_("nudge."), LOAD_PATCHES);
 682
 683         mwindow->gui->unlock_window();
 684         if(patch->track->data_type == TRACK_VIDEO)
 685                 mwindow->restart_brender();
 686         mwindow->sync_parameters(CHANGE_PARAMS);
 687         mwindow->gui->lock_window("NudgePatch::handle_event 2");
 688
 689         mwindow->session->changes_made = 1;
 690 }
 691
 692
 693 int NudgePatch::button_press_event()
 694 {
 695         int result = 0;
 696
 697         if(is_event_win() && cursor_inside())
 698         {
 699                 if(get_buttonpress() == 4)
 700                 {
 701                         int value = patch->calculate_nudge(get_text());
 702                         value += calculate_increment();
 703                         set_value(value);
 704                         update();
 705                         result = 1;
 706                 }
 707                 else
 708                 if(get_buttonpress() == 5)
 709                 {
 710                         int value = patch->calculate_nudge(get_text());
 711                         value -= calculate_increment();
 712                         set_value(value);
 713                         update();
 714                         result = 1;
 715                 }
 716                 else
 717                 if(get_buttonpress() == 3)
 718                 {
 719                         patch->patchbay->nudge_popup->activate_menu(patch);
 720                         result = 1;
 721                 }
 722         }
 723
 724         if(!result)
 725                 return BC_TextBox::button_press_event();
 726         else
 727                 return result;
 728 }
 729
 730 int64_t NudgePatch::calculate_increment()
 731 {
 732         if(patch->track->data_type == TRACK_AUDIO)
 733         {
 734                 return (int64_t)ceil(patch->track->edl->session->sample_rate / 10.0);
 735         }
 736         else
 737         {
 738                 return (int64_t)ceil(1.0 / patch->track->edl->session->frame_rate);
 739         }
 740 }
 741
 742 void NudgePatch::update()
 743 {
 744         int changed;
 745         char *string = patch->calculate_nudge_text(&changed);
 746         if(changed)
 747                 BC_TextBox::update(string);
 748 }
 749
 750
 751 MixPatch::MixPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 752  : BC_Toggle(x, y, mwindow->theme->get_image_set("mixpatch_data"),
 753         patch->mixer, "", 0, 0, 0)
 754 {
 755         this->mwindow = mwindow;
 756         this->patch = patch;
 757 }
 758
 759 MixPatch::~MixPatch()
 760 {
 761 }
 762
 763 int MixPatch::handle_event()
 764 {
 765         int v = patch->track ? get_value() : 0;
 766         if( patch->mixer != v ) {
 767                 if( patch->track )
 768                         mwindow->gui->update_mixers(patch->track, v);
 769                 else
 770                         update(v);
 771                 mwindow->update_mixer_tracks();
 772         }
 773         return 1;
 774 }
 775
 776 void MixPatch::update(int v)
 777 {
 778         patch->mixer = v;
 779         BC_Toggle::update(v);
 780 }
 781