static int MuteSet(audio_output_t *aout, bool mute)
{
if (!aout->sys->volumeItf)
return -1;
SLresult r = SetMute(aout->sys->volumeItf, mute);
return (r == SL_RESULT_SUCCESS) ? 0 : -1;
}
/*----------------------------------------------------------------------
| PLT_MicroMediaController::HandleCmd_unmute
+---------------------------------------------------------------------*/
void
PLT_MicroMediaController::HandleCmd_unmute()
{
PLT_DeviceDataReference device;
GetCurMediaRenderer(device);
if (!device.IsNull()) {
SetMute(device, 0, "Master", false, NULL);
}
}
int main(int argc, CHAR* argv[])
{
HRESULT hr;
float newVolume = 0;
IAudioEndpointVolume *endpointVolume = nullptr;
// Exit early if only displaying help
if (argc == 1 || argc > 1 && strcmp(argv[1], "help") == 0) {
DisplayUsageAndExit();
}
// Find devices for manipulating mixer volumes
InitializeAudioEndpoint(&endpointVolume);
// Parse command line arguments and perform actions
if (argc == 2 && strcmp(argv[1], "get") == 0) {
printf("%.0f\n", GetVolume(endpointVolume) * 100);
} else if (argc == 3 && strcmp(argv[1], "set") == 0) {
newVolume = strtof(argv[2], nullptr) / 100;
if (argv[2][0] == '+' || argv[2][0] == '-') {
newVolume += GetVolume(endpointVolume);
}
if (newVolume < 0) newVolume = 0;
if (newVolume > 1) newVolume = 1;
SetVolume(endpointVolume, newVolume);
} else if (argc == 2 && strcmp(argv[1], "mute") == 0) {
BOOL currentValue = GetMute(endpointVolume);
if (currentValue != TRUE)
SetMute(endpointVolume, TRUE);
} else if (argc == 2 && strcmp(argv[1], "unmute") == 0) {
BOOL currentValue = GetMute(endpointVolume);
if (currentValue != FALSE)
SetMute(endpointVolume, FALSE);
} else if (argc == 2 && strcmp(argv[1], "togglemute") == 0) {
BOOL currentValue = GetMute(endpointVolume);
SetMute(endpointVolume, !currentValue);
}
// Cleanup
DestroyAudioEndpoint(endpointVolume);
return 0;
}
BOOL CPlayerToolBar::OnVolumeMute(UINT nID)
{
SetMute(!IsMuted());
if (::IsWindow(m_volctrl.GetSafeHwnd())) {
m_volctrl.Invalidate();
}
return FALSE;
}
BOOLEAN
MixSetMute(
PGLOBAL_DEVICE_INFO pGDI,
ULONG ControlId
)
{
ASSERT(ControlId == ControlLineoutMute);
SetMute(pGDI,
(BOOLEAN)
(pGDI->LocalMixerData.ControlInfo[ControlLineoutMute].Data.v[0].u != 0));
return TRUE;
}
void Channel::SetMode(Player const* player, std::string const& p2n, bool mod, bool set)
{
uint64 guid = player->GetGUID();
if (!IsOn(guid))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, guid);
return;
}
if (!playersStore[guid].IsModerator() && !player->GetSession()->HasPermission(RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, guid);
return;
}
if (guid == _ownerGUID && std::string(p2n) == player->GetName() && mod)
return;
Player* newp = sObjectAccessor->FindPlayerByName(p2n);
uint64 victim = newp ? newp->GetGUID() : 0;
if (!victim || !IsOn(victim) ||
(player->GetTeam() != newp->GetTeam() &&
(!player->GetSession()->HasPermission(RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL) ||
!newp->GetSession()->HasPermission(RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL))))
// allow make moderator from another team only if both is GMs
// at this moment this only way to show channel post for GM from another team
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, guid);
return;
}
if (_ownerGUID == victim && _ownerGUID != guid)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, guid);
return;
}
if (mod)
SetModerator(newp->GetGUID(), set);
else
SetMute(newp->GetGUID(), set);
}
void Channel::SetMode(Player const* player, std::string const& p2n, bool mod, bool set)
{
uint64 guid = player->GetGUID();
uint32 sec = player->GetSession()->GetSecurity();
if (!IsOn(guid))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, guid);
return;
}
if (!playersStore[guid].IsModerator() && !AccountMgr::IsGMAccount(sec))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, guid);
return;
}
if (guid == _ownerGUID && std::string(p2n) == player->GetName() && mod)
return;
Player* newp = sObjectAccessor->FindPlayerByName(p2n);
uint64 victim = newp ? newp->GetGUID() : 0;
if (!victim || !IsOn(victim) ||
// allow make moderator from another team only if both is GMs
// at this moment this only way to show channel post for GM from another team
((!AccountMgr::IsGMAccount(sec) || !AccountMgr::IsGMAccount(newp->GetSession()->GetSecurity())) &&
player->GetTeam() != newp->GetTeam() && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL)))
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, guid);
return;
}
if (_ownerGUID == victim && _ownerGUID != guid)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, guid);
return;
}
if (mod)
SetModerator(newp->GetGUID(), set);
else
SetMute(newp->GetGUID(), set);
}
void Channel::SetMode(Player const* player, std::string const& p2n, bool mod, bool set)
{
ObjectGuid const& guid = player->GetGUID();
if (!IsOn(guid))
{
NotMemberAppend appender;
ChannelNameBuilder<NotMemberAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
PlayerInfo& info = _playersStore.at(guid);
if (!info.IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
NotModeratorAppend appender;
ChannelNameBuilder<NotModeratorAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (guid == _ownerGuid && p2n == player->GetName() && mod)
return;
Player* newp = ObjectAccessor::FindConnectedPlayerByName(p2n);
ObjectGuid victim = newp ? newp->GetGUID() : ObjectGuid::Empty;
if (victim.IsEmpty() || !IsOn(victim) ||
(player->GetTeam() != newp->GetTeam() &&
(!player->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL) ||
!newp->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL))))
{
PlayerNotFoundAppend appender(p2n);
ChannelNameBuilder<PlayerNotFoundAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (_ownerGuid == victim && _ownerGuid != guid)
{
NotOwnerAppend appender;
ChannelNameBuilder<NotOwnerAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (mod)
SetModerator(newp->GetGUID(), set);
else
SetMute(newp->GetGUID(), set);
}
void Channel::SetMode(Player const* player, std::string const& p2n, bool mod, bool set)
{
ObjectGuid const& guid = player->GetGUID();
if (!IsOn(guid))
{
WorldPackets::Channel::ChannelNotify notify;
MakeNotMember(notify);
player->SendDirectMessage(notify.Write());
return;
}
if (!_playersStore[guid].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
WorldPackets::Channel::ChannelNotify notify;
MakeNotModerator(notify);
player->SendDirectMessage(notify.Write());
return;
}
if (guid == _ownerGUID && p2n == player->GetName() && mod)
return;
Player* newp = ObjectAccessor::FindConnectedPlayerByName(p2n);
ObjectGuid victim = newp ? newp->GetGUID() : ObjectGuid::Empty;
if (victim.IsEmpty() || !IsOn(victim) ||
(player->GetTeam() != newp->GetTeam() &&
(!player->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL) ||
!newp->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL))))
{
WorldPackets::Channel::ChannelNotify notify;
MakePlayerNotFound(notify, p2n);
player->SendDirectMessage(notify.Write());
return;
}
if (_ownerGUID == victim && _ownerGUID != guid)
{
WorldPackets::Channel::ChannelNotify notify;
MakeNotOwner(notify);
player->SendDirectMessage(notify.Write());
return;
}
if (mod)
SetModerator(newp->GetGUID(), set);
else
SetMute(newp->GetGUID(), set);
}
void Channel::SetMode(Player const* player, std::string const& p2n, bool mod, bool set)
{
ObjectGuid guid = player->GetGUID();
if (!IsOn(guid))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, guid);
return;
}
if (!playersStore[guid].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, guid);
return;
}
if (guid == _ownerGUID && std::string(p2n) == player->GetName() && mod)
return;
Player* newp = sObjectAccessor->FindPlayerByName(p2n);
ObjectGuid victim = newp ? newp->GetGUID() : ObjectGuid::Empty;
if (!victim || !IsOn(victim) ||
(player->GetTeam() != newp->GetTeam() &&
(!player->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL) ||
!newp->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL))))
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, guid);
return;
}
if (_ownerGUID == victim && _ownerGUID != guid)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, guid);
return;
}
if (mod)
SetModerator(newp->GetGUID(), set);
else
SetMute(newp->GetGUID(), set);
}
void Channel::SetMode(uint64 p, const char *p2n, bool mod, bool set)
{
uint32 sec = 0;
Player *plr = objmgr.GetPlayer(p);
if(plr)
sec = plr->GetSession()->GetSecurity();
if(!IsOn(p))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, p);
}
else if(!players[p].IsModerator() && sec < SEC_GAMEMASTER)
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, p);
}
else
{
Player *newp = objmgr.GetPlayer(p2n);
if(!newp)
return;
PlayerInfo inf = players[newp->GetGUID()];
if(p == m_ownerGUID && newp->GetGUID() == m_ownerGUID && mod)
return;
if(newp == NULL || !IsOn(newp->GetGUID()))
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, p);
}
else if(m_ownerGUID == newp->GetGUID() && m_ownerGUID != p)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, p);
}
else
{
if(mod)
SetModerator(newp->GetGUID(), set);
else
SetMute(newp->GetGUID(), set);
}
}
}
void Channel::SetMode(Player const* player, std::string const& p2n, bool mod, bool set)
{
uint64 guid = player->GetGUID();
uint32 sec = player->GetSession()->GetSecurity();
if (!IsOn(guid))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, guid);
return;
}
if (!playersStore[guid].IsModerator() && !AccountMgr::IsGMAccount(sec))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, guid);
return;
}
if (guid == _ownerGUID && std::string(p2n) == player->GetName() && mod)
return;
Player* newp = sObjectAccessor->FindPlayerByName(p2n);
uint64 victim = newp ? newp->GetGUID() : 0;
if (!victim || !IsOn(victim))
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, guid);
return;
}
if (_ownerGUID == victim && _ownerGUID != guid)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, guid);
return;
}
if (mod)
SetModerator(newp->GetGUID(), set);
else
SetMute(newp->GetGUID(), set);
}
USHORT CHalRecordMix::Open( PHALADAPTER pHalAdapter, PULONG pRecordMixCtl, PULONG pRecordMixStatus )
/////////////////////////////////////////////////////////////////////////////
{
m_pHalAdapter = pHalAdapter;
m_usDeviceID = m_pHalAdapter->GetDeviceID();
m_RegMixControl.Init( pRecordMixCtl );
m_RegMixStatus.Init( pRecordMixStatus );
m_asSource = 0;
SetMute( FALSE );
m_usDitherDepth = 24;
SetDitherDepth( MIXVAL_DITHERDEPTH_AUTO );
SetDither( FALSE );
return( HSTATUS_OK );
}
void SeqTrack::Load(SaveElementArray data)
{
int i;
for (i = 0; i < data.GetCount(); i++)
{
if (data[i]->getKey() == wxT("TrackName")) SetName(data[i]->getValue());
else if (data[i]->getKey() == wxT("VuValue")) SetVuValue(data[i]->getValueInt());
else if (data[i]->getKey() == wxT("Record")) SetRecording(data[i]->getValueInt());
else if (data[i]->getKey() == wxT("Mute")) SetMute(data[i]->getValueInt());
else if (data[i]->getKey() == wxT("Selected"))
{
if (data[i]->getValueInt() == true)
SelectTrack();
}
else if (data[i]->getKey() == wxT("PluginsNameConnected"))
ConnectTo(RackPanel->FindPlugin(data[i]->getValue()));
}
}
bool SetTrackAudioCommand::ApplyInner(const CommandContext & context, Track * t )
{
static_cast<void>(context);
auto wt = dynamic_cast<WaveTrack *>(t);
auto pt = dynamic_cast<PlayableTrack *>(t);
if( wt && bHasGain )
wt->SetGain(DB_TO_LINEAR(mGain));
if( wt && bHasPan )
wt->SetPan(mPan/100.0);
// These ones don't make sense on the second channel of a stereo track.
if( !bIsSecondChannel ){
if( pt && bHasSolo )
pt->SetSolo(bSolo);
if( pt && bHasMute )
pt->SetMute(bMute);
}
return true;
}
//-----------------------------------------------------------------------------
//!
//-----------------------------------------------------------------------------
void tNASBar::keyPressEvent( QKeyEvent* pEvent )
{
TRACE_FUNCTION;
switch( pEvent->key() )
{
case Key::Menu:
//qDebug("tNASTunerBar Key::Menu");
if( pEvent->isAutoRepeat() == false )
{
ShowContextMenu();
pEvent->accept();
}
break;
case Key::Plus:
AdjustVolume( 1 );
pEvent->accept();
break;
case Key::Minus:
AdjustVolume( -1 );
pEvent->accept();
break;
case Key::Enter:
case Key::Rotary:
if ( pEvent->isAutoRepeat() == false )
{
SetMute( !m_FusionClientAgent.IsMuted() );
pEvent->accept();
}
break;
default:
tPanel::keyPressEvent( pEvent ); // pass the event to the base class
break;
}
}
void Channel::SetMode(Player *p, const char *p2n, bool mod, bool set)
{
WorldPacket data;
if(!IsOn(p))
{
MakeNotOn(&data);
SendToOne(&data,p);
}
else if(!players[p].moderator && p->GetSession()->GetSecurity() < 2)
{
MakeNotModerator(&data);
SendToOne(&data,p);
}
else
{
Player *newp = objmgr.GetPlayer(p2n);
PlayerInfo inf = players[newp];
if(p == owner && newp == owner && mod)
return;
if(newp == NULL || !IsOn(newp))
{
MakeNotOn(&data,p2n);
SendToOne(&data,p);
}
else if(owner == newp && owner != p)
{
MakeNotOwner(&data);
SendToOne(&data,p);
}
else
{
if(mod)
SetModerator(newp,set);
else
SetMute(newp,set);
}
}
}
void Client::FloodControl(uint8_t chatType, const csString & newMessage, const csString & recipient)
{
int matches = 0;
floodHistory[nextFloodHistoryIndex] = FloodBuffRow(chatType, newMessage, recipient, csGetTicks());
nextFloodHistoryIndex = (nextFloodHistoryIndex + 1) % floodMax;
// Count occurances of this new message in the flood history.
for (int i = 0; i < floodMax; i++)
{
if (csGetTicks() - floodHistory[i].ticks < floodForgiveTime && floodHistory[i].chatType == chatType && floodHistory[i].text == newMessage && floodHistory[i].recipient == recipient)
matches++;
}
if (matches >= floodMax)
{
SetMute(true);
psserver->SendSystemError(clientnum, "BAM! Muted.");
}
else if (matches >= floodWarn)
{
psserver->SendSystemError(clientnum, "Flood warning. Stop or you will be muted.");
}
}
void Channel::SetMode(Player* player, const char* targetName, bool moderator, bool set)
{
ObjectGuid guid = player->GetObjectGuid();
if (!IsOn(guid))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, guid);
return;
}
if (!m_players[guid].IsModerator() && player->GetSession()->GetSecurity() < SEC_GAMEMASTER)
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, guid);
return;
}
Player* target = sObjectMgr.GetPlayer(targetName);
if (!target)
{
WorldPacket data;
MakePlayerNotFound(&data, targetName);
SendToOne(&data, guid);
return;
}
ObjectGuid targetGuid = target->GetObjectGuid();
if (moderator && guid == m_ownerGuid && targetGuid == m_ownerGuid)
return;
if (!IsOn(targetGuid))
{
WorldPacket data;
MakePlayerNotFound(&data, targetName);
SendToOne(&data, guid);
return;
}
// allow make moderator from another team only if both is GMs
// at this moment this only way to show channel post for GM from another team
if ((player->GetSession()->GetSecurity() < SEC_GAMEMASTER || target->GetSession()->GetSecurity() < SEC_GAMEMASTER) &&
player->GetTeam() != target->GetTeam() && !sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
{
WorldPacket data;
MakePlayerNotFound(&data, targetName);
SendToOne(&data, guid);
return;
}
if (m_ownerGuid == targetGuid && m_ownerGuid != guid)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, guid);
return;
}
// set channel moderator
if (moderator)
SetModerator(targetGuid, set);
else
SetMute(targetGuid, set);
}
BOOL CPlayerToolBar::Create(CWnd* pParentWnd)
{
VERIFY(__super::CreateEx(pParentWnd,
TBSTYLE_FLAT | TBSTYLE_TRANSPARENT | TBSTYLE_AUTOSIZE | TBSTYLE_CUSTOMERASE,
WS_CHILD | WS_VISIBLE | CBRS_BOTTOM | CBRS_TOOLTIPS,
CRect(2, 2, 0, 1)));
VERIFY(LoadToolBar(IDB_PLAYERTOOLBAR));
// Should never be RTLed
ModifyStyleEx(WS_EX_LAYOUTRTL, WS_EX_NOINHERITLAYOUT);
CToolBarCtrl& tb = GetToolBarCtrl();
tb.DeleteButton(tb.GetButtonCount() - 1);
tb.DeleteButton(tb.GetButtonCount() - 1);
SetMute(AfxGetAppSettings().fMute);
UINT styles[] = {
TBBS_CHECKGROUP, TBBS_CHECKGROUP, TBBS_CHECKGROUP,
TBBS_SEPARATOR,
TBBS_BUTTON, TBBS_BUTTON, TBBS_BUTTON, TBBS_BUTTON,
TBBS_SEPARATOR,
TBBS_BUTTON,
TBBS_SEPARATOR,
TBBS_SEPARATOR,
TBBS_CHECKBOX,
};
for (int i = 0; i < _countof(styles); ++i) {
// This fixes missing separator in Win 7
if (styles[i] & TBBS_SEPARATOR) {
SetButtonInfo(i, GetItemID(i), styles[i], -1);
} else {
SetButtonStyle(i, styles[i] | TBBS_DISABLED);
}
}
m_volctrl.Create(this);
m_volctrl.SetRange(0, 100);
m_nButtonHeight = 16; // reset m_nButtonHeight
CImage image;
if (LoadExternalToolBar(&image)) {
CBitmap* bmp = CBitmap::FromHandle(image);
int width = image.GetWidth();
int height = image.GetHeight();
int bpp = image.GetBPP();
if (width == height * 15) {
// the manual specifies that sizeButton should be sizeImage inflated by (7, 6)
SetSizes(CSize(height + 7, height + 6), CSize(height, height));
m_pButtonsImages = DEBUG_NEW CImageList();
if (bpp == 32) {
m_pButtonsImages->Create(height, height, ILC_COLOR32 | ILC_MASK, 1, 0);
m_pButtonsImages->Add(bmp, nullptr); // alpha is the mask
} else {
m_pButtonsImages->Create(height, height, ILC_COLOR24 | ILC_MASK, 1, 0);
m_pButtonsImages->Add(bmp, RGB(255, 0, 255));
}
m_nButtonHeight = height;
GetToolBarCtrl().SetImageList(m_pButtonsImages);
}
image.Destroy();
}
return TRUE;
}
ReturnValue VolumeController::Unmute()
{
return SetMute(false);
}
void Channel::SetMode(Player const* player, std::string const& p2n, bool mod, bool set)
{
uint64 guid = player->GetGUID();
uint32 sec = player->GetSession()->GetSecurity();
if (!IsOn(guid))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, guid);
return;
}
if (!playersStore[guid].IsModerator() && !AccountMgr::IsGMAccount(sec))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, guid);
return;
}
if (guid == _ownerGUID && std::string(p2n) == player->GetName() && mod)
return;
Player* newp = ObjectAccessor::FindPlayerByName(p2n, false);
uint64 victim = newp ? newp->GetGUID() : 0;
if (!victim || !IsOn(victim) ||
// allow make moderator from another team only if both is GMs
// at this moment this only way to show channel post for GM from another team
((!AccountMgr::IsGMAccount(sec) || !AccountMgr::IsGMAccount(newp->GetSession()->GetSecurity())) && player->GetTeamId() != newp->GetTeamId()))
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, guid);
return;
}
if (_ownerGUID == victim && _ownerGUID != guid)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, guid);
return;
}
if (mod)
{
bool isBadConstantModerator = _channelRights.moderators.find(newp->GetSession()->GetAccountId()) != _channelRights.moderators.end();
if (!isBadConstantModerator)
SetModerator(newp->GetGUID(), set);
}
else
{
bool isGoodConstantModerator = _channelRights.moderators.find(player->GetSession()->GetAccountId()) != _channelRights.moderators.end();
if (!AccountMgr::IsGMAccount(sec) && !isGoodConstantModerator)
{
if (_channelRights.flags & CHANNEL_RIGHT_CANT_MUTE)
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, guid);
return;
}
}
SetMute(newp->GetGUID(), set);
}
}
BOOL CPlayerToolBar::OnVolumeMute(UINT nID)
{
SetMute(!IsMuted());
return FALSE;
}
void CPlayerToolBar::SwitchTheme()
{
AppSettings& s = AfxGetAppSettings();
CToolBarCtrl& tb = GetToolBarCtrl();
m_nButtonHeight = 16;
if (iDisableXPToolbars != (__int64)s.fDisableXPToolbars) {
VERIFY(LoadToolBar(IDB_PLAYERTOOLBAR));
ModifyStyleEx(WS_EX_LAYOUTRTL, WS_EX_NOINHERITLAYOUT);
tb.SetExtendedStyle(TBSTYLE_EX_DRAWDDARROWS);
tb.DeleteButton(1);
tb.DeleteButton(tb.GetButtonCount()-2);
SetMute(s.fMute);
UINT styles[] = {
TBBS_CHECKGROUP, TBBS_CHECKGROUP,
TBBS_SEPARATOR,
TBBS_BUTTON, TBBS_BUTTON, TBBS_BUTTON, TBBS_BUTTON,
TBBS_SEPARATOR,
TBBS_BUTTON,
TBBS_BUTTON,
TBBS_SEPARATOR,
TBBS_SEPARATOR,
TBBS_CHECKBOX,
};
for (int i = 0; i < _countof(styles); i++) {
SetButtonStyle(i, styles[i] | TBBS_DISABLED);
}
iDisableXPToolbars = s.fDisableXPToolbars;
}
if (s.fDisableXPToolbars) {
if (HMODULE h = LoadLibrary(_T("uxtheme.dll"))) {
SetWindowThemeFunct f = (SetWindowThemeFunct)GetProcAddress(h, "SetWindowTheme");
if (f) {
f(m_hWnd, L" ", L" ");
}
FreeLibrary(h);
}
SwitchRemmapedImgList(IDB_PLAYERTOOLBAR, 0);// 0 Remap Active
COLORSCHEME cs;
cs.dwSize = sizeof(COLORSCHEME);
cs.clrBtnHighlight = 0x0046413c;
cs.clrBtnShadow = 0x0037322d;
tb.SetColorScheme(&cs);
tb.SetIndent(5);
} else {
if (HMODULE h = LoadLibrary(_T("uxtheme.dll"))) {
SetWindowThemeFunct f = (SetWindowThemeFunct)GetProcAddress(h, "SetWindowTheme");
if (f) {
f(m_hWnd, L"Explorer", NULL);
}
FreeLibrary(h);
}
SwitchRemmapedImgList(IDB_PLAYERTOOLBAR, 2);// 2 Undo Active
COLORSCHEME cs;
cs.dwSize = sizeof(COLORSCHEME);
cs.clrBtnHighlight = GetSysColor(COLOR_BTNFACE);
cs.clrBtnShadow = GetSysColor(COLOR_BTNSHADOW);
tb.SetColorScheme(&cs);
tb.SetIndent(0);
}
HBITMAP hBmp = NULL;
bool fp = CMPCPngImage::FileExists(CString(L"toolbar"));
if (s.fDisableXPToolbars && !fp) {
/*
int col = s.clrFaceABGR;
int r, g, b, R, G, B;
r = col & 0xFF;
g = (col >> 8) & 0xFF;
b = col >> 16;
*/
hBmp = CMPCPngImage::LoadExternalImage(L"toolbar", IDB_PLAYERTOOLBAR_PNG, IMG_TYPE::PNG, s.nThemeBrightness, s.nThemeRed, s.nThemeGreen, s.nThemeBlue);
} else if (fp) {
hBmp = CMPCPngImage::LoadExternalImage(L"toolbar", 0, IMG_TYPE::UNDEF);
}
BITMAP bitmapBmp;
if (NULL != hBmp) {
::GetObject(hBmp, sizeof(bitmapBmp), &bitmapBmp);
if (fp && bitmapBmp.bmWidth != bitmapBmp.bmHeight * 15) {
if (s.fDisableXPToolbars) {
hBmp = CMPCPngImage::LoadExternalImage(L"", IDB_PLAYERTOOLBAR_PNG, IMG_TYPE::PNG, s.nThemeBrightness, s.nThemeRed, s.nThemeGreen, s.nThemeBlue);
::GetObject(hBmp, sizeof(bitmapBmp), &bitmapBmp);
} else {
DeleteObject(hBmp);
hBmp = NULL;
}
}
}
if (NULL != hBmp) {
CBitmap *bmp = DNew CBitmap();
bmp->Attach(hBmp);
SetSizes(CSize(bitmapBmp.bmHeight + 7, bitmapBmp.bmHeight + 6), CSize(bitmapBmp.bmHeight, bitmapBmp.bmHeight));
SAFE_DELETE(m_pButtonsImages);
m_pButtonsImages = DNew CImageList();
if (32 == bitmapBmp.bmBitsPixel) {
m_pButtonsImages->Create(bitmapBmp.bmHeight, bitmapBmp.bmHeight, ILC_COLOR32 | ILC_MASK, 1, 0);
m_pButtonsImages->Add(bmp, static_cast<CBitmap*>(0));
} else {
m_pButtonsImages->Create(bitmapBmp.bmHeight, bitmapBmp.bmHeight, ILC_COLOR24 | ILC_MASK, 1, 0);
m_pButtonsImages->Add(bmp, RGB(255, 0, 255));
}
m_nButtonHeight = bitmapBmp.bmHeight;
tb.SetImageList(m_pButtonsImages);
fDisableImgListRemap = true;
delete bmp;
DeleteObject(hBmp);
}
if (s.fDisableXPToolbars) {
if (!fDisableImgListRemap) {
SwitchRemmapedImgList(IDB_PLAYERTOOLBAR, 0);// 0 Remap Active
SwitchRemmapedImgList(IDB_PLAYERTOOLBAR, 1);// 1 Remap Disabled
}
} else {
fDisableImgListRemap = true;
if (NULL == fp) {
SwitchRemmapedImgList(IDB_PLAYERTOOLBAR, 2);// 2 Undo Active
if (!fDisableImgListRemap) {
SwitchRemmapedImgList(IDB_PLAYERTOOLBAR, 3);// 3 Undo Disabled
}
}
}
if (::IsWindow(m_volctrl.GetSafeHwnd())) {
m_volctrl.Invalidate();
}
CMainFrame* pFrame = (CMainFrame*)GetParentFrame();
OAFilterState fs = pFrame->GetMediaState();
TBBUTTONINFO bi;
bi.cbSize = sizeof(bi);
bi.dwMask = TBIF_IMAGE;
if (fs == State_Running) {
bi.iImage = 1;
} else {
bi.iImage = 0;
}
tb.SetButtonInfo(ID_PLAY_PLAY, &bi);
}
void AudioSystem::ToggleMute()
{ SetMute(!IsMuted()); }
ReturnValue VolumeController::Mute()
{
return SetMute(true);
}
void CMixereView::OnToggleMute()
{
SetMute(-1);
}
void Channel::SetMode(ObjectGuid p, const char *p2n, bool mod, bool set)
{
PlayerPointer plr = GetPlayer(p);
if (!plr.get())
return;
uint32 sec = plr->GetSession()->GetSecurity();
if (!IsOn(p))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, p);
}
else if (!m_players[p].IsModerator() && sec < SEC_GAMEMASTER)
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, p);
}
else
{
PlayerPointer newp = GetPlayer(p2n);
if (!newp.get())
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, p);
return;
}
PlayerInfo inf = m_players[newp->GetObjectGuid()];
if (p == m_ownerGuid && newp->GetObjectGuid() == m_ownerGuid && mod)
return;
if (!IsOn(newp->GetObjectGuid()))
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, p);
return;
}
// allow make moderator from another team only if both is GMs
// at this moment this only way to show channel post for GM from another team
if ((plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || newp->GetSession()->GetSecurity() < SEC_GAMEMASTER) &&
plr->GetTeam() != newp->GetTeam() && !sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, p);
return;
}
if (m_ownerGuid == newp->GetObjectGuid() && m_ownerGuid != p)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, p);
return;
}
if (mod)
{
if (HasFlag(CHANNEL_FLAG_GENERAL) && newp->GetSession()->GetSecurity() < SEC_GAMEMASTER)
return;
SetModerator(newp->GetObjectGuid(), set);
}
else
SetMute(newp->GetObjectGuid(), set);
}
}
void Channel::SetMode(uint64 p, const char *p2n, bool mod, bool set)
{
Player *plr = sObjectMgr->GetPlayer(p);
if (!plr)
return;
uint32 sec = plr->GetSession()->GetSecurity();
if (!IsOn(p))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, p);
}
else if (!players[p].IsModerator() && sec < SEC_GAMEMASTER)
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, p);
}
else
{
Player *newp = sObjectMgr->GetPlayer(p2n);
if (!newp)
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, p);
return;
}
if (p == m_ownerGUID && newp->GetGUID() == m_ownerGUID && mod)
return;
if (!IsOn(newp->GetGUID()))
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, p);
return;
}
// allow make moderator from another team only if both is GMs
// at this moment this only way to show channel post for GM from another team
if ((plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || newp->GetSession()->GetSecurity() < SEC_GAMEMASTER) &&
plr->GetTeam() != newp->GetTeam() && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
{
WorldPacket data;
MakePlayerNotFound(&data, p2n);
SendToOne(&data, p);
return;
}
if (m_ownerGUID == newp->GetGUID() && m_ownerGUID != p)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, p);
return;
}
if (mod)
SetModerator(newp->GetGUID(), set);
else
SetMute(newp->GetGUID(), set);
}
}
ReturnValue VolumeController::ToggleMute()
{
return SetMute(!m_muted);
}