#include <new>
#include <stdio.h>
#include <Alert.h>
#include <Bitmap.h>
#include <Catalog.h>
#include <Entry.h>
#include <File.h>
#include <FindDirectory.h>
#include <IconUtils.h>
#include <MenuItem.h>
#include <Path.h>
#include <PopUpMenu.h>
#include <Resources.h>
#include <Roster.h>
#include <String.h>
#include <StringView.h>
#include <TextView.h>
#include <ToolTip.h>
#include <ToolTipManager.h>
#include "desklink.h"
#include "MixerControl.h"
#include "VolumeWindow.h"
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "MediaReplicant"
static const uint32 kMsgOpenMediaSettings = 'mese';
static const uint32 kMsgOpenSoundSettings = 'sose';
static const uint32 kMsgOpenMediaPlayer = 'omep';
static const uint32 kMsgToggleBeep = 'tdbp';
static const uint32 kMsgVolumeWhich = 'svwh';
static const char* kReplicantName = "MediaReplicant";
static const char* kSettingsFile = "x-vnd.Haiku-desklink";
class VolumeToolTip : public BTextToolTip {
public:
VolumeToolTip(int32 which = VOLUME_USE_MIXER)
:
BTextToolTip(""),
fWhich(which)
{
}
virtual ~VolumeToolTip()
{
}
virtual void AttachedToWindow()
{
Update();
}
void SetWhich(int32 which)
{
fWhich = which;
}
void Update()
{
if (!Lock())
return;
BTextView* view = (BTextView*)View();
if (fMuteMessage.Length() != 0)
view->SetText(fMuteMessage.String());
else {
MixerControl control;
control.Connect(fWhich);
BString text;
text.SetToFormat(B_TRANSLATE("%g dB"), control.Volume());
view->SetText(text.String());
}
Unlock();
}
void SetMuteMessage(const char* message)
{
fMuteMessage = message == NULL ? "" : message;
}
private:
int32 fWhich;
BString fMuteMessage;
};
class MediaReplicant : public BView {
public:
MediaReplicant(BRect frame, const char* name,
uint32 resizeMask = B_FOLLOW_ALL,
uint32 flags = B_WILL_DRAW | B_NAVIGABLE
| B_PULSE_NEEDED);
MediaReplicant(BMessage* archive);
virtual ~MediaReplicant();
static MediaReplicant* Instantiate(BMessage* data);
virtual status_t Archive(BMessage* data, bool deep = true) const;
virtual void AttachedToWindow();
virtual void MouseDown(BPoint point);
virtual void Draw(BRect updateRect);
virtual void MessageReceived(BMessage* message);
private:
status_t _LaunchByPath(const char* path);
status_t _LaunchBySignature(const char* signature);
void _Launch(const char* prettyName,
const char* signature, directory_which base,
const char* fileName);
void _LoadSettings();
void _SaveSettings();
void _Init();
BBitmap* _LoadIcon(BResources& resources, const char* name);
void _DisconnectMixer();
status_t _ConnectMixer();
MixerControl* fMixerControl;
BBitmap* fIcon;
BBitmap* fMutedIcon;
VolumeWindow* fVolumeSlider;
bool fDontBeep;
int32 fVolumeWhich;
bool fMuted;
};
status_t
our_image(image_info& image)
{
int32 cookie = 0;
while (get_next_image_info(B_CURRENT_TEAM, &cookie, &image) == B_OK) {
if ((char*)our_image >= (char*)image.text
&& (char*)our_image <= (char*)image.text + image.text_size)
return B_OK;
}
return B_ERROR;
}
MediaReplicant::MediaReplicant(BRect frame, const char* name,
uint32 resizeMask, uint32 flags)
:
BView(frame, name, resizeMask, flags),
fMixerControl(NULL),
fVolumeSlider(NULL),
fMuted(false)
{
_Init();
}
MediaReplicant::MediaReplicant(BMessage* message)
:
BView(message),
fMixerControl(NULL),
fVolumeSlider(NULL),
fMuted(false)
{
_Init();
}
MediaReplicant::~MediaReplicant()
{
delete fIcon;
_SaveSettings();
_DisconnectMixer();
}
MediaReplicant*
MediaReplicant::Instantiate(BMessage* data)
{
if (!validate_instantiation(data, kReplicantName))
return NULL;
return new(std::nothrow) MediaReplicant(data);
}
status_t
MediaReplicant::Archive(BMessage* data, bool deep) const
{
status_t status = BView::Archive(data, deep);
if (status < B_OK)
return status;
return data->AddString("add_on", kAppSignature);
}
void
MediaReplicant::AttachedToWindow()
{
AdoptParentColors();
_ConnectMixer();
BView::AttachedToWindow();
}
void
MediaReplicant::Draw(BRect rect)
{
SetDrawingMode(B_OP_OVER);
DrawBitmap(fMuted ? fMutedIcon : fIcon);
}
void
MediaReplicant::MouseDown(BPoint point)
{
int32 buttons = B_PRIMARY_MOUSE_BUTTON;
if (Looper() != NULL && Looper()->CurrentMessage() != NULL)
Looper()->CurrentMessage()->FindInt32("buttons", &buttons);
BPoint where = ConvertToScreen(point);
if ((buttons & B_SECONDARY_MOUSE_BUTTON) != 0) {
BPopUpMenu* menu = new BPopUpMenu("", false, false);
menu->SetFont(be_plain_font);
menu->AddItem(new BMenuItem(
B_TRANSLATE("Media preferences" B_UTF8_ELLIPSIS),
new BMessage(kMsgOpenMediaSettings)));
menu->AddItem(new BMenuItem(
B_TRANSLATE("Sounds preferences" B_UTF8_ELLIPSIS),
new BMessage(kMsgOpenSoundSettings)));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Open MediaPlayer"),
new BMessage(kMsgOpenMediaPlayer)));
menu->AddSeparatorItem();
BMenu* subMenu = new BMenu(B_TRANSLATE("Options"));
menu->AddItem(subMenu);
BMenuItem* item = new BMenuItem(B_TRANSLATE("Control physical output"),
new BMessage(kMsgVolumeWhich));
item->SetMarked(fVolumeWhich == VOLUME_USE_PHYS_OUTPUT);
subMenu->AddItem(item);
item = new BMenuItem(B_TRANSLATE("Beep"),
new BMessage(kMsgToggleBeep));
item->SetMarked(!fDontBeep);
subMenu->AddItem(item);
menu->SetTargetForItems(this);
subMenu->SetTargetForItems(this);
menu->Go(where, true, true, BRect(where - BPoint(4, 4),
where + BPoint(4, 4)));
} else if ((buttons & B_TERTIARY_MOUSE_BUTTON) != 0) {
if (fMixerControl != NULL) {
fMixerControl->SetMute(!fMuted);
fMuted = fMixerControl->Mute();
VolumeToolTip* tip = dynamic_cast<VolumeToolTip*>(ToolTip());
if (tip != NULL) {
tip->SetMuteMessage(fMuted ? B_TRANSLATE("Muted"): NULL);
tip->Update();
ShowToolTip(tip);
}
Invalidate();
}
} else {
fVolumeSlider = new VolumeWindow(BRect(where.x, where.y,
where.x + 207, where.y + 19), fDontBeep, fVolumeWhich);
fVolumeSlider->Show();
}
}
void
MediaReplicant::MessageReceived(BMessage* message)
{
switch (message->what) {
case kMsgOpenMediaPlayer:
_Launch("MediaPlayer", "application/x-vnd.Haiku-MediaPlayer",
B_SYSTEM_APPS_DIRECTORY, "MediaPlayer");
break;
case kMsgOpenMediaSettings:
_Launch("Media Preferences", "application/x-vnd.Haiku-Media",
B_SYSTEM_PREFERENCES_DIRECTORY, "Media");
break;
case kMsgOpenSoundSettings:
_Launch("Sounds Preferences", "application/x-vnd.Haiku-Sounds",
B_SYSTEM_PREFERENCES_DIRECTORY, "Sounds");
break;
case kMsgToggleBeep:
{
BMenuItem* item;
if (message->FindPointer("source", (void**)&item) != B_OK)
return;
item->SetMarked(!item->IsMarked());
fDontBeep = !item->IsMarked();
break;
}
case kMsgVolumeWhich:
{
BMenuItem* item;
if (message->FindPointer("source", (void**)&item) != B_OK)
return;
item->SetMarked(!item->IsMarked());
fVolumeWhich = item->IsMarked()
? VOLUME_USE_PHYS_OUTPUT : VOLUME_USE_MIXER;
if (_ConnectMixer() != B_OK
&& fVolumeWhich == VOLUME_USE_PHYS_OUTPUT) {
item->SetMarked(false);
fVolumeWhich = VOLUME_USE_MIXER;
_ConnectMixer();
}
if (VolumeToolTip* tip = dynamic_cast<VolumeToolTip*>(ToolTip())) {
tip->SetWhich(fVolumeWhich);
tip->Update();
}
break;
}
case B_MOUSE_WHEEL_CHANGED:
{
float deltaY;
if (message->FindFloat("be:wheel_delta_y", &deltaY) == B_OK
&& deltaY != 0.0 && fMixerControl != NULL) {
fMixerControl->ChangeVolumeBy(deltaY < 0 ? 6 : -6);
VolumeToolTip* tip = dynamic_cast<VolumeToolTip*>(ToolTip());
if (tip != NULL) {
tip->Update();
ShowToolTip(tip);
}
}
break;
}
case B_MEDIA_NEW_PARAMETER_VALUE:
{
if (fMixerControl != NULL && !fMixerControl->Connected())
return;
bool setMuted = fMixerControl->Mute();
if (setMuted != fMuted) {
fMuted = setMuted;
VolumeToolTip* tip = dynamic_cast<VolumeToolTip*>(ToolTip());
if (tip != NULL) {
tip->SetMuteMessage(fMuted ? B_TRANSLATE("Muted") : NULL);
tip->Update();
}
Invalidate();
}
break;
}
case B_MEDIA_SERVER_STARTED:
_ConnectMixer();
break;
case B_MEDIA_SERVER_QUIT:
_DisconnectMixer();
break;
case B_MEDIA_NODE_CREATED:
{
media_node mixerNode;
media_node_id mixerNodeID;
BMediaRoster* roster = BMediaRoster::CurrentRoster();
if (roster != NULL
&& message->FindInt32("media_node_id", &mixerNodeID) == B_OK
&& roster->GetNodeFor(mixerNodeID, &mixerNode) == B_OK) {
if (mixerNode.kind == B_SYSTEM_MIXER)
_ConnectMixer();
roster->ReleaseNode(mixerNode);
}
break;
}
default:
BView::MessageReceived(message);
break;
}
}
status_t
MediaReplicant::_LaunchByPath(const char* path)
{
entry_ref ref;
status_t status = get_ref_for_path(path, &ref);
if (status != B_OK)
return status;
status = be_roster->Launch(&ref);
if (status != B_ALREADY_RUNNING)
return status;
app_info appInfo;
status = be_roster->GetAppInfo(&ref, &appInfo);
if (status != B_OK)
return status;
return be_roster->ActivateApp(appInfo.team);
}
status_t
MediaReplicant::_LaunchBySignature(const char* signature)
{
status_t status = be_roster->Launch(signature);
if (status != B_ALREADY_RUNNING)
return status;
app_info appInfo;
status = be_roster->GetAppInfo(signature, &appInfo);
if (status != B_OK)
return status;
return be_roster->ActivateApp(appInfo.team);
}
void
MediaReplicant::_Launch(const char* prettyName, const char* signature,
directory_which base, const char* fileName)
{
BPath path;
status_t status = find_directory(base, &path);
if (status == B_OK)
path.Append(fileName);
if (_LaunchBySignature(signature) != B_OK
&& _LaunchByPath(path.Path()) != B_OK) {
BString message = B_TRANSLATE("Couldn't launch ");
message << prettyName;
BAlert* alert = new BAlert(
B_TRANSLATE_COMMENT("desklink", "Title of an alert box"),
message.String(), B_TRANSLATE("OK"));
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
}
}
void
MediaReplicant::_LoadSettings()
{
fDontBeep = false;
fVolumeWhich = VOLUME_USE_MIXER;
BPath path;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path, false) < B_OK)
return;
path.Append(kSettingsFile);
BFile settings(path.Path(), B_READ_ONLY);
if (settings.InitCheck() < B_OK)
return;
BMessage msg;
if (msg.Unflatten(&settings) < B_OK)
return;
msg.FindInt32("volwhich", &fVolumeWhich);
msg.FindBool("dontbeep", &fDontBeep);
}
void
MediaReplicant::_SaveSettings()
{
BPath path;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path, false) < B_OK)
return;
path.Append(kSettingsFile);
BFile settings(path.Path(), B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
if (settings.InitCheck() < B_OK)
return;
BMessage msg('CNFG');
msg.AddInt32("volwhich", fVolumeWhich);
msg.AddBool("dontbeep", fDontBeep);
ssize_t size = 0;
msg.Flatten(&settings, &size);
}
void
MediaReplicant::_Init()
{
image_info info;
if (our_image(info) != B_OK)
return;
BFile file(info.name, B_READ_ONLY);
if (file.InitCheck() != B_OK)
return;
BResources resources(&file);
if (resources.InitCheck() != B_OK)
return;
fIcon = _LoadIcon(resources, "Speaker");
fMutedIcon = _LoadIcon(resources, "SpeakerMuted");
_LoadSettings();
SetToolTip(new VolumeToolTip(fVolumeWhich));
}
BBitmap*
MediaReplicant::_LoadIcon(BResources& resources, const char* name)
{
size_t size;
const void* data = resources.LoadResource(B_VECTOR_ICON_TYPE, name, &size);
if (data == NULL)
return NULL;
BBitmap* icon = new BBitmap(Bounds(), B_RGBA32);
if (icon->InitCheck() != B_OK
|| BIconUtils::GetVectorIcon((const uint8*)data, size, icon) != B_OK) {
delete icon;
return NULL;
}
return icon;
}
void
MediaReplicant::_DisconnectMixer()
{
BMediaRoster* roster = BMediaRoster::CurrentRoster();
if (roster == NULL)
return;
roster->StopWatching(this, B_MEDIA_SERVER_STARTED);
roster->StopWatching(this, B_MEDIA_SERVER_QUIT);
roster->StopWatching(this, B_MEDIA_NODE_CREATED);
if (fMixerControl == NULL)
return;
if (fMixerControl->MuteNode() != media_node::null) {
roster->StopWatching(this, fMixerControl->MuteNode(),
B_MEDIA_NEW_PARAMETER_VALUE);
}
delete fMixerControl;
fMixerControl = NULL;
}
status_t
MediaReplicant::_ConnectMixer()
{
_DisconnectMixer();
BMediaRoster* roster = BMediaRoster::Roster();
if (roster == NULL)
return B_ERROR;
roster->StartWatching(this, B_MEDIA_SERVER_STARTED);
roster->StartWatching(this, B_MEDIA_SERVER_QUIT);
roster->StartWatching(this, B_MEDIA_NODE_CREATED);
fMixerControl = new MixerControl(fVolumeWhich);
const char* errorString = NULL;
float volume = 0.0;
fMixerControl->Connect(fVolumeWhich, &volume, &errorString);
if (errorString != NULL) {
SetToolTip(errorString);
delete fMixerControl;
fMixerControl = NULL;
return B_ERROR;
}
if (fMixerControl->MuteNode() != media_node::null) {
roster->StartWatching(this, fMixerControl->MuteNode(),
B_MEDIA_NEW_PARAMETER_VALUE);
fMuted = fMixerControl->Mute();
}
return B_OK;
}
extern "C" BView*
instantiate_deskbar_item(float maxWidth, float maxHeight)
{
return new MediaReplicant(BRect(0, 0, maxHeight - 1, maxHeight - 1),
kReplicantName);
}
