src/apps/cortex/InfoView/InfoWindowManager.cpp

   1 /*
   2  * Copyright (c) 1999-2000, Eric Moon.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions, and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions, and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  26  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  27  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31
  32 // InfoWindowManager.cpp
  33
  34 #include "InfoWindowManager.h"
  35 // InfoWindow
  36 #include "AppNodeInfoView.h"
  37 #include "ConnectionInfoView.h"
  38 #include "DormantNodeInfoView.h"
  39 #include "EndPointInfoView.h"
  40 #include "FileNodeInfoView.h"
  41 #include "LiveNodeInfoView.h"
  42 #include "InfoWindow.h"
  43 // NodeManager
  44 #include "AddOnHostProtocol.h"
  45 #include "Connection.h"
  46 #include "NodeRef.h"
  47
  48 // Application Kit
  49 #include <Application.h>
  50 #include <AppDefs.h>
  51 #include <Roster.h>
  52 // Media Kit
  53 #include <MediaAddOn.h>
  54 #include <MediaRoster.h>
  55 // Support Kit
  56 #include <List.h>
  57
  58 __USE_CORTEX_NAMESPACE
  59
  60 #include <Debug.h>
  61 #define D_ACCESS(x) //PRINT (x)
  62 #define D_ALLOC(x) //PRINT (x)
  63 #define D_INTERNAL(x) //PRINT (x)
  64 #define D_MESSAGE(x) //PRINT (x)
  65 #define D_WINDOW(x) //PRINT (x)
  66
  67 // -------------------------------------------------------- //
  68 // internal types
  69 // -------------------------------------------------------- //
  70
  71 // used to remember window for live nodes
  72 struct live_node_window {
  73
  74 public:                                         // *** ctor/dtor
  75
  76                                                         live_node_window(
  77                                                                 const NodeRef *ref,
  78                                                                 BWindow *window)
  79                                                                 : ref(ref),
  80                                                                   window(window)
  81                                                         { }
  82
  83 public:                                         // *** data members
  84
  85         const NodeRef              *ref;
  86
  87         BWindow                            *window;
  88 };
  89
  90 // used to remember windows for dormant nodes
  91 struct dormant_node_window {
  92
  93 public:                                         // *** ctor/dtor
  94
  95                                                         dormant_node_window(
  96                                                                 const dormant_node_info &info,
  97                                                                 BWindow *window)
  98                                                                 : info(info),
  99                                                                   window(window)
 100                                                         { }
 101
 102 public:                                         // *** data members
 103
 104         const dormant_node_info info;
 105
 106         BWindow                            *window;
 107 };
 108
 109 // used to remember windows for connections
 110 struct connection_window {
 111
 112 public:                                         // *** ctor/dtor
 113
 114                                                         connection_window(
 115                                                                 const media_source &source,
 116                                                                 const media_destination &destination,
 117                                                                 BWindow *window)
 118                                                                 : source(source),
 119                                                                   destination(destination),
 120                                                                   window(window)
 121                                                         { }
 122
 123 public:                                         // *** data members
 124
 125         media_source                    source;
 126
 127         media_destination               destination;
 128
 129         BWindow                            *window;
 130 };
 131
 132 // used to remember windows for media_inputs
 133 struct input_window {
 134
 135 public:                                         // *** ctor/dtor
 136
 137                                                         input_window(
 138                                                                 const media_destination &destination,
 139                                                                 BWindow *window)
 140                                                                 : destination(destination),
 141                                                                   window(window)
 142                                                         { }
 143
 144 public:                                         // *** data members
 145
 146         media_destination               destination;
 147
 148         BWindow                            *window;
 149 };
 150
 151 // used to remember windows for media_outputs
 152 struct output_window {
 153
 154 public:                                         // *** ctor/dtor
 155
 156                                                         output_window(
 157                                                                 const media_source &source,
 158                                                                 BWindow *window)
 159                                                                 : source(source),
 160                                                                   window(window)
 161                                                         { }
 162
 163 public:                                         // *** data members
 164
 165         media_source                    source;
 166
 167         BWindow                            *window;
 168 };
 169
 170 // -------------------------------------------------------- //
 171 // static member init
 172 // -------------------------------------------------------- //
 173
 174 const BPoint InfoWindowManager::M_DEFAULT_OFFSET        = BPoint(20.0, 20.0);
 175 const BPoint InfoWindowManager::M_INIT_POSITION = BPoint(90.0, 90.0);
 176
 177 InfoWindowManager *InfoWindowManager::s_instance = 0;
 178
 179 // -------------------------------------------------------- //
 180 // *** ctor/dtor
 181 // -------------------------------------------------------- //
 182
 183 /* hidden */
 184 InfoWindowManager::InfoWindowManager()
 185         : BLooper("InfoWindowManager",
 186                           B_NORMAL_PRIORITY),
 187           m_liveNodeWindows(0),
 188           m_dormantNodeWindows(0),
 189           m_connectionWindows(0),
 190           m_inputWindows(0),
 191           m_outputWindows(0),
 192           m_nextWindowPosition(M_INIT_POSITION) {
 193         D_ALLOC(("InfoWindowManager::InfoWindowManager()\n"));
 194
 195         Run();
 196
 197         BMediaRoster *roster = BMediaRoster::CurrentRoster();
 198         if (roster) {
 199                 roster->StartWatching(BMessenger(0, this),
 200                                                           B_MEDIA_CONNECTION_BROKEN);
 201         }
 202 }
 203
 204 InfoWindowManager::~InfoWindowManager() {
 205         D_ALLOC(("InfoWindowManager::~InfoWindowManager()\n"));
 206
 207         BMediaRoster *roster = BMediaRoster::CurrentRoster();
 208         if (roster) {
 209                 roster->StopWatching(BMessenger(0, this),
 210                                                           B_MEDIA_CONNECTION_BROKEN);
 211         }
 212
 213         if (m_liveNodeWindows) {
 214                 while (m_liveNodeWindows->CountItems() > 0) {
 215                         live_node_window *entry = static_cast<live_node_window *>
 216                                                                           (m_liveNodeWindows->ItemAt(0));
 217                         if (entry && entry->window) {
 218                                 remove_observer(this, entry->ref);
 219                                 BMessenger messenger(0, entry->window);
 220                                 messenger.SendMessage(B_QUIT_REQUESTED);
 221                         }
 222                         m_liveNodeWindows->RemoveItem(reinterpret_cast<void *>(entry));
 223                         delete entry;
 224                 }
 225                 delete m_liveNodeWindows;
 226                 m_liveNodeWindows = 0;
 227         }
 228
 229         if (m_dormantNodeWindows) {
 230                 while (m_dormantNodeWindows->CountItems() > 0) {
 231                         dormant_node_window *entry = static_cast<dormant_node_window *>
 232                                                                                  (m_dormantNodeWindows->ItemAt(0));
 233                         if (entry && entry->window) {
 234                                 BMessenger messenger(0, entry->window);
 235                                 messenger.SendMessage(B_QUIT_REQUESTED);
 236                         }
 237                         m_dormantNodeWindows->RemoveItem(reinterpret_cast<void *>(entry));
 238                         delete entry;
 239                 }
 240                 delete m_dormantNodeWindows;
 241                 m_dormantNodeWindows = 0;
 242         }
 243
 244         if (m_connectionWindows) {
 245                 while (m_connectionWindows->CountItems() > 0) {
 246                         connection_window *entry = static_cast<connection_window *>
 247                                                                            (m_connectionWindows->ItemAt(0));
 248                         if (entry && entry->window) {
 249                                 BMessenger messenger(0, entry->window);
 250                                 messenger.SendMessage(B_QUIT_REQUESTED);
 251                         }
 252                         m_connectionWindows->RemoveItem(reinterpret_cast<void *>(entry));
 253                         delete entry;
 254                 }
 255                 delete m_connectionWindows;
 256                 m_connectionWindows = 0;
 257         }
 258
 259         if (m_inputWindows) {
 260                 while (m_inputWindows->CountItems() > 0) {
 261                         input_window *entry = static_cast<input_window *>
 262                                                                   (m_inputWindows->ItemAt(0));
 263                         if (entry && entry->window) {
 264                                 BMessenger messenger(0, entry->window);
 265                                 messenger.SendMessage(B_QUIT_REQUESTED);
 266                         }
 267                         m_inputWindows->RemoveItem(reinterpret_cast<void *>(entry));
 268                         delete entry;
 269                 }
 270                 delete m_inputWindows;
 271                 m_inputWindows = 0;
 272         }
 273
 274         if (m_outputWindows) {
 275                 while (m_outputWindows->CountItems() > 0) {
 276                         output_window *entry = static_cast<output_window *>
 277                                                                    (m_outputWindows->ItemAt(0));
 278                         if (entry && entry->window) {
 279                                 BMessenger messenger(0, entry->window);
 280                                 messenger.SendMessage(B_QUIT_REQUESTED);
 281                         }
 282                         m_outputWindows->RemoveItem(reinterpret_cast<void *>(entry));
 283                         delete entry;
 284                 }
 285                 delete m_outputWindows;
 286                 m_outputWindows = 0;
 287         }
 288 }
 289
 290 // -------------------------------------------------------- //
 291 // *** singleton access
 292 // -------------------------------------------------------- //
 293
 294 /*static*/
 295 InfoWindowManager *InfoWindowManager::Instance() {
 296         D_ACCESS(("InfoWindowManager::Instance()\n"));
 297
 298         if (!s_instance) {
 299                 D_ACCESS((" -> create instance\n"));
 300                 s_instance = new InfoWindowManager();
 301         }
 302
 303         return s_instance;
 304 }
 305
 306 /* static */
 307 void InfoWindowManager::shutDown() {
 308         D_WINDOW(("InfoWindowManager::shutDown()\n"));
 309
 310         if (s_instance) {
 311                 s_instance->Lock();
 312                 s_instance->Quit();
 313                 s_instance = 0;
 314         }
 315 }
 316
 317 // -------------------------------------------------------- //
 318 // *** operations
 319 // -------------------------------------------------------- //
 320
 321 status_t InfoWindowManager::openWindowFor(
 322         const NodeRef *ref) {
 323         D_WINDOW(("InfoWindowManager::openWindowFor(live_node)\n"));
 324
 325         // make absolutely sure we're locked
 326         if (!IsLocked()) {
 327                 debugger("The looper must be locked !");
 328         }
 329
 330         // make sure the ref is valid
 331         if (!ref) {
 332                 return B_ERROR;
 333         }
 334
 335         BWindow *window = 0;
 336         if (_findWindowFor(ref->id(), &window)) {
 337                 // window for this node already exists, activate it
 338                 window->SetWorkspaces(B_CURRENT_WORKSPACE);
 339                 window->Activate();
 340                 return B_OK;
 341         }
 342
 343         BRect frame = InfoView::M_DEFAULT_FRAME;
 344         frame.OffsetTo(m_nextWindowPosition);
 345         m_nextWindowPosition += M_DEFAULT_OFFSET;
 346         window = new InfoWindow(frame);
 347
 348         if (_addWindowFor(ref, window)) {
 349                 // find the correct InfoView sub-class
 350                 BMediaRoster *roster = BMediaRoster::CurrentRoster();
 351                 dormant_node_info dormantNodeInfo;
 352                 if (ref->kind() & B_FILE_INTERFACE)
 353                 {
 354                         window->AddChild(new FileNodeInfoView(ref));
 355                 }
 356                 else if (roster->GetDormantNodeFor(ref->node(), &dormantNodeInfo) != B_OK) {
 357                         port_info portInfo;
 358                         app_info appInfo;
 359                         if ((get_port_info(ref->node().port, &portInfo) == B_OK)
 360                          && (be_roster->GetRunningAppInfo(portInfo.team, &appInfo) == B_OK)) {
 361                                 app_info thisAppInfo;
 362                                 if ((be_app->GetAppInfo(&thisAppInfo) != B_OK)
 363                                  || ((strcmp(appInfo.signature, thisAppInfo.signature) != 0)
 364                                  && (strcmp(appInfo.signature, addon_host::g_appSignature) != 0))) {
 365                                         window->AddChild(new AppNodeInfoView(ref));
 366                                 }
 367                                 else {
 368                                         window->AddChild(new LiveNodeInfoView(ref));
 369                                 }
 370                         }
 371                         else {
 372                                 window->AddChild(new LiveNodeInfoView(ref));
 373                         }
 374                 }
 375                 else {
 376                         window->AddChild(new LiveNodeInfoView(ref));
 377                 }
 378                 // display the window
 379                 window->Show();
 380                 return B_OK;
 381         }
 382
 383         // failed
 384         delete window;
 385         return B_ERROR;
 386 }
 387
 388 status_t InfoWindowManager::openWindowFor(
 389         const dormant_node_info &info) {
 390         D_WINDOW(("InfoWindowManager::openWindowFor(dormant_node)\n"));
 391
 392         // make absolutely sure we're locked
 393         if (!IsLocked()) {
 394                 debugger("The looper must be locked !");
 395         }
 396
 397         BWindow *window = 0;
 398         if (_findWindowFor(info, &window)) {
 399                 // window for this node already exists, activate it
 400                 window->SetWorkspaces(B_CURRENT_WORKSPACE);
 401                 window->Activate();
 402                 return B_OK;
 403         }
 404
 405         BRect frame = InfoView::M_DEFAULT_FRAME;
 406         frame.OffsetTo(m_nextWindowPosition);
 407         m_nextWindowPosition += M_DEFAULT_OFFSET;
 408         window = new InfoWindow(frame);
 409
 410         if (_addWindowFor(info, window)) {
 411                 window->AddChild(new DormantNodeInfoView(info));
 412                 window->Show();
 413                 return B_OK;
 414         }
 415
 416         // failed
 417         delete window;
 418         return B_ERROR;
 419 }
 420
 421 status_t InfoWindowManager::openWindowFor(
 422         const Connection &connection) {
 423         D_WINDOW(("InfoWindowManager::openWindowFor(connection)\n"));
 424
 425         // make absolutely sure we're locked
 426         if (!IsLocked()) {
 427                 debugger("The looper must be locked !");
 428         }
 429
 430         BWindow *window = 0;
 431         if (_findWindowFor(connection.source(), connection.destination(), &window)) {
 432                 // window for this node already exists, activate it
 433                 window->SetWorkspaces(B_CURRENT_WORKSPACE);
 434                 window->Activate();
 435                 return B_OK;
 436         }
 437
 438         BRect frame = InfoView::M_DEFAULT_FRAME;
 439         frame.OffsetTo(m_nextWindowPosition);
 440         m_nextWindowPosition += M_DEFAULT_OFFSET;
 441         window = new InfoWindow(frame);
 442
 443         if (_addWindowFor(connection, window)) {
 444                 window->AddChild(new ConnectionInfoView(connection));
 445                 window->Show();
 446                 return B_OK;
 447         }
 448
 449         // failed
 450         delete window;
 451         return B_ERROR;
 452 }
 453
 454 status_t InfoWindowManager::openWindowFor(
 455         const media_input &input) {
 456         D_WINDOW(("InfoWindowManager::openWindowFor(input)\n"));
 457
 458         // make absolutely sure we're locked
 459         if (!IsLocked()) {
 460                 debugger("The looper must be locked !");
 461         }
 462
 463         BWindow *window = 0;
 464         if (_findWindowFor(input.destination, &window)) {
 465                 // window for this node already exists, activate it
 466                 window->SetWorkspaces(B_CURRENT_WORKSPACE);
 467                 window->Activate();
 468                 return B_OK;
 469         }
 470
 471         BRect frame = InfoView::M_DEFAULT_FRAME;
 472         frame.OffsetTo(m_nextWindowPosition);
 473         m_nextWindowPosition += M_DEFAULT_OFFSET;
 474         window = new InfoWindow(frame);
 475
 476         if (_addWindowFor(input, window)) {
 477                 window->AddChild(new EndPointInfoView(input));
 478                 window->Show();
 479                 return B_OK;
 480         }
 481
 482         // failed
 483         delete window;
 484         return B_ERROR;
 485 }
 486
 487 status_t InfoWindowManager::openWindowFor(
 488         const media_output &output) {
 489         D_WINDOW(("InfoWindowManager::openWindowFor(output)\n"));
 490
 491         // make absolutely sure we're locked
 492         if (!IsLocked()) {
 493                 debugger("The looper must be locked !");
 494         }
 495
 496         BWindow *window = 0;
 497         if (_findWindowFor(output.source, &window)) {
 498                 // window for this node already exists, activate it
 499                 window->SetWorkspaces(B_CURRENT_WORKSPACE);
 500                 window->Activate();
 501                 return B_OK;
 502         }
 503
 504         BRect frame = InfoView::M_DEFAULT_FRAME;
 505         frame.OffsetTo(m_nextWindowPosition);
 506         m_nextWindowPosition += M_DEFAULT_OFFSET;
 507         window = new BWindow(frame, "", B_DOCUMENT_WINDOW, 0);
 508
 509         if (_addWindowFor(output, window)) {
 510                 window->AddChild(new EndPointInfoView(output));
 511                 window->Show();
 512                 return B_OK;
 513         }
 514
 515         // failed
 516         delete window;
 517         return B_ERROR;
 518 }
 519
 520 // -------------------------------------------------------- //
 521 // *** BLooper impl
 522 // -------------------------------------------------------- //
 523
 524 void InfoWindowManager::MessageReceived(
 525         BMessage *message) {
 526         D_MESSAGE(("InfoWindowManager::MessageReceived()\n"));
 527
 528         switch (message->what) {
 529                 case M_LIVE_NODE_WINDOW_CLOSED: {
 530                         D_MESSAGE((" -> M_LIVE_NODE_WINDOW_CLOSED\n"));
 531                         int32 nodeID;
 532                         if (message->FindInt32("nodeID", &nodeID) != B_OK) {
 533                                 return;
 534                         }
 535                         _removeWindowFor(nodeID);
 536                         break;
 537                 }
 538                 case M_DORMANT_NODE_WINDOW_CLOSED: {
 539                         D_MESSAGE((" -> M_DORMANT_NODE_WINDOW_CLOSED\n"));
 540                         dormant_node_info info;
 541                         if (message->FindInt32("addOnID", &info.addon) != B_OK) {
 542                                 return;
 543                         }
 544                         if (message->FindInt32("flavorID", &info.flavor_id) != B_OK) {
 545                                 return;
 546                         }
 547                         _removeWindowFor(info);
 548                         break;
 549                 }
 550                 case M_CONNECTION_WINDOW_CLOSED: {
 551                         D_MESSAGE((" -> M_CONNECTION_WINDOW_CLOSED\n"));
 552                         media_source source;
 553                         if (message->FindInt32("source_port", &source.port) != B_OK) {
 554                                 return;
 555                         }
 556                         if (message->FindInt32("source_id", &source.id) != B_OK) {
 557                                 return;
 558                         }
 559                         media_destination destination;
 560                         if (message->FindInt32("destination_port", &destination.port) != B_OK) {
 561                                 return;
 562                         }
 563                         if (message->FindInt32("destination_id", &destination.id) != B_OK) {
 564                                 return;
 565                         }
 566                         _removeWindowFor(source, destination);
 567                         break;
 568                 }
 569                 case M_INPUT_WINDOW_CLOSED: {
 570                         D_MESSAGE((" -> M_INPUT_WINDOW_CLOSED\n"));
 571                         media_destination destination;
 572                         if (message->FindInt32("destination_port", &destination.port) != B_OK) {
 573                                 return;
 574                         }
 575                         if (message->FindInt32("destination_id", &destination.id) != B_OK) {
 576                                 return;
 577                         }
 578                         _removeWindowFor(destination);
 579                         break;
 580                 }
 581                 case M_OUTPUT_WINDOW_CLOSED: {
 582                         D_MESSAGE((" -> M_OUTPUT_WINDOW_CLOSED\n"));
 583                         media_source source;
 584                         if (message->FindInt32("source_port", &source.port) != B_OK) {
 585                                 return;
 586                         }
 587                         if (message->FindInt32("source_id", &source.id) != B_OK) {
 588                                 return;
 589                         }
 590                         _removeWindowFor(source);
 591                         break;
 592                 }
 593                 case NodeRef::M_RELEASED: {
 594                         D_MESSAGE((" -> NodeRef::M_RELEASED\n"));
 595                         int32 nodeID;
 596                         if (message->FindInt32("nodeID", &nodeID) != B_OK) {
 597                                 return;
 598                         }
 599                         BWindow *window;
 600                         if (_findWindowFor(nodeID, &window)) {
 601                                 window->Lock();
 602                                 window->Quit();
 603                                 _removeWindowFor(nodeID);
 604                         }
 605                         break;
 606                 }
 607                 case B_MEDIA_CONNECTION_BROKEN: {
 608                         D_MESSAGE((" -> B_MEDIA_CONNECTION_BROKEN\n"));
 609                         const void *data;
 610                         ssize_t dataSize;
 611                         if (message->FindData("source", B_RAW_TYPE, &data, &dataSize) != B_OK) {
 612                                 return;
 613                         }
 614                         const media_source source = *reinterpret_cast<const media_source *>(data);
 615                         if (message->FindData("destination", B_RAW_TYPE, &data, &dataSize) != B_OK) {
 616                                 return;
 617                         }
 618                         const media_destination destination = *reinterpret_cast<const media_destination *>(data);
 619                         BWindow *window;
 620                         if (_findWindowFor(source, destination, &window)) {
 621                                 window->Lock();
 622                                 window->Quit();
 623                                 _removeWindowFor(source, destination);
 624                         }
 625                         break;
 626                 }
 627                 default: {
 628                         BLooper::MessageReceived(message);
 629                 }
 630         }
 631 }
 632
 633 // -------------------------------------------------------- //
 634 // *** internal operations
 635 // -------------------------------------------------------- //
 636
 637 bool InfoWindowManager::_addWindowFor(
 638         const NodeRef *ref,
 639         BWindow *window) {
 640         D_INTERNAL(("InfoWindowManager::_addWindowFor(live_node)\n"));
 641
 642         if (!m_liveNodeWindows) {
 643                 m_liveNodeWindows = new BList();
 644         }
 645
 646         live_node_window *entry = new live_node_window(ref, window);
 647         if (m_liveNodeWindows->AddItem(reinterpret_cast<void *>(entry))) {
 648                 add_observer(this, entry->ref);
 649                 return true;
 650         }
 651
 652         return false;
 653 }
 654
 655 bool InfoWindowManager::_findWindowFor(
 656         int32 nodeID,
 657         BWindow **outWindow) {
 658         D_INTERNAL(("InfoWindowManager::_findWindowFor(live_node)\n"));
 659
 660         if (!m_liveNodeWindows) {
 661                 return false;
 662         }
 663
 664         for (int32 i = 0; i < m_liveNodeWindows->CountItems(); i++) {
 665                 live_node_window *entry = static_cast<live_node_window *>
 666                                                                   (m_liveNodeWindows->ItemAt(i));
 667                 if (entry->ref->id() == nodeID) {
 668                         *outWindow = entry->window;
 669                         return true;
 670                 }
 671         }
 672
 673         return false;
 674 }
 675
 676 void InfoWindowManager::_removeWindowFor(
 677         int32 nodeID) {
 678         D_INTERNAL(("InfoWindowManager::_removeWindowFor(live_node)\n"));
 679
 680         if (!m_liveNodeWindows) {
 681                 return;
 682         }
 683
 684         for (int32 i = 0; i < m_liveNodeWindows->CountItems(); i++) {
 685                 live_node_window *entry = static_cast<live_node_window *>
 686                                                                   (m_liveNodeWindows->ItemAt(i));
 687                 if (entry->ref->id() == nodeID) {
 688                         m_liveNodeWindows->RemoveItem(reinterpret_cast<void *>(entry));
 689                         remove_observer(this, entry->ref);
 690                         delete entry;
 691                 }
 692         }
 693
 694         if (m_liveNodeWindows->CountItems() <= 0) {
 695                 delete m_liveNodeWindows;
 696                 m_liveNodeWindows = 0;
 697         }
 698 }
 699
 700 bool InfoWindowManager::_addWindowFor(
 701         const dormant_node_info &info,
 702         BWindow *window) {
 703         D_INTERNAL(("InfoWindowManager::_addWindowFor(dormant_node)\n"));
 704
 705         if (!m_dormantNodeWindows) {
 706                 m_dormantNodeWindows = new BList();
 707         }
 708
 709         dormant_node_window *entry = new dormant_node_window(info, window);
 710         return m_dormantNodeWindows->AddItem(reinterpret_cast<void *>(entry));
 711 }
 712
 713 bool InfoWindowManager::_findWindowFor(
 714         const dormant_node_info &info,
 715         BWindow **outWindow) {
 716         D_INTERNAL(("InfoWindowManager::_findWindowFor(dormant_node)\n"));
 717
 718         if (!m_dormantNodeWindows) {
 719                 return false;
 720         }
 721
 722         for (int32 i = 0; i < m_dormantNodeWindows->CountItems(); i++) {
 723                 dormant_node_window *entry = static_cast<dormant_node_window *>
 724                                                                          (m_dormantNodeWindows->ItemAt(i));
 725                 if ((entry->info.addon == info.addon)
 726                  && (entry->info.flavor_id == info.flavor_id)) {
 727                         *outWindow = entry->window;
 728                         return true;
 729                 }
 730         }
 731
 732         return false;
 733 }
 734
 735 void InfoWindowManager::_removeWindowFor(
 736         const dormant_node_info &info) {
 737         D_INTERNAL(("InfoWindowManager::_removeWindowFor(dormant_node)\n"));
 738
 739         if (!m_dormantNodeWindows) {
 740                 return;
 741         }
 742
 743         for (int32 i = 0; i < m_dormantNodeWindows->CountItems(); i++) {
 744                 dormant_node_window *entry = static_cast<dormant_node_window *>
 745                                                                          (m_dormantNodeWindows->ItemAt(i));
 746                 if ((entry->info.addon == info.addon)
 747                  && (entry->info.flavor_id == info.flavor_id)) {
 748                         m_dormantNodeWindows->RemoveItem(reinterpret_cast<void *>(entry));
 749                         delete entry;
 750                 }
 751         }
 752
 753         if (m_dormantNodeWindows->CountItems() >= 0) {
 754                 delete m_dormantNodeWindows;
 755                 m_dormantNodeWindows = 0;
 756         }
 757 }
 758
 759 bool InfoWindowManager::_addWindowFor(
 760         const Connection &connection,
 761         BWindow *window) {
 762         D_INTERNAL(("InfoWindowManager::_addWindowFor(connection)\n"));
 763
 764         if (!m_connectionWindows) {
 765                 m_connectionWindows = new BList();
 766         }
 767
 768         connection_window *entry = new connection_window(connection.source(),
 769                                                                                                          connection.destination(),
 770                                                                                                          window);
 771         return m_connectionWindows->AddItem(reinterpret_cast<void *>(entry));
 772 }
 773
 774 bool InfoWindowManager::_findWindowFor(
 775         const media_source &source,
 776         const media_destination &destination,
 777         BWindow **outWindow) {
 778         D_INTERNAL(("InfoWindowManager::_findWindowFor(connection)\n"));
 779
 780         if (!m_connectionWindows) {
 781                 return false;
 782         }
 783
 784         for (int32 i = 0; i < m_connectionWindows->CountItems(); i++) {
 785                 connection_window *entry = static_cast<connection_window *>
 786                                                                    (m_connectionWindows->ItemAt(i));
 787                 if ((entry->source == source)
 788                  && (entry->destination == destination)) {
 789                         *outWindow = entry->window;
 790                         return true;
 791                 }
 792         }
 793
 794         return false;
 795 }
 796
 797 void InfoWindowManager::_removeWindowFor(
 798         const media_source &source,
 799         const media_destination &destination) {
 800         D_INTERNAL(("InfoWindowManager::_removeWindowFor(connection)\n"));
 801
 802         if (!m_connectionWindows) {
 803                 return;
 804         }
 805
 806         for (int32 i = 0; i < m_connectionWindows->CountItems(); i++) {
 807                 connection_window *entry = static_cast<connection_window *>
 808                                                                    (m_connectionWindows->ItemAt(i));
 809                 if ((entry->source == source)
 810                  && (entry->destination == destination)) {
 811                         m_connectionWindows->RemoveItem(reinterpret_cast<void *>(entry));
 812                         delete entry;
 813                 }
 814         }
 815
 816         if (m_connectionWindows->CountItems() >= 0) {
 817                 delete m_connectionWindows;
 818                 m_connectionWindows = 0;
 819         }
 820 }
 821
 822 bool InfoWindowManager::_addWindowFor(
 823         const media_input &input,
 824         BWindow *window) {
 825         D_INTERNAL(("InfoWindowManager::_addWindowFor(input)\n"));
 826
 827         if (!m_inputWindows) {
 828                 m_inputWindows = new BList();
 829         }
 830
 831         input_window *entry = new input_window(input.destination, window);
 832         return m_inputWindows->AddItem(reinterpret_cast<void *>(entry));
 833 }
 834
 835 bool InfoWindowManager::_findWindowFor(
 836         const media_destination &destination,
 837         BWindow **outWindow) {
 838         D_INTERNAL(("InfoWindowManager::_findWindowFor(input)\n"));
 839
 840         if (!m_inputWindows) {
 841                 return false;
 842         }
 843
 844         for (int32 i = 0; i < m_inputWindows->CountItems(); i++) {
 845                 input_window *entry = static_cast<input_window *>
 846                                                           (m_inputWindows->ItemAt(i));
 847                 if (entry->destination == destination) {
 848                         *outWindow = entry->window;
 849                         return true;
 850                 }
 851         }
 852
 853         return false;
 854 }
 855
 856 void InfoWindowManager::_removeWindowFor(
 857         const media_destination &destination) {
 858         D_INTERNAL(("InfoWindowManager::_removeWindowFor(input)\n"));
 859
 860         if (!m_inputWindows) {
 861                 return;
 862         }
 863
 864         for (int32 i = 0; i < m_inputWindows->CountItems(); i++) {
 865                 input_window *entry = static_cast<input_window *>
 866                                                           (m_inputWindows->ItemAt(i));
 867                 if (entry->destination == destination) {
 868                         m_inputWindows->RemoveItem(reinterpret_cast<void *>(entry));
 869                         delete entry;
 870                 }
 871         }
 872
 873         if (m_inputWindows->CountItems() >= 0) {
 874                 delete m_inputWindows;
 875                 m_inputWindows = 0;
 876         }
 877 }
 878
 879 bool InfoWindowManager::_addWindowFor(
 880         const media_output &output,
 881         BWindow *window) {
 882         D_INTERNAL(("InfoWindowManager::_addWindowFor(output)\n"));
 883
 884         if (!m_outputWindows) {
 885                 m_outputWindows = new BList();
 886         }
 887
 888         output_window *entry = new output_window(output.source, window);
 889         return m_outputWindows->AddItem(reinterpret_cast<void *>(entry));
 890 }
 891
 892 bool InfoWindowManager::_findWindowFor(
 893         const media_source &source,
 894         BWindow **outWindow) {
 895         D_INTERNAL(("InfoWindowManager::_findWindowFor(output)\n"));
 896
 897         if (!m_outputWindows) {
 898                 return false;
 899         }
 900
 901         for (int32 i = 0; i < m_outputWindows->CountItems(); i++) {
 902                 output_window *entry = static_cast<output_window *>
 903                                                           (m_outputWindows->ItemAt(i));
 904                 if (entry->source == source) {
 905                         *outWindow = entry->window;
 906                         return true;
 907                 }
 908         }
 909
 910         return false;
 911 }
 912
 913 void InfoWindowManager::_removeWindowFor(
 914         const media_source &source) {
 915         D_INTERNAL(("InfoWindowManager::_removeWindowFor(output)\n"));
 916
 917         if (!m_outputWindows) {
 918                 return;
 919         }
 920
 921         for (int32 i = 0; i < m_outputWindows->CountItems(); i++) {
 922                 output_window *entry = static_cast<output_window *>
 923                                                           (m_outputWindows->ItemAt(i));
 924                 if (entry->source == source) {
 925                         m_outputWindows->RemoveItem(reinterpret_cast<void *>(entry));
 926                         delete entry;
 927                 }
 928         }
 929
 930         if (m_outputWindows->CountItems() >= 0) {
 931                 delete m_outputWindows;
 932                 m_outputWindows = 0;
 933         }
 934 }
 935
 936 // END -- InfoWindowManager.cpp --