src/bin/desklink/MediaReplicant.cpp

   1 /*
   2  * Copyright 2003-2013, Haiku. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Jérôme Duval
   7  *              François Revol
   8  *              Marcus Overhagen
   9  *              Jonas Sundström
  10  *              Axel Dörfler, axeld@pinc-software.de.
  11  *              Stephan Aßmus <superstippi@gmx.de>
  12  *              Puck Meerburg, puck@puckipedia.nl
  13  */
  14
  15
  16 //! Volume control, and media shortcuts in Deskbar
  17
  18
  19 #include <new>
  20 #include <stdio.h>
  21
  22 #include <Alert.h>
  23 #include <Bitmap.h>
  24 #include <Catalog.h>
  25 #include <Entry.h>
  26 #include <File.h>
  27 #include <FindDirectory.h>
  28 #include <IconUtils.h>
  29 #include <MenuItem.h>
  30 #include <Path.h>
  31 #include <PopUpMenu.h>
  32 #include <Roster.h>
  33 #include <String.h>
  34 #include <StringView.h>
  35 #include <ToolTip.h>
  36 #include <ToolTipManager.h>
  37
  38 #include "desklink.h"
  39 #include "iconfile.h"
  40 #include "MixerControl.h"
  41 #include "VolumeWindow.h"
  42
  43
  44 #undef B_TRANSLATION_CONTEXT
  45 #define B_TRANSLATION_CONTEXT "MediaReplicant"
  46
  47
  48 static const uint32 kMsgOpenMediaSettings = 'mese';
  49 static const uint32 kMsgOpenSoundSettings = 'sose';
  50 static const uint32 kMsgOpenMediaPlayer = 'omep';
  51 static const uint32 kMsgToggleBeep = 'tdbp';
  52 static const uint32 kMsgVolumeWhich = 'svwh';
  53
  54 static const char* kReplicantName = "MediaReplicant";
  55         // R5 name needed, Media prefs manel removes by name
  56
  57 static const char* kSettingsFile = "x-vnd.Haiku-desklink";
  58
  59
  60 class VolumeToolTip : public BToolTip {
  61 public:
  62         VolumeToolTip(int32 which = VOLUME_USE_MIXER)
  63                 :
  64                 fWhich(which)
  65         {
  66                 fView = new BStringView("", "");
  67         }
  68
  69         virtual ~VolumeToolTip()
  70         {
  71                 delete fView;
  72         }
  73
  74         virtual BView* View() const
  75         {
  76                 return fView;
  77         }
  78
  79         virtual void AttachedToWindow()
  80         {
  81                 Update();
  82         }
  83
  84         void SetWhich(int32 which)
  85         {
  86                 fWhich = which;
  87         }
  88
  89         void Update()
  90         {
  91                 if (!Lock())
  92                         return;
  93
  94                 if (fMuteMessage.Length() != 0)
  95                         fView->SetText(fMuteMessage.String());
  96                 else {
  97                         MixerControl control;
  98                         control.Connect(fWhich);
  99
 100                         BString text;
 101                         text.SetToFormat(B_TRANSLATE("%g dB"), control.Volume());
 102                         fView->SetText(text.String());
 103                 }
 104
 105                 Unlock();
 106         }
 107
 108         void SetMuteMessage(const char* message)
 109         {
 110                 fMuteMessage = message == NULL ? "" : message;
 111         }
 112
 113 private:
 114         BStringView*    fView;
 115         int32                   fWhich;
 116         BString                 fMuteMessage;
 117 };
 118
 119
 120 class MediaReplicant : public BView {
 121 public:
 122                                                         MediaReplicant(BRect frame, const char* name,
 123                                                                 uint32 resizeMask = B_FOLLOW_ALL,
 124                                                                 uint32 flags = B_WILL_DRAW | B_NAVIGABLE
 125                                                                         | B_PULSE_NEEDED);
 126                                                         MediaReplicant(BMessage* archive);
 127
 128         virtual                                 ~MediaReplicant();
 129
 130         // archiving overrides
 131         static  MediaReplicant* Instantiate(BMessage* data);
 132         virtual status_t                Archive(BMessage* data, bool deep = true) const;
 133
 134         // BView overrides
 135         virtual void                    AttachedToWindow();
 136         virtual void                    MouseDown(BPoint point);
 137         virtual void                    Draw(BRect updateRect);
 138         virtual void                    MessageReceived(BMessage* message);
 139         virtual void                    Pulse();
 140
 141 private:
 142                         status_t                _LaunchByPath(const char* path);
 143                         status_t                _LaunchBySignature(const char* signature);
 144                         void                    _Launch(const char* prettyName,
 145                                                                 const char* signature, directory_which base,
 146                                                                 const char* fileName);
 147                         void                    _LoadSettings();
 148                         void                    _SaveSettings();
 149                         void                    _Init();
 150
 151                         BBitmap*                fIcon;
 152                         BBitmap*                fMutedIcon;
 153                         VolumeWindow*   fVolumeSlider;
 154                         bool                    fDontBeep;
 155                                 // don't beep on volume change
 156                         int32                   fVolumeWhich;
 157                                 // which volume parameter to act on (Mixer/Phys.Output)
 158                         bool                            fMuted;
 159 };
 160
 161
 162 MediaReplicant::MediaReplicant(BRect frame, const char* name,
 163                 uint32 resizeMask, uint32 flags)
 164         :
 165         BView(frame, name, resizeMask, flags),
 166         fVolumeSlider(NULL),
 167         fMuted(false)
 168 {
 169         _Init();
 170 }
 171
 172
 173 MediaReplicant::MediaReplicant(BMessage* message)
 174         :
 175         BView(message),
 176         fVolumeSlider(NULL),
 177         fMuted(false)
 178 {
 179         _Init();
 180 }
 181
 182
 183 MediaReplicant::~MediaReplicant()
 184 {
 185         delete fIcon;
 186         _SaveSettings();
 187 }
 188
 189
 190 MediaReplicant*
 191 MediaReplicant::Instantiate(BMessage* data)
 192 {
 193         if (!validate_instantiation(data, kReplicantName))
 194                 return NULL;
 195
 196         return new(std::nothrow) MediaReplicant(data);
 197 }
 198
 199
 200 status_t
 201 MediaReplicant::Archive(BMessage* data, bool deep) const
 202 {
 203         status_t status = BView::Archive(data, deep);
 204         if (status < B_OK)
 205                 return status;
 206
 207         return data->AddString("add_on", kAppSignature);
 208 }
 209
 210
 211 void
 212 MediaReplicant::AttachedToWindow()
 213 {
 214         BView* parent = Parent();
 215         if (parent)
 216                 SetViewColor(parent->ViewColor());
 217
 218         BView::AttachedToWindow();
 219 }
 220
 221
 222 void
 223 MediaReplicant::Draw(BRect rect)
 224 {
 225         SetDrawingMode(B_OP_OVER);
 226         DrawBitmap(fMuted ? fMutedIcon : fIcon);
 227 }
 228
 229
 230 void
 231 MediaReplicant::MouseDown(BPoint point)
 232 {
 233         int32 buttons = B_PRIMARY_MOUSE_BUTTON;
 234         if (Looper() != NULL && Looper()->CurrentMessage() != NULL)
 235                 Looper()->CurrentMessage()->FindInt32("buttons", &buttons);
 236
 237         BPoint where = ConvertToScreen(point);
 238
 239         if ((buttons & B_SECONDARY_MOUSE_BUTTON) != 0) {
 240                 BPopUpMenu* menu = new BPopUpMenu("", false, false);
 241                 menu->SetFont(be_plain_font);
 242
 243                 menu->AddItem(new BMenuItem(
 244                         B_TRANSLATE("Media preferences" B_UTF8_ELLIPSIS),
 245                         new BMessage(kMsgOpenMediaSettings)));
 246                 menu->AddItem(new BMenuItem(
 247                         B_TRANSLATE("Sound preferences" B_UTF8_ELLIPSIS),
 248                         new BMessage(kMsgOpenSoundSettings)));
 249
 250                 menu->AddSeparatorItem();
 251
 252                 menu->AddItem(new BMenuItem(B_TRANSLATE("Open MediaPlayer"),
 253                         new BMessage(kMsgOpenMediaPlayer)));
 254
 255                 menu->AddSeparatorItem();
 256
 257                 BMenu* subMenu = new BMenu(B_TRANSLATE("Options"));
 258                 menu->AddItem(subMenu);
 259
 260                 BMenuItem* item = new BMenuItem(B_TRANSLATE("Control physical output"),
 261                         new BMessage(kMsgVolumeWhich));
 262                 item->SetMarked(fVolumeWhich == VOLUME_USE_PHYS_OUTPUT);
 263                 subMenu->AddItem(item);
 264
 265                 item = new BMenuItem(B_TRANSLATE("Beep"),
 266                         new BMessage(kMsgToggleBeep));
 267                 item->SetMarked(!fDontBeep);
 268                 subMenu->AddItem(item);
 269
 270                 menu->SetTargetForItems(this);
 271                 subMenu->SetTargetForItems(this);
 272
 273                 menu->Go(where, true, true, BRect(where - BPoint(4, 4),
 274                         where + BPoint(4, 4)));
 275
 276         } else if ((buttons & B_TERTIARY_MOUSE_BUTTON) != 0) {
 277                 MixerControl mixerControl;
 278                 if (mixerControl.Connect(fVolumeWhich)) {
 279                         mixerControl.SetMute(!fMuted);
 280                         fMuted = mixerControl.Mute();
 281                         VolumeToolTip* tip = dynamic_cast<VolumeToolTip*>(ToolTip());
 282                         if (tip != NULL) {
 283                                 tip->SetMuteMessage(fMuted ? B_TRANSLATE("Muted"): NULL);
 284                                 ShowToolTip(tip);
 285                         }
 286                         Invalidate();
 287                 }
 288
 289         } else {
 290                 // Show VolumeWindow
 291                 fVolumeSlider = new VolumeWindow(BRect(where.x, where.y,
 292                         where.x + 207, where.y + 19), fDontBeep, fVolumeWhich);
 293                 fVolumeSlider->Show();
 294         }
 295 }
 296
 297
 298 void
 299 MediaReplicant::Pulse()
 300 {
 301         bool setMuted = false;
 302         MixerControl mixerControl;
 303         const char* errorString = NULL;
 304         if (!mixerControl.Connect(fVolumeWhich, NULL, &errorString)) {
 305                 fMuted = true;
 306                 errorString = NULL;
 307         } else
 308                 setMuted = mixerControl.Mute();
 309
 310         if (setMuted != fMuted) {
 311                 fMuted = setMuted;
 312                 VolumeToolTip* tip = dynamic_cast<VolumeToolTip*>(ToolTip());
 313                 if (tip != NULL)
 314                         tip->SetMuteMessage(errorString);
 315                 Invalidate();
 316         }
 317 }
 318
 319
 320 void
 321 MediaReplicant::MessageReceived(BMessage* message)
 322 {
 323         switch (message->what) {
 324                 case kMsgOpenMediaPlayer:
 325                         _Launch("MediaPlayer", "application/x-vnd.Haiku-MediaPlayer",
 326                                 B_SYSTEM_APPS_DIRECTORY, "MediaPlayer");
 327                         break;
 328
 329                 case kMsgOpenMediaSettings:
 330                         _Launch("Media Preferences", "application/x-vnd.Haiku-Media",
 331                                 B_SYSTEM_PREFERENCES_DIRECTORY, "Media");
 332                         break;
 333
 334                 case kMsgOpenSoundSettings:
 335                         _Launch("Sounds Preferences", "application/x-vnd.Haiku-Sounds",
 336                                 B_SYSTEM_PREFERENCES_DIRECTORY, "Sounds");
 337                         break;
 338
 339                 case kMsgToggleBeep:
 340                 {
 341                         BMenuItem* item;
 342                         if (message->FindPointer("source", (void**)&item) != B_OK)
 343                                 return;
 344
 345                         item->SetMarked(!item->IsMarked());
 346                         fDontBeep = !item->IsMarked();
 347                         break;
 348                 }
 349
 350                 case kMsgVolumeWhich:
 351                 {
 352                         BMenuItem* item;
 353                         if (message->FindPointer("source", (void**)&item) != B_OK)
 354                                 return;
 355
 356                         item->SetMarked(!item->IsMarked());
 357                         fVolumeWhich = item->IsMarked()
 358                                 ? VOLUME_USE_PHYS_OUTPUT : VOLUME_USE_MIXER;
 359
 360                         if (VolumeToolTip* tip = dynamic_cast<VolumeToolTip*>(ToolTip()))
 361                                 tip->SetWhich(fVolumeWhich);
 362                         break;
 363                 }
 364
 365                 case B_MOUSE_WHEEL_CHANGED:
 366                 {
 367                         float deltaY;
 368                         if (message->FindFloat("be:wheel_delta_y", &deltaY) == B_OK
 369                                 && deltaY != 0.0) {
 370                                 MixerControl mixerControl;
 371                                 mixerControl.Connect(fVolumeWhich);
 372                                 mixerControl.ChangeVolumeBy(deltaY < 0 ? 6 : -6);
 373
 374                                 VolumeToolTip* tip = dynamic_cast<VolumeToolTip*>(ToolTip());
 375                                 if (tip != NULL) {
 376                                         tip->Update();
 377                                         ShowToolTip(tip);
 378                                 }
 379                         }
 380                         break;
 381                 }
 382
 383                 default:
 384                         BView::MessageReceived(message);
 385                         break;
 386         }
 387 }
 388
 389
 390 status_t
 391 MediaReplicant::_LaunchByPath(const char* path)
 392 {
 393         entry_ref ref;
 394         status_t status = get_ref_for_path(path, &ref);
 395         if (status != B_OK)
 396                 return status;
 397
 398         status = be_roster->Launch(&ref);
 399         if (status != B_ALREADY_RUNNING)
 400                 return status;
 401
 402         // The application runs already, bring it to front
 403
 404         app_info appInfo;
 405         status = be_roster->GetAppInfo(&ref, &appInfo);
 406         if (status != B_OK)
 407                 return status;
 408
 409         return be_roster->ActivateApp(appInfo.team);
 410 }
 411
 412
 413 status_t
 414 MediaReplicant::_LaunchBySignature(const char* signature)
 415 {
 416         status_t status = be_roster->Launch(signature);
 417         if (status != B_ALREADY_RUNNING)
 418                 return status;
 419
 420         // The application runs already, bring it to front
 421
 422         app_info appInfo;
 423         status = be_roster->GetAppInfo(signature, &appInfo);
 424         if (status != B_OK)
 425                 return status;
 426
 427         return be_roster->ActivateApp(appInfo.team);
 428 }
 429
 430
 431 void
 432 MediaReplicant::_Launch(const char* prettyName, const char* signature,
 433         directory_which base, const char* fileName)
 434 {
 435         BPath path;
 436         status_t status = find_directory(base, &path);
 437         if (status == B_OK)
 438                 path.Append(fileName);
 439
 440         // launch the application
 441         if (_LaunchBySignature(signature) != B_OK
 442                 && _LaunchByPath(path.Path()) != B_OK) {
 443                 BString message = B_TRANSLATE("Couldn't launch ");
 444                 message << prettyName;
 445
 446                 BAlert* alert = new BAlert(B_TRANSLATE("desklink"), message.String(),
 447                         B_TRANSLATE("OK"));
 448                 alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
 449                 alert->Go();
 450         }
 451 }
 452
 453
 454 void
 455 MediaReplicant::_LoadSettings()
 456 {
 457         fDontBeep = false;
 458         fVolumeWhich = VOLUME_USE_MIXER;
 459
 460         BPath path;
 461         if (find_directory(B_USER_SETTINGS_DIRECTORY, &path, false) < B_OK)
 462                 return;
 463
 464         path.Append(kSettingsFile);
 465
 466         BFile settings(path.Path(), B_READ_ONLY);
 467         if (settings.InitCheck() < B_OK)
 468                 return;
 469
 470         BMessage msg;
 471         if (msg.Unflatten(&settings) < B_OK)
 472                 return;
 473
 474         msg.FindInt32("volwhich", &fVolumeWhich);
 475         msg.FindBool("dontbeep", &fDontBeep);
 476 }
 477
 478
 479 void
 480 MediaReplicant::_SaveSettings()
 481 {
 482         BPath path;
 483         if (find_directory(B_USER_SETTINGS_DIRECTORY, &path, false) < B_OK)
 484                 return;
 485
 486         path.Append(kSettingsFile);
 487
 488         BFile settings(path.Path(), B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
 489         if (settings.InitCheck() < B_OK)
 490                 return;
 491
 492         BMessage msg('CNFG');
 493         msg.AddInt32("volwhich", fVolumeWhich);
 494         msg.AddBool("dontbeep", fDontBeep);
 495
 496         ssize_t size = 0;
 497         msg.Flatten(&settings, &size);
 498 }
 499
 500
 501 void
 502 MediaReplicant::_Init()
 503 {
 504         fIcon = new BBitmap(BRect(0, 0, kSpeakerWidth - 1, kSpeakerHeight - 1),
 505                 B_RGBA32);
 506         BIconUtils::GetVectorIcon(kSpeakerIcon, sizeof(kSpeakerIcon), fIcon);
 507
 508         fMutedIcon = new BBitmap(BRect(0, 0, kSpeakerWidth - 1, kSpeakerHeight - 1),
 509                 B_RGBA32);
 510         BIconUtils::GetVectorIcon(kMutedSpeakerIcon, sizeof(kMutedSpeakerIcon),
 511                 fMutedIcon);
 512
 513         _LoadSettings();
 514
 515         SetToolTip(new VolumeToolTip(fVolumeWhich));
 516 }
 517
 518
 519 //      #pragma mark -
 520
 521
 522 extern "C" BView*
 523 instantiate_deskbar_item(void)
 524 {
 525         return new MediaReplicant(BRect(0, 0, 16, 16), kReplicantName);
 526 }
 527