backup
/
gps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
gps/GPSResources/tcpmpVerOld/interface/win32/interface.c

3383 lines
86 KiB
C
Executable File
Raw Permalink Blame History

/*****************************************************************************
*
* This program is free software ; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id: interface.c 624 2006-02-01 17:48:42Z picard $
*
* The Core Pocket Media Player
* Copyright (c) 2004-2005 Gabor Kovacs
*
****************************************************************************/
#include "../../common/common.h"
#include "../win.h"
#include "interface.h"
#include "resource.h"
#include "openfile_win32.h"
#include "../about.h"
#include "../benchresult.h"
#include "../mediainfo.h"
#include "../settings.h"
#include "playlst.h"
#include "../skin.h"
#include "../../config.h"
#define CORETHEQUE_UI_ID FOURCC('C','T','Q','U')
#if defined(TARGET_WINCE) || defined(TARGET_WIN32)
#ifndef STRICT
#define STRICT
#endif
#include <windows.h>
#if _MSC_VER > 1000
#pragma warning(disable : 4201)
#endif
#include <commctrl.h>
#define REG_INITING 0x2400
#define TIMER_CLIPPING 500
#define TIMER_INITING 501
#define TIMER_SLEEP 502
#define TIMER_KEYINSEEK 503
#define TIMER_SLIDERINSEEK 504
#define TIMER_SLIDERINVOL 505
#define TIMER_CLIPPING2 506
#define TIMER_TITLESCROLL 507
#define SLIDERINSEEK_CYCLE 250
#define SLIDERINVOL_CYCLE 100
#define KEYINSEEK_START 1000
#define KEYINSEEK_REPEAT 500
#define CLIPPING_CYCLE 200
#define INITING_CYCLE 3000
#define SLEEP_CYCLE 5000
#define CLIPPING2_CYCLE 200
#define TITLESCROLL_CYCLE 150
#define TITLESCROLL_WAIT (4000/TITLESCROLL_CYCLE)
#define TRACKMAX 30000
#define TRACKHEIGHT 16
#define TRACKTHUMB 12
#define TITLEHEIGHT 16
#define TITLEFONT 11
#define VOLMINWIDTH 35
#define VOLTHUMB 12
#define IF_AUDIO 50000
#define IF_VIDEO 51000
#define IF_VIDEOACCEL 52000
#define IF_CHAPTER 53000
#define IF_STREAM_AUDIO 54000
#define IF_STREAM_VIDEO 55000
#define IF_STREAM_SUBTITLE 56000
static int HotKey[] =
{
IF_FILE_OPENFILE,
IF_FILE_PLAYLIST,
IF_PLAY,
IF_PLAYPAUSE,
IF_PLAY_FULLSCREEN,
IF_STOP,
IF_MOVE_FFWD,
IF_MOVE_BACK,
IF_NEXT,
IF_PREV,
IF_PREV_SMART,
IF_NEXT2,
IF_PREV_SMART2,
IF_FASTFORWARD,
IF_OPTIONS_VOLUME_UP,
IF_OPTIONS_VOLUME_DOWN,
IF_OPTIONS_VOLUME_UP_FINE,
IF_OPTIONS_VOLUME_DOWN_FINE,
IF_OPTIONS_MUTE,
IF_OPTIONS_EQUALIZER,
IF_OPTIONS_FULLSCREEN,
IF_OPTIONS_ZOOM_FIT,
IF_OPTIONS_ZOOM_IN,
IF_OPTIONS_ZOOM_OUT,
IF_OPTIONS_ROTATE,
IF_OPTIONS_BRIGHTNESS_UP,
IF_OPTIONS_BRIGHTNESS_DOWN,
IF_OPTIONS_CONTRAST_UP,
IF_OPTIONS_CONTRAST_DOWN,
IF_OPTIONS_SATURATION_UP,
IF_OPTIONS_SATURATION_DOWN,
IF_OPTIONS_TOGGLE_VIDEO,
IF_OPTIONS_TOGGLE_AUDIO,
//!SUBTITLE IF_OPTIONS_TOGGLE_SUBTITLE,
IF_OPTIONS_AUDIO_STEREO_TOGGLE,
IF_OPTIONS_SCREEN,
IF_FILE_EXIT,
};
#define HOTKEYCOUNT (sizeof(HotKey)/sizeof(int))
typedef struct intface
{
win Win;
DWORD ThreadId;
player* Player;
node* Color;
node* Equalizer;
WNDPROC DefTrackProc;
WNDPROC DefVolProc;
HWND WndTrack;
HWND WndTitle;
HWND WndVol;
HWND WndVolBack;
int TrackThumb;
RECT ClientRect;
rect SkinViewport;
rect SkinArea;
rect Viewport;
int InSkin;
bool_t InVol;
bool_t InSeek;
bool_t Capture;
bool_t ForceFullScreen;
bool_t TrackBar;
bool_t TitleBar;
bool_t TaskBar;
bool_t Buttons;
bool_t Focus;
bool_t Clipping;
bool_t Overlap;
bool_t VolResizeNeeded;
bool_t VolResizeNeeded2;
bool_t Exited;
POINT Offset;
bool_t Bench;
bool_t Wait;
bool_t CmdLineMode;
int Vol;
int HotKey[HOTKEYCOUNT];
// refresh states
int TrackSetPos;
int TrackPos;
bool_t Play;
bool_t FFwd;
bool_t FullScreen;
bool_t Mute;
HFONT TitleFont;
int TitleFontSize;
tick_t TitleTime;
int TitleTimeWidth;
int TitleNameWidth;
int TitleNameSize;
int TitleNameOffset;
int ScrollMode;
bool_t UpdateScroll;
int TitleDurWidth;
int TitleBorder;
int TitleTop;
int TitleWidth;
int TitleHeight;
HBRUSH TitleBrush;
rgbval_t TitleFace;
rgbval_t TitleText;
tchar_t TitleName[256];
tchar_t TitleDur[32];
int MenuPreAmp;
int MenuStreams;
int MenuAStream;
int MenuVStream;
int MenuSubStream;
array VOutput;
array AOutput;
bool_t AllKeys;
bool_t AllKeysWarning;
int SkinNo;
skin Skin[MAX_SKIN];
tchar_t SkinPath[MAXPATH];
} intface;
static void ResizeVolume(intface* p)
{
if (p->WndVolBack)
{
RECT rv;
RECT r;
POINT o;
int Width;
int i;
GetClientRect(p->Win.WndTB,&r);
if (r.left<r.right)
{
SendMessage(p->Win.WndTB,TB_GETRECT,IF_OPTIONS_MUTE,(LPARAM)&rv);
#if defined(TARGET_WINCE)
if (p->Win.ToolBarHeight) // decrease width by 'X' button on right
r.right = max(r.left,r.right-(rv.right-rv.left));
#endif
Width = r.right-rv.right;
if (Width < 16)
Width = 16;
i = WinUnitToPixelX(&p->Win,50);
if (Width > i)
Width = i;
o.x = o.y = 0;
if (!p->Win.ToolBarHeight)
ClientToScreen(p->Win.WndTB,&o);
MoveWindow(p->WndVolBack,rv.right+o.x,o.y+1,Width,r.bottom-1,TRUE);
GetClientRect(p->WndVolBack,&r);
i = WinUnitToPixelX(&p->Win,2);
MoveWindow(p->WndVol,-i,0,r.right+2*i,r.bottom,TRUE);
SendMessage(p->WndVol, TBM_SETTHUMBLENGTH,WinUnitToPixelY(&p->Win,VOLTHUMB),0);
}
}
}
static bool_t Toggle(intface* p,int Param,int Force);
static void UpdateVolume(intface* p);
static void UpdateClipping(intface* p,bool_t Suggest,bool_t HotKey);
static void ShowVol(intface* p,bool_t Show)
{
if (p->WndVolBack && !p->Win.ToolBarHeight)
{
if (Show)
SetWindowPos(p->WndVolBack,HWND_TOPMOST,0,0,0,0,SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_SHOWWINDOW);
else
ShowWindow(p->WndVolBack,SW_HIDE);
if (p->VolResizeNeeded2>1)
p->VolResizeNeeded2=1;
}
}
static void Resize(intface* p)
{
RECT r;
bool_t Rotated = IsOrientationChanged();
DEBUG_MSG(DEBUG_VIDEO,T("Resize begin"));
if (Rotated)
{
p->Player->Set(p->Player,PLAYER_ROTATEBEGIN,NULL,0);
p->Player->Set(p->Player,PLAYER_RESETVIDEO,NULL,0);
if (!p->Win.ToolBarHeight)
{
p->VolResizeNeeded2 = 1; // toolbar position may change later
if (p->WndVolBack && IsWindowVisible(p->WndVolBack))
{
ShowVol(p,0);
p->VolResizeNeeded2 = 2;
}
}
else
p->VolResizeNeeded = 1;
if (p->Win.FullScreen)
PostMessage(p->Win.Wnd,MSG_PLAYER,PLAYER_FULLSCREEN,0);
}
p->Offset.x = 0;
p->Offset.y = 0;
ClientToScreen(p->Win.Wnd,&p->Offset);
if (!p->Win.FullScreen)
{
#if !defined(TARGET_WINCE) && defined(MAXIMIZE_FULLSCREEN)
WINDOWPLACEMENT Place;
Place.length = sizeof(Place);
GetWindowPlacement(p->Win.Wnd,&Place);
if (Place.showCmd != SW_MAXIMIZE)
#endif
{
GetClientRect(p->Win.Wnd,&r);
if (r.right != p->ClientRect.right || r.bottom != p->ClientRect.bottom)
{
bool_t Skin = p->Skin[p->SkinNo].Valid;
int TrackThumb;
int TrackHeight = 0;
p->TitleHeight = 0;
p->ClientRect = r;
r.top += p->Win.ToolBarHeight;
if (p->WndTrack)
{
TrackHeight = WinUnitToPixelY(&p->Win,TRACKHEIGHT);
r.bottom -= TrackHeight;
MoveWindow(p->WndTrack,r.left,r.bottom,r.right,TrackHeight,TRUE);
TrackThumb = WinUnitToPixelY(&p->Win,TRACKTHUMB);
if (p->TrackThumb != TrackThumb)
{
p->TrackThumb = TrackThumb; // avoid calling this regulary because it shows the trackbar
SendMessage(p->WndTrack, TBM_SETTHUMBLENGTH,TrackThumb,0);
}
}
if (p->WndTitle)
{
p->TitleTimeWidth = 0;
p->TitleFontSize = TITLEFONT;
p->TitleFont = WinFont(&p->Win,&p->TitleFontSize,0);
p->TitleHeight = WinUnitToPixelY(&p->Win,TITLEHEIGHT);
p->TitleBorder = WinUnitToPixelX(&p->Win,3);
p->TitleWidth = r.right - r.left;
if (Skin)
{
skinitem* i = &p->Skin[p->SkinNo].Item[SKIN_TITLE];
p->TitleWidth = i->Rect.Width;
p->TitleHeight = i->Rect.Height;
MoveWindow(p->WndTitle,r.left + i->Rect.x,r.top + i->Rect.y,p->TitleWidth,p->TitleHeight,TRUE);
}
else
{
if (p->Win.ToolBarHeight)
{
r.bottom -= p->TitleHeight;
MoveWindow(p->WndTitle,r.left,r.bottom,p->TitleWidth,p->TitleHeight,TRUE);
}
else
{
MoveWindow(p->WndTitle,r.left,r.top,p->TitleWidth,p->TitleHeight,TRUE);
r.top += p->TitleHeight;
}
}
p->TitleTop = (p->TitleHeight-WinUnitToPixelY(&p->Win,p->TitleFontSize))/2;
}
p->SkinArea.x = r.left;
p->SkinArea.y = r.top;
p->SkinArea.Width = r.right - r.left;
p->SkinArea.Height = r.bottom - r.top;\
if (!Skin)
p->SkinViewport = p->SkinArea;
else
{
p->SkinViewport = p->Skin[p->SkinNo].Item[SKIN_VIEWPORT].Rect;
p->SkinViewport.x += p->SkinArea.x;
p->SkinViewport.y += p->SkinArea.y;
}
if (p->Win.ToolBarHeight && !p->VolResizeNeeded)
ResizeVolume(p);
}
p->Viewport = p->SkinViewport;
p->Viewport.x += p->Offset.x;
p->Viewport.y += p->Offset.y;
p->Player->Set(p->Player,PLAYER_SKIN_VIEWPORT,&p->Viewport,sizeof(rect));
p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0);
if (p->VolResizeNeeded)
{
ResizeVolume(p);
p->VolResizeNeeded = 0;
}
}
}
else
{
GetClientRect(p->Win.Wnd,&r);
p->Viewport.x = r.left + p->Offset.x;
p->Viewport.y = r.top + p->Offset.y;
p->Viewport.Width = r.right - r.left;
p->Viewport.Height = r.bottom - r.top;
}
if (Rotated)
p->Player->Set(p->Player,PLAYER_ROTATEEND,NULL,0);
DEBUG_MSG4(DEBUG_VIDEO,T("Resize end %d,%d,%d,%d"),p->Viewport.x,p->Viewport.y,p->Viewport.Width,p->Viewport.Height);
}
static BOOL CALLBACK EnumCheck(HWND Wnd, LPARAM lParam )
{
intface* p = (intface*) lParam;
RECT r;
if (Wnd == p->Win.Wnd)
return 0;
if (IsWindowVisible(Wnd))
{
GetWindowRect(Wnd,&r);
if (p->Viewport.x < r.right &&
p->Viewport.x + p->Viewport.Width > r.left &&
p->Viewport.y < r.bottom &&
p->Viewport.y + p->Viewport.Height > r.top)
{
p->Overlap = 1;
return 0;
}
}
return 1;
}
static void UpdateHotKey(intface* p,bool_t State,bool_t NoKeep)
{
int i;
if (!p->AllKeys)
{
for (i=0;i<HOTKEYCOUNT;++i)
if (p->HotKey[i])
{
if (State)
{
if (!WinEssentialKey(p->HotKey[i]))
WinRegisterHotKey(&p->Win,HotKey[i],p->HotKey[i]);
}
else
if (NoKeep || !(p->HotKey[i] & HOTKEY_KEEP))
WinUnRegisterHotKey(&p->Win,HotKey[i]);
else
if (WinEssentialKey(p->HotKey[i])) //essential keys -> register in the background
WinRegisterHotKey(&p->Win,HotKey[i],p->HotKey[i]);
}
}
else
{
WinAllKeys(State);
if (!State && !NoKeep)
for (i=0;i<HOTKEYCOUNT;++i)
if (p->HotKey[i] & HOTKEY_KEEP)
WinRegisterHotKey(&p->Win,HotKey[i],p->HotKey[i]);
}
}
static void UpdateSleepTimer(intface* p)
{
#if defined(TARGET_WINCE)
if (p->Play>0 || p->FFwd>0)
{
SleepTimerReset();
SetTimer(p->Win.Wnd,TIMER_SLEEP,SLEEP_CYCLE,NULL);
}
else
KillTimer(p->Win.Wnd,TIMER_SLEEP);
#endif
}
static void UpdateTitleScroll(intface* p)
{
if (p->Focus && p->TitleNameSize < p->TitleNameWidth)
{
if (p->TitleNameOffset >= p->TitleNameWidth - p->TitleNameSize)
p->TitleNameOffset = p->TitleNameWidth - p->TitleNameSize;
SetTimer(p->Win.Wnd,TIMER_TITLESCROLL,TITLESCROLL_CYCLE,NULL);
}
else
{
p->TitleNameOffset = 0;
p->ScrollMode = 0;
KillTimer(p->Win.Wnd,TIMER_TITLESCROLL);
}
}
static void TitleScroll(intface* p)
{
if (p->ScrollMode<TITLESCROLL_WAIT)
++p->ScrollMode;
else
if (p->ScrollMode==TITLESCROLL_WAIT)
{
p->TitleNameOffset += 3;
if (p->TitleNameOffset >= p->TitleNameWidth - p->TitleNameSize)
{
p->TitleNameOffset = p->TitleNameWidth - p->TitleNameSize;
++p->ScrollMode;
}
InvalidateRect(p->WndTitle,NULL,1);
}
else
if (p->ScrollMode<TITLESCROLL_WAIT*2+1)
++p->ScrollMode;
else
{
p->TitleNameOffset -= 3;
if (p->TitleNameOffset<=0)
{
p->TitleNameOffset=0;
p->ScrollMode = 0;
}
InvalidateRect(p->WndTitle,NULL,1);
}
UpdateTitleScroll(p);
}
static bool_t ShowVideo(intface* p)
{
bool_t b = p->Focus;
if (!b)
p->Player->Get(p->Player,PLAYER_SHOWINBACKGROUND,&b,sizeof(b));
return b;
}
static void UpdateClippingTimer(intface* p)
{
if (p->Clipping && ShowVideo(p))
SetTimer(p->Win.Wnd,TIMER_CLIPPING,CLIPPING_CYCLE,NULL);
else
KillTimer(p->Win.Wnd,TIMER_CLIPPING);
}
static bool_t IsOverlay(intface* p)
{
bool_t b = 0;
p->Player->Get(p->Player,PLAYER_VIDEO_OVERLAY,&b,sizeof(b));
return b;
}
static bool_t IsOverlapped(intface* p)
{
if (!p->Win.FullScreen || p->Wait)
{
// check for overlapping top-level windows
p->Overlap = 0;
EnumWindows(EnumCheck,(LPARAM)p);
if (p->Overlap)
return 1;
}
return 0;
}
static void UpdateClipping(intface* p,bool_t Suggest,bool_t HotKey)
{
if (p->Clipping != Suggest)
{
KillTimer(p->Win.Wnd,TIMER_CLIPPING2);
if (!Suggest && IsOverlapped(p))
return; // overlapping window -> clipping still needed
p->Clipping = Suggest;
p->Player->Set(p->Player,PLAYER_CLIPPING,&p->Clipping,sizeof(bool_t));
if (HotKey)
UpdateHotKey(p,!p->Clipping,0);
UpdateClippingTimer(p);
}
}
static void RefreshButton(intface* p,int No,bool_t* State,int Id,int Off,int On)
{
int i;
bool_t b;
if (p->Player->Get(p->Player,No,&b,sizeof(b)) != ERR_NONE)
b = -1;
switch (No)
{
case PLAYER_PLAY: i = SKIN_PLAY; break;
case PLAYER_FFWD: i = SKIN_FFWD; break;
case PLAYER_MUTE: i = SKIN_MUTE; break;
case PLAYER_FULLSCREEN: i = SKIN_FULLSCREEN; break;
case PLAYER_REPEAT: i = SKIN_REPEAT; break;
default: i = -1; break;
}
if (i>=0 && p->Skin[p->SkinNo].Item[i].Pushed != b)
{
p->Skin[p->SkinNo].Item[i].Pushed = b;
SkinDrawItem(p->Skin+p->SkinNo,p->Win.Wnd,i,&p->SkinArea);
}
if (State && b != *State)
{
if (b == -1 || *State == -1)
SendMessage(p->Win.WndTB,TB_ENABLEBUTTON,Id,MAKELPARAM(b!=-1,0));
*State = b;
if (b != -1)
{
SendMessage(p->Win.WndTB,TB_CHECKBUTTON,Id,MAKELPARAM(b,0));
if (On>=0)
SendMessage(p->Win.WndTB,TB_CHANGEBITMAP,Id,MAKELPARAM(p->Win.BitmapNo+(b?On:Off),0));
}
}
}
static void SetTrackThumb(HWND Wnd, bool_t State)
{
int Style = GetWindowLong(Wnd,GWL_STYLE);
if ((Style & TBS_NOTHUMB) != (State?0:TBS_NOTHUMB))
{
Style ^= TBS_NOTHUMB;
SetWindowLong(Wnd,GWL_STYLE,Style);
}
}
static void UpdateTitleTime(intface* p)
{
if (p->WndTitle)
{
tick_t Time;
if (p->Player->Get(p->Player,PLAYER_POSITION,&Time,sizeof(tick_t)) == ERR_NONE)
{
Time = (Time / TICKSPERSEC) * TICKSPERSEC;
if (Time<0)
Time=0;
}
else
Time = -1;
if (Time != p->TitleTime)
{
RECT r;
r.left = p->TitleWidth - p->TitleTimeWidth - p->TitleDurWidth - p->TitleBorder;
r.right = r.left + p->TitleTimeWidth;
r.top = 0;
r.bottom = p->TitleHeight;
p->TitleTime = Time;
InvalidateRect(p->WndTitle,&r,0);
}
}
}
static void UpdateMenuBool(intface* p,int MenuId,int Param)
{
bool_t b = 0;
WinMenuEnable(&p->Win,1,MenuId,p->Player->Get(p->Player,Param,&b,sizeof(b)) != ERR_NOT_SUPPORTED);
WinMenuCheck(&p->Win,1,MenuId,b);
}
static void UpdateMenuInt(intface* p,int MenuId,int Param,int Value)
{
int v = 0;
WinMenuEnable(&p->Win,1,MenuId,p->Player->Get(p->Player,Param,&v,sizeof(v)) != ERR_NOT_SUPPORTED);
WinMenuCheck(&p->Win,1,MenuId,v==Value);
}
static void UpdateMenuFrac(intface* p,int MenuId,int Param,int Num,int Den)
{
fraction f = {0,0};
WinMenuEnable(&p->Win,1,MenuId,p->Player->Get(p->Player,Param,&f,sizeof(f)) != ERR_NOT_SUPPORTED);
WinMenuCheck(&p->Win,1,MenuId,f.Num*Den==f.Den*Num);
}
static void UpdateMenu(intface* p)
{
packetformat PacketFormat;
node* AOutput;
bool_t Stereo;
bool_t b;
int* i;
int No,Id;
int PreAmp;
bool_t Accel;
tchar_t Name[20+1];
int ACurrent = -1;
int VCurrent = -1;
int SubCurrent = -1;
// remove old chapters
if (!WinMenuEnable(&p->Win,0,IF_FILE_CHAPTERS_NONE,0))
{
WinMenuInsert(&p->Win,0,IF_CHAPTER+1,IF_FILE_CHAPTERS_NONE,LangStr(INTERFACE_ID,IF_FILE_CHAPTERS_NONE));
for (No=1;No<MAXCHAPTER;++No)
if (!WinMenuDelete(&p->Win,0,IF_CHAPTER+No))
break;
}
// add new chapters
for (No=1;No<MAXCHAPTER && PlayerGetChapter(p->Player,No,Name,TSIZEOF(Name))>=0;++No)
WinMenuInsert(&p->Win,0,IF_FILE_CHAPTERS_NONE,IF_CHAPTER+No,Name);
if (No>1)
WinMenuDelete(&p->Win,0,IF_FILE_CHAPTERS_NONE);
else
WinMenuEnable(&p->Win,0,IF_FILE_CHAPTERS_NONE,0);
// remove old streams
if (p->MenuVStream >= 0)
{
WinMenuInsert(&p->Win,1,p->MenuVStream,IF_OPTIONS_VIDEO_STREAM_NONE, LangStr(INTERFACE_ID,IF_OPTIONS_VIDEO_STREAM_NONE));
for (No=0;No<p->MenuStreams;++No)
WinMenuDelete(&p->Win,1,IF_STREAM_VIDEO+No);
}
if (p->MenuAStream >= 0)
{
WinMenuInsert(&p->Win,1,p->MenuAStream,IF_OPTIONS_AUDIO_STREAM_NONE, LangStr(INTERFACE_ID,IF_OPTIONS_AUDIO_STREAM_NONE));
for (No=0;No<p->MenuStreams;++No)
WinMenuDelete(&p->Win,1,IF_STREAM_AUDIO+No);
}
if (p->MenuSubStream >= 0)
for (No=0;No<p->MenuStreams;++No)
WinMenuDelete(&p->Win,1,IF_STREAM_SUBTITLE+No);
// add new streams
p->MenuStreams = 0;
p->MenuAStream = -1;
p->MenuVStream = -1;
p->MenuSubStream = -1;
for (No=0;PlayerGetStream(p->Player,No,&PacketFormat,Name,TSIZEOF(Name),NULL);++No)
switch (PacketFormat.Type)
{
case PACKET_VIDEO:
p->MenuVStream = IF_STREAM_VIDEO+No;
WinMenuInsert(&p->Win,1,IF_OPTIONS_VIDEO_STREAM_NONE,IF_STREAM_VIDEO+No,Name);
break;
case PACKET_AUDIO:
p->MenuAStream = IF_STREAM_AUDIO+No;
WinMenuInsert(&p->Win,1,IF_OPTIONS_AUDIO_STREAM_NONE,IF_STREAM_AUDIO+No,Name);
break;
case PACKET_SUBTITLE:
p->MenuSubStream = IF_STREAM_SUBTITLE+No;
WinMenuInsert(&p->Win,1,IF_OPTIONS_SUBTITLE_STREAM_NONE,IF_STREAM_SUBTITLE+No,Name);
break;
}
p->MenuStreams = No;
p->Player->Get(p->Player,PLAYER_VSTREAM,&VCurrent,sizeof(int));
p->Player->Get(p->Player,PLAYER_ASTREAM,&ACurrent,sizeof(int));
p->Player->Get(p->Player,PLAYER_SUBSTREAM,&SubCurrent,sizeof(int));
if (p->MenuVStream<0)
WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_STREAM_NONE,0);
else
{
WinMenuCheck(&p->Win,1,IF_STREAM_VIDEO+VCurrent,1);
WinMenuDelete(&p->Win,1,IF_OPTIONS_VIDEO_STREAM_NONE);
}
if (p->MenuAStream<0)
WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STREAM_NONE,0);
else
{
WinMenuCheck(&p->Win,1,IF_STREAM_AUDIO+ACurrent,1);
WinMenuDelete(&p->Win,1,IF_OPTIONS_AUDIO_STREAM_NONE);
}
if (SubCurrent >= MAXSTREAM)
SubCurrent = -1;
WinMenuEnable(&p->Win,1,IF_OPTIONS_SUBTITLE_STREAM_NONE,p->MenuSubStream>=0);
WinMenuCheck(&p->Win,1,IF_OPTIONS_SUBTITLE_STREAM_NONE,SubCurrent<0);
if (SubCurrent>=0)
WinMenuCheck(&p->Win,1,IF_STREAM_SUBTITLE+SubCurrent,1);
UpdateMenuFrac(p,IF_OPTIONS_ASPECT_AUTO,PLAYER_ASPECT,0,1);
UpdateMenuFrac(p,IF_OPTIONS_ASPECT_SQUARE,PLAYER_ASPECT,1,1);
UpdateMenuFrac(p,IF_OPTIONS_ASPECT_4_3_SCREEN,PLAYER_ASPECT,-4,3);
UpdateMenuFrac(p,IF_OPTIONS_ASPECT_4_3_NTSC,PLAYER_ASPECT,10,11);
UpdateMenuFrac(p,IF_OPTIONS_ASPECT_4_3_PAL,PLAYER_ASPECT,12,11);
UpdateMenuFrac(p,IF_OPTIONS_ASPECT_16_9_SCREEN,PLAYER_ASPECT,-16,9);
UpdateMenuFrac(p,IF_OPTIONS_ASPECT_16_9_NTSC,PLAYER_ASPECT,40,33);
UpdateMenuFrac(p,IF_OPTIONS_ASPECT_16_9_PAL,PLAYER_ASPECT,16,11);
UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_SCREEN,PLAYER_FULL_ZOOM,0,1);
UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_110,PLAYER_FULL_ZOOM,-11,10);
UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_120,PLAYER_FULL_ZOOM,-12,10);
UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FIT_130,PLAYER_FULL_ZOOM,-13,10);
UpdateMenuFrac(p,IF_OPTIONS_ZOOM_FILL_SCREEN,PLAYER_FULL_ZOOM,-4,SCALE_ONE);
UpdateMenuFrac(p,IF_OPTIONS_ZOOM_STRETCH_SCREEN,PLAYER_FULL_ZOOM,-3,SCALE_ONE);
UpdateMenuFrac(p,IF_OPTIONS_ZOOM_50,PLAYER_FULL_ZOOM,1,2);
UpdateMenuFrac(p,IF_OPTIONS_ZOOM_100,PLAYER_FULL_ZOOM,1,1);
UpdateMenuFrac(p,IF_OPTIONS_ZOOM_150,PLAYER_FULL_ZOOM,3,2);
UpdateMenuFrac(p,IF_OPTIONS_ZOOM_200,PLAYER_FULL_ZOOM,2,1);
UpdateMenuBool(p,IF_OPTIONS_VIDEO_ZOOM_SMOOTH50,PLAYER_SMOOTH50);
UpdateMenuBool(p,IF_OPTIONS_VIDEO_ZOOM_SMOOTHALWAYS,PLAYER_SMOOTHALWAYS);
WinMenuCheck(&p->Win,1,IF_OPTIONS_VIEW_TITLEBAR,p->TitleBar);
WinMenuCheck(&p->Win,1,IF_OPTIONS_VIEW_TRACKBAR,p->TrackBar);
WinMenuCheck(&p->Win,1,IF_OPTIONS_VIEW_TASKBAR,p->TaskBar);
//UpdateMenuInt(p,IF_OPTIONS_AUDIO_QUALITY_LOW,PLAYER_AUDIO_QUALITY,0);
//UpdateMenuInt(p,IF_OPTIONS_AUDIO_QUALITY_MEDIUM,PLAYER_AUDIO_QUALITY,1);
//UpdateMenuInt(p,IF_OPTIONS_AUDIO_QUALITY_HIGH,PLAYER_AUDIO_QUALITY,2);
if (p->Player->Get(p->Player,PLAYER_PREAMP,&PreAmp,sizeof(PreAmp)) != ERR_NONE)
PreAmp = 0;
if (PreAmp != p->MenuPreAmp)
{
p->MenuPreAmp = PreAmp;
stprintf_s(Name,TSIZEOF(Name),LangStr(INTERFACE_ID,IF_OPTIONS_AUDIO_PREAMP),PreAmp);
WinMenuDelete(&p->Win,1,IF_OPTIONS_AUDIO_PREAMP);
WinMenuInsert(&p->Win,1,IF_OPTIONS_AUDIO_PREAMP_INC,IF_OPTIONS_AUDIO_PREAMP,Name);
}
UpdateMenuInt(p,IF_OPTIONS_VIDEO_QUALITY_LOWEST,PLAYER_VIDEO_QUALITY,0);
UpdateMenuInt(p,IF_OPTIONS_VIDEO_QUALITY_LOW,PLAYER_VIDEO_QUALITY,1);
UpdateMenuInt(p,IF_OPTIONS_VIDEO_QUALITY_NORMAL,PLAYER_VIDEO_QUALITY,2);
UpdateMenuInt(p,IF_OPTIONS_ROTATE_GUI,PLAYER_FULL_DIR,-1);
UpdateMenuInt(p,IF_OPTIONS_ROTATE_0,PLAYER_FULL_DIR,0);
UpdateMenuInt(p,IF_OPTIONS_ROTATE_90,PLAYER_FULL_DIR,DIR_SWAPXY | DIR_MIRRORLEFTRIGHT);
UpdateMenuInt(p,IF_OPTIONS_ROTATE_270,PLAYER_FULL_DIR,DIR_SWAPXY | DIR_MIRRORUPDOWN);
UpdateMenuInt(p,IF_OPTIONS_ROTATE_180,PLAYER_FULL_DIR,DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_10,PLAYER_PLAY_SPEED,1,10);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_25,PLAYER_PLAY_SPEED,1,4);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_50,PLAYER_PLAY_SPEED,1,2);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_80,PLAYER_PLAY_SPEED,8,10);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_90,PLAYER_PLAY_SPEED,9,10);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_100,PLAYER_PLAY_SPEED,1,1);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_110,PLAYER_PLAY_SPEED,11,10);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_120,PLAYER_PLAY_SPEED,12,10);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_150,PLAYER_PLAY_SPEED,3,2);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_200,PLAYER_PLAY_SPEED,2,1);
UpdateMenuFrac(p,IF_OPTIONS_SPEED_BENCHMARK,PLAYER_PLAY_SPEED,0,1);
UpdateMenuBool(p,IF_PLAY,PLAYER_PLAY);
WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_DITHER,p->Color->Get(p->Color,COLOR_DITHER,&b,sizeof(b)) != ERR_NOT_SUPPORTED);
WinMenuCheck(&p->Win,1,IF_OPTIONS_VIDEO_DITHER,b);
UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO,PLAYER_STEREO,STEREO_NORMAL);
UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_SWAPPED,PLAYER_STEREO,STEREO_SWAPPED);
UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_JOINED,PLAYER_STEREO,STEREO_JOINED);
UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_LEFT,PLAYER_STEREO,STEREO_LEFT);
UpdateMenuInt(p,IF_OPTIONS_AUDIO_STEREO_RIGHT,PLAYER_STEREO,STEREO_RIGHT);
UpdateMenuBool(p,IF_OPTIONS_FULLSCREEN,PLAYER_FULLSCREEN);
UpdateMenuBool(p,IF_OPTIONS_REPEAT,PLAYER_REPEAT);
UpdateMenuBool(p,IF_OPTIONS_SHUFFLE,PLAYER_SHUFFLE);
p->Equalizer->Get(p->Equalizer,EQUALIZER_ENABLED,&b,sizeof(b));
WinMenuCheck(&p->Win,1,IF_OPTIONS_EQUALIZER,b);
p->Player->Get(p->Player,PLAYER_VIDEO_ACCEL,&Accel,sizeof(Accel));
p->Player->Get(p->Player,PLAYER_VOUTPUTID,&Id,sizeof(Id));
WinMenuCheck(&p->Win,1,IF_OPTIONS_VIDEO_TURNOFF,!Id);
for (No=0,i=ARRAYBEGIN(p->VOutput,int);i!=ARRAYEND(p->VOutput,int);++i,++No)
{
WinMenuCheck(&p->Win,1,IF_VIDEO+No,*i==Id && !Accel);
WinMenuCheck(&p->Win,1,IF_VIDEOACCEL+No,*i==Id && Accel);
}
p->Player->Get(p->Player,PLAYER_AOUTPUTID,&Id,sizeof(Id));
WinMenuCheck(&p->Win,1,IF_OPTIONS_AUDIO_TURNOFF,!Id);
for (No=0,i=ARRAYBEGIN(p->AOutput,int);i!=ARRAYEND(p->AOutput,int);++i,++No)
WinMenuCheck(&p->Win,1,IF_AUDIO+No,*i==Id);
Stereo = 1;
p->Player->Get(p->Player,PLAYER_AOUTPUT,&AOutput,sizeof(AOutput));
if (AOutput && AOutput->Get(AOutput,OUT_INPUT|PIN_FORMAT,&PacketFormat,sizeof(PacketFormat))==ERR_NONE &&
PacketFormat.Type == PACKET_AUDIO && PacketFormat.Format.Audio.Channels<2)
Stereo = 0;
WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO,Stereo);
WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_SWAPPED,Stereo);
WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_JOINED,Stereo);
WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_LEFT,Stereo);
WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STEREO_RIGHT,Stereo);
}
static void UpdatePosition(intface* p);
static int Delta(intface* p,node* Node,int Param,int d,int Min,int Max)
{
int State;
if (Node && Node->Get(Node,Param,&State,sizeof(State))==ERR_NONE)
{
State += d;
if (State < Min)
State = Min;
if (State > Max)
State = Max;
Node->Set(Node,Param,&State,sizeof(State));
if (Param == PLAYER_VOLUME)
{
if (State > Min) Toggle(p,PLAYER_MUTE,0);
UpdateVolume(p);
}
}
return State;
}
static bool_t IsCoverAtr(player *Player)
{
node* Format;
int CoverArt;
int VStream;
return Player->Get(Player,PLAYER_FORMAT,&Format,sizeof(Format))==ERR_NONE && Format &&
Format->Get(Format,FORMAT_COVERART,&CoverArt,sizeof(CoverArt))==ERR_NONE &&
Player->Get(Player,PLAYER_VSTREAM,&VStream,sizeof(VStream))==ERR_NONE && VStream==CoverArt;
}
static bool_t ToggleFullScreen(intface* p,int Force,int CoverArtFullScreen)
{
bool_t State = 0;
if (p->Player->Get(p->Player,PLAYER_FULLSCREEN,&State,sizeof(State))==ERR_NONE)
{
node* VOutput;
bool_t Primary;
packetformat Format;
if (State==Force)
return State;
State = !State;
if (p->Player->Get(p->Player,PLAYER_VOUTPUT,&VOutput,sizeof(VOutput))!=ERR_NONE ||
!VOutput ||
VOutput->Get(VOutput,VOUT_PRIMARY,&Primary,sizeof(Primary))!=ERR_NONE || !Primary ||
(!CoverArtFullScreen && IsCoverAtr(p->Player)) ||
(!p->ForceFullScreen && VOutput->Get(VOutput,OUT_INPUT|PIN_FORMAT,&Format,sizeof(Format))!=ERR_NONE) ||
(!p->ForceFullScreen && !Format.Format.Video.Width))
State = 0;
UpdatePosition(p); // before returning from fullscreen
if (!State)
{
p->Player->Set(p->Player,PLAYER_FULLSCREEN,&State,sizeof(State));
p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0);
RefreshButton(p,PLAYER_FULLSCREEN,&p->FullScreen,IF_OPTIONS_FULLSCREEN,-1,-1);
}
if (p->Skin[p->SkinNo].Valid) p->Skin[p->SkinNo].Hidden = State;
if (p->WndTrack) ShowWindow(p->WndTrack,State ? SW_HIDE:SW_SHOWNA);
if (p->WndTitle) ShowWindow(p->WndTitle,State ? SW_HIDE:SW_SHOWNA);
WinSetFullScreen(&p->Win,State);
if (p->Win.WndTB) UpdateWindow(p->Win.WndTB);
ShowVol(p,!State); // called after WinSetFullScreen so TOPMOST is over taskbar
if (State)
{
p->Player->Set(p->Player,PLAYER_FULLSCREEN,&State,sizeof(State));
p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0);
RefreshButton(p,PLAYER_FULLSCREEN,&p->FullScreen,IF_OPTIONS_FULLSCREEN,-1,-1);
}
}
return State;
}
static bool_t Toggle(intface* p,int Param,int Force)
{
bool_t State = 0;
if (p->Player->Get(p->Player,Param,&State,sizeof(State))==ERR_NONE)
{
assert(Param != PLAYER_FULLSCREEN);
if (State==Force)
return State;
State = !State;
p->Player->Set(p->Player,Param,&State,sizeof(State));
if (Param == PLAYER_PLAY)
RefreshButton(p,PLAYER_PLAY,&p->Play,IF_PLAY,0,1);
else
if (Param == PLAYER_FFWD)
RefreshButton(p,PLAYER_FFWD,&p->FFwd,IF_FASTFORWARD,4,1);
else
RefreshButton(p,Param,NULL,0,0,0);
}
return State;
}
static bool_t IsAutoRun(intface* p, const tchar_t* CmdLine)
{
while (IsSpace(*CmdLine))
++CmdLine;
return tcsnicmp(CmdLine,T("-autorun"),8)==0;
}
static void EnumDir(const tchar_t* Path,const tchar_t* Exts,player* Player)
{
streamdir DirItem;
stream* Stream = GetStream(Path,1);
if (Stream)
{
int Result = Stream->EnumDir(Stream,Path,Exts,1,&DirItem);
while (Result == ERR_NONE)
{
tchar_t FullPath[MAXPATH];
AbsPath(FullPath,TSIZEOF(FullPath),DirItem.FileName,Path);
if (DirItem.Size < 0)
EnumDir(FullPath,Exts,Player);
else
if (DirItem.Type == FTYPE_AUDIO || DirItem.Type == FTYPE_VIDEO)
{
int n;
Player->Get(Player,PLAYER_LIST_COUNT,&n,sizeof(n));
Player->Set(Player,PLAYER_LIST_URL+n,FullPath,sizeof(FullPath));
}
Result = Stream->EnumDir(Stream,NULL,NULL,0,&DirItem);
}
NodeDelete((node*)Stream);
}
}
void ProcessCmdLine( intface* p, const tchar_t* CmdLine)
{
int n;
tchar_t URL[MAXPATH];
if (IsAutoRun(p,CmdLine))
{
// search for media files on SD card
tchar_t Base[MAXPATH];
int* i;
array List;
tchar_t* s;
int ExtsLen = 1024;
tchar_t* Exts = malloc(ExtsLen*sizeof(tchar_t));
if (!Exts)
return;
Exts[0]=0;
NodeEnumClass(&List,FORMAT_CLASS);
for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
{
const tchar_t* s = LangStr(*i,NODE_EXTS);
if (s[0])
{
if (Exts[0]) tcscat_s(Exts,ExtsLen,T(";"));
tcscat_s(Exts,ExtsLen,s);
}
}
ArrayClear(&List);
n = 0;
p->Player->Set(p->Player,PLAYER_LIST_COUNT,&n,sizeof(n));
GetModuleFileName(GetModuleHandle(NULL),Base,MAXPATH);
s = tcsrchr(Base,'\\');
if (s) *s=0;
s = tcsrchr(Base,'\\');
if (s) *s=0;
EnumDir(Base,Exts,p->Player);
free(Exts);
}
else
{
while (IsSpace(*CmdLine))
++CmdLine;
if (*CmdLine == '"')
{
tchar_t* ch = tcschr(++CmdLine,'"');
if (ch) *ch=0;
}
tcscpy_s(URL,TSIZEOF(URL),CmdLine);
p->CmdLineMode = 1;
n = 1;
p->Player->Set(p->Player,PLAYER_LIST_COUNT,&n,sizeof(n));
PlayerAdd(p->Player,0,URL,NULL);
}
n = 0;
p->Player->Set(p->Player,PLAYER_LIST_CURRIDX,&n,sizeof(n));
if (!IsWindowEnabled(p->Win.Wnd))
Toggle(p,PLAYER_PLAY,0);
}
void SetTrackPos(intface* p,int x)
{
fraction Percent;
RECT r,rt;
int Adj;
if (p->TrackSetPos == x)
return;
p->TrackSetPos = x;
SendMessage(p->WndTrack,TBM_GETCHANNELRECT,0,(LONG)&r);
SendMessage(p->WndTrack,TBM_GETTHUMBRECT,0,(LONG)&rt);
Adj = (rt.right-rt.left) >> 1;
r.left += Adj;
r.right -= (rt.right-rt.left)-Adj;
if (x > 32768) x -= 65536;
if (r.right <= r.left) r.right = r.left+1;
if (x < r.left) x = r.left;
if (x > r.right) x = r.right;
x = Scale(TRACKMAX,x-r.left,r.right-r.left);
Percent.Num = x;
Percent.Den = TRACKMAX;
p->Player->Set(p->Player,PLAYER_PERCENT,&Percent,sizeof(Percent));
}
LRESULT CALLBACK TitleProc(HWND WndTitle, UINT Msg, WPARAM wParam, LPARAM lParam)
{
intface* p = (intface*) WinGetObject(WndTitle);
if (p)
{
PAINTSTRUCT Paint;
RECT r;
tchar_t Time[32];
switch (Msg)
{
case WM_ERASEBKGND:
GetClientRect(WndTitle,&r);
FillRect((HDC)wParam,&r,p->TitleBrush ? p->TitleBrush:GetSysColorBrush(COLOR_BTNFACE));
break;
case WM_SIZE:
p->UpdateScroll = 1;
break;
case WM_LBUTTONDOWN:
break;
case WM_MOUSEMOVE:
break;
case WM_LBUTTONUP:
break;
case WM_PAINT:
BeginPaint(WndTitle,&Paint);
SelectObject(Paint.hdc,p->TitleFont);
SetBkColor(Paint.hdc,p->TitleFace);
SetTextColor(Paint.hdc,p->TitleText);
#if !defined(TARGET_WINCE)
SetTextAlign(Paint.hdc,TA_LEFT);
#endif
if (!p->TitleTimeWidth)
{
SIZE Size;
tchar_t* s;
tchar_t Dur[32];
tick_t Duration;
tchar_t TitleName[256];
node* Format;
if (p->Player->Get(p->Player,PLAYER_FORMAT,&Format,sizeof(Format)) == ERR_NONE && !Format)
p->TitleTime = -1;
p->Player->Get(p->Player,PLAYER_TITLE,TitleName,sizeof(TitleName));
if (tcscmp(p->TitleName,TitleName)!=0)
{
tcscpy_s(p->TitleName,TSIZEOF(p->TitleName),TitleName);
GetTextExtentPoint(Paint.hdc,p->TitleName,tcslen(p->TitleName),&Size);
p->TitleNameWidth = Size.cx;
p->TitleNameOffset = 0;
p->ScrollMode = 0;
p->UpdateScroll = 1;
}
s = Dur;
Dur[0] = 0;
if (p->Player->Get(p->Player,PLAYER_DURATION,&Duration,sizeof(Duration)) == ERR_NONE && Duration>=0)
{
TickToString(Dur,TSIZEOF(Dur),Duration,0,0,1);
if (p->TitleTime<0)
p->TitleTime = 0;
}
else
s = T("0:00:00");
GetTextExtentPoint(Paint.hdc,s,tcslen(s),&Size);
p->TitleTimeWidth = Size.cx;
p->TitleDurWidth = 0;
p->TitleDur[0] = 0;
if (Dur[0])
{
stprintf_s(p->TitleDur,TSIZEOF(p->TitleDur),T("/%s"),Dur);
GetTextExtentPoint(Paint.hdc,p->TitleDur,tcslen(p->TitleDur),&Size);
p->TitleDurWidth = Size.cx;
p->UpdateScroll = 1;
}
}
if (p->TitleTime>=0)
TickToString(Time,TSIZEOF(Time),p->TitleTime,0,0,1);
else
Time[0] = 0;
r.top = p->TitleTop;
r.bottom = p->TitleHeight - p->TitleTop;
r.left = p->TitleBorder;
r.right = p->TitleWidth - p->TitleTimeWidth - p->TitleDurWidth - p->TitleBorder * 2;
p->TitleNameSize = r.right - r.left;
if (p->UpdateScroll)
{
p->UpdateScroll = 0;
UpdateTitleScroll(p);
}
ExtTextOut(Paint.hdc,r.left-p->TitleNameOffset,r.top,ETO_CLIPPED,&r,p->TitleName,tcslen(p->TitleName),NULL);
r.left = r.right + p->TitleBorder;
r.right = r.left + p->TitleTimeWidth;
//SetBkColor(Paint.hdc,0xFFFFFF);
ExtTextOut(Paint.hdc,r.left,r.top,ETO_CLIPPED|ETO_OPAQUE,&r,Time,tcslen(Time),NULL);
//SetBkColor(Paint.hdc,0x00FF00);
if (p->TitleDurWidth)
{
r.left = r.right;
r.right = r.left + p->TitleDurWidth;
ExtTextOut(Paint.hdc,r.left,r.top,ETO_CLIPPED,&r,p->TitleDur,tcslen(p->TitleDur),NULL);
}
EndPaint(WndTitle,&Paint);
break;
}
}
return DefWindowProc(WndTitle,Msg,wParam,lParam);
}
static void SetKeyInSeek(intface* p)
{
bool_t First = !p->InSeek;
p->InSeek = 1;
p->Player->Set(p->Player,PLAYER_INSEEK,&p->InSeek,sizeof(p->InSeek));
SetTimer(p->Win.Wnd,TIMER_KEYINSEEK,First?KEYINSEEK_START:KEYINSEEK_REPEAT,NULL);
}
static void StopSeek(intface* p)
{
p->InSeek = 0;
p->Player->Set(p->Player,PLAYER_INSEEK,&p->InSeek,sizeof(p->InSeek));
KillTimer(p->Win.Wnd,TIMER_KEYINSEEK);
if (p->Capture)
{
ReleaseCapture();
p->Capture = 0;
KillTimer(p->Win.Wnd,TIMER_SLIDERINSEEK);
}
}
LRESULT CALLBACK TrackProc(HWND WndTrack, UINT Msg, WPARAM wParam, LPARAM lParam)
{
intface* p = (intface*) WinGetObject(WndTrack);
if (Msg == WM_LBUTTONDOWN)
{
p->InSeek = 1;
p->Capture = 1;
p->TrackSetPos = -1;
p->Player->Set(p->Player,PLAYER_INSEEK,&p->InSeek,sizeof(p->InSeek));
SetTrackPos(p,LOWORD(lParam));
SetCapture(WndTrack);
SetTimer(p->Win.Wnd,TIMER_SLIDERINSEEK,SLIDERINSEEK_CYCLE,NULL);
return 0;
}
if (Msg == WM_MOUSEMOVE)
{
if (p->InSeek && (wParam & MK_LBUTTON))
SetTrackPos(p,LOWORD(lParam));
return 0;
}
if (Msg == WM_LBUTTONUP)
{
if (p->InSeek)
{
SetTrackPos(p,LOWORD(lParam));
StopSeek(p);
}
return 0;
}
return CallWindowProc(p->DefTrackProc,WndTrack,Msg,wParam,lParam);
}
void UpdateVol(intface* p)
{
if (p->Vol >= 0)
{
SendMessage(p->WndVol,TBM_SETPOS,1,p->Vol);
p->Player->Set(p->Player,PLAYER_VOLUME,&p->Vol,sizeof(p->Vol));
p->Vol = -1;
if (p->Skin[p->SkinNo].Valid)
SkinUpdate(&p->Skin[p->SkinNo],p->Player,p->Win.Wnd,&p->SkinArea);
}
}
void SetVolPos(intface* p,int x)
{
RECT r;
int Adj;
SendMessage(p->WndVol,TBM_GETCHANNELRECT,0,(LONG)&r);
Adj = WinUnitToPixelX(&p->Win,VOLTHUMB)/4;
r.left += Adj;
r.right -= Adj;
if (x > 32768) x -= 65536;
if (r.right <= r.left) r.right = r.left+1;
if (x < r.left) x = r.left;
if (x > r.right) x = r.right;
p->Vol = (100*(x-r.left))/(r.right-r.left);
}
LRESULT CALLBACK VolBackProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
//DEBUG_MSG1(DEBUG_WIN,T("MSG %04x"),Msg);
switch (Msg)
{
#if defined(TARGET_WINCE)
case WM_CTLCOLORSTATIC:
return (LRESULT) GetSysColorBrush(COLOR_BTNFACE);
#endif
}
return DefWindowProc(Wnd,Msg,wParam,lParam);
}
LRESULT CALLBACK VolProc(HWND WndVol, UINT Msg, WPARAM wParam, LPARAM lParam)
{
intface* p = (intface*) WinGetObject(WndVol);
switch (Msg)
{
case WM_MOUSEMOVE:
if ((wParam & MK_LBUTTON)==0)
break;
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
SetVolPos(p,LOWORD(lParam));
if (!p->InVol)
{
p->InVol = 1;
SetForegroundWindow(p->Win.Wnd);
SetCapture(WndVol);
SetTimer(p->Win.Wnd,TIMER_SLIDERINVOL,SLIDERINVOL_CYCLE,NULL);
UpdateVol(p);
}
return 0;
case WM_LBUTTONUP:
if (!p->InVol)
SetForegroundWindow(p->Win.Wnd);
else
{
p->InVol = 0;
ReleaseCapture();
KillTimer(p->Win.Wnd,TIMER_SLIDERINVOL);
}
SetVolPos(p,LOWORD(lParam));
UpdateVol(p);
return 0;
}
return CallWindowProc(p->DefVolProc,WndVol,Msg,wParam,lParam);
}
void CreateDeviceMenu(intface* p)
{
int No;
int *i;
NodeEnumClass(&p->VOutput,VOUT_CLASS);
NodeEnumClass(&p->AOutput,AOUT_CLASS);
for (No=0,i=ARRAYBEGIN(p->VOutput,int);i!=ARRAYEND(p->VOutput,int);++i,++No)
{
if (VOutIDCT(*i))
{
tchar_t s[256];
stprintf_s(s,TSIZEOF(s),LangStr(INTERFACE_ID,IF_OPTIONS_VIDEO_ACCEL),LangStr(*i,NODE_NAME));
WinMenuInsert(&p->Win,1,IF_OPTIONS_VIDEO_TURNOFF,IF_VIDEOACCEL+No,s);
}
WinMenuInsert(&p->Win,1,IF_OPTIONS_VIDEO_TURNOFF,IF_VIDEO+No,LangStr(*i,NODE_NAME));
}
for (No=0,i=ARRAYBEGIN(p->AOutput,int);i!=ARRAYEND(p->AOutput,int);++i,++No)
WinMenuInsert(&p->Win,1,IF_OPTIONS_AUDIO_TURNOFF,IF_AUDIO+No,LangStr(*i,NODE_NAME));
}
static menudef MenuDef[] =
{
{ 0,INTERFACE_ID, IF_FILE },
{ 1,INTERFACE_ID, IF_FILE_OPENFILE },
{ 1,INTERFACE_ID, IF_FILE_CORETHEQUE },
{ 1,INTERFACE_ID, IF_FILE_PLAYLIST },
{ 1,-1,-1 },
{ 1,INTERFACE_ID, IF_PLAY },
{ 1,INTERFACE_ID, IF_NEXT },
{ 1,INTERFACE_ID, IF_PREV },
{ 1,-1,-1 },
{ 1,INTERFACE_ID, IF_FILE_CHAPTERS },
{ 2,INTERFACE_ID, IF_FILE_CHAPTERS_NONE },
{ 1,INTERFACE_ID, IF_FILE_MEDIAINFO },
{ 1,INTERFACE_ID, IF_FILE_BENCHMARK },
{ 1,INTERFACE_ID, IF_FILE_ABOUT },
{ 1,-1,-1 },
{ 1,INTERFACE_ID, IF_FILE_EXIT },
{ 0,INTERFACE_ID, IF_OPTIONS },
{ 1,INTERFACE_ID, IF_OPTIONS_SPEED },
{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_10 },
{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_25 },
{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_50 },
{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_80 },
{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_90 },
{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_100 },
{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_110 },
{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_120 },
{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_150 },
{ 2,INTERFACE_ID, IF_OPTIONS_SPEED_200 },
{ 1,INTERFACE_ID, IF_OPTIONS_VIEW, MENU_SMALL },
{ 2,INTERFACE_ID, IF_OPTIONS_ZOOM },
#if !defined(SH3)
{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_SCREEN },
{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FILL_SCREEN },
{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_STRETCH_SCREEN },
{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_110 },
{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_120 },
{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_FIT_130 },
{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_50 },
#endif
{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_100 },
#if !defined(SH3)
{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_150 },
#endif
{ 3,INTERFACE_ID, IF_OPTIONS_ZOOM_200 },
#if !defined(SH3)
{ 2,INTERFACE_ID, IF_OPTIONS_ASPECT },
{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_AUTO },
{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_SQUARE },
{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_4_3_SCREEN },
{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_4_3_NTSC },
{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_4_3_PAL },
{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_16_9_SCREEN },
{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_16_9_NTSC },
{ 3,INTERFACE_ID, IF_OPTIONS_ASPECT_16_9_PAL },
#endif
{ 2,INTERFACE_ID, IF_OPTIONS_ORIENTATION },
{ 3,INTERFACE_ID, IF_OPTIONS_ORIENTATION_FULLSCREEN },
{ 3,INTERFACE_ID, IF_OPTIONS_ROTATE_GUI },
{ 3,INTERFACE_ID, IF_OPTIONS_ROTATE_0 },
{ 3,INTERFACE_ID, IF_OPTIONS_ROTATE_90 },
{ 3,INTERFACE_ID, IF_OPTIONS_ROTATE_270 },
{ 3,INTERFACE_ID, IF_OPTIONS_ROTATE_180 },
{ 2,INTERFACE_ID, IF_OPTIONS_VIEW, MENU_NOTSMALL },
{ 3,INTERFACE_ID, IF_OPTIONS_VIEW_TITLEBAR },
{ 3,INTERFACE_ID, IF_OPTIONS_VIEW_TRACKBAR },
{ 3,INTERFACE_ID, IF_OPTIONS_VIEW_TASKBAR },
{ 1,INTERFACE_ID, IF_OPTIONS_VIDEO },
#if !defined(SH3) && !defined(MIPS)
{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_ZOOM_SMOOTH50 },
{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_ZOOM_SMOOTHALWAYS },
{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_DITHER },
#endif
{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY },
{ 3,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY_LOWEST },
{ 3,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY_LOW },
{ 3,INTERFACE_ID, IF_OPTIONS_VIDEO_QUALITY_NORMAL },
{ 2,-1,-1 },
{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_DEVICE, MENU_SMALL|MENU_GRAYED },
{ 3,INTERFACE_ID, IF_OPTIONS_VIDEO_TURNOFF },
{ 2,-1,-1 },
{ 2,INTERFACE_ID, IF_OPTIONS_VIDEO_STREAM, MENU_SMALL|MENU_GRAYED },
{ 3,INTERFACE_ID, IF_OPTIONS_VIDEO_STREAM_NONE },
{ 1,INTERFACE_ID, IF_OPTIONS_AUDIO },
{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_CHANNELS, MENU_SMALL },
{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO },
{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_SWAPPED },
{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_JOINED },
{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_LEFT },
{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STEREO_RIGHT },
// { 2,-1,-1 },
// { 2,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY },
// { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY_LOW },
// { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY_MEDIUM },
// { 3,INTERFACE_ID, IF_OPTIONS_AUDIO_QUALITY_HIGH },
{ 2,-1,-1 },
{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_PREAMP_DEC },
{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_PREAMP },
{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_PREAMP_INC },
{ 2,-1,-1 },
{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_DEVICE, MENU_SMALL|MENU_GRAYED },
{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_TURNOFF },
{ 2,-1,-1 },
{ 2,INTERFACE_ID, IF_OPTIONS_AUDIO_STREAM, MENU_SMALL|MENU_GRAYED },
{ 3,INTERFACE_ID, IF_OPTIONS_AUDIO_STREAM_NONE },
//!SUBTITLE { 1,INTERFACE_ID, IF_OPTIONS_SUBTITLE_STREAM, MENU_GRAYED },
//!SUBTITLE { 2,INTERFACE_ID, IF_OPTIONS_SUBTITLE_STREAM_NONE },
{ 1,-1,-1 },
{ 1,INTERFACE_ID, IF_OPTIONS_REPEAT },
{ 1,INTERFACE_ID, IF_OPTIONS_SHUFFLE },
{ 1,INTERFACE_ID, IF_OPTIONS_EQUALIZER },
{ 1,INTERFACE_ID, IF_OPTIONS_FULLSCREEN },
#if defined(CONFIG_SKIN)
{ 1,INTERFACE_ID, IF_OPTIONS_SKIN },
#endif
{ 1,-1,-1 },
{ 1,INTERFACE_ID, IF_OPTIONS_SETTINGS },
MENUDEF_END
};
void CreateButtons(intface* p)
{
if (QueryPlatform(PLATFORM_TYPENO) != TYPE_SMARTPHONE)
{
bool_t FullScreenButton = 1;
RECT r,rv;
WinBitmap(&p->Win,IDB_TOOLBAR16,IDB_TOOLBAR32,10);
WinAddButton(&p->Win,-1,-1,NULL,0);
WinAddButton(&p->Win,IF_PLAY,0,NULL,1);
WinAddButton(&p->Win,IF_FASTFORWARD,4,NULL,1);
WinAddButton(&p->Win,IF_STOP,5,NULL,0);
WinAddButton(&p->Win,-1,-1,NULL,0);
WinAddButton(&p->Win,IF_OPTIONS_FULLSCREEN,6,NULL,1);
WinAddButton(&p->Win,IF_OPTIONS_MUTE,7,NULL,1);
GetClientRect(p->Win.WndTB,&r);
SendMessage(p->Win.WndTB,TB_GETRECT,IF_OPTIONS_MUTE,(LPARAM)&rv);
if (r.right-rv.right < VOLMINWIDTH)
{
WinDeleteButton(&p->Win,IF_FASTFORWARD);
SendMessage(p->Win.WndTB,TB_GETRECT,IF_OPTIONS_MUTE,(LPARAM)&rv);
if (r.right-rv.right < VOLMINWIDTH)
{
WinDeleteButton(&p->Win,IF_OPTIONS_FULLSCREEN);
FullScreenButton = 0;
}
}
WinMenuDelete(&p->Win,0,IF_PLAY);
if (FullScreenButton)
WinMenuDelete(&p->Win,1,IF_OPTIONS_FULLSCREEN);
WinMenuDelete(&p->Win,1,IF_OPTIONS_MUTE);
}
}
static void UpdateVolume(intface* p)
{
int x;
if (p->Skin[p->SkinNo].Valid)
SkinUpdate(&p->Skin[p->SkinNo],p->Player,p->Win.Wnd,&p->SkinArea);
if (p->WndVol)
{
bool_t Enable = p->Player->Get(p->Player,PLAYER_VOLUME,&x,sizeof(x))==ERR_NONE;
EnableWindow(p->WndVol,Enable);
SetTrackThumb(p->WndVol,Enable);
if (Enable)
SendMessage(p->WndVol,TBM_SETPOS,1,x);
}
RefreshButton(p,PLAYER_MUTE,&p->Mute,IF_OPTIONS_MUTE,7,8);
}
static void CreateVolumeTrack(intface* p)
{
if (QueryPlatform(PLATFORM_TYPENO) != TYPE_SMARTPHONE)
{
WNDCLASS WinClass;
memset(&WinClass,0,sizeof(WinClass));
WinClass.style = CS_HREDRAW | CS_VREDRAW;
WinClass.lpfnWndProc = (WNDPROC) VolBackProc;
WinClass.cbClsExtra = 0;
WinClass.cbWndExtra = 0;
WinClass.hInstance = p->Win.Module;
WinClass.hCursor = WinCursorArrow();
WinClass.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
WinClass.lpszMenuName = 0;
WinClass.lpszClassName = T("VolumeBack");
RegisterClass(&WinClass);
p->WndVolBack = CreateWindowEx(
WS_EX_TOPMOST,
WinClass.lpszClassName,
Context()->ProgramName,
(p->Win.ToolBarHeight ? WS_CHILD:WS_POPUP) | WS_VISIBLE |
TBS_HORZ|TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH,
200, 0,
40, 20,
(p->Win.ToolBarHeight ? p->Win.WndTB:p->Win.Wnd),
NULL,
p->Win.Module,
NULL
);
p->WndVol = CreateWindowEx(
0,
TRACKBAR_CLASS,
NULL,
WS_CHILD | WS_VISIBLE |
TBS_HORZ|TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH,
0, 0,
40, 20,
p->WndVolBack,
NULL,
p->Win.Module,
NULL
);
p->DefVolProc = (WNDPROC)GetWindowLong(p->WndVol,GWL_WNDPROC);
SetWindowLong(p->WndVol,GWL_WNDPROC,(LONG)VolProc);
WinSetObject(p->WndVol,&p->Win);
SendMessage(p->WndVol, TBM_SETRANGE, FALSE,MAKELONG(0,100));
SendMessage(p->WndVol, TBM_SETPAGESIZE,0,10);
SendMessage(p->WndVol, TBM_SETLINESIZE,0,10);
ResizeVolume(p);
UpdateVolume(p);
}
}
static int UpdateTitleBar(intface* p,bool_t DoResize)
{
if (p->TitleBar && !p->WndTitle && p->Win.Wnd)
{
WNDCLASS WinClass;
memset(&WinClass,0,sizeof(WinClass));
WinClass.style = CS_HREDRAW | CS_VREDRAW;
WinClass.lpfnWndProc = (WNDPROC) TitleProc;
WinClass.cbClsExtra = 0;
WinClass.cbWndExtra = 0;
WinClass.hInstance = p->Win.Module;
WinClass.hCursor = WinCursorArrow();
WinClass.hbrBackground = NULL;
WinClass.lpszMenuName = 0;
WinClass.lpszClassName = T("TitleBar");
RegisterClass(&WinClass);
p->WndTitle = CreateWindowEx(
0,
WinClass.lpszClassName,
T("Time"),
WS_CHILD | WS_VISIBLE,
0, 0,
200, 20,
p->Win.Wnd,
NULL,
p->Win.Module,
NULL
);
WinSetObject(p->WndTitle,&p->Win);
p->ClientRect.right = -1;
if (DoResize) Resize(p);
}
if (!p->TitleBar && p->WndTitle)
{
DestroyWindow(p->WndTitle);
p->WndTitle = NULL;
p->ClientRect.right = -1;
if (DoResize) Resize(p);
}
return ERR_NONE;
}
static NOINLINE void UpdateTrackPos(intface* p)
{
if (p->Skin[p->SkinNo].Valid)
SkinUpdate(p->Skin+p->SkinNo,p->Player,p->Win.Wnd,&p->SkinArea);
if (p->WndTrack)
{
fraction f;
int TrackPos;
if (p->Player->Get(p->Player,PLAYER_PERCENT,&f,sizeof(fraction)) == ERR_NONE)
TrackPos = Scale(TRACKMAX,f.Num,f.Den);
else
TrackPos = -1;
if (TrackPos != p->TrackPos)
{
if (TrackPos == -1)
{
SetTrackThumb(p->WndTrack,0);
EnableWindow(p->WndTrack,0);
}
if (p->TrackPos == -1)
{
SetTrackThumb(p->WndTrack,1);
EnableWindow(p->WndTrack,1);
}
p->TrackPos = TrackPos;
SendMessage(p->WndTrack,TBM_SETPOS,1,TrackPos);
}
}
}
static int UpdateTrackBar(intface* p,bool_t DoResize)
{
bool_t TrackBar = p->TrackBar && !p->Skin[p->SkinNo].Valid;
if (TrackBar && !p->WndTrack && p->Win.Wnd)
{
p->WndTrack = CreateWindowEx(
0,
TRACKBAR_CLASS,
T("Time"),
WS_CHILD | WS_VISIBLE |
TBS_HORZ|TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH,
0, 0,
200, 20,
p->Win.Wnd,
NULL,
p->Win.Module,
NULL
);
p->DefTrackProc = (WNDPROC)GetWindowLong(p->WndTrack,GWL_WNDPROC);
SetWindowLong(p->WndTrack,GWL_WNDPROC,(LONG)TrackProc);
WinSetObject(p->WndTrack,&p->Win);
SendMessage(p->WndTrack, TBM_SETRANGE, FALSE,MAKELONG(0,TRACKMAX));
SendMessage(p->WndTrack, TBM_SETPAGESIZE,0,TRACKMAX/20);
SendMessage(p->WndTrack, TBM_SETLINESIZE,0,TRACKMAX/100);
p->TrackPos = 0;
UpdateTrackPos(p);
p->ClientRect.right = -1;
if (DoResize) Resize(p);
}
if (!TrackBar && p->WndTrack)
{
DestroyWindow(p->WndTrack);
p->WndTrack = NULL;
p->ClientRect.right = -1;
if (DoResize) Resize(p);
}
p->TrackThumb = -1;
return ERR_NONE;
}
static void BeforeExit(intface* p)
{
if (Context()->Wnd)
{
NodeRegSaveValue(0,REG_INITING,NULL,0,TYPE_INT);
NodeRegSave((node*)p);
UpdateHotKey(p,0,1);
if (p->WndVolBack)
{
DestroyWindow(p->WndVolBack);
p->WndVolBack = NULL;
}
Context_Wnd(NULL);
}
}
static void ShowError2(intface* p, const tchar_t* s)
{
win* Win;
if (p->Player)
{
p->Player->Set(p->Player,PLAYER_STOP,NULL,1); // full stop (no filling buffers)
ToggleFullScreen(p,0,0); //ATI tweaks would have problem
}
UpdateClipping(p,1,1); // force clipping mode
// find application foreground window
Win = &p->Win;
while (Win->Child) Win = Win->Child;
MessageBox(Win->Wnd,s,LangStr(PLATFORM_ID,PLATFORM_ERROR),MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
}
static void ToggleStream(intface* p,int Id,int Type,bool_t UseNone)
{
packetformat Format;
int No,Current,First=-1;
p->Player->Get(p->Player,Id,&Current,sizeof(int));
if (Current == MAXSTREAM)
Current = -1;
for (No=0;PlayerGetStream(p->Player,No,&Format,NULL,0,NULL);++No)
if (Format.Type == Type)
{
if (First < 0)
First = No;
if (Current == No)
Current = -1;
else
if (Current == -1)
Current = No;
}
if (Current == -1)
Current = UseNone ? MAXSTREAM:First;
if (Current >= 0)
{
p->Player->Set(p->Player,Id,&Current,sizeof(int));
p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
}
}
static int UpdateTaskBar(intface* p)
{
if (!p->Win.FullScreen)
DIASet(p->TaskBar?DIA_TASKBAR:0,DIA_TASKBAR);
return ERR_NONE;
}
static int UpdateSkin(intface* p,bool_t Others);
static int UpdateSkinFile(intface* p)
{
if (p->Player)
{
SkinFree(p->Skin,NULL);
SkinLoad(p->Skin,p->Win.Wnd,p->SkinPath);
UpdateSkin(p,1);
}
return ERR_NONE;
}
static int Command(intface* p,int Cmd)
{
node* Node;
bool_t b;
int i;
fraction f;
tick_t t;
int Zero = 0;
switch (Cmd)
{
case IF_SKIN0:
p->SkinNo = 0;
UpdateSkin(p,1);
break;
case IF_SKIN1:
p->SkinNo = 1;
UpdateSkin(p,1);
break;
case IF_OPTIONS_VOLUME_UP:
Delta(p,(node*)p->Player,PLAYER_VOLUME,10,0,100);
break;
case IF_OPTIONS_VOLUME_DOWN:
Delta(p,(node*)p->Player,PLAYER_VOLUME,-10,0,100);
break;
case IF_OPTIONS_VOLUME_UP_FINE:
Delta(p,(node*)p->Player,PLAYER_VOLUME,3,0,100);
break;
case IF_OPTIONS_VOLUME_DOWN_FINE:
Delta(p,(node*)p->Player,PLAYER_VOLUME,-3,0,100);
break;
case IF_OPTIONS_BRIGHTNESS_UP:
Delta(p,p->Color,COLOR_BRIGHTNESS,6,-128,127);
break;
case IF_OPTIONS_BRIGHTNESS_DOWN:
Delta(p,p->Color,COLOR_BRIGHTNESS,-6,-128,127);
break;
case IF_OPTIONS_CONTRAST_UP:
Delta(p,p->Color,COLOR_CONTRAST,6,-128,127);
break;
case IF_OPTIONS_CONTRAST_DOWN:
Delta(p,p->Color,COLOR_CONTRAST,-6,-128,127);
break;
case IF_OPTIONS_SATURATION_UP:
Delta(p,p->Color,COLOR_SATURATION,6,-128,127);
break;
case IF_OPTIONS_SATURATION_DOWN:
Delta(p,p->Color,COLOR_SATURATION,-6,-128,127);
break;
case IF_OPTIONS_SCREEN:
SetDisplayPower(!GetDisplayPower(),1);
break;
case IF_OPTIONS_AUDIO_STEREO_TOGGLE:
p->Player->Get(p->Player,PLAYER_STEREO,&i,sizeof(i));
i = i==STEREO_LEFT?STEREO_RIGHT:STEREO_LEFT;
p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
break;
case IF_OPTIONS_TOGGLE_VIDEO:
ToggleStream(p,PLAYER_VSTREAM,PACKET_VIDEO,0);
break;
case IF_OPTIONS_TOGGLE_SUBTITLE:
ToggleStream(p,PLAYER_SUBSTREAM,PACKET_SUBTITLE,1);
break;
case IF_OPTIONS_TOGGLE_AUDIO:
ToggleStream(p,PLAYER_ASTREAM,PACKET_AUDIO,0);
break;
case IF_OPTIONS_ZOOM_IN:
p->Player->Get(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
if (f.Num <= 0) f.Num = f.Den = 1;
if (f.Den != 100)
{
f.Num = f.Num * 100 / f.Den;
f.Den = 100;
}
f.Num+=5;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_OUT:
p->Player->Get(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
if (f.Num <= 0) f.Num = f.Den = 1;
if (f.Den != 100)
{
f.Num = f.Num * 100 / f.Den;
f.Den = 100;
}
if (f.Num>5) f.Num-=5;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_FIT:
p->Player->Get(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
f.Num = f.Num == -1 ? -2:-1;
f.Den = 1;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_PLAY_FULLSCREEN:
if (p->Player->Get(p->Player,PLAYER_STREAMING,&b,sizeof(b))==ERR_NONE && b)
ToggleFullScreen(p,-1,0);
else
if (!(p->Player->Get(p->Player,PLAYER_FULLSCREEN,&b,sizeof(b))==ERR_NONE && b) &&
!(p->Player->Get(p->Player,PLAYER_PLAY,&b,sizeof(b))==ERR_NONE && b))
{
ToggleFullScreen(p,1,0);
Toggle(p,PLAYER_PLAY,1);
}
else
{
Toggle(p,PLAYER_PLAY,0);
ToggleFullScreen(p,0,0);
}
break;
case IF_MOVE_FFWD:
SetKeyInSeek(p);
p->Player->Set(p->Player,PLAYER_MOVEFFWD,NULL,0);
break;
case IF_MOVE_BACK:
SetKeyInSeek(p);
p->Player->Set(p->Player,PLAYER_MOVEBACK,NULL,0);
break;
case IF_NEXT2:
case IF_NEXT:
p->Player->Set(p->Player,PLAYER_NEXT,NULL,0);
break;
case IF_PREV_SMART:
case IF_PREV_SMART2:
p->Player->Set(p->Player,PLAYER_PREV,NULL,1);
break;
case IF_PREV:
p->Player->Set(p->Player,PLAYER_PREV,NULL,0);
break;
case IF_PLAYPAUSE:
case IF_PLAY:
p->Play = -1; // force button refresh
Toggle(p,PLAYER_PLAY,-1);
break;
case IF_FASTFORWARD:
p->FFwd = -1; // force button refresh
Toggle(p,PLAYER_FFWD,-1);
break;
case IF_FILE_BENCHMARK:
if (!ToggleFullScreen(p,1,0))
{
if (p->WndTrack)
SetTrackThumb(p->WndTrack,0);
WaitBegin();
}
UpdateWindow(p->Win.Wnd);
t = 0;
p->Player->Set(p->Player,PLAYER_BENCHMARK,&t,sizeof(t));
p->Bench = 1;
break;
case IF_STOP:
p->Player->Set(p->Player,PLAYER_STOP,NULL,0);
f.Num = 0;
f.Den = 1;
p->Player->Set(p->Player,PLAYER_PERCENT,&f,sizeof(f));
break;
case IF_FILE_OPENFILE:
p->CmdLineMode = 0;
Node = NodeCreate(OPENFILE_ID);
i = 0;
Node->Set(Node,OPENFILE_FLAGS,&i,sizeof(i));
i = MEDIA_CLASS;
Node->Set(Node,OPENFILE_CLASS,&i,sizeof(i));
UpdateHotKey(p,0,1);
i = ((win*)Node)->Popup((win*)Node,&p->Win);
NodeDelete(Node);
if (i==2)
{
UpdateWindow(p->Win.Wnd);
i=0;
p->Player->Set(p->Player,PLAYER_LIST_CURRIDX,&i,sizeof(i));
}
break;
case IF_FILE_CORETHEQUE:
WinPopupClass(CORETHEQUE_UI_ID,&p->Win);
p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0);
break;
case IF_FILE_ABOUT:
WinPopupClass(ABOUT_ID,&p->Win);
break;
case IF_OPTIONS_SETTINGS:
UpdateHotKey(p,0,1);
p->AllKeysWarning = 1;
WinPopupClass(SETTINGS_ID,&p->Win);
p->AllKeysWarning = 0;
p->Player->Set(p->Player,PLAYER_UPDATEVIDEO,NULL,0);
break;
case IF_FILE_PLAYLIST:
WinPopupClass(PLAYLIST_ID,&p->Win);
break;
case IF_FILE_MEDIAINFO:
WinPopupClass(MEDIAINFO_ID,&p->Win);
break;
case IF_FILE_EXIT:
// just to be sure to stop overlay update (WM_DESTROY comes after window is hidden)
BeforeExit(p);
DestroyWindow(p->Win.Wnd);
break;
case IF_OPTIONS_REPEAT:
Toggle(p,PLAYER_REPEAT,-1);
break;
case IF_OPTIONS_SHUFFLE:
Toggle(p,PLAYER_SHUFFLE,-1);
break;
case IF_OPTIONS_EQUALIZER:
p->Equalizer->Get(p->Equalizer,EQUALIZER_ENABLED,&b,sizeof(b));
b = !b;
p->Equalizer->Set(p->Equalizer,EQUALIZER_ENABLED,&b,sizeof(b));
//p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
break;
case IF_OPTIONS_SKIN:
Node = NodeCreate(OPENFILE_ID);
if (Node)
{
i = OPENFLAG_SINGLE;
Node->Set(Node,OPENFILE_FLAGS,&i,sizeof(i));
i = SKIN_CLASS;
Node->Set(Node,OPENFILE_CLASS,&i,sizeof(i));
i = ((win*)Node)->Popup((win*)Node,&p->Win);
NodeDelete(Node);
if (i==1)
{
p->SkinPath[0] = 0;
UpdateSkinFile(p);
}
}
break;
case IF_OPTIONS_FULLSCREEN:
p->FullScreen = -1; // force button refresh
ToggleFullScreen(p,-1,1);
break;
case IF_OPTIONS_MUTE:
p->Mute = -1; // force button refresh
if (p->Player->Get(p->Player,PLAYER_VOLUME,&i,sizeof(i))==ERR_NONE && i==0)
{
i = 1;
p->Player->Set(p->Player,PLAYER_VOLUME,&i,sizeof(i));
}
Toggle(p,PLAYER_MUTE,-1);
UpdateVolume(p);
break;
case IF_OPTIONS_VIDEO_DITHER:
p->Color->Get(p->Color,COLOR_DITHER,&b,sizeof(b));
b = !b;
p->Color->Set(p->Color,COLOR_DITHER,&b,sizeof(b));
break;
case IF_OPTIONS_ROTATE:
p->Player->Get(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
switch (i)
{
case 0: i = DIR_SWAPXY | DIR_MIRRORLEFTRIGHT; break;
case DIR_SWAPXY | DIR_MIRRORLEFTRIGHT: i = DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT; break;
case DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT: i = DIR_SWAPXY | DIR_MIRRORUPDOWN; break;
case DIR_SWAPXY | DIR_MIRRORUPDOWN: i = 0; break;
default: i = 0; break;
}
p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
p->Player->Get(p->Player,PLAYER_SKIN_DIR,&i,sizeof(i));
switch (i)
{
case 0: i = DIR_SWAPXY | DIR_MIRRORLEFTRIGHT; break;
case DIR_SWAPXY | DIR_MIRRORLEFTRIGHT: i = DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT; break;
case DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT: i = DIR_SWAPXY | DIR_MIRRORUPDOWN; break;
case DIR_SWAPXY | DIR_MIRRORUPDOWN: i = 0; break;
default: i = 0; break;
}
p->Player->Set(p->Player,PLAYER_SKIN_DIR,&i,sizeof(i));
break;
case IF_OPTIONS_ROTATE_GUI:
i = -1;
p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
break;
case IF_OPTIONS_ROTATE_0:
i = 0;
p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
break;
case IF_OPTIONS_ROTATE_270:
i = DIR_SWAPXY | DIR_MIRRORUPDOWN;
p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
break;
case IF_OPTIONS_ROTATE_180:
i = DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT;
p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
break;
case IF_OPTIONS_ROTATE_90:
i = DIR_SWAPXY | DIR_MIRRORLEFTRIGHT;
p->Player->Set(p->Player,PLAYER_FULL_DIR,&i,sizeof(i));
break;
case IF_OPTIONS_ASPECT_AUTO:
f.Num = 0;
f.Den = 1;
p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
break;
case IF_OPTIONS_ASPECT_SQUARE:
f.Num = 1;
f.Den = 1;
p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
break;
case IF_OPTIONS_ASPECT_4_3_SCREEN:
f.Num = -4;
f.Den = 3;
p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
break;
case IF_OPTIONS_ASPECT_4_3_NTSC:
f.Num = 10;
f.Den = 11;
p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
break;
case IF_OPTIONS_ASPECT_4_3_PAL:
f.Num = 12;
f.Den = 11;
p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
break;
case IF_OPTIONS_ASPECT_16_9_SCREEN:
f.Num = -16;
f.Den = 9;
p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
break;
case IF_OPTIONS_ASPECT_16_9_NTSC:
f.Num = 40;
f.Den = 33;
p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
break;
case IF_OPTIONS_ASPECT_16_9_PAL:
f.Num = 16;
f.Den = 11;
p->Player->Set(p->Player,PLAYER_ASPECT,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_FIT_SCREEN:
f.Num = 0;
f.Den = 1;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_STRETCH_SCREEN:
f.Num = -3;
f.Den = SCALE_ONE;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_FILL_SCREEN:
f.Num = -4;
f.Den = SCALE_ONE;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_VIEW_TITLEBAR:
p->TitleBar = !p->TitleBar;
UpdateTitleBar(p,1);
break;
case IF_OPTIONS_VIEW_TASKBAR:
p->TaskBar = !p->TaskBar;
UpdateTaskBar(p);
break;
case IF_OPTIONS_VIEW_TRACKBAR:
p->TrackBar = !p->TrackBar;
UpdateTrackBar(p,1);
break;
case IF_OPTIONS_ZOOM_50:
f.Num = 1;
f.Den = 2;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_100:
f.Num = 1;
f.Den = 1;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_FIT_110:
f.Num = -11;
f.Den = 10;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_FIT_120:
f.Num = -12;
f.Den = 10;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_FIT_130:
f.Num = -13;
f.Den = 10;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_150:
f.Num = 3;
f.Den = 2;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_ZOOM_200:
f.Num = 2;
f.Den = 1;
p->Player->Set(p->Player,PLAYER_FULL_ZOOM,&f,sizeof(f));
p->Player->Set(p->Player,PLAYER_SKIN_ZOOM,&f,sizeof(f));
break;
case IF_OPTIONS_VIDEO_ZOOM_SMOOTH50:
Toggle(p,PLAYER_SMOOTH50,-1);
Toggle(p,PLAYER_SMOOTHALWAYS,0);
break;
case IF_OPTIONS_VIDEO_ZOOM_SMOOTHALWAYS:
Toggle(p,PLAYER_SMOOTHALWAYS,-1);
Toggle(p,PLAYER_SMOOTH50,0);
break;
case IF_OPTIONS_AUDIO_STEREO:
i = STEREO_NORMAL;
p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
break;
case IF_OPTIONS_AUDIO_STEREO_SWAPPED:
i = STEREO_SWAPPED;
p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
break;
case IF_OPTIONS_AUDIO_STEREO_JOINED:
i = STEREO_JOINED;
p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
break;
case IF_OPTIONS_AUDIO_STEREO_LEFT:
i = STEREO_LEFT;
p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
break;
case IF_OPTIONS_AUDIO_STEREO_RIGHT:
i = STEREO_RIGHT;
p->Player->Set(p->Player,PLAYER_STEREO,&i,sizeof(i));
break;
case IF_OPTIONS_AUDIO_PREAMP_INC:
p->Player->Get(p->Player,PLAYER_PREAMP,&i,sizeof(i));
i += 25;
if (i>200) i=200;
p->Player->Set(p->Player,PLAYER_PREAMP,&i,sizeof(i));
break;
case IF_OPTIONS_AUDIO_PREAMP_DEC:
p->Player->Get(p->Player,PLAYER_PREAMP,&i,sizeof(i));
i -= 25;
if (i<-200) i=-200;
p->Player->Set(p->Player,PLAYER_PREAMP,&i,sizeof(i));
break;
case IF_OPTIONS_AUDIO_PREAMP:
i = 0;
p->Player->Set(p->Player,PLAYER_PREAMP,&i,sizeof(i));
break;
case IF_OPTIONS_AUDIO_QUALITY_LOW:
i = 0;
p->Player->Set(p->Player,PLAYER_AUDIO_QUALITY,&i,sizeof(i));
break;
case IF_OPTIONS_AUDIO_QUALITY_MEDIUM:
i = 1;
p->Player->Set(p->Player,PLAYER_AUDIO_QUALITY,&i,sizeof(i));
break;
case IF_OPTIONS_AUDIO_QUALITY_HIGH:
i = 2;
p->Player->Set(p->Player,PLAYER_AUDIO_QUALITY,&i,sizeof(i));
break;
case IF_OPTIONS_VIDEO_QUALITY_LOWEST:
i = 0;
p->Player->Set(p->Player,PLAYER_VIDEO_QUALITY,&i,sizeof(i));
p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
break;
case IF_OPTIONS_VIDEO_QUALITY_LOW:
i = 1;
p->Player->Set(p->Player,PLAYER_VIDEO_QUALITY,&i,sizeof(i));
p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
break;
case IF_OPTIONS_VIDEO_QUALITY_NORMAL:
i = 2;
p->Player->Set(p->Player,PLAYER_VIDEO_QUALITY,&i,sizeof(i));
p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
break;
case IF_OPTIONS_SPEED_10:
f.Num = 1;
f.Den = 10;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_SPEED_25:
f.Num = 1;
f.Den = 4;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_SPEED_50:
f.Num = 1;
f.Den = 2;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_SPEED_100:
f.Num = 1;
f.Den = 1;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_SPEED_150:
f.Num = 3;
f.Den = 2;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_SPEED_200:
f.Num = 2;
f.Den = 1;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_SPEED_80:
f.Num = 8;
f.Den = 10;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_SPEED_90:
f.Num = 9;
f.Den = 10;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_SPEED_110:
f.Num = 11;
f.Den = 10;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_SPEED_120:
f.Num = 12;
f.Den = 10;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_SPEED_BENCHMARK:
f.Num = 0;
f.Den = 1;
p->Player->Set(p->Player,PLAYER_PLAY_SPEED,&f,sizeof(f));
break;
case IF_OPTIONS_VIDEO_TURNOFF:
p->Player->Set(p->Player,PLAYER_VOUTPUTID,&Zero,sizeof(Zero));
break;
case IF_OPTIONS_AUDIO_TURNOFF:
p->Player->Set(p->Player,PLAYER_AOUTPUTID,&Zero,sizeof(Zero));
UpdateVolume(p);
break;
case IF_OPTIONS_SUBTITLE_STREAM_NONE:
i = MAXSTREAM;
p->Player->Set(p->Player,PLAYER_SUBSTREAM,&i,sizeof(i));
break;
}
if (Cmd >= IF_CHAPTER && Cmd < IF_CHAPTER+100)
{
tick_t Time = PlayerGetChapter(p->Player,Cmd-IF_CHAPTER,NULL,0);
if (Time>=0)
p->Player->Set(p->Player,PLAYER_POSITION,&Time,sizeof(tick_t));
}
if (Cmd >= IF_STREAM_AUDIO && Cmd < IF_STREAM_AUDIO+MAXSTREAM)
{
i = Cmd-IF_STREAM_AUDIO;
p->Player->Set(p->Player,PLAYER_ASTREAM,&i,sizeof(i));
p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
}
if (Cmd >= IF_STREAM_VIDEO && Cmd < IF_STREAM_VIDEO+MAXSTREAM)
{
i = Cmd-IF_STREAM_VIDEO;
p->Player->Set(p->Player,PLAYER_VSTREAM,&i,sizeof(i));
p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
}
if (Cmd >= IF_STREAM_SUBTITLE && Cmd < IF_STREAM_SUBTITLE+MAXSTREAM)
{
i = Cmd-IF_STREAM_SUBTITLE;
p->Player->Set(p->Player,PLAYER_SUBSTREAM,&i,sizeof(i));
p->Player->Set(p->Player,PLAYER_RESYNC,NULL,0);
}
if (Cmd >= IF_VIDEO && Cmd < IF_VIDEO+ARRAYCOUNT(p->VOutput,int))
{
b = 0;
p->Player->Set(p->Player,PLAYER_VIDEO_ACCEL,&b,sizeof(b));
p->Player->Set(p->Player,PLAYER_VOUTPUTID,ARRAYBEGIN(p->VOutput,int)+(Cmd-IF_VIDEO),sizeof(int));
}
if (Cmd >= IF_VIDEOACCEL && Cmd < IF_VIDEOACCEL+ARRAYCOUNT(p->VOutput,int))
{
b = 1;
p->Player->Set(p->Player,PLAYER_VIDEO_ACCEL,&b,sizeof(b));
p->Player->Set(p->Player,PLAYER_VOUTPUTID,ARRAYBEGIN(p->VOutput,int)+(Cmd-IF_VIDEOACCEL),sizeof(int));
}
if (Cmd >= IF_AUDIO && Cmd < IF_AUDIO+ARRAYCOUNT(p->AOutput,int))
{
p->Player->Set(p->Player,PLAYER_AOUTPUTID,ARRAYBEGIN(p->AOutput,int)+(Cmd-IF_AUDIO),sizeof(int));
UpdateVolume(p);
}
if (p->Focus && p->Clipping)
UpdateClipping(p,0,1); // maybe overlapping window is gone
return ERR_INVALID_PARAM;
}
static int PlayerNotify(intface* p,int Id,int Value)
{
if (Id == PLAYER_TITLE)
{
p->TitleTimeWidth = 0;
if (Value)
p->TitleTime = -1;
if (p->WndTitle && !p->FullScreen)
InvalidateRect(p->WndTitle,NULL,1); // redraws timer too!
if (!p->Win.FullScreen && !p->Bench && p->InSeek && p->Capture)
PostMessage(p->Win.Wnd,MSG_PLAYER,PLAYER_PERCENT,Value);
}
else
if (Id == PLAYER_PERCENT)
{
if (!p->Win.FullScreen && !p->Bench && (!p->InSeek || !p->Capture))
PostMessage(p->Win.Wnd,MSG_PLAYER,PLAYER_PERCENT,Value);
}
else
PostMessage(p->Win.Wnd,MSG_PLAYER,Id,Value);
return ERR_NONE;
}
static int ErrorNotify(intface* p,int Param,int Param2)
{
const tchar_t* Msg = (const tchar_t*)Param2;
if (GetCurrentThreadId() != p->ThreadId)
PostMessage(p->Win.Wnd,MSG_ERROR,0,(LPARAM)tcsdup(Msg));
else
ShowError2(p,Msg);
return ERR_NONE;
}
static int KeyRotate(intface* p,int Code)
{
int i;
int Dir;
if (!QueryAdvanced(ADVANCED_KEYFOLLOWDIR))
return Code;
switch (Code)
{
case VK_UP: i=1; break;
case VK_RIGHT: i=2; break;
case VK_DOWN: i=3; break;
case VK_LEFT: i=4; break;
default: return Code;
}
p->Player->Get(p->Player,PLAYER_REL_DIR,&Dir,sizeof(Dir));
if (Dir & DIR_SWAPXY)
i += (Dir & DIR_MIRRORUPDOWN) ? 1:3;
else
i += (Dir & DIR_MIRRORUPDOWN) ? 2:0;
if (i>4) i-=4;
switch (i)
{
case 1: Code = VK_UP; break;
case 2: Code = VK_RIGHT; break;
case 3: Code = VK_DOWN; break;
case 4: Code = VK_LEFT; break;
}
return Code;
}
static void DefaultSkin(intface* p);
static NOINLINE void UpdatePosition(intface* p)
{
UpdateTrackPos(p);
UpdateTitleTime(p);
}
static const int SkinCmd[MAX_SKINITEM] =
{
0,
0,
0,
0,
0,
IF_PLAY,
IF_STOP,
IF_NEXT,
IF_PREV,
IF_OPTIONS_FULLSCREEN,
IF_FASTFORWARD,
IF_FILE_PLAYLIST,
IF_FILE_OPENFILE,
IF_OPTIONS_MUTE,
IF_OPTIONS_REPEAT,
IF_SKIN0,
IF_SKIN1,
IF_OPTIONS_ROTATE,
0,
IF_PLAY_FULLSCREEN,
IF_FILE_EXIT,
};
static bool_t Proc(intface* p, int Msg, uint32_t wParam, uint32_t lParam, int* Result)
{
tick_t t;
bool_t b;
int i,Key;
PAINTSTRUCT Paint;
notify Notify;
switch (Msg)
{
case WM_CANCELMODE:
if (p->InSkin>0)
{
p->InSkin = 0;
ReleaseCapture();
}
if (p->InVol)
{
p->InVol = 0;
ReleaseCapture();
}
if (p->InSeek)
StopSeek(p);
if (IsOverlay(p))
{
//delayed clipping (don't want to turn off overlay, just because a toolbar button was pressed)
SetTimer(p->Win.Wnd,TIMER_CLIPPING2,CLIPPING2_CYCLE,NULL);
break;
}
// no break
#if !defined(TARGET_WINCE)
case WM_INITMENU:
#endif
UpdateClipping(p,1,1); // force clipping mode
break;
case WM_PAINT:
BeginPaint(p->Win.Wnd,&Paint);
if (p->Skin[p->SkinNo].Valid)
SkinDraw(&p->Skin[p->SkinNo],Paint.hdc,&p->SkinArea);
p->Player->Paint(p->Player,Paint.hdc,p->Offset.x,p->Offset.y);
EndPaint(p->Win.Wnd,&Paint);
break;
#if defined(TARGET_WINCE)
case WM_CTLCOLORSTATIC:
*Result = (LRESULT) GetSysColorBrush(COLOR_BTNFACE);
return 1;
#endif
case WM_SYSCHAR:
if (wParam == 13) //Alt+Enter
PostMessage(p->Win.Wnd,WM_COMMAND,IF_OPTIONS_FULLSCREEN,0);
break;
case WM_TIMER:
if (wParam == TIMER_TITLESCROLL)
TitleScroll(p);
if (wParam == TIMER_SLIDERINVOL)
UpdateVol(p);
if (wParam == TIMER_SLIDERINSEEK && !p->Win.FullScreen)
UpdatePosition(p);
if (wParam == TIMER_KEYINSEEK)
StopSeek(p);
if (wParam == TIMER_CLIPPING2 && ShowVideo(p) && !p->Clipping && IsOverlapped(p))
UpdateClipping(p,1,1);
if (wParam == TIMER_CLIPPING && ShowVideo(p) && p->Clipping)
UpdateClipping(p,0,1);
if (wParam == TIMER_INITING)
{
NodeRegSaveValue(0,REG_INITING,NULL,0,TYPE_INT);
KillTimer(p->Win.Wnd,TIMER_INITING);
}
if (wParam == TIMER_SLEEP && (p->Play>0 || p->FFwd>0))
SleepTimerReset();
break;
case WM_INITMENUPOPUP:
UpdateClipping(p,1,1); // force clipping mode
UpdateMenu(p);
break;
case WM_KEYUP:
#if defined(TARGET_WINCE)
if (!GetDisplayPower())
SetDisplayPower(0,1);
#endif
Key = WinKeyState(KeyRotate(p,wParam));
for (i=0;i<HOTKEYCOUNT;++i)
if (p->HotKey[i] && (p->HotKey[i] & ~HOTKEY_KEEP) == Key)
return 0;
if (p->AllKeys)
ForwardMenuButtons(&p->Win,Msg,wParam,lParam);
break;
case WM_KEYDOWN:
Key = WinKeyState(KeyRotate(p,wParam));
for (i=0;i<HOTKEYCOUNT;++i)
if (p->HotKey[i] && (p->HotKey[i] & ~HOTKEY_KEEP) == Key)
{
PostMessage(p->Win.Wnd,WM_COMMAND,HotKey[i],0);
return 0;
}
if (p->AllKeys)
ForwardMenuButtons(&p->Win,Msg,wParam,lParam);
break;
case WM_HOTKEY:
#if defined(TARGET_WINCE)
if ((LOWORD(lParam) & MOD_KEYUP))
{
if (!GetDisplayPower())
SetDisplayPower(0,1);
}
else
#endif
PostMessage(p->Win.Wnd,WM_COMMAND,wParam,0);
*Result = 0;
return 1;
case WM_MOUSEMOVE:
if (p->InSkin>0 && (wParam & MK_LBUTTON))
SkinMouse(&p->Skin[p->SkinNo],p->InSkin,(int16_t)LOWORD(lParam)-p->SkinArea.x,(int16_t)HIWORD(lParam)-p->SkinArea.y,p->Player,NULL,p->Win.Wnd,&p->SkinArea);
return 0;
case WM_LBUTTONUP:
if (p->InSkin>0)
{
int Cmd = 0;
SkinMouse(&p->Skin[p->SkinNo],p->InSkin,(int16_t)LOWORD(lParam)-p->SkinArea.x,(int16_t)HIWORD(lParam)-p->SkinArea.y,p->Player,&Cmd,p->Win.Wnd,&p->SkinArea);
if (p->InSeek)
StopSeek(p);
p->InSkin = 0;
if (p->Capture)
{
ReleaseCapture();
p->Capture = 0;
}
if (Cmd==SKIN_VOLUME)
UpdateVolume(p);
if (Cmd>0 && SkinCmd[Cmd]>0)
Command(p,SkinCmd[Cmd]);
}
*Result = 0;
return 1;
case WM_LBUTTONDBLCLK:
case WM_LBUTTONDOWN:
DEBUG_MSG(DEBUG_WIN,T("LBUTTON"));
if ((wParam & MK_LBUTTON) && p->Focus)
{
tchar_t URL[MAXPATH];
SetDisplayPower(1,0);
if (p->Skin[p->SkinNo].Valid && !p->FullScreen)
p->InSkin = SkinMouse(&p->Skin[p->SkinNo],0,(int16_t)LOWORD(lParam)-p->SkinArea.x,(int16_t)HIWORD(lParam)-p->SkinArea.y,p->Player,NULL,p->Win.Wnd,&p->SkinArea);
else
p->InSkin = -1;
if (p->InSkin>0)
{
SetCapture(p->Win.Wnd);
p->Capture = 1;
if (p->InSkin == SKIN_SEEK)
p->InSeek = 1;
}
else if (p->InSkin<0)
{
if (!p->FullScreen && p->Player->CommentByName(p->Player,-1,T("URL"),URL,TSIZEOF(URL)))
WinShowHTML(URL);
else
if (p->Player->Get(p->Player,PLAYER_SINGLECLICKFULLSCREEN,&b,sizeof(b))==ERR_NONE && !b)
{
if (Msg == WM_LBUTTONDBLCLK)
PostMessage(p->Win.Wnd,WM_COMMAND,IF_OPTIONS_FULLSCREEN,0);
PostMessage(p->Win.Wnd,WM_COMMAND,IF_PLAY,0);
}
else
PostMessage(p->Win.Wnd,WM_COMMAND,IF_PLAY_FULLSCREEN,0);
}
}
SetForegroundWindow(p->Win.Wnd); //sometimes wince suck (triple click in opendialog)
*Result = 0;
return 1;
case WM_MOVE:
Resize(p);
break;
case WM_SETTINGCHANGE:
if (wParam == SETTINGCHANGE_RESET)
{
p->Player->Set(p->Player,PLAYER_RESETVIDEO,NULL,0);
if (p->VolResizeNeeded2)
{
ResizeVolume(p);
if (p->VolResizeNeeded2>1)
ShowVol(p,1);
p->VolResizeNeeded2 = 0;
}
}
break;
case WM_SIZE:
#ifdef MAXIMIZE_FULLSCREEN
if (wParam == SIZE_MAXIMIZED)
{
ShowWindow(p->Win.Wnd,SW_SHOWNORMAL);
ToggleFullScreen(p,1,1);
}
else
#endif
Resize(p);
break;
case WM_SETFOCUS:
if (!p->Focus || !p->WndVolBack || (HWND)wParam != p->WndVolBack)
{
DEBUG_MSG(DEBUG_WIN,T("SETFOCUS"));
p->Focus = 1;
DIASet(0,DIA_SIP);
if (p->Wait)
{
WaitBegin();
UpdateHotKey(p,1,0);
// clipping still needed
}
else
UpdateClipping(p,0,1); // turn off clipping when no overlapping windows
UpdateClippingTimer(p);
UpdateTitleScroll(p);
}
break;
case WM_KILLFOCUS:
if (!p->WndVolBack || (HWND)wParam != p->WndVolBack)
{
DEBUG_MSG(DEBUG_WIN,T("KILLFOCUS"));
p->Focus = 0;
if (!ShowVideo(p))
UpdateClipping(p,1,1); // force clipping mode
if (p->Wait)
WaitEnd();
}
break;
case WM_ACTIVATE:
if (!p->WndVolBack || (HWND)lParam != p->WndVolBack)
{
if (LOWORD(wParam)==WA_INACTIVE)
{
#ifdef NDEBUG
Toggle(p,PLAYER_FOREGROUND,0);
ToggleFullScreen(p,0,0); // example ATI tweaks have problem
#endif
ShowVol(p,0);
if (p->InSeek) StopSeek(p);
SetDisplayPower(1,0);
}
else
{
ShowVol(p,1);
UpdateVolume(p);
Toggle(p,PLAYER_FOREGROUND,1);
if (p->ForceFullScreen)
PostMessage(p->Win.Wnd,MSG_PLAYER,PLAYER_FULLSCREEN,1);
}
}
break;
case WM_DESTROY:
BeforeExit(p);
PostQuitMessage(0);
SkinFree(p->Skin,NULL);
Context()->Error.Func = NULL;
ArrayClear(&p->VOutput);
ArrayClear(&p->AOutput);
break;
case MSG_ERROR:
ShowError2(p,(const tchar_t*)lParam);
free((tchar_t*)lParam);
return 1;
case MSG_PLAYER:
switch (wParam)
{
case PLAYER_EXIT_AT_END:
if (p->CmdLineMode)
PostMessage(p->Win.Wnd,WM_COMMAND,IF_FILE_EXIT,0);
break;
case PLAYER_PERCENT:
UpdatePosition(p);
break;
case PLAYER_LOADMODE:
if (p->Wait != (bool_t)lParam)
{
p->Wait = lParam;
if (p->Wait)
{
if (WaitBegin())
UpdateClipping(p,1,0);
}
else
WaitEnd();
}
break;
case PLAYER_FULLSCREEN:
p->ForceFullScreen = lParam;
if (GetForegroundWindow() == p->Win.Wnd || !lParam)
{
ToggleFullScreen(p,lParam,1);
p->ForceFullScreen = 0;
}
break;
case PLAYER_PLAY:
RefreshButton(p,PLAYER_PLAY,&p->Play,IF_PLAY,0,1);
RefreshButton(p,PLAYER_FFWD,&p->FFwd,IF_FASTFORWARD,4,1);
UpdateSleepTimer(p);
break;
case PLAYER_BENCHMARK:
if (p->Bench && p->Player->Get(p->Player,PLAYER_BENCHMARK,&t,sizeof(tick_t))==ERR_NONE)
{
p->Bench = 0;
ToggleFullScreen(p,0,0);
WaitEnd();
if (p->WndTrack)
SetTrackThumb(p->WndTrack,1);
UpdateWindow(p->Win.Wnd);
WinPopupClass(BENCHRESULT_ID,&p->Win);
}
break;
}
return 1;
case WM_COPYDATA:
ProcessCmdLine(p,(const tchar_t*)((COPYDATASTRUCT*)lParam)->lpData);
return 1;
case MSG_INIT:
SetForegroundWindow(p->Win.Wnd);
if (Context()->CmdLine[0] || NodeRegLoadValue(0,REG_INITING,&i,sizeof(i),TYPE_INT))
{
b = 1; // last time crashed -> discard saved playlist
p->Player->Set(p->Player,PLAYER_DISCARDLIST,&b,sizeof(b));
}
#ifdef NDEBUG
i = 1;
NodeRegSaveValue(0,REG_INITING,&i,sizeof(int),TYPE_INT);
SetTimer(p->Win.Wnd,TIMER_INITING,INITING_CYCLE,NULL);
#endif
Context_Wnd(p->Win.Wnd);
if (Context()->CmdLine[0])
{
p->Player->Get(p->Player,PLAYER_PLAYATOPEN_FULL,&b,sizeof(b));
if (!b)
{
UpdateWindow(p->Win.Wnd); //http connection may take a while
if (p->Win.WndTB)
UpdateWindow(p->Win.WndTB);
}
ProcessCmdLine(p,Context()->CmdLine);
}
if (LangStr(LANG_ID,LANG_DEFAULT)[0]==0 &&
LangStr(LANG_ID,Context()->Lang)[0]==0)
ShowMessage(NULL,T("Language files (*.txt,*.tgz) are missing!"));
return 1;
case WM_CREATE:
WinTitle(&p->Win,Context()->ProgramName);
p->ThreadId = GetCurrentThreadId();
p->Player = (player*)Context()->Player;
p->Color = NodeEnumObject(NULL,COLOR_ID);
p->Equalizer = NodeEnumObject(NULL,EQUALIZER_ID);
p->Focus = 0;
p->Clipping = 0;
Notify.This = p;
Notify.Func = (notifyfunc)PlayerNotify;
if (p->Player)
p->Player->Set(p->Player,PLAYER_NOTIFY,&Notify,sizeof(Notify));
Context()->Error.This = p;
Context()->Error.Func = ErrorNotify;
WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_STREAM,0);
WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_STREAM,0);
WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_STREAM,0);
WinMenuEnable(&p->Win,1,IF_OPTIONS_VIDEO_DEVICE,0);
WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_DEVICE,0);
WinMenuEnable(&p->Win,1,IF_OPTIONS_ORIENTATION_FULLSCREEN,0);
WinMenuEnable(&p->Win,1,IF_OPTIONS_AUDIO_QUALITY,0);
if (!NodeEnumClass(NULL,CORETHEQUE_UI_ID))
WinMenuDelete(&p->Win,0,IF_FILE_CORETHEQUE);
if (IsAutoRun(p,Context()->CmdLine))
DefaultSkin(p);
SkinLoad(p->Skin,p->Win.Wnd,p->SkinPath);
if (!p->Skin[0].Valid)
CreateButtons(p);
UpdateSkin(p,0);
UpdateTrackBar(p,0);
UpdateTitleBar(p,0);
CreateVolumeTrack(p);
CreateDeviceMenu(p);
Resize(p);
// first finish window creation and postpone loading playlist and etc...
PostMessage(p->Win.Wnd,MSG_INIT,0,0);
UpdateHotKey(p,1,0);
break;
}
return 0;
}
static const datatable Params[] =
{
{ IF_TITLEBAR, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
{ IF_TRACKBAR, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
{ IF_TASKBAR, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
{ IF_SKINNO, TYPE_INT, DF_SETUP|DF_HIDDEN },
{ IF_SKINPATH, TYPE_STRING,DF_SETUP|DF_HIDDEN },
#if defined(TARGET_WINCE)
{ IF_ALLKEYS, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
#endif
DATATABLE_END(INTERFACE_ID)
};
static int Enum( intface* p, int* No, datadef* Param )
{
if (NodeEnumTable(No,Param,Params)==ERR_NONE)
return ERR_NONE;
if (*No>=0 && *No<HOTKEYCOUNT)
{
memset(Param,0,sizeof(datadef));
Param->No = HotKey[*No];
Param->Type = TYPE_HOTKEY;
Param->Size = sizeof(int);
Param->Flags = DF_SETUP;
#if defined(TARGET_WINCE)
if (*No==0) Param->Flags |= DF_GAP;
#endif
Param->Class = INTERFACE_ID;
Param->Name = LangStr(INTERFACE_ID,Param->No);
return ERR_NONE;
}
return ERR_INVALID_PARAM;
}
static int Get(intface* p,int No,void* Data,int Size)
{
int Result = ERR_INVALID_PARAM;
int i;
for (i=0;i<HOTKEYCOUNT;++i)
if (HotKey[i]==No)
{
GETVALUE(p->HotKey[i],int);
break;
}
switch (No)
{
case IF_TRACKBAR: GETVALUE(p->TrackBar,bool_t); break;
case IF_TITLEBAR: GETVALUE(p->TitleBar,bool_t); break;
case IF_TASKBAR: GETVALUE(p->TaskBar,bool_t); break;
case IF_SKINNO: GETVALUE(p->SkinNo,int); break;
case IF_SKINPATH: GETSTRING(p->SkinPath); break;
case IF_ALLKEYS: GETVALUE(p->AllKeys,bool_t); break;
}
return Result;
}
static int UpdateSkin(intface* p,bool_t Others)
{
if (!p->Player)
return ERR_NONE;
if (p->SkinNo>0 && !p->Skin[p->SkinNo].Valid)
p->SkinNo=0;
if (Others)
{
if (p->Skin[p->SkinNo].Valid)
SkinUpdate(&p->Skin[p->SkinNo],p->Player,p->Win.Wnd,&p->SkinArea);
ShowVol(p,1);
UpdateTrackBar(p,1);
InvalidateRect(p->Win.Wnd,NULL,0);
p->ClientRect.right = -1;
Resize(p);
}
RefreshButton(p,PLAYER_REPEAT,NULL,0,0,0);
RefreshButton(p,PLAYER_PLAY,NULL,0,0,0);
RefreshButton(p,PLAYER_FFWD,NULL,0,0,0);
RefreshButton(p,PLAYER_MUTE,NULL,0,0,0);
RefreshButton(p,PLAYER_FULLSCREEN,NULL,0,0,0);
if (p->TitleBrush)
{
DeleteObject(p->TitleBrush);
p->TitleBrush = NULL;
}
if (p->Skin[p->SkinNo].Valid)
{
p->TitleBrush = CreateSolidBrush(p->Skin[p->SkinNo].Item[SKIN_TITLE].ColorFace);
p->TitleFace = p->Skin[p->SkinNo].Item[SKIN_TITLE].ColorFace;
p->TitleText = p->Skin[p->SkinNo].Item[SKIN_TITLE].ColorText;
}
else
{
p->TitleBrush = NULL;
p->TitleFace = GetSysColor(COLOR_BTNFACE);
p->TitleText = GetSysColor(COLOR_BTNTEXT);
}
return ERR_NONE;
}
static int UpdateAllKeys(intface* p)
{
if (!p->AllKeys && p->AllKeysWarning)
{
int i;
for (i=0;i<HOTKEYCOUNT;++i)
if (p->HotKey[i] && WinNoHotKey(p->HotKey[i]))
{
ShowMessage(LangStr(p->Win.Node.Class,NODE_NAME),LangStr(INTERFACE_ID,IF_ALLKEYS_WARNING2));
break;
}
}
return ERR_NONE;
}
static void SetHotKey(intface* p,int i,int Key)
{
if (p->Focus && p->HotKey[i] && !p->AllKeys)
WinUnRegisterHotKey(&p->Win,HotKey[i]);
if (!p->AllKeys && p->AllKeysWarning && WinNoHotKey(Key))
ShowMessage(LangStr(p->Win.Node.Class,NODE_NAME),LangStr(INTERFACE_ID,IF_ALLKEYS_WARNING));
p->HotKey[i] = Key;
if (p->Focus && p->HotKey[i] && !p->AllKeys && !WinEssentialKey(p->HotKey[i]))
WinRegisterHotKey(&p->Win,HotKey[i],p->HotKey[i]);
}
static int Set(intface* p,int No,const void* Data,int Size)
{
int Result = ERR_INVALID_PARAM;
int i,j;
for (i=0;i<HOTKEYCOUNT;++i)
if (HotKey[i]==No)
{
int Key = *(int*)Data;
SetHotKey(p,i,0);
if (Key)
{
for (j=0;j<HOTKEYCOUNT;++j)
if ((p->HotKey[j] & ~HOTKEY_KEEP) == (Key & ~HOTKEY_KEEP))
SetHotKey(p,j,0);
SetHotKey(p,i,Key);
}
Result = ERR_NONE;
break;
}
switch (No)
{
case IF_TRACKBAR: SETVALUE(p->TrackBar,bool_t,UpdateTrackBar(p,1)); break;
case IF_TITLEBAR: SETVALUE(p->TitleBar,bool_t,UpdateTitleBar(p,1)); break;
case IF_TASKBAR: SETVALUE(p->TaskBar,bool_t,UpdateTaskBar(p)); break;
case IF_SKINNO: SETVALUE(p->SkinNo,int,UpdateSkin(p,1)); break;
case IF_SKINPATH: SETSTRING(p->SkinPath); Result = UpdateSkinFile(p); break;
case IF_ALLKEYS: SETVALUECMP(p->AllKeys,bool_t,UpdateAllKeys(p),EqBool); break;
}
return Result;
}
static void DefaultSkin(intface* p)
{
tchar_t* s;
GetModuleFileName(GetModuleHandle(NULL),p->SkinPath,MAXPATH);
s = tcsrchr(p->SkinPath,'\\');
if (s) s[1]=0;
tcscat_s(p->SkinPath,TSIZEOF(p->SkinPath),T("skin.xml"));
p->SkinNo = 0;
}
static int Create(intface* p)
{
int Key;
DefaultSkin(p);
p->Win.WinWidth = 360;
p->Win.WinHeight = 240;
p->Win.Proc = Proc;
p->Win.Command = (wincommand)Command;
p->Win.MenuDef = MenuDef;
p->Win.Node.Enum = Enum;
p->Win.Node.Get = Get;
p->Win.Node.Set = Set;
p->Vol = -1;
p->TaskBar = 1;
p->TitleBar = 1;
p->TrackBar = 1;
p->MenuPreAmp = -1;
p->MenuStreams = 0;
p->MenuAStream = -1;
p->MenuVStream = -1;
p->MenuSubStream = -1;
Key = VK_RIGHT;
Set(p,IF_MOVE_FFWD,&Key,sizeof(Key));
Key = VK_LEFT;
Set(p,IF_MOVE_BACK,&Key,sizeof(Key));
Key = VK_UP;
Set(p,IF_OPTIONS_VOLUME_UP,&Key,sizeof(Key));
Key = VK_DOWN;
Set(p,IF_OPTIONS_VOLUME_DOWN,&Key,sizeof(Key));
Key = VK_RETURN;
Set(p,QueryPlatform(PLATFORM_TYPENO) == TYPE_SMARTPHONE?IF_PLAY_FULLSCREEN:IF_PLAY,&Key,sizeof(Key));
Key = 0xB0; //VK_MEDIA_NEXT_TRACK;
Set(p,IF_NEXT2,&Key,sizeof(Key));
Key = 0xB1; //VK_MEDIA_PREV_TRACK;
Set(p,IF_PREV_SMART2,&Key,sizeof(Key));
Key = 0xB2; //VK_MEDIA_STOP;
Set(p,IF_STOP,&Key,sizeof(Key));
Key = 0xB3; //VK_MEDIA_PLAY_PAUSE;
Set(p,IF_PLAYPAUSE,&Key,sizeof(Key));
#if defined(TARGET_WIN32)
Key = VK_SPACE;
Set(p,IF_PLAY,&Key,sizeof(Key));
#endif
return ERR_NONE;
}
static const nodedef IntFace =
{
sizeof(intface)|CF_GLOBAL|CF_SETTINGS,
INTERFACE_ID,
WIN_CLASS,
PRI_MAXIMUM+570,
(nodecreate)Create,
};
static const nodedef Skin =
{
0,
SKIN_CLASS,
NODE_CLASS,
PRI_MAXIMUM,
};
void Interface_Init()
{
NodeRegisterClass(&IntFace);
NodeRegisterClass(&Skin);
}
void Interface_Done()
{
NodeUnRegisterClass(INTERFACE_ID);
NodeUnRegisterClass(SKIN_CLASS);
}
#endif
Reference in New Issue View Git Blame Copy Permalink