HRESULT GLWindow::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (bDummy)
return DefWindowProc(m_hwnd, uMsg, wParam, lParam);
int ll = (int)(short)LOWORD(lParam);
int hl = (int)(short)HIWORD(lParam);
OnMessage(uMsg, wParam, lParam);
switch(uMsg)
{
case WM_CREATE:
initRC();
OnCreate();
return 0;
case WM_PAINT:
this->Redraw();
ValidateRect(m_hwnd, NULL);
return 0;
case WM_SIZE:
OnSize(ll, hl);
return 0;
case WM_LBUTTONDOWN:
OnMouseDown(MouseButton::LBUTTON, ll, hl);
SetCapture(m_hwnd);
return 0;
case WM_MBUTTONDOWN:
OnMouseDown(MouseButton::MBUTTON, ll, hl);
SetCapture(m_hwnd);
return 0;
case WM_RBUTTONDOWN:
OnMouseDown(MouseButton::RBUTTON, ll, hl);
SetCapture(m_hwnd);
return 0;
case WM_LBUTTONUP:
OnMouseUp(MouseButton::LBUTTON, ll, hl);
ReleaseCapture();
return 0;
case WM_MBUTTONUP:
OnMouseUp(MouseButton::MBUTTON, ll, hl);
ReleaseCapture();
return 0;
case WM_RBUTTONUP:
OnMouseUp(MouseButton::RBUTTON, ll, hl);
ReleaseCapture();
return 0;
case WM_LBUTTONDBLCLK:
OnMouseDblClick(MouseButton::LBUTTON, ll, hl);
return 0;
case WM_MBUTTONDBLCLK:
OnMouseDblClick(MouseButton::MBUTTON, ll, hl);
return 0;
case WM_RBUTTONDBLCLK:
OnMouseDblClick(MouseButton::RBUTTON, ll, hl);
return 0;
case WM_MOUSEMOVE:
OnMouseMove(wParam, ll, hl);
return 0;
case WM_MOUSEWHEEL:
OnMouseWheel(HIWORD(wParam), LOWORD(wParam), ll, hl);
return 0;
case WM_KEYDOWN:
OnKeyDown(wParam);
return 0;
case WM_KEYUP:
OnKeyUp(wParam);
return 0;
case WM_CHAR:
OnChar(wParam);
return 0;
case WM_TIMER:
OnTimer();
return 0;
case WM_ACTIVATE:
{
WORD active = LOWORD(wParam);
if (active == WA_INACTIVE) {
if (bFullScreen) {
ShowWindow(m_hwnd, SW_SHOWMINIMIZED);
ChangeDisplaySettings(NULL, 0);
}
} else {
SetFocus(m_hwnd);
if (bFullScreen) changeDisplaySettings();
}
return 0;
}
case WM_DESTROY:
OnDestroy();
delete m_rc;
ReleaseDC(m_hwnd, m_hdc);
return 0;
}
return DefWindowProc(m_hwnd, uMsg, wParam, lParam);
}
void CUdpClient::Process()
{
Sleep(2000);
CLog::Log(UDPCLIENT_DEBUG_LEVEL, "UDPCLIENT: Listening.");
SOCKADDR_IN remoteAddress;
char messageBuffer[1024];
DWORD dataAvailable;
while ( !m_bStop )
{
fd_set readset, exceptset;
FD_ZERO(&readset); FD_SET(client_socket, &readset);
FD_ZERO(&exceptset); FD_SET(client_socket, &exceptset);
int nfds = (int)(client_socket);
timeval tv = { 0, 100000 };
if (select(nfds, &readset, NULL, &exceptset, &tv) < 0)
{
CLog::Log(LOGERROR, "UDPCLIENT: failed to select on socket");
break;
}
// is there any data to read
dataAvailable = 0;
ioctlsocket(client_socket, FIONREAD, &dataAvailable);
// while there is data to read
while (dataAvailable > 0)
{
// read data
int messageLength = sizeof(messageBuffer) - 1 ;
#ifndef _LINUX
int remoteAddressSize;
#else
socklen_t remoteAddressSize;
#endif
remoteAddressSize = sizeof(remoteAddress);
int ret = recvfrom(client_socket, messageBuffer, messageLength, 0, (struct sockaddr *) & remoteAddress, &remoteAddressSize);
if (ret != SOCKET_ERROR)
{
// Packet received
messageLength = ret;
messageBuffer[messageLength] = '\0';
CStdString message = messageBuffer;
CLog::Log(UDPCLIENT_DEBUG_LEVEL, "UDPCLIENT RX: %u\t\t<- '%s'",
timeGetTime(), message.c_str() );
// NOTE: You should consider locking access to the screen device
// or at least wait until after vertical refresh before firing off events
// to protect access to graphics resources.
g_graphicsContext.Lock();
OnMessage(remoteAddress, message, (LPBYTE)messageBuffer, messageLength);
g_graphicsContext.Unlock();
}
else
{
CLog::Log(UDPCLIENT_DEBUG_LEVEL, "UDPCLIENT: Socket error %u", WSAGetLastError());
}
// is there any more data to read?
dataAvailable = 0;
ioctlsocket(client_socket, FIONREAD, &dataAvailable);
}
// dispatch a single command if any pending
while(DispatchNextCommand()) {}
}
closesocket(client_socket);
CLog::Log(UDPCLIENT_DEBUG_LEVEL, "UDPCLIENT: Stopped listening.");
}
LRESULT
Window::OnMessage(HWND _hWnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
switch (message) {
case WM_CREATE:
OnCreate();
return 0;
case WM_DESTROY:
OnDestroy();
return 0;
case WM_SIZE:
OnResize(LOWORD(lParam), HIWORD(lParam));
return 0;
case WM_MOUSEMOVE:
if (OnMouseMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), wParam))
return 0;
break;
case WM_LBUTTONDOWN:
if (OnMouseDown(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam))) {
/* true returned: message was handled */
ResetUserIdle();
return 0;
}
break;
case WM_LBUTTONUP:
if (OnMouseUp(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam))) {
/* true returned: message was handled */
ResetUserIdle();
return 0;
}
break;
case WM_LBUTTONDBLCLK:
if (!double_clicks)
/* instead of disabling CS_DBLCLKS (which would affect all
instances of a window class), we just translate
WM_LBUTTONDBLCLK to WM_LBUTTONDOWN here; this even works for
built-in window class such as BUTTON */
return OnMessage(_hWnd, WM_LBUTTONDOWN, wParam, lParam);
if (OnMouseDouble(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam))) {
/* true returned: message was handled */
ResetUserIdle();
return 0;
}
break;
#ifdef WM_MOUSEWHEEL
case WM_MOUSEWHEEL:
if (OnMouseWheel(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
GET_WHEEL_DELTA_WPARAM(wParam))) {
/* true returned: message was handled */
ResetUserIdle();
return 0;
}
break;
#endif
case WM_KEYDOWN:
if (OnKeyDown(wParam)) {
/* true returned: message was handled */
ResetUserIdle();
return 0;
}
break;
case WM_KEYUP:
if (OnKeyUp(wParam)) {
/* true returned: message was handled */
ResetUserIdle();
return 0;
}
break;
case WM_CHAR:
if (OnCharacter((TCHAR)wParam))
/* true returned: message was handled */
return 0;
break;
case WM_COMMAND:
if (OnCommand(LOWORD(wParam), HIWORD(wParam))) {
/* true returned: message was handled */
ResetUserIdle();
return 0;
}
break;
case WM_CANCELMODE:
OnCancelMode();
/* pass on to DefWindowProc(), there may be more to do */
break;
case WM_SETFOCUS:
OnSetFocus();
/* pass on to DefWindowProc() so the underlying window class knows
it's focused */
break;
case WM_KILLFOCUS:
OnKillFocus();
/* pass on to DefWindowProc() so the underlying window class knows
it's not focused anymore */
break;
case WM_TIMER:
if (OnTimer(*(WindowTimer *)wParam))
return 0;
break;
case WM_PAINT:
if (custom_painting) {
PaintCanvas canvas(*this);
OnPaint(canvas, canvas.get_dirty());
return 0;
}
break;
case WM_GETDLGCODE:
if (OnKeyCheck(wParam))
return DLGC_WANTMESSAGE;
break;
}
if (message >= WM_USER && message <= 0x7FFF && OnUser(message - WM_USER))
return 0;
return OnUnhandledMessage(_hWnd, message, wParam, lParam);
}
void CGUIDialogKeyboard::UpdateButtons()
{
if (m_bShift)
{ // show the button depressed
CGUIMessage msg(GUI_MSG_SELECTED, GetID(), CTL_BUTTON_SHIFT);
OnMessage(msg);
}
else
{
CGUIMessage msg(GUI_MSG_DESELECTED, GetID(), CTL_BUTTON_SHIFT);
OnMessage(msg);
}
if (m_keyType == CAPS)
{
CGUIMessage msg(GUI_MSG_SELECTED, GetID(), CTL_BUTTON_CAPS);
OnMessage(msg);
}
else
{
CGUIMessage msg(GUI_MSG_DESELECTED, GetID(), CTL_BUTTON_CAPS);
OnMessage(msg);
}
if (m_keyType == SYMBOLS)
{
CGUIMessage msg(GUI_MSG_SELECTED, GetID(), CTL_BUTTON_SYMBOLS);
OnMessage(msg);
}
else
{
CGUIMessage msg(GUI_MSG_DESELECTED, GetID(), CTL_BUTTON_SYMBOLS);
OnMessage(msg);
}
char szLabel[2];
szLabel[0] = 32;
szLabel[1] = 0;
CStdString aLabel = szLabel;
// set numerals
for (int iButton = 48; iButton <= 57; iButton++)
{
if (m_keyType == SYMBOLS)
aLabel[0] = symbol_map[iButton - 48];
else
aLabel[0] = iButton;
SetControlLabel(iButton, aLabel);
}
// set correct alphabet characters...
for (int iButton = 65; iButton <= 90; iButton++)
{
// set the correct case...
if ((m_keyType == CAPS && m_bShift) || (m_keyType == LOWER && !m_bShift))
{ // make lower case
aLabel[0] = iButton + 32;
}
else if (m_keyType == SYMBOLS)
{
aLabel[0] = symbol_map[iButton - 65 + 10];
}
else
{
aLabel[0] = iButton;
}
SetControlLabel(iButton, aLabel);
}
for (unsigned int i = 0; i < NUM_SYMBOLS; i++)
{
aLabel[0] = symbolButtons[i];
SetControlLabel(symbolButtons[i], aLabel);
}
}
bool CGUIDialogSettingsBase::OnMessage(CGUIMessage &message)
{
switch (message.GetMessage())
{
case GUI_MSG_WINDOW_INIT:
{
m_delayedSetting.reset();
if (message.GetParam1() != WINDOW_INVALID)
{ // coming to this window first time (ie not returning back from some other window)
// so we reset our section and control states
m_iCategory = 0;
ResetControlStates();
}
if (AllowResettingSettings())
{
m_resetSetting = new CSettingAction(SETTINGS_RESET_SETTING_ID);
m_resetSetting->SetLabel(10041);
m_resetSetting->SetHelp(10045);
m_resetSetting->SetControl(CreateControl("button"));
}
m_dummyCategory = new CSettingCategory(SETTINGS_EMPTY_CATEGORY_ID);
m_dummyCategory->SetLabel(10046);
m_dummyCategory->SetHelp(10047);
break;
}
case GUI_MSG_WINDOW_DEINIT:
{
// cancel any delayed changes
if (m_delayedSetting != NULL)
{
m_delayedTimer.Stop();
CGUIMessage message(GUI_MSG_UPDATE_ITEM, GetID(), m_delayedSetting->GetID());
OnMessage(message);
}
CGUIDialog::OnMessage(message);
FreeControls();
return true;
}
case GUI_MSG_FOCUSED:
{
CGUIDialog::OnMessage(message);
int focusedControl = GetFocusedControlID();
// cancel any delayed changes
if (m_delayedSetting != NULL && m_delayedSetting->GetID() != focusedControl)
{
m_delayedTimer.Stop();
CGUIMessage message(GUI_MSG_UPDATE_ITEM, GetID(), m_delayedSetting->GetID(), 1); // param1 = 1 for "reset the control if it's invalid"
g_windowManager.SendThreadMessage(message, GetID());
}
// update the value of the previous setting (in case it was invalid)
else if (m_iSetting >= CONTROL_SETTINGS_START_CONTROL && m_iSetting < (int)(CONTROL_SETTINGS_START_CONTROL + m_settingControls.size()))
{
BaseSettingControlPtr control = GetSettingControl(m_iSetting);
if (control != NULL && control->GetSetting() != NULL && !control->IsValid())
{
CGUIMessage message(GUI_MSG_UPDATE_ITEM, GetID(), m_iSetting, 1); // param1 = 1 for "reset the control if it's invalid"
g_windowManager.SendThreadMessage(message, GetID());
}
}
CVariant description;
// check if we have changed the category and need to create new setting controls
if (focusedControl >= CONTROL_SETTINGS_START_BUTTONS && focusedControl < (int)(CONTROL_SETTINGS_START_BUTTONS + m_categories.size()))
{
int categoryIndex = focusedControl - CONTROL_SETTINGS_START_BUTTONS;
const CSettingCategory* category = m_categories.at(categoryIndex);
if (categoryIndex != m_iCategory)
{
if (!category->CanAccess())
{
// unable to go to this category - focus the previous one
SET_CONTROL_FOCUS(CONTROL_SETTINGS_START_BUTTONS + m_iCategory, 0);
return false;
}
m_iCategory = categoryIndex;
CreateSettings();
}
description = category->GetHelp();
}
else if (focusedControl >= CONTROL_SETTINGS_START_CONTROL && focusedControl < (int)(CONTROL_SETTINGS_START_CONTROL + m_settingControls.size()))
{
m_iSetting = focusedControl;
CSetting *setting = GetSettingControl(focusedControl)->GetSetting();
if (setting != NULL)
description = setting->GetHelp();
}
// set the description of the currently focused category/setting
if (description.isInteger() ||
(description.isString() && !description.empty()))
SetDescription(description);
return true;
}
case GUI_MSG_CLICKED:
{
int iControl = message.GetSenderId();
if (iControl == CONTROL_SETTINGS_OKAY_BUTTON)
{
OnOkay();
Close();
return true;
}
if (iControl == CONTROL_SETTINGS_CANCEL_BUTTON)
{
OnCancel();
Close();
return true;
}
BaseSettingControlPtr control = GetSettingControl(iControl);
if (control != NULL)
OnClick(control);
break;
}
case GUI_MSG_UPDATE_ITEM:
{
if (m_delayedSetting != NULL && m_delayedSetting->GetID() == message.GetControlId())
{
// first get the delayed setting and reset its member variable
// to avoid handling the delayed setting twice in case the OnClick()
// performed later causes the window to be deinitialized (e.g. when
// changing the language)
BaseSettingControlPtr delayedSetting = m_delayedSetting;
m_delayedSetting.reset();
// if updating the setting fails and param1 has been specifically set
// we need to call OnSettingChanged() to restore a valid value in the
// setting control
if (!delayedSetting->OnClick() && message.GetParam1() != 0)
OnSettingChanged(delayedSetting->GetSetting());
return true;
}
if (message.GetControlId() >= CONTROL_SETTINGS_START_CONTROL && message.GetControlId() < (int)(CONTROL_SETTINGS_START_CONTROL + m_settingControls.size()))
{
BaseSettingControlPtr settingControl = GetSettingControl(message.GetControlId());
if (settingControl.get() != NULL && settingControl->GetSetting() != NULL)
{
settingControl->Update();
return true;
}
}
break;
}
case GUI_MSG_UPDATE:
{
if (IsActive() && HasID(message.GetSenderId()))
{
int focusedControl = GetFocusedControlID();
CreateSettings();
SET_CONTROL_FOCUS(focusedControl, 0);
}
break;
}
default:
break;
}
return CGUIDialog::OnMessage(message);
}
void CGUIDialogKeyboardGeneric::SetEditText(const std::string &text)
{
CGUIMessage msg(GUI_MSG_SET_TEXT, GetID(), CTL_EDIT);
msg.SetLabel(text);
OnMessage(msg);
}
u32 xrServer::OnMessage (NET_Packet& P, ClientID sender) // Non-Zero means broadcasting with "flags" as returned
{
if (g_pGameLevel && Level().IsDemoSave()) Level().Demo_StoreServerData(P.B.data, P.B.count);
u16 type;
P.r_begin (type);
csPlayers.Enter ();
VERIFY (verify_entities());
xrClientData* CL = ID_to_client(sender);
switch (type)
{
case M_UPDATE:
{
Process_update (P,sender); // No broadcast
VERIFY (verify_entities());
}break;
case M_SPAWN:
{
// R_ASSERT(CL->flags.bLocal);
if (CL->flags.bLocal)
Process_spawn (P,sender);
VERIFY (verify_entities());
}break;
case M_EVENT:
{
Process_event (P,sender);
VERIFY (verify_entities());
}break;
case M_EVENT_PACK:
{
NET_Packet tmpP;
while (!P.r_eof())
{
tmpP.B.count = P.r_u8();
P.r (&tmpP.B.data, tmpP.B.count);
OnMessage (tmpP, sender);
};
}break;
case M_CL_UPDATE:
{
xrClientData* CL = ID_to_client (sender);
if (!CL) break;
CL->net_Ready = TRUE;
if (!CL->net_PassUpdates)
break;
//-------------------------------------------------------------------
u32 ClientPing = CL->stats.getPing();
P.w_seek(P.r_tell()+2, &ClientPing, 4);
//-------------------------------------------------------------------
if (SV_Client)
SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE));
VERIFY (verify_entities());
}break;
case M_MOVE_PLAYERS_RESPOND:
{
xrClientData* CL = ID_to_client (sender);
if (!CL) break;
CL->net_Ready = TRUE;
CL->net_PassUpdates = TRUE;
}break;
//-------------------------------------------------------------------
case M_CL_PING_CHALLENGE:
{
P.r_u32();
u32 id = sender.value();
P.w_seek( P.r_tell(), &(id), 4);
if (SV_Client) SendTo (SV_Client->ID, P, net_flags(FALSE));
}break;
case M_CL_PING_CHALLENGE_RESPOND:
{
P.r_u32();
u32 id = P.r_u32();
ClientID clientID; clientID.set(id);
u32 clLastPing = P.r_u32();
xrClientData* pCL = ID_to_client(clientID);
pCL->ps->Rping = u16(clLastPing);
SendTo (clientID, P, net_flags(FALSE));
}break;
//-------------------------------------------------------------------
case M_CL_INPUT:
{
xrClientData* CL = ID_to_client (sender);
if (CL) CL->net_Ready = TRUE;
if (SV_Client) SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE));
VERIFY (verify_entities());
}break;
case M_GAMEMESSAGE:
{
ClientID clientID;clientID.setBroadcast();
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
VERIFY (verify_entities());
}break;
case M_CLIENTREADY:
{
xrClientData* CL = ID_to_client(sender);
if (CL)
{
CL->net_Ready = TRUE;
CL->ps->DeathTime = Device.dwTimeGlobal;
game->OnPlayerConnectFinished(sender);
};
game->signal_Syncronize ();
VERIFY (verify_entities());
}break;
case M_SWITCH_DISTANCE:
{
game->switch_distance (P,sender);
VERIFY (verify_entities());
}break;
case M_CHANGE_LEVEL:
{
if (game->change_level(P,sender)){
ClientID clientID;clientID.setBroadcast();
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
}
VERIFY (verify_entities());
}break;
case M_SAVE_GAME:
{
game->save_game (P,sender);
VERIFY (verify_entities());
}break;
case M_LOAD_GAME:
{
game->load_game (P,sender);
ClientID clientID;clientID.setBroadcast();
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
VERIFY (verify_entities());
}break;
case M_RELOAD_GAME:
{
ClientID clientID;clientID.setBroadcast();
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
VERIFY (verify_entities());
}break;
case M_SAVE_PACKET:
{
Process_save (P,sender);
VERIFY (verify_entities());
}break;
case M_CLIENT_REQUEST_CONNECTION_DATA:
{
xrClientData* CL = ID_to_client (sender);
OnCL_Connected (CL);
}break;
case M_CHAT_MESSAGE:
{
xrClientData *l_pC = ID_to_client(sender);
OnChatMessage (&P, l_pC);
}break;
case M_CHANGE_LEVEL_GAME:
{
ClientID CID; CID.set (0xffffffff);
SendBroadcast (CID,P,net_flags(TRUE,TRUE));
}break;
case M_CL_AUTH:
{
game->AddDelayedEvent (P,GAME_EVENT_PLAYER_AUTH, 0, sender);
}break;
case M_PAUSE_GAME:
{
ClientID clientID;clientID.setBroadcast();
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
}break;
case M_STATISTIC_UPDATE:
{
ClientID clientID;clientID.setBroadcast();
if (SV_Client)
SendBroadcast (SV_Client->ID,P,net_flags(TRUE,TRUE));
else
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
}break;
case M_STATISTIC_UPDATE_RESPOND:
{
if (SV_Client) SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE));
}break;
case M_PLAYER_FIRE:
{
if (game)
game->OnPlayerFire(sender, P);
}break;
}
VERIFY (verify_entities());
csPlayers.Leave ();
return IPureServer::OnMessage(P, sender);
}
// 消息响应
LRESULT CDuiText::OnBaseMessage(UINT uID, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
OnMessage(uID, uMsg, wParam, lParam);
return 0L;
}
bool CGUIDialogKeyboardGeneric::OnMessage(CGUIMessage& message)
{
switch ( message.GetMessage() )
{
case GUI_MSG_CLICKED:
{
int iControl = message.GetSenderId();
switch (iControl)
{
case CTL_BUTTON_DONE:
OnOK();
break;
case CTL_BUTTON_CANCEL:
Close();
break;
case CTL_BUTTON_SHIFT:
OnShift();
break;
case CTL_BUTTON_CAPS:
if (m_keyType == LOWER)
m_keyType = CAPS;
else if (m_keyType == CAPS)
m_keyType = LOWER;
UpdateButtons();
break;
case CTL_BUTTON_LAYOUT:
OnLayout();
break;
case CTL_BUTTON_SYMBOLS:
OnSymbols();
break;
case CTL_BUTTON_LEFT:
MoveCursor( -1);
break;
case CTL_BUTTON_RIGHT:
MoveCursor(1);
break;
case CTL_BUTTON_IP_ADDRESS:
OnIPAddress();
break;
case CTL_BUTTON_CLEAR:
SetEditText("");
break;
case CTL_EDIT:
{
CGUIMessage msg(GUI_MSG_ITEM_SELECTED, GetID(), CTL_EDIT);
OnMessage(msg);
// update callback I guess?
if (m_pCharCallback)
{ // we did _something_, so make sure our search message filter is reset
m_pCharCallback(this, msg.GetLabel());
}
m_text = msg.GetLabel();
return true;
}
default:
OnClickButton(iControl);
break;
}
}
break;
case GUI_MSG_SET_TEXT:
case GUI_MSG_INPUT_TEXT_EDIT:
{
// the edit control only handles these messages if it is either focues
// or its specific control ID is set in the message. As neither is the
// case here (focus is on one of the keyboard buttons) we have to force
// the control ID of the message to the control ID of the edit control
// (unfortunately we have to create a whole copy of the message object for that)
CGUIMessage messageCopy(message.GetMessage(), message.GetSenderId(), CTL_EDIT, message.GetParam1(), message.GetParam2(), message.GetItem());
messageCopy.SetLabel(message.GetLabel());
// ensure this goes to the edit control
CGUIControl *edit = GetControl(CTL_EDIT);
if (edit)
edit->OnMessage(messageCopy);
// close the dialog if requested
if (message.GetMessage() == GUI_MSG_SET_TEXT && message.GetParam1() > 0)
OnOK();
return true;
}
}
return CGUIDialog::OnMessage(message);
}
void CGUIWindowFullScreen::FrameMove()
{
if (g_application.GetPlaySpeed() != 1)
g_infoManager.SetDisplayAfterSeek();
if (m_bShowCurrentTime)
g_infoManager.SetDisplayAfterSeek();
if (!g_application.m_pPlayer) return;
if( g_application.m_pPlayer->IsCaching() )
{
g_infoManager.SetDisplayAfterSeek(0); //Make sure these stuff aren't visible now
}
//------------------------
m_showCodec.Update();
if (m_showCodec)
{
// show audio codec info
CStdString strAudio, strVideo, strGeneral;
g_application.m_pPlayer->GetAudioInfo(strAudio);
{
CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), LABEL_ROW1);
msg.SetLabel(strAudio);
OnMessage(msg);
}
// show video codec info
g_application.m_pPlayer->GetVideoInfo(strVideo);
{
CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), LABEL_ROW2);
msg.SetLabel(strVideo);
OnMessage(msg);
}
// show general info
g_application.m_pPlayer->GetGeneralInfo(strGeneral);
{
CStdString strGeneralFPS;
#ifdef __APPLE__
// We show CPU usage for the entire process, as it's arguably more useful.
double dCPU = m_resourceCounter.GetCPUUsage();
CStdString strCores;
strCores.Format("cpu:%.0f%%", dCPU);
#else
CStdString strCores = g_cpuInfo.GetCoresUsageString();
#endif
int missedvblanks;
int refreshrate;
double clockspeed;
CStdString strClock;
if (g_VideoReferenceClock.GetClockInfo(missedvblanks, clockspeed, refreshrate))
strClock.Format("S( refresh:%i missed:%i speed:%+.3f%% %s )"
, refreshrate
, missedvblanks
, clockspeed - 100.0
, g_renderManager.GetVSyncState().c_str());
strGeneralFPS.Format("%s\nW( fps:%02.2f %s ) %s"
, strGeneral.c_str()
, g_infoManager.GetFPS()
, strCores.c_str(), strClock.c_str() );
CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), LABEL_ROW3);
msg.SetLabel(strGeneralFPS);
OnMessage(msg);
}
}
//----------------------
// ViewMode Information
//----------------------
if (m_bShowViewModeInfo && XbmcThreads::SystemClockMillis() - m_dwShowViewModeTimeout > 2500)
{
m_bShowViewModeInfo = false;
}
if (m_bShowViewModeInfo)
{
{
// get the "View Mode" string
CStdString strTitle = g_localizeStrings.Get(629);
CStdString strMode = g_localizeStrings.Get(630 + g_settings.m_currentVideoSettings.m_ViewMode);
CStdString strInfo;
strInfo.Format("%s : %s", strTitle.c_str(), strMode.c_str());
CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), LABEL_ROW1);
msg.SetLabel(strInfo);
OnMessage(msg);
}
// show sizing information
CRect SrcRect, DestRect;
float fAR;
g_application.m_pPlayer->GetVideoRect(SrcRect, DestRect);
g_application.m_pPlayer->GetVideoAspectRatio(fAR);
{
CStdString strSizing;
strSizing.Format(g_localizeStrings.Get(245),
(int)SrcRect.Width(), (int)SrcRect.Height(),
(int)DestRect.Width(), (int)DestRect.Height(),
g_settings.m_fZoomAmount, fAR*g_settings.m_fPixelRatio,
g_settings.m_fPixelRatio, g_settings.m_fVerticalShift);
CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), LABEL_ROW2);
msg.SetLabel(strSizing);
OnMessage(msg);
}
// show resolution information
int iResolution = g_graphicsContext.GetVideoResolution();
{
CStdString strStatus;
if (g_Windowing.IsFullScreen())
strStatus.Format("%s %ix%i@%.2fHz - %s",
g_localizeStrings.Get(13287), g_settings.m_ResInfo[iResolution].iWidth,
g_settings.m_ResInfo[iResolution].iHeight, g_settings.m_ResInfo[iResolution].fRefreshRate,
g_localizeStrings.Get(244));
else
strStatus.Format("%s %ix%i - %s",
g_localizeStrings.Get(13287), g_settings.m_ResInfo[iResolution].iWidth,
g_settings.m_ResInfo[iResolution].iHeight, g_localizeStrings.Get(242));
CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), LABEL_ROW3);
msg.SetLabel(strStatus);
OnMessage(msg);
}
}
if (m_timeCodeShow && m_timeCodePosition != 0)
{
if ( (XbmcThreads::SystemClockMillis() - m_timeCodeTimeout) >= 2500)
{
m_timeCodeShow = false;
m_timeCodePosition = 0;
}
CStdString strDispTime = "00:00:00";
CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), LABEL_ROW1);
for (int pos = 7, i = m_timeCodePosition; pos >= 0 && i > 0; pos--)
{
if (strDispTime[pos] != ':')
{
i -= 1;
strDispTime[pos] = (char)m_timeCodeStamp[i] + '0';
}
}
strDispTime += "/" + g_infoManager.GetDuration(TIME_FORMAT_HH_MM_SS) + " [" + g_infoManager.GetCurrentPlayTime(TIME_FORMAT_HH_MM_SS) + "]"; // duration [ time ]
msg.SetLabel(strDispTime);
OnMessage(msg);
}
if (m_showCodec || m_bShowViewModeInfo)
{
SET_CONTROL_VISIBLE(LABEL_ROW1);
SET_CONTROL_VISIBLE(LABEL_ROW2);
SET_CONTROL_VISIBLE(LABEL_ROW3);
SET_CONTROL_VISIBLE(BLUE_BAR);
}
else if (m_timeCodeShow)
{
SET_CONTROL_VISIBLE(LABEL_ROW1);
SET_CONTROL_HIDDEN(LABEL_ROW2);
SET_CONTROL_HIDDEN(LABEL_ROW3);
SET_CONTROL_VISIBLE(BLUE_BAR);
}
else
{
SET_CONTROL_HIDDEN(LABEL_ROW1);
SET_CONTROL_HIDDEN(LABEL_ROW2);
SET_CONTROL_HIDDEN(LABEL_ROW3);
SET_CONTROL_HIDDEN(BLUE_BAR);
}
}
void RPCServer::ThreadFunc(sThread *t)
{
while (t->CheckTerminate())
{
sTCPSocket *reads[100], *writes[100], *newconn;
sInt nReads = 0, nWrites = 0;
Connection *conn;
sFORALL_LIST(Connections, conn)
{
reads[nReads++] = conn->Socket;
if (!conn->OutBuffers.IsEmpty())
writes[nWrites++] = conn->Socket;
}
if (Socket.WaitForEvents(nReads,reads,nWrites,writes,&newconn,100))
{
if (newconn)
{
conn = new Connection;
conn->Socket = newconn;
Connections.AddTail(conn);
}
// handle incoming data
for (int i=0; i<nReads; i++)
{
sFORALL_LIST(Connections,conn) if (conn->Socket == reads[i])
{
sDInt read;
Buffer *buf = conn->InBuffers.IsEmpty()?0:conn->InBuffers.GetTail();
if (!buf || buf->Count == Buffer::SIZE)
{
buf = new Buffer;
conn->InBuffers.AddTail(buf);
}
sBool ret = conn->Socket->Read(buf->Data+buf->Count,Buffer::SIZE-buf->Count,read);
// close connection?
if (!ret || read==0)
{
Connections.Rem(conn);
sDelete(conn);
break;
}
else
{
// add to in buffer
buf->Count+=(sInt)read;
// seach for end marker
const sU8 *patptr = (const sU8*)"\n\r\n\r";
const sU8 *bufptr = buf->Data+buf->Count;
for (;;)
{
if (*--bufptr != *patptr) break;
if (!*++patptr) break;
if (bufptr == buf->Data)
{
if (buf == conn->InBuffers.GetHead())
break;
buf = conn->InBuffers.GetPrev(buf);
bufptr = buf->Data+buf->Count;
}
}
if (!*patptr)
{
OnMessage(conn, buf, bufptr);
sDeleteAll(conn->InBuffers);
}
}
break;
}
}
// handle outgoing data
for (int i=0; i<nWrites; i++)
{
sFORALL_LIST(Connections,conn) if (conn->Socket == writes[i])
{
Buffer *buf = conn->OutBuffers.GetHead();
sDInt written = 0;
sBool ret = conn->Socket->Write(buf->Data, buf->Count, written);
// close connection?
if (!ret)
{
Connections.Rem(conn);
sDelete(conn);
break;
}
else
{
if (written<buf->Count)
sMoveMem(buf->Data, buf->Data+written, sInt(buf->Count-written));
buf->Count-=(sInt)written;
if (!buf->Count)
{
conn->OutBuffers.RemHead();
delete buf;
}
// close connection after sending it all out
if (conn->OutBuffers.IsEmpty())
{
Connections.Rem(conn);
sDelete(conn);
}
}
break;
}
}
}
}
int CGUIDialogFavourites::GetSelectedItem()
{
CGUIMessage message(GUI_MSG_ITEM_SELECTED, GetID(), FAVOURITES_LIST);
OnMessage(message);
return message.GetParam1();
}
void CGUIDialogFavourites::UpdateList()
{
int currentItem = GetSelectedItem();
CGUIMessage message(GUI_MSG_LABEL_BIND, GetID(), FAVOURITES_LIST, currentItem >= 0 ? currentItem : 0, 0, m_favourites);
OnMessage(message);
}
bool CGUIWindowLoginScreen::OnMessage(CGUIMessage& message)
{
switch ( message.GetMessage() )
{
case GUI_MSG_WINDOW_DEINIT:
{
m_viewControl.Reset();
m_vecItems->Clear();
}
break;
case GUI_MSG_CLICKED:
{
int iControl = message.GetSenderId();
if (iControl == CONTROL_BIG_LIST)
{
int iAction = message.GetParam1();
// iItem is checked for validity inside these routines
if (iAction == ACTION_CONTEXT_MENU || iAction == ACTION_MOUSE_RIGHT_CLICK)
{
int iItem = m_viewControl.GetSelectedItem();
bool bResult = OnPopupMenu(m_viewControl.GetSelectedItem());
if (bResult)
{
Update();
CGUIMessage msg(GUI_MSG_ITEM_SELECT,GetID(),CONTROL_BIG_LIST,iItem);
OnMessage(msg);
}
return bResult;
}
else if (iAction == ACTION_SELECT_ITEM || iAction == ACTION_MOUSE_LEFT_CLICK)
{
int iItem = m_viewControl.GetSelectedItem();
bool bCanceled;
bool bOkay = g_passwordManager.IsProfileLockUnlocked(iItem, bCanceled);
if (bOkay)
{
LoadProfile(iItem);
}
else
{
if (!bCanceled && iItem != 0)
CGUIDialogOK::ShowAndGetInput(20068,20117,20022,20022);
}
}
}
}
break;
case GUI_MSG_SETFOCUS:
{
if (m_viewControl.HasControl(message.GetControlId()) && m_viewControl.GetCurrentControl() != message.GetControlId())
{
m_viewControl.SetFocused();
return true;
}
}
default:
break;
}
return CGUIWindow::OnMessage(message);
}
int CGUIDialogSmartPlaylistEditor::GetSelectedItem()
{
CGUIMessage message(GUI_MSG_ITEM_SELECTED, GetID(), CONTROL_RULE_LIST);
OnMessage(message);
return message.GetParam1();
}
void CGUIDialogSmartPlaylistEditor::UpdateButtons()
{
CONTROL_ENABLE(CONTROL_OK); // always enabled since we can have no rules -> match everything (as we do with default partymode playlists)
// if there's no rule available, add a dummy one the user can edit
if (m_playlist.m_ruleCombination.m_rules.size() <= 0)
m_playlist.m_ruleCombination.AddRule(CSmartPlaylistRule());
// name
if (m_mode == "partyvideo" || m_mode == "partymusic")
{
SET_CONTROL_LABEL2(CONTROL_NAME, g_localizeStrings.Get(16035));
CONTROL_DISABLE(CONTROL_NAME);
}
else
SET_CONTROL_LABEL2(CONTROL_NAME, m_playlist.m_playlistName);
UpdateRuleControlButtons();
CONTROL_ENABLE_ON_CONDITION(CONTROL_MATCH, m_playlist.m_ruleCombination.m_rules.size() > 1);
int currentItem = GetSelectedItem();
CGUIMessage msgReset(GUI_MSG_LABEL_RESET, GetID(), CONTROL_RULE_LIST);
OnMessage(msgReset);
m_ruleLabels->Clear();
for (unsigned int i = 0; i < m_playlist.m_ruleCombination.m_rules.size(); i++)
{
CFileItemPtr item(new CFileItem("", false));
if (m_playlist.m_ruleCombination.m_rules[i]->m_field == FieldNone)
item->SetLabel(g_localizeStrings.Get(21423));
else
item->SetLabel(std::static_pointer_cast<CSmartPlaylistRule>(m_playlist.m_ruleCombination.m_rules[i])->GetLocalizedRule());
m_ruleLabels->Add(item);
}
CGUIMessage msg(GUI_MSG_LABEL_BIND, GetID(), CONTROL_RULE_LIST, 0, 0, m_ruleLabels);
OnMessage(msg);
SendMessage(GUI_MSG_ITEM_SELECT, GetID(), CONTROL_RULE_LIST, currentItem);
if (m_playlist.m_orderDirection != SortOrderDescending)
{
CONTROL_SELECT(CONTROL_ORDER_DIRECTION);
}
else
{
CONTROL_DESELECT(CONTROL_ORDER_DIRECTION);
}
// sort out the order fields
std::vector< std::pair<std::string, int> > labels;
std::vector<SortBy> orders = CSmartPlaylistRule::GetOrders(m_playlist.GetType());
for (unsigned int i = 0; i < orders.size(); i++)
labels.push_back(make_pair(g_localizeStrings.Get(SortUtils::GetSortLabel(orders[i])), orders[i]));
SET_CONTROL_LABELS(CONTROL_ORDER_FIELD, m_playlist.m_orderField, &labels);
// setup groups
labels.clear();
std::vector<Field> groups = CSmartPlaylistRule::GetGroups(m_playlist.GetType());
Field currentGroup = CSmartPlaylistRule::TranslateGroup(m_playlist.GetGroup().c_str());
for (unsigned int i = 0; i < groups.size(); i++)
labels.push_back(make_pair(CSmartPlaylistRule::GetLocalizedGroup(groups[i]), groups[i]));
SET_CONTROL_LABELS(CONTROL_GROUP_BY, currentGroup, &labels);
if (m_playlist.IsGroupMixed())
CONTROL_SELECT(CONTROL_GROUP_MIXED);
else
CONTROL_DESELECT(CONTROL_GROUP_MIXED);
// disable the group controls if there's no group
// or only one group which can't be mixed
if (groups.size() == 0 ||
(groups.size() == 1 && !CSmartPlaylistRule::CanGroupMix(groups[0])))
{
CONTROL_DISABLE(CONTROL_GROUP_BY);
CONTROL_DISABLE(CONTROL_GROUP_MIXED);
}
else
{
CONTROL_ENABLE(CONTROL_GROUP_BY);
CONTROL_ENABLE_ON_CONDITION(CONTROL_GROUP_MIXED, CSmartPlaylistRule::CanGroupMix(currentGroup));
}
}
