random-mirrors
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Winamp/video.cpp

858 lines
23 KiB
C++
Raw Blame History

#include <windowsx.h>
#include "main.h"
#include <ddraw.h>
#include <multimon.h>
#include "api.h"
#include "vid_overlay.h"
#include "vid_ddraw.h"
#include "vid_subs.h"
#include "vid_none.h"
#include "VideoOutput.h"
#include "Browser.h"
#include "video.h"
#include "../nu/AutoWide.h"
#include "WinampAttributes.h"
#include "resource.h"
#define WM_VIDEO_UPDATE_STATUS_TEXT WM_USER+0x874
#define WM_VIDEO_OPEN WM_USER+0x875
#define WM_VIDEO_CLOSE WM_USER+0x876
#define WM_VIDEO_RESIZE WM_USER+0x877
#define WM_VIDEO_CREATE WM_USER+0x900
#define VIDEO_GENFF_SIZEREQUEST (WM_USER+2048)
#undef GetSystemMetrics
#define INIT_DIRECTDRAW_STRUCT(x) (ZeroMemory(&x, sizeof(x)), x.dwSize=sizeof(x))
VideoOutput *m_videooutput = NULL;
static int VW_OnLButtonUp(HWND hwnd, int x, int y, UINT flags);
static int VW_OnRButtonUp(HWND hwnd, int x, int y, UINT flags);
static int VW_OnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
static int VW_OnMouseMove(HWND hwnd, int x, int y, UINT keyFlags);
static int VW_OnLButtonDblClk(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
static BOOL VW_OnNCActivate(HWND hwnd, BOOL fActive, HWND hwndActDeact, BOOL fMinimized);
extern "C" int g_video_numaudiotracks;
extern "C" int is_fullscreen_video = 0;
extern "C" int no_notify_play;
extern "C" int last_no_notify_play;
#undef GetSystemMetrics
bool sizeOnOpen = false;
int widthOnOpen, heightOnOpen;
#define VideoClassicWidth() 19
#define VideoClassicHeight() 58
static void VideoClose();
/* Resizes the windows (parent and children) based on what the size of the video should be */
static void SetVideoSize(int width, int height)
{
if (m_videooutput && m_videooutput->is_fullscreen()) // fullscreen
{
m_videooutput->SetVideoPosition(0, 0, config_video_width, config_video_height);
}
else // not fullscreen
{
// send out ideal video size message (in case anyone wants it)
PostMessageW(hMainWindow, WM_WA_IPC, (((width) & 0xFFFF) << 16) | ((height) & 0xFFFF), IPC_SETIDEALVIDEOSIZE);
if (GetParent(hVideoWindow)) // if gen_ff owns the window, then signal it about the video size
PostMessageW(GetParent(hVideoWindow), VIDEO_GENFF_SIZEREQUEST, width, height);
else // classic skin
SetWindowPos(hVideoWindow, 0, 0, 0, width + VideoClassicWidth(), height + VideoClassicHeight(), SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
}
}
/* Resizes the windows (parent and children) based on what the size of the parent should be */
void SetExteriorSize(int width, int height)
{
// calculate interior size
width -= VideoClassicWidth();
height -= VideoClassicHeight();
// pass our calculated value onto the size routine
SetVideoSize(width, height);
}
/* lays out children (video and ad) based on a given parent window size */
static void LayoutChildren(int width, int height)
{
if (m_videooutput && m_videooutput->is_fullscreen()) // fullscreen
{
m_videooutput->SetVideoPosition(0, 0, config_video_width, config_video_height);
}
else // not fullscreen
{
// calculate interior size
width -= VideoClassicWidth();
height -= VideoClassicHeight();
// size the video
if (m_videooutput)
{
m_videooutput->SetVideoPosition(11, 20, width, height);
InvalidateRect(m_videooutput->getHwnd(), 0, TRUE); // force repaint of video
}
InvalidateRect(hVideoWindow, 0, TRUE); // force repaint of parent window
}
}
/* Resizes the windows (parent and children) based on what the size of the parent should be
Sets the position of the parent window */
static void SetExteriorSizeAndPosition(int x, int y, int width, int height)
{
config_video_wx = x;
config_video_wy = y;
SetExteriorSize(width, height);
}
void updateTrackSubmenu()
{
HMENU menu = GetSubMenu(GetSubMenu(top_menu, 3), 13);
HMENU audiomenu = GetSubMenu(menu, 6);
HMENU videomenu = GetSubMenu(menu, 7);
static int audioadded = 0;
static int videoadded = 0;
static int first = 1;
if (first)
{
RemoveMenu(audiomenu, ID_VID_AUDIO0, MF_BYCOMMAND);
RemoveMenu(videomenu, ID_VID_VIDEO0, MF_BYCOMMAND);
first = 1;
}
if (audioadded)
{
for (int i = 0;i < 16;i++)
{
RemoveMenu(audiomenu, ID_VID_AUDIO0 + i, MF_BYCOMMAND);
}
audioadded = 0;
}
if (videoadded)
{
for (int i = 0;i < 16;i++)
{
RemoveMenu(videomenu, ID_VID_VIDEO0 + i, MF_BYCOMMAND);
}
videoadded = 0;
}
VideoOutput *out = (VideoOutput *)video_getIVideoOutput();
if (!out || !out->getTrackSelector())
{
EnableMenuItem(menu, 8, MF_GRAYED | MF_BYPOSITION);
EnableMenuItem(menu, 9, MF_GRAYED | MF_BYPOSITION);
return ;
}
ITrackSelector *sel = out->getTrackSelector();
int numaudiotracks = sel->getNumAudioTracks();
if (numaudiotracks < 2)
{
EnableMenuItem(menu, 8, MF_GRAYED | MF_BYPOSITION);
}
else
{
audioadded = 1;
int curtrack = sel->getCurAudioTrack();
for (int i = 0;i < numaudiotracks;i++)
{
char t[256] = {0};
sel->enumAudioTrackName(i, t, 255);
InsertMenuA(audiomenu, i, MF_BYPOSITION, ID_VID_AUDIO0 + i, t);
CheckMenuItem(audiomenu, ID_VID_AUDIO0 + i, ((i == curtrack) ? MF_CHECKED : MF_UNCHECKED) | MF_BYCOMMAND);
}
EnableMenuItem(menu, 8, MF_ENABLED | MF_BYPOSITION);
}
int numvideotracks = sel->getNumVideoTracks();
if (numvideotracks < 2)
{
EnableMenuItem(menu, 9, MF_GRAYED | MF_BYPOSITION);
}
else
{
videoadded = 1;
int curtrack = sel->getCurVideoTrack();
for (int i = 0;i < numvideotracks;i++)
{
char t[256] = {0};
sel->enumVideoTrackName(i, t, 255);
InsertMenuA(videomenu, i, MF_BYPOSITION, ID_VID_VIDEO0 + i, t);
CheckMenuItem(videomenu, ID_VID_VIDEO0 + i, ((i == curtrack) ? MF_CHECKED : MF_UNCHECKED) | MF_BYCOMMAND);
}
EnableMenuItem(menu, 9, MF_ENABLED | MF_BYPOSITION);
}
}
int ShowVideoWindow(int init_state)
{
sizeOnOpen = false;
if (config_video_open // if we're already open
|| !hVideoWindow // or we havn't made the video window yet
|| !g_has_video_plugin // or we're configured to not have video
|| !Ipc_WindowToggle(IPC_CB_WND_VIDEO, 1)) // or some plugin doesn't want us to open the video window
return 0; // then bail out
CheckMenuItem(main_menu, WINAMP_OPTIONS_VIDEO, MF_CHECKED);
if(!init_state && !config_minimized) ShowWindow(hVideoWindow, SW_SHOWNA);
//ad->show(true);
config_video_open = 1;
set_aot(1);
return 1;
}
void HideVideoWindow(int autoStop)
{
sizeOnOpen = false;
if (!config_video_open // if we're not even open
|| !hVideoWindow // or we havn't made the video window yet
// || !g_has_video_plugin // or we're configured to not have video
|| !Ipc_WindowToggle(IPC_CB_WND_VIDEO, !config_video_open)) // or some plugin doesn't want us to close the video window
return ; // then bail out
if (GetForegroundWindow() == hVideoWindow || IsChild(hVideoWindow, GetForegroundWindow()))
{
SendMessageW(hMainWindow, WM_COMMAND, WINAMP_NEXT_WINDOW, 0);
}
CheckMenuItem(main_menu, WINAMP_OPTIONS_VIDEO, MF_UNCHECKED);
ShowWindow(hVideoWindow, SW_HIDE);
config_video_open = 0;
if (autoStop && config_video_stopclose && !(GetAsyncKeyState(VK_SHIFT)&0x8000) && video_isVideoPlaying())
{
PostMessageW(hMainWindow, WM_COMMAND, WINAMP_BUTTON4, 0);
}
}
HMENU BuildPopupMenu();
void Vid_Cmd(windowCommand *wc)
{
switch (wc->cmd)
{
case VIDCMD_FULLSCREEN:
videoGoFullscreen();
break;
case VIDCMD_1X:
SendMessageW(videoGetHwnd(), WM_COMMAND, ID_VIDEOWND_ZOOM100, 0);
break;
case VIDCMD_2X:
SendMessageW(videoGetHwnd(), WM_COMMAND, ID_VIDEOWND_ZOOM200, 0);
break;
case VIDCMD_LIB:
SendMessageW(videoGetHwnd(), WM_COMMAND, WINAMP_VIDEO_TVBUTTON, 0);
break;
case VIDPOPUP_MISC:
DoTrackPopup(BuildPopupMenu(), wc->align, wc->x, wc->y, videoGetHwnd());
break;
case VIDCMD_EXIT_FS:
videoForceFullscreenOff();
break;
}
}
static int VW_OnRButtonUp(HWND hwnd, int x, int y, UINT flags)
{
POINT p;
extern HMENU top_menu;
GetCursorPos(&p);
DoTrackPopup(main_menu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, p.x, p.y, hMainWindow);
return 1;
}
static int VW_OnLButtonUp(HWND hwnd, int x, int y, UINT flags)
{
ReleaseCapture();
videoui_handlemouseevent(x, y, -1, flags);
return 1;
}
static int VW_OnLButtonDown( HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags )
{
SetCapture( hwnd );
videoui_handlemouseevent( x, y, 1, keyFlags );
SetFocus( hwnd );
return 1;
}
static int VW_OnMouseMove(HWND hwnd, int x, int y, UINT keyFlags)
{
videoui_handlemouseevent(x, y, 0, keyFlags);
return 1;
}
static BOOL VW_OnNCActivate( HWND hwnd, BOOL fActive, HWND hwndActDeact, BOOL fMinimized )
{
if ( !m_videooutput || ( m_videooutput && !m_videooutput->is_fullscreen() ) )
{
if ( fActive == FALSE )
draw_vw_tbar( config_hilite ? 0 : 1 );
else
draw_vw_tbar( 1 );
}
return TRUE;
}
static int VW_OnLButtonDblClk(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
{
return 1;
}
/*Turns off and on the screensaver*/
VOID CALLBACK ResetScreenSaver(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
// benski> this seems less hackish. only win2k and up
if (config_video_noss && video_isVideoPlaying())
SetThreadExecutionState(ES_DISPLAY_REQUIRED);
// TODO: maybe we should do the same thing with ES_SYSTEM_REQUIRED to keep the system from snoozing
// benski> old code was here
/*
BOOL b;
if (config_video_noss && video_isVideoPlaying() && SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, &b, 0) && b)
{
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 0, 0, 0); // turn off
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 1, 0, 0); // turn back on
// this is just a hack
// basically by toggling off and on we reset the timeout count
}
*/
}
static void VideoOpen(HWND hwnd, int width, int height)
{
sizeOnOpen=false;
// check if we appear to be doing a resume from a tag edit
// and if so then we need to ignore the show window option
if (config_video_autoopen &&
((no_notify_play != last_no_notify_play && !last_no_notify_play) || (no_notify_play == last_no_notify_play)))
ShowVideoWindow(0);
last_no_notify_play = no_notify_play;
HWND skinVidWindow = GetParent(hwnd) ? GetParent(hwnd) : hwnd;
if (m_videooutput->is_fullscreen() || config_video_auto_fs) // go fullscreen
{
videoGoFullscreen();
InvalidateRect(m_videooutput->getHwnd(), 0, TRUE);
}
else // not fullscreen
{
if (config_video_updsize)
{
widthOnOpen = width;
heightOnOpen = height;
sizeOnOpen = true;
SetVideoSize(width, height);
}
LayoutChildren(config_video_width, config_video_height);
if (!IsIconic(skinVidWindow))
BringWindowToTop(skinVidWindow);
InvalidateRect(hwnd, 0, TRUE);
}
}
LRESULT CALLBACK video_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (uMsg == g_scrollMsg) { wParam <<= 16; uMsg = WM_MOUSEWHEEL; }
if (uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDOWN || uMsg == WM_RBUTTONUP || uMsg == WM_MOUSEMOVE)
if (!m_videooutput || !m_videooutput->is_fullscreen())
{
switch (uMsg)
{
HANDLE_MSG(hwnd, WM_LBUTTONUP, VW_OnLButtonUp);
HANDLE_MSG(hwnd, WM_LBUTTONDOWN, VW_OnLButtonDown);
HANDLE_MSG(hwnd, WM_MOUSEMOVE, VW_OnMouseMove);
HANDLE_MSG(hwnd, WM_RBUTTONUP, VW_OnRButtonUp);
}
}
switch (uMsg)
{
case WM_USER + 1:
if (m_videooutput)
SendMessageW(m_videooutput->getHwnd(), uMsg, wParam, lParam);
break;
case WM_USER + 2:
if (sizeOnOpen)
{
// sizeOnOpen=false;
PostMessageW(hwnd, WM_VIDEO_RESIZE, widthOnOpen, heightOnOpen);
}
if (m_videooutput)
SendMessageW(m_videooutput->getHwnd(), uMsg, wParam, lParam);
break;
case WM_USER + 0x100:
if (wParam == 1 && lParam)
{
config_video_wx = ((POINT *)lParam)->x;
config_video_wy = ((POINT *)lParam)->y;
if ((!!config_snap) ^ (!!(GetKeyState(VK_SHIFT) & 0x8000)))
{
RECT outrc;
EstVidWindowRect(&outrc);
SnapWindowToAllWindows(&outrc, hVideoWindow);
SetVidWindowRect(&outrc);
}
SetWindowPos(hVideoWindow, 0, config_video_wx, config_video_wy, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
}
return 0;
case WM_TIMER:
switch (wParam)
{
case 12345: // signal from elsewhere
if (m_videooutput)
SendMessageW(m_videooutput->getHwnd(), WM_TIMER, 0, 0);
break;
}
return 0;
case WM_WINDOWPOSCHANGING:
case WM_WINDOWPOSCHANGED: // we trap both windowposchanging and windowposchanged incase someone uses SetWindowPos(..., SWP_NOSENDCHANGING)
{
LPWINDOWPOS windowPos = (LPWINDOWPOS) lParam;
if (windowPos->flags & SWP_NOSIZE)
{
break;
}
if (uMsg == WM_WINDOWPOSCHANGED)
{
config_video_width = windowPos->cx;
config_video_height = windowPos->cy;
LayoutChildren(config_video_width, config_video_height);
// update the position of the tooltips on window resize
set_vid_wnd_tooltip();
}
}
break;
case WM_NOTIFY:
{
LPTOOLTIPTEXT tt = (LPTOOLTIPTEXT)lParam;
if(tt->hdr.hwndFrom = hVideoTooltipWindow)
{
switch (tt->hdr.code)
{
case TTN_SHOW:
SetWindowPos(tt->hdr.hwndFrom,HWND_TOPMOST,0,0,0,0,SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE);
break;
}
}
}
break;
case WM_GETMINMAXINFO:
{
MINMAXINFO *p = (MINMAXINFO *)lParam;
p->ptMaxTrackSize.x = 16384;
p->ptMaxTrackSize.y = 16384;
}
return 0;
case WM_VIDEO_RESIZE:
//ReplyMessage(0); // if IVideoOutput::open() was called on a different thread, this will unblock it.
{
int width = wParam;
int height = lParam;
// idealWidth = wParam;
SetVideoSize(width, height);
LayoutChildren(config_video_width, config_video_height);
}
return 0;
case WM_DESTROY:
if (NULL != WASABI_API_APP) WASABI_API_APP->app_unregisterGlobalWindow(hwnd);
if (vw_init)
draw_vw_kill();
break;
case WM_DISPLAYCHANGE:
InvalidateRect(hwnd, NULL, TRUE);
break;
case WM_VIDEO_OPEN:
VideoOpen(hwnd, wParam, lParam);
// set_aot(1);
return 0;
break;
case WM_VIDEO_CREATE:
m_videooutput->mainthread_Create();
break;
case WM_VIDEO_CLOSE:
VideoClose();
InvalidateRect(hwnd, NULL, TRUE); //repaint
return 0;
case WM_VIDEO_UPDATE_STATUS_TEXT:
if (m_videooutput && !m_videooutput->is_fullscreen())
draw_vw_info((wchar_t*)wParam, 1);
videoTextFeed->UpdateText((const wchar_t*)wParam, 1024);
return 0;
case WM_MOUSEWHEEL:
return SendMessageW(hMainWindow, uMsg, wParam, lParam);
HANDLE_MSG(hwnd, WM_QUERYNEWPALETTE, Main_OnQueryNewPalette);
HANDLE_MSG(hwnd, WM_PALETTECHANGED, Main_OnPaletteChanged);
HANDLE_MSG(hwnd, WM_NCACTIVATE, VW_OnNCActivate);
HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK, VW_OnLButtonDblClk);
case WM_CONTEXTMENU:
{
if (lParam == MAKELONG(-1, -1))
{
extern HMENU top_menu;
RECT r;
GetWindowRect(videoGetHwnd(), &r);
DoTrackPopup(BuildPopupMenu(), TPM_LEFTALIGN | TPM_RIGHTBUTTON, r.left, r.top, videoGetHwnd());
}
}
return 0;
case WM_KEYDOWN: case WM_KEYUP: case WM_SYSKEYDOWN: case WM_SYSKEYUP:
if ((GetAsyncKeyState(VK_CONTROL)&0x8000) && wParam == VK_F4)
{
if (uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN)
SendMessageW(hMainWindow, WM_COMMAND, WINAMP_OPTIONS_VIDEO, 0);
}
/* else if(uMsg==WM_SYSKEYDOWN && (LPARAM&(1<<29)) && wParam == VK_RETURN)
{
if (m_videooutput)
{
if(!m_videooutput->is_fullscreen()) m_videooutput->fullscreen();
else m_videooutput->remove_fullscreen();
}
}*/
else
{
if (SendMessageW(m_videooutput->getHwnd(), uMsg, wParam, lParam)) return 0;
if (wParam != VK_RETURN && m_videooutput->is_fullscreen() && ((GetAsyncKeyState(VK_CONTROL) | GetAsyncKeyState(VK_MENU))&0x8000)) return 0;
{
MSG winmsg;
winmsg.message = uMsg;
winmsg.hwnd = hMainWindow;
winmsg.wParam = wParam;
winmsg.lParam = lParam;
if (WASABI_API_APP->app_translateAccelerators(&winmsg)) return 0;
//if (transAccel(hwnd,uMsg,wParam,lParam)) return 0;
//transAccelStruct tas = {hwnd, uMsg, wParam, lParam};
//if (SendMessageW(hMainWindow, WM_WA_IPC, (WPARAM)&tas, IPC_TRANSLATEACCELERATOR)) return 0;
}
}
break;
case WM_DROPFILES:
return SendMessageW(hMainWindow, uMsg, wParam, lParam);
case WM_SHOWWINDOW:
if (wParam == TRUE) // showing
{
if (sizeOnOpen)
{
//sizeOnOpen=false;
PostMessageW(hwnd, WM_VIDEO_RESIZE, widthOnOpen, heightOnOpen);
}
if (!IsIconic(hwnd))
BringWindowToTop(hwnd);
LayoutChildren(config_video_width, config_video_height);
}
RefreshIconicThumbnail();
/*
{
// if extra_data[EMBED_STATE_EXTRA_REPARENTING] is set, we are being reparented by the freeform lib, so we should
// just ignore this message because our visibility will not change once the freeform
// takeover/restoration is complete
embedWindowState *ws = (embedWindowState *)GetWindowLongW(hwnd, GWL_USERDATA);
if (ws != NULL && ws->extra_data[EMBED_STATE_EXTRA_REPARENTING])
{
}
}
*/
break;
case WM_CLOSE:
if (!m_videooutput || !m_videooutput->is_fullscreen())
WASABI_API_APP->main_shutdown();
else
m_videooutput->remove_fullscreen();
return 0;
case WM_PAINT:
if (!m_videooutput || !m_videooutput->is_fullscreen())
{
draw_paint_vw(hwnd);
return 0;
}
break;
case WM_CREATE:
hVideoWindow = hwnd;
SetTimer(hwnd, 32, 15000, ResetScreenSaver);
SetWindowLongPtrW(hwnd, GWLP_USERDATA, (config_keeponscreen&2) ? 0x49474541 : 0);
SetWindowLongW(hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE)&~(WS_CAPTION));
SetWindowPos(hVideoWindow, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
//ad->CreateHWND(hwnd);
m_videooutput = new VideoOutput(hwnd);
if (!config_minimized)
ShowWindow(m_videooutput->getHwnd(), SW_SHOWNA);
SetExteriorSizeAndPosition(config_video_wx, config_video_wy, config_video_width, config_video_height);
LayoutChildren(config_video_width, config_video_height);
if (NULL != WASABI_API_APP) WASABI_API_APP->app_registerGlobalWindow(hwnd);
return 0;
case WM_COMMAND:
return SendMessageW(hMainWindow, uMsg, wParam, lParam);
case WM_MOVE:
if (m_videooutput)
SendMessageW(m_videooutput->getHwnd(), WM_MOVE, 0, 0);
return 0;
case WM_SETCURSOR:
if (config_usecursors && !disable_skin_cursors)
{
#define inreg(x,y,x2,y2) \
((mouse_x <= ( x2 ) && mouse_x >= ( x ) && \
mouse_y <= ( y2 ) && mouse_y >= ( y )))
if (((HWND)wParam == hVideoWindow || IsChild(hVideoWindow, (HWND)wParam)) && HIWORD(lParam) == WM_MOUSEMOVE)
{
int mouse_x, mouse_y;
POINT p;
static RECT b[] =
{
{ -(275 - 264), 3, -(275 - 272), 12}, //close
{0, 0, -1, 13}, // titelbar
{ -20, -20, -1, -1},
};
int iconoffs[] = {15 + 1, 15 + 2, 15 + 4, 15 + 5};
int b_len = 3;
int x;
GetCursorPos(&p);
ScreenToClient(hVideoWindow, &p);
mouse_x = p.x;
mouse_y = p.y;
for (x = 0; x < b_len; x ++)
{
int l, r, t, bo;
l = b[x].left;r = b[x].right;t = b[x].top;bo = b[x].bottom;
if (l < 0) l += config_video_width;
if (r < 0) r += config_video_width;
if (t < 0) t += config_video_height;
if (bo < 0) bo += config_video_height;
if (inreg(l, t, r, bo)) break;
}
if (Skin_Cursors[iconoffs[x]]) SetCursor(Skin_Cursors[iconoffs[x]]);
else SetCursor(LoadCursorW(NULL, IDC_ARROW));
}
return TRUE;
}
else SetCursor(LoadCursorW(NULL, IDC_ARROW));
return TRUE;
case WM_SYSCOMMAND:
// eat screen saver message when fullscreen
if (((wParam & 0xfff0) == SC_SCREENSAVE || (wParam & 0xfff0) == SC_MONITORPOWER) && config_video_noss &&
video_isVideoPlaying())
{
return -1;
}
break;
}
if (FALSE != IsDirectMouseWheelMessage(uMsg))
{
SendMessageW(hwnd, WM_MOUSEWHEEL, wParam, lParam);
return TRUE;
}
return DefWindowProcW(hwnd, uMsg, wParam, lParam);
}
static void VideoClose()
{
sizeOnOpen=false;
if (!g_has_video_plugin)
return ;
if (m_videooutput && m_videooutput->is_fullscreen() && config_video_remove_fs_on_stop)
videoForceFullscreenOff();
if ((!m_videooutput && (bool)config_video_autoclose)
|| (m_videooutput && !m_videooutput->is_fullscreen() && (bool)config_video_autoclose))
HideVideoWindow(false);
}
extern "C"
{
void videoAdSizeChanged()
{
LayoutChildren(config_video_width, config_video_height);
}
void *video_getIVideoOutput()
{
return (void *)m_videooutput;
}
int video_isVideoPlaying()
{
if (!m_videooutput) return 0;
return m_videooutput->isVideoPlaying();
}
void videoGoFullscreen()
{
if (m_videooutput)
{
m_videooutput->fullscreen();
}
}
int videoIsFullscreen()
{
if (m_videooutput) return !!m_videooutput->is_fullscreen();
return 0;
}
void videoReinit()
{
if (m_videooutput)
PostMessageW(m_videooutput->getHwnd(), WM_USER + 0x1, 0, 0);
}
void videoForceFullscreenOff()
{
if (m_videooutput)
{
m_videooutput->remove_fullscreen();
LayoutChildren(config_video_width, config_video_height);
}
}
void videoToggleFullscreen()
{
if (m_videooutput)
{
if (!m_videooutput->is_fullscreen())
videoGoFullscreen();
else
videoForceFullscreenOff();
}
}
void videoSetFlip(int on)
{
if (m_videooutput)
{
m_videooutput->extended(VIDUSER_SET_VFLIP, on, 0);
}
// for consistency we need to update the state on the prefs page
if(prefs_last_page == 24 && IsWindow(prefs_hwnd))
{
SendMessageW(prefs_hwnd, WM_USER + 33, IDC_PREFS_VIDEO_FLIPRGB, on);
}
CheckMenuItem(GetSubMenu(GetSubMenu(top_menu, 3), 13), ID_VIDEOWND_VERTICALLYFLIP, (on ? MF_CHECKED: MF_UNCHECKED));
}
DWORD videoGetWidthHeightDWORD()
{
if (!m_videooutput) return 0;
return m_videooutput->GetWidthHeightDWORD();
}
HWND videoGetHwnd()
{
if (m_videooutput) return m_videooutput->getHwnd();
return NULL;
}
int video_getNumAudioTracks()
{
VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
if (!vid) return 1;
ITrackSelector *sel = vid->getTrackSelector();
if (!sel) return 1;
return sel->getNumAudioTracks();
}
int video_getNumVideoTracks()
{
VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
if (!vid) return 1;
ITrackSelector *sel = vid->getTrackSelector();
if (!sel) return 1;
return sel->getNumVideoTracks();
}
int video_getCurAudioTrack()
{
VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
if (!vid) return 0;
ITrackSelector *sel = vid->getTrackSelector();
if (!sel) return 0;
return sel->getCurAudioTrack();
}
int video_getCurVideoTrack()
{
VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
if (!vid) return 0;
ITrackSelector *sel = vid->getTrackSelector();
if (!sel) return 0;
return sel->getCurVideoTrack();
}
int video_setCurAudioTrack(int track)
{
VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
if (!vid) return 0;
ITrackSelector *sel = vid->getTrackSelector();
if (!sel) return 0;
sel->setAudioTrack(track);
return sel->getCurAudioTrack();
}
int video_setCurVideoTrack(int track)
{
VideoOutput *vid = (VideoOutput *)video_getIVideoOutput();
if (!vid) return 0;
ITrackSelector *sel = vid->getTrackSelector();
if (!sel) return 0;
sel->setVideoTrack(track);
return sel->getCurVideoTrack();
}
HWND video_Create()
{
return CreateWindowExW(WS_EX_ACCEPTFILES, L"Winamp Video", getStringW(IDS_VIDEOCAPTION, NULL, 0), (WS_OVERLAPPED | WS_CLIPCHILDREN)&(~WS_CAPTION),
config_video_wx, config_video_wy, config_video_width, config_video_height,
hMainWindow, NULL, GetModuleHandle(NULL), NULL);
}
}
Reference in New Issue View Git Blame Copy Permalink