mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-09-22 12:21:41 +02:00
264056972d
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1736 8ced0084-cf51-0410-be5f-012b33b47a6e
1143 lines
28 KiB
C++
1143 lines
28 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// Plainamp, Open source Winamp core
|
|
//
|
|
// Copyright © 2005 Sebastian Pipping <webmaster@hartwork.org>
|
|
//
|
|
// --> http://www.hartwork.org
|
|
//
|
|
// This source code is released under the GNU General Public License (GPL).
|
|
// See GPL.txt for details. Any non-GPL usage is strictly forbidden.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
#include "PluginManager.h"
|
|
#include "Plugin.h"
|
|
#include "InputPlugin.h"
|
|
#include "OutputPlugin.h"
|
|
#include "VisPlugin.h"
|
|
#include "DspPlugin.h"
|
|
#include "GenPlugin.h"
|
|
#include "Console.h"
|
|
#include "Main.h"
|
|
#include "Util.h"
|
|
#include "Config.h"
|
|
|
|
|
|
|
|
#define MENU_INPUT_CONFIG 1
|
|
#define MENU_INPUT_ABOUT 2
|
|
|
|
#define MENU_OUTPUT_CONFIG 1
|
|
#define MENU_OUTPUT_ABOUT 2
|
|
#define MENU_OUTPUT_SEP 3
|
|
#define MENU_OUTPUT_ACTIVE 4
|
|
#define MENU_OUTPUT_LOAD 5
|
|
|
|
#define MENU_GEN_CONFIG 1
|
|
#define MENU_GEN_SEP 2
|
|
#define MENU_GEN_LOAD 3
|
|
|
|
|
|
|
|
HWND WindowManager = NULL; // extern
|
|
HWND WindowListView = NULL;
|
|
|
|
|
|
WNDPROC WndprocListViewBackup = NULL;
|
|
LRESULT CALLBACK WndprocListView( HWND hwnd, UINT message, WPARAM wp, LPARAM lp );
|
|
|
|
LRESULT CALLBACK WndprocManager( HWND hwnd, UINT message, WPARAM wp, LPARAM lp );
|
|
|
|
|
|
HMENU input_menu = NULL;
|
|
HMENU output_menu = NULL;
|
|
HMENU gen_menu = NULL;
|
|
|
|
|
|
|
|
bool bManagerGrid;
|
|
ConfBool cbManagerGrid( &bManagerGrid, "ManagerGrid", CONF_MODE_PUBLIC, true );
|
|
|
|
bool bManagerVisible;
|
|
WINDOWPLACEMENT WinPlaceManager;
|
|
|
|
void WinPlaceManagerCallback( ConfVar * var )
|
|
{
|
|
if( !IsWindow( WindowManager ) ) return;
|
|
|
|
GetWindowPlacement( WindowManager, &WinPlaceManager );
|
|
|
|
// MSDN: If the window identified by the hWnd parameter
|
|
// is maximized, the showCmd member is SW_SHOWMAXIMIZED.
|
|
// If the window is minimized, showCmd is SW_SHOWMINIMIZED.
|
|
// Otherwise, it is SW_SHOWNORMAL.
|
|
if( !bManagerVisible )
|
|
{
|
|
WinPlaceManager.showCmd = SW_HIDE;
|
|
}
|
|
}
|
|
|
|
RECT rManagerDefault = { 500, 400, 1000, 700 };
|
|
|
|
ConfWinPlaceCallback cwpcWinPlaceManager(
|
|
&WinPlaceManager,
|
|
TEXT( "WinPlaceManager" ),
|
|
&rManagerDefault,
|
|
WinPlaceManagerCallback
|
|
);
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#define CLASSNAME_PAPMC TEXT( "PLAINAMP_PMC" )
|
|
#define PAPMC_TITLE TEXT( "Plugin Manager" )
|
|
|
|
bool PluginManager::Build()
|
|
{
|
|
LoadCommonControls();
|
|
|
|
// Register class
|
|
WNDCLASS wc = {
|
|
0, // UINT style
|
|
WndprocManager, // WNDPROC lpfnWndProc
|
|
0, // int cbClsExtra
|
|
0, // int cbWndExtra
|
|
g_hInstance, // HINSTANCE hInstance
|
|
NULL, // HICON hIcon
|
|
LoadCursor( NULL, IDC_ARROW ), // HCURSOR hCursor
|
|
( HBRUSH )COLOR_WINDOW, // HBRUSH hbrBackground
|
|
NULL, // LPCTSTR lpszMenuName
|
|
CLASSNAME_PAPMC // LPCTSTR lpszClassName
|
|
};
|
|
|
|
if( !RegisterClass( &wc ) ) return false;
|
|
|
|
WindowManager = CreateWindowEx(
|
|
WS_EX_TOOLWINDOW, // DWORD dwExStyle
|
|
CLASSNAME_PAPMC, // LPCTSTR lpClassName
|
|
PAPMC_TITLE, // LPCTSTR lpWindowName
|
|
WS_OVERLAPPEDWINDOW | // DWORD dwStyle
|
|
WS_CLIPCHILDREN, //
|
|
rManagerDefault.left, // int x
|
|
rManagerDefault.top, // int y
|
|
rManagerDefault.right - rManagerDefault.left, // int nWidth
|
|
rManagerDefault.bottom - rManagerDefault.top, // int nHeight
|
|
NULL, // HWND hWndParent
|
|
NULL, // HMENU hMenu
|
|
g_hInstance, // HINSTANCE hInstance
|
|
NULL // LPVOID lpParam
|
|
);
|
|
|
|
RECT r;
|
|
GetClientRect( WindowManager, &r );
|
|
|
|
WindowListView = CreateWindowEx(
|
|
WS_EX_CLIENTEDGE, // DWORD dwExStyle
|
|
WC_LISTVIEW, // LPCTSTR lpClassName
|
|
NULL, // LPCTSTR lpWindowName
|
|
WS_VSCROLL | // DWORD dwStyle
|
|
LVS_REPORT | //
|
|
LVS_SORTASCENDING | //
|
|
LVS_SINGLESEL | //
|
|
WS_CHILD | //
|
|
WS_VISIBLE, //
|
|
0, // int x
|
|
0, // int y
|
|
r.right - r.left, // int nWidth
|
|
r.bottom - r.top, // int nHeight
|
|
WindowManager, // HWND hWndParent
|
|
NULL, // HMENU hMenu
|
|
g_hInstance, // HINSTANCE hInstance
|
|
NULL // LPVOID lpParam
|
|
);
|
|
|
|
if( !WindowListView ) return false;
|
|
|
|
ListView_SetExtendedListViewStyle(
|
|
WindowListView,
|
|
LVS_EX_FULLROWSELECT |
|
|
( bManagerGrid ? LVS_EX_GRIDLINES : 0 ) |
|
|
LVS_EX_HEADERDRAGDROP
|
|
);
|
|
|
|
// (0) File
|
|
LVCOLUMN lvc = {
|
|
LVCF_TEXT | LVCF_WIDTH | LVCF_FMT, // UINT mask;
|
|
LVCFMT_LEFT, // int fmt;
|
|
100, // int cx;
|
|
TEXT( "File" ), // LPTSTR pszText;
|
|
5, // int cchTextMax;
|
|
0, // int iSubItem;
|
|
0, // int iOrder;
|
|
0 // int iImage;
|
|
};
|
|
ListView_InsertColumn( WindowListView, 0, &lvc );
|
|
|
|
// (1) Status
|
|
lvc.pszText = TEXT( "Status" );
|
|
lvc.cchTextMax = 7;
|
|
ListView_InsertColumn( WindowListView, 1, &lvc );
|
|
|
|
// (2) Name
|
|
lvc.cx = 220;
|
|
lvc.pszText = TEXT( "Name" );
|
|
lvc.cchTextMax = 5;
|
|
ListView_InsertColumn( WindowListView, 2, &lvc );
|
|
|
|
|
|
// (3) Type
|
|
lvc.pszText = TEXT( "Type" );
|
|
lvc.cchTextMax = 5;
|
|
ListView_InsertColumn( WindowListView, 3, &lvc );
|
|
|
|
|
|
bManagerVisible = ( WinPlaceManager.showCmd != SW_HIDE );
|
|
SetWindowPlacement( WindowManager, &WinPlaceManager );
|
|
|
|
|
|
// Exchange window procedure
|
|
WndprocListViewBackup = ( WNDPROC )GetWindowLong( WindowListView, GWL_WNDPROC );
|
|
if( WndprocListViewBackup != NULL )
|
|
{
|
|
SetWindowLong( WindowListView, GWL_WNDPROC, ( LONG )WndprocListView );
|
|
}
|
|
|
|
|
|
// Build context menu
|
|
input_menu = CreatePopupMenu();
|
|
AppendMenu( input_menu, MF_STRING, MENU_INPUT_CONFIG, TEXT( "Config" ) );
|
|
AppendMenu( input_menu, MF_STRING, MENU_INPUT_ABOUT, TEXT( "About" ) );
|
|
|
|
output_menu = CreatePopupMenu();
|
|
AppendMenu( output_menu, MF_STRING, MENU_OUTPUT_CONFIG, TEXT( "Config" ) );
|
|
AppendMenu( output_menu, MF_STRING, MENU_OUTPUT_ABOUT, TEXT( "About" ) );
|
|
AppendMenu( output_menu, MF_SEPARATOR | MF_GRAYED | MF_DISABLED, MENU_OUTPUT_SEP, NULL );
|
|
AppendMenu( output_menu, MF_STRING, MENU_OUTPUT_ACTIVE, TEXT( "Active" ) );
|
|
AppendMenu( output_menu, MF_STRING, MENU_OUTPUT_LOAD, TEXT( " " ) );
|
|
|
|
gen_menu = CreatePopupMenu();
|
|
AppendMenu( gen_menu, MF_STRING, MENU_GEN_CONFIG, TEXT( "Config" ) );
|
|
AppendMenu( gen_menu, MF_SEPARATOR | MF_GRAYED | MF_DISABLED, MENU_GEN_SEP, NULL );
|
|
AppendMenu( gen_menu, MF_STRING, MENU_GEN_LOAD, TEXT( " " ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
bool PluginManager::Fill()
|
|
{
|
|
if( !WindowListView ) return false;
|
|
|
|
LVITEM lvi;
|
|
memset( &lvi, 0, sizeof( LVITEM ) );
|
|
lvi.mask = LVIF_TEXT | LVIF_PARAM;
|
|
|
|
Plugin * plugin;
|
|
int iIndex;
|
|
vector<Plugin *>::iterator iter = plugins.begin();
|
|
while( iter != plugins.end() )
|
|
{
|
|
lvi.mask = LVIF_TEXT | LVIF_PARAM;
|
|
|
|
plugin = *iter;
|
|
lvi.iItem = 0;
|
|
lvi.lParam = ( LPARAM )plugin;
|
|
|
|
// (0) File
|
|
|
|
lvi.iSubItem = 0;
|
|
lvi.pszText = plugin->GetFilename();
|
|
lvi.cchTextMax = plugin->GetFilenameLen() + 1;
|
|
iIndex = ListView_InsertItem( WindowListView, &lvi );
|
|
lvi.iItem = iIndex;
|
|
lvi.mask = LVIF_TEXT;
|
|
|
|
// (1) Status
|
|
lvi.iSubItem = 1;
|
|
if( plugin->IsLoaded() )
|
|
{
|
|
if( plugin->IsActive() )
|
|
{
|
|
lvi.pszText = TEXT( "Active" );
|
|
}
|
|
else
|
|
{
|
|
lvi.pszText = TEXT( "Loaded" );
|
|
}
|
|
lvi.cchTextMax = 7;
|
|
}
|
|
else
|
|
{
|
|
lvi.pszText = TEXT( "Not loaded" );
|
|
lvi.cchTextMax = 11;
|
|
}
|
|
ListView_SetItem( WindowListView, &lvi );
|
|
|
|
// (2) Name
|
|
lvi.iSubItem = 2;
|
|
lvi.pszText = plugin->GetName();
|
|
lvi.cchTextMax = plugin->GetNameLen() + 1;
|
|
ListView_SetItem( WindowListView, &lvi );
|
|
|
|
// (3) Type
|
|
lvi.iSubItem = 3;
|
|
lvi.pszText = plugin->GetTypeString();
|
|
lvi.cchTextMax = plugin->GetTypeStringLen() + 1;
|
|
ListView_SetItem( WindowListView, &lvi );
|
|
|
|
iter++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
bool PluginManager::Destroy()
|
|
{
|
|
if( !WindowListView ) return false;
|
|
|
|
DestroyWindow( WindowManager );
|
|
DestroyMenu( input_menu );
|
|
DestroyMenu( output_menu );
|
|
DestroyMenu( gen_menu );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
bool PluginManager::Popup()
|
|
{
|
|
if( !WindowListView ) return false;
|
|
if( !IsWindowVisible( WindowManager ) )
|
|
ShowWindow( WindowManager, SW_SHOW );
|
|
|
|
SetActiveWindow( WindowManager );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
void UpdatePluginStatus( Plugin * plugin, bool bLoaded, bool bActive )
|
|
{
|
|
LVFINDINFO lvfi = {
|
|
LVFI_PARAM, // UINT flags
|
|
NULL, // LPCTSTR psz
|
|
( LPARAM )plugin, // LPARAM lParam
|
|
POINT(), // POINT pt
|
|
0 // UINT vkDirection
|
|
};
|
|
|
|
int iIndex = ListView_FindItem( WindowListView, -1, &lvfi );
|
|
if( iIndex != -1 )
|
|
{
|
|
LVITEM lvi;
|
|
memset( &lvi, 0, sizeof( LVITEM ) );
|
|
lvi.mask = LVIF_TEXT;
|
|
lvi.iItem = iIndex;
|
|
lvi.iSubItem = 1;
|
|
if( bLoaded )
|
|
{
|
|
if( bActive )
|
|
{
|
|
lvi.pszText = TEXT( "Active" );
|
|
}
|
|
else
|
|
{
|
|
lvi.pszText = TEXT( "Loaded" );
|
|
}
|
|
lvi.cchTextMax = 7;
|
|
}
|
|
else
|
|
{
|
|
lvi.pszText = TEXT( "Not loaded" );
|
|
lvi.cchTextMax = 11;
|
|
}
|
|
ListView_SetItem( WindowListView, &lvi );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
void ContextMenuInput( InputPlugin * input, POINT * p )
|
|
{
|
|
BOOL iIndex = TrackPopupMenu(
|
|
input_menu,
|
|
TPM_LEFTALIGN |
|
|
TPM_TOPALIGN |
|
|
TPM_NONOTIFY |
|
|
TPM_RETURNCMD |
|
|
TPM_RIGHTBUTTON,
|
|
p->x,
|
|
p->y,
|
|
0,
|
|
WindowManager,
|
|
NULL
|
|
);
|
|
|
|
switch( iIndex )
|
|
{
|
|
case MENU_INPUT_ABOUT:
|
|
input->About( WindowManager );
|
|
break;
|
|
|
|
case MENU_INPUT_CONFIG:
|
|
input->Config( WindowManager );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
void ContextMenuOutput( OutputPlugin * output, POINT * p )
|
|
{
|
|
const bool bLoaded = output->IsLoaded();
|
|
const bool bActive = output->IsActive();
|
|
|
|
EnableMenuItem(
|
|
output_menu,
|
|
MENU_OUTPUT_CONFIG,
|
|
bLoaded ? MF_ENABLED : MF_GRAYED | MF_DISABLED
|
|
);
|
|
EnableMenuItem(
|
|
output_menu,
|
|
MENU_OUTPUT_ABOUT,
|
|
bLoaded ? MF_ENABLED : MF_GRAYED | MF_DISABLED
|
|
);
|
|
EnableMenuItem(
|
|
output_menu,
|
|
MENU_OUTPUT_ACTIVE,
|
|
bLoaded ? MF_ENABLED : MF_GRAYED | MF_DISABLED
|
|
);
|
|
CheckMenuItem(
|
|
output_menu,
|
|
MENU_OUTPUT_ACTIVE,
|
|
bActive ? MF_CHECKED : MF_UNCHECKED
|
|
);
|
|
|
|
|
|
MENUITEMINFO mii = { 0 };
|
|
mii.cbSize = sizeof( MENUITEMINFO );
|
|
mii.fMask = MIIM_STATE | MIIM_STRING;
|
|
mii.fState = bActive ? MFS_GRAYED | MFS_DISABLED : MFS_ENABLED;
|
|
mii.dwTypeData = ( LPTSTR )( bLoaded ? TEXT( "Unload" ) : TEXT( "Load" ) );
|
|
mii.cch = bLoaded ? 7 : 5;
|
|
|
|
SetMenuItemInfo(
|
|
output_menu, // HMENU hMenu
|
|
MENU_OUTPUT_LOAD, // UINT uItem
|
|
FALSE, // BOOL fByPosition,
|
|
&mii // LPMENUITEMINFO lpmii
|
|
);
|
|
|
|
|
|
BOOL iIndex = TrackPopupMenu(
|
|
output_menu,
|
|
TPM_LEFTALIGN |
|
|
TPM_TOPALIGN |
|
|
TPM_NONOTIFY |
|
|
TPM_RETURNCMD |
|
|
TPM_RIGHTBUTTON,
|
|
p->x,
|
|
p->y,
|
|
0,
|
|
WindowManager,
|
|
NULL
|
|
);
|
|
|
|
switch( iIndex )
|
|
{
|
|
case MENU_OUTPUT_CONFIG:
|
|
output->Config( WindowManager );
|
|
break;
|
|
|
|
case MENU_OUTPUT_ABOUT:
|
|
output->About( WindowManager );
|
|
break;
|
|
|
|
case MENU_OUTPUT_ACTIVE:
|
|
{
|
|
if( Playback::IsPlaying() )
|
|
{
|
|
MessageBox( WindowManager, TEXT( "Cannot do this while playing!" ), TEXT( "Error" ), MB_ICONERROR );
|
|
break;
|
|
}
|
|
|
|
if( bActive )
|
|
output->Stop();
|
|
else
|
|
output->Start();
|
|
|
|
const bool bActiveNew = output->IsActive();
|
|
if( bActiveNew != bActive )
|
|
{
|
|
UpdatePluginStatus( output, bLoaded, bActiveNew );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case MENU_OUTPUT_LOAD:
|
|
{
|
|
if( bLoaded )
|
|
output->Unload();
|
|
else
|
|
output->Load();
|
|
|
|
const bool bLoadedNew = output->IsLoaded();
|
|
if( bLoadedNew != bLoaded )
|
|
{
|
|
UpdatePluginStatus( output, bLoadedNew, bActive );
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
void ContextMenuVis( VisPlugin * vis, POINT * p )
|
|
{
|
|
HMENU vis_menu = CreatePopupMenu();
|
|
|
|
const bool bLoaded = vis->IsLoaded();
|
|
const bool bPluginActive = vis->IsActive();
|
|
|
|
VisModule * mod;
|
|
HMENU * menus = NULL;
|
|
|
|
const int iModCount = ( int )vis->modules.size();
|
|
if( iModCount == 1 )
|
|
{
|
|
// Single module
|
|
mod = vis->modules[ 0 ];
|
|
const UINT uFlagsActive = MF_STRING |
|
|
( mod->IsActive() ? MF_CHECKED : MF_UNCHECKED ) |
|
|
( bLoaded ? MF_ENABLED : MF_DISABLED | MF_GRAYED );
|
|
const UINT uFlagsConfig = MF_STRING |
|
|
( bLoaded ? MF_ENABLED : MF_DISABLED | MF_GRAYED );
|
|
AppendMenu( vis_menu, uFlagsActive, 1, TEXT( "Active" ) );
|
|
AppendMenu( vis_menu, uFlagsConfig, 2, TEXT( "Config" ) );
|
|
}
|
|
else
|
|
{
|
|
// Two or more
|
|
menus = new HMENU[ iModCount ];
|
|
int iIndex = 0;
|
|
vector <VisModule *>::iterator iter = vis->modules.begin();
|
|
while( iter != vis->modules.end() )
|
|
{
|
|
mod = *iter;
|
|
|
|
menus[ iIndex ] = CreatePopupMenu();
|
|
UINT uFlags = MF_STRING | ( mod->IsActive() ? MF_CHECKED : MF_UNCHECKED );
|
|
AppendMenu( menus[ iIndex ], uFlags, iIndex * 2 + 1, TEXT( "Active" ) );
|
|
AppendMenu( menus[ iIndex ], MF_STRING, iIndex * 2 + 2, TEXT( "Config" ) );
|
|
|
|
uFlags = MF_STRING | MF_POPUP | ( ( !bLoaded || ( bPluginActive && !mod->IsActive() ) ) ? MF_GRAYED | MF_DISABLED : 0 );
|
|
AppendMenu( vis_menu, uFlags, ( UINT_PTR )menus[ iIndex ], mod->GetName() );
|
|
|
|
iIndex++;
|
|
iter++;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
const int iPos = ( int )vis->modules.size() * 2 + 1;
|
|
AppendMenu( vis_menu, MF_SEPARATOR | MF_GRAYED | MF_DISABLED, iPos, NULL );
|
|
|
|
AppendMenu(
|
|
vis_menu,
|
|
MF_STRING | ( bPluginActive ? MF_DISABLED | MF_GRAYED : MF_ENABLED ),
|
|
iPos + 1,
|
|
bLoaded ? TEXT( "Unload" ) : TEXT( "Load" )
|
|
);
|
|
|
|
|
|
BOOL iIndex = TrackPopupMenu(
|
|
vis_menu, // HMENU hMenu
|
|
TPM_LEFTALIGN | // UINT uFlags
|
|
TPM_TOPALIGN | // .
|
|
TPM_NONOTIFY | // .
|
|
TPM_RETURNCMD | // .
|
|
TPM_RIGHTBUTTON, // .
|
|
p->x, // int x
|
|
p->y, // int y
|
|
0, // int nReserved
|
|
WindowManager, // HWND hWnd
|
|
NULL // HWND prcRect
|
|
);
|
|
|
|
if( iIndex )
|
|
{
|
|
if( iIndex >= iPos )
|
|
{
|
|
// Load/unload
|
|
if( bLoaded )
|
|
vis->Unload();
|
|
else
|
|
vis->Load();
|
|
|
|
const bool bLoadedNew = vis->IsLoaded();
|
|
|
|
if( bLoadedNew != bLoaded )
|
|
UpdatePluginStatus( vis, bLoadedNew, FALSE );
|
|
}
|
|
else
|
|
{
|
|
int iWhich = ( iIndex - 1 ) / 2;
|
|
if( iIndex & 1 )
|
|
{
|
|
// Active
|
|
const bool bPluginActive = vis->IsActive();
|
|
|
|
if( !vis->modules[ iWhich ]->IsActive() )
|
|
vis->modules[ iWhich ]->Start();
|
|
else
|
|
vis->modules[ iWhich ]->Stop();
|
|
|
|
const bool bPluginActiveNew = vis->IsActive();
|
|
|
|
if( bPluginActiveNew && ( bPluginActiveNew != bPluginActive ) )
|
|
UpdatePluginStatus( vis, TRUE, bPluginActiveNew );
|
|
}
|
|
else
|
|
{
|
|
// Config
|
|
vis->modules[ iWhich ]->Config();
|
|
}
|
|
}
|
|
}
|
|
|
|
DestroyMenu( vis_menu );
|
|
if( iModCount > 1 )
|
|
{
|
|
for( int i = 0; i < iModCount; i++ )
|
|
DestroyMenu( menus[ i ] );
|
|
delete [] menus;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
void ContextMenuDsp( DspPlugin * dsp, POINT * p )
|
|
{
|
|
HMENU context_menu = CreatePopupMenu();
|
|
|
|
const bool bLoaded = dsp->IsLoaded();
|
|
const bool bPluginActive = dsp->IsActive();
|
|
|
|
DspModule * mod;
|
|
|
|
HMENU * menus = NULL;
|
|
|
|
HMENU * add_rem_menus = NULL;
|
|
|
|
const int iEach = ( 3 * active_dsp_count + 2 );
|
|
|
|
const int iModCount = ( int )dsp->modules.size();
|
|
if( iModCount == 1 )
|
|
{
|
|
// Single module
|
|
mod = dsp->modules[ 0 ];
|
|
|
|
add_rem_menus = new HMENU[ 2 ];
|
|
add_rem_menus[ 0 ] = CreatePopupMenu();
|
|
add_rem_menus[ 1 ] = CreatePopupMenu();
|
|
|
|
int i;
|
|
TCHAR szHere[ 12 ];
|
|
for( i = 0; i < active_dsp_count; i++ )
|
|
{
|
|
TCHAR * szName = active_dsp_mods[ i ]->GetName();
|
|
|
|
// Entry for "Add"
|
|
_stprintf( szHere, TEXT( "Here (%i)" ), i + 1 );
|
|
AppendMenu(
|
|
add_rem_menus[ 0 ],
|
|
MF_STRING,
|
|
2 * i + 1,
|
|
szHere
|
|
);
|
|
AppendMenu(
|
|
add_rem_menus[ 0 ],
|
|
MF_STRING | MF_DISABLED | MF_GRAYED,
|
|
2 * i + 2,
|
|
szName
|
|
);
|
|
|
|
// Entry for "Remove"
|
|
AppendMenu(
|
|
add_rem_menus[ 1 ],
|
|
MF_STRING,
|
|
2 * active_dsp_count + 2 + i,
|
|
szName
|
|
);
|
|
}
|
|
_stprintf( szHere, TEXT( "Here (%i)" ), i + 1 );
|
|
AppendMenu(
|
|
add_rem_menus[ 0 ],
|
|
MF_STRING,
|
|
2 * i + 1,
|
|
szHere
|
|
);
|
|
|
|
|
|
// Main entries
|
|
const UINT uFlagsAdd = MF_STRING | MF_POPUP |
|
|
( ( bLoaded && !mod->IsActive() ) ? 0 : MF_DISABLED | MF_GRAYED );
|
|
const UINT uFlagsRemove = MF_STRING | MF_POPUP |
|
|
( ( bLoaded && active_dsp_count ) ? 0 : MF_GRAYED | MF_DISABLED );
|
|
const UINT uFlagsConfig = MF_STRING |
|
|
( ( bLoaded && mod->IsActive() ) ? 0 : MF_DISABLED | MF_GRAYED );
|
|
|
|
AppendMenu(
|
|
context_menu,
|
|
uFlagsAdd,
|
|
( UINT_PTR )add_rem_menus[ 0 ],
|
|
TEXT( "Add" )
|
|
);
|
|
AppendMenu(
|
|
context_menu,
|
|
uFlagsRemove,
|
|
( UINT_PTR )add_rem_menus[ 1 ],
|
|
TEXT( "Remove" )
|
|
);
|
|
AppendMenu(
|
|
context_menu,
|
|
uFlagsConfig,
|
|
3 * active_dsp_count + 1 + 1,
|
|
TEXT( "Config" )
|
|
);
|
|
}
|
|
else
|
|
{
|
|
// Two or more
|
|
menus = new HMENU[ iModCount ];
|
|
add_rem_menus = new HMENU[ 2 * iModCount ];
|
|
|
|
int iIndex = 0;
|
|
vector <DspModule *>::iterator iter = dsp->modules.begin();
|
|
while( iter != dsp->modules.end() )
|
|
{
|
|
mod = *iter;
|
|
|
|
menus[ iIndex ] = CreatePopupMenu();
|
|
|
|
add_rem_menus[ 2 * iIndex ] = CreatePopupMenu();
|
|
add_rem_menus[ 2 * iIndex + 1 ] = CreatePopupMenu();
|
|
|
|
int i;
|
|
TCHAR szHere[ 12 ];
|
|
for( i = 0; i < active_dsp_count; i++ )
|
|
{
|
|
TCHAR * szName = active_dsp_mods[ i ]->GetName();
|
|
|
|
// Entry for "Add"
|
|
_stprintf( szHere, TEXT( "Here (%i)" ), i + 1 );
|
|
AppendMenu(
|
|
add_rem_menus[ 2 * iIndex ],
|
|
MF_STRING,
|
|
( iIndex * iEach ) + ( 2 * i + 1 ),
|
|
szHere
|
|
);
|
|
AppendMenu(
|
|
add_rem_menus[ 2 * iIndex ],
|
|
MF_STRING | MF_DISABLED | MF_GRAYED,
|
|
( iIndex * iEach ) + ( 2 * i + 2 ),
|
|
szName
|
|
);
|
|
|
|
// Entry for "Remove"
|
|
AppendMenu(
|
|
add_rem_menus[ 2 * iIndex + 1 ],
|
|
MF_STRING,
|
|
( iIndex * iEach ) + ( 2 * active_dsp_count + 2 + i ),
|
|
szName
|
|
);
|
|
}
|
|
_stprintf( szHere, TEXT( "Here (%i)" ), i + 1 );
|
|
AppendMenu(
|
|
add_rem_menus[ 2 * iIndex ],
|
|
MF_STRING,
|
|
( iIndex * iEach ) + ( 2 * i + 1 ),
|
|
szHere
|
|
);
|
|
|
|
AppendMenu(
|
|
menus[ iIndex ],
|
|
MF_STRING | MF_POPUP | ( mod->IsActive() ? MF_DISABLED | MF_GRAYED : 0 ),
|
|
( UINT_PTR )add_rem_menus[ 2 * iIndex ],
|
|
TEXT( "Add" )
|
|
);
|
|
AppendMenu(
|
|
menus[ iIndex ],
|
|
MF_STRING | MF_POPUP | ( active_dsp_count ? 0 : MF_GRAYED | MF_DISABLED ),
|
|
( UINT_PTR )add_rem_menus[ 2 * iIndex + 1 ],
|
|
TEXT( "Remove" )
|
|
);
|
|
AppendMenu(
|
|
menus[ iIndex ],
|
|
MF_STRING | ( mod->IsActive() ? 0 : MF_DISABLED | MF_GRAYED ),
|
|
( iIndex * iEach ) + ( 3 * active_dsp_count + 1 + 1 ),
|
|
TEXT( "Config" )
|
|
);
|
|
AppendMenu( context_menu, MF_STRING | MF_POPUP | ( bLoaded ? 0 : ( MF_DISABLED | MF_GRAYED ) ), ( UINT_PTR )menus[ iIndex ], mod->GetName() );
|
|
|
|
iIndex++;
|
|
iter++;
|
|
}
|
|
}
|
|
|
|
|
|
const int iPos = ( int )dsp->modules.size() * ( 3 * active_dsp_count + 1 + 1 ) + 1;
|
|
AppendMenu( context_menu, MF_SEPARATOR | MF_GRAYED | MF_DISABLED, iPos, NULL );
|
|
|
|
UINT uFlags = MF_STRING;
|
|
|
|
AppendMenu(
|
|
context_menu,
|
|
uFlags | ( bPluginActive ? MF_DISABLED | MF_GRAYED : MF_ENABLED ),
|
|
iPos + 1,
|
|
bLoaded ? TEXT( "Unload" ) : TEXT( "Load" )
|
|
);
|
|
|
|
|
|
BOOL iIndex = TrackPopupMenu(
|
|
context_menu, // HMENU hMenu
|
|
TPM_LEFTALIGN | // UINT uFlags
|
|
TPM_TOPALIGN | // .
|
|
TPM_NONOTIFY | // .
|
|
TPM_RETURNCMD | // .
|
|
TPM_RIGHTBUTTON, // .
|
|
p->x, // int x
|
|
p->y, // int y
|
|
0, // int nReserved
|
|
WindowManager, // HWND hWnd
|
|
NULL // HWND prcRect
|
|
);
|
|
|
|
/*
|
|
|
|
Example menu
|
|
|
|
Mod1
|
|
Add
|
|
Here [ 1]
|
|
Active1 [ 2]
|
|
Here [ 3]
|
|
Active2 [ 4]
|
|
Here [ 5]
|
|
Remove
|
|
Active1 [ 6]
|
|
Active2 [ 7]
|
|
Config [ 8]
|
|
Mod2
|
|
Add
|
|
Here [ 9]
|
|
Active1 [10]
|
|
...
|
|
---
|
|
Load/Unload [11]
|
|
|
|
*/
|
|
|
|
|
|
if( iIndex )
|
|
{
|
|
if( iIndex >= iPos )
|
|
{
|
|
// Load/unload
|
|
if( bLoaded )
|
|
dsp->Unload();
|
|
else
|
|
dsp->Load();
|
|
|
|
const bool bLoadedNew = dsp->IsLoaded();
|
|
|
|
if( bLoadedNew != bLoaded )
|
|
UpdatePluginStatus( dsp, bLoadedNew, FALSE );
|
|
}
|
|
else
|
|
{
|
|
int iWhichMod = ( iIndex - 1 ) / iEach;
|
|
int iRem = iIndex % iEach;
|
|
if( iRem == 0 )
|
|
{
|
|
// Config
|
|
dsp->modules[ iWhichMod ]->Config();
|
|
|
|
}
|
|
else if( iRem < 2 * active_dsp_count + 2 )
|
|
{
|
|
// Add module
|
|
const bool bPluginActive = dsp->IsActive();
|
|
|
|
dsp->modules[ iWhichMod ]->Start( iRem / 2 );
|
|
|
|
const bool bPluginActiveNew = dsp->IsActive();
|
|
if( bPluginActiveNew != bPluginActive )
|
|
{
|
|
UpdatePluginStatus( dsp, TRUE, bPluginActiveNew );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Remove module
|
|
const bool bPluginActive = dsp->IsActive();
|
|
|
|
iWhichMod = iRem - ( 2 * active_dsp_count + 2 );
|
|
/*
|
|
TCHAR szBuffer[ 5000 ];
|
|
_stprintf( szBuffer, TEXT( "REM <%i> <%i>" ), iIndex, iWhichMod );
|
|
Console::Append( szBuffer );
|
|
*/
|
|
active_dsp_mods[ iWhichMod ]->Stop();
|
|
|
|
const bool bPluginActiveNew = dsp->IsActive();
|
|
if( bPluginActiveNew != bPluginActive )
|
|
{
|
|
UpdatePluginStatus( dsp, TRUE, bPluginActiveNew );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DestroyMenu( context_menu );
|
|
if( iModCount > 1 )
|
|
{
|
|
for( int i = 0; i < iModCount; i++ )
|
|
DestroyMenu( menus[ i ] );
|
|
delete [] menus;
|
|
}
|
|
|
|
for( int j = 0; j < iModCount; j++ )
|
|
DestroyMenu( add_rem_menus[ j ] );
|
|
delete [] add_rem_menus;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
void ContextMenuGen( GenPlugin * gen, POINT * p )
|
|
{
|
|
const bool bLoaded = gen->IsLoaded();
|
|
|
|
EnableMenuItem(
|
|
gen_menu,
|
|
MENU_GEN_CONFIG,
|
|
bLoaded ? MF_ENABLED : MF_GRAYED | MF_DISABLED
|
|
);
|
|
|
|
|
|
MENUITEMINFO mii = { 0 };
|
|
mii.cbSize = sizeof( MENUITEMINFO );
|
|
mii.fMask = MIIM_STATE | MIIM_STRING;
|
|
mii.fState = gen->AllowRuntimeUnload() ? MFS_ENABLED : MFS_GRAYED | MFS_DISABLED;
|
|
mii.dwTypeData = ( LPTSTR )( bLoaded ? TEXT( "Unload" ) : TEXT( "Load and activate" ) );
|
|
mii.cch = bLoaded ? 7 : 18;
|
|
|
|
SetMenuItemInfo(
|
|
gen_menu, // HMENU hMenu
|
|
MENU_GEN_LOAD, // UINT uItem
|
|
FALSE, // BOOL fByPosition,
|
|
&mii // LPMENUITEMINFO lpmii
|
|
);
|
|
|
|
|
|
BOOL iIndex = TrackPopupMenu(
|
|
gen_menu,
|
|
TPM_LEFTALIGN |
|
|
TPM_TOPALIGN |
|
|
TPM_NONOTIFY |
|
|
TPM_RETURNCMD |
|
|
TPM_RIGHTBUTTON,
|
|
p->x,
|
|
p->y,
|
|
0,
|
|
WindowManager,
|
|
NULL
|
|
);
|
|
|
|
switch( iIndex )
|
|
{
|
|
case MENU_GEN_CONFIG:
|
|
gen->Config();
|
|
break;
|
|
|
|
case MENU_GEN_LOAD:
|
|
{
|
|
if( bLoaded )
|
|
gen->Unload();
|
|
else
|
|
gen->Load();
|
|
|
|
const bool bLoadedNew = gen->IsLoaded();
|
|
if( bLoadedNew != bLoaded )
|
|
{
|
|
UpdatePluginStatus( gen, bLoadedNew, bLoadedNew );
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
void ContextMenu( Plugin * plugin, POINT * p )
|
|
{
|
|
if( !plugin ) return;
|
|
|
|
switch( plugin->GetType() )
|
|
{
|
|
case PLUGIN_TYPE_INPUT:
|
|
ContextMenuInput( ( InputPlugin * )plugin, p );
|
|
break;
|
|
|
|
case PLUGIN_TYPE_OUTPUT:
|
|
ContextMenuOutput( ( OutputPlugin * )plugin, p );
|
|
break;
|
|
|
|
case PLUGIN_TYPE_VIS:
|
|
ContextMenuVis( ( VisPlugin * )plugin, p );
|
|
break;
|
|
|
|
case PLUGIN_TYPE_DSP:
|
|
ContextMenuDsp( ( DspPlugin * )plugin, p );
|
|
break;
|
|
|
|
case PLUGIN_TYPE_GEN:
|
|
ContextMenuGen( ( GenPlugin * )plugin, p );
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
LRESULT CALLBACK WndprocListView( HWND hwnd, UINT message, WPARAM wp, LPARAM lp )
|
|
{
|
|
static bool bContextOpen = false;
|
|
|
|
switch( message )
|
|
{
|
|
case WM_CONTEXTMENU:
|
|
{
|
|
if( ( HWND )wp != WindowListView ) break;
|
|
if( bContextOpen ) break;
|
|
bContextOpen = true;
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
POINT p = { LOWORD( lp ), HIWORD( lp ) };
|
|
ScreenToClient( WindowListView, &p );
|
|
|
|
// Which item?
|
|
LVHITTESTINFO hti;
|
|
memset( &hti, 0, sizeof( LVHITTESTINFO ) );
|
|
hti.pt = p;
|
|
ListView_HitTest( WindowListView, &hti );
|
|
|
|
// Which plugin?
|
|
LVITEM lvi;
|
|
memset( &lvi, 0, sizeof( LVITEM ) );
|
|
lvi.mask = LVIF_PARAM;
|
|
lvi.iItem = hti.iItem;
|
|
lvi.iSubItem = 0;
|
|
|
|
if( !ListView_GetItem( WindowListView, &lvi ) )
|
|
{
|
|
bContextOpen = false;
|
|
break;
|
|
}
|
|
Plugin * plugin = ( Plugin * )lvi.lParam;
|
|
|
|
// Context menu
|
|
p.x = LOWORD( lp );
|
|
p.y = HIWORD( lp );
|
|
ContextMenu( plugin, &p );
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
bContextOpen = false;
|
|
break;
|
|
}
|
|
}
|
|
return CallWindowProc( WndprocListViewBackup, hwnd, message, wp, lp );
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
///
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
LRESULT CALLBACK WndprocManager( HWND hwnd, UINT message, WPARAM wp, LPARAM lp )
|
|
{
|
|
switch( message )
|
|
{
|
|
case WM_SIZE:
|
|
{
|
|
// Resize children
|
|
RECT client;
|
|
GetClientRect( WindowManager, &client );
|
|
|
|
if( WindowListView )
|
|
MoveWindow( WindowListView, 0, 0, client.right - client.left, client.bottom - client.top, TRUE );
|
|
break;
|
|
}
|
|
|
|
case WM_SYSCOMMAND:
|
|
if( ( wp & 0xFFF0 ) == SC_CLOSE )
|
|
{
|
|
ShowWindow( hwnd, SW_HIDE );
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
cwpcWinPlaceManager.TriggerCallback();
|
|
cwpcWinPlaceManager.RemoveCallback();
|
|
break;
|
|
|
|
case WM_SHOWWINDOW:
|
|
bManagerVisible = ( wp == TRUE );
|
|
break;
|
|
}
|
|
return DefWindowProc( hwnd, message, wp, lp );
|
|
}
|