src/wx/screens_panel.cc

   1 /*
   2     Copyright (C) 2015-2022 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of DCP-o-matic.
   5
   6     DCP-o-matic 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     DCP-o-matic 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 DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21
  22 #include "cinema_dialog.h"
  23 #include "dcpomatic_button.h"
  24 #include "screen_dialog.h"
  25 #include "screens_panel.h"
  26 #include "wx_util.h"
  27 #include "lib/cinema.h"
  28 #include "lib/config.h"
  29 #include "lib/screen.h"
  30 #include "lib/timer.h"
  31 #include <unicode/putil.h>
  32 #include <unicode/ucol.h>
  33 #include <unicode/uiter.h>
  34 #include <unicode/utypes.h>
  35 #include <unicode/ustring.h>
  36
  37
  38 using std::cout;
  39 using std::make_pair;
  40 using std::make_shared;
  41 using std::map;
  42 using std::pair;
  43 using std::shared_ptr;
  44 using std::string;
  45 using std::vector;
  46 using boost::optional;
  47 using namespace dcpomatic;
  48
  49
  50 ScreensPanel::ScreensPanel (wxWindow* parent)
  51         : wxPanel (parent, wxID_ANY)
  52 {
  53         auto sizer = new wxBoxSizer (wxVERTICAL);
  54
  55         _search = new wxSearchCtrl (this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(200, search_ctrl_height()));
  56 #ifndef __WXGTK3__
  57         /* The cancel button seems to be strangely broken in GTK3; clicking on it twice sometimes works */
  58         _search->ShowCancelButton (true);
  59 #endif
  60         sizer->Add (_search, 0, wxBOTTOM, DCPOMATIC_SIZER_GAP);
  61
  62         auto targets = new wxBoxSizer (wxHORIZONTAL);
  63         _targets = new wxTreeListCtrl (this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTL_MULTIPLE | wxTL_3STATE | wxTL_NO_HEADER);
  64         _targets->AppendColumn (wxT("foo"));
  65
  66         targets->Add (_targets, 1, wxEXPAND | wxRIGHT, DCPOMATIC_SIZER_GAP);
  67
  68         add_cinemas ();
  69
  70         auto target_buttons = new wxBoxSizer (wxVERTICAL);
  71
  72         _add_cinema = new Button (this, _("Add Cinema..."));
  73         target_buttons->Add (_add_cinema, 1, wxEXPAND | wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
  74         _edit_cinema = new Button (this, _("Edit Cinema..."));
  75         target_buttons->Add (_edit_cinema, 1, wxEXPAND | wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
  76         _remove_cinema = new Button (this, _("Remove Cinema"));
  77         target_buttons->Add (_remove_cinema, 1, wxEXPAND | wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
  78         _add_screen = new Button (this, _("Add Screen..."));
  79         target_buttons->Add (_add_screen, 1, wxEXPAND | wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
  80         _edit_screen = new Button (this, _("Edit Screen..."));
  81         target_buttons->Add (_edit_screen, 1, wxEXPAND | wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
  82         _remove_screen = new Button (this, _("Remove Screen"));
  83         target_buttons->Add (_remove_screen, 1, wxEXPAND | wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
  84
  85         targets->Add (target_buttons, 0, 0);
  86
  87         sizer->Add (targets, 1, wxEXPAND);
  88
  89         _search->Bind        (wxEVT_TEXT, boost::bind (&ScreensPanel::search_changed, this));
  90         _targets->Bind       (wxEVT_TREELIST_SELECTION_CHANGED, &ScreensPanel::selection_changed_shim, this);
  91         _targets->Bind       (wxEVT_TREELIST_ITEM_CHECKED, &ScreensPanel::checkbox_changed, this);
  92
  93         _add_cinema->Bind    (wxEVT_BUTTON, boost::bind (&ScreensPanel::add_cinema_clicked, this));
  94         _edit_cinema->Bind   (wxEVT_BUTTON, boost::bind (&ScreensPanel::edit_cinema_clicked, this));
  95         _remove_cinema->Bind (wxEVT_BUTTON, boost::bind (&ScreensPanel::remove_cinema_clicked, this));
  96
  97         _add_screen->Bind    (wxEVT_BUTTON, boost::bind (&ScreensPanel::add_screen_clicked, this));
  98         _edit_screen->Bind   (wxEVT_BUTTON, boost::bind (&ScreensPanel::edit_screen_clicked, this));
  99         _remove_screen->Bind (wxEVT_BUTTON, boost::bind (&ScreensPanel::remove_screen_clicked, this));
 100
 101         SetSizer (sizer);
 102
 103         UErrorCode status = U_ZERO_ERROR;
 104         _collator = ucol_open(nullptr, &status);
 105         if (_collator) {
 106                 ucol_setAttribute(_collator, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
 107                 ucol_setAttribute(_collator, UCOL_STRENGTH, UCOL_PRIMARY, &status);
 108                 ucol_setAttribute(_collator, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
 109         }
 110 }
 111
 112
 113 ScreensPanel::~ScreensPanel ()
 114 {
 115         _targets->Unbind (wxEVT_TREELIST_SELECTION_CHANGED, &ScreensPanel::selection_changed_shim, this);
 116         _targets->Unbind (wxEVT_TREELIST_ITEM_CHECKED, &ScreensPanel::checkbox_changed, this);
 117
 118         if (_collator) {
 119                 ucol_close (_collator);
 120         }
 121 }
 122
 123
 124 void
 125 ScreensPanel::setup_sensitivity ()
 126 {
 127         bool const sc = _selected_cinemas.size() == 1;
 128         bool const ss = _selected_screens.size() == 1;
 129
 130         _edit_cinema->Enable (sc || ss);
 131         _remove_cinema->Enable (_selected_cinemas.size() >= 1);
 132
 133         _add_screen->Enable (sc || ss);
 134         _edit_screen->Enable (ss);
 135         _remove_screen->Enable (_selected_screens.size() >= 1);
 136 }
 137
 138
 139 optional<wxTreeListItem>
 140 ScreensPanel::add_cinema (shared_ptr<Cinema> cinema, wxTreeListItem previous)
 141 {
 142         auto search = wx_to_std (_search->GetValue ());
 143         transform (search.begin(), search.end(), search.begin(), ::tolower);
 144
 145         if (!search.empty ()) {
 146                 auto name = cinema->name;
 147                 transform (name.begin(), name.end(), name.begin(), ::tolower);
 148                 if (name.find (search) == string::npos) {
 149                         return {};
 150                 }
 151         }
 152
 153         auto id = _targets->InsertItem(_targets->GetRootItem(), previous, std_to_wx(cinema->name));
 154
 155         _cinemas.push_back(make_pair(id, cinema));
 156         _item_to_cinema[id] = cinema;
 157         _cinema_to_item[cinema] = id;
 158
 159         for (auto screen: cinema->screens()) {
 160                 add_screen (cinema, screen);
 161         }
 162
 163         return id;
 164 }
 165
 166
 167 optional<wxTreeListItem>
 168 ScreensPanel::add_screen (shared_ptr<Cinema> cinema, shared_ptr<Screen> screen)
 169 {
 170         auto item = cinema_to_item(cinema);
 171         if (!item) {
 172                 return {};
 173         }
 174
 175         auto id = _targets->AppendItem(*item, std_to_wx(screen->name));
 176
 177         _screens.push_back(make_pair(id, screen));
 178         _item_to_screen[id] = screen;
 179         _screen_to_item[screen] = id;
 180
 181         return item;
 182 }
 183
 184
 185 void
 186 ScreensPanel::add_cinema_clicked ()
 187 {
 188         auto d = new CinemaDialog (GetParent(), _("Add Cinema"));
 189         if (d->ShowModal () == wxID_OK) {
 190                 auto cinema = make_shared<Cinema>(d->name(), d->emails(), d->notes(), d->utc_offset_hour(), d->utc_offset_minute());
 191
 192                 auto cinemas = Config::instance()->cinemas();
 193                 cinemas.sort(
 194                         [this](shared_ptr<Cinema> a, shared_ptr<Cinema> b) { return compare(a->name, b->name) < 0; }
 195                         );
 196
 197                 optional<wxTreeListItem> item;
 198                 for (auto existing_cinema: cinemas) {
 199                         if (!item && compare(d->name(), existing_cinema->name) < 0) {
 200                                 if (auto existing_item = cinema_to_item(existing_cinema)) {
 201                                         item = add_cinema (cinema, *existing_item);
 202                                 }
 203                         }
 204                 }
 205
 206                 if (!item) {
 207                         item = add_cinema (cinema, wxTLI_LAST);
 208                 }
 209
 210                 if (item) {
 211                         _targets->UnselectAll ();
 212                         _targets->Select (*item);
 213                 }
 214
 215                 Config::instance()->add_cinema (cinema);
 216         }
 217
 218         d->Destroy ();
 219 }
 220
 221
 222 shared_ptr<Cinema>
 223 ScreensPanel::cinema_for_operation () const
 224 {
 225         if (_selected_cinemas.size() == 1) {
 226                 return _selected_cinemas[0];
 227         } else if (_selected_screens.size() == 1) {
 228                 return _selected_screens[0]->cinema;
 229         }
 230
 231         return {};
 232 }
 233
 234
 235 void
 236 ScreensPanel::edit_cinema_clicked ()
 237 {
 238         auto cinema = cinema_for_operation ();
 239         if (!cinema) {
 240                 return;
 241         }
 242
 243         auto d = new CinemaDialog (
 244                 GetParent(), _("Edit cinema"), cinema->name, cinema->emails, cinema->notes, cinema->utc_offset_hour(), cinema->utc_offset_minute()
 245                 );
 246
 247         if (d->ShowModal() == wxID_OK) {
 248                 cinema->name = d->name();
 249                 cinema->emails = d->emails();
 250                 cinema->notes = d->notes();
 251                 cinema->set_utc_offset_hour(d->utc_offset_hour());
 252                 cinema->set_utc_offset_minute(d->utc_offset_minute());
 253                 auto item = cinema_to_item(cinema);
 254                 DCPOMATIC_ASSERT(item);
 255                 _targets->SetItemText (*item, std_to_wx(d->name()));
 256                 Config::instance()->changed (Config::CINEMAS);
 257         }
 258
 259         d->Destroy ();
 260 }
 261
 262
 263 void
 264 ScreensPanel::remove_cinema_clicked ()
 265 {
 266         if (_selected_cinemas.size() == 1) {
 267                 if (!confirm_dialog(this, wxString::Format(_("Are you sure you want to remove the cinema '%s'?"), std_to_wx(_selected_cinemas[0]->name)))) {
 268                         return;
 269                 }
 270         } else {
 271                 if (!confirm_dialog(this, wxString::Format(_("Are you sure you want to remove %d cinemas?"), int(_selected_cinemas.size())))) {
 272                         return;
 273                 }
 274         }
 275
 276         for (auto const& cinema: _selected_cinemas) {
 277                 Config::instance()->remove_cinema(cinema);
 278                 auto item = cinema_to_item(cinema);
 279                 DCPOMATIC_ASSERT(item);
 280                 _targets->DeleteItem(*item);
 281         }
 282
 283         selection_changed ();
 284 }
 285
 286
 287 void
 288 ScreensPanel::add_screen_clicked ()
 289 {
 290         auto cinema = cinema_for_operation ();
 291         if (!cinema) {
 292                 return;
 293         }
 294
 295         auto d = new ScreenDialog (GetParent(), _("Add Screen"));
 296         if (d->ShowModal () != wxID_OK) {
 297                 d->Destroy ();
 298                 return;
 299         }
 300
 301         for (auto screen: cinema->screens()) {
 302                 if (screen->name == d->name()) {
 303                         error_dialog (
 304                                 GetParent(),
 305                                 wxString::Format (
 306                                         _("You cannot add a screen called '%s' as the cinema already has a screen with this name."),
 307                                         std_to_wx(d->name()).data()
 308                                         )
 309                                 );
 310                         return;
 311                 }
 312         }
 313
 314         auto screen = std::make_shared<Screen>(d->name(), d->notes(), d->recipient(), d->recipient_file(), d->trusted_devices());
 315         cinema->add_screen (screen);
 316         auto id = add_screen (cinema, screen);
 317         if (id) {
 318                 _targets->Expand (id.get ());
 319         }
 320
 321         Config::instance()->changed (Config::CINEMAS);
 322
 323         d->Destroy ();
 324 }
 325
 326
 327 void
 328 ScreensPanel::edit_screen_clicked ()
 329 {
 330         if (_selected_screens.size() != 1) {
 331                 return;
 332         }
 333
 334         auto edit_screen = _selected_screens[0];
 335
 336         auto d = new ScreenDialog (
 337                 GetParent(), _("Edit screen"),
 338                 edit_screen->name,
 339                 edit_screen->notes,
 340                 edit_screen->recipient,
 341                 edit_screen->recipient_file,
 342                 edit_screen->trusted_devices
 343                 );
 344
 345         if (d->ShowModal() != wxID_OK) {
 346                 d->Destroy ();
 347                 return;
 348         }
 349
 350         auto cinema = edit_screen->cinema;
 351         for (auto screen: cinema->screens()) {
 352                 if (screen != edit_screen && screen->name == d->name()) {
 353                         error_dialog (
 354                                 GetParent(),
 355                                 wxString::Format (
 356                                         _("You cannot change this screen's name to '%s' as the cinema already has a screen with this name."),
 357                                         std_to_wx(d->name()).data()
 358                                         )
 359                                 );
 360                         return;
 361                 }
 362         }
 363
 364         edit_screen->name = d->name();
 365         edit_screen->notes = d->notes();
 366         edit_screen->recipient = d->recipient();
 367         edit_screen->recipient_file = d->recipient_file();
 368         edit_screen->trusted_devices = d->trusted_devices();
 369         auto item = screen_to_item(edit_screen);
 370         DCPOMATIC_ASSERT (item);
 371         _targets->SetItemText (*item, std_to_wx(d->name()));
 372         Config::instance()->changed (Config::CINEMAS);
 373
 374         d->Destroy ();
 375 }
 376
 377
 378 void
 379 ScreensPanel::remove_screen_clicked ()
 380 {
 381         if (_selected_screens.size() == 1) {
 382                 if (!confirm_dialog(this, wxString::Format(_("Are you sure you want to remove the screen '%s'?"), std_to_wx(_selected_screens[0]->name)))) {
 383                         return;
 384                 }
 385         } else {
 386                 if (!confirm_dialog(this, wxString::Format(_("Are you sure you want to remove %d screens?"), int(_selected_screens.size())))) {
 387                         return;
 388                 }
 389         }
 390
 391         for (auto const& screen: _selected_screens) {
 392                 screen->cinema->remove_screen(screen);
 393                 auto item = screen_to_item(screen);
 394                 DCPOMATIC_ASSERT(item);
 395                 _targets->DeleteItem(*item);
 396         }
 397
 398         Config::instance()->changed (Config::CINEMAS);
 399 }
 400
 401
 402 vector<shared_ptr<Screen>>
 403 ScreensPanel::screens () const
 404 {
 405         vector<shared_ptr<Screen>> output;
 406
 407         for (auto item = _targets->GetFirstItem(); item.IsOk(); item = _targets->GetNextItem(item)) {
 408                 if (_targets->GetCheckedState(item) == wxCHK_CHECKED) {
 409                         if (auto screen = item_to_screen(item)) {
 410                                 output.push_back (screen);
 411                         }
 412                 }
 413         }
 414
 415         return output;
 416 }
 417
 418
 419 void
 420 ScreensPanel::selection_changed_shim (wxTreeListEvent &)
 421 {
 422         selection_changed ();
 423 }
 424
 425
 426 void
 427 ScreensPanel::selection_changed ()
 428 {
 429         if (_ignore_selection_change) {
 430                 return;
 431         }
 432
 433         wxTreeListItems selection;
 434         _targets->GetSelections (selection);
 435
 436         _selected_cinemas.clear ();
 437         _selected_screens.clear ();
 438
 439         for (size_t i = 0; i < selection.size(); ++i) {
 440                 if (auto cinema = item_to_cinema(selection[i])) {
 441                         _selected_cinemas.push_back(cinema);
 442                 }
 443                 if (auto screen = item_to_screen(selection[i])) {
 444                         _selected_screens.push_back(screen);
 445                 }
 446         }
 447
 448         setup_sensitivity ();
 449 }
 450
 451
 452 void
 453 ScreensPanel::add_cinemas ()
 454 {
 455         auto cinemas = Config::instance()->cinemas();
 456         cinemas.sort(
 457                 [this](shared_ptr<Cinema> a, shared_ptr<Cinema> b) { return compare(a->name, b->name) < 0; }
 458                 );
 459
 460         for (auto cinema: cinemas) {
 461                 add_cinema (cinema, wxTLI_LAST);
 462         }
 463 }
 464
 465
 466 void
 467 ScreensPanel::search_changed ()
 468 {
 469         _targets->DeleteAllItems ();
 470         _cinemas.clear ();
 471         _screens.clear ();
 472
 473         _item_to_cinema.clear ();
 474         _cinema_to_item.clear ();
 475         _item_to_screen.clear ();
 476         _screen_to_item.clear ();
 477
 478         add_cinemas ();
 479
 480         _ignore_selection_change = true;
 481
 482         for (auto const& selection: _selected_cinemas) {
 483                 if (auto item = cinema_to_item(selection)) {
 484                         _targets->Select (*item);
 485                 }
 486         }
 487
 488         for (auto const& selection: _selected_screens) {
 489                 if (auto item = screen_to_item(selection)) {
 490                         _targets->Select (*item);
 491                 }
 492         }
 493
 494         _ignore_selection_change = false;
 495
 496         _ignore_check_change = true;
 497
 498         for (auto const& checked: _checked_screens) {
 499                 if (auto item = screen_to_item(checked)) {
 500                         _targets->CheckItem(*item, wxCHK_CHECKED);
 501                         setup_cinema_checked_state(*item);
 502                 }
 503         }
 504
 505         _ignore_check_change = false;
 506 }
 507
 508
 509 void
 510 ScreensPanel::set_screen_checked (wxTreeListItem item, bool checked)
 511 {
 512         auto screen = item_to_screen(item);
 513         DCPOMATIC_ASSERT(screen);
 514         if (checked) {
 515                 _checked_screens.insert(screen);
 516         } else {
 517                 _checked_screens.erase(screen);
 518         }
 519 }
 520
 521
 522 void
 523 ScreensPanel::setup_cinema_checked_state (wxTreeListItem screen)
 524 {
 525         auto cinema = _targets->GetItemParent(screen);
 526         DCPOMATIC_ASSERT (cinema.IsOk());
 527         int checked = 0;
 528         int unchecked = 0;
 529         for (auto child = _targets->GetFirstChild(cinema); child.IsOk(); child = _targets->GetNextSibling(child)) {
 530                 if (_targets->GetCheckedState(child) == wxCHK_CHECKED) {
 531                     ++checked;
 532                 } else {
 533                     ++unchecked;
 534                 }
 535         }
 536         if (checked == 0) {
 537                 _targets->CheckItem(cinema, wxCHK_UNCHECKED);
 538         } else if (unchecked == 0) {
 539                 _targets->CheckItem(cinema, wxCHK_CHECKED);
 540         } else {
 541                 _targets->CheckItem(cinema, wxCHK_UNDETERMINED);
 542         }
 543 }
 544
 545
 546 void
 547 ScreensPanel::checkbox_changed (wxTreeListEvent& ev)
 548 {
 549         if (_ignore_check_change) {
 550                 return;
 551         }
 552
 553         if (item_to_cinema(ev.GetItem())) {
 554                 /* Cinema: check/uncheck all children */
 555                 auto const checked = _targets->GetCheckedState(ev.GetItem());
 556                 for (auto child = _targets->GetFirstChild(ev.GetItem()); child.IsOk(); child = _targets->GetNextSibling(child)) {
 557                         _targets->CheckItem(child, checked);
 558                         set_screen_checked(child, checked);
 559                 }
 560         } else {
 561                 set_screen_checked(ev.GetItem(), _targets->GetCheckedState(ev.GetItem()));
 562                 setup_cinema_checked_state(ev.GetItem());
 563         }
 564
 565         ScreensChanged ();
 566 }
 567
 568
 569 shared_ptr<Cinema>
 570 ScreensPanel::item_to_cinema (wxTreeListItem item) const
 571 {
 572         auto iter = _item_to_cinema.find (item);
 573         if (iter == _item_to_cinema.end()) {
 574                 return {};
 575         }
 576
 577         return iter->second;
 578 }
 579
 580
 581 shared_ptr<Screen>
 582 ScreensPanel::item_to_screen (wxTreeListItem item) const
 583 {
 584         auto iter = _item_to_screen.find (item);
 585         if (iter == _item_to_screen.end()) {
 586                 return {};
 587         }
 588
 589         return iter->second;
 590 }
 591
 592
 593 optional<wxTreeListItem>
 594 ScreensPanel::cinema_to_item (shared_ptr<Cinema> cinema) const
 595 {
 596         auto iter = _cinema_to_item.find (cinema);
 597         if (iter == _cinema_to_item.end()) {
 598                 return {};
 599         }
 600
 601         return iter->second;
 602 }
 603
 604
 605 optional<wxTreeListItem>
 606 ScreensPanel::screen_to_item (shared_ptr<Screen> screen) const
 607 {
 608         auto iter = _screen_to_item.find (screen);
 609         if (iter == _screen_to_item.end()) {
 610                 return {};
 611         }
 612
 613         return iter->second;
 614 }
 615
 616
 617 int
 618 ScreensPanel::compare (string const& utf8_a, string const& utf8_b)
 619 {
 620         if (_collator) {
 621                 UErrorCode error = U_ZERO_ERROR;
 622                 boost::scoped_array<uint16_t> utf16_a(new uint16_t[utf8_a.size() + 1]);
 623                 u_strFromUTF8(reinterpret_cast<UChar*>(utf16_a.get()), utf8_a.size() + 1, nullptr, utf8_a.c_str(), -1, &error);
 624                 boost::scoped_array<uint16_t> utf16_b(new uint16_t[utf8_b.size() + 1]);
 625                 u_strFromUTF8(reinterpret_cast<UChar*>(utf16_b.get()), utf8_b.size() + 1, nullptr, utf8_b.c_str(), -1, &error);
 626                 return ucol_strcoll(_collator, reinterpret_cast<UChar*>(utf16_a.get()), -1, reinterpret_cast<UChar*>(utf16_b.get()), -1);
 627         } else {
 628                 return strcoll(utf8_a.c_str(), utf8_b.c_str());
 629         }
 630 }