src/preferences/media/MediaViews.cpp

   1 /*
   2  * Copyright 2003-2011, Haiku.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Sikosis
   7  *              Jérôme Duval
   8  */
   9
  10
  11 #include "MediaViews.h"
  12
  13 #include <AutoDeleter.h>
  14 #include <Box.h>
  15 #include <Button.h>
  16 #include <Catalog.h>
  17 #include <CheckBox.h>
  18 #include <Deskbar.h>
  19 #include <Entry.h>
  20 #include <LayoutBuilder.h>
  21 #include <Locale.h>
  22 #include <MediaAddOn.h>
  23 #include <MediaRoster.h>
  24 #include <MenuField.h>
  25 #include <PopUpMenu.h>
  26 #include <String.h>
  27 #include <StringView.h>
  28 #include <TextView.h>
  29
  30 #include <assert.h>
  31 #include <stdio.h>
  32
  33 #include "MediaWindow.h"
  34
  35
  36 #undef B_TRANSLATION_CONTEXT
  37 #define B_TRANSLATION_CONTEXT "Media views"
  38
  39 #define MEDIA_DEFAULT_INPUT_CHANGE 'dich'
  40 #define MEDIA_DEFAULT_OUTPUT_CHANGE 'doch'
  41 #define MEDIA_SHOW_HIDE_VOLUME_CONTROL 'shvc'
  42
  43
  44 SettingsView::SettingsView()
  45         :
  46         BGroupView(B_VERTICAL, B_USE_DEFAULT_SPACING),
  47         fInputMenu(NULL),
  48         fOutputMenu(NULL)
  49 {
  50         // input menu
  51         fInputMenu = new BPopUpMenu(B_TRANSLATE("<none>"));
  52         fInputMenu->SetLabelFromMarked(true);
  53
  54         // input menu
  55         fOutputMenu = new BPopUpMenu(B_TRANSLATE("<none>"));
  56         fOutputMenu->SetLabelFromMarked(true);
  57 }
  58
  59
  60 BButton*
  61 SettingsView::MakeRestartButton()
  62 {
  63         return new BButton("restartButton",
  64                 B_TRANSLATE("Restart media services"),
  65                 new BMessage(ML_RESTART_MEDIA_SERVER),
  66                         B_ALIGN_RIGHT);
  67 }
  68
  69
  70
  71 void
  72 SettingsView::AddInputNodes(NodeList& list)
  73 {
  74         _EmptyMenu(fInputMenu);
  75
  76         BMessage message(MEDIA_DEFAULT_INPUT_CHANGE);
  77         _PopulateMenu(fInputMenu, list, message);
  78 }
  79
  80
  81 void
  82 SettingsView::AddOutputNodes(NodeList& list)
  83 {
  84         _EmptyMenu(fOutputMenu);
  85
  86         BMessage message(MEDIA_DEFAULT_OUTPUT_CHANGE);
  87         _PopulateMenu(fOutputMenu, list, message);
  88 }
  89
  90
  91 void
  92 SettingsView::SetDefaultInput(const dormant_node_info* info)
  93 {
  94         _ClearMenuSelection(fInputMenu);
  95         NodeMenuItem* item = _FindNodeItem(fInputMenu, info);
  96         if (item)
  97                 item->SetMarked(true);
  98 }
  99
 100
 101 void
 102 SettingsView::SetDefaultOutput(const dormant_node_info* info)
 103 {
 104         _ClearMenuSelection(fOutputMenu);
 105         NodeMenuItem* item = _FindNodeItem(fOutputMenu, info);
 106         if (item)
 107                 item->SetMarked(true);
 108 }
 109
 110
 111 void
 112 SettingsView::MessageReceived(BMessage* message)
 113 {
 114         switch (message->what) {
 115                 case MEDIA_DEFAULT_INPUT_CHANGE:
 116                 {
 117                         int32 index;
 118                         if (message->FindInt32("index", &index)!=B_OK)
 119                                 break;
 120                         NodeMenuItem* item
 121                                 = static_cast<NodeMenuItem*>(fInputMenu->ItemAt(index));
 122                         SetDefaultInput(item->NodeInfo());
 123                         break;
 124                 }
 125                 case MEDIA_DEFAULT_OUTPUT_CHANGE:
 126                 {
 127                         int32 index;
 128                         if (message->FindInt32("index", &index)!=B_OK)
 129                                 break;
 130                         NodeMenuItem* item
 131                                 = static_cast<NodeMenuItem*>(fOutputMenu->ItemAt(index));
 132                         SetDefaultOutput(item->NodeInfo());
 133                         break;
 134                 }
 135                 default:
 136                         BGroupView::MessageReceived(message);
 137         }
 138 }
 139
 140
 141 void
 142 SettingsView::AttachedToWindow()
 143 {
 144         BMessenger thisMessenger(this);
 145         fInputMenu->SetTargetForItems(thisMessenger);
 146         fOutputMenu->SetTargetForItems(thisMessenger);
 147 }
 148
 149
 150 MediaWindow*
 151 SettingsView::_MediaWindow() const
 152 {
 153         return static_cast<MediaWindow*>(Window());
 154 }
 155
 156
 157 void
 158 SettingsView::_EmptyMenu(BMenu* menu)
 159 {
 160         while (menu->CountItems() > 0)
 161                 delete menu->RemoveItem((int32)0);
 162 }
 163
 164
 165 void
 166 SettingsView::_PopulateMenu(BMenu* menu, NodeList& nodes,
 167         const BMessage& message)
 168 {
 169         for (int32 i = 0; i < nodes.CountItems(); i++) {
 170                 dormant_node_info* info = nodes.ItemAt(i);
 171                 menu->AddItem(new NodeMenuItem(info, new BMessage(message)));
 172         }
 173
 174         if (Window() != NULL)
 175                 menu->SetTargetForItems(BMessenger(this));
 176 }
 177
 178
 179 NodeMenuItem*
 180 SettingsView::_FindNodeItem(BMenu* menu, const dormant_node_info* nodeInfo)
 181 {
 182         for (int32 i = 0; i < menu->CountItems(); i++) {
 183                 NodeMenuItem* item = static_cast<NodeMenuItem*>(menu->ItemAt(i));
 184                 const dormant_node_info* itemInfo = item->NodeInfo();
 185                 if (itemInfo && itemInfo->addon == nodeInfo->addon
 186                         && itemInfo->flavor_id == nodeInfo->flavor_id) {
 187                         return item;
 188                 }
 189         }
 190         return NULL;
 191 }
 192
 193
 194 void
 195 SettingsView::_ClearMenuSelection(BMenu* menu)
 196 {
 197         for (int32 i = 0; i < menu->CountItems(); i++) {
 198                 BMenuItem* item = menu->ItemAt(i);
 199                 item->SetMarked(false);
 200         }
 201 }
 202
 203
 204 NodeMenuItem::NodeMenuItem(const dormant_node_info* info, BMessage* message,
 205         char shortcut, uint32 modifiers)
 206         :
 207         BMenuItem(info->name, message, shortcut, modifiers),
 208         fInfo(info)
 209 {
 210
 211 }
 212
 213
 214 status_t
 215 NodeMenuItem::Invoke(BMessage* message)
 216 {
 217         if (IsMarked())
 218                 return B_OK;
 219         return BMenuItem::Invoke(message);
 220 }
 221
 222
 223 ChannelMenuItem::ChannelMenuItem(media_input* input, BMessage* message,
 224         char shortcut, uint32 modifiers)
 225         :
 226         BMenuItem(input->name, message, shortcut, modifiers),
 227         fInput(input)
 228 {
 229 }
 230
 231
 232 ChannelMenuItem::~ChannelMenuItem()
 233 {
 234         delete fInput;
 235 }
 236
 237
 238 int32
 239 ChannelMenuItem::DestinationID()
 240 {
 241         return fInput->destination.id;
 242 }
 243
 244
 245 media_input*
 246 ChannelMenuItem::Input()
 247 {
 248         return fInput;
 249 }
 250
 251
 252 status_t
 253 ChannelMenuItem::Invoke(BMessage* message)
 254 {
 255         if (IsMarked())
 256                 return B_OK;
 257         return BMenuItem::Invoke(message);
 258 }
 259
 260
 261 AudioSettingsView::AudioSettingsView()
 262 {
 263         BBox* defaultsBox = new BBox("defaults");
 264         defaultsBox->SetLabel(B_TRANSLATE("Defaults"));
 265         BGridView* defaultsGridView = new BGridView();
 266
 267         BMenuField* inputMenuField = new BMenuField("inputMenuField",
 268                 B_TRANSLATE("Audio input:"), InputMenu());
 269
 270         BMenuField* outputMenuField = new BMenuField("outputMenuField",
 271                 B_TRANSLATE("Audio output:"), OutputMenu());
 272
 273         BLayoutBuilder::Grid<>(defaultsGridView)
 274                 .SetInsets(B_USE_DEFAULT_SPACING, 0, B_USE_DEFAULT_SPACING,
 275                         B_USE_DEFAULT_SPACING)
 276                 .AddMenuField(inputMenuField, 0, 0, B_ALIGN_HORIZONTAL_UNSET, 1, 3, 1)
 277                 .AddMenuField(outputMenuField, 0, 1)
 278                 .AddMenuField(_MakeChannelMenu(), 2, 1);
 279
 280         defaultsBox->AddChild(defaultsGridView);
 281
 282         BLayoutBuilder::Group<>(this)
 283                 .SetInsets(0, 0, 0, 0)
 284                 .Add(defaultsBox)
 285                 .AddGroup(B_HORIZONTAL)
 286                         .Add(_MakeVolumeCheckBox())
 287                         .Add(MakeRestartButton())
 288                         .End()
 289                 .AddGlue();
 290 }
 291
 292
 293 void
 294 AudioSettingsView::SetDefaultChannel(int32 channelID)
 295 {
 296         for (int32 i = 0; i < fChannelMenu->CountItems(); i++) {
 297                 ChannelMenuItem* item = _ChannelMenuItemAt(i);
 298                 item->SetMarked(item->DestinationID() == channelID);
 299         }
 300 }
 301
 302
 303 void
 304 AudioSettingsView::AttachedToWindow()
 305 {
 306         SettingsView::AttachedToWindow();
 307
 308         BMessenger thisMessenger(this);
 309         fChannelMenu->SetTargetForItems(thisMessenger);
 310         fVolumeCheckBox->SetTarget(thisMessenger);
 311 }
 312
 313
 314 void
 315 AudioSettingsView::MessageReceived(BMessage* message)
 316 {
 317         switch (message->what) {
 318                 case ML_DEFAULT_CHANNEL_CHANGED:
 319                         {
 320                                 int32 index;
 321                                 if (message->FindInt32("index", &index) != B_OK)
 322                                         break;
 323                                 ChannelMenuItem* item = _ChannelMenuItemAt(index);
 324
 325                                 if (item) {
 326                                         BMediaRoster* roster = BMediaRoster::Roster();
 327                                         roster->SetAudioOutput(*item->Input());
 328                                 } else
 329                                         fprintf(stderr, "ChannelMenuItem not found\n");
 330                         }
 331                         break;
 332                 case MEDIA_SHOW_HIDE_VOLUME_CONTROL:
 333                 {
 334                         if (fVolumeCheckBox->Value() == B_CONTROL_ON)
 335                                 _ShowDeskbarVolumeControl();
 336                         else
 337                                 _HideDeskbarVolumeControl();
 338                         break;
 339                 }
 340
 341                 default:
 342                         SettingsView::MessageReceived(message);
 343         }
 344 }
 345
 346
 347 void
 348 AudioSettingsView::SetDefaultInput(const dormant_node_info* info)
 349 {
 350         SettingsView::SetDefaultInput(info);
 351         _MediaWindow()->UpdateInputListItem(MediaListItem::AUDIO_TYPE, info);
 352         BMediaRoster::Roster()->SetAudioInput(*info);
 353 }
 354
 355
 356 void
 357 AudioSettingsView::SetDefaultOutput(const dormant_node_info* info)
 358 {
 359         SettingsView::SetDefaultOutput(info);
 360         _MediaWindow()->UpdateOutputListItem(MediaListItem::AUDIO_TYPE, info);
 361         _FillChannelMenu(info);
 362         BMediaRoster::Roster()->SetAudioOutput(*info);
 363 }
 364
 365
 366 BMenuField*
 367 AudioSettingsView::_MakeChannelMenu()
 368 {
 369         fChannelMenu = new BPopUpMenu(B_TRANSLATE("<none>"));
 370         fChannelMenu->SetLabelFromMarked(true);
 371         BMenuField* channelMenuField = new BMenuField("channelMenuField",
 372                 B_TRANSLATE("Channel:"), fChannelMenu);
 373         return channelMenuField;
 374 }
 375
 376
 377 BCheckBox*
 378 AudioSettingsView::_MakeVolumeCheckBox()
 379 {
 380         fVolumeCheckBox = new BCheckBox("volumeCheckBox",
 381                 B_TRANSLATE("Show volume control on Deskbar"),
 382                 new BMessage(MEDIA_SHOW_HIDE_VOLUME_CONTROL));
 383
 384         if (BDeskbar().HasItem("MediaReplicant"))
 385                 fVolumeCheckBox->SetValue(B_CONTROL_ON);
 386
 387         return fVolumeCheckBox;
 388 }
 389
 390
 391 void
 392 AudioSettingsView::_FillChannelMenu(const dormant_node_info* nodeInfo)
 393 {
 394         _EmptyMenu(fChannelMenu);
 395
 396         BMediaRoster* roster = BMediaRoster::Roster();
 397         media_node node;
 398         media_node_id node_id;
 399
 400         status_t err = roster->GetInstancesFor(nodeInfo->addon,
 401                 nodeInfo->flavor_id, &node_id);
 402         if (err != B_OK) {
 403                 err = roster->InstantiateDormantNode(*nodeInfo, &node,
 404                         B_FLAVOR_IS_GLOBAL);
 405         } else {
 406                 err = roster->GetNodeFor(node_id, &node);
 407         }
 408
 409         if (err == B_OK) {
 410                 int32 inputCount = 4;
 411                 media_input* inputs = new media_input[inputCount];
 412                 BPrivate::ArrayDeleter<media_input> inputDeleter(inputs);
 413
 414                 while (true) {
 415                         int32 realInputCount = 0;
 416                         err = roster->GetAllInputsFor(node, inputs,
 417                                 inputCount, &realInputCount);
 418                         if (realInputCount > inputCount) {
 419                                 inputCount *= 2;
 420                                 inputs = new media_input[inputCount];
 421                                 inputDeleter.SetTo(inputs);
 422                         } else {
 423                                 inputCount = realInputCount;
 424                                 break;
 425                         }
 426                 }
 427
 428                 if (err == B_OK) {
 429                         BMessage message(ML_DEFAULT_CHANNEL_CHANGED);
 430
 431                         for (int32 i = 0; i < inputCount; i++) {
 432                                 media_input* input = new media_input();
 433                                 memcpy(input, &inputs[i], sizeof(*input));
 434                                 ChannelMenuItem* channelItem = new ChannelMenuItem(input,
 435                                         new BMessage(message));
 436                                 fChannelMenu->AddItem(channelItem);
 437
 438                                 if (channelItem->DestinationID() == 0)
 439                                         channelItem->SetMarked(true);
 440                         }
 441                 }
 442         }
 443
 444         if (Window())
 445                 fChannelMenu->SetTargetForItems(BMessenger(this));
 446 }
 447
 448
 449 void
 450 AudioSettingsView::_ShowDeskbarVolumeControl()
 451 {
 452         BDeskbar deskbar;
 453         BEntry entry("/bin/desklink", true);
 454         int32 id;
 455         entry_ref ref;
 456         status_t status = entry.GetRef(&ref);
 457         if (status == B_OK)
 458                 status = deskbar.AddItem(&ref, &id);
 459
 460         if (status != B_OK) {
 461                 fprintf(stderr, B_TRANSLATE(
 462                         "Couldn't add volume control in Deskbar: %s\n"),
 463                         strerror(status));
 464         }
 465 }
 466
 467
 468 void
 469 AudioSettingsView::_HideDeskbarVolumeControl()
 470 {
 471         BDeskbar deskbar;
 472         status_t status = deskbar.RemoveItem("MediaReplicant");
 473         if (status != B_OK) {
 474                 fprintf(stderr, B_TRANSLATE(
 475                         "Couldn't remove volume control in Deskbar: %s\n"),
 476                         strerror(status));
 477         }
 478 }
 479
 480
 481 ChannelMenuItem*
 482 AudioSettingsView::_ChannelMenuItemAt(int32 index)
 483 {
 484         return static_cast<ChannelMenuItem*>(fChannelMenu->ItemAt(index));
 485 }
 486
 487
 488 VideoSettingsView::VideoSettingsView()
 489 {
 490         BBox* defaultsBox = new BBox("defaults");
 491         defaultsBox->SetLabel(B_TRANSLATE("Defaults"));
 492         BGridView* defaultsGridView = new BGridView();
 493
 494         BMenuField* inputMenuField = new BMenuField("inputMenuField",
 495                 B_TRANSLATE("Video input:"), InputMenu());
 496
 497         BMenuField* outputMenuField = new BMenuField("outputMenuField",
 498                 B_TRANSLATE("Video output:"), OutputMenu());
 499
 500         BLayoutBuilder::Grid<>(defaultsGridView)
 501                 .SetInsets(B_USE_DEFAULT_SPACING, 0, B_USE_DEFAULT_SPACING,
 502                         B_USE_DEFAULT_SPACING)
 503                 .AddMenuField(inputMenuField, 0, 0)
 504                 .AddMenuField(outputMenuField, 0, 1);
 505
 506         defaultsBox->AddChild(defaultsGridView);
 507
 508         BLayoutBuilder::Group<>(this)
 509                 .SetInsets(0, 0, 0, 0)
 510                 .Add(defaultsBox)
 511                 .AddGroup(B_HORIZONTAL)
 512                         .AddGlue()
 513                         .Add(MakeRestartButton())
 514                         .End()
 515                 .AddGlue();
 516 }
 517
 518
 519 void
 520 VideoSettingsView::SetDefaultInput(const dormant_node_info* info)
 521 {
 522         SettingsView::SetDefaultInput(info);
 523         _MediaWindow()->UpdateInputListItem(MediaListItem::VIDEO_TYPE, info);
 524         BMediaRoster::Roster()->SetVideoInput(*info);
 525 }
 526
 527
 528 void
 529 VideoSettingsView::SetDefaultOutput(const dormant_node_info* info)
 530 {
 531         SettingsView::SetDefaultOutput(info);
 532         _MediaWindow()->UpdateOutputListItem(MediaListItem::VIDEO_TYPE, info);
 533         BMediaRoster::Roster()->SetVideoOutput(*info);
 534 }